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 /* Load sys/types.h if not already loaded.
36 In some systems loading it twice is suicidal. */
38 #include <sys/types.h>
41 #include <sys/ioctl.h>
48 /* Caused redefinition of DBL_DIG on Netbsd; seems not to be needed. */
49 /* #include <sys/param.h> */
52 #include "character.h"
55 #include "dispextern.h"
57 #include "termhooks.h"
60 #include "emacs-icon.h"
65 #include "intervals.h"
70 #include "xsettings.h"
72 #include "sysselect.h"
75 #include <X11/Shell.h>
83 #include <X11/Xproto.h>
87 #if defined (USE_LUCID) || defined (USE_MOTIF)
88 #include "../lwlib/xlwmenu.h"
92 #if !defined (NO_EDITRES)
94 extern void _XEditResCheckMessages (Widget
, XtPointer
, XEvent
*, Boolean
*);
95 #endif /* not NO_EDITRES */
97 /* Include toolkit specific headers for the scroll bar widget. */
99 #ifdef USE_TOOLKIT_SCROLL_BARS
100 #if defined USE_MOTIF
101 #include <Xm/Xm.h> /* For LESSTIF_VERSION */
102 #include <Xm/ScrollBar.h>
103 #else /* !USE_MOTIF i.e. use Xaw */
106 #include <X11/Xaw3d/Simple.h>
107 #include <X11/Xaw3d/Scrollbar.h>
108 #include <X11/Xaw3d/ThreeD.h>
109 #else /* !HAVE_XAW3D */
110 #include <X11/Xaw/Simple.h>
111 #include <X11/Xaw/Scrollbar.h>
112 #endif /* !HAVE_XAW3D */
114 #define XtNpickTop "pickTop"
115 #endif /* !XtNpickTop */
116 #endif /* !USE_MOTIF */
117 #endif /* USE_TOOLKIT_SCROLL_BARS */
119 #endif /* USE_X_TOOLKIT */
123 #ifndef XtNinitialState
124 #define XtNinitialState "initialState"
128 #include "bitmaps/gray.xbm"
131 #include <X11/XKBlib.h>
134 /* Default to using XIM if available. */
138 bool use_xim
= false; /* configure --without-xim */
141 /* Non-zero means that a HELP_EVENT has been generated since Emacs
144 static bool any_help_event_p
;
146 /* This is a chain of structures for all the X displays currently in
149 struct x_display_info
*x_display_list
;
153 /* The application context for Xt use. */
154 XtAppContext Xt_app_con
;
155 static String Xt_default_resources
[] = {0};
157 /* Non-zero means user is interacting with a toolkit scroll bar. */
158 static bool toolkit_scroll_bar_interaction
;
160 #endif /* USE_X_TOOLKIT */
162 /* Non-zero timeout value means ignore next mouse click if it arrives
163 before that timeout elapses (i.e. as part of the same sequence of
164 events resulting from clicking on a frame to select it). */
166 static Time ignore_next_mouse_click_timeout
;
168 /* Used locally within XTread_socket. */
170 static int x_noop_count
;
172 static Lisp_Object Qalt
, Qhyper
, Qmeta
, Qsuper
, Qmodifier_value
;
174 static Lisp_Object Qvendor_specific_keysyms
;
175 static Lisp_Object Qlatin_1
;
178 /* The name of the Emacs icon file. */
179 static Lisp_Object xg_default_icon_file
;
181 /* Used in gtkutil.c. */
182 Lisp_Object Qx_gtk_map_stock
;
185 /* Some functions take this as char *, not const char *. */
186 static char emacs_class
[] = EMACS_CLASS
;
190 XEMBED_MAPPED
= 1 << 0
195 XEMBED_EMBEDDED_NOTIFY
= 0,
196 XEMBED_WINDOW_ACTIVATE
= 1,
197 XEMBED_WINDOW_DEACTIVATE
= 2,
198 XEMBED_REQUEST_FOCUS
= 3,
200 XEMBED_FOCUS_OUT
= 5,
201 XEMBED_FOCUS_NEXT
= 6,
202 XEMBED_FOCUS_PREV
= 7,
204 XEMBED_MODALITY_ON
= 10,
205 XEMBED_MODALITY_OFF
= 11,
206 XEMBED_REGISTER_ACCELERATOR
= 12,
207 XEMBED_UNREGISTER_ACCELERATOR
= 13,
208 XEMBED_ACTIVATE_ACCELERATOR
= 14
211 static bool x_alloc_nearest_color_1 (Display
*, Colormap
, XColor
*);
212 static void x_set_window_size_1 (struct frame
*, int, int, int, bool);
213 static void x_raise_frame (struct frame
*);
214 static void x_lower_frame (struct frame
*);
215 static const XColor
*x_color_cells (Display
*, int *);
216 static int x_io_error_quitter (Display
*);
217 static struct terminal
*x_create_terminal (struct x_display_info
*);
218 void x_delete_terminal (struct terminal
*);
219 static void x_update_end (struct frame
*);
220 static void XTframe_up_to_date (struct frame
*);
221 static void x_clear_frame (struct frame
*);
222 static _Noreturn
void x_ins_del_lines (struct frame
*, int, int);
223 static void frame_highlight (struct frame
*);
224 static void frame_unhighlight (struct frame
*);
225 static void x_new_focus_frame (struct x_display_info
*, struct frame
*);
226 static void x_focus_changed (int, int, struct x_display_info
*,
227 struct frame
*, struct input_event
*);
228 static void XTframe_rehighlight (struct frame
*);
229 static void x_frame_rehighlight (struct x_display_info
*);
230 static void x_draw_hollow_cursor (struct window
*, struct glyph_row
*);
231 static void x_draw_bar_cursor (struct window
*, struct glyph_row
*, int,
232 enum text_cursor_kinds
);
234 static void x_clip_to_row (struct window
*, struct glyph_row
*,
235 enum glyph_row_area
, GC
);
236 static void x_flush (struct frame
*f
);
237 static void x_update_begin (struct frame
*);
238 static void x_update_window_begin (struct window
*);
239 static struct scroll_bar
*x_window_to_scroll_bar (Display
*, Window
);
240 static void x_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
241 enum scroll_bar_part
*,
242 Lisp_Object
*, Lisp_Object
*,
244 static int x_handle_net_wm_state (struct frame
*, const XPropertyEvent
*);
245 static void x_check_fullscreen (struct frame
*);
246 static void x_check_expected_move (struct frame
*, int, int);
247 static void x_sync_with_move (struct frame
*, int, int, int);
248 static int handle_one_xevent (struct x_display_info
*,
249 const XEvent
*, int *,
250 struct input_event
*);
251 #if ! (defined USE_X_TOOLKIT || defined USE_MOTIF)
252 static int x_dispatch_event (XEvent
*, Display
*);
254 /* Don't declare this _Noreturn because we want no
255 interference with debugging failing X calls. */
256 static void x_connection_closed (Display
*, const char *);
257 static void x_wm_set_window_state (struct frame
*, int);
258 static void x_wm_set_icon_pixmap (struct frame
*, ptrdiff_t);
259 static void x_initialize (void);
262 /* Flush display of frame F. */
265 x_flush (struct frame
*f
)
267 eassert (f
&& FRAME_X_P (f
));
268 /* Don't call XFlush when it is not safe to redisplay; the X
269 connection may be broken. */
270 if (!NILP (Vinhibit_redisplay
))
274 XFlush (FRAME_X_DISPLAY (f
));
279 /* Remove calls to XFlush by defining XFlush to an empty replacement.
280 Calls to XFlush should be unnecessary because the X output buffer
281 is flushed automatically as needed by calls to XPending,
282 XNextEvent, or XWindowEvent according to the XFlush man page.
283 XTread_socket calls XPending. Removing XFlush improves
286 #define XFlush(DISPLAY) (void) 0
289 /***********************************************************************
291 ***********************************************************************/
295 /* This is a function useful for recording debugging information about
296 the sequence of occurrences in this file. */
304 struct record event_record
[100];
306 int event_record_index
;
309 record_event (char *locus
, int type
)
311 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
312 event_record_index
= 0;
314 event_record
[event_record_index
].locus
= locus
;
315 event_record
[event_record_index
].type
= type
;
316 event_record_index
++;
323 /* Return the struct x_display_info corresponding to DPY. */
325 struct x_display_info
*
326 x_display_info_for_display (Display
*dpy
)
328 struct x_display_info
*dpyinfo
;
330 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
331 if (dpyinfo
->display
== dpy
)
338 x_find_topmost_parent (struct frame
*f
)
340 struct x_output
*x
= f
->output_data
.x
;
341 Window win
= None
, wi
= x
->parent_desc
;
342 Display
*dpy
= FRAME_X_DISPLAY (f
);
344 while (wi
!= FRAME_DISPLAY_INFO (f
)->root_window
)
348 unsigned int nchildren
;
351 XQueryTree (dpy
, win
, &root
, &wi
, &children
, &nchildren
);
358 #define OPAQUE 0xffffffff
361 x_set_frame_alpha (struct frame
*f
)
363 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
364 Display
*dpy
= FRAME_X_DISPLAY (f
);
365 Window win
= FRAME_OUTER_WINDOW (f
);
367 double alpha_min
= 1.0;
371 if (dpyinfo
->x_highlight_frame
== f
)
376 if (FLOATP (Vframe_alpha_lower_limit
))
377 alpha_min
= XFLOAT_DATA (Vframe_alpha_lower_limit
);
378 else if (INTEGERP (Vframe_alpha_lower_limit
))
379 alpha_min
= (XINT (Vframe_alpha_lower_limit
)) / 100.0;
383 else if (alpha
> 1.0)
385 else if (0.0 <= alpha
&& alpha
< alpha_min
&& alpha_min
<= 1.0)
388 opac
= alpha
* OPAQUE
;
390 x_catch_errors (dpy
);
392 /* If there is a parent from the window manager, put the property there
393 also, to work around broken window managers that fail to do that.
394 Do this unconditionally as this function is called on reparent when
395 alpha has not changed on the frame. */
397 parent
= x_find_topmost_parent (f
);
399 XChangeProperty (dpy
, parent
, dpyinfo
->Xatom_net_wm_window_opacity
,
400 XA_CARDINAL
, 32, PropModeReplace
,
401 (unsigned char *) &opac
, 1L);
403 /* return unless necessary */
408 unsigned long n
, left
;
410 rc
= XGetWindowProperty (dpy
, win
, dpyinfo
->Xatom_net_wm_window_opacity
,
411 0L, 1L, False
, XA_CARDINAL
,
412 &actual
, &format
, &n
, &left
,
415 if (rc
== Success
&& actual
!= None
)
417 unsigned long value
= *(unsigned long *)data
;
427 XChangeProperty (dpy
, win
, dpyinfo
->Xatom_net_wm_window_opacity
,
428 XA_CARDINAL
, 32, PropModeReplace
,
429 (unsigned char *) &opac
, 1L);
434 x_display_pixel_height (struct x_display_info
*dpyinfo
)
436 return HeightOfScreen (dpyinfo
->screen
);
440 x_display_pixel_width (struct x_display_info
*dpyinfo
)
442 return WidthOfScreen (dpyinfo
->screen
);
446 /***********************************************************************
447 Starting and ending an update
448 ***********************************************************************/
450 /* Start an update of frame F. This function is installed as a hook
451 for update_begin, i.e. it is called when update_begin is called.
452 This function is called prior to calls to x_update_window_begin for
453 each window being updated. Currently, there is nothing to do here
454 because all interesting stuff is done on a window basis. */
457 x_update_begin (struct frame
*f
)
463 /* Start update of window W. */
466 x_update_window_begin (struct window
*w
)
468 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
469 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
471 w
->output_cursor
= w
->cursor
;
475 if (f
== hlinfo
->mouse_face_mouse_frame
)
477 /* Don't do highlighting for mouse motion during the update. */
478 hlinfo
->mouse_face_defer
= 1;
480 /* If F needs to be redrawn, simply forget about any prior mouse
482 if (FRAME_GARBAGED_P (f
))
483 hlinfo
->mouse_face_window
= Qnil
;
490 /* Draw a vertical window border from (x,y0) to (x,y1) */
493 x_draw_vertical_window_border (struct window
*w
, int x
, int y0
, int y1
)
495 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
498 face
= FACE_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
500 XSetForeground (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
503 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
504 f
->output_data
.x
->normal_gc
, x
, y0
, x
, y1
);
507 /* Draw a window divider from (x0,y0) to (x1,y1) */
510 x_draw_window_divider (struct window
*w
, int x0
, int x1
, int y0
, int y1
)
512 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
515 face
= FACE_FROM_ID (f
, WINDOW_DIVIDER_FACE_ID
);
517 XSetForeground (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
520 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
521 f
->output_data
.x
->normal_gc
, x0
, y0
, x1
- x0
, y1
- y0
);
524 /* End update of window W.
526 Draw vertical borders between horizontally adjacent windows, and
527 display W's cursor if CURSOR_ON_P is non-zero.
529 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
530 glyphs in mouse-face were overwritten. In that case we have to
531 make sure that the mouse-highlight is properly redrawn.
533 W may be a menu bar pseudo-window in case we don't have X toolkit
534 support. Such windows don't have a cursor, so don't display it
538 x_update_window_end (struct window
*w
, bool cursor_on_p
,
539 bool mouse_face_overwritten_p
)
541 if (!w
->pseudo_window_p
)
546 display_and_set_cursor (w
, 1,
547 w
->output_cursor
.hpos
, w
->output_cursor
.vpos
,
548 w
->output_cursor
.x
, w
->output_cursor
.y
);
550 if (draw_window_fringes (w
, 1))
552 if (WINDOW_RIGHT_DIVIDER_WIDTH (w
))
553 x_draw_right_divider (w
);
555 x_draw_vertical_border (w
);
561 /* If a row with mouse-face was overwritten, arrange for
562 XTframe_up_to_date to redisplay the mouse highlight. */
563 if (mouse_face_overwritten_p
)
564 reset_mouse_highlight (MOUSE_HL_INFO (XFRAME (w
->frame
)));
568 /* End update of frame F. This function is installed as a hook in
572 x_update_end (struct frame
*f
)
574 /* Mouse highlight may be displayed again. */
575 MOUSE_HL_INFO (f
)->mouse_face_defer
= 0;
579 XFlush (FRAME_X_DISPLAY (f
));
585 /* This function is called from various places in xdisp.c
586 whenever a complete update has been performed. */
589 XTframe_up_to_date (struct frame
*f
)
592 FRAME_MOUSE_UPDATE (f
);
596 /* Clear under internal border if any for non-toolkit builds. */
599 #if !defined USE_X_TOOLKIT && !defined USE_GTK
601 x_clear_under_internal_border (struct frame
*f
)
603 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
605 Display
*display
= FRAME_X_DISPLAY (f
);
606 Window window
= FRAME_X_WINDOW (f
);
607 int border
= FRAME_INTERNAL_BORDER_WIDTH (f
);
608 int width
= FRAME_PIXEL_WIDTH (f
);
609 int height
= FRAME_PIXEL_HEIGHT (f
);
610 int margin
= FRAME_TOP_MARGIN_HEIGHT (f
);
613 x_clear_area (display
, window
, 0, 0, border
, height
);
614 x_clear_area (display
, window
, 0, margin
, width
, border
);
615 x_clear_area (display
, window
, width
- border
, 0, border
, height
);
616 x_clear_area (display
, window
, 0, height
- border
, width
, border
);
622 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
623 arrow bitmaps, or clear the fringes if no bitmaps are required
624 before DESIRED_ROW is made current. This function is called from
625 update_window_line only if it is known that there are differences
626 between bitmaps to be drawn between current row and DESIRED_ROW. */
629 x_after_update_window_line (struct window
*w
, struct glyph_row
*desired_row
)
633 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
634 desired_row
->redraw_fringe_bitmaps_p
= 1;
637 /* When a window has disappeared, make sure that no rest of
638 full-width rows stays visible in the internal border. Could
639 check here if updated window is the leftmost/rightmost window,
640 but I guess it's not worth doing since vertically split windows
641 are almost never used, internal border is rarely set, and the
642 overhead is very small. */
647 if (windows_or_buffers_changed
648 && desired_row
->full_width_p
649 && (f
= XFRAME (w
->frame
),
650 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
652 && (height
= desired_row
->visible_height
,
655 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
658 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
659 0, y
, width
, height
);
660 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
661 FRAME_PIXEL_WIDTH (f
) - width
,
670 x_draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
, struct draw_fringe_bitmap_params
*p
)
672 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
673 Display
*display
= FRAME_X_DISPLAY (f
);
674 Window window
= FRAME_X_WINDOW (f
);
675 GC gc
= f
->output_data
.x
->normal_gc
;
676 struct face
*face
= p
->face
;
678 /* Must clip because of partially visible lines. */
679 x_clip_to_row (w
, row
, ANY_AREA
, gc
);
681 if (p
->bx
>= 0 && !p
->overlay_p
)
683 /* In case the same realized face is used for fringes and
684 for something displayed in the text (e.g. face `region' on
685 mono-displays, the fill style may have been changed to
686 FillSolid in x_draw_glyph_string_background. */
688 XSetFillStyle (display
, face
->gc
, FillOpaqueStippled
);
690 XSetForeground (display
, face
->gc
, face
->background
);
692 XFillRectangle (display
, window
, face
->gc
,
693 p
->bx
, p
->by
, p
->nx
, p
->ny
);
696 XSetForeground (display
, face
->gc
, face
->foreground
);
702 Pixmap pixmap
, clipmask
= (Pixmap
) 0;
703 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
707 bits
= (char *) (p
->bits
+ p
->dh
);
709 bits
= (char *) p
->bits
+ p
->dh
;
711 /* Draw the bitmap. I believe these small pixmaps can be cached
713 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, p
->wd
, p
->h
,
715 ? (p
->overlay_p
? face
->background
716 : f
->output_data
.x
->cursor_pixel
)
718 face
->background
, depth
);
722 clipmask
= XCreatePixmapFromBitmapData (display
,
723 FRAME_DISPLAY_INFO (f
)->root_window
,
726 gcv
.clip_mask
= clipmask
;
727 gcv
.clip_x_origin
= p
->x
;
728 gcv
.clip_y_origin
= p
->y
;
729 XChangeGC (display
, gc
, GCClipMask
| GCClipXOrigin
| GCClipYOrigin
, &gcv
);
732 XCopyArea (display
, pixmap
, window
, gc
, 0, 0,
733 p
->wd
, p
->h
, p
->x
, p
->y
);
734 XFreePixmap (display
, pixmap
);
738 gcv
.clip_mask
= (Pixmap
) 0;
739 XChangeGC (display
, gc
, GCClipMask
, &gcv
);
740 XFreePixmap (display
, clipmask
);
744 XSetClipMask (display
, gc
, None
);
747 /***********************************************************************
749 ***********************************************************************/
753 static void x_set_glyph_string_clipping (struct glyph_string
*);
754 static void x_set_glyph_string_gc (struct glyph_string
*);
755 static void x_draw_glyph_string_foreground (struct glyph_string
*);
756 static void x_draw_composite_glyph_string_foreground (struct glyph_string
*);
757 static void x_draw_glyph_string_box (struct glyph_string
*);
758 static void x_draw_glyph_string (struct glyph_string
*);
759 static _Noreturn
void x_delete_glyphs (struct frame
*, int);
760 static void x_compute_glyph_string_overhangs (struct glyph_string
*);
761 static void x_set_cursor_gc (struct glyph_string
*);
762 static void x_set_mode_line_face_gc (struct glyph_string
*);
763 static void x_set_mouse_face_gc (struct glyph_string
*);
764 static bool x_alloc_lighter_color (struct frame
*, Display
*, Colormap
,
765 unsigned long *, double, int);
766 static void x_setup_relief_color (struct frame
*, struct relief
*,
767 double, int, unsigned long);
768 static void x_setup_relief_colors (struct glyph_string
*);
769 static void x_draw_image_glyph_string (struct glyph_string
*);
770 static void x_draw_image_relief (struct glyph_string
*);
771 static void x_draw_image_foreground (struct glyph_string
*);
772 static void x_draw_image_foreground_1 (struct glyph_string
*, Pixmap
);
773 static void x_clear_glyph_string_rect (struct glyph_string
*, int,
775 static void x_draw_relief_rect (struct frame
*, int, int, int, int,
776 int, int, int, int, int, int,
778 static void x_draw_box_rect (struct glyph_string
*, int, int, int, int,
779 int, int, int, XRectangle
*);
780 static void x_scroll_bar_clear (struct frame
*);
783 static void x_check_font (struct frame
*, struct font
*);
787 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
791 x_set_cursor_gc (struct glyph_string
*s
)
793 if (s
->font
== FRAME_FONT (s
->f
)
794 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
795 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
797 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
800 /* Cursor on non-default face: must merge. */
804 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
805 xgcv
.foreground
= s
->face
->background
;
807 /* If the glyph would be invisible, try a different foreground. */
808 if (xgcv
.foreground
== xgcv
.background
)
809 xgcv
.foreground
= s
->face
->foreground
;
810 if (xgcv
.foreground
== xgcv
.background
)
811 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
812 if (xgcv
.foreground
== xgcv
.background
)
813 xgcv
.foreground
= s
->face
->foreground
;
815 /* Make sure the cursor is distinct from text in this face. */
816 if (xgcv
.background
== s
->face
->background
817 && xgcv
.foreground
== s
->face
->foreground
)
819 xgcv
.background
= s
->face
->foreground
;
820 xgcv
.foreground
= s
->face
->background
;
823 IF_DEBUG (x_check_font (s
->f
, s
->font
));
824 xgcv
.graphics_exposures
= False
;
825 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
827 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
828 XChangeGC (s
->display
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
831 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
832 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
834 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
839 /* Set up S->gc of glyph string S for drawing text in mouse face. */
842 x_set_mouse_face_gc (struct glyph_string
*s
)
847 /* What face has to be used last for the mouse face? */
848 face_id
= MOUSE_HL_INFO (s
->f
)->mouse_face_face_id
;
849 face
= FACE_FROM_ID (s
->f
, face_id
);
851 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
853 if (s
->first_glyph
->type
== CHAR_GLYPH
)
854 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
856 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
857 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
858 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
860 if (s
->font
== s
->face
->font
)
864 /* Otherwise construct scratch_cursor_gc with values from FACE
869 xgcv
.background
= s
->face
->background
;
870 xgcv
.foreground
= s
->face
->foreground
;
871 xgcv
.graphics_exposures
= False
;
872 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
874 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
875 XChangeGC (s
->display
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
878 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
879 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
881 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
884 eassert (s
->gc
!= 0);
888 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
889 Faces to use in the mode line have already been computed when the
890 matrix was built, so there isn't much to do, here. */
893 x_set_mode_line_face_gc (struct glyph_string
*s
)
899 /* Set S->gc of glyph string S for drawing that glyph string. Set
900 S->stippled_p to a non-zero value if the face of S has a stipple
904 x_set_glyph_string_gc (struct glyph_string
*s
)
906 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
908 if (s
->hl
== DRAW_NORMAL_TEXT
)
911 s
->stippled_p
= s
->face
->stipple
!= 0;
913 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
915 x_set_mode_line_face_gc (s
);
916 s
->stippled_p
= s
->face
->stipple
!= 0;
918 else if (s
->hl
== DRAW_CURSOR
)
923 else if (s
->hl
== DRAW_MOUSE_FACE
)
925 x_set_mouse_face_gc (s
);
926 s
->stippled_p
= s
->face
->stipple
!= 0;
928 else if (s
->hl
== DRAW_IMAGE_RAISED
929 || s
->hl
== DRAW_IMAGE_SUNKEN
)
932 s
->stippled_p
= s
->face
->stipple
!= 0;
937 s
->stippled_p
= s
->face
->stipple
!= 0;
940 /* GC must have been set. */
941 eassert (s
->gc
!= 0);
945 /* Set clipping for output of glyph string S. S may be part of a mode
946 line or menu if we don't have X toolkit support. */
949 x_set_glyph_string_clipping (struct glyph_string
*s
)
951 XRectangle
*r
= s
->clip
;
952 int n
= get_glyph_string_clip_rects (s
, r
, 2);
955 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, r
, n
, Unsorted
);
960 /* Set SRC's clipping for output of glyph string DST. This is called
961 when we are drawing DST's left_overhang or right_overhang only in
965 x_set_glyph_string_clipping_exactly (struct glyph_string
*src
, struct glyph_string
*dst
)
970 r
.width
= src
->width
;
972 r
.height
= src
->height
;
975 XSetClipRectangles (dst
->display
, dst
->gc
, 0, 0, &r
, 1, Unsorted
);
980 Compute left and right overhang of glyph string S. */
983 x_compute_glyph_string_overhangs (struct glyph_string
*s
)
986 && (s
->first_glyph
->type
== CHAR_GLYPH
987 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
989 struct font_metrics metrics
;
991 if (s
->first_glyph
->type
== CHAR_GLYPH
)
993 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
994 struct font
*font
= s
->font
;
997 for (i
= 0; i
< s
->nchars
; i
++)
998 code
[i
] = (s
->char2b
[i
].byte1
<< 8) | s
->char2b
[i
].byte2
;
999 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1003 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1005 composition_gstring_width (gstring
, s
->cmp_from
, s
->cmp_to
, &metrics
);
1007 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1008 ? metrics
.rbearing
- metrics
.width
: 0);
1009 s
->left_overhang
= metrics
.lbearing
< 0 ? - metrics
.lbearing
: 0;
1013 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1014 s
->left_overhang
= - s
->cmp
->lbearing
;
1019 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1022 x_clear_glyph_string_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
1025 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
1026 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
1027 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
1028 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
1032 /* Draw the background of glyph_string S. If S->background_filled_p
1033 is non-zero don't draw it. FORCE_P non-zero means draw the
1034 background even if it wouldn't be drawn normally. This is used
1035 when a string preceding S draws into the background of S, or S
1036 contains the first component of a composition. */
1039 x_draw_glyph_string_background (struct glyph_string
*s
, bool force_p
)
1041 /* Nothing to do if background has already been drawn or if it
1042 shouldn't be drawn in the first place. */
1043 if (!s
->background_filled_p
)
1045 int box_line_width
= max (s
->face
->box_line_width
, 0);
1049 /* Fill background with a stipple pattern. */
1050 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1051 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1052 s
->y
+ box_line_width
,
1053 s
->background_width
,
1054 s
->height
- 2 * box_line_width
);
1055 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1056 s
->background_filled_p
= 1;
1058 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1059 || s
->font_not_found_p
1060 || s
->extends_to_end_of_line_p
1063 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1064 s
->background_width
,
1065 s
->height
- 2 * box_line_width
);
1066 s
->background_filled_p
= 1;
1072 /* Draw the foreground of glyph string S. */
1075 x_draw_glyph_string_foreground (struct glyph_string
*s
)
1079 /* If first glyph of S has a left box line, start drawing the text
1080 of S to the right of that box line. */
1081 if (s
->face
->box
!= FACE_NO_BOX
1082 && s
->first_glyph
->left_box_line_p
)
1083 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1087 /* Draw characters of S as rectangles if S's font could not be
1089 if (s
->font_not_found_p
)
1091 for (i
= 0; i
< s
->nchars
; ++i
)
1093 struct glyph
*g
= s
->first_glyph
+ i
;
1094 XDrawRectangle (s
->display
, s
->window
,
1095 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1097 x
+= g
->pixel_width
;
1102 struct font
*font
= s
->font
;
1103 int boff
= font
->baseline_offset
;
1106 if (font
->vertical_centering
)
1107 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1109 y
= s
->ybase
- boff
;
1111 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1112 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 0);
1114 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 1);
1115 if (s
->face
->overstrike
)
1116 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, 0);
1120 /* Draw the foreground of composite glyph string S. */
1123 x_draw_composite_glyph_string_foreground (struct glyph_string
*s
)
1126 struct font
*font
= s
->font
;
1128 /* If first glyph of S has a left box line, start drawing the text
1129 of S to the right of that box line. */
1130 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1131 && s
->first_glyph
->left_box_line_p
)
1132 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1136 /* S is a glyph string for a composition. S->cmp_from is the index
1137 of the first character drawn for glyphs of this composition.
1138 S->cmp_from == 0 means we are drawing the very first character of
1139 this composition. */
1141 /* Draw a rectangle for the composition if the font for the very
1142 first character of the composition could not be loaded. */
1143 if (s
->font_not_found_p
)
1145 if (s
->cmp_from
== 0)
1146 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, s
->y
,
1147 s
->width
- 1, s
->height
- 1);
1149 else if (! s
->first_glyph
->u
.cmp
.automatic
)
1153 for (i
= 0, j
= s
->cmp_from
; i
< s
->nchars
; i
++, j
++)
1154 /* TAB in a composition means display glyphs with padding
1155 space on the left or right. */
1156 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1158 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1159 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1161 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, 0);
1162 if (s
->face
->overstrike
)
1163 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, 0);
1168 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1173 for (i
= j
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
1175 glyph
= LGSTRING_GLYPH (gstring
, i
);
1176 if (NILP (LGLYPH_ADJUSTMENT (glyph
)))
1177 width
+= LGLYPH_WIDTH (glyph
);
1180 int xoff
, yoff
, wadjust
;
1184 font
->driver
->draw (s
, j
, i
, x
, y
, 0);
1185 if (s
->face
->overstrike
)
1186 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, 0);
1189 xoff
= LGLYPH_XOFF (glyph
);
1190 yoff
= LGLYPH_YOFF (glyph
);
1191 wadjust
= LGLYPH_WADJUST (glyph
);
1192 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, 0);
1193 if (s
->face
->overstrike
)
1194 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
+ 1, y
+ yoff
, 0);
1202 font
->driver
->draw (s
, j
, i
, x
, y
, 0);
1203 if (s
->face
->overstrike
)
1204 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, 0);
1210 /* Draw the foreground of glyph string S for glyphless characters. */
1213 x_draw_glyphless_glyph_string_foreground (struct glyph_string
*s
)
1215 struct glyph
*glyph
= s
->first_glyph
;
1219 /* If first glyph of S has a left box line, start drawing the text
1220 of S to the right of that box line. */
1221 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1222 && s
->first_glyph
->left_box_line_p
)
1223 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1229 for (i
= 0; i
< s
->nchars
; i
++, glyph
++)
1231 char buf
[7], *str
= NULL
;
1232 int len
= glyph
->u
.glyphless
.len
;
1234 if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_ACRONYM
)
1237 && CHAR_TABLE_P (Vglyphless_char_display
)
1238 && (CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display
))
1242 = (! glyph
->u
.glyphless
.for_no_font
1243 ? CHAR_TABLE_REF (Vglyphless_char_display
,
1244 glyph
->u
.glyphless
.ch
)
1245 : XCHAR_TABLE (Vglyphless_char_display
)->extras
[0]);
1246 if (STRINGP (acronym
))
1247 str
= SSDATA (acronym
);
1250 else if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_HEX_CODE
)
1252 sprintf (buf
, "%0*X",
1253 glyph
->u
.glyphless
.ch
< 0x10000 ? 4 : 6,
1254 glyph
->u
.glyphless
.ch
);
1260 int upper_len
= (len
+ 1) / 2;
1263 /* It is assured that all LEN characters in STR is ASCII. */
1264 for (j
= 0; j
< len
; j
++)
1266 code
= s
->font
->driver
->encode_char (s
->font
, str
[j
]);
1267 STORE_XCHAR2B (char2b
+ j
, code
>> 8, code
& 0xFF);
1269 s
->font
->driver
->draw (s
, 0, upper_len
,
1270 x
+ glyph
->slice
.glyphless
.upper_xoff
,
1271 s
->ybase
+ glyph
->slice
.glyphless
.upper_yoff
,
1273 s
->font
->driver
->draw (s
, upper_len
, len
,
1274 x
+ glyph
->slice
.glyphless
.lower_xoff
,
1275 s
->ybase
+ glyph
->slice
.glyphless
.lower_yoff
,
1278 if (glyph
->u
.glyphless
.method
!= GLYPHLESS_DISPLAY_THIN_SPACE
)
1279 XDrawRectangle (s
->display
, s
->window
, s
->gc
,
1280 x
, s
->ybase
- glyph
->ascent
,
1281 glyph
->pixel_width
- 1,
1282 glyph
->ascent
+ glyph
->descent
- 1);
1283 x
+= glyph
->pixel_width
;
1287 #ifdef USE_X_TOOLKIT
1291 /* Return the frame on which widget WIDGET is used.. Abort if frame
1292 cannot be determined. */
1294 static struct frame
*
1295 x_frame_of_widget (Widget widget
)
1297 struct x_display_info
*dpyinfo
;
1298 Lisp_Object tail
, frame
;
1301 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
1303 /* Find the top-level shell of the widget. Note that this function
1304 can be called when the widget is not yet realized, so XtWindow
1305 (widget) == 0. That's the reason we can't simply use
1306 x_any_window_to_frame. */
1307 while (!XtIsTopLevelShell (widget
))
1308 widget
= XtParent (widget
);
1310 /* Look for a frame with that top-level widget. Allocate the color
1311 on that frame to get the right gamma correction value. */
1312 FOR_EACH_FRAME (tail
, frame
)
1316 && f
->output_data
.nothing
!= 1
1317 && FRAME_DISPLAY_INFO (f
) == dpyinfo
1318 && f
->output_data
.x
->widget
== widget
)
1324 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1325 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1326 If this produces the same color as PIXEL, try a color where all RGB
1327 values have DELTA added. Return the allocated color in *PIXEL.
1328 DISPLAY is the X display, CMAP is the colormap to operate on.
1329 Value is true if successful. */
1332 x_alloc_lighter_color_for_widget (Widget widget
, Display
*display
, Colormap cmap
,
1333 unsigned long *pixel
, double factor
, int delta
)
1335 struct frame
*f
= x_frame_of_widget (widget
);
1336 return x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
);
1339 #endif /* USE_LUCID */
1342 /* Structure specifying which arguments should be passed by Xt to
1343 cvt_string_to_pixel. We want the widget's screen and colormap. */
1345 static XtConvertArgRec cvt_string_to_pixel_args
[] =
1347 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.screen
),
1349 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.colormap
),
1354 /* The address of this variable is returned by
1355 cvt_string_to_pixel. */
1357 static Pixel cvt_string_to_pixel_value
;
1360 /* Convert a color name to a pixel color.
1362 DPY is the display we are working on.
1364 ARGS is an array of *NARGS XrmValue structures holding additional
1365 information about the widget for which the conversion takes place.
1366 The contents of this array are determined by the specification
1367 in cvt_string_to_pixel_args.
1369 FROM is a pointer to an XrmValue which points to the color name to
1370 convert. TO is an XrmValue in which to return the pixel color.
1372 CLOSURE_RET is a pointer to user-data, in which we record if
1373 we allocated the color or not.
1375 Value is True if successful, False otherwise. */
1378 cvt_string_to_pixel (Display
*dpy
, XrmValue
*args
, Cardinal
*nargs
,
1379 XrmValue
*from
, XrmValue
*to
,
1380 XtPointer
*closure_ret
)
1390 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1391 "wrongParameters", "cvt_string_to_pixel",
1393 "Screen and colormap args required", NULL
, NULL
);
1397 screen
= *(Screen
**) args
[0].addr
;
1398 cmap
= *(Colormap
*) args
[1].addr
;
1399 color_name
= (String
) from
->addr
;
1401 if (strcmp (color_name
, XtDefaultBackground
) == 0)
1403 *closure_ret
= (XtPointer
) False
;
1404 pixel
= WhitePixelOfScreen (screen
);
1406 else if (strcmp (color_name
, XtDefaultForeground
) == 0)
1408 *closure_ret
= (XtPointer
) False
;
1409 pixel
= BlackPixelOfScreen (screen
);
1411 else if (XParseColor (dpy
, cmap
, color_name
, &color
)
1412 && x_alloc_nearest_color_1 (dpy
, cmap
, &color
))
1414 pixel
= color
.pixel
;
1415 *closure_ret
= (XtPointer
) True
;
1420 Cardinal nparams
= 1;
1422 params
[0] = color_name
;
1423 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1424 "badValue", "cvt_string_to_pixel",
1425 "XtToolkitError", "Invalid color `%s'",
1430 if (to
->addr
!= NULL
)
1432 if (to
->size
< sizeof (Pixel
))
1434 to
->size
= sizeof (Pixel
);
1438 *(Pixel
*) to
->addr
= pixel
;
1442 cvt_string_to_pixel_value
= pixel
;
1443 to
->addr
= (XtPointer
) &cvt_string_to_pixel_value
;
1446 to
->size
= sizeof (Pixel
);
1451 /* Free a pixel color which was previously allocated via
1452 cvt_string_to_pixel. This is registered as the destructor
1453 for this type of resource via XtSetTypeConverter.
1455 APP is the application context in which we work.
1457 TO is a pointer to an XrmValue holding the color to free.
1458 CLOSURE is the value we stored in CLOSURE_RET for this color
1459 in cvt_string_to_pixel.
1461 ARGS and NARGS are like for cvt_string_to_pixel. */
1464 cvt_pixel_dtor (XtAppContext app
, XrmValuePtr to
, XtPointer closure
, XrmValuePtr args
,
1469 XtAppWarningMsg (app
, "wrongParameters", "cvt_pixel_dtor",
1471 "Screen and colormap arguments required",
1474 else if (closure
!= NULL
)
1476 /* We did allocate the pixel, so free it. */
1477 Screen
*screen
= *(Screen
**) args
[0].addr
;
1478 Colormap cmap
= *(Colormap
*) args
[1].addr
;
1479 x_free_dpy_colors (DisplayOfScreen (screen
), screen
, cmap
,
1480 (Pixel
*) to
->addr
, 1);
1485 #endif /* USE_X_TOOLKIT */
1488 /* Value is an array of XColor structures for the contents of the
1489 color map of display DPY. Set *NCELLS to the size of the array.
1490 Note that this probably shouldn't be called for large color maps,
1491 say a 24-bit TrueColor map. */
1493 static const XColor
*
1494 x_color_cells (Display
*dpy
, int *ncells
)
1496 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1498 if (dpyinfo
->color_cells
== NULL
)
1500 Screen
*screen
= dpyinfo
->screen
;
1501 int ncolor_cells
= XDisplayCells (dpy
, XScreenNumberOfScreen (screen
));
1504 dpyinfo
->color_cells
= xnmalloc (ncolor_cells
,
1505 sizeof *dpyinfo
->color_cells
);
1506 dpyinfo
->ncolor_cells
= ncolor_cells
;
1508 for (i
= 0; i
< ncolor_cells
; ++i
)
1509 dpyinfo
->color_cells
[i
].pixel
= i
;
1511 XQueryColors (dpy
, dpyinfo
->cmap
,
1512 dpyinfo
->color_cells
, ncolor_cells
);
1515 *ncells
= dpyinfo
->ncolor_cells
;
1516 return dpyinfo
->color_cells
;
1520 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1521 colors in COLORS. Use cached information, if available. */
1524 x_query_colors (struct frame
*f
, XColor
*colors
, int ncolors
)
1526 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
1528 if (dpyinfo
->color_cells
)
1531 for (i
= 0; i
< ncolors
; ++i
)
1533 unsigned long pixel
= colors
[i
].pixel
;
1534 eassert (pixel
< dpyinfo
->ncolor_cells
);
1535 eassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
1536 colors
[i
] = dpyinfo
->color_cells
[pixel
];
1540 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
1544 /* On frame F, translate pixel color to RGB values for the color in
1545 COLOR. Use cached information, if available. */
1548 x_query_color (struct frame
*f
, XColor
*color
)
1550 x_query_colors (f
, color
, 1);
1554 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
1555 exact match can't be allocated, try the nearest color available.
1556 Value is true if successful. Set *COLOR to the color
1560 x_alloc_nearest_color_1 (Display
*dpy
, Colormap cmap
, XColor
*color
)
1564 rc
= XAllocColor (dpy
, cmap
, color
) != 0;
1567 /* If we got to this point, the colormap is full, so we're going
1568 to try to get the next closest color. The algorithm used is
1569 a least-squares matching, which is what X uses for closest
1570 color matching with StaticColor visuals. */
1572 int max_color_delta
= 255;
1573 int max_delta
= 3 * max_color_delta
;
1574 int nearest_delta
= max_delta
+ 1;
1576 const XColor
*cells
= x_color_cells (dpy
, &ncells
);
1578 for (nearest
= i
= 0; i
< ncells
; ++i
)
1580 int dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
1581 int dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
1582 int dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
1583 int delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
1585 if (delta
< nearest_delta
)
1588 nearest_delta
= delta
;
1592 color
->red
= cells
[nearest
].red
;
1593 color
->green
= cells
[nearest
].green
;
1594 color
->blue
= cells
[nearest
].blue
;
1595 rc
= XAllocColor (dpy
, cmap
, color
) != 0;
1599 /* If allocation succeeded, and the allocated pixel color is not
1600 equal to a cached pixel color recorded earlier, there was a
1601 change in the colormap, so clear the color cache. */
1602 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1603 XColor
*cached_color
;
1605 if (dpyinfo
->color_cells
1606 && (cached_color
= &dpyinfo
->color_cells
[color
->pixel
],
1607 (cached_color
->red
!= color
->red
1608 || cached_color
->blue
!= color
->blue
1609 || cached_color
->green
!= color
->green
)))
1611 xfree (dpyinfo
->color_cells
);
1612 dpyinfo
->color_cells
= NULL
;
1613 dpyinfo
->ncolor_cells
= 0;
1617 #ifdef DEBUG_X_COLORS
1619 register_color (color
->pixel
);
1620 #endif /* DEBUG_X_COLORS */
1626 /* Allocate the color COLOR->pixel on frame F, colormap CMAP. If an
1627 exact match can't be allocated, try the nearest color available.
1628 Value is true if successful. Set *COLOR to the color
1632 x_alloc_nearest_color (struct frame
*f
, Colormap cmap
, XColor
*color
)
1634 gamma_correct (f
, color
);
1635 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f
), cmap
, color
);
1639 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
1640 It's necessary to do this instead of just using PIXEL directly to
1641 get color reference counts right. */
1644 x_copy_color (struct frame
*f
, unsigned long pixel
)
1648 color
.pixel
= pixel
;
1650 x_query_color (f
, &color
);
1651 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
1653 #ifdef DEBUG_X_COLORS
1654 register_color (pixel
);
1660 /* Brightness beyond which a color won't have its highlight brightness
1663 Nominally, highlight colors for `3d' faces are calculated by
1664 brightening an object's color by a constant scale factor, but this
1665 doesn't yield good results for dark colors, so for colors who's
1666 brightness is less than this value (on a scale of 0-65535) have an
1667 use an additional additive factor.
1669 The value here is set so that the default menu-bar/mode-line color
1670 (grey75) will not have its highlights changed at all. */
1671 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
1674 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1675 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1676 If this produces the same color as PIXEL, try a color where all RGB
1677 values have DELTA added. Return the allocated color in *PIXEL.
1678 DISPLAY is the X display, CMAP is the colormap to operate on.
1679 Value is non-zero if successful. */
1682 x_alloc_lighter_color (struct frame
*f
, Display
*display
, Colormap cmap
,
1683 unsigned long *pixel
, double factor
, int delta
)
1689 /* Get RGB color values. */
1690 color
.pixel
= *pixel
;
1691 x_query_color (f
, &color
);
1693 /* Change RGB values by specified FACTOR. Avoid overflow! */
1694 eassert (factor
>= 0);
1695 new.red
= min (0xffff, factor
* color
.red
);
1696 new.green
= min (0xffff, factor
* color
.green
);
1697 new.blue
= min (0xffff, factor
* color
.blue
);
1699 /* Calculate brightness of COLOR. */
1700 bright
= (2 * color
.red
+ 3 * color
.green
+ color
.blue
) / 6;
1702 /* We only boost colors that are darker than
1703 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1704 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1705 /* Make an additive adjustment to NEW, because it's dark enough so
1706 that scaling by FACTOR alone isn't enough. */
1708 /* How far below the limit this color is (0 - 1, 1 being darker). */
1709 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1710 /* The additive adjustment. */
1711 int min_delta
= delta
* dimness
* factor
/ 2;
1715 new.red
= max (0, new.red
- min_delta
);
1716 new.green
= max (0, new.green
- min_delta
);
1717 new.blue
= max (0, new.blue
- min_delta
);
1721 new.red
= min (0xffff, min_delta
+ new.red
);
1722 new.green
= min (0xffff, min_delta
+ new.green
);
1723 new.blue
= min (0xffff, min_delta
+ new.blue
);
1727 /* Try to allocate the color. */
1728 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1731 if (new.pixel
== *pixel
)
1733 /* If we end up with the same color as before, try adding
1734 delta to the RGB values. */
1735 x_free_colors (f
, &new.pixel
, 1);
1737 new.red
= min (0xffff, delta
+ color
.red
);
1738 new.green
= min (0xffff, delta
+ color
.green
);
1739 new.blue
= min (0xffff, delta
+ color
.blue
);
1740 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1751 /* Set up the foreground color for drawing relief lines of glyph
1752 string S. RELIEF is a pointer to a struct relief containing the GC
1753 with which lines will be drawn. Use a color that is FACTOR or
1754 DELTA lighter or darker than the relief's background which is found
1755 in S->f->output_data.x->relief_background. If such a color cannot
1756 be allocated, use DEFAULT_PIXEL, instead. */
1759 x_setup_relief_color (struct frame
*f
, struct relief
*relief
, double factor
,
1760 int delta
, unsigned long default_pixel
)
1763 struct x_output
*di
= f
->output_data
.x
;
1764 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
1765 unsigned long pixel
;
1766 unsigned long background
= di
->relief_background
;
1767 Colormap cmap
= FRAME_X_COLORMAP (f
);
1768 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
1769 Display
*dpy
= FRAME_X_DISPLAY (f
);
1771 xgcv
.graphics_exposures
= False
;
1772 xgcv
.line_width
= 1;
1774 /* Free previously allocated color. The color cell will be reused
1775 when it has been freed as many times as it was allocated, so this
1776 doesn't affect faces using the same colors. */
1777 if (relief
->gc
&& relief
->pixel
!= -1)
1779 x_free_colors (f
, &relief
->pixel
, 1);
1783 /* Allocate new color. */
1784 xgcv
.foreground
= default_pixel
;
1786 if (dpyinfo
->n_planes
!= 1
1787 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
1788 xgcv
.foreground
= relief
->pixel
= pixel
;
1790 if (relief
->gc
== 0)
1792 xgcv
.stipple
= dpyinfo
->gray
;
1794 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
1797 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
1801 /* Set up colors for the relief lines around glyph string S. */
1804 x_setup_relief_colors (struct glyph_string
*s
)
1806 struct x_output
*di
= s
->f
->output_data
.x
;
1807 unsigned long color
;
1809 if (s
->face
->use_box_color_for_shadows_p
)
1810 color
= s
->face
->box_color
;
1811 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1813 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1814 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1819 /* Get the background color of the face. */
1820 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
1821 color
= xgcv
.background
;
1824 if (di
->white_relief
.gc
== 0
1825 || color
!= di
->relief_background
)
1827 di
->relief_background
= color
;
1828 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
1829 WHITE_PIX_DEFAULT (s
->f
));
1830 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
1831 BLACK_PIX_DEFAULT (s
->f
));
1836 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1837 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1838 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1839 relief. LEFT_P non-zero means draw a relief on the left side of
1840 the rectangle. RIGHT_P non-zero means draw a relief on the right
1841 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1845 x_draw_relief_rect (struct frame
*f
,
1846 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
1847 int raised_p
, int top_p
, int bot_p
, int left_p
, int right_p
,
1848 XRectangle
*clip_rect
)
1850 Display
*dpy
= FRAME_X_DISPLAY (f
);
1851 Window window
= FRAME_X_WINDOW (f
);
1856 gc
= f
->output_data
.x
->white_relief
.gc
;
1858 gc
= f
->output_data
.x
->black_relief
.gc
;
1859 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
1861 /* This code is more complicated than it has to be, because of two
1862 minor hacks to make the boxes look nicer: (i) if width > 1, draw
1863 the outermost line using the black relief. (ii) Omit the four
1870 XDrawLine (dpy
, window
, gc
,
1871 left_x
+ (left_p
? 1 : 0), top_y
,
1872 right_x
+ (right_p
? 0 : 1), top_y
);
1874 for (i
= 1; i
< width
; ++i
)
1875 XDrawLine (dpy
, window
, gc
,
1876 left_x
+ i
* left_p
, top_y
+ i
,
1877 right_x
+ 1 - i
* right_p
, top_y
+ i
);
1884 XDrawLine (dpy
, window
, gc
, left_x
, top_y
+ 1, left_x
, bottom_y
);
1886 XClearArea (dpy
, window
, left_x
, top_y
, 1, 1, False
);
1887 XClearArea (dpy
, window
, left_x
, bottom_y
, 1, 1, False
);
1889 for (i
= (width
> 1 ? 1 : 0); i
< width
; ++i
)
1890 XDrawLine (dpy
, window
, gc
,
1891 left_x
+ i
, top_y
+ (i
+ 1) * top_p
,
1892 left_x
+ i
, bottom_y
+ 1 - (i
+ 1) * bot_p
);
1895 XSetClipMask (dpy
, gc
, None
);
1897 gc
= f
->output_data
.x
->black_relief
.gc
;
1899 gc
= f
->output_data
.x
->white_relief
.gc
;
1900 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
1904 /* Outermost top line. */
1906 XDrawLine (dpy
, window
, gc
,
1907 left_x
+ (left_p
? 1 : 0), top_y
,
1908 right_x
+ (right_p
? 0 : 1), top_y
);
1910 /* Outermost left line. */
1912 XDrawLine (dpy
, window
, gc
, left_x
, top_y
+ 1, left_x
, bottom_y
);
1918 XDrawLine (dpy
, window
, gc
,
1919 left_x
+ (left_p
? 1 : 0), bottom_y
,
1920 right_x
+ (right_p
? 0 : 1), bottom_y
);
1921 for (i
= 1; i
< width
; ++i
)
1922 XDrawLine (dpy
, window
, gc
,
1923 left_x
+ i
* left_p
, bottom_y
- i
,
1924 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
1930 XClearArea (dpy
, window
, right_x
, top_y
, 1, 1, False
);
1931 XClearArea (dpy
, window
, right_x
, bottom_y
, 1, 1, False
);
1932 for (i
= 0; i
< width
; ++i
)
1933 XDrawLine (dpy
, window
, gc
,
1934 right_x
- i
, top_y
+ (i
+ 1) * top_p
,
1935 right_x
- i
, bottom_y
+ 1 - (i
+ 1) * bot_p
);
1938 XSetClipMask (dpy
, gc
, None
);
1942 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1943 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1944 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
1945 left side of the rectangle. RIGHT_P non-zero means draw a line
1946 on the right side of the rectangle. CLIP_RECT is the clipping
1947 rectangle to use when drawing. */
1950 x_draw_box_rect (struct glyph_string
*s
,
1951 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
1952 int left_p
, int right_p
, XRectangle
*clip_rect
)
1956 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
1957 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
1958 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, clip_rect
, 1, Unsorted
);
1961 XFillRectangle (s
->display
, s
->window
, s
->gc
,
1962 left_x
, top_y
, right_x
- left_x
+ 1, width
);
1966 XFillRectangle (s
->display
, s
->window
, s
->gc
,
1967 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
1970 XFillRectangle (s
->display
, s
->window
, s
->gc
,
1971 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
1975 XFillRectangle (s
->display
, s
->window
, s
->gc
,
1976 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
1978 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
1979 XSetClipMask (s
->display
, s
->gc
, None
);
1983 /* Draw a box around glyph string S. */
1986 x_draw_glyph_string_box (struct glyph_string
*s
)
1988 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
1989 int left_p
, right_p
;
1990 struct glyph
*last_glyph
;
1991 XRectangle clip_rect
;
1993 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
1994 ? WINDOW_RIGHT_EDGE_X (s
->w
)
1995 : window_box_right (s
->w
, s
->area
));
1997 /* The glyph that may have a right box line. */
1998 last_glyph
= (s
->cmp
|| s
->img
2000 : s
->first_glyph
+ s
->nchars
- 1);
2002 width
= eabs (s
->face
->box_line_width
);
2003 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
2005 right_x
= (s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
2007 : min (last_x
, s
->x
+ s
->background_width
) - 1);
2009 bottom_y
= top_y
+ s
->height
- 1;
2011 left_p
= (s
->first_glyph
->left_box_line_p
2012 || (s
->hl
== DRAW_MOUSE_FACE
2014 || s
->prev
->hl
!= s
->hl
)));
2015 right_p
= (last_glyph
->right_box_line_p
2016 || (s
->hl
== DRAW_MOUSE_FACE
2018 || s
->next
->hl
!= s
->hl
)));
2020 get_glyph_string_clip_rect (s
, &clip_rect
);
2022 if (s
->face
->box
== FACE_SIMPLE_BOX
)
2023 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2024 left_p
, right_p
, &clip_rect
);
2027 x_setup_relief_colors (s
);
2028 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
2029 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
2034 /* Draw foreground of image glyph string S. */
2037 x_draw_image_foreground (struct glyph_string
*s
)
2040 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2042 /* If first glyph of S has a left box line, start drawing it to the
2043 right of that line. */
2044 if (s
->face
->box
!= FACE_NO_BOX
2045 && s
->first_glyph
->left_box_line_p
2047 x
+= eabs (s
->face
->box_line_width
);
2049 /* If there is a margin around the image, adjust x- and y-position
2051 if (s
->slice
.x
== 0)
2052 x
+= s
->img
->hmargin
;
2053 if (s
->slice
.y
== 0)
2054 y
+= s
->img
->vmargin
;
2060 /* We can't set both a clip mask and use XSetClipRectangles
2061 because the latter also sets a clip mask. We also can't
2062 trust on the shape extension to be available
2063 (XShapeCombineRegion). So, compute the rectangle to draw
2065 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2068 XRectangle clip_rect
, image_rect
, r
;
2070 xgcv
.clip_mask
= s
->img
->mask
;
2071 xgcv
.clip_x_origin
= x
;
2072 xgcv
.clip_y_origin
= y
;
2073 xgcv
.function
= GXcopy
;
2074 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2076 get_glyph_string_clip_rect (s
, &clip_rect
);
2079 image_rect
.width
= s
->slice
.width
;
2080 image_rect
.height
= s
->slice
.height
;
2081 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2082 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2083 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2084 r
.width
, r
.height
, r
.x
, r
.y
);
2088 XRectangle clip_rect
, image_rect
, r
;
2090 get_glyph_string_clip_rect (s
, &clip_rect
);
2093 image_rect
.width
= s
->slice
.width
;
2094 image_rect
.height
= s
->slice
.height
;
2095 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2096 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2097 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2098 r
.width
, r
.height
, r
.x
, r
.y
);
2100 /* When the image has a mask, we can expect that at
2101 least part of a mouse highlight or a block cursor will
2102 be visible. If the image doesn't have a mask, make
2103 a block cursor visible by drawing a rectangle around
2104 the image. I believe it's looking better if we do
2105 nothing here for mouse-face. */
2106 if (s
->hl
== DRAW_CURSOR
)
2108 int relief
= eabs (s
->img
->relief
);
2109 XDrawRectangle (s
->display
, s
->window
, s
->gc
,
2110 x
- relief
, y
- relief
,
2111 s
->slice
.width
+ relief
*2 - 1,
2112 s
->slice
.height
+ relief
*2 - 1);
2117 /* Draw a rectangle if image could not be loaded. */
2118 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
2119 s
->slice
.width
- 1, s
->slice
.height
- 1);
2123 /* Draw a relief around the image glyph string S. */
2126 x_draw_image_relief (struct glyph_string
*s
)
2128 int x1
, y1
, thick
, raised_p
, top_p
, bot_p
, left_p
, right_p
;
2131 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2133 /* If first glyph of S has a left box line, start drawing it to the
2134 right of that line. */
2135 if (s
->face
->box
!= FACE_NO_BOX
2136 && s
->first_glyph
->left_box_line_p
2138 x
+= eabs (s
->face
->box_line_width
);
2140 /* If there is a margin around the image, adjust x- and y-position
2142 if (s
->slice
.x
== 0)
2143 x
+= s
->img
->hmargin
;
2144 if (s
->slice
.y
== 0)
2145 y
+= s
->img
->vmargin
;
2147 if (s
->hl
== DRAW_IMAGE_SUNKEN
2148 || s
->hl
== DRAW_IMAGE_RAISED
)
2150 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
2151 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
2155 thick
= eabs (s
->img
->relief
);
2156 raised_p
= s
->img
->relief
> 0;
2159 x1
= x
+ s
->slice
.width
- 1;
2160 y1
= y
+ s
->slice
.height
- 1;
2161 top_p
= bot_p
= left_p
= right_p
= 0;
2163 if (s
->slice
.x
== 0)
2164 x
-= thick
, left_p
= 1;
2165 if (s
->slice
.y
== 0)
2166 y
-= thick
, top_p
= 1;
2167 if (s
->slice
.x
+ s
->slice
.width
== s
->img
->width
)
2168 x1
+= thick
, right_p
= 1;
2169 if (s
->slice
.y
+ s
->slice
.height
== s
->img
->height
)
2170 y1
+= thick
, bot_p
= 1;
2172 x_setup_relief_colors (s
);
2173 get_glyph_string_clip_rect (s
, &r
);
2174 x_draw_relief_rect (s
->f
, x
, y
, x1
, y1
, thick
, raised_p
,
2175 top_p
, bot_p
, left_p
, right_p
, &r
);
2179 /* Draw the foreground of image glyph string S to PIXMAP. */
2182 x_draw_image_foreground_1 (struct glyph_string
*s
, Pixmap pixmap
)
2185 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2187 /* If first glyph of S has a left box line, start drawing it to the
2188 right of that line. */
2189 if (s
->face
->box
!= FACE_NO_BOX
2190 && s
->first_glyph
->left_box_line_p
2192 x
+= eabs (s
->face
->box_line_width
);
2194 /* If there is a margin around the image, adjust x- and y-position
2196 if (s
->slice
.x
== 0)
2197 x
+= s
->img
->hmargin
;
2198 if (s
->slice
.y
== 0)
2199 y
+= s
->img
->vmargin
;
2205 /* We can't set both a clip mask and use XSetClipRectangles
2206 because the latter also sets a clip mask. We also can't
2207 trust on the shape extension to be available
2208 (XShapeCombineRegion). So, compute the rectangle to draw
2210 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2214 xgcv
.clip_mask
= s
->img
->mask
;
2215 xgcv
.clip_x_origin
= x
- s
->slice
.x
;
2216 xgcv
.clip_y_origin
= y
- s
->slice
.y
;
2217 xgcv
.function
= GXcopy
;
2218 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2220 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2221 s
->slice
.x
, s
->slice
.y
,
2222 s
->slice
.width
, s
->slice
.height
, x
, y
);
2223 XSetClipMask (s
->display
, s
->gc
, None
);
2227 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2228 s
->slice
.x
, s
->slice
.y
,
2229 s
->slice
.width
, s
->slice
.height
, x
, y
);
2231 /* When the image has a mask, we can expect that at
2232 least part of a mouse highlight or a block cursor will
2233 be visible. If the image doesn't have a mask, make
2234 a block cursor visible by drawing a rectangle around
2235 the image. I believe it's looking better if we do
2236 nothing here for mouse-face. */
2237 if (s
->hl
== DRAW_CURSOR
)
2239 int r
= eabs (s
->img
->relief
);
2240 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
- r
, y
- r
,
2241 s
->slice
.width
+ r
*2 - 1,
2242 s
->slice
.height
+ r
*2 - 1);
2247 /* Draw a rectangle if image could not be loaded. */
2248 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
2249 s
->slice
.width
- 1, s
->slice
.height
- 1);
2253 /* Draw part of the background of glyph string S. X, Y, W, and H
2254 give the rectangle to draw. */
2257 x_draw_glyph_string_bg_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
2261 /* Fill background with a stipple pattern. */
2262 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2263 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2264 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2267 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2271 /* Draw image glyph string S.
2274 s->x +-------------------------
2277 | +-------------------------
2280 | | +-------------------
2286 x_draw_image_glyph_string (struct glyph_string
*s
)
2288 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
2289 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2291 Pixmap pixmap
= None
;
2294 if (s
->slice
.y
== 0)
2295 height
-= box_line_vwidth
;
2296 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
2297 height
-= box_line_vwidth
;
2299 /* Fill background with face under the image. Do it only if row is
2300 taller than image or if image has a clip mask to reduce
2302 s
->stippled_p
= s
->face
->stipple
!= 0;
2303 if (height
> s
->slice
.height
2307 || s
->img
->pixmap
== 0
2308 || s
->width
!= s
->background_width
)
2312 /* Create a pixmap as large as the glyph string. Fill it
2313 with the background color. Copy the image to it, using
2314 its mask. Copy the temporary pixmap to the display. */
2315 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2316 int depth
= DefaultDepthOfScreen (screen
);
2318 /* Create a pixmap as large as the glyph string. */
2319 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2320 s
->background_width
,
2323 /* Don't clip in the following because we're working on the
2325 XSetClipMask (s
->display
, s
->gc
, None
);
2327 /* Fill the pixmap with the background color/stipple. */
2330 /* Fill background with a stipple pattern. */
2331 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2332 XSetTSOrigin (s
->display
, s
->gc
, - s
->x
, - s
->y
);
2333 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2334 0, 0, s
->background_width
, s
->height
);
2335 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2336 XSetTSOrigin (s
->display
, s
->gc
, 0, 0);
2341 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2343 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2344 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2345 0, 0, s
->background_width
, s
->height
);
2346 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2354 if (s
->first_glyph
->left_box_line_p
2356 x
+= box_line_hwidth
;
2358 if (s
->slice
.y
== 0)
2359 y
+= box_line_vwidth
;
2361 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
2364 s
->background_filled_p
= 1;
2367 /* Draw the foreground. */
2370 x_draw_image_foreground_1 (s
, pixmap
);
2371 x_set_glyph_string_clipping (s
);
2372 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
2373 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
2374 XFreePixmap (s
->display
, pixmap
);
2377 x_draw_image_foreground (s
);
2379 /* If we must draw a relief around the image, do it. */
2381 || s
->hl
== DRAW_IMAGE_RAISED
2382 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2383 x_draw_image_relief (s
);
2387 /* Draw stretch glyph string S. */
2390 x_draw_stretch_glyph_string (struct glyph_string
*s
)
2392 eassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2394 if (s
->hl
== DRAW_CURSOR
2395 && !x_stretch_cursor_p
)
2397 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
2398 wide as the stretch glyph. */
2399 int width
, background_width
= s
->background_width
;
2402 if (!s
->row
->reversed_p
)
2404 int left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2408 background_width
-= left_x
- x
;
2414 /* In R2L rows, draw the cursor on the right edge of the
2416 int right_x
= window_box_right_offset (s
->w
, TEXT_AREA
);
2418 if (x
+ background_width
> right_x
)
2419 background_width
-= x
- right_x
;
2420 x
+= background_width
;
2422 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
2423 if (s
->row
->reversed_p
)
2427 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
2429 /* Clear rest using the GC of the original non-cursor face. */
2430 if (width
< background_width
)
2433 int w
= background_width
- width
, h
= s
->height
;
2437 if (!s
->row
->reversed_p
)
2441 if (s
->row
->mouse_face_p
2442 && cursor_in_mouse_face_p (s
->w
))
2444 x_set_mouse_face_gc (s
);
2450 get_glyph_string_clip_rect (s
, &r
);
2451 XSetClipRectangles (s
->display
, gc
, 0, 0, &r
, 1, Unsorted
);
2453 if (s
->face
->stipple
)
2455 /* Fill background with a stipple pattern. */
2456 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2457 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2458 XSetFillStyle (s
->display
, gc
, FillSolid
);
2463 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
2464 XSetForeground (s
->display
, gc
, xgcv
.background
);
2465 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2466 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
2470 else if (!s
->background_filled_p
)
2472 int background_width
= s
->background_width
;
2473 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2475 /* Don't draw into left margin, fringe or scrollbar area
2476 except for header line and mode line. */
2477 if (x
< left_x
&& !s
->row
->mode_line_p
)
2479 background_width
-= left_x
- x
;
2482 if (background_width
> 0)
2483 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2486 s
->background_filled_p
= 1;
2490 Draw a wavy line under S. The wave fills wave_height pixels from y0.
2496 wave_height = 3 | * * * *
2501 x_draw_underwave (struct glyph_string
*s
)
2503 int wave_height
= 3, wave_length
= 2;
2504 int dx
, dy
, x0
, y0
, width
, x1
, y1
, x2
, y2
, odd
, xmax
;
2505 XRectangle wave_clip
, string_clip
, final_clip
;
2508 dy
= wave_height
- 1;
2510 y0
= s
->ybase
- wave_height
+ 3;
2514 /* Find and set clipping rectangle */
2518 wave_clip
.width
= width
;
2519 wave_clip
.height
= wave_height
;
2520 get_glyph_string_clip_rect (s
, &string_clip
);
2522 if (!x_intersect_rectangles (&wave_clip
, &string_clip
, &final_clip
))
2525 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, &final_clip
, 1, Unsorted
);
2527 /* Draw the waves */
2529 x1
= x0
- (x0
% dx
);
2539 if (INT_MAX
- dx
< xmax
)
2544 XDrawLine (s
->display
, s
->window
, s
->gc
, x1
, y1
, x2
, y2
);
2546 x2
+= dx
, y2
= y0
+ odd
*dy
;
2550 /* Restore previous clipping rectangle(s) */
2551 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, s
->clip
, s
->num_clips
, Unsorted
);
2555 /* Draw glyph string S. */
2558 x_draw_glyph_string (struct glyph_string
*s
)
2560 bool relief_drawn_p
= 0;
2562 /* If S draws into the background of its successors, draw the
2563 background of the successors first so that S can draw into it.
2564 This makes S->next use XDrawString instead of XDrawImageString. */
2565 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2568 struct glyph_string
*next
;
2570 for (width
= 0, next
= s
->next
;
2571 next
&& width
< s
->right_overhang
;
2572 width
+= next
->width
, next
= next
->next
)
2573 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
2575 x_set_glyph_string_gc (next
);
2576 x_set_glyph_string_clipping (next
);
2577 if (next
->first_glyph
->type
== STRETCH_GLYPH
)
2578 x_draw_stretch_glyph_string (next
);
2580 x_draw_glyph_string_background (next
, 1);
2581 next
->num_clips
= 0;
2585 /* Set up S->gc, set clipping and draw S. */
2586 x_set_glyph_string_gc (s
);
2588 /* Draw relief (if any) in advance for char/composition so that the
2589 glyph string can be drawn over it. */
2590 if (!s
->for_overlaps
2591 && s
->face
->box
!= FACE_NO_BOX
2592 && (s
->first_glyph
->type
== CHAR_GLYPH
2593 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2596 x_set_glyph_string_clipping (s
);
2597 x_draw_glyph_string_background (s
, 1);
2598 x_draw_glyph_string_box (s
);
2599 x_set_glyph_string_clipping (s
);
2602 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
2604 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2605 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
2606 /* We must clip just this glyph. left_overhang part has already
2607 drawn when s->prev was drawn, and right_overhang part will be
2608 drawn later when s->next is drawn. */
2609 x_set_glyph_string_clipping_exactly (s
, s
);
2611 x_set_glyph_string_clipping (s
);
2613 switch (s
->first_glyph
->type
)
2616 x_draw_image_glyph_string (s
);
2620 x_draw_stretch_glyph_string (s
);
2624 if (s
->for_overlaps
)
2625 s
->background_filled_p
= 1;
2627 x_draw_glyph_string_background (s
, 0);
2628 x_draw_glyph_string_foreground (s
);
2631 case COMPOSITE_GLYPH
:
2632 if (s
->for_overlaps
|| (s
->cmp_from
> 0
2633 && ! s
->first_glyph
->u
.cmp
.automatic
))
2634 s
->background_filled_p
= 1;
2636 x_draw_glyph_string_background (s
, 1);
2637 x_draw_composite_glyph_string_foreground (s
);
2640 case GLYPHLESS_GLYPH
:
2641 if (s
->for_overlaps
)
2642 s
->background_filled_p
= 1;
2644 x_draw_glyph_string_background (s
, 1);
2645 x_draw_glyphless_glyph_string_foreground (s
);
2652 if (!s
->for_overlaps
)
2654 /* Draw underline. */
2655 if (s
->face
->underline_p
)
2657 if (s
->face
->underline_type
== FACE_UNDER_WAVE
)
2659 if (s
->face
->underline_defaulted_p
)
2660 x_draw_underwave (s
);
2664 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2665 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
2666 x_draw_underwave (s
);
2667 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2670 else if (s
->face
->underline_type
== FACE_UNDER_LINE
)
2672 unsigned long thickness
, position
;
2675 if (s
->prev
&& s
->prev
->face
->underline_p
2676 && s
->prev
->face
->underline_type
== FACE_UNDER_LINE
)
2678 /* We use the same underline style as the previous one. */
2679 thickness
= s
->prev
->underline_thickness
;
2680 position
= s
->prev
->underline_position
;
2684 /* Get the underline thickness. Default is 1 pixel. */
2685 if (s
->font
&& s
->font
->underline_thickness
> 0)
2686 thickness
= s
->font
->underline_thickness
;
2689 if (x_underline_at_descent_line
)
2690 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
2693 /* Get the underline position. This is the recommended
2694 vertical offset in pixels from the baseline to the top of
2695 the underline. This is a signed value according to the
2696 specs, and its default is
2698 ROUND ((maximum descent) / 2), with
2699 ROUND(x) = floor (x + 0.5) */
2701 if (x_use_underline_position_properties
2702 && s
->font
&& s
->font
->underline_position
>= 0)
2703 position
= s
->font
->underline_position
;
2705 position
= (s
->font
->descent
+ 1) / 2;
2707 position
= underline_minimum_offset
;
2709 position
= max (position
, underline_minimum_offset
);
2711 /* Check the sanity of thickness and position. We should
2712 avoid drawing underline out of the current line area. */
2713 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
2714 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
2715 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
2716 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
2717 s
->underline_thickness
= thickness
;
2718 s
->underline_position
= position
;
2719 y
= s
->ybase
+ position
;
2720 if (s
->face
->underline_defaulted_p
)
2721 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2722 s
->x
, y
, s
->width
, thickness
);
2726 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2727 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
2728 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2729 s
->x
, y
, s
->width
, thickness
);
2730 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2734 /* Draw overline. */
2735 if (s
->face
->overline_p
)
2737 unsigned long dy
= 0, h
= 1;
2739 if (s
->face
->overline_color_defaulted_p
)
2740 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2745 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2746 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
2747 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2749 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2753 /* Draw strike-through. */
2754 if (s
->face
->strike_through_p
)
2756 unsigned long h
= 1;
2757 unsigned long dy
= (s
->height
- h
) / 2;
2759 if (s
->face
->strike_through_color_defaulted_p
)
2760 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2765 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2766 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
2767 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2769 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2773 /* Draw relief if not yet drawn. */
2774 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2775 x_draw_glyph_string_box (s
);
2779 struct glyph_string
*prev
;
2781 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2782 if (prev
->hl
!= s
->hl
2783 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2785 /* As prev was drawn while clipped to its own area, we
2786 must draw the right_overhang part using s->hl now. */
2787 enum draw_glyphs_face save
= prev
->hl
;
2790 x_set_glyph_string_gc (prev
);
2791 x_set_glyph_string_clipping_exactly (s
, prev
);
2792 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2793 x_draw_glyph_string_foreground (prev
);
2795 x_draw_composite_glyph_string_foreground (prev
);
2796 XSetClipMask (prev
->display
, prev
->gc
, None
);
2798 prev
->num_clips
= 0;
2804 struct glyph_string
*next
;
2806 for (next
= s
->next
; next
; next
= next
->next
)
2807 if (next
->hl
!= s
->hl
2808 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
2810 /* As next will be drawn while clipped to its own area,
2811 we must draw the left_overhang part using s->hl now. */
2812 enum draw_glyphs_face save
= next
->hl
;
2815 x_set_glyph_string_gc (next
);
2816 x_set_glyph_string_clipping_exactly (s
, next
);
2817 if (next
->first_glyph
->type
== CHAR_GLYPH
)
2818 x_draw_glyph_string_foreground (next
);
2820 x_draw_composite_glyph_string_foreground (next
);
2821 XSetClipMask (next
->display
, next
->gc
, None
);
2823 next
->num_clips
= 0;
2824 next
->clip_head
= s
->next
;
2829 /* Reset clipping. */
2830 XSetClipMask (s
->display
, s
->gc
, None
);
2834 /* Shift display to make room for inserted glyphs. */
2837 x_shift_glyphs_for_insert (struct frame
*f
, int x
, int y
, int width
, int height
, int shift_by
)
2839 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
2840 f
->output_data
.x
->normal_gc
,
2841 x
, y
, width
, height
,
2845 /* Delete N glyphs at the nominal cursor position. Not implemented
2849 x_delete_glyphs (struct frame
*f
, register int n
)
2855 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
2856 If they are <= 0, this is probably an error. */
2859 x_clear_area (Display
*dpy
, Window window
, int x
, int y
, int width
, int height
)
2861 eassert (width
> 0 && height
> 0);
2862 XClearArea (dpy
, window
, x
, y
, width
, height
, False
);
2866 /* Clear an entire frame. */
2869 x_clear_frame (struct frame
*f
)
2871 /* Clearing the frame will erase any cursor, so mark them all as no
2873 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2877 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
2879 /* We have to clear the scroll bars. If we have changed colors or
2880 something like that, then they should be notified. */
2881 x_scroll_bar_clear (f
);
2883 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
2884 /* Make sure scroll bars are redrawn. As they aren't redrawn by
2885 redisplay, do it here. */
2886 if (FRAME_GTK_WIDGET (f
))
2887 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
2890 XFlush (FRAME_X_DISPLAY (f
));
2897 /* Invert the middle quarter of the frame for .15 sec. */
2900 XTflash (struct frame
*f
)
2906 /* Use Gdk routines to draw. This way, we won't draw over scroll bars
2907 when the scroll bars and the edit widget share the same X window. */
2908 GdkWindow
*window
= gtk_widget_get_window (FRAME_GTK_WIDGET (f
));
2910 cairo_t
*cr
= gdk_cairo_create (window
);
2911 cairo_set_source_rgb (cr
, 1, 1, 1);
2912 cairo_set_operator (cr
, CAIRO_OPERATOR_DIFFERENCE
);
2913 #define XFillRectangle(d, win, gc, x, y, w, h) \
2915 cairo_rectangle (cr, x, y, w, h); \
2919 #else /* ! HAVE_GTK3 */
2922 vals
.foreground
.pixel
= (FRAME_FOREGROUND_PIXEL (f
)
2923 ^ FRAME_BACKGROUND_PIXEL (f
));
2924 vals
.function
= GDK_XOR
;
2925 gc
= gdk_gc_new_with_values (window
,
2926 &vals
, GDK_GC_FUNCTION
| GDK_GC_FOREGROUND
);
2927 #define XFillRectangle(d, win, gc, x, y, w, h) \
2928 gdk_draw_rectangle (window, gc, TRUE, x, y, w, h)
2929 #endif /* ! HAVE_GTK3 */
2930 #else /* ! USE_GTK */
2933 /* Create a GC that will use the GXxor function to flip foreground
2934 pixels into background pixels. */
2938 values
.function
= GXxor
;
2939 values
.foreground
= (FRAME_FOREGROUND_PIXEL (f
)
2940 ^ FRAME_BACKGROUND_PIXEL (f
));
2942 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2943 GCFunction
| GCForeground
, &values
);
2947 /* Get the height not including a menu bar widget. */
2948 int height
= FRAME_PIXEL_HEIGHT (f
);
2949 /* Height of each line to flash. */
2950 int flash_height
= FRAME_LINE_HEIGHT (f
);
2951 /* These will be the left and right margins of the rectangles. */
2952 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
2953 int flash_right
= FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
2954 int width
= flash_right
- flash_left
;
2956 /* If window is tall, flash top and bottom line. */
2957 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
2959 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2961 (FRAME_INTERNAL_BORDER_WIDTH (f
)
2962 + FRAME_TOP_MARGIN_HEIGHT (f
)),
2963 width
, flash_height
);
2964 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2966 (height
- flash_height
2967 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
2968 width
, flash_height
);
2972 /* If it is short, flash it all. */
2973 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2974 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
2975 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
2980 struct timespec delay
= make_timespec (0, 150 * 1000 * 1000);
2981 struct timespec wakeup
= timespec_add (current_timespec (), delay
);
2983 /* Keep waiting until past the time wakeup or any input gets
2985 while (! detect_input_pending ())
2987 struct timespec current
= current_timespec ();
2988 struct timespec timeout
;
2990 /* Break if result would not be positive. */
2991 if (timespec_cmp (wakeup
, current
) <= 0)
2994 /* How long `select' should wait. */
2995 timeout
= make_timespec (0, 10 * 1000 * 1000);
2997 /* Try to wait that long--but we might wake up sooner. */
2998 pselect (0, NULL
, NULL
, NULL
, &timeout
, NULL
);
3002 /* If window is tall, flash top and bottom line. */
3003 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3005 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3007 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3008 + FRAME_TOP_MARGIN_HEIGHT (f
)),
3009 width
, flash_height
);
3010 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3012 (height
- flash_height
3013 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3014 width
, flash_height
);
3017 /* If it is short, flash it all. */
3018 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3019 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3020 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3026 g_object_unref (G_OBJECT (gc
));
3028 #undef XFillRectangle
3030 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
3041 XTtoggle_invisible_pointer (struct frame
*f
, int invisible
)
3046 if (FRAME_DISPLAY_INFO (f
)->invisible_cursor
!= 0)
3047 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3048 FRAME_DISPLAY_INFO (f
)->invisible_cursor
);
3051 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3052 f
->output_data
.x
->current_cursor
);
3053 f
->pointer_invisible
= invisible
;
3058 /* Make audible bell. */
3061 XTring_bell (struct frame
*f
)
3063 if (FRAME_X_DISPLAY (f
))
3071 XkbBell (FRAME_X_DISPLAY (f
), None
, 0, None
);
3073 XBell (FRAME_X_DISPLAY (f
), 0);
3075 XFlush (FRAME_X_DISPLAY (f
));
3081 /***********************************************************************
3083 ***********************************************************************/
3085 /* Perform an insert-lines or delete-lines operation, inserting N
3086 lines or deleting -N lines at vertical position VPOS. */
3089 x_ins_del_lines (struct frame
*f
, int vpos
, int n
)
3095 /* Scroll part of the display as described by RUN. */
3098 x_scroll_run (struct window
*w
, struct run
*run
)
3100 struct frame
*f
= XFRAME (w
->frame
);
3101 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
3103 /* Get frame-relative bounding box of the text display area of W,
3104 without mode lines. Include in this box the left and right
3106 window_box (w
, ANY_AREA
, &x
, &y
, &width
, &height
);
3108 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
3109 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
3110 bottom_y
= y
+ height
;
3114 /* Scrolling up. Make sure we don't copy part of the mode
3115 line at the bottom. */
3116 if (from_y
+ run
->height
> bottom_y
)
3117 height
= bottom_y
- from_y
;
3119 height
= run
->height
;
3123 /* Scrolling down. Make sure we don't copy over the mode line.
3125 if (to_y
+ run
->height
> bottom_y
)
3126 height
= bottom_y
- to_y
;
3128 height
= run
->height
;
3133 /* Cursor off. Will be switched on again in x_update_window_end. */
3136 XCopyArea (FRAME_X_DISPLAY (f
),
3137 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
3138 f
->output_data
.x
->normal_gc
,
3148 /***********************************************************************
3150 ***********************************************************************/
3154 frame_highlight (struct frame
*f
)
3156 /* We used to only do this if Vx_no_window_manager was non-nil, but
3157 the ICCCM (section 4.1.6) says that the window's border pixmap
3158 and border pixel are window attributes which are "private to the
3159 client", so we can always change it to whatever we want. */
3161 /* I recently started to get errors in this XSetWindowBorder, depending on
3162 the window-manager in use, tho something more is at play since I've been
3163 using that same window-manager binary for ever. Let's not crash just
3164 because of this (bug#9310). */
3165 x_catch_errors (FRAME_X_DISPLAY (f
));
3166 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3167 f
->output_data
.x
->border_pixel
);
3168 x_uncatch_errors ();
3170 x_update_cursor (f
, 1);
3171 x_set_frame_alpha (f
);
3175 frame_unhighlight (struct frame
*f
)
3177 /* We used to only do this if Vx_no_window_manager was non-nil, but
3178 the ICCCM (section 4.1.6) says that the window's border pixmap
3179 and border pixel are window attributes which are "private to the
3180 client", so we can always change it to whatever we want. */
3182 /* Same as above for XSetWindowBorder (bug#9310). */
3183 x_catch_errors (FRAME_X_DISPLAY (f
));
3184 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3185 f
->output_data
.x
->border_tile
);
3186 x_uncatch_errors ();
3188 x_update_cursor (f
, 1);
3189 x_set_frame_alpha (f
);
3192 /* The focus has changed. Update the frames as necessary to reflect
3193 the new situation. Note that we can't change the selected frame
3194 here, because the Lisp code we are interrupting might become confused.
3195 Each event gets marked with the frame in which it occurred, so the
3196 Lisp code can tell when the switch took place by examining the events. */
3199 x_new_focus_frame (struct x_display_info
*dpyinfo
, struct frame
*frame
)
3201 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
3203 if (frame
!= dpyinfo
->x_focus_frame
)
3205 /* Set this before calling other routines, so that they see
3206 the correct value of x_focus_frame. */
3207 dpyinfo
->x_focus_frame
= frame
;
3209 if (old_focus
&& old_focus
->auto_lower
)
3210 x_lower_frame (old_focus
);
3212 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
3213 dpyinfo
->x_pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
3215 dpyinfo
->x_pending_autoraise_frame
= NULL
;
3218 x_frame_rehighlight (dpyinfo
);
3221 /* Handle FocusIn and FocusOut state changes for FRAME.
3222 If FRAME has focus and there exists more than one frame, puts
3223 a FOCUS_IN_EVENT into *BUFP. */
3226 x_focus_changed (int type
, int state
, struct x_display_info
*dpyinfo
, struct frame
*frame
, struct input_event
*bufp
)
3228 if (type
== FocusIn
)
3230 if (dpyinfo
->x_focus_event_frame
!= frame
)
3232 x_new_focus_frame (dpyinfo
, frame
);
3233 dpyinfo
->x_focus_event_frame
= frame
;
3235 /* Don't stop displaying the initial startup message
3236 for a switch-frame event we don't need. */
3237 /* When run as a daemon, Vterminal_frame is always NIL. */
3238 bufp
->arg
= (((NILP (Vterminal_frame
)
3239 || ! FRAME_X_P (XFRAME (Vterminal_frame
))
3240 || EQ (Fdaemonp (), Qt
))
3241 && CONSP (Vframe_list
)
3242 && !NILP (XCDR (Vframe_list
)))
3244 bufp
->kind
= FOCUS_IN_EVENT
;
3245 XSETFRAME (bufp
->frame_or_window
, frame
);
3248 frame
->output_data
.x
->focus_state
|= state
;
3251 if (FRAME_XIC (frame
))
3252 XSetICFocus (FRAME_XIC (frame
));
3255 else if (type
== FocusOut
)
3257 frame
->output_data
.x
->focus_state
&= ~state
;
3259 if (dpyinfo
->x_focus_event_frame
== frame
)
3261 dpyinfo
->x_focus_event_frame
= 0;
3262 x_new_focus_frame (dpyinfo
, 0);
3264 bufp
->kind
= FOCUS_OUT_EVENT
;
3265 XSETFRAME (bufp
->frame_or_window
, frame
);
3269 if (FRAME_XIC (frame
))
3270 XUnsetICFocus (FRAME_XIC (frame
));
3272 if (frame
->pointer_invisible
)
3273 XTtoggle_invisible_pointer (frame
, 0);
3277 /* Return the Emacs frame-object corresponding to an X window.
3278 It could be the frame's main window or an icon window. */
3280 static struct frame
*
3281 x_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
3283 Lisp_Object tail
, frame
;
3289 FOR_EACH_FRAME (tail
, frame
)
3292 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
3294 if (f
->output_data
.x
->hourglass_window
== wdesc
)
3296 #ifdef USE_X_TOOLKIT
3297 if ((f
->output_data
.x
->edit_widget
3298 && XtWindow (f
->output_data
.x
->edit_widget
) == wdesc
)
3299 /* A tooltip frame? */
3300 || (!f
->output_data
.x
->edit_widget
3301 && FRAME_X_WINDOW (f
) == wdesc
)
3302 || f
->output_data
.x
->icon_desc
== wdesc
)
3304 #else /* not USE_X_TOOLKIT */
3306 if (f
->output_data
.x
->edit_widget
)
3308 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
3309 struct x_output
*x
= f
->output_data
.x
;
3310 if (gwdesc
!= 0 && gwdesc
== x
->edit_widget
)
3313 #endif /* USE_GTK */
3314 if (FRAME_X_WINDOW (f
) == wdesc
3315 || f
->output_data
.x
->icon_desc
== wdesc
)
3317 #endif /* not USE_X_TOOLKIT */
3322 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
3324 /* Like x_window_to_frame but also compares the window with the widget's
3327 static struct frame
*
3328 x_any_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
3330 Lisp_Object tail
, frame
;
3331 struct frame
*f
, *found
= NULL
;
3337 FOR_EACH_FRAME (tail
, frame
)
3342 if (FRAME_X_P (f
) && FRAME_DISPLAY_INFO (f
) == dpyinfo
)
3344 /* This frame matches if the window is any of its widgets. */
3345 x
= f
->output_data
.x
;
3346 if (x
->hourglass_window
== wdesc
)
3351 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
3353 && gtk_widget_get_toplevel (gwdesc
) == x
->widget
)
3356 if (wdesc
== XtWindow (x
->widget
)
3357 || wdesc
== XtWindow (x
->column_widget
)
3358 || wdesc
== XtWindow (x
->edit_widget
))
3360 /* Match if the window is this frame's menubar. */
3361 else if (lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
3365 else if (FRAME_X_WINDOW (f
) == wdesc
)
3366 /* A tooltip frame. */
3374 /* Likewise, but consider only the menu bar widget. */
3376 static struct frame
*
3377 x_menubar_window_to_frame (struct x_display_info
*dpyinfo
,
3378 const XEvent
*event
)
3380 Window wdesc
= event
->xany
.window
;
3381 Lisp_Object tail
, frame
;
3388 FOR_EACH_FRAME (tail
, frame
)
3391 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
3393 x
= f
->output_data
.x
;
3395 if (x
->menubar_widget
&& xg_event_is_for_menubar (f
, event
))
3398 /* Match if the window is this frame's menubar. */
3399 if (x
->menubar_widget
3400 && lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
3407 /* Return the frame whose principal (outermost) window is WDESC.
3408 If WDESC is some other (smaller) window, we return 0. */
3411 x_top_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
3413 Lisp_Object tail
, frame
;
3420 FOR_EACH_FRAME (tail
, frame
)
3423 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
3425 x
= f
->output_data
.x
;
3429 /* This frame matches if the window is its topmost widget. */
3431 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
3432 if (gwdesc
== x
->widget
)
3435 if (wdesc
== XtWindow (x
->widget
))
3439 else if (FRAME_X_WINDOW (f
) == wdesc
)
3440 /* Tooltip frame. */
3446 #else /* !USE_X_TOOLKIT && !USE_GTK */
3448 #define x_any_window_to_frame(d, i) x_window_to_frame (d, i)
3449 #define x_top_window_to_frame(d, i) x_window_to_frame (d, i)
3451 #endif /* USE_X_TOOLKIT || USE_GTK */
3453 /* The focus may have changed. Figure out if it is a real focus change,
3454 by checking both FocusIn/Out and Enter/LeaveNotify events.
3456 Returns FOCUS_IN_EVENT event in *BUFP. */
3459 x_detect_focus_change (struct x_display_info
*dpyinfo
, struct frame
*frame
,
3460 const XEvent
*event
, struct input_event
*bufp
)
3465 switch (event
->type
)
3470 struct frame
*focus_frame
= dpyinfo
->x_focus_event_frame
;
3472 = focus_frame
? focus_frame
->output_data
.x
->focus_state
: 0;
3474 if (event
->xcrossing
.detail
!= NotifyInferior
3475 && event
->xcrossing
.focus
3476 && ! (focus_state
& FOCUS_EXPLICIT
))
3477 x_focus_changed ((event
->type
== EnterNotify
? FocusIn
: FocusOut
),
3479 dpyinfo
, frame
, bufp
);
3485 x_focus_changed (event
->type
,
3486 (event
->xfocus
.detail
== NotifyPointer
?
3487 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
3488 dpyinfo
, frame
, bufp
);
3492 if (event
->xclient
.message_type
== dpyinfo
->Xatom_XEMBED
)
3494 enum xembed_message msg
= event
->xclient
.data
.l
[1];
3495 x_focus_changed ((msg
== XEMBED_FOCUS_IN
? FocusIn
: FocusOut
),
3496 FOCUS_EXPLICIT
, dpyinfo
, frame
, bufp
);
3503 #if !defined USE_X_TOOLKIT && !defined USE_GTK
3504 /* Handle an event saying the mouse has moved out of an Emacs frame. */
3507 x_mouse_leave (struct x_display_info
*dpyinfo
)
3509 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
3513 /* The focus has changed, or we have redirected a frame's focus to
3514 another frame (this happens when a frame uses a surrogate
3515 mini-buffer frame). Shift the highlight as appropriate.
3517 The FRAME argument doesn't necessarily have anything to do with which
3518 frame is being highlighted or un-highlighted; we only use it to find
3519 the appropriate X display info. */
3522 XTframe_rehighlight (struct frame
*frame
)
3524 x_frame_rehighlight (FRAME_DISPLAY_INFO (frame
));
3528 x_frame_rehighlight (struct x_display_info
*dpyinfo
)
3530 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
3532 if (dpyinfo
->x_focus_frame
)
3534 dpyinfo
->x_highlight_frame
3535 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
3536 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
3537 : dpyinfo
->x_focus_frame
);
3538 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
3540 fset_focus_frame (dpyinfo
->x_focus_frame
, Qnil
);
3541 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
3545 dpyinfo
->x_highlight_frame
= 0;
3547 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
3550 frame_unhighlight (old_highlight
);
3551 if (dpyinfo
->x_highlight_frame
)
3552 frame_highlight (dpyinfo
->x_highlight_frame
);
3558 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
3560 /* Initialize mode_switch_bit and modifier_meaning. */
3562 x_find_modifier_meanings (struct x_display_info
*dpyinfo
)
3564 int min_code
, max_code
;
3567 XModifierKeymap
*mods
;
3569 dpyinfo
->meta_mod_mask
= 0;
3570 dpyinfo
->shift_lock_mask
= 0;
3571 dpyinfo
->alt_mod_mask
= 0;
3572 dpyinfo
->super_mod_mask
= 0;
3573 dpyinfo
->hyper_mod_mask
= 0;
3575 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
3577 syms
= XGetKeyboardMapping (dpyinfo
->display
,
3578 min_code
, max_code
- min_code
+ 1,
3580 mods
= XGetModifierMapping (dpyinfo
->display
);
3582 /* Scan the modifier table to see which modifier bits the Meta and
3583 Alt keysyms are on. */
3585 int row
, col
; /* The row and column in the modifier table. */
3586 int found_alt_or_meta
;
3588 for (row
= 3; row
< 8; row
++)
3590 found_alt_or_meta
= 0;
3591 for (col
= 0; col
< mods
->max_keypermod
; col
++)
3593 KeyCode code
= mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
3595 /* Zeroes are used for filler. Skip them. */
3599 /* Are any of this keycode's keysyms a meta key? */
3603 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
3605 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
3611 found_alt_or_meta
= 1;
3612 dpyinfo
->meta_mod_mask
|= (1 << row
);
3617 found_alt_or_meta
= 1;
3618 dpyinfo
->alt_mod_mask
|= (1 << row
);
3623 if (!found_alt_or_meta
)
3624 dpyinfo
->hyper_mod_mask
|= (1 << row
);
3625 code_col
= syms_per_code
;
3626 col
= mods
->max_keypermod
;
3631 if (!found_alt_or_meta
)
3632 dpyinfo
->super_mod_mask
|= (1 << row
);
3633 code_col
= syms_per_code
;
3634 col
= mods
->max_keypermod
;
3638 /* Ignore this if it's not on the lock modifier. */
3639 if (!found_alt_or_meta
&& ((1 << row
) == LockMask
))
3640 dpyinfo
->shift_lock_mask
= LockMask
;
3641 code_col
= syms_per_code
;
3642 col
= mods
->max_keypermod
;
3651 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
3652 if (! dpyinfo
->meta_mod_mask
)
3654 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
3655 dpyinfo
->alt_mod_mask
= 0;
3658 /* If some keys are both alt and meta,
3659 make them just meta, not alt. */
3660 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
3662 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
3666 XFreeModifiermap (mods
);
3669 /* Convert between the modifier bits X uses and the modifier bits
3673 x_x_to_emacs_modifiers (struct x_display_info
*dpyinfo
, int state
)
3675 int mod_meta
= meta_modifier
;
3676 int mod_alt
= alt_modifier
;
3677 int mod_hyper
= hyper_modifier
;
3678 int mod_super
= super_modifier
;
3681 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3682 if (INTEGERP (tem
)) mod_alt
= XINT (tem
) & INT_MAX
;
3683 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3684 if (INTEGERP (tem
)) mod_meta
= XINT (tem
) & INT_MAX
;
3685 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3686 if (INTEGERP (tem
)) mod_hyper
= XINT (tem
) & INT_MAX
;
3687 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3688 if (INTEGERP (tem
)) mod_super
= XINT (tem
) & INT_MAX
;
3690 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
3691 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
3692 | ((state
& dpyinfo
->meta_mod_mask
) ? mod_meta
: 0)
3693 | ((state
& dpyinfo
->alt_mod_mask
) ? mod_alt
: 0)
3694 | ((state
& dpyinfo
->super_mod_mask
) ? mod_super
: 0)
3695 | ((state
& dpyinfo
->hyper_mod_mask
) ? mod_hyper
: 0));
3699 x_emacs_to_x_modifiers (struct x_display_info
*dpyinfo
, EMACS_INT state
)
3701 EMACS_INT mod_meta
= meta_modifier
;
3702 EMACS_INT mod_alt
= alt_modifier
;
3703 EMACS_INT mod_hyper
= hyper_modifier
;
3704 EMACS_INT mod_super
= super_modifier
;
3708 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3709 if (INTEGERP (tem
)) mod_alt
= XINT (tem
);
3710 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3711 if (INTEGERP (tem
)) mod_meta
= XINT (tem
);
3712 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3713 if (INTEGERP (tem
)) mod_hyper
= XINT (tem
);
3714 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3715 if (INTEGERP (tem
)) mod_super
= XINT (tem
);
3718 return ( ((state
& mod_alt
) ? dpyinfo
->alt_mod_mask
: 0)
3719 | ((state
& mod_super
) ? dpyinfo
->super_mod_mask
: 0)
3720 | ((state
& mod_hyper
) ? dpyinfo
->hyper_mod_mask
: 0)
3721 | ((state
& shift_modifier
) ? ShiftMask
: 0)
3722 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
3723 | ((state
& mod_meta
) ? dpyinfo
->meta_mod_mask
: 0));
3726 /* Convert a keysym to its name. */
3729 x_get_keysym_name (int keysym
)
3734 value
= XKeysymToString (keysym
);
3740 /* Mouse clicks and mouse movement. Rah.
3742 Formerly, we used PointerMotionHintMask (in standard_event_mask)
3743 so that we would have to call XQueryPointer after each MotionNotify
3744 event to ask for another such event. However, this made mouse tracking
3745 slow, and there was a bug that made it eventually stop.
3747 Simply asking for MotionNotify all the time seems to work better.
3749 In order to avoid asking for motion events and then throwing most
3750 of them away or busy-polling the server for mouse positions, we ask
3751 the server for pointer motion hints. This means that we get only
3752 one event per group of mouse movements. "Groups" are delimited by
3753 other kinds of events (focus changes and button clicks, for
3754 example), or by XQueryPointer calls; when one of these happens, we
3755 get another MotionNotify event the next time the mouse moves. This
3756 is at least as efficient as getting motion events when mouse
3757 tracking is on, and I suspect only negligibly worse when tracking
3760 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3762 If the event is a button press, then note that we have grabbed
3766 construct_mouse_click (struct input_event
*result
,
3767 const XButtonEvent
*event
,
3770 /* Make the event type NO_EVENT; we'll change that when we decide
3772 result
->kind
= MOUSE_CLICK_EVENT
;
3773 result
->code
= event
->button
- Button1
;
3774 result
->timestamp
= event
->time
;
3775 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
),
3777 | (event
->type
== ButtonRelease
3781 XSETINT (result
->x
, event
->x
);
3782 XSETINT (result
->y
, event
->y
);
3783 XSETFRAME (result
->frame_or_window
, f
);
3788 /* Function to report a mouse movement to the mainstream Emacs code.
3789 The input handler calls this.
3791 We have received a mouse movement event, which is given in *event.
3792 If the mouse is over a different glyph than it was last time, tell
3793 the mainstream emacs code by setting mouse_moved. If not, ask for
3794 another motion event, so we can check again the next time it moves. */
3797 note_mouse_movement (struct frame
*frame
, const XMotionEvent
*event
)
3800 struct x_display_info
*dpyinfo
;
3802 if (!FRAME_X_OUTPUT (frame
))
3805 dpyinfo
= FRAME_DISPLAY_INFO (frame
);
3806 dpyinfo
->last_mouse_movement_time
= event
->time
;
3807 dpyinfo
->last_mouse_motion_frame
= frame
;
3808 dpyinfo
->last_mouse_motion_x
= event
->x
;
3809 dpyinfo
->last_mouse_motion_y
= event
->y
;
3811 if (event
->window
!= FRAME_X_WINDOW (frame
))
3813 frame
->mouse_moved
= 1;
3814 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3815 note_mouse_highlight (frame
, -1, -1);
3816 dpyinfo
->last_mouse_glyph_frame
= NULL
;
3821 /* Has the mouse moved off the glyph it was on at the last sighting? */
3822 r
= &dpyinfo
->last_mouse_glyph
;
3823 if (frame
!= dpyinfo
->last_mouse_glyph_frame
3824 || event
->x
< r
->x
|| event
->x
>= r
->x
+ r
->width
3825 || event
->y
< r
->y
|| event
->y
>= r
->y
+ r
->height
)
3827 frame
->mouse_moved
= 1;
3828 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3829 note_mouse_highlight (frame
, event
->x
, event
->y
);
3830 /* Remember which glyph we're now on. */
3831 remember_mouse_glyph (frame
, event
->x
, event
->y
, r
);
3832 dpyinfo
->last_mouse_glyph_frame
= frame
;
3839 /* Return the current position of the mouse.
3840 *FP should be a frame which indicates which display to ask about.
3842 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
3843 and *PART to the frame, window, and scroll bar part that the mouse
3844 is over. Set *X and *Y to the portion and whole of the mouse's
3845 position on the scroll bar.
3847 If the mouse movement started elsewhere, set *FP to the frame the
3848 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
3851 Set *TIMESTAMP to the server time-stamp for the time at which the mouse
3852 was at this position.
3854 Don't store anything if we don't have a valid set of values to report.
3856 This clears the mouse_moved flag, so we can wait for the next mouse
3860 XTmouse_position (struct frame
**fp
, int insist
, Lisp_Object
*bar_window
,
3861 enum scroll_bar_part
*part
, Lisp_Object
*x
, Lisp_Object
*y
,
3865 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
3869 if (dpyinfo
->last_mouse_scroll_bar
&& insist
== 0)
3870 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, timestamp
);
3876 Window dummy_window
;
3879 Lisp_Object frame
, tail
;
3881 /* Clear the mouse-moved flag for every frame on this display. */
3882 FOR_EACH_FRAME (tail
, frame
)
3883 if (FRAME_X_P (XFRAME (frame
))
3884 && FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
3885 XFRAME (frame
)->mouse_moved
= 0;
3887 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3889 /* Figure out which root window we're on. */
3890 XQueryPointer (FRAME_X_DISPLAY (*fp
),
3891 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
3893 /* The root window which contains the pointer. */
3896 /* Trash which we can't trust if the pointer is on
3897 a different screen. */
3900 /* The position on that root window. */
3903 /* More trash we can't trust. */
3906 /* Modifier keys and pointer buttons, about which
3908 (unsigned int *) &dummy
);
3910 /* Now we have a position on the root; find the innermost window
3911 containing the pointer. */
3915 int parent_x
= 0, parent_y
= 0;
3919 /* XTranslateCoordinates can get errors if the window
3920 structure is changing at the same time this function
3921 is running. So at least we must not crash from them. */
3923 x_catch_errors (FRAME_X_DISPLAY (*fp
));
3925 if (x_mouse_grabbed (dpyinfo
))
3927 /* If mouse was grabbed on a frame, give coords for that frame
3928 even if the mouse is now outside it. */
3929 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3935 FRAME_X_WINDOW (dpyinfo
->last_mouse_frame
),
3937 /* From-position, to-position. */
3938 root_x
, root_y
, &win_x
, &win_y
,
3942 f1
= dpyinfo
->last_mouse_frame
;
3948 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3950 /* From-window, to-window. */
3953 /* From-position, to-position. */
3954 root_x
, root_y
, &win_x
, &win_y
,
3959 if (child
== None
|| child
== win
)
3962 /* We don't wan't to know the innermost window. We
3963 want the edit window. For non-Gtk+ the innermost
3964 window is the edit window. For Gtk+ it might not
3965 be. It might be the tool bar for example. */
3966 if (x_window_to_frame (dpyinfo
, win
))
3974 /* Now we know that:
3975 win is the innermost window containing the pointer
3976 (XTC says it has no child containing the pointer),
3977 win_x and win_y are the pointer's position in it
3978 (XTC did this the last time through), and
3979 parent_x and parent_y are the pointer's position in win's parent.
3980 (They are what win_x and win_y were when win was child.
3981 If win is the root window, it has no parent, and
3982 parent_{x,y} are invalid, but that's okay, because we'll
3983 never use them in that case.) */
3986 /* We don't wan't to know the innermost window. We
3987 want the edit window. */
3988 f1
= x_window_to_frame (dpyinfo
, win
);
3990 /* Is win one of our frames? */
3991 f1
= x_any_window_to_frame (dpyinfo
, win
);
3994 #ifdef USE_X_TOOLKIT
3995 /* If we end up with the menu bar window, say it's not
3998 && f1
->output_data
.x
->menubar_widget
3999 && win
== XtWindow (f1
->output_data
.x
->menubar_widget
))
4001 #endif /* USE_X_TOOLKIT */
4004 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
4007 x_uncatch_errors ();
4009 /* If not, is it one of our scroll bars? */
4012 struct scroll_bar
*bar
;
4014 bar
= x_window_to_scroll_bar (FRAME_X_DISPLAY (*fp
), win
);
4018 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4024 if (f1
== 0 && insist
> 0)
4025 f1
= SELECTED_FRAME ();
4029 /* Ok, we found a frame. Store all the values.
4030 last_mouse_glyph is a rectangle used to reduce the
4031 generation of mouse events. To not miss any motion
4032 events, we must divide the frame into rectangles of the
4033 size of the smallest character that could be displayed
4034 on it, i.e. into the same rectangles that matrices on
4035 the frame are divided into. */
4037 /* FIXME: what if F1 is not an X frame? */
4038 dpyinfo
= FRAME_DISPLAY_INFO (f1
);
4039 remember_mouse_glyph (f1
, win_x
, win_y
, &dpyinfo
->last_mouse_glyph
);
4040 dpyinfo
->last_mouse_glyph_frame
= f1
;
4045 XSETINT (*x
, win_x
);
4046 XSETINT (*y
, win_y
);
4047 *timestamp
= dpyinfo
->last_mouse_movement_time
;
4057 /***********************************************************************
4059 ***********************************************************************/
4061 /* Scroll bar support. */
4063 /* Given an X window ID and a DISPLAY, find the struct scroll_bar which
4065 This can be called in GC, so we have to make sure to strip off mark
4068 static struct scroll_bar
*
4069 x_window_to_scroll_bar (Display
*display
, Window window_id
)
4071 Lisp_Object tail
, frame
;
4073 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
4074 window_id
= (Window
) xg_get_scroll_id_for_window (display
, window_id
);
4075 #endif /* USE_GTK && USE_TOOLKIT_SCROLL_BARS */
4077 FOR_EACH_FRAME (tail
, frame
)
4079 Lisp_Object bar
, condemned
;
4081 if (! FRAME_X_P (XFRAME (frame
)))
4084 /* Scan this frame's scroll bar list for a scroll bar with the
4086 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
4087 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
4088 /* This trick allows us to search both the ordinary and
4089 condemned scroll bar lists with one loop. */
4090 ! NILP (bar
) || (bar
= condemned
,
4093 bar
= XSCROLL_BAR (bar
)->next
)
4094 if (XSCROLL_BAR (bar
)->x_window
== window_id
&&
4095 FRAME_X_DISPLAY (XFRAME (frame
)) == display
)
4096 return XSCROLL_BAR (bar
);
4103 #if defined USE_LUCID
4105 /* Return the Lucid menu bar WINDOW is part of. Return null
4106 if WINDOW is not part of a menu bar. */
4109 x_window_to_menu_bar (Window window
)
4111 Lisp_Object tail
, frame
;
4113 FOR_EACH_FRAME (tail
, frame
)
4114 if (FRAME_X_P (XFRAME (frame
)))
4116 Widget menu_bar
= XFRAME (frame
)->output_data
.x
->menubar_widget
;
4118 if (menu_bar
&& xlwmenu_window_p (menu_bar
, window
))
4124 #endif /* USE_LUCID */
4127 /************************************************************************
4129 ************************************************************************/
4131 #ifdef USE_TOOLKIT_SCROLL_BARS
4133 static void x_send_scroll_bar_event (Lisp_Object
, int, int, int);
4135 /* Lisp window being scrolled. Set when starting to interact with
4136 a toolkit scroll bar, reset to nil when ending the interaction. */
4138 static Lisp_Object window_being_scrolled
;
4140 /* Whether this is an Xaw with arrow-scrollbars. This should imply
4141 that movements of 1/20 of the screen size are mapped to up/down. */
4144 /* Id of action hook installed for scroll bars. */
4146 static XtActionHookId action_hook_id
;
4148 static Boolean xaw3d_arrow_scroll
;
4150 /* Whether the drag scrolling maintains the mouse at the top of the
4151 thumb. If not, resizing the thumb needs to be done more carefully
4152 to avoid jerkiness. */
4154 static Boolean xaw3d_pick_top
;
4156 /* Action hook installed via XtAppAddActionHook when toolkit scroll
4157 bars are used.. The hook is responsible for detecting when
4158 the user ends an interaction with the scroll bar, and generates
4159 a `end-scroll' SCROLL_BAR_CLICK_EVENT' event if so. */
4162 xt_action_hook (Widget widget
, XtPointer client_data
, String action_name
,
4163 XEvent
*event
, String
*params
, Cardinal
*num_params
)
4166 const char *end_action
;
4169 scroll_bar_p
= XmIsScrollBar (widget
);
4170 end_action
= "Release";
4171 #else /* !USE_MOTIF i.e. use Xaw */
4172 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
4173 end_action
= "EndScroll";
4174 #endif /* USE_MOTIF */
4177 && strcmp (action_name
, end_action
) == 0
4178 && WINDOWP (window_being_scrolled
))
4181 struct scroll_bar
*bar
;
4183 x_send_scroll_bar_event (window_being_scrolled
,
4184 scroll_bar_end_scroll
, 0, 0);
4185 w
= XWINDOW (window_being_scrolled
);
4186 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
4188 if (bar
->dragging
!= -1)
4191 /* The thumb size is incorrect while dragging: fix it. */
4192 set_vertical_scroll_bar (w
);
4194 window_being_scrolled
= Qnil
;
4195 #if defined (USE_LUCID)
4196 bar
->last_seen_part
= scroll_bar_nowhere
;
4198 /* Xt timeouts no longer needed. */
4199 toolkit_scroll_bar_interaction
= 0;
4202 #endif /* not USE_GTK */
4204 /* Send a client message with message type Xatom_Scrollbar for a
4205 scroll action to the frame of WINDOW. PART is a value identifying
4206 the part of the scroll bar that was clicked on. PORTION is the
4207 amount to scroll of a whole of WHOLE. */
4210 x_send_scroll_bar_event (Lisp_Object window
, int part
, int portion
, int whole
)
4213 XClientMessageEvent
*ev
= &event
.xclient
;
4214 struct window
*w
= XWINDOW (window
);
4215 struct frame
*f
= XFRAME (w
->frame
);
4216 intptr_t iw
= (intptr_t) w
;
4217 enum { BITS_PER_INTPTR
= CHAR_BIT
* sizeof iw
};
4218 verify (BITS_PER_INTPTR
<= 64);
4219 int sign_shift
= BITS_PER_INTPTR
- 32;
4223 /* Construct a ClientMessage event to send to the frame. */
4224 ev
->type
= ClientMessage
;
4225 ev
->message_type
= FRAME_DISPLAY_INFO (f
)->Xatom_Scrollbar
;
4226 ev
->display
= FRAME_X_DISPLAY (f
);
4227 ev
->window
= FRAME_X_WINDOW (f
);
4230 /* A 32-bit X client on a 64-bit X server can pass a window pointer
4231 as-is. A 64-bit client on a 32-bit X server is in trouble
4232 because a pointer does not fit and would be truncated while
4233 passing through the server. So use two slots and hope that X12
4234 will resolve such issues someday. */
4235 ev
->data
.l
[0] = iw
>> 31 >> 1;
4236 ev
->data
.l
[1] = sign_shift
<= 0 ? iw
: iw
<< sign_shift
>> sign_shift
;
4237 ev
->data
.l
[2] = part
;
4238 ev
->data
.l
[3] = portion
;
4239 ev
->data
.l
[4] = whole
;
4241 /* Make Xt timeouts work while the scroll bar is active. */
4242 #ifdef USE_X_TOOLKIT
4243 toolkit_scroll_bar_interaction
= 1;
4244 x_activate_timeout_atimer ();
4247 /* Setting the event mask to zero means that the message will
4248 be sent to the client that created the window, and if that
4249 window no longer exists, no event will be sent. */
4250 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
4255 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
4259 x_scroll_bar_to_input_event (const XEvent
*event
,
4260 struct input_event
*ievent
)
4262 const XClientMessageEvent
*ev
= &event
->xclient
;
4266 /* See the comment in the function above. */
4267 intptr_t iw0
= ev
->data
.l
[0];
4268 intptr_t iw1
= ev
->data
.l
[1];
4269 intptr_t iw
= (iw0
<< 31 << 1) + (iw1
& 0xffffffffu
);
4270 w
= (struct window
*) iw
;
4272 XSETWINDOW (window
, w
);
4274 ievent
->kind
= SCROLL_BAR_CLICK_EVENT
;
4275 ievent
->frame_or_window
= window
;
4278 ievent
->timestamp
= CurrentTime
;
4281 XtLastTimestampProcessed (FRAME_X_DISPLAY (XFRAME (w
->frame
)));
4284 ievent
->part
= ev
->data
.l
[2];
4285 ievent
->x
= make_number (ev
->data
.l
[3]);
4286 ievent
->y
= make_number (ev
->data
.l
[4]);
4287 ievent
->modifiers
= 0;
4293 /* Minimum and maximum values used for Motif scroll bars. */
4295 #define XM_SB_MAX 10000000
4298 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
4299 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
4300 CALL_DATA is a pointer to a XmScrollBarCallbackStruct. */
4303 xm_scroll_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
4305 struct scroll_bar
*bar
= client_data
;
4306 XmScrollBarCallbackStruct
*cs
= call_data
;
4307 int part
= -1, whole
= 0, portion
= 0;
4311 case XmCR_DECREMENT
:
4313 part
= scroll_bar_up_arrow
;
4316 case XmCR_INCREMENT
:
4318 part
= scroll_bar_down_arrow
;
4321 case XmCR_PAGE_DECREMENT
:
4323 part
= scroll_bar_above_handle
;
4326 case XmCR_PAGE_INCREMENT
:
4328 part
= scroll_bar_below_handle
;
4333 part
= scroll_bar_to_top
;
4336 case XmCR_TO_BOTTOM
:
4338 part
= scroll_bar_to_bottom
;
4345 /* Get the slider size. */
4347 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
4350 whole
= XM_SB_MAX
- slider_size
;
4351 portion
= min (cs
->value
, whole
);
4352 part
= scroll_bar_handle
;
4353 bar
->dragging
= cs
->value
;
4357 case XmCR_VALUE_CHANGED
:
4363 window_being_scrolled
= bar
->window
;
4364 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4368 #elif defined USE_GTK
4370 /* Scroll bar callback for GTK scroll bars. WIDGET is the scroll
4371 bar widget. DATA is a pointer to the scroll_bar structure. */
4374 xg_scroll_callback (GtkRange
*range
,
4375 GtkScrollType scroll
,
4379 struct scroll_bar
*bar
= user_data
;
4381 int part
= -1, whole
= 0, portion
= 0;
4382 GtkAdjustment
*adj
= GTK_ADJUSTMENT (gtk_range_get_adjustment (range
));
4383 struct frame
*f
= g_object_get_data (G_OBJECT (range
), XG_FRAME_DATA
);
4385 if (xg_ignore_gtk_scrollbar
) return FALSE
;
4386 position
= gtk_adjustment_get_value (adj
);
4391 case GTK_SCROLL_JUMP
:
4392 /* Buttons 1 2 or 3 must be grabbed. */
4393 if (FRAME_DISPLAY_INFO (f
)->grabbed
!= 0
4394 && FRAME_DISPLAY_INFO (f
)->grabbed
< (1 << 4))
4396 part
= scroll_bar_handle
;
4397 whole
= gtk_adjustment_get_upper (adj
) -
4398 gtk_adjustment_get_page_size (adj
);
4399 portion
= min ((int)position
, whole
);
4400 bar
->dragging
= portion
;
4403 case GTK_SCROLL_STEP_BACKWARD
:
4404 part
= scroll_bar_up_arrow
;
4407 case GTK_SCROLL_STEP_FORWARD
:
4408 part
= scroll_bar_down_arrow
;
4411 case GTK_SCROLL_PAGE_BACKWARD
:
4412 part
= scroll_bar_above_handle
;
4415 case GTK_SCROLL_PAGE_FORWARD
:
4416 part
= scroll_bar_below_handle
;
4423 window_being_scrolled
= bar
->window
;
4424 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4430 /* Callback for button release. Sets dragging to -1 when dragging is done. */
4433 xg_end_scroll_callback (GtkWidget
*widget
,
4434 GdkEventButton
*event
,
4437 struct scroll_bar
*bar
= user_data
;
4439 if (WINDOWP (window_being_scrolled
))
4441 x_send_scroll_bar_event (window_being_scrolled
,
4442 scroll_bar_end_scroll
, 0, 0);
4443 window_being_scrolled
= Qnil
;
4450 #else /* not USE_GTK and not USE_MOTIF */
4452 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
4453 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
4454 scroll bar struct. CALL_DATA is a pointer to a float saying where
4458 xaw_jump_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
4460 struct scroll_bar
*bar
= client_data
;
4461 float *top_addr
= call_data
;
4462 float top
= *top_addr
;
4464 int whole
, portion
, height
;
4465 enum scroll_bar_part part
;
4467 /* Get the size of the thumb, a value between 0 and 1. */
4469 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
4473 portion
= shown
< 1 ? top
* whole
: 0;
4475 if (shown
< 1 && (eabs (top
+ shown
- 1) < 1.0f
/ height
))
4476 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
4477 the bottom, so we force the scrolling whenever we see that we're
4478 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
4479 we try to ensure that we always stay two pixels away from the
4481 part
= scroll_bar_down_arrow
;
4483 part
= scroll_bar_handle
;
4485 window_being_scrolled
= bar
->window
;
4486 bar
->dragging
= portion
;
4487 bar
->last_seen_part
= part
;
4488 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4492 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
4493 i.e. line or page up or down. WIDGET is the Xaw scroll bar
4494 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
4495 the scroll bar. CALL_DATA is an integer specifying the action that
4496 has taken place. Its magnitude is in the range 0..height of the
4497 scroll bar. Negative values mean scroll towards buffer start.
4498 Values < height of scroll bar mean line-wise movement. */
4501 xaw_scroll_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
4503 struct scroll_bar
*bar
= client_data
;
4504 /* The position really is stored cast to a pointer. */
4505 int position
= (intptr_t) call_data
;
4507 enum scroll_bar_part part
;
4509 /* Get the height of the scroll bar. */
4511 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
4514 if (eabs (position
) >= height
)
4515 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
4517 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
4518 it maps line-movement to call_data = max(5, height/20). */
4519 else if (xaw3d_arrow_scroll
&& eabs (position
) <= max (5, height
/ 20))
4520 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
4522 part
= scroll_bar_move_ratio
;
4524 window_being_scrolled
= bar
->window
;
4526 bar
->last_seen_part
= part
;
4527 x_send_scroll_bar_event (bar
->window
, part
, position
, height
);
4530 #endif /* not USE_GTK and not USE_MOTIF */
4532 #define SCROLL_BAR_NAME "verticalScrollBar"
4534 /* Create the widget for scroll bar BAR on frame F. Record the widget
4535 and X window of the scroll bar in BAR. */
4539 x_create_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
4541 const char *scroll_bar_name
= SCROLL_BAR_NAME
;
4544 xg_create_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
4545 G_CALLBACK (xg_end_scroll_callback
),
4550 #else /* not USE_GTK */
4553 x_create_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
4559 const char *scroll_bar_name
= SCROLL_BAR_NAME
;
4560 unsigned long pixel
;
4565 /* Set resources. Create the widget. */
4566 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4567 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
4568 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
4569 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
4570 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
4571 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
4572 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
4574 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4577 XtSetArg (av
[ac
], XmNforeground
, pixel
);
4581 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4584 XtSetArg (av
[ac
], XmNbackground
, pixel
);
4588 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
4589 (char *) scroll_bar_name
, av
, ac
);
4591 /* Add one callback for everything that can happen. */
4592 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
4594 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
4596 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
4598 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
4600 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
4602 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
4604 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
4607 /* Realize the widget. Only after that is the X window created. */
4608 XtRealizeWidget (widget
);
4610 /* Set the cursor to an arrow. I didn't find a resource to do that.
4611 And I'm wondering why it hasn't an arrow cursor by default. */
4612 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
4613 f
->output_data
.x
->nontext_cursor
);
4615 #else /* !USE_MOTIF i.e. use Xaw */
4617 /* Set resources. Create the widget. The background of the
4618 Xaw3d scroll bar widget is a little bit light for my taste.
4619 We don't alter it here to let users change it according
4620 to their taste with `emacs*verticalScrollBar.background: xxx'. */
4621 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4622 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
4623 /* For smoother scrolling with Xaw3d -sm */
4624 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
4626 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4629 XtSetArg (av
[ac
], XtNforeground
, pixel
);
4633 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4636 XtSetArg (av
[ac
], XtNbackground
, pixel
);
4640 /* Top/bottom shadow colors. */
4642 /* Allocate them, if necessary. */
4643 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
4645 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4648 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
4649 FRAME_X_COLORMAP (f
),
4650 &pixel
, 1.2, 0x8000))
4652 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
4655 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4657 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4660 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
4661 FRAME_X_COLORMAP (f
),
4662 &pixel
, 0.6, 0x4000))
4664 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
4668 #ifdef XtNbeNiceToColormap
4669 /* Tell the toolkit about them. */
4670 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
4671 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4672 /* We tried to allocate a color for the top/bottom shadow, and
4673 failed, so tell Xaw3d to use dithering instead. */
4674 /* But only if we have a small colormap. Xaw3d can allocate nice
4677 XtSetArg (av
[ac
], XtNbeNiceToColormap
,
4678 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)) < 16);
4682 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
4683 be more consistent with other emacs 3d colors, and since Xaw3d is
4684 not good at dealing with allocation failure. */
4686 /* This tells Xaw3d to use real colors instead of dithering for
4688 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
4691 /* Specify the colors. */
4692 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
4695 XtSetArg (av
[ac
], XtNtopShadowPixel
, pixel
);
4698 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
4701 XtSetArg (av
[ac
], XtNbottomShadowPixel
, pixel
);
4707 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
4708 f
->output_data
.x
->edit_widget
, av
, ac
);
4711 char const *initial
= "";
4712 char const *val
= initial
;
4713 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
4714 #ifdef XtNarrowScrollbars
4715 XtNarrowScrollbars
, (XtPointer
) &xaw3d_arrow_scroll
,
4717 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
4718 if (xaw3d_arrow_scroll
|| val
== initial
)
4719 { /* ARROW_SCROLL */
4720 xaw3d_arrow_scroll
= True
;
4721 /* Isn't that just a personal preference ? --Stef */
4722 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
4726 /* Define callbacks. */
4727 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
4728 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
4731 /* Realize the widget. Only after that is the X window created. */
4732 XtRealizeWidget (widget
);
4734 #endif /* !USE_MOTIF */
4736 /* Install an action hook that lets us detect when the user
4737 finishes interacting with a scroll bar. */
4738 if (action_hook_id
== 0)
4739 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
4741 /* Remember X window and widget in the scroll bar vector. */
4742 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
4743 xwindow
= XtWindow (widget
);
4744 bar
->x_window
= xwindow
;
4748 #endif /* not USE_GTK */
4751 /* Set the thumb size and position of scroll bar BAR. We are currently
4752 displaying PORTION out of a whole WHOLE, and our position POSITION. */
4756 x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
, int whole
)
4758 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
4761 #else /* not USE_GTK */
4763 x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
,
4766 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4767 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4774 if (scroll_bar_adjust_thumb_portion_p
)
4776 /* We use an estimate of 30 chars per line rather than the real
4777 `portion' value. This has the disadvantage that the thumb size
4778 is not very representative, but it makes our life a lot easier.
4779 Otherwise, we have to constantly adjust the thumb size, which
4780 we can't always do quickly enough: while dragging, the size of
4781 the thumb might prevent the user from dragging the thumb all the
4782 way to the end. but Motif and some versions of Xaw3d don't allow
4783 updating the thumb size while dragging. Also, even if we can update
4784 its size, the update will often happen too late.
4785 If you don't believe it, check out revision 1.650 of xterm.c to see
4786 what hoops we were going through and the still poor behavior we got. */
4787 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
4788 /* When the thumb is at the bottom, position == whole.
4789 So we need to increase `whole' to make space for the thumb. */
4797 top
= (float) position
/ whole
;
4798 shown
= (float) portion
/ whole
;
4801 if (bar
->dragging
== -1)
4805 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
4806 is the scroll bar's maximum and MIN is the scroll bar's minimum
4808 size
= clip_to_bounds (1, shown
* XM_SB_MAX
, XM_SB_MAX
);
4810 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
4811 value
= top
* XM_SB_MAX
;
4812 value
= min (value
, XM_SB_MAX
- size
);
4814 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
4816 #else /* !USE_MOTIF i.e. use Xaw */
4822 top
= (float) position
/ whole
;
4823 shown
= (float) portion
/ whole
;
4827 float old_top
, old_shown
;
4829 XtVaGetValues (widget
,
4830 XtNtopOfThumb
, &old_top
,
4831 XtNshown
, &old_shown
,
4835 /* Massage the top+shown values. */
4836 if (bar
->dragging
== -1 || bar
->last_seen_part
== scroll_bar_down_arrow
)
4837 top
= max (0, min (1, top
));
4840 #if ! defined (HAVE_XAW3D)
4841 /* With Xaw, 'top' values too closer to 1.0 may
4842 cause the thumb to disappear. Fix that. */
4843 top
= min (top
, 0.99f
);
4845 /* Keep two pixels available for moving the thumb down. */
4846 shown
= max (0, min (1 - top
- (2.0f
/ height
), shown
));
4847 #if ! defined (HAVE_XAW3D)
4848 /* Likewise with too small 'shown'. */
4849 shown
= max (shown
, 0.01f
);
4852 /* If the call to XawScrollbarSetThumb below doesn't seem to
4853 work, check that 'NARROWPROTO' is defined in src/config.h.
4854 If this is not so, most likely you need to fix configure. */
4855 if (top
!= old_top
|| shown
!= old_shown
)
4857 if (bar
->dragging
== -1)
4858 XawScrollbarSetThumb (widget
, top
, shown
);
4861 /* Try to make the scrolling a tad smoother. */
4862 if (!xaw3d_pick_top
)
4863 shown
= min (shown
, old_shown
);
4865 XawScrollbarSetThumb (widget
, top
, shown
);
4869 #endif /* !USE_MOTIF */
4873 #endif /* not USE_GTK */
4875 #endif /* USE_TOOLKIT_SCROLL_BARS */
4879 /************************************************************************
4880 Scroll bars, general
4881 ************************************************************************/
4883 /* Create a scroll bar and return the scroll bar vector for it. W is
4884 the Emacs window on which to create the scroll bar. TOP, LEFT,
4885 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
4888 static struct scroll_bar
*
4889 x_scroll_bar_create (struct window
*w
, int top
, int left
, int width
, int height
)
4891 struct frame
*f
= XFRAME (w
->frame
);
4892 struct scroll_bar
*bar
4893 = ALLOCATE_PSEUDOVECTOR (struct scroll_bar
, x_window
, PVEC_OTHER
);
4898 #ifdef USE_TOOLKIT_SCROLL_BARS
4899 x_create_toolkit_scroll_bar (f
, bar
);
4900 #else /* not USE_TOOLKIT_SCROLL_BARS */
4902 XSetWindowAttributes a
;
4906 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4907 if (a
.background_pixel
== -1)
4908 a
.background_pixel
= FRAME_BACKGROUND_PIXEL (f
);
4910 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
4911 | ButtonMotionMask
| PointerMotionHintMask
4913 a
.cursor
= FRAME_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
4915 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
4917 /* Clear the area of W that will serve as a scroll bar. This is
4918 for the case that a window has been split horizontally. In
4919 this case, no clear_frame is generated to reduce flickering. */
4920 if (width
> 0 && window_box_height (w
) > 0)
4921 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4922 left
, top
, width
, window_box_height (w
));
4924 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4925 /* Position and size of scroll bar. */
4926 left
, top
, width
, height
,
4927 /* Border width, depth, class, and visual. */
4934 bar
->x_window
= window
;
4936 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4938 XSETWINDOW (bar
->window
, w
);
4942 bar
->height
= height
;
4946 #if defined (USE_TOOLKIT_SCROLL_BARS) && defined (USE_LUCID)
4947 bar
->last_seen_part
= scroll_bar_nowhere
;
4950 /* Add bar to its frame's list of scroll bars. */
4951 bar
->next
= FRAME_SCROLL_BARS (f
);
4953 XSETVECTOR (barobj
, bar
);
4954 fset_scroll_bars (f
, barobj
);
4955 if (!NILP (bar
->next
))
4956 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4958 /* Map the window/widget. */
4959 #ifdef USE_TOOLKIT_SCROLL_BARS
4962 xg_update_scrollbar_pos (f
, bar
->x_window
, top
,
4963 left
,width
, max (height
, 1));
4964 #else /* not USE_GTK */
4965 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4966 XtConfigureWidget (scroll_bar
, left
, top
, width
, max (height
, 1), 0);
4967 XtMapWidget (scroll_bar
);
4968 #endif /* not USE_GTK */
4970 #else /* not USE_TOOLKIT_SCROLL_BARS */
4971 XMapRaised (FRAME_X_DISPLAY (f
), bar
->x_window
);
4972 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4979 #ifndef USE_TOOLKIT_SCROLL_BARS
4981 /* Draw BAR's handle in the proper position.
4983 If the handle is already drawn from START to END, don't bother
4984 redrawing it, unless REBUILD is non-zero; in that case, always
4985 redraw it. (REBUILD is handy for drawing the handle after expose
4988 Normally, we want to constrain the start and end of the handle to
4989 fit inside its rectangle, but if the user is dragging the scroll
4990 bar handle, we want to let them drag it down all the way, so that
4991 the bar's top is as far down as it goes; otherwise, there's no way
4992 to move to the very end of the buffer. */
4995 x_scroll_bar_set_handle (struct scroll_bar
*bar
, int start
, int end
, int rebuild
)
4997 bool dragging
= bar
->dragging
!= -1;
4998 Window w
= bar
->x_window
;
4999 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5000 GC gc
= f
->output_data
.x
->normal_gc
;
5002 /* If the display is already accurate, do nothing. */
5004 && start
== bar
->start
5011 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, bar
->width
);
5012 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, bar
->height
);
5013 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
5015 /* Make sure the values are reasonable, and try to preserve
5016 the distance between start and end. */
5018 int length
= end
- start
;
5022 else if (start
> top_range
)
5024 end
= start
+ length
;
5028 else if (end
> top_range
&& ! dragging
)
5032 /* Store the adjusted setting in the scroll bar. */
5036 /* Clip the end position, just for display. */
5037 if (end
> top_range
)
5040 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
5041 below top positions, to make sure the handle is always at least
5042 that many pixels tall. */
5043 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
5045 /* Draw the empty space above the handle. Note that we can't clear
5046 zero-height areas; that means "clear to end of window." */
5048 x_clear_area (FRAME_X_DISPLAY (f
), w
,
5049 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
5050 VERTICAL_SCROLL_BAR_TOP_BORDER
,
5051 inside_width
, start
);
5053 /* Change to proper foreground color if one is specified. */
5054 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5055 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5056 f
->output_data
.x
->scroll_bar_foreground_pixel
);
5058 /* Draw the handle itself. */
5059 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
5060 /* x, y, width, height */
5061 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
5062 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
5063 inside_width
, end
- start
);
5065 /* Restore the foreground color of the GC if we changed it above. */
5066 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5067 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5068 FRAME_FOREGROUND_PIXEL (f
));
5070 /* Draw the empty space below the handle. Note that we can't
5071 clear zero-height areas; that means "clear to end of window." */
5072 if (end
< inside_height
)
5073 x_clear_area (FRAME_X_DISPLAY (f
), w
,
5074 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
5075 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
5076 inside_width
, inside_height
- end
);
5082 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5084 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
5088 x_scroll_bar_remove (struct scroll_bar
*bar
)
5090 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5093 #ifdef USE_TOOLKIT_SCROLL_BARS
5095 xg_remove_scroll_bar (f
, bar
->x_window
);
5096 #else /* not USE_GTK */
5097 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
5098 #endif /* not USE_GTK */
5100 XDestroyWindow (FRAME_X_DISPLAY (f
), bar
->x_window
);
5103 /* Dissociate this scroll bar from its window. */
5104 wset_vertical_scroll_bar (XWINDOW (bar
->window
), Qnil
);
5110 /* Set the handle of the vertical scroll bar for WINDOW to indicate
5111 that we are displaying PORTION characters out of a total of WHOLE
5112 characters, starting at POSITION. If WINDOW has no scroll bar,
5116 XTset_vertical_scroll_bar (struct window
*w
, int portion
, int whole
, int position
)
5118 struct frame
*f
= XFRAME (w
->frame
);
5120 struct scroll_bar
*bar
;
5121 int top
, height
, left
, width
;
5122 int window_y
, window_height
;
5124 /* Get window dimensions. */
5125 window_box (w
, ANY_AREA
, 0, &window_y
, 0, &window_height
);
5127 height
= window_height
;
5129 /* Compute the left edge and the width of the scroll bar area. */
5130 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
5131 width
= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
5133 /* Does the scroll bar exist yet? */
5134 if (NILP (w
->vertical_scroll_bar
))
5136 if (width
> 0 && height
> 0)
5139 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5140 left
, top
, width
, height
);
5144 bar
= x_scroll_bar_create (w
, top
, left
, width
, max (height
, 1));
5148 /* It may just need to be moved and resized. */
5149 unsigned int mask
= 0;
5151 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5155 if (left
!= bar
->left
)
5157 if (top
!= bar
->top
)
5159 if (width
!= bar
->width
)
5161 if (height
!= bar
->height
)
5164 #ifdef USE_TOOLKIT_SCROLL_BARS
5166 /* Move/size the scroll bar widget. */
5169 /* Since toolkit scroll bars are smaller than the space reserved
5170 for them on the frame, we have to clear "under" them. */
5171 if (width
> 0 && height
> 0)
5172 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5173 left
, top
, width
, height
);
5175 xg_update_scrollbar_pos (f
, bar
->x_window
, top
,
5176 left
, width
, max (height
, 1));
5177 #else /* not USE_GTK */
5178 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
5179 left
, top
, width
, max (height
, 1), 0);
5180 #endif /* not USE_GTK */
5182 #else /* not USE_TOOLKIT_SCROLL_BARS */
5184 /* Move/size the scroll bar window. */
5193 XConfigureWindow (FRAME_X_DISPLAY (f
), bar
->x_window
,
5197 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5199 /* Remember new settings. */
5203 bar
->height
= height
;
5208 #ifdef USE_TOOLKIT_SCROLL_BARS
5209 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
5210 #else /* not USE_TOOLKIT_SCROLL_BARS */
5211 /* Set the scroll bar's current state, unless we're currently being
5213 if (bar
->dragging
== -1)
5215 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
5218 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
5221 int start
= ((double) position
* top_range
) / whole
;
5222 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
5223 x_scroll_bar_set_handle (bar
, start
, end
, 0);
5226 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5228 XSETVECTOR (barobj
, bar
);
5229 wset_vertical_scroll_bar (w
, barobj
);
5233 /* The following three hooks are used when we're doing a thorough
5234 redisplay of the frame. We don't explicitly know which scroll bars
5235 are going to be deleted, because keeping track of when windows go
5236 away is a real pain - "Can you say set-window-configuration, boys
5237 and girls?" Instead, we just assert at the beginning of redisplay
5238 that *all* scroll bars are to be removed, and then save a scroll bar
5239 from the fiery pit when we actually redisplay its window. */
5241 /* Arrange for all scroll bars on FRAME to be removed at the next call
5242 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
5243 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
5246 XTcondemn_scroll_bars (struct frame
*frame
)
5248 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
5249 while (! NILP (FRAME_SCROLL_BARS (frame
)))
5252 bar
= FRAME_SCROLL_BARS (frame
);
5253 fset_scroll_bars (frame
, XSCROLL_BAR (bar
)->next
);
5254 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
5255 XSCROLL_BAR (bar
)->prev
= Qnil
;
5256 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
5257 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
5258 fset_condemned_scroll_bars (frame
, bar
);
5263 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
5264 Note that WINDOW isn't necessarily condemned at all. */
5267 XTredeem_scroll_bar (struct window
*window
)
5269 struct scroll_bar
*bar
;
5273 /* We can't redeem this window's scroll bar if it doesn't have one. */
5274 if (NILP (window
->vertical_scroll_bar
))
5277 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
5279 /* Unlink it from the condemned list. */
5280 f
= XFRAME (WINDOW_FRAME (window
));
5281 if (NILP (bar
->prev
))
5283 /* If the prev pointer is nil, it must be the first in one of
5285 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
5286 /* It's not condemned. Everything's fine. */
5288 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
5289 window
->vertical_scroll_bar
))
5290 fset_condemned_scroll_bars (f
, bar
->next
);
5292 /* If its prev pointer is nil, it must be at the front of
5293 one or the other! */
5297 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
5299 if (! NILP (bar
->next
))
5300 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
5302 bar
->next
= FRAME_SCROLL_BARS (f
);
5304 XSETVECTOR (barobj
, bar
);
5305 fset_scroll_bars (f
, barobj
);
5306 if (! NILP (bar
->next
))
5307 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
5310 /* Remove all scroll bars on FRAME that haven't been saved since the
5311 last call to `*condemn_scroll_bars_hook'. */
5314 XTjudge_scroll_bars (struct frame
*f
)
5316 Lisp_Object bar
, next
;
5318 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
5320 /* Clear out the condemned list now so we won't try to process any
5321 more events on the hapless scroll bars. */
5322 fset_condemned_scroll_bars (f
, Qnil
);
5324 for (; ! NILP (bar
); bar
= next
)
5326 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
5328 x_scroll_bar_remove (b
);
5331 b
->next
= b
->prev
= Qnil
;
5334 /* Now there should be no references to the condemned scroll bars,
5335 and they should get garbage-collected. */
5339 #ifndef USE_TOOLKIT_SCROLL_BARS
5340 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
5341 is a no-op when using toolkit scroll bars.
5343 This may be called from a signal handler, so we have to ignore GC
5347 x_scroll_bar_expose (struct scroll_bar
*bar
, const XEvent
*event
)
5349 Window w
= bar
->x_window
;
5350 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5351 GC gc
= f
->output_data
.x
->normal_gc
;
5355 x_scroll_bar_set_handle (bar
, bar
->start
, bar
->end
, 1);
5357 /* Switch to scroll bar foreground color. */
5358 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5359 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5360 f
->output_data
.x
->scroll_bar_foreground_pixel
);
5362 /* Draw a one-pixel border just inside the edges of the scroll bar. */
5363 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
5364 /* x, y, width, height */
5365 0, 0, bar
->width
- 1, bar
->height
- 1);
5367 /* Restore the foreground color of the GC if we changed it above. */
5368 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5369 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5370 FRAME_FOREGROUND_PIXEL (f
));
5375 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5377 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
5378 is set to something other than NO_EVENT, it is enqueued.
5380 This may be called from a signal handler, so we have to ignore GC
5385 x_scroll_bar_handle_click (struct scroll_bar
*bar
,
5386 const XEvent
*event
,
5387 struct input_event
*emacs_event
)
5389 if (! WINDOWP (bar
->window
))
5392 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
5393 emacs_event
->code
= event
->xbutton
.button
- Button1
;
5394 emacs_event
->modifiers
5395 = (x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO
5396 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
5397 event
->xbutton
.state
)
5398 | (event
->type
== ButtonRelease
5401 emacs_event
->frame_or_window
= bar
->window
;
5402 emacs_event
->arg
= Qnil
;
5403 emacs_event
->timestamp
= event
->xbutton
.time
;
5406 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
5407 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
5410 if (y
> top_range
) y
= top_range
;
5413 emacs_event
->part
= scroll_bar_above_handle
;
5414 else if (y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5415 emacs_event
->part
= scroll_bar_handle
;
5417 emacs_event
->part
= scroll_bar_below_handle
;
5419 #ifndef USE_TOOLKIT_SCROLL_BARS
5420 /* If the user has released the handle, set it to its final position. */
5421 if (event
->type
== ButtonRelease
&& bar
->dragging
!= -1)
5423 int new_start
= y
- bar
->dragging
;
5424 int new_end
= new_start
+ bar
->end
- bar
->start
;
5426 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5431 XSETINT (emacs_event
->x
, y
);
5432 XSETINT (emacs_event
->y
, top_range
);
5436 #ifndef USE_TOOLKIT_SCROLL_BARS
5438 /* Handle some mouse motion while someone is dragging the scroll bar.
5440 This may be called from a signal handler, so we have to ignore GC
5444 x_scroll_bar_note_movement (struct scroll_bar
*bar
,
5445 const XMotionEvent
*event
)
5447 struct frame
*f
= XFRAME (XWINDOW (bar
->window
)->frame
);
5448 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
5450 dpyinfo
->last_mouse_movement_time
= event
->time
;
5451 dpyinfo
->last_mouse_scroll_bar
= bar
;
5454 /* If we're dragging the bar, display it. */
5455 if (bar
->dragging
!= -1)
5457 /* Where should the handle be now? */
5458 int new_start
= event
->y
- bar
->dragging
;
5460 if (new_start
!= bar
->start
)
5462 int new_end
= new_start
+ bar
->end
- bar
->start
;
5464 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5469 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5471 /* Return information to the user about the current position of the mouse
5472 on the scroll bar. */
5475 x_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
5476 enum scroll_bar_part
*part
, Lisp_Object
*x
,
5477 Lisp_Object
*y
, Time
*timestamp
)
5479 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
5480 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
5481 Window w
= bar
->x_window
;
5482 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5484 Window dummy_window
;
5486 unsigned int dummy_mask
;
5490 /* Get the mouse's position relative to the scroll bar window, and
5492 if (XQueryPointer (FRAME_X_DISPLAY (f
), w
,
5494 /* Root, child, root x and root y. */
5495 &dummy_window
, &dummy_window
,
5496 &dummy_coord
, &dummy_coord
,
5498 /* Position relative to scroll bar. */
5501 /* Mouse buttons and modifier keys. */
5504 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
5506 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
5508 if (bar
->dragging
!= -1)
5509 win_y
-= bar
->dragging
;
5513 if (win_y
> top_range
)
5517 *bar_window
= bar
->window
;
5519 if (bar
->dragging
!= -1)
5520 *part
= scroll_bar_handle
;
5521 else if (win_y
< bar
->start
)
5522 *part
= scroll_bar_above_handle
;
5523 else if (win_y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5524 *part
= scroll_bar_handle
;
5526 *part
= scroll_bar_below_handle
;
5528 XSETINT (*x
, win_y
);
5529 XSETINT (*y
, top_range
);
5532 dpyinfo
->last_mouse_scroll_bar
= NULL
;
5533 *timestamp
= dpyinfo
->last_mouse_movement_time
;
5540 /* The screen has been cleared so we may have changed foreground or
5541 background colors, and the scroll bars may need to be redrawn.
5542 Clear out the scroll bars, and ask for expose events, so we can
5546 x_scroll_bar_clear (struct frame
*f
)
5548 #ifndef USE_TOOLKIT_SCROLL_BARS
5551 /* We can have scroll bars even if this is 0,
5552 if we just turned off scroll bar mode.
5553 But in that case we should not clear them. */
5554 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5555 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
5556 bar
= XSCROLL_BAR (bar
)->next
)
5557 XClearArea (FRAME_X_DISPLAY (f
),
5558 XSCROLL_BAR (bar
)->x_window
,
5560 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5563 #ifdef ENABLE_CHECKING
5565 /* Record the last 100 characters stored
5566 to help debug the loss-of-chars-during-GC problem. */
5568 static int temp_index
;
5569 static short temp_buffer
[100];
5571 #define STORE_KEYSYM_FOR_DEBUG(keysym) \
5572 if (temp_index == sizeof temp_buffer / sizeof (short)) \
5574 temp_buffer[temp_index++] = (keysym)
5576 #else /* not ENABLE_CHECKING */
5578 #define STORE_KEYSYM_FOR_DEBUG(keysym) ((void)0)
5580 #endif /* ENABLE_CHECKING */
5582 /* Set this to nonzero to fake an "X I/O error"
5583 on a particular display. */
5585 static struct x_display_info
*XTread_socket_fake_io_error
;
5587 /* When we find no input here, we occasionally do a no-op command
5588 to verify that the X server is still running and we can still talk with it.
5589 We try all the open displays, one by one.
5590 This variable is used for cycling thru the displays. */
5592 static struct x_display_info
*next_noop_dpyinfo
;
5601 /* Filter events for the current X input method.
5602 DPYINFO is the display this event is for.
5603 EVENT is the X event to filter.
5605 Returns non-zero if the event was filtered, caller shall not process
5607 Returns zero if event is wasn't filtered. */
5611 x_filter_event (struct x_display_info
*dpyinfo
, XEvent
*event
)
5613 /* XFilterEvent returns non-zero if the input method has
5614 consumed the event. We pass the frame's X window to
5615 XFilterEvent because that's the one for which the IC
5618 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
5619 event
->xclient
.window
);
5621 return XFilterEvent (event
, f1
? FRAME_X_WINDOW (f1
) : None
);
5626 static int current_count
;
5627 static int current_finish
;
5628 static struct input_event
*current_hold_quit
;
5630 /* This is the filter function invoked by the GTK event loop.
5631 It is invoked before the XEvent is translated to a GdkEvent,
5632 so we have a chance to act on the event before GTK. */
5633 static GdkFilterReturn
5634 event_handler_gdk (GdkXEvent
*gxev
, GdkEvent
*ev
, gpointer data
)
5636 XEvent
*xev
= (XEvent
*) gxev
;
5639 if (current_count
>= 0)
5641 struct x_display_info
*dpyinfo
;
5643 dpyinfo
= x_display_info_for_display (xev
->xany
.display
);
5646 /* Filter events for the current X input method.
5647 GTK calls XFilterEvent but not for key press and release,
5648 so we do it here. */
5649 if ((xev
->type
== KeyPress
|| xev
->type
== KeyRelease
)
5651 && x_filter_event (dpyinfo
, xev
))
5654 return GDK_FILTER_REMOVE
;
5659 current_finish
= X_EVENT_NORMAL
;
5662 handle_one_xevent (dpyinfo
, xev
, ¤t_finish
,
5666 current_finish
= x_dispatch_event (xev
, xev
->xany
.display
);
5670 if (current_finish
== X_EVENT_GOTO_OUT
|| current_finish
== X_EVENT_DROP
)
5671 return GDK_FILTER_REMOVE
;
5673 return GDK_FILTER_CONTINUE
;
5675 #endif /* USE_GTK */
5678 static void xembed_send_message (struct frame
*f
, Time
,
5679 enum xembed_message
,
5680 long detail
, long data1
, long data2
);
5682 /* Handles the XEvent EVENT on display DPYINFO.
5684 *FINISH is X_EVENT_GOTO_OUT if caller should stop reading events.
5685 *FINISH is zero if caller should continue reading events.
5686 *FINISH is X_EVENT_DROP if event should not be passed to the toolkit.
5687 *EVENT is unchanged unless we're processing KeyPress event.
5689 We return the number of characters stored into the buffer. */
5692 handle_one_xevent (struct x_display_info
*dpyinfo
,
5693 const XEvent
*event
,
5694 int *finish
, struct input_event
*hold_quit
)
5697 struct input_event ie
;
5698 struct selection_input_event sie
;
5702 ptrdiff_t nbytes
= 0;
5703 struct frame
*any
, *f
= NULL
;
5704 struct coding_system coding
;
5705 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
5706 /* This holds the state XLookupString needs to implement dead keys
5707 and other tricks known as "compose processing". _X Window System_
5708 says that a portable program can't use this, but Stephen Gildea assures
5709 me that letting the compiler initialize it to zeros will work okay. */
5710 static XComposeStatus compose_status
;
5714 *finish
= X_EVENT_NORMAL
;
5716 EVENT_INIT (inev
.ie
);
5717 inev
.ie
.kind
= NO_EVENT
;
5720 any
= x_any_window_to_frame (dpyinfo
, event
->xany
.window
);
5722 if (any
&& any
->wait_event_type
== event
->type
)
5723 any
->wait_event_type
= 0; /* Indicates we got it. */
5725 switch (event
->type
)
5729 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_protocols
5730 && event
->xclient
.format
== 32)
5732 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_take_focus
)
5734 /* Use the value returned by x_any_window_to_frame
5735 because this could be the shell widget window
5736 if the frame has no title bar. */
5739 /* Not quite sure this is needed -pd */
5740 if (f
&& FRAME_XIC (f
))
5741 XSetICFocus (FRAME_XIC (f
));
5743 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
5744 instructs the WM to set the input focus automatically for
5745 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
5746 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
5747 it has set the focus. So, XSetInputFocus below is not
5750 The call to XSetInputFocus below has also caused trouble. In
5751 cases where the XSetInputFocus done by the WM and the one
5752 below are temporally close (on a fast machine), the call
5753 below can generate additional FocusIn events which confuse
5756 /* Since we set WM_TAKE_FOCUS, we must call
5757 XSetInputFocus explicitly. But not if f is null,
5758 since that might be an event for a deleted frame. */
5761 Display
*d
= event
->xclient
.display
;
5762 /* Catch and ignore errors, in case window has been
5763 iconified by a window manager such as GWM. */
5765 XSetInputFocus (d
, event
->xclient
.window
,
5766 /* The ICCCM says this is
5767 the only valid choice. */
5769 event
->xclient
.data
.l
[1]);
5770 /* This is needed to detect the error
5771 if there is an error. */
5773 x_uncatch_errors ();
5775 /* Not certain about handling scroll bars here */
5780 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_save_yourself
)
5782 /* Save state modify the WM_COMMAND property to
5783 something which can reinstate us. This notifies
5784 the session manager, who's looking for such a
5785 PropertyNotify. Can restart processing when
5786 a keyboard or mouse event arrives. */
5787 /* If we have a session manager, don't set this.
5788 KDE will then start two Emacsen, one for the
5789 session manager and one for this. */
5791 if (! x_session_have_connection ())
5794 f
= x_top_window_to_frame (dpyinfo
,
5795 event
->xclient
.window
);
5796 /* This is just so we only give real data once
5797 for a single Emacs process. */
5798 if (f
== SELECTED_FRAME ())
5799 XSetCommand (FRAME_X_DISPLAY (f
),
5800 event
->xclient
.window
,
5801 initial_argv
, initial_argc
);
5803 XSetCommand (FRAME_X_DISPLAY (f
),
5804 event
->xclient
.window
,
5810 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_delete_window
)
5814 goto OTHER
; /* May be a dialog that is to be removed */
5816 inev
.ie
.kind
= DELETE_WINDOW_EVENT
;
5817 XSETFRAME (inev
.ie
.frame_or_window
, f
);
5824 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_configure_denied
)
5827 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_window_moved
)
5830 f
= x_window_to_frame (dpyinfo
, event
->xclient
.window
);
5832 new_x
= event
->xclient
.data
.s
[0];
5833 new_y
= event
->xclient
.data
.s
[1];
5837 f
->left_pos
= new_x
;
5844 if (event
->xclient
.message_type
== dpyinfo
->Xatom_editres
)
5848 _XEditResCheckMessages (f
->output_data
.x
->widget
,
5849 NULL
, (XEvent
*) event
, NULL
);
5852 #endif /* HACK_EDITRES */
5854 if (event
->xclient
.message_type
== dpyinfo
->Xatom_DONE
5855 || event
->xclient
.message_type
== dpyinfo
->Xatom_PAGE
)
5857 /* Ghostview job completed. Kill it. We could
5858 reply with "Next" if we received "Page", but we
5859 currently never do because we are interested in
5860 images, only, which should have 1 page. */
5861 Pixmap pixmap
= (Pixmap
) event
->xclient
.data
.l
[1];
5862 f
= x_window_to_frame (dpyinfo
, event
->xclient
.window
);
5865 x_kill_gs_process (pixmap
, f
);
5866 expose_frame (f
, 0, 0, 0, 0);
5870 #ifdef USE_TOOLKIT_SCROLL_BARS
5871 /* Scroll bar callbacks send a ClientMessage from which
5872 we construct an input_event. */
5873 if (event
->xclient
.message_type
== dpyinfo
->Xatom_Scrollbar
)
5875 x_scroll_bar_to_input_event (event
, &inev
.ie
);
5876 *finish
= X_EVENT_GOTO_OUT
;
5879 #endif /* USE_TOOLKIT_SCROLL_BARS */
5881 /* XEmbed messages from the embedder (if any). */
5882 if (event
->xclient
.message_type
== dpyinfo
->Xatom_XEMBED
)
5884 enum xembed_message msg
= event
->xclient
.data
.l
[1];
5885 if (msg
== XEMBED_FOCUS_IN
|| msg
== XEMBED_FOCUS_OUT
)
5886 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
5888 *finish
= X_EVENT_GOTO_OUT
;
5892 xft_settings_event (dpyinfo
, event
);
5897 if (x_handle_dnd_message (f
, &event
->xclient
, dpyinfo
, &inev
.ie
))
5898 *finish
= X_EVENT_DROP
;
5902 case SelectionNotify
:
5903 dpyinfo
->last_user_time
= event
->xselection
.time
;
5904 #ifdef USE_X_TOOLKIT
5905 if (! x_window_to_frame (dpyinfo
, event
->xselection
.requestor
))
5907 #endif /* not USE_X_TOOLKIT */
5908 x_handle_selection_notify (&event
->xselection
);
5911 case SelectionClear
: /* Someone has grabbed ownership. */
5912 dpyinfo
->last_user_time
= event
->xselectionclear
.time
;
5913 #ifdef USE_X_TOOLKIT
5914 if (! x_window_to_frame (dpyinfo
, event
->xselectionclear
.window
))
5916 #endif /* USE_X_TOOLKIT */
5918 const XSelectionClearEvent
*eventp
= &event
->xselectionclear
;
5920 inev
.ie
.kind
= SELECTION_CLEAR_EVENT
;
5921 SELECTION_EVENT_DISPLAY (&inev
.sie
) = eventp
->display
;
5922 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
5923 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
5927 case SelectionRequest
: /* Someone wants our selection. */
5928 dpyinfo
->last_user_time
= event
->xselectionrequest
.time
;
5929 #ifdef USE_X_TOOLKIT
5930 if (!x_window_to_frame (dpyinfo
, event
->xselectionrequest
.owner
))
5932 #endif /* USE_X_TOOLKIT */
5934 const XSelectionRequestEvent
*eventp
= &event
->xselectionrequest
;
5936 inev
.ie
.kind
= SELECTION_REQUEST_EVENT
;
5937 SELECTION_EVENT_DISPLAY (&inev
.sie
) = eventp
->display
;
5938 SELECTION_EVENT_REQUESTOR (&inev
.sie
) = eventp
->requestor
;
5939 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
5940 SELECTION_EVENT_TARGET (&inev
.sie
) = eventp
->target
;
5941 SELECTION_EVENT_PROPERTY (&inev
.sie
) = eventp
->property
;
5942 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
5946 case PropertyNotify
:
5947 dpyinfo
->last_user_time
= event
->xproperty
.time
;
5948 f
= x_top_window_to_frame (dpyinfo
, event
->xproperty
.window
);
5949 if (f
&& event
->xproperty
.atom
== dpyinfo
->Xatom_net_wm_state
)
5950 if (x_handle_net_wm_state (f
, &event
->xproperty
)
5951 && FRAME_ICONIFIED_P (f
)
5952 && f
->output_data
.x
->net_wm_state_hidden_seen
)
5954 /* Gnome shell does not iconify us when C-z is pressed.
5955 It hides the frame. So if our state says we aren't
5956 hidden anymore, treat it as deiconified. */
5957 SET_FRAME_VISIBLE (f
, 1);
5958 SET_FRAME_ICONIFIED (f
, 0);
5959 f
->output_data
.x
->has_been_visible
= 1;
5960 f
->output_data
.x
->net_wm_state_hidden_seen
= 0;
5961 inev
.ie
.kind
= DEICONIFY_EVENT
;
5962 XSETFRAME (inev
.ie
.frame_or_window
, f
);
5965 x_handle_property_notify (&event
->xproperty
);
5966 xft_settings_event (dpyinfo
, event
);
5969 case ReparentNotify
:
5970 f
= x_top_window_to_frame (dpyinfo
, event
->xreparent
.window
);
5973 f
->output_data
.x
->parent_desc
= event
->xreparent
.parent
;
5974 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
5976 /* Perhaps reparented due to a WM restart. Reset this. */
5977 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_UNKNOWN
;
5978 FRAME_DISPLAY_INFO (f
)->net_supported_window
= 0;
5980 x_set_frame_alpha (f
);
5985 f
= x_window_to_frame (dpyinfo
, event
->xexpose
.window
);
5988 if (!FRAME_VISIBLE_P (f
))
5990 SET_FRAME_VISIBLE (f
, 1);
5991 SET_FRAME_ICONIFIED (f
, 0);
5992 f
->output_data
.x
->has_been_visible
= 1;
5993 SET_FRAME_GARBAGED (f
);
5998 /* This seems to be needed for GTK 2.6 and later, see
5999 http://debbugs.gnu.org/cgi/bugreport.cgi?bug=15398. */
6000 x_clear_area (event
->xexpose
.display
,
6001 event
->xexpose
.window
,
6002 event
->xexpose
.x
, event
->xexpose
.y
,
6003 event
->xexpose
.width
, event
->xexpose
.height
);
6005 expose_frame (f
, event
->xexpose
.x
, event
->xexpose
.y
,
6006 event
->xexpose
.width
, event
->xexpose
.height
);
6011 #ifndef USE_TOOLKIT_SCROLL_BARS
6012 struct scroll_bar
*bar
;
6014 #if defined USE_LUCID
6015 /* Submenus of the Lucid menu bar aren't widgets
6016 themselves, so there's no way to dispatch events
6017 to them. Recognize this case separately. */
6019 Widget widget
= x_window_to_menu_bar (event
->xexpose
.window
);
6021 xlwmenu_redisplay (widget
);
6023 #endif /* USE_LUCID */
6025 #ifdef USE_TOOLKIT_SCROLL_BARS
6026 /* Dispatch event to the widget. */
6028 #else /* not USE_TOOLKIT_SCROLL_BARS */
6029 bar
= x_window_to_scroll_bar (event
->xexpose
.display
,
6030 event
->xexpose
.window
);
6033 x_scroll_bar_expose (bar
, event
);
6034 #ifdef USE_X_TOOLKIT
6037 #endif /* USE_X_TOOLKIT */
6038 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6042 case GraphicsExpose
: /* This occurs when an XCopyArea's
6043 source area was obscured or not
6045 f
= x_window_to_frame (dpyinfo
, event
->xgraphicsexpose
.drawable
);
6047 expose_frame (f
, event
->xgraphicsexpose
.x
,
6048 event
->xgraphicsexpose
.y
,
6049 event
->xgraphicsexpose
.width
,
6050 event
->xgraphicsexpose
.height
);
6051 #ifdef USE_X_TOOLKIT
6054 #endif /* USE_X_TOOLKIT */
6057 case NoExpose
: /* This occurs when an XCopyArea's
6058 source area was completely
6063 /* Redo the mouse-highlight after the tooltip has gone. */
6064 if (event
->xunmap
.window
== tip_window
)
6067 x_redo_mouse_highlight (dpyinfo
);
6070 f
= x_top_window_to_frame (dpyinfo
, event
->xunmap
.window
);
6071 if (f
) /* F may no longer exist if
6072 the frame was deleted. */
6074 bool visible
= FRAME_VISIBLE_P (f
);
6075 /* While a frame is unmapped, display generation is
6076 disabled; you don't want to spend time updating a
6077 display that won't ever be seen. */
6078 SET_FRAME_VISIBLE (f
, 0);
6079 /* We can't distinguish, from the event, whether the window
6080 has become iconified or invisible. So assume, if it
6081 was previously visible, than now it is iconified.
6082 But x_make_frame_invisible clears both
6083 the visible flag and the iconified flag;
6084 and that way, we know the window is not iconified now. */
6085 if (visible
|| FRAME_ICONIFIED_P (f
))
6087 SET_FRAME_ICONIFIED (f
, 1);
6088 inev
.ie
.kind
= ICONIFY_EVENT
;
6089 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6095 if (event
->xmap
.window
== tip_window
)
6096 /* The tooltip has been drawn already. Avoid
6097 the SET_FRAME_GARBAGED below. */
6100 /* We use x_top_window_to_frame because map events can
6101 come for sub-windows and they don't mean that the
6102 frame is visible. */
6103 f
= x_top_window_to_frame (dpyinfo
, event
->xmap
.window
);
6106 bool iconified
= FRAME_ICONIFIED_P (f
);
6107 /* wait_reading_process_output will notice this and update
6108 the frame's display structures.
6109 If we where iconified, we should not set garbaged,
6110 because that stops redrawing on Expose events. This looks
6111 bad if we are called from a recursive event loop
6112 (x_dispatch_event), for example when a dialog is up. */
6114 SET_FRAME_GARBAGED (f
);
6116 /* Check if fullscreen was specified before we where mapped the
6117 first time, i.e. from the command line. */
6118 if (!f
->output_data
.x
->has_been_visible
)
6119 x_check_fullscreen (f
);
6121 SET_FRAME_VISIBLE (f
, 1);
6122 SET_FRAME_ICONIFIED (f
, 0);
6123 f
->output_data
.x
->has_been_visible
= 1;
6127 inev
.ie
.kind
= DEICONIFY_EVENT
;
6128 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6130 else if (! NILP (Vframe_list
) && ! NILP (XCDR (Vframe_list
)))
6131 /* Force a redisplay sooner or later to update the
6132 frame titles in case this is the second frame. */
6133 record_asynch_buffer_change ();
6136 xg_frame_resized (f
, -1, -1);
6143 dpyinfo
->last_user_time
= event
->xkey
.time
;
6144 ignore_next_mouse_click_timeout
= 0;
6146 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6147 /* Dispatch KeyPress events when in menu. */
6148 if (popup_activated ())
6154 #if ! defined (USE_GTK)
6155 /* If mouse-highlight is an integer, input clears out
6156 mouse highlighting. */
6157 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
6159 || !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
)))
6161 clear_mouse_face (hlinfo
);
6162 hlinfo
->mouse_face_hidden
= 1;
6166 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
6169 /* Scroll bars consume key events, but we want
6170 the keys to go to the scroll bar's frame. */
6171 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
6172 event
->xkey
.window
);
6173 if (widget
&& XmIsScrollBar (widget
))
6175 widget
= XtParent (widget
);
6176 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
6179 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
6183 KeySym keysym
, orig_keysym
;
6184 /* al%imercury@uunet.uu.net says that making this 81
6185 instead of 80 fixed a bug whereby meta chars made
6188 It seems that some version of XmbLookupString has
6189 a bug of not returning XBufferOverflow in
6190 status_return even if the input is too long to
6191 fit in 81 bytes. So, we must prepare sufficient
6192 bytes for copy_buffer. 513 bytes (256 chars for
6193 two-byte character set) seems to be a fairly good
6194 approximation. -- 2000.8.10 handa@etl.go.jp */
6195 unsigned char copy_buffer
[513];
6196 unsigned char *copy_bufptr
= copy_buffer
;
6197 int copy_bufsiz
= sizeof (copy_buffer
);
6199 Lisp_Object coding_system
= Qlatin_1
;
6201 /* Event will be modified. */
6202 XKeyEvent xkey
= event
->xkey
;
6205 /* Don't pass keys to GTK. A Tab will shift focus to the
6206 tool bar in GTK 2.4. Keys will still go to menus and
6207 dialogs because in that case popup_activated is nonzero
6209 *finish
= X_EVENT_DROP
;
6212 xkey
.state
|= x_emacs_to_x_modifiers (FRAME_DISPLAY_INFO (f
),
6213 extra_keyboard_modifiers
);
6214 modifiers
= xkey
.state
;
6216 /* This will have to go some day... */
6218 /* make_lispy_event turns chars into control chars.
6219 Don't do it here because XLookupString is too eager. */
6220 xkey
.state
&= ~ControlMask
;
6221 xkey
.state
&= ~(dpyinfo
->meta_mod_mask
6222 | dpyinfo
->super_mod_mask
6223 | dpyinfo
->hyper_mod_mask
6224 | dpyinfo
->alt_mod_mask
);
6226 /* In case Meta is ComposeCharacter,
6227 clear its status. According to Markus Ehrnsperger
6228 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
6229 this enables ComposeCharacter to work whether or
6230 not it is combined with Meta. */
6231 if (modifiers
& dpyinfo
->meta_mod_mask
)
6232 memset (&compose_status
, 0, sizeof (compose_status
));
6237 Status status_return
;
6239 coding_system
= Vlocale_coding_system
;
6240 nbytes
= XmbLookupString (FRAME_XIC (f
),
6241 &xkey
, (char *) copy_bufptr
,
6242 copy_bufsiz
, &keysym
,
6244 if (status_return
== XBufferOverflow
)
6246 copy_bufsiz
= nbytes
+ 1;
6247 copy_bufptr
= alloca (copy_bufsiz
);
6248 nbytes
= XmbLookupString (FRAME_XIC (f
),
6249 &xkey
, (char *) copy_bufptr
,
6250 copy_bufsiz
, &keysym
,
6253 /* Xutf8LookupString is a new but already deprecated interface. -stef */
6254 if (status_return
== XLookupNone
)
6256 else if (status_return
== XLookupChars
)
6261 else if (status_return
!= XLookupKeySym
6262 && status_return
!= XLookupBoth
)
6266 nbytes
= XLookupString (&xkey
, (char *) copy_bufptr
,
6267 copy_bufsiz
, &keysym
,
6270 nbytes
= XLookupString (&xkey
, (char *) copy_bufptr
,
6271 copy_bufsiz
, &keysym
,
6275 /* If not using XIM/XIC, and a compose sequence is in progress,
6276 we break here. Otherwise, chars_matched is always 0. */
6277 if (compose_status
.chars_matched
> 0 && nbytes
== 0)
6280 memset (&compose_status
, 0, sizeof (compose_status
));
6281 orig_keysym
= keysym
;
6283 /* Common for all keysym input events. */
6284 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6286 = x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), modifiers
);
6287 inev
.ie
.timestamp
= xkey
.time
;
6289 /* First deal with keysyms which have defined
6290 translations to characters. */
6291 if (keysym
>= 32 && keysym
< 128)
6292 /* Avoid explicitly decoding each ASCII character. */
6294 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
6295 inev
.ie
.code
= keysym
;
6299 /* Keysyms directly mapped to Unicode characters. */
6300 if (keysym
>= 0x01000000 && keysym
<= 0x0110FFFF)
6302 if (keysym
< 0x01000080)
6303 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
6305 inev
.ie
.kind
= MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
6306 inev
.ie
.code
= keysym
& 0xFFFFFF;
6310 /* Now non-ASCII. */
6311 if (HASH_TABLE_P (Vx_keysym_table
)
6312 && (c
= Fgethash (make_number (keysym
),
6317 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (XFASTINT (c
))
6318 ? ASCII_KEYSTROKE_EVENT
6319 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6320 inev
.ie
.code
= XFASTINT (c
);
6324 /* Random non-modifier sorts of keysyms. */
6325 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
6326 || keysym
== XK_Delete
6327 #ifdef XK_ISO_Left_Tab
6328 || (keysym
>= XK_ISO_Left_Tab
6329 && keysym
<= XK_ISO_Enter
)
6331 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
6332 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
6334 /* This recognizes the "extended function
6335 keys". It seems there's no cleaner way.
6336 Test IsModifierKey to avoid handling
6337 mode_switch incorrectly. */
6338 || (XK_Select
<= keysym
&& keysym
< XK_KP_Space
)
6340 #ifdef XK_dead_circumflex
6341 || orig_keysym
== XK_dead_circumflex
6343 #ifdef XK_dead_grave
6344 || orig_keysym
== XK_dead_grave
6346 #ifdef XK_dead_tilde
6347 || orig_keysym
== XK_dead_tilde
6349 #ifdef XK_dead_diaeresis
6350 || orig_keysym
== XK_dead_diaeresis
6352 #ifdef XK_dead_macron
6353 || orig_keysym
== XK_dead_macron
6355 #ifdef XK_dead_degree
6356 || orig_keysym
== XK_dead_degree
6358 #ifdef XK_dead_acute
6359 || orig_keysym
== XK_dead_acute
6361 #ifdef XK_dead_cedilla
6362 || orig_keysym
== XK_dead_cedilla
6364 #ifdef XK_dead_breve
6365 || orig_keysym
== XK_dead_breve
6367 #ifdef XK_dead_ogonek
6368 || orig_keysym
== XK_dead_ogonek
6370 #ifdef XK_dead_caron
6371 || orig_keysym
== XK_dead_caron
6373 #ifdef XK_dead_doubleacute
6374 || orig_keysym
== XK_dead_doubleacute
6376 #ifdef XK_dead_abovedot
6377 || orig_keysym
== XK_dead_abovedot
6379 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
6380 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
6381 /* Any "vendor-specific" key is ok. */
6382 || (orig_keysym
& (1 << 28))
6383 || (keysym
!= NoSymbol
&& nbytes
== 0))
6384 && ! (IsModifierKey (orig_keysym
)
6385 /* The symbols from XK_ISO_Lock
6386 to XK_ISO_Last_Group_Lock
6387 don't have real modifiers but
6388 should be treated similarly to
6389 Mode_switch by Emacs. */
6390 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
6391 || (XK_ISO_Lock
<= orig_keysym
6392 && orig_keysym
<= XK_ISO_Last_Group_Lock
)
6396 STORE_KEYSYM_FOR_DEBUG (keysym
);
6397 /* make_lispy_event will convert this to a symbolic
6399 inev
.ie
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
6400 inev
.ie
.code
= keysym
;
6404 { /* Raw bytes, not keysym. */
6408 for (i
= 0, nchars
= 0; i
< nbytes
; i
++)
6410 if (ASCII_BYTE_P (copy_bufptr
[i
]))
6412 STORE_KEYSYM_FOR_DEBUG (copy_bufptr
[i
]);
6415 if (nchars
< nbytes
)
6417 /* Decode the input data. */
6419 /* The input should be decoded with `coding_system'
6420 which depends on which X*LookupString function
6421 we used just above and the locale. */
6422 setup_coding_system (coding_system
, &coding
);
6423 coding
.src_multibyte
= 0;
6424 coding
.dst_multibyte
= 1;
6425 /* The input is converted to events, thus we can't
6426 handle composition. Anyway, there's no XIM that
6427 gives us composition information. */
6428 coding
.common_flags
&= ~CODING_ANNOTATION_MASK
;
6430 SAFE_NALLOCA (coding
.destination
, MAX_MULTIBYTE_LENGTH
,
6432 coding
.dst_bytes
= MAX_MULTIBYTE_LENGTH
* nbytes
;
6433 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
6434 decode_coding_c_string (&coding
, copy_bufptr
, nbytes
, Qnil
);
6435 nbytes
= coding
.produced
;
6436 nchars
= coding
.produced_char
;
6437 copy_bufptr
= coding
.destination
;
6440 /* Convert the input data to a sequence of
6441 character events. */
6442 for (i
= 0; i
< nbytes
; i
+= len
)
6445 if (nchars
== nbytes
)
6446 ch
= copy_bufptr
[i
], len
= 1;
6448 ch
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
, len
);
6449 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (ch
)
6450 ? ASCII_KEYSTROKE_EVENT
6451 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6453 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
6458 inev
.ie
.kind
= NO_EVENT
; /* Already stored above. */
6460 if (keysym
== NoSymbol
)
6463 /* FIXME: check side effects and remove this. */
6464 ((XEvent
*) event
)->xkey
= xkey
;
6468 /* Don't dispatch this event since XtDispatchEvent calls
6469 XFilterEvent, and two calls in a row may freeze the
6477 dpyinfo
->last_user_time
= event
->xkey
.time
;
6479 /* Don't dispatch this event since XtDispatchEvent calls
6480 XFilterEvent, and two calls in a row may freeze the
6488 dpyinfo
->last_user_time
= event
->xcrossing
.time
;
6489 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
6493 if (f
&& x_mouse_click_focus_ignore_position
)
6494 ignore_next_mouse_click_timeout
= event
->xmotion
.time
+ 200;
6496 /* EnterNotify counts as mouse movement,
6497 so update things that depend on mouse position. */
6498 if (f
&& !f
->output_data
.x
->hourglass_p
)
6499 note_mouse_movement (f
, &event
->xmotion
);
6501 /* We may get an EnterNotify on the buttons in the toolbar. In that
6502 case we moved out of any highlighted area and need to note this. */
6503 if (!f
&& dpyinfo
->last_mouse_glyph_frame
)
6504 note_mouse_movement (dpyinfo
->last_mouse_glyph_frame
, &event
->xmotion
);
6509 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
6513 dpyinfo
->last_user_time
= event
->xcrossing
.time
;
6514 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
6516 f
= x_top_window_to_frame (dpyinfo
, event
->xcrossing
.window
);
6519 if (f
== hlinfo
->mouse_face_mouse_frame
)
6521 /* If we move outside the frame, then we're
6522 certainly no longer on any text in the frame. */
6523 clear_mouse_face (hlinfo
);
6524 hlinfo
->mouse_face_mouse_frame
= 0;
6527 /* Generate a nil HELP_EVENT to cancel a help-echo.
6528 Do it only if there's something to cancel.
6529 Otherwise, the startup message is cleared when
6530 the mouse leaves the frame. */
6531 if (any_help_event_p
)
6535 /* See comment in EnterNotify above */
6536 else if (dpyinfo
->last_mouse_glyph_frame
)
6537 note_mouse_movement (dpyinfo
->last_mouse_glyph_frame
, &event
->xmotion
);
6542 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
6547 dpyinfo
->last_user_time
= event
->xmotion
.time
;
6548 previous_help_echo_string
= help_echo_string
;
6549 help_echo_string
= Qnil
;
6551 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
6552 : x_window_to_frame (dpyinfo
, event
->xmotion
.window
));
6554 if (hlinfo
->mouse_face_hidden
)
6556 hlinfo
->mouse_face_hidden
= 0;
6557 clear_mouse_face (hlinfo
);
6561 if (f
&& xg_event_is_for_scrollbar (f
, event
))
6567 /* Generate SELECT_WINDOW_EVENTs when needed.
6568 Don't let popup menus influence things (bug#1261). */
6569 if (!NILP (Vmouse_autoselect_window
) && !popup_activated ())
6571 static Lisp_Object last_mouse_window
;
6572 Lisp_Object window
= window_from_coordinates
6573 (f
, event
->xmotion
.x
, event
->xmotion
.y
, 0, 0);
6575 /* Window will be selected only when it is not selected now and
6576 last mouse movement event was not in it. Minibuffer window
6577 will be selected only when it is active. */
6578 if (WINDOWP (window
)
6579 && !EQ (window
, last_mouse_window
)
6580 && !EQ (window
, selected_window
)
6581 /* For click-to-focus window managers
6582 create event iff we don't leave the
6584 && (focus_follows_mouse
6585 || (EQ (XWINDOW (window
)->frame
,
6586 XWINDOW (selected_window
)->frame
))))
6588 inev
.ie
.kind
= SELECT_WINDOW_EVENT
;
6589 inev
.ie
.frame_or_window
= window
;
6591 /* Remember the last window where we saw the mouse. */
6592 last_mouse_window
= window
;
6594 if (!note_mouse_movement (f
, &event
->xmotion
))
6595 help_echo_string
= previous_help_echo_string
;
6599 #ifndef USE_TOOLKIT_SCROLL_BARS
6600 struct scroll_bar
*bar
6601 = x_window_to_scroll_bar (event
->xmotion
.display
,
6602 event
->xmotion
.window
);
6605 x_scroll_bar_note_movement (bar
, &event
->xmotion
);
6606 #endif /* USE_TOOLKIT_SCROLL_BARS */
6608 /* If we move outside the frame, then we're
6609 certainly no longer on any text in the frame. */
6610 clear_mouse_face (hlinfo
);
6613 /* If the contents of the global variable help_echo_string
6614 has changed, generate a HELP_EVENT. */
6615 if (!NILP (help_echo_string
)
6616 || !NILP (previous_help_echo_string
))
6621 case ConfigureNotify
:
6622 f
= x_top_window_to_frame (dpyinfo
, event
->xconfigure
.window
);
6626 && event
->xconfigure
.window
== FRAME_X_WINDOW (f
))
6628 xg_frame_resized (f
, event
->xconfigure
.width
,
6629 event
->xconfigure
.height
);
6635 #ifndef USE_X_TOOLKIT
6637 int width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, event
->xconfigure
.width
);
6638 int height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, event
->xconfigure
.height
);
6640 /* In the toolkit version, change_frame_size
6641 is called by the code that handles resizing
6642 of the EmacsFrame widget. */
6644 /* Even if the number of character rows and columns has
6645 not changed, the font size may have changed, so we need
6646 to check the pixel dimensions as well. */
6647 if (width
!= FRAME_TEXT_WIDTH (f
)
6648 || height
!= FRAME_TEXT_HEIGHT (f
)
6649 || event
->xconfigure
.width
!= FRAME_PIXEL_WIDTH (f
)
6650 || event
->xconfigure
.height
!= FRAME_PIXEL_HEIGHT (f
))
6652 change_frame_size (f
, width
, height
, 0, 1, 0, 1);
6653 x_clear_under_internal_border (f
);
6654 SET_FRAME_GARBAGED (f
);
6655 cancel_mouse_face (f
);
6658 /** FRAME_PIXEL_WIDTH (f) = event->xconfigure.width; **/
6659 /** FRAME_PIXEL_HEIGHT (f) = event->xconfigure.height; **/
6660 #endif /* not USE_GTK */
6664 /* GTK creates windows but doesn't map them.
6665 Only get real positions when mapped. */
6666 if (FRAME_GTK_OUTER_WIDGET (f
)
6667 && gtk_widget_get_mapped (FRAME_GTK_OUTER_WIDGET (f
)))
6669 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
6672 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
6673 xic_set_statusarea (f
);
6682 /* If we decide we want to generate an event to be seen
6683 by the rest of Emacs, we put it here. */
6684 bool tool_bar_p
= 0;
6686 memset (&compose_status
, 0, sizeof (compose_status
));
6687 dpyinfo
->last_mouse_glyph_frame
= NULL
;
6688 dpyinfo
->last_user_time
= event
->xbutton
.time
;
6690 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
6691 : x_window_to_frame (dpyinfo
, event
->xbutton
.window
));
6694 if (f
&& xg_event_is_for_scrollbar (f
, event
))
6699 #if ! defined (USE_GTK)
6700 /* Is this in the tool-bar? */
6701 if (WINDOWP (f
->tool_bar_window
)
6702 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
6705 int x
= event
->xbutton
.x
;
6706 int y
= event
->xbutton
.y
;
6708 window
= window_from_coordinates (f
, x
, y
, 0, 1);
6709 tool_bar_p
= EQ (window
, f
->tool_bar_window
);
6711 if (tool_bar_p
&& event
->xbutton
.button
< 4)
6712 handle_tool_bar_click
6713 (f
, x
, y
, event
->xbutton
.type
== ButtonPress
,
6714 x_x_to_emacs_modifiers (dpyinfo
, event
->xbutton
.state
));
6716 #endif /* !USE_GTK */
6719 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6720 if (! popup_activated ())
6723 if (ignore_next_mouse_click_timeout
)
6725 if (event
->type
== ButtonPress
6726 && event
->xbutton
.time
> ignore_next_mouse_click_timeout
)
6728 ignore_next_mouse_click_timeout
= 0;
6729 construct_mouse_click (&inev
.ie
, &event
->xbutton
, f
);
6731 if (event
->type
== ButtonRelease
)
6732 ignore_next_mouse_click_timeout
= 0;
6735 construct_mouse_click (&inev
.ie
, &event
->xbutton
, f
);
6737 if (FRAME_X_EMBEDDED_P (f
))
6738 xembed_send_message (f
, event
->xbutton
.time
,
6739 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
6743 struct scroll_bar
*bar
6744 = x_window_to_scroll_bar (event
->xbutton
.display
,
6745 event
->xbutton
.window
);
6747 #ifdef USE_TOOLKIT_SCROLL_BARS
6748 /* Make the "Ctrl-Mouse-2 splits window" work for toolkit
6750 if (bar
&& event
->xbutton
.state
& ControlMask
)
6752 x_scroll_bar_handle_click (bar
, event
, &inev
.ie
);
6753 *finish
= X_EVENT_DROP
;
6755 #else /* not USE_TOOLKIT_SCROLL_BARS */
6757 x_scroll_bar_handle_click (bar
, event
, &inev
.ie
);
6758 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6761 if (event
->type
== ButtonPress
)
6763 dpyinfo
->grabbed
|= (1 << event
->xbutton
.button
);
6764 dpyinfo
->last_mouse_frame
= f
;
6767 last_tool_bar_item
= -1;
6770 dpyinfo
->grabbed
&= ~(1 << event
->xbutton
.button
);
6772 /* Ignore any mouse motion that happened before this event;
6773 any subsequent mouse-movement Emacs events should reflect
6774 only motion after the ButtonPress/Release. */
6778 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6779 f
= x_menubar_window_to_frame (dpyinfo
, event
);
6780 /* For a down-event in the menu bar,
6781 don't pass it to Xt right now.
6782 Instead, save it away
6783 and we will pass it to Xt from kbd_buffer_get_event.
6784 That way, we can run some Lisp code first. */
6785 if (! popup_activated ()
6787 /* Gtk+ menus only react to the first three buttons. */
6788 && event
->xbutton
.button
< 3
6790 && f
&& event
->type
== ButtonPress
6791 /* Verify the event is really within the menu bar
6792 and not just sent to it due to grabbing. */
6793 && event
->xbutton
.x
>= 0
6794 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
6795 && event
->xbutton
.y
>= 0
6796 && event
->xbutton
.y
< f
->output_data
.x
->menubar_height
6797 && event
->xbutton
.same_screen
)
6799 if (!f
->output_data
.x
->saved_menu_event
)
6800 f
->output_data
.x
->saved_menu_event
= xmalloc (sizeof *event
);
6801 *f
->output_data
.x
->saved_menu_event
= *event
;
6802 inev
.ie
.kind
= MENU_BAR_ACTIVATE_EVENT
;
6803 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6804 *finish
= X_EVENT_DROP
;
6808 #endif /* USE_X_TOOLKIT || USE_GTK */
6812 case CirculateNotify
:
6815 case CirculateRequest
:
6818 case VisibilityNotify
:
6822 /* Someone has changed the keyboard mapping - update the
6824 switch (event
->xmapping
.request
)
6826 case MappingModifier
:
6827 x_find_modifier_meanings (dpyinfo
);
6828 /* This is meant to fall through. */
6829 case MappingKeyboard
:
6830 XRefreshKeyboardMapping ((XMappingEvent
*) &event
->xmapping
);
6835 xft_settings_event (dpyinfo
, event
);
6840 #ifdef USE_X_TOOLKIT
6842 if (*finish
!= X_EVENT_DROP
)
6843 XtDispatchEvent ((XEvent
*) event
);
6845 #endif /* USE_X_TOOLKIT */
6850 if (inev
.ie
.kind
!= NO_EVENT
)
6852 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
6857 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
6862 XSETFRAME (frame
, f
);
6868 any_help_event_p
= 1;
6869 gen_help_event (help_echo_string
, frame
, help_echo_window
,
6870 help_echo_object
, help_echo_pos
);
6874 help_echo_string
= Qnil
;
6875 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
6884 /* Handles the XEvent EVENT on display DISPLAY.
6885 This is used for event loops outside the normal event handling,
6886 i.e. looping while a popup menu or a dialog is posted.
6888 Returns the value handle_one_xevent sets in the finish argument. */
6890 x_dispatch_event (XEvent
*event
, Display
*display
)
6892 struct x_display_info
*dpyinfo
;
6893 int finish
= X_EVENT_NORMAL
;
6895 dpyinfo
= x_display_info_for_display (display
);
6898 handle_one_xevent (dpyinfo
, event
, &finish
, 0);
6903 /* Read events coming from the X server.
6904 Return as soon as there are no more events to be read.
6906 Return the number of characters stored into the buffer,
6907 thus pretending to be `read' (except the characters we store
6908 in the keyboard buffer can be multibyte, so are not necessarily
6912 XTread_socket (struct terminal
*terminal
, struct input_event
*hold_quit
)
6915 int event_found
= 0;
6916 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
6920 /* For debugging, this gives a way to fake an I/O error. */
6921 if (dpyinfo
== XTread_socket_fake_io_error
)
6923 XTread_socket_fake_io_error
= 0;
6924 x_io_error_quitter (dpyinfo
->display
);
6928 while (XPending (dpyinfo
->display
))
6933 XNextEvent (dpyinfo
->display
, &event
);
6936 /* Filter events for the current X input method. */
6937 if (x_filter_event (dpyinfo
, &event
))
6942 count
+= handle_one_xevent (dpyinfo
, &event
, &finish
, hold_quit
);
6944 if (finish
== X_EVENT_GOTO_OUT
)
6950 /* For GTK we must use the GTK event loop. But XEvents gets passed
6951 to our filter function above, and then to the big event switch.
6952 We use a bunch of globals to communicate with our filter function,
6953 that is kind of ugly, but it works.
6955 There is no way to do one display at the time, GTK just does events
6956 from all displays. */
6958 while (gtk_events_pending ())
6960 current_count
= count
;
6961 current_hold_quit
= hold_quit
;
6963 gtk_main_iteration ();
6965 count
= current_count
;
6967 current_hold_quit
= 0;
6969 if (current_finish
== X_EVENT_GOTO_OUT
)
6972 #endif /* USE_GTK */
6974 /* On some systems, an X bug causes Emacs to get no more events
6975 when the window is destroyed. Detect that. (1994.) */
6978 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
6979 One XNOOP in 100 loops will make Emacs terminate.
6980 B. Bretthauer, 1994 */
6982 if (x_noop_count
>= 100)
6986 if (next_noop_dpyinfo
== 0)
6987 next_noop_dpyinfo
= x_display_list
;
6989 XNoOp (next_noop_dpyinfo
->display
);
6991 /* Each time we get here, cycle through the displays now open. */
6992 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
6996 /* If the focus was just given to an auto-raising frame,
6997 raise it now. FIXME: handle more than one such frame. */
6998 if (dpyinfo
->x_pending_autoraise_frame
)
7000 x_raise_frame (dpyinfo
->x_pending_autoraise_frame
);
7001 dpyinfo
->x_pending_autoraise_frame
= NULL
;
7012 /***********************************************************************
7014 ***********************************************************************/
7016 /* Set clipping for output in glyph row ROW. W is the window in which
7017 we operate. GC is the graphics context to set clipping in.
7019 ROW may be a text row or, e.g., a mode line. Text rows must be
7020 clipped to the interior of the window dedicated to text display,
7021 mode lines must be clipped to the whole window. */
7024 x_clip_to_row (struct window
*w
, struct glyph_row
*row
,
7025 enum glyph_row_area area
, GC gc
)
7027 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7028 XRectangle clip_rect
;
7029 int window_x
, window_y
, window_width
;
7031 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
7033 clip_rect
.x
= window_x
;
7034 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, row
->y
));
7035 clip_rect
.y
= max (clip_rect
.y
, window_y
);
7036 clip_rect
.width
= window_width
;
7037 clip_rect
.height
= row
->visible_height
;
7039 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
7043 /* Draw a hollow box cursor on window W in glyph row ROW. */
7046 x_draw_hollow_cursor (struct window
*w
, struct glyph_row
*row
)
7048 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7049 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
7050 Display
*dpy
= FRAME_X_DISPLAY (f
);
7053 struct glyph
*cursor_glyph
;
7056 /* Get the glyph the cursor is on. If we can't tell because
7057 the current matrix is invalid or such, give up. */
7058 cursor_glyph
= get_phys_cursor_glyph (w
);
7059 if (cursor_glyph
== NULL
)
7062 /* Compute frame-relative coordinates for phys cursor. */
7063 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &x
, &y
, &h
);
7064 wd
= w
->phys_cursor_width
;
7066 /* The foreground of cursor_gc is typically the same as the normal
7067 background color, which can cause the cursor box to be invisible. */
7068 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7069 if (dpyinfo
->scratch_cursor_gc
)
7070 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
7072 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
7073 GCForeground
, &xgcv
);
7074 gc
= dpyinfo
->scratch_cursor_gc
;
7076 /* Set clipping, draw the rectangle, and reset clipping again. */
7077 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7078 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
- 1);
7079 XSetClipMask (dpy
, gc
, None
);
7083 /* Draw a bar cursor on window W in glyph row ROW.
7085 Implementation note: One would like to draw a bar cursor with an
7086 angle equal to the one given by the font property XA_ITALIC_ANGLE.
7087 Unfortunately, I didn't find a font yet that has this property set.
7091 x_draw_bar_cursor (struct window
*w
, struct glyph_row
*row
, int width
, enum text_cursor_kinds kind
)
7093 struct frame
*f
= XFRAME (w
->frame
);
7094 struct glyph
*cursor_glyph
;
7096 /* If cursor is out of bounds, don't draw garbage. This can happen
7097 in mini-buffer windows when switching between echo area glyphs
7099 cursor_glyph
= get_phys_cursor_glyph (w
);
7100 if (cursor_glyph
== NULL
)
7103 /* If on an image, draw like a normal cursor. That's usually better
7104 visible than drawing a bar, esp. if the image is large so that
7105 the bar might not be in the window. */
7106 if (cursor_glyph
->type
== IMAGE_GLYPH
)
7108 struct glyph_row
*r
;
7109 r
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
7110 draw_phys_cursor_glyph (w
, r
, DRAW_CURSOR
);
7114 Display
*dpy
= FRAME_X_DISPLAY (f
);
7115 Window window
= FRAME_X_WINDOW (f
);
7116 GC gc
= FRAME_DISPLAY_INFO (f
)->scratch_cursor_gc
;
7117 unsigned long mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
7118 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
7121 /* If the glyph's background equals the color we normally draw
7122 the bars cursor in, the bar cursor in its normal color is
7123 invisible. Use the glyph's foreground color instead in this
7124 case, on the assumption that the glyph's colors are chosen so
7125 that the glyph is legible. */
7126 if (face
->background
== f
->output_data
.x
->cursor_pixel
)
7127 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
7129 xgcv
.background
= xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7130 xgcv
.graphics_exposures
= 0;
7133 XChangeGC (dpy
, gc
, mask
, &xgcv
);
7136 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
7137 FRAME_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
7140 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7142 if (kind
== BAR_CURSOR
)
7144 int x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
7147 width
= FRAME_CURSOR_WIDTH (f
);
7148 width
= min (cursor_glyph
->pixel_width
, width
);
7150 w
->phys_cursor_width
= width
;
7152 /* If the character under cursor is R2L, draw the bar cursor
7153 on the right of its glyph, rather than on the left. */
7154 if ((cursor_glyph
->resolved_level
& 1) != 0)
7155 x
+= cursor_glyph
->pixel_width
- width
;
7157 XFillRectangle (dpy
, window
, gc
, x
,
7158 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
7159 width
, row
->height
);
7163 int dummy_x
, dummy_y
, dummy_h
;
7166 width
= row
->height
;
7168 width
= min (row
->height
, width
);
7170 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &dummy_x
,
7171 &dummy_y
, &dummy_h
);
7173 XFillRectangle (dpy
, window
, gc
,
7174 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
7175 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
7176 row
->height
- width
),
7177 w
->phys_cursor_width
, width
);
7180 XSetClipMask (dpy
, gc
, None
);
7185 /* RIF: Define cursor CURSOR on frame F. */
7188 x_define_frame_cursor (struct frame
*f
, Cursor cursor
)
7190 if (!f
->pointer_invisible
7191 && f
->output_data
.x
->current_cursor
!= cursor
)
7192 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
7193 f
->output_data
.x
->current_cursor
= cursor
;
7197 /* RIF: Clear area on frame F. */
7200 x_clear_frame_area (struct frame
*f
, int x
, int y
, int width
, int height
)
7202 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), x
, y
, width
, height
);
7204 /* Must queue a redraw, because scroll bars might have been cleared. */
7205 if (FRAME_GTK_WIDGET (f
))
7206 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
7211 /* RIF: Draw cursor on window W. */
7214 x_draw_window_cursor (struct window
*w
, struct glyph_row
*glyph_row
, int x
,
7215 int y
, enum text_cursor_kinds cursor_type
,
7216 int cursor_width
, bool on_p
, bool active_p
)
7218 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7222 w
->phys_cursor_type
= cursor_type
;
7223 w
->phys_cursor_on_p
= 1;
7225 if (glyph_row
->exact_window_width_line_p
7226 && (glyph_row
->reversed_p
7227 ? (w
->phys_cursor
.hpos
< 0)
7228 : (w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])))
7230 glyph_row
->cursor_in_fringe_p
= 1;
7231 draw_fringe_bitmap (w
, glyph_row
, glyph_row
->reversed_p
);
7235 switch (cursor_type
)
7237 case HOLLOW_BOX_CURSOR
:
7238 x_draw_hollow_cursor (w
, glyph_row
);
7241 case FILLED_BOX_CURSOR
:
7242 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
7246 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
7250 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
7254 w
->phys_cursor_width
= 0;
7263 if (w
== XWINDOW (f
->selected_window
))
7264 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
7265 xic_set_preeditarea (w
, x
, y
);
7269 XFlush (FRAME_X_DISPLAY (f
));
7275 /* Make the x-window of frame F use the gnu icon bitmap. */
7278 x_bitmap_icon (struct frame
*f
, Lisp_Object file
)
7280 ptrdiff_t bitmap_id
;
7282 if (FRAME_X_WINDOW (f
) == 0)
7285 /* Free up our existing icon bitmap and mask if any. */
7286 if (f
->output_data
.x
->icon_bitmap
> 0)
7287 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7288 f
->output_data
.x
->icon_bitmap
= 0;
7293 /* Use gtk_window_set_icon_from_file () if available,
7294 It's not restricted to bitmaps */
7295 if (xg_set_icon (f
, file
))
7297 #endif /* USE_GTK */
7298 bitmap_id
= x_create_bitmap_from_file (f
, file
);
7299 x_create_bitmap_mask (f
, bitmap_id
);
7303 /* Create the GNU bitmap and mask if necessary. */
7304 if (FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
7310 if (xg_set_icon (f
, xg_default_icon_file
)
7311 || xg_set_icon_from_xpm_data (f
, gnu_xpm_bits
))
7314 #elif defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
7316 rc
= x_create_bitmap_from_xpm_data (f
, gnu_xpm_bits
);
7318 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
7322 /* If all else fails, use the (black and white) xbm image. */
7325 rc
= x_create_bitmap_from_data (f
, (char *) gnu_xbm_bits
,
7326 gnu_xbm_width
, gnu_xbm_height
);
7330 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
7331 x_create_bitmap_mask (f
, FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
);
7335 /* The first time we create the GNU bitmap and mask,
7336 this increments the ref-count one extra time.
7337 As a result, the GNU bitmap and mask are never freed.
7338 That way, we don't have to worry about allocating it again. */
7339 x_reference_bitmap (f
, FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
);
7341 bitmap_id
= FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
;
7344 x_wm_set_icon_pixmap (f
, bitmap_id
);
7345 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
7351 /* Make the x-window of frame F use a rectangle with text.
7352 Use ICON_NAME as the text. */
7355 x_text_icon (struct frame
*f
, const char *icon_name
)
7357 if (FRAME_X_WINDOW (f
) == 0)
7362 text
.value
= (unsigned char *) icon_name
;
7363 text
.encoding
= XA_STRING
;
7365 text
.nitems
= strlen (icon_name
);
7366 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
7369 if (f
->output_data
.x
->icon_bitmap
> 0)
7370 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7371 f
->output_data
.x
->icon_bitmap
= 0;
7372 x_wm_set_icon_pixmap (f
, 0);
7377 #define X_ERROR_MESSAGE_SIZE 200
7379 /* If non-nil, this should be a string.
7380 It means catch X errors and store the error message in this string.
7382 The reason we use a stack is that x_catch_error/x_uncatch_error can
7383 be called from a signal handler.
7386 struct x_error_message_stack
{
7387 char string
[X_ERROR_MESSAGE_SIZE
];
7389 struct x_error_message_stack
*prev
;
7391 static struct x_error_message_stack
*x_error_message
;
7393 /* An X error handler which stores the error message in
7394 *x_error_message. This is called from x_error_handler if
7395 x_catch_errors is in effect. */
7398 x_error_catcher (Display
*display
, XErrorEvent
*event
)
7400 XGetErrorText (display
, event
->error_code
,
7401 x_error_message
->string
,
7402 X_ERROR_MESSAGE_SIZE
);
7405 /* Begin trapping X errors for display DPY. Actually we trap X errors
7406 for all displays, but DPY should be the display you are actually
7409 After calling this function, X protocol errors no longer cause
7410 Emacs to exit; instead, they are recorded in the string
7411 stored in *x_error_message.
7413 Calling x_check_errors signals an Emacs error if an X error has
7414 occurred since the last call to x_catch_errors or x_check_errors.
7416 Calling x_uncatch_errors resumes the normal error handling. */
7419 x_catch_errors (Display
*dpy
)
7421 struct x_error_message_stack
*data
= xmalloc (sizeof *data
);
7423 /* Make sure any errors from previous requests have been dealt with. */
7427 data
->string
[0] = 0;
7428 data
->prev
= x_error_message
;
7429 x_error_message
= data
;
7432 /* Undo the last x_catch_errors call.
7433 DPY should be the display that was passed to x_catch_errors. */
7436 x_uncatch_errors (void)
7438 struct x_error_message_stack
*tmp
;
7442 /* The display may have been closed before this function is called.
7443 Check if it is still open before calling XSync. */
7444 if (x_display_info_for_display (x_error_message
->dpy
) != 0)
7445 XSync (x_error_message
->dpy
, False
);
7447 tmp
= x_error_message
;
7448 x_error_message
= x_error_message
->prev
;
7453 /* If any X protocol errors have arrived since the last call to
7454 x_catch_errors or x_check_errors, signal an Emacs error using
7455 sprintf (a buffer, FORMAT, the x error message text) as the text. */
7458 x_check_errors (Display
*dpy
, const char *format
)
7460 /* Make sure to catch any errors incurred so far. */
7463 if (x_error_message
->string
[0])
7465 char string
[X_ERROR_MESSAGE_SIZE
];
7466 memcpy (string
, x_error_message
->string
, X_ERROR_MESSAGE_SIZE
);
7467 x_uncatch_errors ();
7468 error (format
, string
);
7472 /* Nonzero if we had any X protocol errors
7473 since we did x_catch_errors on DPY. */
7476 x_had_errors_p (Display
*dpy
)
7478 /* Make sure to catch any errors incurred so far. */
7481 return x_error_message
->string
[0] != 0;
7484 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
7487 x_clear_errors (Display
*dpy
)
7489 x_error_message
->string
[0] = 0;
7492 #if 0 /* See comment in unwind_to_catch why calling this is a bad
7493 * idea. --lorentey */
7494 /* Close off all unclosed x_catch_errors calls. */
7497 x_fully_uncatch_errors (void)
7499 while (x_error_message
)
7500 x_uncatch_errors ();
7505 static unsigned int x_wire_count
;
7508 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
7513 /************************************************************************
7515 ************************************************************************/
7517 /* Error message passed to x_connection_closed. */
7519 static char *error_msg
;
7521 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
7522 the text of an error message that lead to the connection loss. */
7525 x_connection_closed (Display
*dpy
, const char *error_message
)
7527 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
7528 Lisp_Object frame
, tail
;
7529 ptrdiff_t idx
= SPECPDL_INDEX ();
7531 error_msg
= alloca (strlen (error_message
) + 1);
7532 strcpy (error_msg
, error_message
);
7534 /* Inhibit redisplay while frames are being deleted. */
7535 specbind (Qinhibit_redisplay
, Qt
);
7539 /* Protect display from being closed when we delete the last
7541 dpyinfo
->reference_count
++;
7542 dpyinfo
->terminal
->reference_count
++;
7545 /* First delete frames whose mini-buffers are on frames
7546 that are on the dead display. */
7547 FOR_EACH_FRAME (tail
, frame
)
7549 Lisp_Object minibuf_frame
;
7551 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
7552 if (FRAME_X_P (XFRAME (frame
))
7553 && FRAME_X_P (XFRAME (minibuf_frame
))
7554 && ! EQ (frame
, minibuf_frame
)
7555 && FRAME_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
7556 delete_frame (frame
, Qnoelisp
);
7559 /* Now delete all remaining frames on the dead display.
7560 We are now sure none of these is used as the mini-buffer
7561 for another frame that we need to delete. */
7562 FOR_EACH_FRAME (tail
, frame
)
7563 if (FRAME_X_P (XFRAME (frame
))
7564 && FRAME_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
7566 /* Set this to t so that delete_frame won't get confused
7567 trying to find a replacement. */
7568 kset_default_minibuffer_frame (FRAME_KBOARD (XFRAME (frame
)), Qt
);
7569 delete_frame (frame
, Qnoelisp
);
7572 /* If DPYINFO is null, this means we didn't open the display in the
7573 first place, so don't try to close it. */
7576 /* We can not call XtCloseDisplay here because it calls XSync.
7577 XSync inside the error handler apparently hangs Emacs. On
7578 current Xt versions, this isn't needed either. */
7580 /* A long-standing GTK bug prevents proper disconnect handling
7581 (https://bugzilla.gnome.org/show_bug.cgi?id=85715). Once,
7582 the resulting Glib error message loop filled a user's disk.
7583 To avoid this, kill Emacs unconditionally on disconnect. */
7584 shut_down_emacs (0, Qnil
);
7585 fprintf (stderr
, "%s\n\
7586 When compiled with GTK, Emacs cannot recover from X disconnects.\n\
7587 This is a GTK bug: https://bugzilla.gnome.org/show_bug.cgi?id=85715\n\
7588 For details, see etc/PROBLEMS.\n",
7591 #endif /* USE_GTK */
7593 /* Indicate that this display is dead. */
7594 dpyinfo
->display
= 0;
7596 dpyinfo
->reference_count
--;
7597 dpyinfo
->terminal
->reference_count
--;
7598 if (dpyinfo
->reference_count
!= 0)
7599 /* We have just closed all frames on this display. */
7604 XSETTERMINAL (tmp
, dpyinfo
->terminal
);
7605 Fdelete_terminal (tmp
, Qnoelisp
);
7609 if (terminal_list
== 0)
7611 fprintf (stderr
, "%s\n", error_msg
);
7612 Fkill_emacs (make_number (70));
7616 totally_unblock_input ();
7618 unbind_to (idx
, Qnil
);
7619 clear_waiting_for_input ();
7621 /* Tell GCC not to suggest attribute 'noreturn' for this function. */
7622 IF_LINT (if (! terminal_list
) return; )
7624 /* Here, we absolutely have to use a non-local exit (e.g. signal, throw,
7625 longjmp), because returning from this function would get us back into
7626 Xlib's code which will directly call `exit'. */
7627 error ("%s", error_msg
);
7630 /* We specifically use it before defining it, so that gcc doesn't inline it,
7631 otherwise gdb doesn't know how to properly put a breakpoint on it. */
7632 static void x_error_quitter (Display
*, XErrorEvent
*);
7634 /* This is the first-level handler for X protocol errors.
7635 It calls x_error_quitter or x_error_catcher. */
7638 x_error_handler (Display
*display
, XErrorEvent
*event
)
7640 #if defined USE_GTK && defined HAVE_GTK3
7641 if ((event
->error_code
== BadMatch
|| event
->error_code
== BadWindow
)
7642 && event
->request_code
== X_SetInputFocus
)
7648 if (x_error_message
)
7649 x_error_catcher (display
, event
);
7651 x_error_quitter (display
, event
);
7655 /* This is the usual handler for X protocol errors.
7656 It kills all frames on the display that we got the error for.
7657 If that was the only one, it prints an error message and kills Emacs. */
7659 /* .gdbinit puts a breakpoint here, so make sure it is not inlined. */
7661 /* On older GCC versions, just putting x_error_quitter
7662 after x_error_handler prevents inlining into the former. */
7664 static void NO_INLINE
7665 x_error_quitter (Display
*display
, XErrorEvent
*event
)
7667 char buf
[256], buf1
[356];
7669 /* Ignore BadName errors. They can happen because of fonts
7670 or colors that are not defined. */
7672 if (event
->error_code
== BadName
)
7675 /* Note that there is no real way portable across R3/R4 to get the
7676 original error handler. */
7678 XGetErrorText (display
, event
->error_code
, buf
, sizeof (buf
));
7679 sprintf (buf1
, "X protocol error: %s on protocol request %d",
7680 buf
, event
->request_code
);
7681 x_connection_closed (display
, buf1
);
7685 /* This is the handler for X IO errors, always.
7686 It kills all frames on the display that we lost touch with.
7687 If that was the only one, it prints an error message and kills Emacs. */
7690 x_io_error_quitter (Display
*display
)
7694 snprintf (buf
, sizeof buf
, "Connection lost to X server `%s'",
7695 DisplayString (display
));
7696 x_connection_closed (display
, buf
);
7700 /* Changing the font of the frame. */
7702 /* Give frame F the font FONT-OBJECT as its default font. The return
7703 value is FONT-OBJECT. FONTSET is an ID of the fontset for the
7704 frame. If it is negative, generate a new fontset from
7708 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
7710 struct font
*font
= XFONT_OBJECT (font_object
);
7714 fontset
= fontset_from_font (font_object
);
7715 FRAME_FONTSET (f
) = fontset
;
7716 if (FRAME_FONT (f
) == font
)
7717 /* This font is already set in frame F. There's nothing more to
7721 FRAME_FONT (f
) = font
;
7722 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
7723 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
7724 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (font
);
7726 FRAME_TOOL_BAR_HEIGHT (f
) = FRAME_TOOL_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
);
7727 FRAME_MENU_BAR_HEIGHT (f
) = FRAME_MENU_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
);
7729 compute_fringe_widths (f
, 1);
7731 unit
= FRAME_COLUMN_WIDTH (f
);
7732 #ifdef USE_TOOLKIT_SCROLL_BARS
7733 /* The width of a toolkit scrollbar does not change with the new
7734 font but we have to calculate the number of columns it occupies
7736 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
7737 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + unit
- 1) / unit
;
7739 /* The width of a non-toolkit scrollbar is at least 14 pixels and a
7740 multiple of the frame's character width. */
7741 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + unit
- 1) / unit
;
7742 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
)
7743 = FRAME_CONFIG_SCROLL_BAR_COLS (f
) * unit
;
7746 if (FRAME_X_WINDOW (f
) != 0)
7748 /* Don't change the size of a tip frame; there's no point in
7749 doing it because it's done in Fx_show_tip, and it leads to
7750 problems because the tip frame has no widget. */
7751 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
7752 x_set_window_size (f
, 0, FRAME_COLS (f
) * FRAME_COLUMN_WIDTH (f
),
7753 FRAME_LINES (f
) * FRAME_LINE_HEIGHT (f
), 1);
7758 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
7761 xic_set_xfontset (f
, SSDATA (fontset_ascii (fontset
)));
7770 /***********************************************************************
7772 ***********************************************************************/
7778 /* XIM destroy callback function, which is called whenever the
7779 connection to input method XIM dies. CLIENT_DATA contains a
7780 pointer to the x_display_info structure corresponding to XIM. */
7783 xim_destroy_callback (XIM xim
, XPointer client_data
, XPointer call_data
)
7785 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
7786 Lisp_Object frame
, tail
;
7790 /* No need to call XDestroyIC.. */
7791 FOR_EACH_FRAME (tail
, frame
)
7793 struct frame
*f
= XFRAME (frame
);
7794 if (FRAME_X_P (f
) && FRAME_DISPLAY_INFO (f
) == dpyinfo
)
7796 FRAME_XIC (f
) = NULL
;
7797 xic_free_xfontset (f
);
7801 /* No need to call XCloseIM. */
7802 dpyinfo
->xim
= NULL
;
7803 XFree (dpyinfo
->xim_styles
);
7807 #endif /* HAVE_X11R6 */
7810 /* This isn't prototyped in OSF 5.0 or 5.1a. */
7811 extern char *XSetIMValues (XIM
, ...);
7814 /* Open the connection to the XIM server on display DPYINFO.
7815 RESOURCE_NAME is the resource name Emacs uses. */
7818 xim_open_dpy (struct x_display_info
*dpyinfo
, char *resource_name
)
7826 XCloseIM (dpyinfo
->xim
);
7827 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
,
7834 XIMCallback destroy
;
7837 /* Get supported styles and XIM values. */
7838 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
7841 destroy
.callback
= xim_destroy_callback
;
7842 destroy
.client_data
= (XPointer
)dpyinfo
;
7843 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
7849 #endif /* HAVE_XIM */
7850 dpyinfo
->xim
= NULL
;
7854 #ifdef HAVE_X11R6_XIM
7856 /* XIM instantiate callback function, which is called whenever an XIM
7857 server is available. DISPLAY is the display of the XIM.
7858 CLIENT_DATA contains a pointer to an xim_inst_t structure created
7859 when the callback was registered. */
7862 xim_instantiate_callback (Display
*display
, XPointer client_data
, XPointer call_data
)
7864 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
7865 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
7867 /* We don't support multiple XIM connections. */
7871 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
7873 /* Create XIC for the existing frames on the same display, as long
7874 as they have no XIC. */
7875 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
7877 Lisp_Object tail
, frame
;
7880 FOR_EACH_FRAME (tail
, frame
)
7882 struct frame
*f
= XFRAME (frame
);
7885 && FRAME_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
7886 if (FRAME_XIC (f
) == NULL
)
7888 create_frame_xic (f
);
7889 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
7890 xic_set_statusarea (f
);
7891 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
7893 struct window
*w
= XWINDOW (f
->selected_window
);
7894 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
7903 #endif /* HAVE_X11R6_XIM */
7906 /* Open a connection to the XIM server on display DPYINFO.
7907 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
7908 connection only at the first time. On X11R6, open the connection
7909 in the XIM instantiate callback function. */
7912 xim_initialize (struct x_display_info
*dpyinfo
, char *resource_name
)
7914 dpyinfo
->xim
= NULL
;
7918 #ifdef HAVE_X11R6_XIM
7919 struct xim_inst_t
*xim_inst
= xmalloc (sizeof *xim_inst
);
7921 dpyinfo
->xim_callback_data
= xim_inst
;
7922 xim_inst
->dpyinfo
= dpyinfo
;
7923 xim_inst
->resource_name
= xstrdup (resource_name
);
7924 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
7925 resource_name
, emacs_class
,
7926 xim_instantiate_callback
,
7927 /* This is XPointer in XFree86
7928 but (XPointer *) on Tru64, at
7929 least, hence the configure test. */
7930 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
7931 #else /* not HAVE_X11R6_XIM */
7932 xim_open_dpy (dpyinfo
, resource_name
);
7933 #endif /* not HAVE_X11R6_XIM */
7935 #endif /* HAVE_XIM */
7939 /* Close the connection to the XIM server on display DPYINFO. */
7942 xim_close_dpy (struct x_display_info
*dpyinfo
)
7947 #ifdef HAVE_X11R6_XIM
7948 if (dpyinfo
->display
)
7949 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
7951 xim_instantiate_callback
, NULL
);
7952 xfree (dpyinfo
->xim_callback_data
->resource_name
);
7953 xfree (dpyinfo
->xim_callback_data
);
7954 #endif /* HAVE_X11R6_XIM */
7955 if (dpyinfo
->display
)
7956 XCloseIM (dpyinfo
->xim
);
7957 dpyinfo
->xim
= NULL
;
7958 XFree (dpyinfo
->xim_styles
);
7960 #endif /* HAVE_XIM */
7963 #endif /* not HAVE_X11R6_XIM */
7967 /* Calculate the absolute position in frame F
7968 from its current recorded position values and gravity. */
7971 x_calc_absolute_position (struct frame
*f
)
7973 int flags
= f
->size_hint_flags
;
7975 /* We have nothing to do if the current position
7976 is already for the top-left corner. */
7977 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
7980 /* Treat negative positions as relative to the leftmost bottommost
7981 position that fits on the screen. */
7982 if (flags
& XNegative
)
7983 f
->left_pos
= x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
7984 - FRAME_PIXEL_WIDTH (f
) + f
->left_pos
;
7987 int height
= FRAME_PIXEL_HEIGHT (f
);
7989 #if defined USE_X_TOOLKIT && defined USE_MOTIF
7990 /* Something is fishy here. When using Motif, starting Emacs with
7991 `-g -0-0', the frame appears too low by a few pixels.
7993 This seems to be so because initially, while Emacs is starting,
7994 the column widget's height and the frame's pixel height are
7995 different. The column widget's height is the right one. In
7996 later invocations, when Emacs is up, the frame's pixel height
7999 It's not obvious where the initial small difference comes from.
8000 2000-12-01, gerd. */
8002 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
8005 if (flags
& YNegative
)
8006 f
->top_pos
= x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
8007 - height
+ f
->top_pos
;
8010 /* The left_pos and top_pos
8011 are now relative to the top and left screen edges,
8012 so the flags should correspond. */
8013 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8016 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
8017 to really change the position, and 0 when calling from
8018 x_make_frame_visible (in that case, XOFF and YOFF are the current
8019 position values). It is -1 when calling from x_set_frame_parameters,
8020 which means, do adjust for borders but don't change the gravity. */
8023 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
, int change_gravity
)
8025 int modified_top
, modified_left
;
8027 if (change_gravity
> 0)
8031 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8033 f
->size_hint_flags
|= XNegative
;
8035 f
->size_hint_flags
|= YNegative
;
8036 f
->win_gravity
= NorthWestGravity
;
8038 x_calc_absolute_position (f
);
8041 x_wm_set_size_hint (f
, (long) 0, 0);
8043 modified_left
= f
->left_pos
;
8044 modified_top
= f
->top_pos
;
8046 if (change_gravity
!= 0 && FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
)
8048 /* Some WMs (twm, wmaker at least) has an offset that is smaller
8049 than the WM decorations. So we use the calculated offset instead
8050 of the WM decoration sizes here (x/y_pixels_outer_diff). */
8051 modified_left
+= FRAME_X_OUTPUT (f
)->move_offset_left
;
8052 modified_top
+= FRAME_X_OUTPUT (f
)->move_offset_top
;
8055 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8056 modified_left
, modified_top
);
8058 x_sync_with_move (f
, f
->left_pos
, f
->top_pos
,
8059 FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8062 /* change_gravity is non-zero when this function is called from Lisp to
8063 programmatically move a frame. In that case, we call
8064 x_check_expected_move to discover if we have a "Type A" or "Type B"
8065 window manager, and, for a "Type A" window manager, adjust the position
8068 We call x_check_expected_move if a programmatic move occurred, and
8069 either the window manager type (A/B) is unknown or it is Type A but we
8070 need to compute the top/left offset adjustment for this frame. */
8072 if (change_gravity
!= 0 &&
8073 (FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8074 || (FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
8075 && (FRAME_X_OUTPUT (f
)->move_offset_left
== 0
8076 && FRAME_X_OUTPUT (f
)->move_offset_top
== 0))))
8077 x_check_expected_move (f
, modified_left
, modified_top
);
8082 /* Return non-zero if _NET_SUPPORTING_WM_CHECK window exists and _NET_SUPPORTED
8083 on the root window for frame F contains ATOMNAME.
8084 This is how a WM check shall be done according to the Window Manager
8085 Specification/Extended Window Manager Hints at
8086 http://freedesktop.org/wiki/Specifications/wm-spec. */
8089 wm_supports (struct frame
*f
, Atom want_atom
)
8092 unsigned long actual_size
, bytes_remaining
;
8093 int i
, rc
, actual_format
;
8094 Window wmcheck_window
;
8095 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
8096 Window target_window
= dpyinfo
->root_window
;
8097 long max_len
= 65536;
8098 Display
*dpy
= FRAME_X_DISPLAY (f
);
8099 unsigned char *tmp_data
= NULL
;
8100 Atom target_type
= XA_WINDOW
;
8104 x_catch_errors (dpy
);
8105 rc
= XGetWindowProperty (dpy
, target_window
,
8106 dpyinfo
->Xatom_net_supporting_wm_check
,
8107 0, max_len
, False
, target_type
,
8108 &actual_type
, &actual_format
, &actual_size
,
8109 &bytes_remaining
, &tmp_data
);
8111 if (rc
!= Success
|| actual_type
!= XA_WINDOW
|| x_had_errors_p (dpy
))
8113 if (tmp_data
) XFree (tmp_data
);
8114 x_uncatch_errors ();
8119 wmcheck_window
= *(Window
*) tmp_data
;
8122 /* Check if window exists. */
8123 XSelectInput (dpy
, wmcheck_window
, StructureNotifyMask
);
8125 if (x_had_errors_p (dpy
))
8127 x_uncatch_errors ();
8132 if (dpyinfo
->net_supported_window
!= wmcheck_window
)
8134 /* Window changed, reload atoms */
8135 if (dpyinfo
->net_supported_atoms
!= NULL
)
8136 XFree (dpyinfo
->net_supported_atoms
);
8137 dpyinfo
->net_supported_atoms
= NULL
;
8138 dpyinfo
->nr_net_supported_atoms
= 0;
8139 dpyinfo
->net_supported_window
= 0;
8141 target_type
= XA_ATOM
;
8143 rc
= XGetWindowProperty (dpy
, target_window
,
8144 dpyinfo
->Xatom_net_supported
,
8145 0, max_len
, False
, target_type
,
8146 &actual_type
, &actual_format
, &actual_size
,
8147 &bytes_remaining
, &tmp_data
);
8149 if (rc
!= Success
|| actual_type
!= XA_ATOM
|| x_had_errors_p (dpy
))
8151 if (tmp_data
) XFree (tmp_data
);
8152 x_uncatch_errors ();
8157 dpyinfo
->net_supported_atoms
= (Atom
*)tmp_data
;
8158 dpyinfo
->nr_net_supported_atoms
= actual_size
;
8159 dpyinfo
->net_supported_window
= wmcheck_window
;
8164 for (i
= 0; rc
== 0 && i
< dpyinfo
->nr_net_supported_atoms
; ++i
)
8165 rc
= dpyinfo
->net_supported_atoms
[i
] == want_atom
;
8167 x_uncatch_errors ();
8174 set_wm_state (Lisp_Object frame
, int add
, Atom atom
, Atom value
)
8176 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (XFRAME (frame
));
8178 x_send_client_event (frame
, make_number (0), frame
,
8179 dpyinfo
->Xatom_net_wm_state
,
8181 /* 1 = add, 0 = remove */
8183 (make_number (add
? 1 : 0),
8185 (make_fixnum_or_float (atom
),
8187 ? list1 (make_fixnum_or_float (value
))
8192 x_set_sticky (struct frame
*f
, Lisp_Object new_value
, Lisp_Object old_value
)
8195 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
8197 XSETFRAME (frame
, f
);
8199 set_wm_state (frame
, NILP (new_value
) ? 0 : 1,
8200 dpyinfo
->Xatom_net_wm_state_sticky
, None
);
8203 /* Return the current _NET_WM_STATE.
8204 SIZE_STATE is set to one of the FULLSCREEN_* values.
8205 STICKY is set to 1 if the sticky state is set, 0 if not.
8207 Return non-zero if we are not hidden, zero if we are. */
8210 get_current_wm_state (struct frame
*f
,
8216 unsigned long actual_size
, bytes_remaining
;
8217 int i
, rc
, actual_format
, is_hidden
= 0;
8218 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
8219 long max_len
= 65536;
8220 Display
*dpy
= FRAME_X_DISPLAY (f
);
8221 unsigned char *tmp_data
= NULL
;
8222 Atom target_type
= XA_ATOM
;
8225 *size_state
= FULLSCREEN_NONE
;
8228 x_catch_errors (dpy
);
8229 rc
= XGetWindowProperty (dpy
, window
, dpyinfo
->Xatom_net_wm_state
,
8230 0, max_len
, False
, target_type
,
8231 &actual_type
, &actual_format
, &actual_size
,
8232 &bytes_remaining
, &tmp_data
);
8234 if (rc
!= Success
|| actual_type
!= target_type
|| x_had_errors_p (dpy
))
8236 if (tmp_data
) XFree (tmp_data
);
8237 x_uncatch_errors ();
8239 return !FRAME_ICONIFIED_P (f
);
8242 x_uncatch_errors ();
8244 for (i
= 0; i
< actual_size
; ++i
)
8246 Atom a
= ((Atom
*)tmp_data
)[i
];
8247 if (a
== dpyinfo
->Xatom_net_wm_state_hidden
)
8250 f
->output_data
.x
->net_wm_state_hidden_seen
= 1;
8252 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_horz
)
8254 if (*size_state
== FULLSCREEN_HEIGHT
)
8255 *size_state
= FULLSCREEN_MAXIMIZED
;
8257 *size_state
= FULLSCREEN_WIDTH
;
8259 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_vert
)
8261 if (*size_state
== FULLSCREEN_WIDTH
)
8262 *size_state
= FULLSCREEN_MAXIMIZED
;
8264 *size_state
= FULLSCREEN_HEIGHT
;
8266 else if (a
== dpyinfo
->Xatom_net_wm_state_fullscreen
)
8267 *size_state
= FULLSCREEN_BOTH
;
8268 else if (a
== dpyinfo
->Xatom_net_wm_state_sticky
)
8272 if (tmp_data
) XFree (tmp_data
);
8277 /* Do fullscreen as specified in extended window manager hints */
8280 do_ewmh_fullscreen (struct frame
*f
)
8282 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
8283 int have_net_atom
= wm_supports (f
, dpyinfo
->Xatom_net_wm_state
);
8286 (void)get_current_wm_state (f
, FRAME_OUTER_WINDOW (f
), &cur
, &dummy
);
8288 /* Some window managers don't say they support _NET_WM_STATE, but they do say
8289 they support _NET_WM_STATE_FULLSCREEN. Try that also. */
8291 have_net_atom
= wm_supports (f
, dpyinfo
->Xatom_net_wm_state_fullscreen
);
8293 if (have_net_atom
&& cur
!= f
->want_fullscreen
)
8297 XSETFRAME (frame
, f
);
8299 /* Keep number of calls to set_wm_state as low as possible.
8300 Some window managers, or possible Gtk+, hangs when too many
8301 are sent at once. */
8302 switch (f
->want_fullscreen
)
8304 case FULLSCREEN_BOTH
:
8305 if (cur
== FULLSCREEN_WIDTH
|| cur
== FULLSCREEN_MAXIMIZED
8306 || cur
== FULLSCREEN_HEIGHT
)
8307 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_maximized_horz
,
8308 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
8309 set_wm_state (frame
, 1, dpyinfo
->Xatom_net_wm_state_fullscreen
, None
);
8311 case FULLSCREEN_WIDTH
:
8312 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_HEIGHT
8313 || cur
== FULLSCREEN_MAXIMIZED
)
8314 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_fullscreen
,
8315 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
8316 if (cur
!= FULLSCREEN_MAXIMIZED
)
8317 set_wm_state (frame
, 1, dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
8319 case FULLSCREEN_HEIGHT
:
8320 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_WIDTH
8321 || cur
== FULLSCREEN_MAXIMIZED
)
8322 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_fullscreen
,
8323 dpyinfo
->Xatom_net_wm_state_maximized_horz
);
8324 if (cur
!= FULLSCREEN_MAXIMIZED
)
8325 set_wm_state (frame
, 1, dpyinfo
->Xatom_net_wm_state_maximized_vert
, None
);
8327 case FULLSCREEN_MAXIMIZED
:
8328 if (cur
== FULLSCREEN_BOTH
)
8329 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_fullscreen
, None
);
8330 set_wm_state (frame
, 1, dpyinfo
->Xatom_net_wm_state_maximized_horz
,
8331 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
8333 case FULLSCREEN_NONE
:
8334 if (cur
== FULLSCREEN_BOTH
)
8335 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_fullscreen
, None
);
8337 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_maximized_horz
,
8338 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
8341 f
->want_fullscreen
= FULLSCREEN_NONE
;
8345 return have_net_atom
;
8349 XTfullscreen_hook (struct frame
*f
)
8351 if (FRAME_VISIBLE_P (f
))
8354 x_check_fullscreen (f
);
8362 x_handle_net_wm_state (struct frame
*f
, const XPropertyEvent
*event
)
8364 int value
= FULLSCREEN_NONE
;
8367 int not_hidden
= get_current_wm_state (f
, event
->window
, &value
, &sticky
);
8372 case FULLSCREEN_WIDTH
:
8375 case FULLSCREEN_HEIGHT
:
8378 case FULLSCREEN_BOTH
:
8381 case FULLSCREEN_MAXIMIZED
:
8386 store_frame_param (f
, Qfullscreen
, lval
);
8387 store_frame_param (f
, Qsticky
, sticky
? Qt
: Qnil
);
8392 /* Check if we need to resize the frame due to a fullscreen request.
8393 If so needed, resize the frame. */
8395 x_check_fullscreen (struct frame
*f
)
8397 if (do_ewmh_fullscreen (f
))
8400 if (f
->output_data
.x
->parent_desc
!= FRAME_DISPLAY_INFO (f
)->root_window
)
8401 return; /* Only fullscreen without WM or with EWM hints (above). */
8403 /* Setting fullscreen to nil doesn't do anything. We could save the
8404 last non-fullscreen size and restore it, but it seems like a
8405 lot of work for this unusual case (no window manager running). */
8407 if (f
->want_fullscreen
!= FULLSCREEN_NONE
)
8409 int width
= FRAME_PIXEL_WIDTH (f
), height
= FRAME_PIXEL_HEIGHT (f
);
8410 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
8412 switch (f
->want_fullscreen
)
8414 /* No difference between these two when there is no WM */
8415 case FULLSCREEN_BOTH
:
8416 case FULLSCREEN_MAXIMIZED
:
8417 width
= x_display_pixel_width (dpyinfo
);
8418 height
= x_display_pixel_height (dpyinfo
);
8420 case FULLSCREEN_WIDTH
:
8421 width
= x_display_pixel_width (dpyinfo
);
8423 case FULLSCREEN_HEIGHT
:
8424 height
= x_display_pixel_height (dpyinfo
);
8427 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8432 /* This function is called by x_set_offset to determine whether the window
8433 manager interfered with the positioning of the frame. Type A window
8434 managers position the surrounding window manager decorations a small
8435 amount above and left of the user-supplied position. Type B window
8436 managers position the surrounding window manager decorations at the
8437 user-specified position. If we detect a Type A window manager, we
8438 compensate by moving the window right and down by the proper amount. */
8441 x_check_expected_move (struct frame
*f
, int expected_left
, int expected_top
)
8443 int current_left
= 0, current_top
= 0;
8445 /* x_real_positions returns the left and top offsets of the outermost
8446 window manager window around the frame. */
8448 x_real_positions (f
, ¤t_left
, ¤t_top
);
8450 if (current_left
!= expected_left
|| current_top
!= expected_top
)
8452 /* It's a "Type A" window manager. */
8457 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_A
;
8458 FRAME_X_OUTPUT (f
)->move_offset_left
= expected_left
- current_left
;
8459 FRAME_X_OUTPUT (f
)->move_offset_top
= expected_top
- current_top
;
8461 /* Now fix the mispositioned frame's location. */
8463 adjusted_left
= expected_left
+ FRAME_X_OUTPUT (f
)->move_offset_left
;
8464 adjusted_top
= expected_top
+ FRAME_X_OUTPUT (f
)->move_offset_top
;
8466 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8467 adjusted_left
, adjusted_top
);
8469 x_sync_with_move (f
, expected_left
, expected_top
, 0);
8472 /* It's a "Type B" window manager. We don't have to adjust the
8473 frame's position. */
8475 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_B
;
8479 /* Wait for XGetGeometry to return up-to-date position information for a
8480 recently-moved frame. Call this immediately after calling XMoveWindow.
8481 If FUZZY is non-zero, then LEFT and TOP are just estimates of where the
8482 frame has been moved to, so we use a fuzzy position comparison instead
8483 of an exact comparison. */
8486 x_sync_with_move (struct frame
*f
, int left
, int top
, int fuzzy
)
8490 while (count
++ < 50)
8492 int current_left
= 0, current_top
= 0;
8494 /* In theory, this call to XSync only needs to happen once, but in
8495 practice, it doesn't seem to work, hence the need for the surrounding
8498 XSync (FRAME_X_DISPLAY (f
), False
);
8499 x_real_positions (f
, ¤t_left
, ¤t_top
);
8503 /* The left fuzz-factor is 10 pixels. The top fuzz-factor is 40
8506 if (eabs (current_left
- left
) <= 10
8507 && eabs (current_top
- top
) <= 40)
8510 else if (current_left
== left
&& current_top
== top
)
8514 /* As a last resort, just wait 0.5 seconds and hope that XGetGeometry
8515 will then return up-to-date position info. */
8517 wait_reading_process_output (0, 500000, 0, 0, Qnil
, NULL
, 0);
8521 /* Wait for an event on frame F matching EVENTTYPE. */
8523 x_wait_for_event (struct frame
*f
, int eventtype
)
8525 int level
= interrupt_input_blocked
;
8528 struct timespec tmo
, tmo_at
, time_now
;
8529 int fd
= ConnectionNumber (FRAME_X_DISPLAY (f
));
8531 f
->wait_event_type
= eventtype
;
8533 /* Set timeout to 0.1 second. Hopefully not noticeable.
8534 Maybe it should be configurable. */
8535 tmo
= make_timespec (0, 100 * 1000 * 1000);
8536 tmo_at
= timespec_add (current_timespec (), tmo
);
8538 while (f
->wait_event_type
)
8540 pending_signals
= 1;
8541 totally_unblock_input ();
8542 /* XTread_socket is called after unblock. */
8544 interrupt_input_blocked
= level
;
8549 time_now
= current_timespec ();
8550 if (timespec_cmp (tmo_at
, time_now
) < 0)
8553 tmo
= timespec_sub (tmo_at
, time_now
);
8554 if (pselect (fd
+ 1, &fds
, NULL
, NULL
, &tmo
, NULL
) == 0)
8555 break; /* Timeout */
8558 f
->wait_event_type
= 0;
8562 /* Change the size of frame F's X window to COLS/ROWS in the case F
8563 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
8564 top-left-corner window gravity for this size change and subsequent
8565 size changes. Otherwise we leave the window gravity unchanged. */
8568 x_set_window_size_1 (struct frame
*f
, int change_gravity
, int width
, int height
, bool pixelwise
)
8570 int pixelwidth
, pixelheight
;
8572 check_frame_size (f
, &width
, &height
, pixelwise
);
8574 compute_fringe_widths (f
, 0);
8576 pixelwidth
= ((pixelwise
8577 ? FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
)
8578 : FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, width
))
8579 + FRAME_TOOLBAR_WIDTH (f
));
8580 pixelheight
= ((pixelwise
8581 ? FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
)
8582 : FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, height
))
8583 + FRAME_MENUBAR_HEIGHT (f
)
8584 + FRAME_TOOLBAR_HEIGHT (f
));
8585 if (change_gravity
) f
->win_gravity
= NorthWestGravity
;
8586 x_wm_set_size_hint (f
, (long) 0, 0);
8587 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8588 pixelwidth
, pixelheight
);
8591 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
8592 receive in the ConfigureNotify event; if we get what we asked
8593 for, then the event won't cause the screen to become garbaged, so
8594 we have to make sure to do it here. */
8595 SET_FRAME_GARBAGED (f
);
8597 /* Now, strictly speaking, we can't be sure that this is accurate,
8598 but the window manager will get around to dealing with the size
8599 change request eventually, and we'll hear how it went when the
8600 ConfigureNotify event gets here.
8602 We could just not bother storing any of this information here,
8603 and let the ConfigureNotify event set everything up, but that
8604 might be kind of confusing to the Lisp code, since size changes
8605 wouldn't be reported in the frame parameters until some random
8606 point in the future when the ConfigureNotify event arrives.
8608 We pass 1 for DELAY since we can't run Lisp code inside of
8611 /* But the ConfigureNotify may in fact never arrive, and then this is
8612 not right if the frame is visible. Instead wait (with timeout)
8613 for the ConfigureNotify. */
8614 if (FRAME_VISIBLE_P (f
))
8615 x_wait_for_event (f
, ConfigureNotify
);
8618 change_frame_size (f
, width
, height
, 0, 1, 0, 1);
8624 /* Call this to change the size of frame F's x-window.
8625 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
8626 for this size change and subsequent size changes.
8627 Otherwise we leave the window gravity unchanged. */
8630 x_set_window_size (struct frame
*f
, int change_gravity
, int width
, int height
, bool pixelwise
)
8634 check_frame_size (f
, &width
, &height
, pixelwise
);
8636 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
8638 int text_width
, text_height
;
8640 /* When the frame is maximized/fullscreen or running under for
8641 example Xmonad, x_set_window_size_1 will be a no-op.
8642 In that case, the right thing to do is extend rows/width to
8643 the current frame size. We do that first if x_set_window_size_1
8644 turns out to not be a no-op (there is no way to know).
8645 The size will be adjusted again if the frame gets a
8646 ConfigureNotify event as a result of x_set_window_size. */
8647 int pixelh
= FRAME_PIXEL_HEIGHT (f
);
8648 #ifdef USE_X_TOOLKIT
8649 /* The menu bar is not part of text lines. The tool bar
8651 pixelh
-= FRAME_MENUBAR_HEIGHT (f
);
8653 text_width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, FRAME_PIXEL_WIDTH (f
));
8654 text_height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelh
);
8656 change_frame_size (f
, text_width
, text_height
, 0, 1, 0, 1);
8660 if (FRAME_GTK_WIDGET (f
))
8662 xg_frame_set_char_size (f
, width
* FRAME_COLUMN_WIDTH (f
),
8663 height
* FRAME_LINE_HEIGHT (f
));
8665 xg_frame_set_char_size (f
, width
, height
);
8667 x_set_window_size_1 (f
, change_gravity
, width
, height
, pixelwise
);
8668 #else /* not USE_GTK */
8670 x_set_window_size_1 (f
, change_gravity
, width
, height
, pixelwise
);
8671 #if !defined USE_X_TOOLKIT
8672 x_clear_under_internal_border (f
);
8675 #endif /* not USE_GTK */
8677 /* If cursor was outside the new size, mark it as off. */
8678 mark_window_cursors_off (XWINDOW (f
->root_window
));
8680 /* Clear out any recollection of where the mouse highlighting was,
8681 since it might be in a place that's outside the new frame size.
8682 Actually checking whether it is outside is a pain in the neck,
8683 so don't try--just let the highlighting be done afresh with new size. */
8684 cancel_mouse_face (f
);
8689 /* Mouse warping. */
8692 x_set_mouse_position (struct frame
*f
, int x
, int y
)
8696 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
8697 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
8699 if (pix_x
< 0) pix_x
= 0;
8700 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
8702 if (pix_y
< 0) pix_y
= 0;
8703 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
8707 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8708 0, 0, 0, 0, pix_x
, pix_y
);
8712 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
8715 x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
8719 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8720 0, 0, 0, 0, pix_x
, pix_y
);
8724 /* Raise frame F. */
8727 x_raise_frame (struct frame
*f
)
8730 if (FRAME_VISIBLE_P (f
))
8731 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8732 XFlush (FRAME_X_DISPLAY (f
));
8736 /* Lower frame F. */
8739 x_lower_frame (struct frame
*f
)
8741 if (FRAME_VISIBLE_P (f
))
8744 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8745 XFlush (FRAME_X_DISPLAY (f
));
8750 /* Request focus with XEmbed */
8753 xembed_request_focus (struct frame
*f
)
8755 /* See XEmbed Protocol Specification at
8756 http://freedesktop.org/wiki/Specifications/xembed-spec */
8757 if (FRAME_VISIBLE_P (f
))
8758 xembed_send_message (f
, CurrentTime
,
8759 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
8762 /* Activate frame with Extended Window Manager Hints */
8765 x_ewmh_activate_frame (struct frame
*f
)
8767 /* See Window Manager Specification/Extended Window Manager Hints at
8768 http://freedesktop.org/wiki/Specifications/wm-spec */
8770 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
8772 if (FRAME_VISIBLE_P (f
) && wm_supports (f
, dpyinfo
->Xatom_net_active_window
))
8775 XSETFRAME (frame
, f
);
8776 x_send_client_event (frame
, make_number (0), frame
,
8777 dpyinfo
->Xatom_net_active_window
,
8779 list2i (1, dpyinfo
->last_user_time
));
8784 XTframe_raise_lower (struct frame
*f
, int raise_flag
)
8792 /* XEmbed implementation. */
8794 #if defined USE_X_TOOLKIT || ! defined USE_GTK
8796 /* XEmbed implementation. */
8798 #define XEMBED_VERSION 0
8801 xembed_set_info (struct frame
*f
, enum xembed_info flags
)
8803 unsigned long data
[2];
8804 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
8806 data
[0] = XEMBED_VERSION
;
8809 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8810 dpyinfo
->Xatom_XEMBED_INFO
, dpyinfo
->Xatom_XEMBED_INFO
,
8811 32, PropModeReplace
, (unsigned char *) data
, 2);
8813 #endif /* defined USE_X_TOOLKIT || ! defined USE_GTK */
8816 xembed_send_message (struct frame
*f
, Time t
, enum xembed_message msg
,
8817 long int detail
, long int data1
, long int data2
)
8821 event
.xclient
.type
= ClientMessage
;
8822 event
.xclient
.window
= FRAME_X_OUTPUT (f
)->parent_desc
;
8823 event
.xclient
.message_type
= FRAME_DISPLAY_INFO (f
)->Xatom_XEMBED
;
8824 event
.xclient
.format
= 32;
8825 event
.xclient
.data
.l
[0] = t
;
8826 event
.xclient
.data
.l
[1] = msg
;
8827 event
.xclient
.data
.l
[2] = detail
;
8828 event
.xclient
.data
.l
[3] = data1
;
8829 event
.xclient
.data
.l
[4] = data2
;
8831 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_OUTPUT (f
)->parent_desc
,
8832 False
, NoEventMask
, &event
);
8833 XSync (FRAME_X_DISPLAY (f
), False
);
8836 /* Change of visibility. */
8838 /* This tries to wait until the frame is really visible.
8839 However, if the window manager asks the user where to position
8840 the frame, this will return before the user finishes doing that.
8841 The frame will not actually be visible at that time,
8842 but it will become visible later when the window manager
8843 finishes with it. */
8846 x_make_frame_visible (struct frame
*f
)
8848 int original_top
, original_left
;
8852 x_set_bitmap_icon (f
);
8854 if (! FRAME_VISIBLE_P (f
))
8856 /* We test FRAME_GARBAGED_P here to make sure we don't
8857 call x_set_offset a second time
8858 if we get to x_make_frame_visible a second time
8859 before the window gets really visible. */
8860 if (! FRAME_ICONIFIED_P (f
)
8861 && ! FRAME_X_EMBEDDED_P (f
)
8862 && ! f
->output_data
.x
->asked_for_visible
)
8863 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
8865 f
->output_data
.x
->asked_for_visible
= 1;
8867 if (! EQ (Vx_no_window_manager
, Qt
))
8868 x_wm_set_window_state (f
, NormalState
);
8869 #ifdef USE_X_TOOLKIT
8870 if (FRAME_X_EMBEDDED_P (f
))
8871 xembed_set_info (f
, XEMBED_MAPPED
);
8874 /* This was XtPopup, but that did nothing for an iconified frame. */
8875 XtMapWidget (f
->output_data
.x
->widget
);
8877 #else /* not USE_X_TOOLKIT */
8879 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
8880 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
8882 if (FRAME_X_EMBEDDED_P (f
))
8883 xembed_set_info (f
, XEMBED_MAPPED
);
8885 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8886 #endif /* not USE_GTK */
8887 #endif /* not USE_X_TOOLKIT */
8890 XFlush (FRAME_X_DISPLAY (f
));
8892 /* Synchronize to ensure Emacs knows the frame is visible
8893 before we do anything else. We do this loop with input not blocked
8894 so that incoming events are handled. */
8897 /* This must be before UNBLOCK_INPUT
8898 since events that arrive in response to the actions above
8899 will set it when they are handled. */
8900 int previously_visible
= f
->output_data
.x
->has_been_visible
;
8902 original_left
= f
->left_pos
;
8903 original_top
= f
->top_pos
;
8905 /* This must come after we set COUNT. */
8908 /* We unblock here so that arriving X events are processed. */
8910 /* Now move the window back to where it was "supposed to be".
8911 But don't do it if the gravity is negative.
8912 When the gravity is negative, this uses a position
8913 that is 3 pixels too low. Perhaps that's really the border width.
8915 Don't do this if the window has never been visible before,
8916 because the window manager may choose the position
8917 and we don't want to override it. */
8919 if (! FRAME_VISIBLE_P (f
)
8920 && ! FRAME_ICONIFIED_P (f
)
8921 && ! FRAME_X_EMBEDDED_P (f
)
8922 && f
->win_gravity
== NorthWestGravity
8923 && previously_visible
)
8927 unsigned int width
, height
, border
, depth
;
8931 /* On some window managers (such as FVWM) moving an existing
8932 window, even to the same place, causes the window manager
8933 to introduce an offset. This can cause the window to move
8934 to an unexpected location. Check the geometry (a little
8935 slow here) and then verify that the window is in the right
8936 place. If the window is not in the right place, move it
8937 there, and take the potential window manager hit. */
8938 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8939 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
8941 if (original_left
!= x
|| original_top
!= y
)
8942 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8943 original_left
, original_top
);
8948 XSETFRAME (frame
, f
);
8950 /* Process X events until a MapNotify event has been seen. */
8951 while (!FRAME_VISIBLE_P (f
))
8953 /* Force processing of queued events. */
8956 /* This hack is still in use at least for Cygwin. See
8957 http://lists.gnu.org/archive/html/emacs-devel/2013-12/msg00351.html.
8959 Machines that do polling rather than SIGIO have been
8960 observed to go into a busy-wait here. So we'll fake an
8961 alarm signal to let the handler know that there's something
8962 to be read. We used to raise a real alarm, but it seems
8963 that the handler isn't always enabled here. This is
8965 if (input_polling_used ())
8967 /* It could be confusing if a real alarm arrives while
8968 processing the fake one. Turn it off and let the
8969 handler reset it. */
8970 int old_poll_suppress_count
= poll_suppress_count
;
8971 poll_suppress_count
= 1;
8972 poll_for_input_1 ();
8973 poll_suppress_count
= old_poll_suppress_count
;
8976 if (XPending (FRAME_X_DISPLAY (f
)))
8979 XNextEvent (FRAME_X_DISPLAY (f
), &xev
);
8980 x_dispatch_event (&xev
, FRAME_X_DISPLAY (f
));
8986 /* Change from mapped state to withdrawn state. */
8988 /* Make the frame visible (mapped and not iconified). */
8991 x_make_frame_invisible (struct frame
*f
)
8995 /* Use the frame's outermost window, not the one we normally draw on. */
8996 window
= FRAME_OUTER_WINDOW (f
);
8998 /* Don't keep the highlight on an invisible frame. */
8999 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9000 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9004 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
9005 that the current position of the window is user-specified, rather than
9006 program-specified, so that when the window is mapped again, it will be
9007 placed at the same location, without forcing the user to position it
9008 by hand again (they have already done that once for this window.) */
9009 x_wm_set_size_hint (f
, (long) 0, 1);
9012 if (FRAME_GTK_OUTER_WIDGET (f
))
9013 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f
));
9016 if (FRAME_X_EMBEDDED_P (f
))
9017 xembed_set_info (f
, 0);
9022 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
9023 DefaultScreen (FRAME_X_DISPLAY (f
))))
9026 error ("Can't notify window manager of window withdrawal");
9030 /* We can't distinguish this from iconification
9031 just by the event that we get from the server.
9032 So we can't win using the usual strategy of letting
9033 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
9034 and synchronize with the server to make sure we agree. */
9035 SET_FRAME_VISIBLE (f
, 0);
9036 SET_FRAME_ICONIFIED (f
, 0);
9043 /* Change window state from mapped to iconified. */
9046 x_iconify_frame (struct frame
*f
)
9048 #ifdef USE_X_TOOLKIT
9052 /* Don't keep the highlight on an invisible frame. */
9053 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9054 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9056 if (FRAME_ICONIFIED_P (f
))
9061 x_set_bitmap_icon (f
);
9063 #if defined (USE_GTK)
9064 if (FRAME_GTK_OUTER_WIDGET (f
))
9066 if (! FRAME_VISIBLE_P (f
))
9067 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
9069 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
9070 SET_FRAME_VISIBLE (f
, 0);
9071 SET_FRAME_ICONIFIED (f
, 1);
9077 #ifdef USE_X_TOOLKIT
9079 if (! FRAME_VISIBLE_P (f
))
9081 if (! EQ (Vx_no_window_manager
, Qt
))
9082 x_wm_set_window_state (f
, IconicState
);
9083 /* This was XtPopup, but that did nothing for an iconified frame. */
9084 XtMapWidget (f
->output_data
.x
->widget
);
9085 /* The server won't give us any event to indicate
9086 that an invisible frame was changed to an icon,
9087 so we have to record it here. */
9088 SET_FRAME_VISIBLE (f
, 0);
9089 SET_FRAME_ICONIFIED (f
, 1);
9094 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
9095 XtWindow (f
->output_data
.x
->widget
),
9096 DefaultScreen (FRAME_X_DISPLAY (f
)));
9100 error ("Can't notify window manager of iconification");
9102 SET_FRAME_ICONIFIED (f
, 1);
9103 SET_FRAME_VISIBLE (f
, 0);
9106 XFlush (FRAME_X_DISPLAY (f
));
9108 #else /* not USE_X_TOOLKIT */
9110 /* Make sure the X server knows where the window should be positioned,
9111 in case the user deiconifies with the window manager. */
9112 if (! FRAME_VISIBLE_P (f
)
9113 && ! FRAME_ICONIFIED_P (f
)
9114 && ! FRAME_X_EMBEDDED_P (f
))
9115 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
9117 /* Since we don't know which revision of X we're running, we'll use both
9118 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
9120 /* X11R4: send a ClientMessage to the window manager using the
9121 WM_CHANGE_STATE type. */
9125 msg
.xclient
.window
= FRAME_X_WINDOW (f
);
9126 msg
.xclient
.type
= ClientMessage
;
9127 msg
.xclient
.message_type
= FRAME_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
9128 msg
.xclient
.format
= 32;
9129 msg
.xclient
.data
.l
[0] = IconicState
;
9131 if (! XSendEvent (FRAME_X_DISPLAY (f
),
9132 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
9134 SubstructureRedirectMask
| SubstructureNotifyMask
,
9138 error ("Can't notify window manager of iconification");
9142 /* X11R3: set the initial_state field of the window manager hints to
9144 x_wm_set_window_state (f
, IconicState
);
9146 if (!FRAME_VISIBLE_P (f
))
9148 /* If the frame was withdrawn, before, we must map it. */
9149 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9152 SET_FRAME_ICONIFIED (f
, 1);
9153 SET_FRAME_VISIBLE (f
, 0);
9155 XFlush (FRAME_X_DISPLAY (f
));
9157 #endif /* not USE_X_TOOLKIT */
9161 /* Free X resources of frame F. */
9164 x_free_frame_resources (struct frame
*f
)
9166 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9167 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
9168 #ifdef USE_X_TOOLKIT
9170 struct scroll_bar
*b
;
9175 /* If a display connection is dead, don't try sending more
9176 commands to the X server. */
9177 if (dpyinfo
->display
)
9179 /* We must free faces before destroying windows because some
9180 font-driver (e.g. xft) access a window while finishing a
9182 free_frame_faces (f
);
9184 if (f
->output_data
.x
->icon_desc
)
9185 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
9187 #ifdef USE_X_TOOLKIT
9188 /* Explicitly destroy the scroll bars of the frame. Without
9189 this, we get "BadDrawable" errors from the toolkit later on,
9190 presumably from expose events generated for the disappearing
9191 toolkit scroll bars. */
9192 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
9194 b
= XSCROLL_BAR (bar
);
9195 x_scroll_bar_remove (b
);
9204 #ifdef USE_X_TOOLKIT
9205 if (f
->output_data
.x
->widget
)
9207 XtDestroyWidget (f
->output_data
.x
->widget
);
9208 f
->output_data
.x
->widget
= NULL
;
9210 /* Tooltips don't have widgets, only a simple X window, even if
9211 we are using a toolkit. */
9212 else if (FRAME_X_WINDOW (f
))
9213 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9215 free_frame_menubar (f
);
9216 #else /* !USE_X_TOOLKIT */
9219 xg_free_frame_widgets (f
);
9220 #endif /* USE_GTK */
9222 if (FRAME_X_WINDOW (f
))
9223 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9224 #endif /* !USE_X_TOOLKIT */
9226 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
9227 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
9228 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
9229 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
9230 unload_color (f
, f
->output_data
.x
->border_pixel
);
9231 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
9233 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
9234 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
9235 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
9236 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
9237 #ifdef USE_TOOLKIT_SCROLL_BARS
9238 /* Scrollbar shadow colors. */
9239 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
9240 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
9241 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
9242 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
9243 #endif /* USE_TOOLKIT_SCROLL_BARS */
9244 if (f
->output_data
.x
->white_relief
.pixel
!= -1)
9245 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
9246 if (f
->output_data
.x
->black_relief
.pixel
!= -1)
9247 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
9251 /* Free extra GCs allocated by x_setup_relief_colors. */
9252 if (f
->output_data
.x
->white_relief
.gc
)
9254 XFreeGC (dpyinfo
->display
, f
->output_data
.x
->white_relief
.gc
);
9255 f
->output_data
.x
->white_relief
.gc
= 0;
9257 if (f
->output_data
.x
->black_relief
.gc
)
9259 XFreeGC (dpyinfo
->display
, f
->output_data
.x
->black_relief
.gc
);
9260 f
->output_data
.x
->black_relief
.gc
= 0;
9263 XFlush (FRAME_X_DISPLAY (f
));
9266 xfree (f
->output_data
.x
->saved_menu_event
);
9267 xfree (f
->output_data
.x
);
9268 f
->output_data
.x
= NULL
;
9270 if (f
== dpyinfo
->x_focus_frame
)
9271 dpyinfo
->x_focus_frame
= 0;
9272 if (f
== dpyinfo
->x_focus_event_frame
)
9273 dpyinfo
->x_focus_event_frame
= 0;
9274 if (f
== dpyinfo
->x_highlight_frame
)
9275 dpyinfo
->x_highlight_frame
= 0;
9276 if (f
== hlinfo
->mouse_face_mouse_frame
)
9277 reset_mouse_highlight (hlinfo
);
9283 /* Destroy the X window of frame F. */
9286 x_destroy_window (struct frame
*f
)
9288 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9290 /* If a display connection is dead, don't try sending more
9291 commands to the X server. */
9292 if (dpyinfo
->display
!= 0)
9293 x_free_frame_resources (f
);
9295 dpyinfo
->reference_count
--;
9299 /* Setting window manager hints. */
9301 /* Set the normal size hints for the window manager, for frame F.
9302 FLAGS is the flags word to use--or 0 meaning preserve the flags
9303 that the window now has.
9304 If USER_POSITION, set the USPosition
9305 flag (this is useful when FLAGS is 0).
9306 The GTK version is in gtkutils.c. */
9310 x_wm_set_size_hint (struct frame
*f
, long flags
, bool user_position
)
9312 XSizeHints size_hints
;
9313 Window window
= FRAME_OUTER_WINDOW (f
);
9315 #ifdef USE_X_TOOLKIT
9316 if (f
->output_data
.x
->widget
)
9318 widget_update_wm_size_hints (f
->output_data
.x
->widget
);
9323 /* Setting PMaxSize caused various problems. */
9324 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
9326 size_hints
.x
= f
->left_pos
;
9327 size_hints
.y
= f
->top_pos
;
9329 size_hints
.height
= FRAME_PIXEL_HEIGHT (f
);
9330 size_hints
.width
= FRAME_PIXEL_WIDTH (f
);
9332 size_hints
.width_inc
= frame_resize_pixelwise
? 1 : FRAME_COLUMN_WIDTH (f
);
9333 size_hints
.height_inc
= frame_resize_pixelwise
? 1 : FRAME_LINE_HEIGHT (f
);
9335 size_hints
.max_width
= x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
9336 - FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9337 size_hints
.max_height
= x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
9338 - FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9340 /* Calculate the base and minimum sizes. */
9342 int base_width
, base_height
;
9343 int min_rows
= 0, min_cols
= 0;
9345 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9346 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9348 check_frame_size (f
, &min_cols
, &min_rows
, 0);
9350 if (frame_resize_pixelwise
)
9351 /* Needed to prevent a bad protocol error crash when making the
9352 frame size very small. */
9354 min_cols
= 2 * min_cols
;
9355 min_rows
= 2 * min_rows
;
9358 /* The window manager uses the base width hints to calculate the
9359 current number of rows and columns in the frame while
9360 resizing; min_width and min_height aren't useful for this
9361 purpose, since they might not give the dimensions for a
9362 zero-row, zero-column frame.
9364 We use the base_width and base_height members if we have
9365 them; otherwise, we set the min_width and min_height members
9366 to the size for a zero x zero frame. */
9368 size_hints
.flags
|= PBaseSize
;
9369 size_hints
.base_width
= base_width
;
9370 size_hints
.base_height
= base_height
+ FRAME_MENUBAR_HEIGHT (f
);
9371 size_hints
.min_width
= base_width
+ min_cols
* FRAME_COLUMN_WIDTH (f
);
9372 size_hints
.min_height
= base_height
+ min_rows
* FRAME_LINE_HEIGHT (f
);
9375 /* If we don't need the old flags, we don't need the old hint at all. */
9378 size_hints
.flags
|= flags
;
9383 XSizeHints hints
; /* Sometimes I hate X Windows... */
9384 long supplied_return
;
9387 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
9391 size_hints
.flags
|= flags
;
9396 if (hints
.flags
& PSize
)
9397 size_hints
.flags
|= PSize
;
9398 if (hints
.flags
& PPosition
)
9399 size_hints
.flags
|= PPosition
;
9400 if (hints
.flags
& USPosition
)
9401 size_hints
.flags
|= USPosition
;
9402 if (hints
.flags
& USSize
)
9403 size_hints
.flags
|= USSize
;
9410 size_hints
.win_gravity
= f
->win_gravity
;
9411 size_hints
.flags
|= PWinGravity
;
9415 size_hints
.flags
&= ~ PPosition
;
9416 size_hints
.flags
|= USPosition
;
9418 #endif /* PWinGravity */
9420 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
9422 #endif /* not USE_GTK */
9424 /* Used for IconicState or NormalState */
9427 x_wm_set_window_state (struct frame
*f
, int state
)
9429 #ifdef USE_X_TOOLKIT
9432 XtSetArg (al
[0], XtNinitialState
, state
);
9433 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9434 #else /* not USE_X_TOOLKIT */
9435 Window window
= FRAME_X_WINDOW (f
);
9437 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
9438 f
->output_data
.x
->wm_hints
.initial_state
= state
;
9440 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9441 #endif /* not USE_X_TOOLKIT */
9445 x_wm_set_icon_pixmap (struct frame
*f
, ptrdiff_t pixmap_id
)
9447 Pixmap icon_pixmap
, icon_mask
;
9449 #if !defined USE_X_TOOLKIT && !defined USE_GTK
9450 Window window
= FRAME_OUTER_WINDOW (f
);
9455 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
9456 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
9457 icon_mask
= x_bitmap_mask (f
, pixmap_id
);
9458 f
->output_data
.x
->wm_hints
.icon_mask
= icon_mask
;
9462 /* It seems there is no way to turn off use of an icon
9470 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
);
9474 #elif defined (USE_X_TOOLKIT) /* same as in x_wm_set_window_state. */
9478 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
9479 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9480 XtSetArg (al
[0], XtNiconMask
, icon_mask
);
9481 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9484 #else /* not USE_X_TOOLKIT && not USE_GTK */
9486 f
->output_data
.x
->wm_hints
.flags
|= (IconPixmapHint
| IconMaskHint
);
9487 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9489 #endif /* not USE_X_TOOLKIT && not USE_GTK */
9493 x_wm_set_icon_position (struct frame
*f
, int icon_x
, int icon_y
)
9495 Window window
= FRAME_OUTER_WINDOW (f
);
9497 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
9498 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
9499 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
9501 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9505 /***********************************************************************
9507 ***********************************************************************/
9511 /* Check that FONT is valid on frame F. It is if it can be found in F's
9515 x_check_font (struct frame
*f
, struct font
*font
)
9517 eassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
9518 if (font
->driver
->check
)
9519 eassert (font
->driver
->check (f
, font
) == 0);
9522 #endif /* GLYPH_DEBUG */
9525 /***********************************************************************
9527 ***********************************************************************/
9529 #ifdef USE_X_TOOLKIT
9530 static XrmOptionDescRec emacs_options
[] = {
9531 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
9532 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
9534 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
9535 XrmoptionSepArg
, NULL
},
9536 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
9538 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9539 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9540 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9541 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
9542 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
9543 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
9544 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
9547 /* Whether atimer for Xt timeouts is activated or not. */
9549 static int x_timeout_atimer_activated_flag
;
9551 #endif /* USE_X_TOOLKIT */
9553 static int x_initialized
;
9555 /* Test whether two display-name strings agree up to the dot that separates
9556 the screen number from the server number. */
9558 same_x_server (const char *name1
, const char *name2
)
9561 const char *system_name
= SSDATA (Vsystem_name
);
9562 ptrdiff_t system_name_length
= SBYTES (Vsystem_name
);
9563 ptrdiff_t length_until_period
= 0;
9565 while (system_name
[length_until_period
] != 0
9566 && system_name
[length_until_period
] != '.')
9567 length_until_period
++;
9569 /* Treat `unix' like an empty host name. */
9570 if (! strncmp (name1
, "unix:", 5))
9572 if (! strncmp (name2
, "unix:", 5))
9574 /* Treat this host's name like an empty host name. */
9575 if (! strncmp (name1
, system_name
, system_name_length
)
9576 && name1
[system_name_length
] == ':')
9577 name1
+= system_name_length
;
9578 if (! strncmp (name2
, system_name
, system_name_length
)
9579 && name2
[system_name_length
] == ':')
9580 name2
+= system_name_length
;
9581 /* Treat this host's domainless name like an empty host name. */
9582 if (! strncmp (name1
, system_name
, length_until_period
)
9583 && name1
[length_until_period
] == ':')
9584 name1
+= length_until_period
;
9585 if (! strncmp (name2
, system_name
, length_until_period
)
9586 && name2
[length_until_period
] == ':')
9587 name2
+= length_until_period
;
9589 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
9593 if (seen_colon
&& *name1
== '.')
9597 && (*name1
== '.' || *name1
== '\0')
9598 && (*name2
== '.' || *name2
== '\0'));
9601 /* Count number of set bits in mask and number of bits to shift to
9602 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
9605 get_bits_and_offset (unsigned long mask
, int *bits
, int *offset
)
9626 /* Return 1 if display DISPLAY is available for use, 0 otherwise.
9627 But don't permanently open it, just test its availability. */
9630 x_display_ok (const char *display
)
9632 Display
*dpy
= XOpenDisplay (display
);
9633 return dpy
? (XCloseDisplay (dpy
), 1) : 0;
9638 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
9639 const gchar
*msg
, gpointer user_data
)
9641 if (!strstr (msg
, "g_set_prgname"))
9642 fprintf (stderr
, "%s-WARNING **: %s\n", log_domain
, msg
);
9646 /* Open a connection to X display DISPLAY_NAME, and return
9647 the structure that describes the open display.
9648 If we cannot contact the display, return null. */
9650 struct x_display_info
*
9651 x_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
9655 struct terminal
*terminal
;
9656 struct x_display_info
*dpyinfo
;
9668 if (! x_display_ok (SSDATA (display_name
)))
9669 error ("Display %s can't be opened", SSDATA (display_name
));
9675 char *argv
[NUM_ARGV
];
9676 char **argv2
= argv
;
9679 if (x_initialized
++ > 1)
9681 xg_display_open (SSDATA (display_name
), &dpy
);
9685 static char display_opt
[] = "--display";
9686 static char name_opt
[] = "--name";
9688 for (argc
= 0; argc
< NUM_ARGV
; ++argc
)
9692 argv
[argc
++] = initial_argv
[0];
9694 if (! NILP (display_name
))
9696 argv
[argc
++] = display_opt
;
9697 argv
[argc
++] = SSDATA (display_name
);
9700 argv
[argc
++] = name_opt
;
9701 argv
[argc
++] = resource_name
;
9703 XSetLocaleModifiers ("");
9705 /* Emacs can only handle core input events, so make sure
9706 Gtk doesn't use Xinput or Xinput2 extensions. */
9707 xputenv ("GDK_CORE_DEVICE_EVENTS=1");
9709 /* Work around GLib bug that outputs a faulty warning. See
9710 https://bugzilla.gnome.org/show_bug.cgi?id=563627. */
9711 id
= g_log_set_handler ("GLib", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
9712 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
9714 /* NULL window -> events for all windows go to our function.
9715 Call before gtk_init so Gtk+ event filters comes after our. */
9716 gdk_window_add_filter (NULL
, event_handler_gdk
, NULL
);
9718 /* gtk_init does set_locale. Fix locale before and after. */
9720 gtk_init (&argc
, &argv2
);
9723 g_log_remove_handler ("GLib", id
);
9727 dpy
= DEFAULT_GDK_DISPLAY ();
9729 #if ! GTK_CHECK_VERSION (2, 90, 0)
9730 /* Load our own gtkrc if it exists. */
9732 const char *file
= "~/.emacs.d/gtkrc";
9733 Lisp_Object s
, abs_file
;
9735 s
= build_string (file
);
9736 abs_file
= Fexpand_file_name (s
, Qnil
);
9738 if (! NILP (abs_file
) && !NILP (Ffile_readable_p (abs_file
)))
9739 gtk_rc_parse (SSDATA (abs_file
));
9743 XSetErrorHandler (x_error_handler
);
9744 XSetIOErrorHandler (x_io_error_quitter
);
9747 #else /* not USE_GTK */
9748 #ifdef USE_X_TOOLKIT
9749 /* weiner@footloose.sps.mot.com reports that this causes
9751 X protocol error: BadAtom (invalid Atom parameter)
9752 on protocol request 18skiloaf.
9753 So let's not use it until R6. */
9755 XtSetLanguageProc (NULL
, NULL
, NULL
);
9766 argv
[argc
++] = "-xrm";
9767 argv
[argc
++] = xrm_option
;
9769 turn_on_atimers (0);
9770 dpy
= XtOpenDisplay (Xt_app_con
, SSDATA (display_name
),
9771 resource_name
, EMACS_CLASS
,
9772 emacs_options
, XtNumber (emacs_options
),
9774 turn_on_atimers (1);
9777 /* I think this is to compensate for XtSetLanguageProc. */
9782 #else /* not USE_X_TOOLKIT */
9783 XSetLocaleModifiers ("");
9784 dpy
= XOpenDisplay (SSDATA (display_name
));
9785 #endif /* not USE_X_TOOLKIT */
9786 #endif /* not USE_GTK*/
9788 /* Detect failure. */
9795 /* We have definitely succeeded. Record the new connection. */
9797 dpyinfo
= xzalloc (sizeof *dpyinfo
);
9798 terminal
= x_create_terminal (dpyinfo
);
9801 struct x_display_info
*share
;
9803 for (share
= x_display_list
; share
; share
= share
->next
)
9804 if (same_x_server (SSDATA (XCAR (share
->name_list_element
)),
9805 SSDATA (display_name
)))
9808 terminal
->kboard
= share
->terminal
->kboard
;
9811 terminal
->kboard
= allocate_kboard (Qx
);
9813 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
9815 char *vendor
= ServerVendor (dpy
);
9817 /* Protect terminal from GC before removing it from the
9818 list of terminals. */
9819 struct gcpro gcpro1
;
9820 Lisp_Object gcpro_term
;
9821 XSETTERMINAL (gcpro_term
, terminal
);
9822 GCPRO1 (gcpro_term
);
9824 /* Temporarily hide the partially initialized terminal. */
9825 terminal_list
= terminal
->next_terminal
;
9827 kset_system_key_alist
9829 call1 (Qvendor_specific_keysyms
,
9830 vendor
? build_string (vendor
) : empty_unibyte_string
));
9832 terminal
->next_terminal
= terminal_list
;
9833 terminal_list
= terminal
;
9837 /* Don't let the initial kboard remain current longer than necessary.
9838 That would cause problems if a file loaded on startup tries to
9839 prompt in the mini-buffer. */
9840 if (current_kboard
== initial_kboard
)
9841 current_kboard
= terminal
->kboard
;
9843 terminal
->kboard
->reference_count
++;
9846 /* Put this display on the chain. */
9847 dpyinfo
->next
= x_display_list
;
9848 x_display_list
= dpyinfo
;
9850 dpyinfo
->name_list_element
= Fcons (display_name
, Qnil
);
9851 dpyinfo
->display
= dpy
;
9853 /* Set the name of the terminal. */
9854 terminal
->name
= xlispstrdup (display_name
);
9857 XSetAfterFunction (x_current_display
, x_trace_wire
);
9860 lim
= min (PTRDIFF_MAX
, SIZE_MAX
) - sizeof "@";
9861 if (lim
- SBYTES (Vinvocation_name
) < SBYTES (Vsystem_name
))
9862 memory_full (SIZE_MAX
);
9863 dpyinfo
->x_id_name
= xmalloc (SBYTES (Vinvocation_name
)
9864 + SBYTES (Vsystem_name
) + 2);
9865 strcat (strcat (strcpy (dpyinfo
->x_id_name
, SSDATA (Vinvocation_name
)), "@"),
9866 SSDATA (Vsystem_name
));
9868 /* Figure out which modifier bits mean what. */
9869 x_find_modifier_meanings (dpyinfo
);
9871 /* Get the scroll bar cursor. */
9873 /* We must create a GTK cursor, it is required for GTK widgets. */
9874 dpyinfo
->xg_cursor
= xg_create_default_cursor (dpyinfo
->display
);
9875 #endif /* USE_GTK */
9877 dpyinfo
->vertical_scroll_bar_cursor
9878 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
9880 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
9881 resource_name
, EMACS_CLASS
);
9882 #ifdef HAVE_XRMSETDATABASE
9883 XrmSetDatabase (dpyinfo
->display
, xrdb
);
9885 dpyinfo
->display
->db
= xrdb
;
9887 /* Put the rdb where we can find it in a way that works on
9889 dpyinfo
->xrdb
= xrdb
;
9891 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
9892 DefaultScreen (dpyinfo
->display
));
9893 select_visual (dpyinfo
);
9894 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
9895 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
9896 dpyinfo
->icon_bitmap_id
= -1;
9897 dpyinfo
->wm_type
= X_WMTYPE_UNKNOWN
;
9899 reset_mouse_highlight (&dpyinfo
->mouse_highlight
);
9901 /* See if we can construct pixel values from RGB values. */
9902 if (dpyinfo
->visual
->class == TrueColor
)
9904 get_bits_and_offset (dpyinfo
->visual
->red_mask
,
9905 &dpyinfo
->red_bits
, &dpyinfo
->red_offset
);
9906 get_bits_and_offset (dpyinfo
->visual
->blue_mask
,
9907 &dpyinfo
->blue_bits
, &dpyinfo
->blue_offset
);
9908 get_bits_and_offset (dpyinfo
->visual
->green_mask
,
9909 &dpyinfo
->green_bits
, &dpyinfo
->green_offset
);
9912 /* See if a private colormap is requested. */
9913 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
9915 if (dpyinfo
->visual
->class == PseudoColor
)
9918 value
= display_x_get_resource (dpyinfo
,
9919 build_string ("privateColormap"),
9920 build_string ("PrivateColormap"),
9923 && (!strcmp (SSDATA (value
), "true")
9924 || !strcmp (SSDATA (value
), "on")))
9925 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
9929 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
9930 dpyinfo
->visual
, AllocNone
);
9934 /* If we are using Xft, check dpi value in X resources.
9935 It is better we use it as well, since Xft will use it, as will all
9936 Gnome applications. If our real DPI is smaller or larger than the
9937 one Xft uses, our font will look smaller or larger than other
9938 for other applications, even if it is the same font name (monospace-10
9940 char *v
= XGetDefault (dpyinfo
->display
, "Xft", "dpi");
9942 if (v
!= NULL
&& sscanf (v
, "%lf", &d
) == 1)
9943 dpyinfo
->resy
= dpyinfo
->resx
= d
;
9947 if (dpyinfo
->resy
< 1)
9949 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
9950 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
9951 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
9952 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
9953 dpyinfo
->resy
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
9954 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
9955 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
9956 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
9957 dpyinfo
->resx
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
9966 #define ATOM_REFS_INIT(string, member) \
9967 { string, offsetof (struct x_display_info, member) },
9968 ATOM_REFS_INIT ("WM_PROTOCOLS", Xatom_wm_protocols
)
9969 ATOM_REFS_INIT ("WM_TAKE_FOCUS", Xatom_wm_take_focus
)
9970 ATOM_REFS_INIT ("WM_SAVE_YOURSELF", Xatom_wm_save_yourself
)
9971 ATOM_REFS_INIT ("WM_DELETE_WINDOW", Xatom_wm_delete_window
)
9972 ATOM_REFS_INIT ("WM_CHANGE_STATE", Xatom_wm_change_state
)
9973 ATOM_REFS_INIT ("WM_CONFIGURE_DENIED", Xatom_wm_configure_denied
)
9974 ATOM_REFS_INIT ("WM_MOVED", Xatom_wm_window_moved
)
9975 ATOM_REFS_INIT ("WM_CLIENT_LEADER", Xatom_wm_client_leader
)
9976 ATOM_REFS_INIT ("Editres", Xatom_editres
)
9977 ATOM_REFS_INIT ("CLIPBOARD", Xatom_CLIPBOARD
)
9978 ATOM_REFS_INIT ("TIMESTAMP", Xatom_TIMESTAMP
)
9979 ATOM_REFS_INIT ("TEXT", Xatom_TEXT
)
9980 ATOM_REFS_INIT ("COMPOUND_TEXT", Xatom_COMPOUND_TEXT
)
9981 ATOM_REFS_INIT ("UTF8_STRING", Xatom_UTF8_STRING
)
9982 ATOM_REFS_INIT ("DELETE", Xatom_DELETE
)
9983 ATOM_REFS_INIT ("MULTIPLE", Xatom_MULTIPLE
)
9984 ATOM_REFS_INIT ("INCR", Xatom_INCR
)
9985 ATOM_REFS_INIT ("_EMACS_TMP_", Xatom_EMACS_TMP
)
9986 ATOM_REFS_INIT ("TARGETS", Xatom_TARGETS
)
9987 ATOM_REFS_INIT ("NULL", Xatom_NULL
)
9988 ATOM_REFS_INIT ("ATOM", Xatom_ATOM
)
9989 ATOM_REFS_INIT ("ATOM_PAIR", Xatom_ATOM_PAIR
)
9990 ATOM_REFS_INIT ("CLIPBOARD_MANAGER", Xatom_CLIPBOARD_MANAGER
)
9991 ATOM_REFS_INIT ("_XEMBED_INFO", Xatom_XEMBED_INFO
)
9992 /* For properties of font. */
9993 ATOM_REFS_INIT ("PIXEL_SIZE", Xatom_PIXEL_SIZE
)
9994 ATOM_REFS_INIT ("AVERAGE_WIDTH", Xatom_AVERAGE_WIDTH
)
9995 ATOM_REFS_INIT ("_MULE_BASELINE_OFFSET", Xatom_MULE_BASELINE_OFFSET
)
9996 ATOM_REFS_INIT ("_MULE_RELATIVE_COMPOSE", Xatom_MULE_RELATIVE_COMPOSE
)
9997 ATOM_REFS_INIT ("_MULE_DEFAULT_ASCENT", Xatom_MULE_DEFAULT_ASCENT
)
9998 /* Ghostscript support. */
9999 ATOM_REFS_INIT ("DONE", Xatom_DONE
)
10000 ATOM_REFS_INIT ("PAGE", Xatom_PAGE
)
10001 ATOM_REFS_INIT ("SCROLLBAR", Xatom_Scrollbar
)
10002 ATOM_REFS_INIT ("_XEMBED", Xatom_XEMBED
)
10004 ATOM_REFS_INIT ("_NET_WM_STATE", Xatom_net_wm_state
)
10005 ATOM_REFS_INIT ("_NET_WM_STATE_FULLSCREEN", Xatom_net_wm_state_fullscreen
)
10006 ATOM_REFS_INIT ("_NET_WM_STATE_MAXIMIZED_HORZ",
10007 Xatom_net_wm_state_maximized_horz
)
10008 ATOM_REFS_INIT ("_NET_WM_STATE_MAXIMIZED_VERT",
10009 Xatom_net_wm_state_maximized_vert
)
10010 ATOM_REFS_INIT ("_NET_WM_STATE_STICKY", Xatom_net_wm_state_sticky
)
10011 ATOM_REFS_INIT ("_NET_WM_STATE_HIDDEN", Xatom_net_wm_state_hidden
)
10012 ATOM_REFS_INIT ("_NET_WM_WINDOW_TYPE", Xatom_net_window_type
)
10013 ATOM_REFS_INIT ("_NET_WM_WINDOW_TYPE_TOOLTIP",
10014 Xatom_net_window_type_tooltip
)
10015 ATOM_REFS_INIT ("_NET_WM_ICON_NAME", Xatom_net_wm_icon_name
)
10016 ATOM_REFS_INIT ("_NET_WM_NAME", Xatom_net_wm_name
)
10017 ATOM_REFS_INIT ("_NET_SUPPORTED", Xatom_net_supported
)
10018 ATOM_REFS_INIT ("_NET_SUPPORTING_WM_CHECK", Xatom_net_supporting_wm_check
)
10019 ATOM_REFS_INIT ("_NET_WM_WINDOW_OPACITY", Xatom_net_wm_window_opacity
)
10020 ATOM_REFS_INIT ("_NET_ACTIVE_WINDOW", Xatom_net_active_window
)
10021 ATOM_REFS_INIT ("_NET_FRAME_EXTENTS", Xatom_net_frame_extents
)
10022 ATOM_REFS_INIT ("_NET_CURRENT_DESKTOP", Xatom_net_current_desktop
)
10023 ATOM_REFS_INIT ("_NET_WORKAREA", Xatom_net_workarea
)
10024 /* Session management */
10025 ATOM_REFS_INIT ("SM_CLIENT_ID", Xatom_SM_CLIENT_ID
)
10026 ATOM_REFS_INIT ("_XSETTINGS_SETTINGS", Xatom_xsettings_prop
)
10027 ATOM_REFS_INIT ("MANAGER", Xatom_xsettings_mgr
)
10031 const int atom_count
= sizeof (atom_refs
) / sizeof (atom_refs
[0]);
10032 /* 1 for _XSETTINGS_SN */
10033 const int total_atom_count
= 1 + atom_count
;
10034 Atom
*atoms_return
= xmalloc (total_atom_count
* sizeof *atoms_return
);
10035 char **atom_names
= xmalloc (total_atom_count
* sizeof *atom_names
);
10036 static char const xsettings_fmt
[] = "_XSETTINGS_S%d";
10037 char xsettings_atom_name
[sizeof xsettings_fmt
- 2
10038 + INT_STRLEN_BOUND (int)];
10040 for (i
= 0; i
< atom_count
; i
++)
10041 atom_names
[i
] = (char *) atom_refs
[i
].name
;
10043 /* Build _XSETTINGS_SN atom name */
10044 sprintf (xsettings_atom_name
, xsettings_fmt
,
10045 XScreenNumberOfScreen (dpyinfo
->screen
));
10046 atom_names
[i
] = xsettings_atom_name
;
10048 XInternAtoms (dpyinfo
->display
, atom_names
, total_atom_count
,
10049 False
, atoms_return
);
10051 for (i
= 0; i
< atom_count
; i
++)
10052 *(Atom
*) ((char *) dpyinfo
+ atom_refs
[i
].offset
) = atoms_return
[i
];
10054 /* Manual copy of last atom */
10055 dpyinfo
->Xatom_xsettings_sel
= atoms_return
[i
];
10057 xfree (atom_names
);
10058 xfree (atoms_return
);
10061 dpyinfo
->x_dnd_atoms_size
= 8;
10062 dpyinfo
->x_dnd_atoms
= xmalloc (sizeof *dpyinfo
->x_dnd_atoms
10063 * dpyinfo
->x_dnd_atoms_size
);
10065 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
10066 gray_bits
, gray_width
, gray_height
,
10070 xim_initialize (dpyinfo
, resource_name
);
10073 xsettings_initialize (dpyinfo
);
10075 connection
= ConnectionNumber (dpyinfo
->display
);
10077 /* This is only needed for distinguishing keyboard and process input. */
10078 if (connection
!= 0)
10079 add_keyboard_wait_descriptor (connection
);
10082 fcntl (connection
, F_SETOWN
, getpid ());
10083 #endif /* ! defined (F_SETOWN) */
10085 if (interrupt_input
)
10086 init_sigio (connection
);
10090 XrmValue d
, fr
, to
;
10093 dpy
= dpyinfo
->display
;
10094 d
.addr
= (XPointer
)&dpy
;
10095 d
.size
= sizeof (Display
*);
10096 fr
.addr
= XtDefaultFont
;
10097 fr
.size
= sizeof (XtDefaultFont
);
10098 to
.size
= sizeof (Font
*);
10099 to
.addr
= (XPointer
)&font
;
10100 x_catch_errors (dpy
);
10101 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
10103 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
10104 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
10105 x_uncatch_errors ();
10109 /* See if we should run in synchronous mode. This is useful
10110 for debugging X code. */
10113 value
= display_x_get_resource (dpyinfo
,
10114 build_string ("synchronous"),
10115 build_string ("Synchronous"),
10117 if (STRINGP (value
)
10118 && (!strcmp (SSDATA (value
), "true")
10119 || !strcmp (SSDATA (value
), "on")))
10120 XSynchronize (dpyinfo
->display
, True
);
10125 value
= display_x_get_resource (dpyinfo
,
10126 build_string ("useXIM"),
10127 build_string ("UseXIM"),
10130 if (STRINGP (value
)
10131 && (!strcmp (SSDATA (value
), "false")
10132 || !strcmp (SSDATA (value
), "off")))
10135 if (STRINGP (value
)
10136 && (!strcmp (SSDATA (value
), "true")
10137 || !strcmp (SSDATA (value
), "on")))
10143 /* Only do this for the very first display in the Emacs session.
10144 Ignore X session management when Emacs was first started on a
10146 if (terminal
->id
== 1)
10147 x_session_initialize (dpyinfo
);
10155 /* Get rid of display DPYINFO, deleting all frames on it,
10156 and without sending any more commands to the X server. */
10159 x_delete_display (struct x_display_info
*dpyinfo
)
10161 struct terminal
*t
;
10163 /* Close all frames and delete the generic struct terminal for this
10165 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
10166 if (t
->type
== output_x_window
&& t
->display_info
.x
== dpyinfo
)
10169 /* Close X session management when we close its display. */
10170 if (t
->id
== 1 && x_session_have_connection ())
10171 x_session_close ();
10173 delete_terminal (t
);
10177 if (next_noop_dpyinfo
== dpyinfo
)
10178 next_noop_dpyinfo
= dpyinfo
->next
;
10180 if (x_display_list
== dpyinfo
)
10181 x_display_list
= dpyinfo
->next
;
10184 struct x_display_info
*tail
;
10186 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
10187 if (tail
->next
== dpyinfo
)
10188 tail
->next
= tail
->next
->next
;
10191 xfree (dpyinfo
->x_id_name
);
10192 xfree (dpyinfo
->x_dnd_atoms
);
10193 xfree (dpyinfo
->color_cells
);
10197 #ifdef USE_X_TOOLKIT
10199 /* Atimer callback function for TIMER. Called every 0.1s to process
10200 Xt timeouts, if needed. We must avoid calling XtAppPending as
10201 much as possible because that function does an implicit XFlush
10202 that slows us down. */
10205 x_process_timeouts (struct atimer
*timer
)
10208 x_timeout_atimer_activated_flag
= 0;
10209 if (toolkit_scroll_bar_interaction
|| popup_activated ())
10211 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
10212 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
10213 /* Reactivate the atimer for next time. */
10214 x_activate_timeout_atimer ();
10219 /* Install an asynchronous timer that processes Xt timeout events
10220 every 0.1s as long as either `toolkit_scroll_bar_interaction' or
10221 `popup_activated_flag' (in xmenu.c) is set. Make sure to call this
10222 function whenever these variables are set. This is necessary
10223 because some widget sets use timeouts internally, for example the
10224 LessTif menu bar, or the Xaw3d scroll bar. When Xt timeouts aren't
10225 processed, these widgets don't behave normally. */
10228 x_activate_timeout_atimer (void)
10231 if (!x_timeout_atimer_activated_flag
)
10233 struct timespec interval
= make_timespec (0, 100 * 1000 * 1000);
10234 start_atimer (ATIMER_RELATIVE
, interval
, x_process_timeouts
, 0);
10235 x_timeout_atimer_activated_flag
= 1;
10240 #endif /* USE_X_TOOLKIT */
10243 /* Set up use of X before we make the first connection. */
10245 static struct redisplay_interface x_redisplay_interface
=
10247 x_frame_parm_handlers
,
10251 x_clear_end_of_line
,
10253 x_after_update_window_line
,
10254 x_update_window_begin
,
10255 x_update_window_end
,
10257 x_clear_window_mouse_face
,
10258 x_get_glyph_overhangs
,
10259 x_fix_overlapping_area
,
10260 x_draw_fringe_bitmap
,
10261 0, /* define_fringe_bitmap */
10262 0, /* destroy_fringe_bitmap */
10263 x_compute_glyph_string_overhangs
,
10264 x_draw_glyph_string
,
10265 x_define_frame_cursor
,
10266 x_clear_frame_area
,
10267 x_draw_window_cursor
,
10268 x_draw_vertical_window_border
,
10269 x_draw_window_divider
,
10270 x_shift_glyphs_for_insert
10274 /* This function is called when the last frame on a display is deleted. */
10276 x_delete_terminal (struct terminal
*terminal
)
10278 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
10279 int connection
= -1;
10281 /* Protect against recursive calls. delete_frame in
10282 delete_terminal calls us back when it deletes our last frame. */
10283 if (!terminal
->name
)
10288 /* We must close our connection to the XIM server before closing the
10291 xim_close_dpy (dpyinfo
);
10294 /* If called from x_connection_closed, the display may already be closed
10295 and dpyinfo->display was set to 0 to indicate that. */
10296 if (dpyinfo
->display
)
10298 connection
= ConnectionNumber (dpyinfo
->display
);
10300 x_destroy_all_bitmaps (dpyinfo
);
10301 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
10303 /* Whether or not XCloseDisplay destroys the associated resource
10304 database depends on the version of libX11. To avoid both
10305 crash and memory leak, we dissociate the database from the
10306 display and then destroy dpyinfo->xrdb ourselves.
10308 Unfortunately, the above strategy does not work in some
10309 situations due to a bug in newer versions of libX11: because
10310 XrmSetDatabase doesn't clear the flag XlibDisplayDfltRMDB if
10311 dpy->db is NULL, XCloseDisplay destroys the associated
10312 database whereas it has not been created by XGetDefault
10313 (Bug#21974 in freedesktop.org Bugzilla). As a workaround, we
10314 don't destroy the database here in order to avoid the crash
10315 in the above situations for now, though that may cause memory
10316 leaks in other situations. */
10318 #ifdef HAVE_XRMSETDATABASE
10319 XrmSetDatabase (dpyinfo
->display
, NULL
);
10321 dpyinfo
->display
->db
= NULL
;
10323 /* We used to call XrmDestroyDatabase from x_delete_display, but
10324 some older versions of libX11 crash if we call it after
10325 closing all the displays. */
10326 XrmDestroyDatabase (dpyinfo
->xrdb
);
10330 xg_display_close (dpyinfo
->display
);
10332 #ifdef USE_X_TOOLKIT
10333 XtCloseDisplay (dpyinfo
->display
);
10335 XCloseDisplay (dpyinfo
->display
);
10337 #endif /* ! USE_GTK */
10340 /* No more input on this descriptor. */
10341 if (connection
!= -1)
10342 delete_keyboard_wait_descriptor (connection
);
10344 /* Mark as dead. */
10345 dpyinfo
->display
= NULL
;
10346 x_delete_display (dpyinfo
);
10350 /* Create a struct terminal, initialize it with the X11 specific
10351 functions and make DISPLAY->TERMINAL point to it. */
10353 static struct terminal
*
10354 x_create_terminal (struct x_display_info
*dpyinfo
)
10356 struct terminal
*terminal
;
10358 terminal
= create_terminal ();
10360 terminal
->type
= output_x_window
;
10361 terminal
->display_info
.x
= dpyinfo
;
10362 dpyinfo
->terminal
= terminal
;
10364 /* kboard is initialized in x_term_init. */
10366 terminal
->clear_frame_hook
= x_clear_frame
;
10367 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
10368 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
10369 terminal
->ring_bell_hook
= XTring_bell
;
10370 terminal
->toggle_invisible_pointer_hook
= XTtoggle_invisible_pointer
;
10371 terminal
->reset_terminal_modes_hook
= NULL
;
10372 terminal
->set_terminal_modes_hook
= NULL
;
10373 terminal
->update_begin_hook
= x_update_begin
;
10374 terminal
->update_end_hook
= x_update_end
;
10375 terminal
->set_terminal_window_hook
= NULL
;
10376 terminal
->read_socket_hook
= XTread_socket
;
10377 terminal
->frame_up_to_date_hook
= XTframe_up_to_date
;
10378 terminal
->mouse_position_hook
= XTmouse_position
;
10379 terminal
->frame_rehighlight_hook
= XTframe_rehighlight
;
10380 terminal
->frame_raise_lower_hook
= XTframe_raise_lower
;
10381 terminal
->fullscreen_hook
= XTfullscreen_hook
;
10382 terminal
->set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
10383 terminal
->condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
10384 terminal
->redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
10385 terminal
->judge_scroll_bars_hook
= XTjudge_scroll_bars
;
10387 terminal
->delete_frame_hook
= x_destroy_window
;
10388 terminal
->delete_terminal_hook
= x_delete_terminal
;
10390 terminal
->rif
= &x_redisplay_interface
;
10396 x_initialize (void)
10401 last_tool_bar_item
= -1;
10402 any_help_event_p
= 0;
10403 ignore_next_mouse_click_timeout
= 0;
10406 current_count
= -1;
10409 /* Try to use interrupt input; if we can't, then start polling. */
10410 Fset_input_interrupt_mode (Qt
);
10412 #ifdef USE_X_TOOLKIT
10413 XtToolkitInitialize ();
10415 Xt_app_con
= XtCreateApplicationContext ();
10417 /* Register a converter from strings to pixels, which uses
10418 Emacs' color allocation infrastructure. */
10419 XtAppSetTypeConverter (Xt_app_con
,
10420 XtRString
, XtRPixel
, cvt_string_to_pixel
,
10421 cvt_string_to_pixel_args
,
10422 XtNumber (cvt_string_to_pixel_args
),
10423 XtCacheByDisplay
, cvt_pixel_dtor
);
10425 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
10428 #ifdef USE_TOOLKIT_SCROLL_BARS
10430 xaw3d_arrow_scroll
= False
;
10431 xaw3d_pick_top
= True
;
10435 /* Note that there is no real way portable across R3/R4 to get the
10436 original error handler. */
10437 XSetErrorHandler (x_error_handler
);
10438 XSetIOErrorHandler (x_io_error_quitter
);
10443 syms_of_xterm (void)
10445 x_error_message
= NULL
;
10447 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
10448 DEFSYM (Qlatin_1
, "latin-1");
10451 xg_default_icon_file
= build_pure_c_string ("icons/hicolor/scalable/apps/emacs.svg");
10452 staticpro (&xg_default_icon_file
);
10454 DEFSYM (Qx_gtk_map_stock
, "x-gtk-map-stock");
10457 DEFVAR_BOOL ("x-use-underline-position-properties",
10458 x_use_underline_position_properties
,
10459 doc
: /* Non-nil means make use of UNDERLINE_POSITION font properties.
10460 A value of nil means ignore them. If you encounter fonts with bogus
10461 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
10462 to 4.1, set this to nil. You can also use `underline-minimum-offset'
10463 to override the font's UNDERLINE_POSITION for small font display
10465 x_use_underline_position_properties
= 1;
10467 DEFVAR_BOOL ("x-underline-at-descent-line",
10468 x_underline_at_descent_line
,
10469 doc
: /* Non-nil means to draw the underline at the same place as the descent line.
10470 A value of nil means to draw the underline according to the value of the
10471 variable `x-use-underline-position-properties', which is usually at the
10472 baseline level. The default value is nil. */);
10473 x_underline_at_descent_line
= 0;
10475 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
10476 x_mouse_click_focus_ignore_position
,
10477 doc
: /* Non-nil means that a mouse click to focus a frame does not move point.
10478 This variable is only used when the window manager requires that you
10479 click on a frame to select it (give it focus). In that case, a value
10480 of nil, means that the selected window and cursor position changes to
10481 reflect the mouse click position, while a non-nil value means that the
10482 selected window or cursor position is preserved. */);
10483 x_mouse_click_focus_ignore_position
= 0;
10485 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars
,
10486 doc
: /* Which toolkit scroll bars Emacs uses, if any.
10487 A value of nil means Emacs doesn't use toolkit scroll bars.
10488 With the X Window system, the value is a symbol describing the
10489 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
10490 With MS Windows or Nextstep, the value is t. */);
10491 #ifdef USE_TOOLKIT_SCROLL_BARS
10493 Vx_toolkit_scroll_bars
= intern_c_string ("motif");
10494 #elif defined HAVE_XAW3D
10495 Vx_toolkit_scroll_bars
= intern_c_string ("xaw3d");
10497 Vx_toolkit_scroll_bars
= intern_c_string ("gtk");
10499 Vx_toolkit_scroll_bars
= intern_c_string ("xaw");
10502 Vx_toolkit_scroll_bars
= Qnil
;
10505 DEFSYM (Qmodifier_value
, "modifier-value");
10506 DEFSYM (Qalt
, "alt");
10507 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
10508 DEFSYM (Qhyper
, "hyper");
10509 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
10510 DEFSYM (Qmeta
, "meta");
10511 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
10512 DEFSYM (Qsuper
, "super");
10513 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
10515 DEFVAR_LISP ("x-alt-keysym", Vx_alt_keysym
,
10516 doc
: /* Which keys Emacs uses for the alt modifier.
10517 This should be one of the symbols `alt', `hyper', `meta', `super'.
10518 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
10519 is nil, which is the same as `alt'. */);
10520 Vx_alt_keysym
= Qnil
;
10522 DEFVAR_LISP ("x-hyper-keysym", Vx_hyper_keysym
,
10523 doc
: /* Which keys Emacs uses for the hyper modifier.
10524 This should be one of the symbols `alt', `hyper', `meta', `super'.
10525 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
10526 default is nil, which is the same as `hyper'. */);
10527 Vx_hyper_keysym
= Qnil
;
10529 DEFVAR_LISP ("x-meta-keysym", Vx_meta_keysym
,
10530 doc
: /* Which keys Emacs uses for the meta modifier.
10531 This should be one of the symbols `alt', `hyper', `meta', `super'.
10532 For example, `meta' means use the Meta_L and Meta_R keysyms. The
10533 default is nil, which is the same as `meta'. */);
10534 Vx_meta_keysym
= Qnil
;
10536 DEFVAR_LISP ("x-super-keysym", Vx_super_keysym
,
10537 doc
: /* Which keys Emacs uses for the super modifier.
10538 This should be one of the symbols `alt', `hyper', `meta', `super'.
10539 For example, `super' means use the Super_L and Super_R keysyms. The
10540 default is nil, which is the same as `super'. */);
10541 Vx_super_keysym
= Qnil
;
10543 DEFVAR_LISP ("x-keysym-table", Vx_keysym_table
,
10544 doc
: /* Hash table of character codes indexed by X keysym codes. */);
10545 Vx_keysym_table
= make_hash_table (hashtest_eql
, make_number (900),
10546 make_float (DEFAULT_REHASH_SIZE
),
10547 make_float (DEFAULT_REHASH_THRESHOLD
),