1 /* X Communication module for terminals which understand the X protocol.
3 Copyright (C) 1989, 1993-2014 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 /* New display code by Gerd Moellmann <gerd@gnu.org>. */
21 /* Xt features made by Fred Pierresteguy. */
27 #include "blockinput.h"
28 #include "syssignal.h"
30 /* This may include sys/types.h, and that somehow loses
31 if this is not done before the other system files. */
33 #include <X11/cursorfont.h>
35 /* If we have Xfixes extension, use it for pointer blanking. */
37 #include <X11/extensions/Xfixes.h>
40 /* Using Xft implies that XRender is available. */
42 #include <X11/extensions/Xrender.h>
45 /* Load sys/types.h if not already loaded.
46 In some systems loading it twice is suicidal. */
48 #include <sys/types.h>
51 #include <sys/ioctl.h>
58 /* Caused redefinition of DBL_DIG on Netbsd; seems not to be needed. */
59 /* #include <sys/param.h> */
62 #include "character.h"
65 #include "dispextern.h"
67 #include "termhooks.h"
70 #include "emacs-icon.h"
75 #include "intervals.h"
80 #include "xsettings.h"
82 #include "sysselect.h"
86 #include <X11/Shell.h>
94 #include <X11/Xproto.h>
98 #if defined (USE_LUCID) || defined (USE_MOTIF)
99 #include "../lwlib/xlwmenu.h"
103 #if !defined (NO_EDITRES)
105 extern void _XEditResCheckMessages (Widget
, XtPointer
, XEvent
*, Boolean
*);
106 #endif /* not NO_EDITRES */
108 /* Include toolkit specific headers for the scroll bar widget. */
110 #ifdef USE_TOOLKIT_SCROLL_BARS
111 #if defined USE_MOTIF
112 #include <Xm/Xm.h> /* For LESSTIF_VERSION */
113 #include <Xm/ScrollBar.h>
114 #else /* !USE_MOTIF i.e. use Xaw */
117 #include <X11/Xaw3d/Simple.h>
118 #include <X11/Xaw3d/Scrollbar.h>
119 #include <X11/Xaw3d/ThreeD.h>
120 #else /* !HAVE_XAW3D */
121 #include <X11/Xaw/Simple.h>
122 #include <X11/Xaw/Scrollbar.h>
123 #endif /* !HAVE_XAW3D */
125 #define XtNpickTop "pickTop"
126 #endif /* !XtNpickTop */
127 #endif /* !USE_MOTIF */
128 #endif /* USE_TOOLKIT_SCROLL_BARS */
130 #endif /* USE_X_TOOLKIT */
134 #ifndef XtNinitialState
135 #define XtNinitialState "initialState"
139 #include "bitmaps/gray.xbm"
142 #include <X11/XKBlib.h>
145 /* Default to using XIM if available. */
149 bool use_xim
= false; /* configure --without-xim */
152 /* Non-zero means that a HELP_EVENT has been generated since Emacs
155 static bool any_help_event_p
;
157 /* This is a chain of structures for all the X displays currently in
160 struct x_display_info
*x_display_list
;
164 /* The application context for Xt use. */
165 XtAppContext Xt_app_con
;
166 static String Xt_default_resources
[] = {0};
168 /* Non-zero means user is interacting with a toolkit scroll bar. */
169 static bool toolkit_scroll_bar_interaction
;
171 #endif /* USE_X_TOOLKIT */
173 /* Non-zero timeout value means ignore next mouse click if it arrives
174 before that timeout elapses (i.e. as part of the same sequence of
175 events resulting from clicking on a frame to select it). */
177 static Time ignore_next_mouse_click_timeout
;
179 /* Used locally within XTread_socket. */
181 static int x_noop_count
;
183 static Lisp_Object Qalt
, Qhyper
, Qmeta
, Qsuper
, Qmodifier_value
;
185 static Lisp_Object Qvendor_specific_keysyms
;
186 static Lisp_Object Qlatin_1
;
189 /* The name of the Emacs icon file. */
190 static Lisp_Object xg_default_icon_file
;
192 /* Used in gtkutil.c. */
193 Lisp_Object Qx_gtk_map_stock
;
196 /* Some functions take this as char *, not const char *. */
197 static char emacs_class
[] = EMACS_CLASS
;
201 XEMBED_MAPPED
= 1 << 0
206 XEMBED_EMBEDDED_NOTIFY
= 0,
207 XEMBED_WINDOW_ACTIVATE
= 1,
208 XEMBED_WINDOW_DEACTIVATE
= 2,
209 XEMBED_REQUEST_FOCUS
= 3,
211 XEMBED_FOCUS_OUT
= 5,
212 XEMBED_FOCUS_NEXT
= 6,
213 XEMBED_FOCUS_PREV
= 7,
215 XEMBED_MODALITY_ON
= 10,
216 XEMBED_MODALITY_OFF
= 11,
217 XEMBED_REGISTER_ACCELERATOR
= 12,
218 XEMBED_UNREGISTER_ACCELERATOR
= 13,
219 XEMBED_ACTIVATE_ACCELERATOR
= 14
222 static bool x_alloc_nearest_color_1 (Display
*, Colormap
, XColor
*);
223 static void x_set_window_size_1 (struct frame
*, int, int, int, bool);
224 static void x_raise_frame (struct frame
*);
225 static void x_lower_frame (struct frame
*);
226 static const XColor
*x_color_cells (Display
*, int *);
227 static int x_io_error_quitter (Display
*);
228 static struct terminal
*x_create_terminal (struct x_display_info
*);
229 static void x_update_end (struct frame
*);
230 static void XTframe_up_to_date (struct frame
*);
231 static void x_clear_frame (struct frame
*);
232 static _Noreturn
void x_ins_del_lines (struct frame
*, int, int);
233 static void frame_highlight (struct frame
*);
234 static void frame_unhighlight (struct frame
*);
235 static void x_new_focus_frame (struct x_display_info
*, struct frame
*);
236 static void x_focus_changed (int, int, struct x_display_info
*,
237 struct frame
*, struct input_event
*);
238 static void XTframe_rehighlight (struct frame
*);
239 static void x_frame_rehighlight (struct x_display_info
*);
240 static void x_draw_hollow_cursor (struct window
*, struct glyph_row
*);
241 static void x_draw_bar_cursor (struct window
*, struct glyph_row
*, int,
242 enum text_cursor_kinds
);
244 static void x_clip_to_row (struct window
*, struct glyph_row
*,
245 enum glyph_row_area
, GC
);
246 static void x_flush (struct frame
*f
);
247 static void x_update_begin (struct frame
*);
248 static void x_update_window_begin (struct window
*);
249 static struct scroll_bar
*x_window_to_scroll_bar (Display
*, Window
, int);
250 static void x_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
251 enum scroll_bar_part
*,
252 Lisp_Object
*, Lisp_Object
*,
254 static void x_horizontal_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
255 enum scroll_bar_part
*,
256 Lisp_Object
*, Lisp_Object
*,
258 static int x_handle_net_wm_state (struct frame
*, const XPropertyEvent
*);
259 static void x_check_fullscreen (struct frame
*);
260 static void x_check_expected_move (struct frame
*, int, int);
261 static void x_sync_with_move (struct frame
*, int, int, int);
262 static int handle_one_xevent (struct x_display_info
*,
263 const XEvent
*, int *,
264 struct input_event
*);
265 #if ! (defined USE_X_TOOLKIT || defined USE_MOTIF)
266 static int x_dispatch_event (XEvent
*, Display
*);
268 /* Don't declare this _Noreturn because we want no
269 interference with debugging failing X calls. */
270 static void x_connection_closed (Display
*, const char *);
271 static void x_wm_set_window_state (struct frame
*, int);
272 static void x_wm_set_icon_pixmap (struct frame
*, ptrdiff_t);
273 static void x_initialize (void);
275 static int get_current_wm_state (struct frame
*, Window
, int *, int *);
277 /* Flush display of frame F. */
280 x_flush (struct frame
*f
)
282 eassert (f
&& FRAME_X_P (f
));
283 /* Don't call XFlush when it is not safe to redisplay; the X
284 connection may be broken. */
285 if (!NILP (Vinhibit_redisplay
))
289 XFlush (FRAME_X_DISPLAY (f
));
294 /* Remove calls to XFlush by defining XFlush to an empty replacement.
295 Calls to XFlush should be unnecessary because the X output buffer
296 is flushed automatically as needed by calls to XPending,
297 XNextEvent, or XWindowEvent according to the XFlush man page.
298 XTread_socket calls XPending. Removing XFlush improves
301 #define XFlush(DISPLAY) (void) 0
304 /***********************************************************************
306 ***********************************************************************/
310 /* This is a function useful for recording debugging information about
311 the sequence of occurrences in this file. */
319 struct record event_record
[100];
321 int event_record_index
;
324 record_event (char *locus
, int type
)
326 if (event_record_index
== ARRAYELTS (event_record
))
327 event_record_index
= 0;
329 event_record
[event_record_index
].locus
= locus
;
330 event_record
[event_record_index
].type
= type
;
331 event_record_index
++;
338 /* Return the struct x_display_info corresponding to DPY. */
340 struct x_display_info
*
341 x_display_info_for_display (Display
*dpy
)
343 struct x_display_info
*dpyinfo
;
345 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
346 if (dpyinfo
->display
== dpy
)
353 x_find_topmost_parent (struct frame
*f
)
355 struct x_output
*x
= f
->output_data
.x
;
356 Window win
= None
, wi
= x
->parent_desc
;
357 Display
*dpy
= FRAME_X_DISPLAY (f
);
359 while (wi
!= FRAME_DISPLAY_INFO (f
)->root_window
)
363 unsigned int nchildren
;
366 if (XQueryTree (dpy
, win
, &root
, &wi
, &children
, &nchildren
))
375 #define OPAQUE 0xffffffff
378 x_set_frame_alpha (struct frame
*f
)
380 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
381 Display
*dpy
= FRAME_X_DISPLAY (f
);
382 Window win
= FRAME_OUTER_WINDOW (f
);
384 double alpha_min
= 1.0;
388 if (dpyinfo
->x_highlight_frame
== f
)
393 if (FLOATP (Vframe_alpha_lower_limit
))
394 alpha_min
= XFLOAT_DATA (Vframe_alpha_lower_limit
);
395 else if (INTEGERP (Vframe_alpha_lower_limit
))
396 alpha_min
= (XINT (Vframe_alpha_lower_limit
)) / 100.0;
400 else if (alpha
> 1.0)
402 else if (0.0 <= alpha
&& alpha
< alpha_min
&& alpha_min
<= 1.0)
405 opac
= alpha
* OPAQUE
;
407 x_catch_errors (dpy
);
409 /* If there is a parent from the window manager, put the property there
410 also, to work around broken window managers that fail to do that.
411 Do this unconditionally as this function is called on reparent when
412 alpha has not changed on the frame. */
414 parent
= x_find_topmost_parent (f
);
416 XChangeProperty (dpy
, parent
, dpyinfo
->Xatom_net_wm_window_opacity
,
417 XA_CARDINAL
, 32, PropModeReplace
,
418 (unsigned char *) &opac
, 1);
420 /* return unless necessary */
425 unsigned long n
, left
;
427 rc
= XGetWindowProperty (dpy
, win
, dpyinfo
->Xatom_net_wm_window_opacity
,
428 0, 1, False
, XA_CARDINAL
,
429 &actual
, &format
, &n
, &left
,
432 if (rc
== Success
&& actual
!= None
)
434 unsigned long value
= *(unsigned long *)data
;
444 XChangeProperty (dpy
, win
, dpyinfo
->Xatom_net_wm_window_opacity
,
445 XA_CARDINAL
, 32, PropModeReplace
,
446 (unsigned char *) &opac
, 1);
450 /***********************************************************************
451 Starting and ending an update
452 ***********************************************************************/
454 /* Start an update of frame F. This function is installed as a hook
455 for update_begin, i.e. it is called when update_begin is called.
456 This function is called prior to calls to x_update_window_begin for
457 each window being updated. Currently, there is nothing to do here
458 because all interesting stuff is done on a window basis. */
461 x_update_begin (struct frame
*f
)
467 /* Start update of window W. */
470 x_update_window_begin (struct window
*w
)
472 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
473 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
475 w
->output_cursor
= w
->cursor
;
479 if (f
== hlinfo
->mouse_face_mouse_frame
)
481 /* Don't do highlighting for mouse motion during the update. */
482 hlinfo
->mouse_face_defer
= 1;
484 /* If F needs to be redrawn, simply forget about any prior mouse
486 if (FRAME_GARBAGED_P (f
))
487 hlinfo
->mouse_face_window
= Qnil
;
494 /* Draw a vertical window border from (x,y0) to (x,y1) */
497 x_draw_vertical_window_border (struct window
*w
, int x
, int y0
, int y1
)
499 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
502 face
= FACE_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
504 XSetForeground (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
507 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
508 f
->output_data
.x
->normal_gc
, x
, y0
, x
, y1
);
511 /* Draw a window divider from (x0,y0) to (x1,y1) */
514 x_draw_window_divider (struct window
*w
, int x0
, int x1
, int y0
, int y1
)
516 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
517 struct face
*face
= FACE_FROM_ID (f
, WINDOW_DIVIDER_FACE_ID
);
518 struct face
*face_first
= FACE_FROM_ID (f
, WINDOW_DIVIDER_FIRST_PIXEL_FACE_ID
);
519 struct face
*face_last
= FACE_FROM_ID (f
, WINDOW_DIVIDER_LAST_PIXEL_FACE_ID
);
520 unsigned long color
= face
? face
->foreground
: FRAME_FOREGROUND_PIXEL (f
);
521 unsigned long color_first
= (face_first
522 ? face_first
->foreground
523 : FRAME_FOREGROUND_PIXEL (f
));
524 unsigned long color_last
= (face_last
525 ? face_last
->foreground
526 : FRAME_FOREGROUND_PIXEL (f
));
527 Display
*display
= FRAME_X_DISPLAY (f
);
528 Window window
= FRAME_X_WINDOW (f
);
530 if (y1
- y0
> x1
- x0
&& x1
- x0
> 2)
533 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color_first
);
534 XFillRectangle (display
, window
, f
->output_data
.x
->normal_gc
,
536 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color
);
537 XFillRectangle (display
, window
, f
->output_data
.x
->normal_gc
,
538 x0
+ 1, y0
, x1
- x0
- 2, y1
- y0
);
539 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color_last
);
540 XFillRectangle (display
, window
, f
->output_data
.x
->normal_gc
,
541 x1
- 1, y0
, 1, y1
- y0
);
543 else if (x1
- x0
> y1
- y0
&& y1
- y0
> 3)
546 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color_first
);
547 XFillRectangle (display
, window
, f
->output_data
.x
->normal_gc
,
549 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color
);
550 XFillRectangle (display
, window
, f
->output_data
.x
->normal_gc
,
551 x0
, y0
+ 1, x1
- x0
, y1
- y0
- 2);
552 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color_last
);
553 XFillRectangle (display
, window
, f
->output_data
.x
->normal_gc
,
554 x0
, y1
- 1, x1
- x0
, 1);
558 XSetForeground (display
, f
->output_data
.x
->normal_gc
, color
);
559 XFillRectangle (display
, window
, f
->output_data
.x
->normal_gc
,
560 x0
, y0
, x1
- x0
, y1
- y0
);
564 /* End update of window W.
566 Draw vertical borders between horizontally adjacent windows, and
567 display W's cursor if CURSOR_ON_P is non-zero.
569 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
570 glyphs in mouse-face were overwritten. In that case we have to
571 make sure that the mouse-highlight is properly redrawn.
573 W may be a menu bar pseudo-window in case we don't have X toolkit
574 support. Such windows don't have a cursor, so don't display it
578 x_update_window_end (struct window
*w
, bool cursor_on_p
,
579 bool mouse_face_overwritten_p
)
581 if (!w
->pseudo_window_p
)
586 display_and_set_cursor (w
, 1,
587 w
->output_cursor
.hpos
, w
->output_cursor
.vpos
,
588 w
->output_cursor
.x
, w
->output_cursor
.y
);
590 if (draw_window_fringes (w
, 1))
592 if (WINDOW_RIGHT_DIVIDER_WIDTH (w
))
593 x_draw_right_divider (w
);
595 x_draw_vertical_border (w
);
601 /* If a row with mouse-face was overwritten, arrange for
602 XTframe_up_to_date to redisplay the mouse highlight. */
603 if (mouse_face_overwritten_p
)
605 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
607 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
608 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
609 hlinfo
->mouse_face_window
= Qnil
;
614 /* End update of frame F. This function is installed as a hook in
618 x_update_end (struct frame
*f
)
620 /* Mouse highlight may be displayed again. */
621 MOUSE_HL_INFO (f
)->mouse_face_defer
= 0;
625 XFlush (FRAME_X_DISPLAY (f
));
631 /* This function is called from various places in xdisp.c
632 whenever a complete update has been performed. */
635 XTframe_up_to_date (struct frame
*f
)
638 FRAME_MOUSE_UPDATE (f
);
642 /* Clear under internal border if any (GTK has its own version). */
645 x_clear_under_internal_border (struct frame
*f
)
647 if (FRAME_INTERNAL_BORDER_WIDTH (f
) > 0)
649 Display
*display
= FRAME_X_DISPLAY (f
);
650 Window window
= FRAME_X_WINDOW (f
);
651 int border
= FRAME_INTERNAL_BORDER_WIDTH (f
);
652 int width
= FRAME_PIXEL_WIDTH (f
);
653 int height
= FRAME_PIXEL_HEIGHT (f
);
654 int margin
= FRAME_TOP_MARGIN_HEIGHT (f
);
657 x_clear_area (display
, window
, 0, 0, border
, height
);
658 x_clear_area (display
, window
, 0, margin
, width
, border
);
659 x_clear_area (display
, window
, width
- border
, 0, border
, height
);
660 x_clear_area (display
, window
, 0, height
- border
, width
, border
);
666 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
667 arrow bitmaps, or clear the fringes if no bitmaps are required
668 before DESIRED_ROW is made current. This function is called from
669 update_window_line only if it is known that there are differences
670 between bitmaps to be drawn between current row and DESIRED_ROW. */
673 x_after_update_window_line (struct window
*w
, struct glyph_row
*desired_row
)
677 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
678 desired_row
->redraw_fringe_bitmaps_p
= 1;
681 /* When a window has disappeared, make sure that no rest of
682 full-width rows stays visible in the internal border. Could
683 check here if updated window is the leftmost/rightmost window,
684 but I guess it's not worth doing since vertically split windows
685 are almost never used, internal border is rarely set, and the
686 overhead is very small. */
691 if (windows_or_buffers_changed
692 && desired_row
->full_width_p
693 && (f
= XFRAME (w
->frame
),
694 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
696 && (height
= desired_row
->visible_height
,
699 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
702 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
703 0, y
, width
, height
);
704 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
705 FRAME_PIXEL_WIDTH (f
) - width
,
714 x_draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
, struct draw_fringe_bitmap_params
*p
)
716 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
717 Display
*display
= FRAME_X_DISPLAY (f
);
718 Window window
= FRAME_X_WINDOW (f
);
719 GC gc
= f
->output_data
.x
->normal_gc
;
720 struct face
*face
= p
->face
;
722 /* Must clip because of partially visible lines. */
723 x_clip_to_row (w
, row
, ANY_AREA
, gc
);
725 if (p
->bx
>= 0 && !p
->overlay_p
)
727 /* In case the same realized face is used for fringes and
728 for something displayed in the text (e.g. face `region' on
729 mono-displays, the fill style may have been changed to
730 FillSolid in x_draw_glyph_string_background. */
732 XSetFillStyle (display
, face
->gc
, FillOpaqueStippled
);
734 XSetForeground (display
, face
->gc
, face
->background
);
736 XFillRectangle (display
, window
, face
->gc
,
737 p
->bx
, p
->by
, p
->nx
, p
->ny
);
740 XSetForeground (display
, face
->gc
, face
->foreground
);
746 Pixmap pixmap
, clipmask
= (Pixmap
) 0;
747 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
751 bits
= (char *) (p
->bits
+ p
->dh
);
753 bits
= (char *) p
->bits
+ p
->dh
;
755 /* Draw the bitmap. I believe these small pixmaps can be cached
757 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, p
->wd
, p
->h
,
759 ? (p
->overlay_p
? face
->background
760 : f
->output_data
.x
->cursor_pixel
)
762 face
->background
, depth
);
766 clipmask
= XCreatePixmapFromBitmapData (display
,
767 FRAME_DISPLAY_INFO (f
)->root_window
,
770 gcv
.clip_mask
= clipmask
;
771 gcv
.clip_x_origin
= p
->x
;
772 gcv
.clip_y_origin
= p
->y
;
773 XChangeGC (display
, gc
, GCClipMask
| GCClipXOrigin
| GCClipYOrigin
, &gcv
);
776 XCopyArea (display
, pixmap
, window
, gc
, 0, 0,
777 p
->wd
, p
->h
, p
->x
, p
->y
);
778 XFreePixmap (display
, pixmap
);
782 gcv
.clip_mask
= (Pixmap
) 0;
783 XChangeGC (display
, gc
, GCClipMask
, &gcv
);
784 XFreePixmap (display
, clipmask
);
788 XSetClipMask (display
, gc
, None
);
791 /***********************************************************************
793 ***********************************************************************/
797 static void x_set_glyph_string_clipping (struct glyph_string
*);
798 static void x_set_glyph_string_gc (struct glyph_string
*);
799 static void x_draw_glyph_string_foreground (struct glyph_string
*);
800 static void x_draw_composite_glyph_string_foreground (struct glyph_string
*);
801 static void x_draw_glyph_string_box (struct glyph_string
*);
802 static void x_draw_glyph_string (struct glyph_string
*);
803 static _Noreturn
void x_delete_glyphs (struct frame
*, int);
804 static void x_compute_glyph_string_overhangs (struct glyph_string
*);
805 static void x_set_cursor_gc (struct glyph_string
*);
806 static void x_set_mode_line_face_gc (struct glyph_string
*);
807 static void x_set_mouse_face_gc (struct glyph_string
*);
808 static bool x_alloc_lighter_color (struct frame
*, Display
*, Colormap
,
809 unsigned long *, double, int);
810 static void x_setup_relief_color (struct frame
*, struct relief
*,
811 double, int, unsigned long);
812 static void x_setup_relief_colors (struct glyph_string
*);
813 static void x_draw_image_glyph_string (struct glyph_string
*);
814 static void x_draw_image_relief (struct glyph_string
*);
815 static void x_draw_image_foreground (struct glyph_string
*);
816 static void x_draw_image_foreground_1 (struct glyph_string
*, Pixmap
);
817 static void x_clear_glyph_string_rect (struct glyph_string
*, int,
819 static void x_draw_relief_rect (struct frame
*, int, int, int, int,
820 int, int, int, int, int, int,
822 static void x_draw_box_rect (struct glyph_string
*, int, int, int, int,
823 int, int, int, XRectangle
*);
824 static void x_scroll_bar_clear (struct frame
*);
827 static void x_check_font (struct frame
*, struct font
*);
831 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
835 x_set_cursor_gc (struct glyph_string
*s
)
837 if (s
->font
== FRAME_FONT (s
->f
)
838 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
839 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
841 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
844 /* Cursor on non-default face: must merge. */
848 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
849 xgcv
.foreground
= s
->face
->background
;
851 /* If the glyph would be invisible, try a different foreground. */
852 if (xgcv
.foreground
== xgcv
.background
)
853 xgcv
.foreground
= s
->face
->foreground
;
854 if (xgcv
.foreground
== xgcv
.background
)
855 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
856 if (xgcv
.foreground
== xgcv
.background
)
857 xgcv
.foreground
= s
->face
->foreground
;
859 /* Make sure the cursor is distinct from text in this face. */
860 if (xgcv
.background
== s
->face
->background
861 && xgcv
.foreground
== s
->face
->foreground
)
863 xgcv
.background
= s
->face
->foreground
;
864 xgcv
.foreground
= s
->face
->background
;
867 IF_DEBUG (x_check_font (s
->f
, s
->font
));
868 xgcv
.graphics_exposures
= False
;
869 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
871 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
872 XChangeGC (s
->display
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
875 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
876 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
878 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
883 /* Set up S->gc of glyph string S for drawing text in mouse face. */
886 x_set_mouse_face_gc (struct glyph_string
*s
)
891 /* What face has to be used last for the mouse face? */
892 face_id
= MOUSE_HL_INFO (s
->f
)->mouse_face_face_id
;
893 face
= FACE_FROM_ID (s
->f
, face_id
);
895 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
897 if (s
->first_glyph
->type
== CHAR_GLYPH
)
898 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
900 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
901 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
902 prepare_face_for_display (s
->f
, s
->face
);
904 if (s
->font
== s
->face
->font
)
908 /* Otherwise construct scratch_cursor_gc with values from FACE
913 xgcv
.background
= s
->face
->background
;
914 xgcv
.foreground
= s
->face
->foreground
;
915 xgcv
.graphics_exposures
= False
;
916 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
918 if (FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
919 XChangeGC (s
->display
, FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
922 FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
923 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
925 s
->gc
= FRAME_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
928 eassert (s
->gc
!= 0);
932 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
933 Faces to use in the mode line have already been computed when the
934 matrix was built, so there isn't much to do, here. */
937 x_set_mode_line_face_gc (struct glyph_string
*s
)
943 /* Set S->gc of glyph string S for drawing that glyph string. Set
944 S->stippled_p to a non-zero value if the face of S has a stipple
948 x_set_glyph_string_gc (struct glyph_string
*s
)
950 prepare_face_for_display (s
->f
, s
->face
);
952 if (s
->hl
== DRAW_NORMAL_TEXT
)
955 s
->stippled_p
= s
->face
->stipple
!= 0;
957 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
959 x_set_mode_line_face_gc (s
);
960 s
->stippled_p
= s
->face
->stipple
!= 0;
962 else if (s
->hl
== DRAW_CURSOR
)
967 else if (s
->hl
== DRAW_MOUSE_FACE
)
969 x_set_mouse_face_gc (s
);
970 s
->stippled_p
= s
->face
->stipple
!= 0;
972 else if (s
->hl
== DRAW_IMAGE_RAISED
973 || s
->hl
== DRAW_IMAGE_SUNKEN
)
976 s
->stippled_p
= s
->face
->stipple
!= 0;
981 /* GC must have been set. */
982 eassert (s
->gc
!= 0);
986 /* Set clipping for output of glyph string S. S may be part of a mode
987 line or menu if we don't have X toolkit support. */
990 x_set_glyph_string_clipping (struct glyph_string
*s
)
992 XRectangle
*r
= s
->clip
;
993 int n
= get_glyph_string_clip_rects (s
, r
, 2);
996 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, r
, n
, Unsorted
);
1001 /* Set SRC's clipping for output of glyph string DST. This is called
1002 when we are drawing DST's left_overhang or right_overhang only in
1006 x_set_glyph_string_clipping_exactly (struct glyph_string
*src
, struct glyph_string
*dst
)
1011 r
.width
= src
->width
;
1013 r
.height
= src
->height
;
1016 XSetClipRectangles (dst
->display
, dst
->gc
, 0, 0, &r
, 1, Unsorted
);
1021 Compute left and right overhang of glyph string S. */
1024 x_compute_glyph_string_overhangs (struct glyph_string
*s
)
1027 && (s
->first_glyph
->type
== CHAR_GLYPH
1028 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
1030 struct font_metrics metrics
;
1032 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1034 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1035 struct font
*font
= s
->font
;
1038 for (i
= 0; i
< s
->nchars
; i
++)
1039 code
[i
] = (s
->char2b
[i
].byte1
<< 8) | s
->char2b
[i
].byte2
;
1040 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1044 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1046 composition_gstring_width (gstring
, s
->cmp_from
, s
->cmp_to
, &metrics
);
1048 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1049 ? metrics
.rbearing
- metrics
.width
: 0);
1050 s
->left_overhang
= metrics
.lbearing
< 0 ? - metrics
.lbearing
: 0;
1054 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1055 s
->left_overhang
= - s
->cmp
->lbearing
;
1060 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1063 x_clear_glyph_string_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
1066 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
1067 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
1068 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
1069 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
1073 /* Draw the background of glyph_string S. If S->background_filled_p
1074 is non-zero don't draw it. FORCE_P non-zero means draw the
1075 background even if it wouldn't be drawn normally. This is used
1076 when a string preceding S draws into the background of S, or S
1077 contains the first component of a composition. */
1080 x_draw_glyph_string_background (struct glyph_string
*s
, bool force_p
)
1082 /* Nothing to do if background has already been drawn or if it
1083 shouldn't be drawn in the first place. */
1084 if (!s
->background_filled_p
)
1086 int box_line_width
= max (s
->face
->box_line_width
, 0);
1090 /* Fill background with a stipple pattern. */
1091 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1092 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1093 s
->y
+ box_line_width
,
1094 s
->background_width
,
1095 s
->height
- 2 * box_line_width
);
1096 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1097 s
->background_filled_p
= 1;
1099 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1100 || s
->font_not_found_p
1101 || s
->extends_to_end_of_line_p
1104 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1105 s
->background_width
,
1106 s
->height
- 2 * box_line_width
);
1107 s
->background_filled_p
= 1;
1113 /* Draw the foreground of glyph string S. */
1116 x_draw_glyph_string_foreground (struct glyph_string
*s
)
1120 /* If first glyph of S has a left box line, start drawing the text
1121 of S to the right of that box line. */
1122 if (s
->face
->box
!= FACE_NO_BOX
1123 && s
->first_glyph
->left_box_line_p
)
1124 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1128 /* Draw characters of S as rectangles if S's font could not be
1130 if (s
->font_not_found_p
)
1132 for (i
= 0; i
< s
->nchars
; ++i
)
1134 struct glyph
*g
= s
->first_glyph
+ i
;
1135 XDrawRectangle (s
->display
, s
->window
,
1136 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1138 x
+= g
->pixel_width
;
1143 struct font
*font
= s
->font
;
1144 int boff
= font
->baseline_offset
;
1147 if (font
->vertical_centering
)
1148 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1150 y
= s
->ybase
- boff
;
1152 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1153 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 0);
1155 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 1);
1156 if (s
->face
->overstrike
)
1157 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, 0);
1161 /* Draw the foreground of composite glyph string S. */
1164 x_draw_composite_glyph_string_foreground (struct glyph_string
*s
)
1167 struct font
*font
= s
->font
;
1169 /* If first glyph of S has a left box line, start drawing the text
1170 of S to the right of that box line. */
1171 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1172 && s
->first_glyph
->left_box_line_p
)
1173 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1177 /* S is a glyph string for a composition. S->cmp_from is the index
1178 of the first character drawn for glyphs of this composition.
1179 S->cmp_from == 0 means we are drawing the very first character of
1180 this composition. */
1182 /* Draw a rectangle for the composition if the font for the very
1183 first character of the composition could not be loaded. */
1184 if (s
->font_not_found_p
)
1186 if (s
->cmp_from
== 0)
1187 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, s
->y
,
1188 s
->width
- 1, s
->height
- 1);
1190 else if (! s
->first_glyph
->u
.cmp
.automatic
)
1194 for (i
= 0, j
= s
->cmp_from
; i
< s
->nchars
; i
++, j
++)
1195 /* TAB in a composition means display glyphs with padding
1196 space on the left or right. */
1197 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1199 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1200 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1202 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, 0);
1203 if (s
->face
->overstrike
)
1204 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, 0);
1209 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1214 for (i
= j
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
1216 glyph
= LGSTRING_GLYPH (gstring
, i
);
1217 if (NILP (LGLYPH_ADJUSTMENT (glyph
)))
1218 width
+= LGLYPH_WIDTH (glyph
);
1221 int xoff
, yoff
, wadjust
;
1225 font
->driver
->draw (s
, j
, i
, x
, y
, 0);
1226 if (s
->face
->overstrike
)
1227 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, 0);
1230 xoff
= LGLYPH_XOFF (glyph
);
1231 yoff
= LGLYPH_YOFF (glyph
);
1232 wadjust
= LGLYPH_WADJUST (glyph
);
1233 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, 0);
1234 if (s
->face
->overstrike
)
1235 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
+ 1, y
+ yoff
, 0);
1243 font
->driver
->draw (s
, j
, i
, x
, y
, 0);
1244 if (s
->face
->overstrike
)
1245 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, 0);
1251 /* Draw the foreground of glyph string S for glyphless characters. */
1254 x_draw_glyphless_glyph_string_foreground (struct glyph_string
*s
)
1256 struct glyph
*glyph
= s
->first_glyph
;
1260 /* If first glyph of S has a left box line, start drawing the text
1261 of S to the right of that box line. */
1262 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1263 && s
->first_glyph
->left_box_line_p
)
1264 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1270 for (i
= 0; i
< s
->nchars
; i
++, glyph
++)
1272 char buf
[7], *str
= NULL
;
1273 int len
= glyph
->u
.glyphless
.len
;
1275 if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_ACRONYM
)
1278 && CHAR_TABLE_P (Vglyphless_char_display
)
1279 && (CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display
))
1283 = (! glyph
->u
.glyphless
.for_no_font
1284 ? CHAR_TABLE_REF (Vglyphless_char_display
,
1285 glyph
->u
.glyphless
.ch
)
1286 : XCHAR_TABLE (Vglyphless_char_display
)->extras
[0]);
1287 if (STRINGP (acronym
))
1288 str
= SSDATA (acronym
);
1291 else if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_HEX_CODE
)
1293 sprintf (buf
, "%0*X",
1294 glyph
->u
.glyphless
.ch
< 0x10000 ? 4 : 6,
1295 glyph
->u
.glyphless
.ch
);
1301 int upper_len
= (len
+ 1) / 2;
1304 /* It is assured that all LEN characters in STR is ASCII. */
1305 for (j
= 0; j
< len
; j
++)
1307 code
= s
->font
->driver
->encode_char (s
->font
, str
[j
]);
1308 STORE_XCHAR2B (char2b
+ j
, code
>> 8, code
& 0xFF);
1310 s
->font
->driver
->draw (s
, 0, upper_len
,
1311 x
+ glyph
->slice
.glyphless
.upper_xoff
,
1312 s
->ybase
+ glyph
->slice
.glyphless
.upper_yoff
,
1314 s
->font
->driver
->draw (s
, upper_len
, len
,
1315 x
+ glyph
->slice
.glyphless
.lower_xoff
,
1316 s
->ybase
+ glyph
->slice
.glyphless
.lower_yoff
,
1319 if (glyph
->u
.glyphless
.method
!= GLYPHLESS_DISPLAY_THIN_SPACE
)
1320 XDrawRectangle (s
->display
, s
->window
, s
->gc
,
1321 x
, s
->ybase
- glyph
->ascent
,
1322 glyph
->pixel_width
- 1,
1323 glyph
->ascent
+ glyph
->descent
- 1);
1324 x
+= glyph
->pixel_width
;
1328 #ifdef USE_X_TOOLKIT
1332 /* Return the frame on which widget WIDGET is used.. Abort if frame
1333 cannot be determined. */
1335 static struct frame
*
1336 x_frame_of_widget (Widget widget
)
1338 struct x_display_info
*dpyinfo
;
1339 Lisp_Object tail
, frame
;
1342 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
1344 /* Find the top-level shell of the widget. Note that this function
1345 can be called when the widget is not yet realized, so XtWindow
1346 (widget) == 0. That's the reason we can't simply use
1347 x_any_window_to_frame. */
1348 while (!XtIsTopLevelShell (widget
))
1349 widget
= XtParent (widget
);
1351 /* Look for a frame with that top-level widget. Allocate the color
1352 on that frame to get the right gamma correction value. */
1353 FOR_EACH_FRAME (tail
, frame
)
1357 && f
->output_data
.nothing
!= 1
1358 && FRAME_DISPLAY_INFO (f
) == dpyinfo
1359 && f
->output_data
.x
->widget
== widget
)
1365 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1366 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1367 If this produces the same color as PIXEL, try a color where all RGB
1368 values have DELTA added. Return the allocated color in *PIXEL.
1369 DISPLAY is the X display, CMAP is the colormap to operate on.
1370 Value is true if successful. */
1373 x_alloc_lighter_color_for_widget (Widget widget
, Display
*display
, Colormap cmap
,
1374 unsigned long *pixel
, double factor
, int delta
)
1376 struct frame
*f
= x_frame_of_widget (widget
);
1377 return x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
);
1380 #endif /* USE_LUCID */
1383 /* Structure specifying which arguments should be passed by Xt to
1384 cvt_string_to_pixel. We want the widget's screen and colormap. */
1386 static XtConvertArgRec cvt_string_to_pixel_args
[] =
1388 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.screen
),
1390 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.colormap
),
1395 /* The address of this variable is returned by
1396 cvt_string_to_pixel. */
1398 static Pixel cvt_string_to_pixel_value
;
1401 /* Convert a color name to a pixel color.
1403 DPY is the display we are working on.
1405 ARGS is an array of *NARGS XrmValue structures holding additional
1406 information about the widget for which the conversion takes place.
1407 The contents of this array are determined by the specification
1408 in cvt_string_to_pixel_args.
1410 FROM is a pointer to an XrmValue which points to the color name to
1411 convert. TO is an XrmValue in which to return the pixel color.
1413 CLOSURE_RET is a pointer to user-data, in which we record if
1414 we allocated the color or not.
1416 Value is True if successful, False otherwise. */
1419 cvt_string_to_pixel (Display
*dpy
, XrmValue
*args
, Cardinal
*nargs
,
1420 XrmValue
*from
, XrmValue
*to
,
1421 XtPointer
*closure_ret
)
1431 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1432 "wrongParameters", "cvt_string_to_pixel",
1434 "Screen and colormap args required", NULL
, NULL
);
1438 screen
= *(Screen
**) args
[0].addr
;
1439 cmap
= *(Colormap
*) args
[1].addr
;
1440 color_name
= (String
) from
->addr
;
1442 if (strcmp (color_name
, XtDefaultBackground
) == 0)
1444 *closure_ret
= (XtPointer
) False
;
1445 pixel
= WhitePixelOfScreen (screen
);
1447 else if (strcmp (color_name
, XtDefaultForeground
) == 0)
1449 *closure_ret
= (XtPointer
) False
;
1450 pixel
= BlackPixelOfScreen (screen
);
1452 else if (XParseColor (dpy
, cmap
, color_name
, &color
)
1453 && x_alloc_nearest_color_1 (dpy
, cmap
, &color
))
1455 pixel
= color
.pixel
;
1456 *closure_ret
= (XtPointer
) True
;
1461 Cardinal nparams
= 1;
1463 params
[0] = color_name
;
1464 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1465 "badValue", "cvt_string_to_pixel",
1466 "XtToolkitError", "Invalid color `%s'",
1471 if (to
->addr
!= NULL
)
1473 if (to
->size
< sizeof (Pixel
))
1475 to
->size
= sizeof (Pixel
);
1479 *(Pixel
*) to
->addr
= pixel
;
1483 cvt_string_to_pixel_value
= pixel
;
1484 to
->addr
= (XtPointer
) &cvt_string_to_pixel_value
;
1487 to
->size
= sizeof (Pixel
);
1492 /* Free a pixel color which was previously allocated via
1493 cvt_string_to_pixel. This is registered as the destructor
1494 for this type of resource via XtSetTypeConverter.
1496 APP is the application context in which we work.
1498 TO is a pointer to an XrmValue holding the color to free.
1499 CLOSURE is the value we stored in CLOSURE_RET for this color
1500 in cvt_string_to_pixel.
1502 ARGS and NARGS are like for cvt_string_to_pixel. */
1505 cvt_pixel_dtor (XtAppContext app
, XrmValuePtr to
, XtPointer closure
, XrmValuePtr args
,
1510 XtAppWarningMsg (app
, "wrongParameters", "cvt_pixel_dtor",
1512 "Screen and colormap arguments required",
1515 else if (closure
!= NULL
)
1517 /* We did allocate the pixel, so free it. */
1518 Screen
*screen
= *(Screen
**) args
[0].addr
;
1519 Colormap cmap
= *(Colormap
*) args
[1].addr
;
1520 x_free_dpy_colors (DisplayOfScreen (screen
), screen
, cmap
,
1521 (Pixel
*) to
->addr
, 1);
1526 #endif /* USE_X_TOOLKIT */
1529 /* Value is an array of XColor structures for the contents of the
1530 color map of display DPY. Set *NCELLS to the size of the array.
1531 Note that this probably shouldn't be called for large color maps,
1532 say a 24-bit TrueColor map. */
1534 static const XColor
*
1535 x_color_cells (Display
*dpy
, int *ncells
)
1537 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1539 if (dpyinfo
->color_cells
== NULL
)
1541 Screen
*screen
= dpyinfo
->screen
;
1542 int ncolor_cells
= XDisplayCells (dpy
, XScreenNumberOfScreen (screen
));
1545 dpyinfo
->color_cells
= xnmalloc (ncolor_cells
,
1546 sizeof *dpyinfo
->color_cells
);
1547 dpyinfo
->ncolor_cells
= ncolor_cells
;
1549 for (i
= 0; i
< ncolor_cells
; ++i
)
1550 dpyinfo
->color_cells
[i
].pixel
= i
;
1552 XQueryColors (dpy
, dpyinfo
->cmap
,
1553 dpyinfo
->color_cells
, ncolor_cells
);
1556 *ncells
= dpyinfo
->ncolor_cells
;
1557 return dpyinfo
->color_cells
;
1561 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1562 colors in COLORS. Use cached information, if available. */
1565 x_query_colors (struct frame
*f
, XColor
*colors
, int ncolors
)
1567 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
1569 if (dpyinfo
->color_cells
)
1572 for (i
= 0; i
< ncolors
; ++i
)
1574 unsigned long pixel
= colors
[i
].pixel
;
1575 eassert (pixel
< dpyinfo
->ncolor_cells
);
1576 eassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
1577 colors
[i
] = dpyinfo
->color_cells
[pixel
];
1581 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
1585 /* On frame F, translate pixel color to RGB values for the color in
1586 COLOR. Use cached information, if available. */
1589 x_query_color (struct frame
*f
, XColor
*color
)
1591 x_query_colors (f
, color
, 1);
1595 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
1596 exact match can't be allocated, try the nearest color available.
1597 Value is true if successful. Set *COLOR to the color
1601 x_alloc_nearest_color_1 (Display
*dpy
, Colormap cmap
, XColor
*color
)
1605 rc
= XAllocColor (dpy
, cmap
, color
) != 0;
1608 /* If we got to this point, the colormap is full, so we're going
1609 to try to get the next closest color. The algorithm used is
1610 a least-squares matching, which is what X uses for closest
1611 color matching with StaticColor visuals. */
1613 int max_color_delta
= 255;
1614 int max_delta
= 3 * max_color_delta
;
1615 int nearest_delta
= max_delta
+ 1;
1617 const XColor
*cells
= x_color_cells (dpy
, &ncells
);
1619 for (nearest
= i
= 0; i
< ncells
; ++i
)
1621 int dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
1622 int dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
1623 int dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
1624 int delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
1626 if (delta
< nearest_delta
)
1629 nearest_delta
= delta
;
1633 color
->red
= cells
[nearest
].red
;
1634 color
->green
= cells
[nearest
].green
;
1635 color
->blue
= cells
[nearest
].blue
;
1636 rc
= XAllocColor (dpy
, cmap
, color
) != 0;
1640 /* If allocation succeeded, and the allocated pixel color is not
1641 equal to a cached pixel color recorded earlier, there was a
1642 change in the colormap, so clear the color cache. */
1643 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1644 XColor
*cached_color
;
1646 if (dpyinfo
->color_cells
1647 && (cached_color
= &dpyinfo
->color_cells
[color
->pixel
],
1648 (cached_color
->red
!= color
->red
1649 || cached_color
->blue
!= color
->blue
1650 || cached_color
->green
!= color
->green
)))
1652 xfree (dpyinfo
->color_cells
);
1653 dpyinfo
->color_cells
= NULL
;
1654 dpyinfo
->ncolor_cells
= 0;
1658 #ifdef DEBUG_X_COLORS
1660 register_color (color
->pixel
);
1661 #endif /* DEBUG_X_COLORS */
1667 /* Allocate the color COLOR->pixel on frame F, colormap CMAP. If an
1668 exact match can't be allocated, try the nearest color available.
1669 Value is true if successful. Set *COLOR to the color
1673 x_alloc_nearest_color (struct frame
*f
, Colormap cmap
, XColor
*color
)
1675 gamma_correct (f
, color
);
1676 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f
), cmap
, color
);
1680 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
1681 It's necessary to do this instead of just using PIXEL directly to
1682 get color reference counts right. */
1685 x_copy_color (struct frame
*f
, unsigned long pixel
)
1689 color
.pixel
= pixel
;
1691 x_query_color (f
, &color
);
1692 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
1694 #ifdef DEBUG_X_COLORS
1695 register_color (pixel
);
1701 /* Brightness beyond which a color won't have its highlight brightness
1704 Nominally, highlight colors for `3d' faces are calculated by
1705 brightening an object's color by a constant scale factor, but this
1706 doesn't yield good results for dark colors, so for colors who's
1707 brightness is less than this value (on a scale of 0-65535) have an
1708 use an additional additive factor.
1710 The value here is set so that the default menu-bar/mode-line color
1711 (grey75) will not have its highlights changed at all. */
1712 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
1715 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1716 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1717 If this produces the same color as PIXEL, try a color where all RGB
1718 values have DELTA added. Return the allocated color in *PIXEL.
1719 DISPLAY is the X display, CMAP is the colormap to operate on.
1720 Value is non-zero if successful. */
1723 x_alloc_lighter_color (struct frame
*f
, Display
*display
, Colormap cmap
,
1724 unsigned long *pixel
, double factor
, int delta
)
1730 /* Get RGB color values. */
1731 color
.pixel
= *pixel
;
1732 x_query_color (f
, &color
);
1734 /* Change RGB values by specified FACTOR. Avoid overflow! */
1735 eassert (factor
>= 0);
1736 new.red
= min (0xffff, factor
* color
.red
);
1737 new.green
= min (0xffff, factor
* color
.green
);
1738 new.blue
= min (0xffff, factor
* color
.blue
);
1740 /* Calculate brightness of COLOR. */
1741 bright
= (2 * color
.red
+ 3 * color
.green
+ color
.blue
) / 6;
1743 /* We only boost colors that are darker than
1744 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1745 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1746 /* Make an additive adjustment to NEW, because it's dark enough so
1747 that scaling by FACTOR alone isn't enough. */
1749 /* How far below the limit this color is (0 - 1, 1 being darker). */
1750 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1751 /* The additive adjustment. */
1752 int min_delta
= delta
* dimness
* factor
/ 2;
1756 new.red
= max (0, new.red
- min_delta
);
1757 new.green
= max (0, new.green
- min_delta
);
1758 new.blue
= max (0, new.blue
- min_delta
);
1762 new.red
= min (0xffff, min_delta
+ new.red
);
1763 new.green
= min (0xffff, min_delta
+ new.green
);
1764 new.blue
= min (0xffff, min_delta
+ new.blue
);
1768 /* Try to allocate the color. */
1769 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1772 if (new.pixel
== *pixel
)
1774 /* If we end up with the same color as before, try adding
1775 delta to the RGB values. */
1776 x_free_colors (f
, &new.pixel
, 1);
1778 new.red
= min (0xffff, delta
+ color
.red
);
1779 new.green
= min (0xffff, delta
+ color
.green
);
1780 new.blue
= min (0xffff, delta
+ color
.blue
);
1781 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1792 /* Set up the foreground color for drawing relief lines of glyph
1793 string S. RELIEF is a pointer to a struct relief containing the GC
1794 with which lines will be drawn. Use a color that is FACTOR or
1795 DELTA lighter or darker than the relief's background which is found
1796 in S->f->output_data.x->relief_background. If such a color cannot
1797 be allocated, use DEFAULT_PIXEL, instead. */
1800 x_setup_relief_color (struct frame
*f
, struct relief
*relief
, double factor
,
1801 int delta
, unsigned long default_pixel
)
1804 struct x_output
*di
= f
->output_data
.x
;
1805 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
1806 unsigned long pixel
;
1807 unsigned long background
= di
->relief_background
;
1808 Colormap cmap
= FRAME_X_COLORMAP (f
);
1809 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
1810 Display
*dpy
= FRAME_X_DISPLAY (f
);
1812 xgcv
.graphics_exposures
= False
;
1813 xgcv
.line_width
= 1;
1815 /* Free previously allocated color. The color cell will be reused
1816 when it has been freed as many times as it was allocated, so this
1817 doesn't affect faces using the same colors. */
1818 if (relief
->gc
&& relief
->pixel
!= -1)
1820 x_free_colors (f
, &relief
->pixel
, 1);
1824 /* Allocate new color. */
1825 xgcv
.foreground
= default_pixel
;
1827 if (dpyinfo
->n_planes
!= 1
1828 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
1829 xgcv
.foreground
= relief
->pixel
= pixel
;
1831 if (relief
->gc
== 0)
1833 xgcv
.stipple
= dpyinfo
->gray
;
1835 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
1838 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
1842 /* Set up colors for the relief lines around glyph string S. */
1845 x_setup_relief_colors (struct glyph_string
*s
)
1847 struct x_output
*di
= s
->f
->output_data
.x
;
1848 unsigned long color
;
1850 if (s
->face
->use_box_color_for_shadows_p
)
1851 color
= s
->face
->box_color
;
1852 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1854 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1855 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1860 /* Get the background color of the face. */
1861 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
1862 color
= xgcv
.background
;
1865 if (di
->white_relief
.gc
== 0
1866 || color
!= di
->relief_background
)
1868 di
->relief_background
= color
;
1869 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
1870 WHITE_PIX_DEFAULT (s
->f
));
1871 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
1872 BLACK_PIX_DEFAULT (s
->f
));
1877 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1878 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1879 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1880 relief. LEFT_P non-zero means draw a relief on the left side of
1881 the rectangle. RIGHT_P non-zero means draw a relief on the right
1882 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1886 x_draw_relief_rect (struct frame
*f
,
1887 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
1888 int raised_p
, int top_p
, int bot_p
, int left_p
, int right_p
,
1889 XRectangle
*clip_rect
)
1891 Display
*dpy
= FRAME_X_DISPLAY (f
);
1892 Window window
= FRAME_X_WINDOW (f
);
1897 gc
= f
->output_data
.x
->white_relief
.gc
;
1899 gc
= f
->output_data
.x
->black_relief
.gc
;
1900 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
1902 /* This code is more complicated than it has to be, because of two
1903 minor hacks to make the boxes look nicer: (i) if width > 1, draw
1904 the outermost line using the black relief. (ii) Omit the four
1911 XDrawLine (dpy
, window
, gc
,
1912 left_x
+ (left_p
? 1 : 0), top_y
,
1913 right_x
+ (right_p
? 0 : 1), top_y
);
1915 for (i
= 1; i
< width
; ++i
)
1916 XDrawLine (dpy
, window
, gc
,
1917 left_x
+ i
* left_p
, top_y
+ i
,
1918 right_x
+ 1 - i
* right_p
, top_y
+ i
);
1925 XDrawLine (dpy
, window
, gc
, left_x
, top_y
+ 1, left_x
, bottom_y
);
1927 XClearArea (dpy
, window
, left_x
, top_y
, 1, 1, False
);
1928 XClearArea (dpy
, window
, left_x
, bottom_y
, 1, 1, False
);
1930 for (i
= (width
> 1 ? 1 : 0); i
< width
; ++i
)
1931 XDrawLine (dpy
, window
, gc
,
1932 left_x
+ i
, top_y
+ (i
+ 1) * top_p
,
1933 left_x
+ i
, bottom_y
+ 1 - (i
+ 1) * bot_p
);
1936 XSetClipMask (dpy
, gc
, None
);
1938 gc
= f
->output_data
.x
->black_relief
.gc
;
1940 gc
= f
->output_data
.x
->white_relief
.gc
;
1941 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
1945 /* Outermost top line. */
1947 XDrawLine (dpy
, window
, gc
,
1948 left_x
+ (left_p
? 1 : 0), top_y
,
1949 right_x
+ (right_p
? 0 : 1), top_y
);
1951 /* Outermost left line. */
1953 XDrawLine (dpy
, window
, gc
, left_x
, top_y
+ 1, left_x
, bottom_y
);
1959 XDrawLine (dpy
, window
, gc
,
1960 left_x
+ (left_p
? 1 : 0), bottom_y
,
1961 right_x
+ (right_p
? 0 : 1), bottom_y
);
1962 for (i
= 1; i
< width
; ++i
)
1963 XDrawLine (dpy
, window
, gc
,
1964 left_x
+ i
* left_p
, bottom_y
- i
,
1965 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
1971 XClearArea (dpy
, window
, right_x
, top_y
, 1, 1, False
);
1972 XClearArea (dpy
, window
, right_x
, bottom_y
, 1, 1, False
);
1973 for (i
= 0; i
< width
; ++i
)
1974 XDrawLine (dpy
, window
, gc
,
1975 right_x
- i
, top_y
+ (i
+ 1) * top_p
,
1976 right_x
- i
, bottom_y
+ 1 - (i
+ 1) * bot_p
);
1979 XSetClipMask (dpy
, gc
, None
);
1983 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
1984 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
1985 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
1986 left side of the rectangle. RIGHT_P non-zero means draw a line
1987 on the right side of the rectangle. CLIP_RECT is the clipping
1988 rectangle to use when drawing. */
1991 x_draw_box_rect (struct glyph_string
*s
,
1992 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
1993 int left_p
, int right_p
, XRectangle
*clip_rect
)
1997 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
1998 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
1999 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, clip_rect
, 1, Unsorted
);
2002 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2003 left_x
, top_y
, right_x
- left_x
+ 1, width
);
2007 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2008 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
2011 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2012 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
2016 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2017 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
2019 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2020 XSetClipMask (s
->display
, s
->gc
, None
);
2024 /* Draw a box around glyph string S. */
2027 x_draw_glyph_string_box (struct glyph_string
*s
)
2029 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
2030 int left_p
, right_p
;
2031 struct glyph
*last_glyph
;
2032 XRectangle clip_rect
;
2034 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
2035 ? WINDOW_RIGHT_EDGE_X (s
->w
)
2036 : window_box_right (s
->w
, s
->area
));
2038 /* The glyph that may have a right box line. */
2039 last_glyph
= (s
->cmp
|| s
->img
2041 : s
->first_glyph
+ s
->nchars
- 1);
2043 width
= eabs (s
->face
->box_line_width
);
2044 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
2046 right_x
= (s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
2048 : min (last_x
, s
->x
+ s
->background_width
) - 1);
2050 bottom_y
= top_y
+ s
->height
- 1;
2052 left_p
= (s
->first_glyph
->left_box_line_p
2053 || (s
->hl
== DRAW_MOUSE_FACE
2055 || s
->prev
->hl
!= s
->hl
)));
2056 right_p
= (last_glyph
->right_box_line_p
2057 || (s
->hl
== DRAW_MOUSE_FACE
2059 || s
->next
->hl
!= s
->hl
)));
2061 get_glyph_string_clip_rect (s
, &clip_rect
);
2063 if (s
->face
->box
== FACE_SIMPLE_BOX
)
2064 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2065 left_p
, right_p
, &clip_rect
);
2068 x_setup_relief_colors (s
);
2069 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
2070 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
2075 /* Draw foreground of image glyph string S. */
2078 x_draw_image_foreground (struct glyph_string
*s
)
2081 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2083 /* If first glyph of S has a left box line, start drawing it to the
2084 right of that line. */
2085 if (s
->face
->box
!= FACE_NO_BOX
2086 && s
->first_glyph
->left_box_line_p
2088 x
+= eabs (s
->face
->box_line_width
);
2090 /* If there is a margin around the image, adjust x- and y-position
2092 if (s
->slice
.x
== 0)
2093 x
+= s
->img
->hmargin
;
2094 if (s
->slice
.y
== 0)
2095 y
+= s
->img
->vmargin
;
2101 /* We can't set both a clip mask and use XSetClipRectangles
2102 because the latter also sets a clip mask. We also can't
2103 trust on the shape extension to be available
2104 (XShapeCombineRegion). So, compute the rectangle to draw
2106 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2109 XRectangle clip_rect
, image_rect
, r
;
2111 xgcv
.clip_mask
= s
->img
->mask
;
2112 xgcv
.clip_x_origin
= x
;
2113 xgcv
.clip_y_origin
= y
;
2114 xgcv
.function
= GXcopy
;
2115 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2117 get_glyph_string_clip_rect (s
, &clip_rect
);
2120 image_rect
.width
= s
->slice
.width
;
2121 image_rect
.height
= s
->slice
.height
;
2122 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2123 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2124 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2125 r
.width
, r
.height
, r
.x
, r
.y
);
2129 XRectangle clip_rect
, image_rect
, r
;
2131 get_glyph_string_clip_rect (s
, &clip_rect
);
2134 image_rect
.width
= s
->slice
.width
;
2135 image_rect
.height
= s
->slice
.height
;
2136 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2137 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2138 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2139 r
.width
, r
.height
, r
.x
, r
.y
);
2141 /* When the image has a mask, we can expect that at
2142 least part of a mouse highlight or a block cursor will
2143 be visible. If the image doesn't have a mask, make
2144 a block cursor visible by drawing a rectangle around
2145 the image. I believe it's looking better if we do
2146 nothing here for mouse-face. */
2147 if (s
->hl
== DRAW_CURSOR
)
2149 int relief
= eabs (s
->img
->relief
);
2150 XDrawRectangle (s
->display
, s
->window
, s
->gc
,
2151 x
- relief
, y
- relief
,
2152 s
->slice
.width
+ relief
*2 - 1,
2153 s
->slice
.height
+ relief
*2 - 1);
2158 /* Draw a rectangle if image could not be loaded. */
2159 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
2160 s
->slice
.width
- 1, s
->slice
.height
- 1);
2164 /* Draw a relief around the image glyph string S. */
2167 x_draw_image_relief (struct glyph_string
*s
)
2169 int x1
, y1
, thick
, raised_p
, top_p
, bot_p
, left_p
, right_p
;
2170 int extra_x
, extra_y
;
2173 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2175 /* If first glyph of S has a left box line, start drawing it to the
2176 right of that line. */
2177 if (s
->face
->box
!= FACE_NO_BOX
2178 && s
->first_glyph
->left_box_line_p
2180 x
+= eabs (s
->face
->box_line_width
);
2182 /* If there is a margin around the image, adjust x- and y-position
2184 if (s
->slice
.x
== 0)
2185 x
+= s
->img
->hmargin
;
2186 if (s
->slice
.y
== 0)
2187 y
+= s
->img
->vmargin
;
2189 if (s
->hl
== DRAW_IMAGE_SUNKEN
2190 || s
->hl
== DRAW_IMAGE_RAISED
)
2192 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
2193 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
2197 thick
= eabs (s
->img
->relief
);
2198 raised_p
= s
->img
->relief
> 0;
2201 x1
= x
+ s
->slice
.width
- 1;
2202 y1
= y
+ s
->slice
.height
- 1;
2204 extra_x
= extra_y
= 0;
2205 if (s
->face
->id
== TOOL_BAR_FACE_ID
)
2207 if (CONSP (Vtool_bar_button_margin
)
2208 && INTEGERP (XCAR (Vtool_bar_button_margin
))
2209 && INTEGERP (XCDR (Vtool_bar_button_margin
)))
2211 extra_x
= XINT (XCAR (Vtool_bar_button_margin
));
2212 extra_y
= XINT (XCDR (Vtool_bar_button_margin
));
2214 else if (INTEGERP (Vtool_bar_button_margin
))
2215 extra_x
= extra_y
= XINT (Vtool_bar_button_margin
);
2218 top_p
= bot_p
= left_p
= right_p
= 0;
2220 if (s
->slice
.x
== 0)
2221 x
-= thick
+ extra_x
, left_p
= 1;
2222 if (s
->slice
.y
== 0)
2223 y
-= thick
+ extra_y
, top_p
= 1;
2224 if (s
->slice
.x
+ s
->slice
.width
== s
->img
->width
)
2225 x1
+= thick
+ extra_x
, right_p
= 1;
2226 if (s
->slice
.y
+ s
->slice
.height
== s
->img
->height
)
2227 y1
+= thick
+ extra_y
, bot_p
= 1;
2229 x_setup_relief_colors (s
);
2230 get_glyph_string_clip_rect (s
, &r
);
2231 x_draw_relief_rect (s
->f
, x
, y
, x1
, y1
, thick
, raised_p
,
2232 top_p
, bot_p
, left_p
, right_p
, &r
);
2236 /* Draw the foreground of image glyph string S to PIXMAP. */
2239 x_draw_image_foreground_1 (struct glyph_string
*s
, Pixmap pixmap
)
2242 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2244 /* If first glyph of S has a left box line, start drawing it to the
2245 right of that line. */
2246 if (s
->face
->box
!= FACE_NO_BOX
2247 && s
->first_glyph
->left_box_line_p
2249 x
+= eabs (s
->face
->box_line_width
);
2251 /* If there is a margin around the image, adjust x- and y-position
2253 if (s
->slice
.x
== 0)
2254 x
+= s
->img
->hmargin
;
2255 if (s
->slice
.y
== 0)
2256 y
+= s
->img
->vmargin
;
2262 /* We can't set both a clip mask and use XSetClipRectangles
2263 because the latter also sets a clip mask. We also can't
2264 trust on the shape extension to be available
2265 (XShapeCombineRegion). So, compute the rectangle to draw
2267 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2271 xgcv
.clip_mask
= s
->img
->mask
;
2272 xgcv
.clip_x_origin
= x
- s
->slice
.x
;
2273 xgcv
.clip_y_origin
= y
- s
->slice
.y
;
2274 xgcv
.function
= GXcopy
;
2275 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2277 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2278 s
->slice
.x
, s
->slice
.y
,
2279 s
->slice
.width
, s
->slice
.height
, x
, y
);
2280 XSetClipMask (s
->display
, s
->gc
, None
);
2284 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2285 s
->slice
.x
, s
->slice
.y
,
2286 s
->slice
.width
, s
->slice
.height
, x
, y
);
2288 /* When the image has a mask, we can expect that at
2289 least part of a mouse highlight or a block cursor will
2290 be visible. If the image doesn't have a mask, make
2291 a block cursor visible by drawing a rectangle around
2292 the image. I believe it's looking better if we do
2293 nothing here for mouse-face. */
2294 if (s
->hl
== DRAW_CURSOR
)
2296 int r
= eabs (s
->img
->relief
);
2297 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
- r
, y
- r
,
2298 s
->slice
.width
+ r
*2 - 1,
2299 s
->slice
.height
+ r
*2 - 1);
2304 /* Draw a rectangle if image could not be loaded. */
2305 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
2306 s
->slice
.width
- 1, s
->slice
.height
- 1);
2310 /* Draw part of the background of glyph string S. X, Y, W, and H
2311 give the rectangle to draw. */
2314 x_draw_glyph_string_bg_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
2318 /* Fill background with a stipple pattern. */
2319 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2320 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2321 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2324 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2328 /* Draw image glyph string S.
2331 s->x +-------------------------
2334 | +-------------------------
2337 | | +-------------------
2343 x_draw_image_glyph_string (struct glyph_string
*s
)
2345 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
2346 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2348 Pixmap pixmap
= None
;
2351 if (s
->slice
.y
== 0)
2352 height
-= box_line_vwidth
;
2353 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
2354 height
-= box_line_vwidth
;
2356 /* Fill background with face under the image. Do it only if row is
2357 taller than image or if image has a clip mask to reduce
2359 s
->stippled_p
= s
->face
->stipple
!= 0;
2360 if (height
> s
->slice
.height
2364 || s
->img
->pixmap
== 0
2365 || s
->width
!= s
->background_width
)
2369 /* Create a pixmap as large as the glyph string. Fill it
2370 with the background color. Copy the image to it, using
2371 its mask. Copy the temporary pixmap to the display. */
2372 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2373 int depth
= DefaultDepthOfScreen (screen
);
2375 /* Create a pixmap as large as the glyph string. */
2376 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2377 s
->background_width
,
2380 /* Don't clip in the following because we're working on the
2382 XSetClipMask (s
->display
, s
->gc
, None
);
2384 /* Fill the pixmap with the background color/stipple. */
2387 /* Fill background with a stipple pattern. */
2388 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2389 XSetTSOrigin (s
->display
, s
->gc
, - s
->x
, - s
->y
);
2390 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2391 0, 0, s
->background_width
, s
->height
);
2392 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2393 XSetTSOrigin (s
->display
, s
->gc
, 0, 0);
2398 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2400 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2401 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2402 0, 0, s
->background_width
, s
->height
);
2403 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2410 int width
= s
->background_width
;
2412 if (s
->first_glyph
->left_box_line_p
2415 x
+= box_line_hwidth
;
2416 width
-= box_line_hwidth
;
2419 if (s
->slice
.y
== 0)
2420 y
+= box_line_vwidth
;
2422 x_draw_glyph_string_bg_rect (s
, x
, y
, width
, height
);
2425 s
->background_filled_p
= 1;
2428 /* Draw the foreground. */
2431 x_draw_image_foreground_1 (s
, pixmap
);
2432 x_set_glyph_string_clipping (s
);
2433 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
2434 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
2435 XFreePixmap (s
->display
, pixmap
);
2438 x_draw_image_foreground (s
);
2440 /* If we must draw a relief around the image, do it. */
2442 || s
->hl
== DRAW_IMAGE_RAISED
2443 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2444 x_draw_image_relief (s
);
2448 /* Draw stretch glyph string S. */
2451 x_draw_stretch_glyph_string (struct glyph_string
*s
)
2453 eassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2455 if (s
->hl
== DRAW_CURSOR
2456 && !x_stretch_cursor_p
)
2458 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
2459 wide as the stretch glyph. */
2460 int width
, background_width
= s
->background_width
;
2463 if (!s
->row
->reversed_p
)
2465 int left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2469 background_width
-= left_x
- x
;
2475 /* In R2L rows, draw the cursor on the right edge of the
2477 int right_x
= window_box_right_offset (s
->w
, TEXT_AREA
);
2479 if (x
+ background_width
> right_x
)
2480 background_width
-= x
- right_x
;
2481 x
+= background_width
;
2483 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
2484 if (s
->row
->reversed_p
)
2488 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
2490 /* Clear rest using the GC of the original non-cursor face. */
2491 if (width
< background_width
)
2494 int w
= background_width
- width
, h
= s
->height
;
2498 if (!s
->row
->reversed_p
)
2502 if (s
->row
->mouse_face_p
2503 && cursor_in_mouse_face_p (s
->w
))
2505 x_set_mouse_face_gc (s
);
2511 get_glyph_string_clip_rect (s
, &r
);
2512 XSetClipRectangles (s
->display
, gc
, 0, 0, &r
, 1, Unsorted
);
2514 if (s
->face
->stipple
)
2516 /* Fill background with a stipple pattern. */
2517 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2518 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2519 XSetFillStyle (s
->display
, gc
, FillSolid
);
2524 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
2525 XSetForeground (s
->display
, gc
, xgcv
.background
);
2526 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2527 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
2530 XSetClipMask (s
->display
, gc
, None
);
2533 else if (!s
->background_filled_p
)
2535 int background_width
= s
->background_width
;
2536 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2538 /* Don't draw into left margin, fringe or scrollbar area
2539 except for header line and mode line. */
2540 if (x
< left_x
&& !s
->row
->mode_line_p
)
2542 background_width
-= left_x
- x
;
2545 if (background_width
> 0)
2546 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2549 s
->background_filled_p
= 1;
2553 Draw a wavy line under S. The wave fills wave_height pixels from y0.
2559 wave_height = 3 | * * * *
2564 x_draw_underwave (struct glyph_string
*s
)
2566 int wave_height
= 3, wave_length
= 2;
2567 int dx
, dy
, x0
, y0
, width
, x1
, y1
, x2
, y2
, odd
, xmax
;
2568 XRectangle wave_clip
, string_clip
, final_clip
;
2571 dy
= wave_height
- 1;
2573 y0
= s
->ybase
- wave_height
+ 3;
2577 /* Find and set clipping rectangle */
2581 wave_clip
.width
= width
;
2582 wave_clip
.height
= wave_height
;
2583 get_glyph_string_clip_rect (s
, &string_clip
);
2585 if (!x_intersect_rectangles (&wave_clip
, &string_clip
, &final_clip
))
2588 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, &final_clip
, 1, Unsorted
);
2590 /* Draw the waves */
2592 x1
= x0
- (x0
% dx
);
2602 if (INT_MAX
- dx
< xmax
)
2607 XDrawLine (s
->display
, s
->window
, s
->gc
, x1
, y1
, x2
, y2
);
2609 x2
+= dx
, y2
= y0
+ odd
*dy
;
2613 /* Restore previous clipping rectangle(s) */
2614 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, s
->clip
, s
->num_clips
, Unsorted
);
2618 /* Draw glyph string S. */
2621 x_draw_glyph_string (struct glyph_string
*s
)
2623 bool relief_drawn_p
= 0;
2625 /* If S draws into the background of its successors, draw the
2626 background of the successors first so that S can draw into it.
2627 This makes S->next use XDrawString instead of XDrawImageString. */
2628 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2631 struct glyph_string
*next
;
2633 for (width
= 0, next
= s
->next
;
2634 next
&& width
< s
->right_overhang
;
2635 width
+= next
->width
, next
= next
->next
)
2636 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
2638 x_set_glyph_string_gc (next
);
2639 x_set_glyph_string_clipping (next
);
2640 if (next
->first_glyph
->type
== STRETCH_GLYPH
)
2641 x_draw_stretch_glyph_string (next
);
2643 x_draw_glyph_string_background (next
, 1);
2644 next
->num_clips
= 0;
2648 /* Set up S->gc, set clipping and draw S. */
2649 x_set_glyph_string_gc (s
);
2651 /* Draw relief (if any) in advance for char/composition so that the
2652 glyph string can be drawn over it. */
2653 if (!s
->for_overlaps
2654 && s
->face
->box
!= FACE_NO_BOX
2655 && (s
->first_glyph
->type
== CHAR_GLYPH
2656 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2659 x_set_glyph_string_clipping (s
);
2660 x_draw_glyph_string_background (s
, 1);
2661 x_draw_glyph_string_box (s
);
2662 x_set_glyph_string_clipping (s
);
2665 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
2667 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2668 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
2669 /* We must clip just this glyph. left_overhang part has already
2670 drawn when s->prev was drawn, and right_overhang part will be
2671 drawn later when s->next is drawn. */
2672 x_set_glyph_string_clipping_exactly (s
, s
);
2674 x_set_glyph_string_clipping (s
);
2676 switch (s
->first_glyph
->type
)
2679 x_draw_image_glyph_string (s
);
2683 x_draw_stretch_glyph_string (s
);
2687 if (s
->for_overlaps
)
2688 s
->background_filled_p
= 1;
2690 x_draw_glyph_string_background (s
, 0);
2691 x_draw_glyph_string_foreground (s
);
2694 case COMPOSITE_GLYPH
:
2695 if (s
->for_overlaps
|| (s
->cmp_from
> 0
2696 && ! s
->first_glyph
->u
.cmp
.automatic
))
2697 s
->background_filled_p
= 1;
2699 x_draw_glyph_string_background (s
, 1);
2700 x_draw_composite_glyph_string_foreground (s
);
2703 case GLYPHLESS_GLYPH
:
2704 if (s
->for_overlaps
)
2705 s
->background_filled_p
= 1;
2707 x_draw_glyph_string_background (s
, 1);
2708 x_draw_glyphless_glyph_string_foreground (s
);
2715 if (!s
->for_overlaps
)
2717 /* Draw underline. */
2718 if (s
->face
->underline_p
)
2720 if (s
->face
->underline_type
== FACE_UNDER_WAVE
)
2722 if (s
->face
->underline_defaulted_p
)
2723 x_draw_underwave (s
);
2727 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2728 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
2729 x_draw_underwave (s
);
2730 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2733 else if (s
->face
->underline_type
== FACE_UNDER_LINE
)
2735 unsigned long thickness
, position
;
2738 if (s
->prev
&& s
->prev
->face
->underline_p
2739 && s
->prev
->face
->underline_type
== FACE_UNDER_LINE
)
2741 /* We use the same underline style as the previous one. */
2742 thickness
= s
->prev
->underline_thickness
;
2743 position
= s
->prev
->underline_position
;
2747 /* Get the underline thickness. Default is 1 pixel. */
2748 if (s
->font
&& s
->font
->underline_thickness
> 0)
2749 thickness
= s
->font
->underline_thickness
;
2752 if (x_underline_at_descent_line
)
2753 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
2756 /* Get the underline position. This is the recommended
2757 vertical offset in pixels from the baseline to the top of
2758 the underline. This is a signed value according to the
2759 specs, and its default is
2761 ROUND ((maximum descent) / 2), with
2762 ROUND(x) = floor (x + 0.5) */
2764 if (x_use_underline_position_properties
2765 && s
->font
&& s
->font
->underline_position
>= 0)
2766 position
= s
->font
->underline_position
;
2768 position
= (s
->font
->descent
+ 1) / 2;
2770 position
= underline_minimum_offset
;
2772 position
= max (position
, underline_minimum_offset
);
2774 /* Check the sanity of thickness and position. We should
2775 avoid drawing underline out of the current line area. */
2776 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
2777 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
2778 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
2779 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
2780 s
->underline_thickness
= thickness
;
2781 s
->underline_position
= position
;
2782 y
= s
->ybase
+ position
;
2783 if (s
->face
->underline_defaulted_p
)
2784 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2785 s
->x
, y
, s
->width
, thickness
);
2789 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2790 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
2791 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2792 s
->x
, y
, s
->width
, thickness
);
2793 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2797 /* Draw overline. */
2798 if (s
->face
->overline_p
)
2800 unsigned long dy
= 0, h
= 1;
2802 if (s
->face
->overline_color_defaulted_p
)
2803 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2808 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2809 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
2810 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2812 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2816 /* Draw strike-through. */
2817 if (s
->face
->strike_through_p
)
2819 unsigned long h
= 1;
2820 unsigned long dy
= (s
->height
- h
) / 2;
2822 if (s
->face
->strike_through_color_defaulted_p
)
2823 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2828 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2829 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
2830 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2832 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2836 /* Draw relief if not yet drawn. */
2837 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2838 x_draw_glyph_string_box (s
);
2842 struct glyph_string
*prev
;
2844 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2845 if (prev
->hl
!= s
->hl
2846 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2848 /* As prev was drawn while clipped to its own area, we
2849 must draw the right_overhang part using s->hl now. */
2850 enum draw_glyphs_face save
= prev
->hl
;
2853 x_set_glyph_string_gc (prev
);
2854 x_set_glyph_string_clipping_exactly (s
, prev
);
2855 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2856 x_draw_glyph_string_foreground (prev
);
2858 x_draw_composite_glyph_string_foreground (prev
);
2859 XSetClipMask (prev
->display
, prev
->gc
, None
);
2861 prev
->num_clips
= 0;
2867 struct glyph_string
*next
;
2869 for (next
= s
->next
; next
; next
= next
->next
)
2870 if (next
->hl
!= s
->hl
2871 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
2873 /* As next will be drawn while clipped to its own area,
2874 we must draw the left_overhang part using s->hl now. */
2875 enum draw_glyphs_face save
= next
->hl
;
2878 x_set_glyph_string_gc (next
);
2879 x_set_glyph_string_clipping_exactly (s
, next
);
2880 if (next
->first_glyph
->type
== CHAR_GLYPH
)
2881 x_draw_glyph_string_foreground (next
);
2883 x_draw_composite_glyph_string_foreground (next
);
2884 XSetClipMask (next
->display
, next
->gc
, None
);
2886 next
->num_clips
= 0;
2887 next
->clip_head
= s
->next
;
2892 /* Reset clipping. */
2893 XSetClipMask (s
->display
, s
->gc
, None
);
2897 /* Shift display to make room for inserted glyphs. */
2900 x_shift_glyphs_for_insert (struct frame
*f
, int x
, int y
, int width
, int height
, int shift_by
)
2902 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
2903 f
->output_data
.x
->normal_gc
,
2904 x
, y
, width
, height
,
2908 /* Delete N glyphs at the nominal cursor position. Not implemented
2912 x_delete_glyphs (struct frame
*f
, register int n
)
2918 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
2919 If they are <= 0, this is probably an error. */
2922 x_clear_area (Display
*dpy
, Window window
, int x
, int y
, int width
, int height
)
2924 eassert (width
> 0 && height
> 0);
2925 XClearArea (dpy
, window
, x
, y
, width
, height
, False
);
2929 /* Clear an entire frame. */
2932 x_clear_frame (struct frame
*f
)
2934 /* Clearing the frame will erase any cursor, so mark them all as no
2936 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2940 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
2942 /* We have to clear the scroll bars. If we have changed colors or
2943 something like that, then they should be notified. */
2944 x_scroll_bar_clear (f
);
2946 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
2947 /* Make sure scroll bars are redrawn. As they aren't redrawn by
2948 redisplay, do it here. */
2949 if (FRAME_GTK_WIDGET (f
))
2950 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
2953 XFlush (FRAME_X_DISPLAY (f
));
2958 /* RIF: Show hourglass cursor on frame F. */
2961 x_show_hourglass (struct frame
*f
)
2963 Display
*dpy
= FRAME_X_DISPLAY (f
);
2967 struct x_output
*x
= FRAME_X_OUTPUT (f
);
2968 #ifdef USE_X_TOOLKIT
2971 if (FRAME_OUTER_WINDOW (f
))
2976 if (!x
->hourglass_window
)
2978 unsigned long mask
= CWCursor
;
2979 XSetWindowAttributes attrs
;
2981 Window parent
= FRAME_X_WINDOW (f
);
2983 Window parent
= FRAME_OUTER_WINDOW (f
);
2985 attrs
.cursor
= x
->hourglass_cursor
;
2987 x
->hourglass_window
= XCreateWindow
2988 (dpy
, parent
, 0, 0, 32000, 32000, 0, 0,
2989 InputOnly
, CopyFromParent
, mask
, &attrs
);
2992 XMapRaised (dpy
, x
->hourglass_window
);
2998 /* RIF: Cancel hourglass cursor on frame F. */
3001 x_hide_hourglass (struct frame
*f
)
3003 struct x_output
*x
= FRAME_X_OUTPUT (f
);
3005 /* Watch out for newly created frames. */
3006 if (x
->hourglass_window
)
3008 XUnmapWindow (FRAME_X_DISPLAY (f
), x
->hourglass_window
);
3009 /* Sync here because XTread_socket looks at the
3010 hourglass_p flag that is reset to zero below. */
3011 XSync (FRAME_X_DISPLAY (f
), False
);
3016 /* Invert the middle quarter of the frame for .15 sec. */
3019 XTflash (struct frame
*f
)
3025 /* Use Gdk routines to draw. This way, we won't draw over scroll bars
3026 when the scroll bars and the edit widget share the same X window. */
3027 GdkWindow
*window
= gtk_widget_get_window (FRAME_GTK_WIDGET (f
));
3029 cairo_t
*cr
= gdk_cairo_create (window
);
3030 cairo_set_source_rgb (cr
, 1, 1, 1);
3031 cairo_set_operator (cr
, CAIRO_OPERATOR_DIFFERENCE
);
3032 #define XFillRectangle(d, win, gc, x, y, w, h) \
3034 cairo_rectangle (cr, x, y, w, h); \
3038 #else /* ! HAVE_GTK3 */
3041 vals
.foreground
.pixel
= (FRAME_FOREGROUND_PIXEL (f
)
3042 ^ FRAME_BACKGROUND_PIXEL (f
));
3043 vals
.function
= GDK_XOR
;
3044 gc
= gdk_gc_new_with_values (window
,
3045 &vals
, GDK_GC_FUNCTION
| GDK_GC_FOREGROUND
);
3046 #define XFillRectangle(d, win, gc, x, y, w, h) \
3047 gdk_draw_rectangle (window, gc, TRUE, x, y, w, h)
3048 #endif /* ! HAVE_GTK3 */
3049 #else /* ! USE_GTK */
3052 /* Create a GC that will use the GXxor function to flip foreground
3053 pixels into background pixels. */
3057 values
.function
= GXxor
;
3058 values
.foreground
= (FRAME_FOREGROUND_PIXEL (f
)
3059 ^ FRAME_BACKGROUND_PIXEL (f
));
3061 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3062 GCFunction
| GCForeground
, &values
);
3066 /* Get the height not including a menu bar widget. */
3067 int height
= FRAME_PIXEL_HEIGHT (f
);
3068 /* Height of each line to flash. */
3069 int flash_height
= FRAME_LINE_HEIGHT (f
);
3070 /* These will be the left and right margins of the rectangles. */
3071 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
3072 int flash_right
= FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
3073 int width
= flash_right
- flash_left
;
3075 /* If window is tall, flash top and bottom line. */
3076 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3078 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3080 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3081 + FRAME_TOP_MARGIN_HEIGHT (f
)),
3082 width
, flash_height
);
3083 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3085 (height
- flash_height
3086 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3087 width
, flash_height
);
3091 /* If it is short, flash it all. */
3092 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3093 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3094 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3099 struct timespec delay
= make_timespec (0, 150 * 1000 * 1000);
3100 struct timespec wakeup
= timespec_add (current_timespec (), delay
);
3102 /* Keep waiting until past the time wakeup or any input gets
3104 while (! detect_input_pending ())
3106 struct timespec current
= current_timespec ();
3107 struct timespec timeout
;
3109 /* Break if result would not be positive. */
3110 if (timespec_cmp (wakeup
, current
) <= 0)
3113 /* How long `select' should wait. */
3114 timeout
= make_timespec (0, 10 * 1000 * 1000);
3116 /* Try to wait that long--but we might wake up sooner. */
3117 pselect (0, NULL
, NULL
, NULL
, &timeout
, NULL
);
3121 /* If window is tall, flash top and bottom line. */
3122 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3124 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3126 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3127 + FRAME_TOP_MARGIN_HEIGHT (f
)),
3128 width
, flash_height
);
3129 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3131 (height
- flash_height
3132 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3133 width
, flash_height
);
3136 /* If it is short, flash it all. */
3137 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3138 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3139 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3145 g_object_unref (G_OBJECT (gc
));
3147 #undef XFillRectangle
3149 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
3160 XTtoggle_invisible_pointer (struct frame
*f
, int invisible
)
3163 FRAME_DISPLAY_INFO (f
)->toggle_visible_pointer (f
, invisible
);
3168 /* Make audible bell. */
3171 XTring_bell (struct frame
*f
)
3173 if (FRAME_X_DISPLAY (f
))
3181 XkbBell (FRAME_X_DISPLAY (f
), None
, 0, None
);
3183 XBell (FRAME_X_DISPLAY (f
), 0);
3185 XFlush (FRAME_X_DISPLAY (f
));
3191 /***********************************************************************
3193 ***********************************************************************/
3195 /* Perform an insert-lines or delete-lines operation, inserting N
3196 lines or deleting -N lines at vertical position VPOS. */
3199 x_ins_del_lines (struct frame
*f
, int vpos
, int n
)
3205 /* Scroll part of the display as described by RUN. */
3208 x_scroll_run (struct window
*w
, struct run
*run
)
3210 struct frame
*f
= XFRAME (w
->frame
);
3211 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
3213 /* Get frame-relative bounding box of the text display area of W,
3214 without mode lines. Include in this box the left and right
3216 window_box (w
, ANY_AREA
, &x
, &y
, &width
, &height
);
3218 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
3219 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
3220 bottom_y
= y
+ height
;
3224 /* Scrolling up. Make sure we don't copy part of the mode
3225 line at the bottom. */
3226 if (from_y
+ run
->height
> bottom_y
)
3227 height
= bottom_y
- from_y
;
3229 height
= run
->height
;
3233 /* Scrolling down. Make sure we don't copy over the mode line.
3235 if (to_y
+ run
->height
> bottom_y
)
3236 height
= bottom_y
- to_y
;
3238 height
= run
->height
;
3243 /* Cursor off. Will be switched on again in x_update_window_end. */
3246 XCopyArea (FRAME_X_DISPLAY (f
),
3247 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
3248 f
->output_data
.x
->normal_gc
,
3258 /***********************************************************************
3260 ***********************************************************************/
3264 frame_highlight (struct frame
*f
)
3266 /* We used to only do this if Vx_no_window_manager was non-nil, but
3267 the ICCCM (section 4.1.6) says that the window's border pixmap
3268 and border pixel are window attributes which are "private to the
3269 client", so we can always change it to whatever we want. */
3271 /* I recently started to get errors in this XSetWindowBorder, depending on
3272 the window-manager in use, tho something more is at play since I've been
3273 using that same window-manager binary for ever. Let's not crash just
3274 because of this (bug#9310). */
3275 x_catch_errors (FRAME_X_DISPLAY (f
));
3276 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3277 f
->output_data
.x
->border_pixel
);
3278 x_uncatch_errors ();
3280 x_update_cursor (f
, 1);
3281 x_set_frame_alpha (f
);
3285 frame_unhighlight (struct frame
*f
)
3287 /* We used to only do this if Vx_no_window_manager was non-nil, but
3288 the ICCCM (section 4.1.6) says that the window's border pixmap
3289 and border pixel are window attributes which are "private to the
3290 client", so we can always change it to whatever we want. */
3292 /* Same as above for XSetWindowBorder (bug#9310). */
3293 x_catch_errors (FRAME_X_DISPLAY (f
));
3294 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3295 f
->output_data
.x
->border_tile
);
3296 x_uncatch_errors ();
3298 x_update_cursor (f
, 1);
3299 x_set_frame_alpha (f
);
3302 /* The focus has changed. Update the frames as necessary to reflect
3303 the new situation. Note that we can't change the selected frame
3304 here, because the Lisp code we are interrupting might become confused.
3305 Each event gets marked with the frame in which it occurred, so the
3306 Lisp code can tell when the switch took place by examining the events. */
3309 x_new_focus_frame (struct x_display_info
*dpyinfo
, struct frame
*frame
)
3311 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
3313 if (frame
!= dpyinfo
->x_focus_frame
)
3315 /* Set this before calling other routines, so that they see
3316 the correct value of x_focus_frame. */
3317 dpyinfo
->x_focus_frame
= frame
;
3319 if (old_focus
&& old_focus
->auto_lower
)
3320 x_lower_frame (old_focus
);
3322 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
3323 dpyinfo
->x_pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
3325 dpyinfo
->x_pending_autoraise_frame
= NULL
;
3328 x_frame_rehighlight (dpyinfo
);
3331 /* Handle FocusIn and FocusOut state changes for FRAME.
3332 If FRAME has focus and there exists more than one frame, puts
3333 a FOCUS_IN_EVENT into *BUFP. */
3336 x_focus_changed (int type
, int state
, struct x_display_info
*dpyinfo
, struct frame
*frame
, struct input_event
*bufp
)
3338 if (type
== FocusIn
)
3340 if (dpyinfo
->x_focus_event_frame
!= frame
)
3342 x_new_focus_frame (dpyinfo
, frame
);
3343 dpyinfo
->x_focus_event_frame
= frame
;
3345 /* Don't stop displaying the initial startup message
3346 for a switch-frame event we don't need. */
3347 /* When run as a daemon, Vterminal_frame is always NIL. */
3348 bufp
->arg
= (((NILP (Vterminal_frame
)
3349 || ! FRAME_X_P (XFRAME (Vterminal_frame
))
3350 || EQ (Fdaemonp (), Qt
))
3351 && CONSP (Vframe_list
)
3352 && !NILP (XCDR (Vframe_list
)))
3354 bufp
->kind
= FOCUS_IN_EVENT
;
3355 XSETFRAME (bufp
->frame_or_window
, frame
);
3358 frame
->output_data
.x
->focus_state
|= state
;
3361 if (FRAME_XIC (frame
))
3362 XSetICFocus (FRAME_XIC (frame
));
3365 else if (type
== FocusOut
)
3367 frame
->output_data
.x
->focus_state
&= ~state
;
3369 if (dpyinfo
->x_focus_event_frame
== frame
)
3371 dpyinfo
->x_focus_event_frame
= 0;
3372 x_new_focus_frame (dpyinfo
, 0);
3374 bufp
->kind
= FOCUS_OUT_EVENT
;
3375 XSETFRAME (bufp
->frame_or_window
, frame
);
3379 if (FRAME_XIC (frame
))
3380 XUnsetICFocus (FRAME_XIC (frame
));
3382 if (frame
->pointer_invisible
)
3383 XTtoggle_invisible_pointer (frame
, 0);
3387 /* Return the Emacs frame-object corresponding to an X window.
3388 It could be the frame's main window or an icon window. */
3390 static struct frame
*
3391 x_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
3393 Lisp_Object tail
, frame
;
3399 FOR_EACH_FRAME (tail
, frame
)
3402 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
3404 if (f
->output_data
.x
->hourglass_window
== wdesc
)
3406 #ifdef USE_X_TOOLKIT
3407 if ((f
->output_data
.x
->edit_widget
3408 && XtWindow (f
->output_data
.x
->edit_widget
) == wdesc
)
3409 /* A tooltip frame? */
3410 || (!f
->output_data
.x
->edit_widget
3411 && FRAME_X_WINDOW (f
) == wdesc
)
3412 || f
->output_data
.x
->icon_desc
== wdesc
)
3414 #else /* not USE_X_TOOLKIT */
3416 if (f
->output_data
.x
->edit_widget
)
3418 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
3419 struct x_output
*x
= f
->output_data
.x
;
3420 if (gwdesc
!= 0 && gwdesc
== x
->edit_widget
)
3423 #endif /* USE_GTK */
3424 if (FRAME_X_WINDOW (f
) == wdesc
3425 || f
->output_data
.x
->icon_desc
== wdesc
)
3427 #endif /* not USE_X_TOOLKIT */
3432 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
3434 /* Like x_window_to_frame but also compares the window with the widget's
3437 static struct frame
*
3438 x_any_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
3440 Lisp_Object tail
, frame
;
3441 struct frame
*f
, *found
= NULL
;
3447 FOR_EACH_FRAME (tail
, frame
)
3452 if (FRAME_X_P (f
) && FRAME_DISPLAY_INFO (f
) == dpyinfo
)
3454 /* This frame matches if the window is any of its widgets. */
3455 x
= f
->output_data
.x
;
3456 if (x
->hourglass_window
== wdesc
)
3461 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
3463 && gtk_widget_get_toplevel (gwdesc
) == x
->widget
)
3466 if (wdesc
== XtWindow (x
->widget
)
3467 || wdesc
== XtWindow (x
->column_widget
)
3468 || wdesc
== XtWindow (x
->edit_widget
))
3470 /* Match if the window is this frame's menubar. */
3471 else if (lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
3475 else if (FRAME_X_WINDOW (f
) == wdesc
)
3476 /* A tooltip frame. */
3484 /* Likewise, but consider only the menu bar widget. */
3486 static struct frame
*
3487 x_menubar_window_to_frame (struct x_display_info
*dpyinfo
,
3488 const XEvent
*event
)
3490 Window wdesc
= event
->xany
.window
;
3491 Lisp_Object tail
, frame
;
3498 FOR_EACH_FRAME (tail
, frame
)
3501 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
3503 x
= f
->output_data
.x
;
3505 if (x
->menubar_widget
&& xg_event_is_for_menubar (f
, event
))
3508 /* Match if the window is this frame's menubar. */
3509 if (x
->menubar_widget
3510 && lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
3517 /* Return the frame whose principal (outermost) window is WDESC.
3518 If WDESC is some other (smaller) window, we return 0. */
3521 x_top_window_to_frame (struct x_display_info
*dpyinfo
, int wdesc
)
3523 Lisp_Object tail
, frame
;
3530 FOR_EACH_FRAME (tail
, frame
)
3533 if (!FRAME_X_P (f
) || FRAME_DISPLAY_INFO (f
) != dpyinfo
)
3535 x
= f
->output_data
.x
;
3539 /* This frame matches if the window is its topmost widget. */
3541 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
3542 if (gwdesc
== x
->widget
)
3545 if (wdesc
== XtWindow (x
->widget
))
3549 else if (FRAME_X_WINDOW (f
) == wdesc
)
3550 /* Tooltip frame. */
3556 #else /* !USE_X_TOOLKIT && !USE_GTK */
3558 #define x_any_window_to_frame(d, i) x_window_to_frame (d, i)
3559 #define x_top_window_to_frame(d, i) x_window_to_frame (d, i)
3561 #endif /* USE_X_TOOLKIT || USE_GTK */
3563 /* The focus may have changed. Figure out if it is a real focus change,
3564 by checking both FocusIn/Out and Enter/LeaveNotify events.
3566 Returns FOCUS_IN_EVENT event in *BUFP. */
3569 x_detect_focus_change (struct x_display_info
*dpyinfo
, struct frame
*frame
,
3570 const XEvent
*event
, struct input_event
*bufp
)
3575 switch (event
->type
)
3580 struct frame
*focus_frame
= dpyinfo
->x_focus_event_frame
;
3582 = focus_frame
? focus_frame
->output_data
.x
->focus_state
: 0;
3584 if (event
->xcrossing
.detail
!= NotifyInferior
3585 && event
->xcrossing
.focus
3586 && ! (focus_state
& FOCUS_EXPLICIT
))
3587 x_focus_changed ((event
->type
== EnterNotify
? FocusIn
: FocusOut
),
3589 dpyinfo
, frame
, bufp
);
3595 x_focus_changed (event
->type
,
3596 (event
->xfocus
.detail
== NotifyPointer
?
3597 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
3598 dpyinfo
, frame
, bufp
);
3602 if (event
->xclient
.message_type
== dpyinfo
->Xatom_XEMBED
)
3604 enum xembed_message msg
= event
->xclient
.data
.l
[1];
3605 x_focus_changed ((msg
== XEMBED_FOCUS_IN
? FocusIn
: FocusOut
),
3606 FOCUS_EXPLICIT
, dpyinfo
, frame
, bufp
);
3613 #if !defined USE_X_TOOLKIT && !defined USE_GTK
3614 /* Handle an event saying the mouse has moved out of an Emacs frame. */
3617 x_mouse_leave (struct x_display_info
*dpyinfo
)
3619 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
3623 /* The focus has changed, or we have redirected a frame's focus to
3624 another frame (this happens when a frame uses a surrogate
3625 mini-buffer frame). Shift the highlight as appropriate.
3627 The FRAME argument doesn't necessarily have anything to do with which
3628 frame is being highlighted or un-highlighted; we only use it to find
3629 the appropriate X display info. */
3632 XTframe_rehighlight (struct frame
*frame
)
3634 x_frame_rehighlight (FRAME_DISPLAY_INFO (frame
));
3638 x_frame_rehighlight (struct x_display_info
*dpyinfo
)
3640 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
3642 if (dpyinfo
->x_focus_frame
)
3644 dpyinfo
->x_highlight_frame
3645 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
3646 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
3647 : dpyinfo
->x_focus_frame
);
3648 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
3650 fset_focus_frame (dpyinfo
->x_focus_frame
, Qnil
);
3651 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
3655 dpyinfo
->x_highlight_frame
= 0;
3657 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
3660 frame_unhighlight (old_highlight
);
3661 if (dpyinfo
->x_highlight_frame
)
3662 frame_highlight (dpyinfo
->x_highlight_frame
);
3668 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
3670 /* Initialize mode_switch_bit and modifier_meaning. */
3672 x_find_modifier_meanings (struct x_display_info
*dpyinfo
)
3674 int min_code
, max_code
;
3677 XModifierKeymap
*mods
;
3679 dpyinfo
->meta_mod_mask
= 0;
3680 dpyinfo
->shift_lock_mask
= 0;
3681 dpyinfo
->alt_mod_mask
= 0;
3682 dpyinfo
->super_mod_mask
= 0;
3683 dpyinfo
->hyper_mod_mask
= 0;
3685 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
3687 syms
= XGetKeyboardMapping (dpyinfo
->display
,
3688 min_code
, max_code
- min_code
+ 1,
3690 mods
= XGetModifierMapping (dpyinfo
->display
);
3692 /* Scan the modifier table to see which modifier bits the Meta and
3693 Alt keysyms are on. */
3695 int row
, col
; /* The row and column in the modifier table. */
3696 int found_alt_or_meta
;
3698 for (row
= 3; row
< 8; row
++)
3700 found_alt_or_meta
= 0;
3701 for (col
= 0; col
< mods
->max_keypermod
; col
++)
3703 KeyCode code
= mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
3705 /* Zeroes are used for filler. Skip them. */
3709 /* Are any of this keycode's keysyms a meta key? */
3713 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
3715 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
3721 found_alt_or_meta
= 1;
3722 dpyinfo
->meta_mod_mask
|= (1 << row
);
3727 found_alt_or_meta
= 1;
3728 dpyinfo
->alt_mod_mask
|= (1 << row
);
3733 if (!found_alt_or_meta
)
3734 dpyinfo
->hyper_mod_mask
|= (1 << row
);
3735 code_col
= syms_per_code
;
3736 col
= mods
->max_keypermod
;
3741 if (!found_alt_or_meta
)
3742 dpyinfo
->super_mod_mask
|= (1 << row
);
3743 code_col
= syms_per_code
;
3744 col
= mods
->max_keypermod
;
3748 /* Ignore this if it's not on the lock modifier. */
3749 if (!found_alt_or_meta
&& ((1 << row
) == LockMask
))
3750 dpyinfo
->shift_lock_mask
= LockMask
;
3751 code_col
= syms_per_code
;
3752 col
= mods
->max_keypermod
;
3761 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
3762 if (! dpyinfo
->meta_mod_mask
)
3764 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
3765 dpyinfo
->alt_mod_mask
= 0;
3768 /* If some keys are both alt and meta,
3769 make them just meta, not alt. */
3770 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
3772 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
3776 XFreeModifiermap (mods
);
3779 /* Convert between the modifier bits X uses and the modifier bits
3783 x_x_to_emacs_modifiers (struct x_display_info
*dpyinfo
, int state
)
3785 int mod_meta
= meta_modifier
;
3786 int mod_alt
= alt_modifier
;
3787 int mod_hyper
= hyper_modifier
;
3788 int mod_super
= super_modifier
;
3791 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3792 if (INTEGERP (tem
)) mod_alt
= XINT (tem
) & INT_MAX
;
3793 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3794 if (INTEGERP (tem
)) mod_meta
= XINT (tem
) & INT_MAX
;
3795 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3796 if (INTEGERP (tem
)) mod_hyper
= XINT (tem
) & INT_MAX
;
3797 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3798 if (INTEGERP (tem
)) mod_super
= XINT (tem
) & INT_MAX
;
3800 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
3801 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
3802 | ((state
& dpyinfo
->meta_mod_mask
) ? mod_meta
: 0)
3803 | ((state
& dpyinfo
->alt_mod_mask
) ? mod_alt
: 0)
3804 | ((state
& dpyinfo
->super_mod_mask
) ? mod_super
: 0)
3805 | ((state
& dpyinfo
->hyper_mod_mask
) ? mod_hyper
: 0));
3809 x_emacs_to_x_modifiers (struct x_display_info
*dpyinfo
, EMACS_INT state
)
3811 EMACS_INT mod_meta
= meta_modifier
;
3812 EMACS_INT mod_alt
= alt_modifier
;
3813 EMACS_INT mod_hyper
= hyper_modifier
;
3814 EMACS_INT mod_super
= super_modifier
;
3818 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3819 if (INTEGERP (tem
)) mod_alt
= XINT (tem
);
3820 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3821 if (INTEGERP (tem
)) mod_meta
= XINT (tem
);
3822 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3823 if (INTEGERP (tem
)) mod_hyper
= XINT (tem
);
3824 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3825 if (INTEGERP (tem
)) mod_super
= XINT (tem
);
3828 return ( ((state
& mod_alt
) ? dpyinfo
->alt_mod_mask
: 0)
3829 | ((state
& mod_super
) ? dpyinfo
->super_mod_mask
: 0)
3830 | ((state
& mod_hyper
) ? dpyinfo
->hyper_mod_mask
: 0)
3831 | ((state
& shift_modifier
) ? ShiftMask
: 0)
3832 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
3833 | ((state
& mod_meta
) ? dpyinfo
->meta_mod_mask
: 0));
3836 /* Convert a keysym to its name. */
3839 x_get_keysym_name (int keysym
)
3844 value
= XKeysymToString (keysym
);
3850 /* Mouse clicks and mouse movement. Rah.
3852 Formerly, we used PointerMotionHintMask (in standard_event_mask)
3853 so that we would have to call XQueryPointer after each MotionNotify
3854 event to ask for another such event. However, this made mouse tracking
3855 slow, and there was a bug that made it eventually stop.
3857 Simply asking for MotionNotify all the time seems to work better.
3859 In order to avoid asking for motion events and then throwing most
3860 of them away or busy-polling the server for mouse positions, we ask
3861 the server for pointer motion hints. This means that we get only
3862 one event per group of mouse movements. "Groups" are delimited by
3863 other kinds of events (focus changes and button clicks, for
3864 example), or by XQueryPointer calls; when one of these happens, we
3865 get another MotionNotify event the next time the mouse moves. This
3866 is at least as efficient as getting motion events when mouse
3867 tracking is on, and I suspect only negligibly worse when tracking
3870 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3872 If the event is a button press, then note that we have grabbed
3876 construct_mouse_click (struct input_event
*result
,
3877 const XButtonEvent
*event
,
3880 /* Make the event type NO_EVENT; we'll change that when we decide
3882 result
->kind
= MOUSE_CLICK_EVENT
;
3883 result
->code
= event
->button
- Button1
;
3884 result
->timestamp
= event
->time
;
3885 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
),
3887 | (event
->type
== ButtonRelease
3891 XSETINT (result
->x
, event
->x
);
3892 XSETINT (result
->y
, event
->y
);
3893 XSETFRAME (result
->frame_or_window
, f
);
3898 /* Function to report a mouse movement to the mainstream Emacs code.
3899 The input handler calls this.
3901 We have received a mouse movement event, which is given in *event.
3902 If the mouse is over a different glyph than it was last time, tell
3903 the mainstream emacs code by setting mouse_moved. If not, ask for
3904 another motion event, so we can check again the next time it moves. */
3907 note_mouse_movement (struct frame
*frame
, const XMotionEvent
*event
)
3910 struct x_display_info
*dpyinfo
;
3912 if (!FRAME_X_OUTPUT (frame
))
3915 dpyinfo
= FRAME_DISPLAY_INFO (frame
);
3916 dpyinfo
->last_mouse_movement_time
= event
->time
;
3917 dpyinfo
->last_mouse_motion_frame
= frame
;
3918 dpyinfo
->last_mouse_motion_x
= event
->x
;
3919 dpyinfo
->last_mouse_motion_y
= event
->y
;
3921 if (event
->window
!= FRAME_X_WINDOW (frame
))
3923 frame
->mouse_moved
= 1;
3924 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3925 note_mouse_highlight (frame
, -1, -1);
3926 dpyinfo
->last_mouse_glyph_frame
= NULL
;
3931 /* Has the mouse moved off the glyph it was on at the last sighting? */
3932 r
= &dpyinfo
->last_mouse_glyph
;
3933 if (frame
!= dpyinfo
->last_mouse_glyph_frame
3934 || event
->x
< r
->x
|| event
->x
>= r
->x
+ r
->width
3935 || event
->y
< r
->y
|| event
->y
>= r
->y
+ r
->height
)
3937 frame
->mouse_moved
= 1;
3938 dpyinfo
->last_mouse_scroll_bar
= NULL
;
3939 note_mouse_highlight (frame
, event
->x
, event
->y
);
3940 /* Remember which glyph we're now on. */
3941 remember_mouse_glyph (frame
, event
->x
, event
->y
, r
);
3942 dpyinfo
->last_mouse_glyph_frame
= frame
;
3949 /* Return the current position of the mouse.
3950 *FP should be a frame which indicates which display to ask about.
3952 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
3953 and *PART to the frame, window, and scroll bar part that the mouse
3954 is over. Set *X and *Y to the portion and whole of the mouse's
3955 position on the scroll bar.
3957 If the mouse movement started elsewhere, set *FP to the frame the
3958 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
3961 Set *TIMESTAMP to the server time-stamp for the time at which the mouse
3962 was at this position.
3964 Don't store anything if we don't have a valid set of values to report.
3966 This clears the mouse_moved flag, so we can wait for the next mouse
3970 XTmouse_position (struct frame
**fp
, int insist
, Lisp_Object
*bar_window
,
3971 enum scroll_bar_part
*part
, Lisp_Object
*x
, Lisp_Object
*y
,
3975 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
3979 if (dpyinfo
->last_mouse_scroll_bar
&& insist
== 0)
3981 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
3983 if (bar
->horizontal
)
3984 x_horizontal_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, timestamp
);
3986 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, timestamp
);
3993 Window dummy_window
;
3996 Lisp_Object frame
, tail
;
3998 /* Clear the mouse-moved flag for every frame on this display. */
3999 FOR_EACH_FRAME (tail
, frame
)
4000 if (FRAME_X_P (XFRAME (frame
))
4001 && FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
4002 XFRAME (frame
)->mouse_moved
= 0;
4004 dpyinfo
->last_mouse_scroll_bar
= NULL
;
4006 /* Figure out which root window we're on. */
4007 XQueryPointer (FRAME_X_DISPLAY (*fp
),
4008 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
4010 /* The root window which contains the pointer. */
4013 /* Trash which we can't trust if the pointer is on
4014 a different screen. */
4017 /* The position on that root window. */
4020 /* More trash we can't trust. */
4023 /* Modifier keys and pointer buttons, about which
4025 (unsigned int *) &dummy
);
4027 /* Now we have a position on the root; find the innermost window
4028 containing the pointer. */
4032 int parent_x
= 0, parent_y
= 0;
4036 /* XTranslateCoordinates can get errors if the window
4037 structure is changing at the same time this function
4038 is running. So at least we must not crash from them. */
4040 x_catch_errors (FRAME_X_DISPLAY (*fp
));
4042 if (x_mouse_grabbed (dpyinfo
))
4044 /* If mouse was grabbed on a frame, give coords for that frame
4045 even if the mouse is now outside it. */
4046 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
4052 FRAME_X_WINDOW (dpyinfo
->last_mouse_frame
),
4054 /* From-position, to-position. */
4055 root_x
, root_y
, &win_x
, &win_y
,
4059 f1
= dpyinfo
->last_mouse_frame
;
4065 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
4067 /* From-window, to-window. */
4070 /* From-position, to-position. */
4071 root_x
, root_y
, &win_x
, &win_y
,
4076 if (child
== None
|| child
== win
)
4079 /* We don't wan't to know the innermost window. We
4080 want the edit window. For non-Gtk+ the innermost
4081 window is the edit window. For Gtk+ it might not
4082 be. It might be the tool bar for example. */
4083 if (x_window_to_frame (dpyinfo
, win
))
4091 /* Now we know that:
4092 win is the innermost window containing the pointer
4093 (XTC says it has no child containing the pointer),
4094 win_x and win_y are the pointer's position in it
4095 (XTC did this the last time through), and
4096 parent_x and parent_y are the pointer's position in win's parent.
4097 (They are what win_x and win_y were when win was child.
4098 If win is the root window, it has no parent, and
4099 parent_{x,y} are invalid, but that's okay, because we'll
4100 never use them in that case.) */
4103 /* We don't wan't to know the innermost window. We
4104 want the edit window. */
4105 f1
= x_window_to_frame (dpyinfo
, win
);
4107 /* Is win one of our frames? */
4108 f1
= x_any_window_to_frame (dpyinfo
, win
);
4111 #ifdef USE_X_TOOLKIT
4112 /* If we end up with the menu bar window, say it's not
4115 && f1
->output_data
.x
->menubar_widget
4116 && win
== XtWindow (f1
->output_data
.x
->menubar_widget
))
4118 #endif /* USE_X_TOOLKIT */
4121 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
4124 x_uncatch_errors ();
4126 /* If not, is it one of our scroll bars? */
4129 struct scroll_bar
*bar
;
4131 bar
= x_window_to_scroll_bar (FRAME_X_DISPLAY (*fp
), win
, 2);
4135 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4141 if (f1
== 0 && insist
> 0)
4142 f1
= SELECTED_FRAME ();
4146 /* Ok, we found a frame. Store all the values.
4147 last_mouse_glyph is a rectangle used to reduce the
4148 generation of mouse events. To not miss any motion
4149 events, we must divide the frame into rectangles of the
4150 size of the smallest character that could be displayed
4151 on it, i.e. into the same rectangles that matrices on
4152 the frame are divided into. */
4154 /* FIXME: what if F1 is not an X frame? */
4155 dpyinfo
= FRAME_DISPLAY_INFO (f1
);
4156 remember_mouse_glyph (f1
, win_x
, win_y
, &dpyinfo
->last_mouse_glyph
);
4157 dpyinfo
->last_mouse_glyph_frame
= f1
;
4162 XSETINT (*x
, win_x
);
4163 XSETINT (*y
, win_y
);
4164 *timestamp
= dpyinfo
->last_mouse_movement_time
;
4174 /***********************************************************************
4176 ***********************************************************************/
4178 /* Scroll bar support. */
4180 /* Given an X window ID and a DISPLAY, find the struct scroll_bar which
4182 This can be called in GC, so we have to make sure to strip off mark
4185 static struct scroll_bar
*
4186 x_window_to_scroll_bar (Display
*display
, Window window_id
, int type
)
4188 Lisp_Object tail
, frame
;
4190 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
4191 window_id
= (Window
) xg_get_scroll_id_for_window (display
, window_id
);
4192 #endif /* USE_GTK && USE_TOOLKIT_SCROLL_BARS */
4194 FOR_EACH_FRAME (tail
, frame
)
4196 Lisp_Object bar
, condemned
;
4198 if (! FRAME_X_P (XFRAME (frame
)))
4201 /* Scan this frame's scroll bar list for a scroll bar with the
4203 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
4204 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
4205 /* This trick allows us to search both the ordinary and
4206 condemned scroll bar lists with one loop. */
4207 ! NILP (bar
) || (bar
= condemned
,
4210 bar
= XSCROLL_BAR (bar
)->next
)
4211 if (XSCROLL_BAR (bar
)->x_window
== window_id
4212 && FRAME_X_DISPLAY (XFRAME (frame
)) == display
4214 || (type
== 1 && XSCROLL_BAR (bar
)->horizontal
)
4215 || (type
== 0 && !XSCROLL_BAR (bar
)->horizontal
)))
4216 return XSCROLL_BAR (bar
);
4223 #if defined USE_LUCID
4225 /* Return the Lucid menu bar WINDOW is part of. Return null
4226 if WINDOW is not part of a menu bar. */
4229 x_window_to_menu_bar (Window window
)
4231 Lisp_Object tail
, frame
;
4233 FOR_EACH_FRAME (tail
, frame
)
4234 if (FRAME_X_P (XFRAME (frame
)))
4236 Widget menu_bar
= XFRAME (frame
)->output_data
.x
->menubar_widget
;
4238 if (menu_bar
&& xlwmenu_window_p (menu_bar
, window
))
4244 #endif /* USE_LUCID */
4247 /************************************************************************
4249 ************************************************************************/
4251 #ifdef USE_TOOLKIT_SCROLL_BARS
4253 static void x_send_scroll_bar_event (Lisp_Object
, int, int, int, bool);
4255 /* Lisp window being scrolled. Set when starting to interact with
4256 a toolkit scroll bar, reset to nil when ending the interaction. */
4258 static Lisp_Object window_being_scrolled
;
4260 /* Whether this is an Xaw with arrow-scrollbars. This should imply
4261 that movements of 1/20 of the screen size are mapped to up/down. */
4264 /* Id of action hook installed for scroll bars. */
4266 static XtActionHookId action_hook_id
;
4267 static XtActionHookId horizontal_action_hook_id
;
4269 static Boolean xaw3d_arrow_scroll
;
4271 /* Whether the drag scrolling maintains the mouse at the top of the
4272 thumb. If not, resizing the thumb needs to be done more carefully
4273 to avoid jerkiness. */
4275 static Boolean xaw3d_pick_top
;
4277 /* Action hook installed via XtAppAddActionHook when toolkit scroll
4278 bars are used.. The hook is responsible for detecting when
4279 the user ends an interaction with the scroll bar, and generates
4280 a `end-scroll' SCROLL_BAR_CLICK_EVENT' event if so. */
4283 xt_action_hook (Widget widget
, XtPointer client_data
, String action_name
,
4284 XEvent
*event
, String
*params
, Cardinal
*num_params
)
4287 const char *end_action
;
4290 scroll_bar_p
= XmIsScrollBar (widget
);
4291 end_action
= "Release";
4292 #else /* !USE_MOTIF i.e. use Xaw */
4293 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
4294 end_action
= "EndScroll";
4295 #endif /* USE_MOTIF */
4298 && strcmp (action_name
, end_action
) == 0
4299 && WINDOWP (window_being_scrolled
))
4302 struct scroll_bar
*bar
;
4304 x_send_scroll_bar_event (window_being_scrolled
,
4305 scroll_bar_end_scroll
, 0, 0, 0);
4306 w
= XWINDOW (window_being_scrolled
);
4307 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
4309 if (bar
->dragging
!= -1)
4312 /* The thumb size is incorrect while dragging: fix it. */
4313 set_vertical_scroll_bar (w
);
4315 window_being_scrolled
= Qnil
;
4316 #if defined (USE_LUCID)
4317 bar
->last_seen_part
= scroll_bar_nowhere
;
4319 /* Xt timeouts no longer needed. */
4320 toolkit_scroll_bar_interaction
= 0;
4326 xt_horizontal_action_hook (Widget widget
, XtPointer client_data
, String action_name
,
4327 XEvent
*event
, String
*params
, Cardinal
*num_params
)
4330 const char *end_action
;
4333 scroll_bar_p
= XmIsScrollBar (widget
);
4334 end_action
= "Release";
4335 #else /* !USE_MOTIF i.e. use Xaw */
4336 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
4337 end_action
= "EndScroll";
4338 #endif /* USE_MOTIF */
4341 && strcmp (action_name
, end_action
) == 0
4342 && WINDOWP (window_being_scrolled
))
4345 struct scroll_bar
*bar
;
4347 x_send_scroll_bar_event (window_being_scrolled
,
4348 scroll_bar_end_scroll
, 0, 0, 1);
4349 w
= XWINDOW (window_being_scrolled
);
4350 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
4352 if (bar
->dragging
!= -1)
4355 /* The thumb size is incorrect while dragging: fix it. */
4356 set_horizontal_scroll_bar (w
);
4358 window_being_scrolled
= Qnil
;
4359 #if defined (USE_LUCID)
4360 bar
->last_seen_part
= scroll_bar_nowhere
;
4362 /* Xt timeouts no longer needed. */
4363 toolkit_scroll_bar_interaction
= 0;
4366 #endif /* not USE_GTK */
4368 /* Send a client message with message type Xatom_Scrollbar for a
4369 scroll action to the frame of WINDOW. PART is a value identifying
4370 the part of the scroll bar that was clicked on. PORTION is the
4371 amount to scroll of a whole of WHOLE. */
4374 x_send_scroll_bar_event (Lisp_Object window
, int part
, int portion
, int whole
, bool horizontal
)
4377 XClientMessageEvent
*ev
= &event
.xclient
;
4378 struct window
*w
= XWINDOW (window
);
4379 struct frame
*f
= XFRAME (w
->frame
);
4380 intptr_t iw
= (intptr_t) w
;
4381 enum { BITS_PER_INTPTR
= CHAR_BIT
* sizeof iw
};
4382 verify (BITS_PER_INTPTR
<= 64);
4383 int sign_shift
= BITS_PER_INTPTR
- 32;
4387 /* Construct a ClientMessage event to send to the frame. */
4388 ev
->type
= ClientMessage
;
4389 ev
->message_type
= (horizontal
4390 ? FRAME_DISPLAY_INFO (f
)->Xatom_Horizontal_Scrollbar
4391 : FRAME_DISPLAY_INFO (f
)->Xatom_Scrollbar
);
4392 ev
->display
= FRAME_X_DISPLAY (f
);
4393 ev
->window
= FRAME_X_WINDOW (f
);
4396 /* A 32-bit X client on a 64-bit X server can pass a window pointer
4397 as-is. A 64-bit client on a 32-bit X server is in trouble
4398 because a pointer does not fit and would be truncated while
4399 passing through the server. So use two slots and hope that X12
4400 will resolve such issues someday. */
4401 ev
->data
.l
[0] = iw
>> 31 >> 1;
4402 ev
->data
.l
[1] = sign_shift
<= 0 ? iw
: iw
<< sign_shift
>> sign_shift
;
4403 ev
->data
.l
[2] = part
;
4404 ev
->data
.l
[3] = portion
;
4405 ev
->data
.l
[4] = whole
;
4407 /* Make Xt timeouts work while the scroll bar is active. */
4408 #ifdef USE_X_TOOLKIT
4409 toolkit_scroll_bar_interaction
= 1;
4410 x_activate_timeout_atimer ();
4413 /* Setting the event mask to zero means that the message will
4414 be sent to the client that created the window, and if that
4415 window no longer exists, no event will be sent. */
4416 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
4421 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
4425 x_scroll_bar_to_input_event (const XEvent
*event
,
4426 struct input_event
*ievent
)
4428 const XClientMessageEvent
*ev
= &event
->xclient
;
4432 /* See the comment in the function above. */
4433 intptr_t iw0
= ev
->data
.l
[0];
4434 intptr_t iw1
= ev
->data
.l
[1];
4435 intptr_t iw
= (iw0
<< 31 << 1) + (iw1
& 0xffffffffu
);
4436 w
= (struct window
*) iw
;
4438 XSETWINDOW (window
, w
);
4440 ievent
->kind
= SCROLL_BAR_CLICK_EVENT
;
4441 ievent
->frame_or_window
= window
;
4444 ievent
->timestamp
= CurrentTime
;
4447 XtLastTimestampProcessed (FRAME_X_DISPLAY (XFRAME (w
->frame
)));
4450 ievent
->part
= ev
->data
.l
[2];
4451 ievent
->x
= make_number (ev
->data
.l
[3]);
4452 ievent
->y
= make_number (ev
->data
.l
[4]);
4453 ievent
->modifiers
= 0;
4456 /* Transform a horizontal scroll bar ClientMessage EVENT to an Emacs
4457 input event in *IEVENT. */
4460 x_horizontal_scroll_bar_to_input_event (const XEvent
*event
,
4461 struct input_event
*ievent
)
4463 const XClientMessageEvent
*ev
= &event
->xclient
;
4467 /* See the comment in the function above. */
4468 intptr_t iw0
= ev
->data
.l
[0];
4469 intptr_t iw1
= ev
->data
.l
[1];
4470 intptr_t iw
= (iw0
<< 31 << 1) + (iw1
& 0xffffffffu
);
4471 w
= (struct window
*) iw
;
4473 XSETWINDOW (window
, w
);
4475 ievent
->kind
= HORIZONTAL_SCROLL_BAR_CLICK_EVENT
;
4476 ievent
->frame_or_window
= window
;
4479 ievent
->timestamp
= CurrentTime
;
4482 XtLastTimestampProcessed (FRAME_X_DISPLAY (XFRAME (w
->frame
)));
4485 ievent
->part
= ev
->data
.l
[2];
4486 ievent
->x
= make_number (ev
->data
.l
[3]);
4487 ievent
->y
= make_number (ev
->data
.l
[4]);
4488 ievent
->modifiers
= 0;
4494 /* Minimum and maximum values used for Motif scroll bars. */
4496 #define XM_SB_MAX 10000000
4498 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
4499 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
4500 CALL_DATA is a pointer to a XmScrollBarCallbackStruct. */
4503 xm_scroll_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
4505 struct scroll_bar
*bar
= client_data
;
4506 XmScrollBarCallbackStruct
*cs
= call_data
;
4507 int part
= -1, whole
= 0, portion
= 0;
4508 int horizontal
= bar
->horizontal
;
4512 case XmCR_DECREMENT
:
4514 part
= horizontal
? scroll_bar_left_arrow
: scroll_bar_up_arrow
;
4517 case XmCR_INCREMENT
:
4519 part
= horizontal
? scroll_bar_right_arrow
: scroll_bar_down_arrow
;
4522 case XmCR_PAGE_DECREMENT
:
4524 part
= horizontal
? scroll_bar_before_handle
: scroll_bar_above_handle
;
4527 case XmCR_PAGE_INCREMENT
:
4529 part
= horizontal
? scroll_bar_after_handle
: scroll_bar_below_handle
;
4534 part
= horizontal
? scroll_bar_to_leftmost
: scroll_bar_to_top
;
4537 case XmCR_TO_BOTTOM
:
4539 part
= horizontal
? scroll_bar_to_rightmost
: scroll_bar_to_bottom
;
4547 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
4553 portion
= (((float) cs
->value
4554 / (XM_SB_MAX
- slider_size
))
4556 - ((float) slider_size
/ XM_SB_MAX
) * whole
));
4557 portion
= max (0, portion
);
4558 part
= scroll_bar_horizontal_handle
;
4562 whole
= XM_SB_MAX
- slider_size
;
4563 portion
= min (cs
->value
, whole
);
4564 part
= scroll_bar_handle
;
4567 bar
->dragging
= cs
->value
;
4571 case XmCR_VALUE_CHANGED
:
4577 window_being_scrolled
= bar
->window
;
4578 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
, bar
->horizontal
);
4582 #elif defined USE_GTK
4584 /* Scroll bar callback for GTK scroll bars. WIDGET is the scroll
4585 bar widget. DATA is a pointer to the scroll_bar structure. */
4588 xg_scroll_callback (GtkRange
*range
,
4589 GtkScrollType scroll
,
4593 struct scroll_bar
*bar
= user_data
;
4594 int part
= -1, whole
= 0, portion
= 0;
4595 GtkAdjustment
*adj
= GTK_ADJUSTMENT (gtk_range_get_adjustment (range
));
4596 struct frame
*f
= g_object_get_data (G_OBJECT (range
), XG_FRAME_DATA
);
4598 if (xg_ignore_gtk_scrollbar
) return FALSE
;
4602 case GTK_SCROLL_JUMP
:
4603 /* Buttons 1 2 or 3 must be grabbed. */
4604 if (FRAME_DISPLAY_INFO (f
)->grabbed
!= 0
4605 && FRAME_DISPLAY_INFO (f
)->grabbed
< (1 << 4))
4607 if (bar
->horizontal
)
4609 part
= scroll_bar_horizontal_handle
;
4610 whole
= (int)(gtk_adjustment_get_upper (adj
) -
4611 gtk_adjustment_get_page_size (adj
));
4612 portion
= min ((int)value
, whole
);
4613 bar
->dragging
= portion
;
4617 part
= scroll_bar_handle
;
4618 whole
= gtk_adjustment_get_upper (adj
) -
4619 gtk_adjustment_get_page_size (adj
);
4620 portion
= min ((int)value
, whole
);
4621 bar
->dragging
= portion
;
4625 case GTK_SCROLL_STEP_BACKWARD
:
4626 part
= (bar
->horizontal
4627 ? scroll_bar_left_arrow
: scroll_bar_up_arrow
);
4630 case GTK_SCROLL_STEP_FORWARD
:
4631 part
= (bar
->horizontal
4632 ? scroll_bar_right_arrow
: scroll_bar_down_arrow
);
4635 case GTK_SCROLL_PAGE_BACKWARD
:
4636 part
= (bar
->horizontal
4637 ? scroll_bar_before_handle
: scroll_bar_above_handle
);
4640 case GTK_SCROLL_PAGE_FORWARD
:
4641 part
= (bar
->horizontal
4642 ? scroll_bar_after_handle
: scroll_bar_below_handle
);
4649 window_being_scrolled
= bar
->window
;
4650 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
, bar
->horizontal
);
4656 /* Callback for button release. Sets dragging to -1 when dragging is done. */
4659 xg_end_scroll_callback (GtkWidget
*widget
,
4660 GdkEventButton
*event
,
4663 struct scroll_bar
*bar
= user_data
;
4665 if (WINDOWP (window_being_scrolled
))
4667 x_send_scroll_bar_event (window_being_scrolled
,
4668 scroll_bar_end_scroll
, 0, 0, bar
->horizontal
);
4669 window_being_scrolled
= Qnil
;
4676 #else /* not USE_GTK and not USE_MOTIF */
4678 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
4679 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
4680 scroll bar struct. CALL_DATA is a pointer to a float saying where
4684 xaw_jump_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
4686 struct scroll_bar
*bar
= client_data
;
4687 float *top_addr
= call_data
;
4688 float top
= *top_addr
;
4690 int whole
, portion
, height
;
4691 enum scroll_bar_part part
;
4692 int horizontal
= bar
->horizontal
;
4694 /* Get the size of the thumb, a value between 0 and 1. */
4696 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
4702 portion
= (top
* (whole
- (shown
* whole
))) / (1 - shown
);
4703 portion
= max (0, portion
);
4704 part
= scroll_bar_horizontal_handle
;
4707 part
= scroll_bar_handle
;
4709 window_being_scrolled
= bar
->window
;
4710 bar
->dragging
= portion
;
4711 bar
->last_seen_part
= part
;
4712 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
, bar
->horizontal
);
4716 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
4717 i.e. line or page up or down. WIDGET is the Xaw scroll bar
4718 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
4719 the scroll bar. CALL_DATA is an integer specifying the action that
4720 has taken place. Its magnitude is in the range 0..height of the
4721 scroll bar. Negative values mean scroll towards buffer start.
4722 Values < height of scroll bar mean line-wise movement. */
4725 xaw_scroll_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
4727 struct scroll_bar
*bar
= client_data
;
4728 /* The position really is stored cast to a pointer. */
4729 int position
= (intptr_t) call_data
;
4731 enum scroll_bar_part part
;
4733 /* Get the height of the scroll bar. */
4735 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
4738 if (eabs (position
) >= height
)
4739 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
4741 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
4742 it maps line-movement to call_data = max(5, height/20). */
4743 else if (xaw3d_arrow_scroll
&& eabs (position
) <= max (5, height
/ 20))
4744 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
4746 part
= scroll_bar_move_ratio
;
4748 window_being_scrolled
= bar
->window
;
4750 bar
->last_seen_part
= part
;
4751 x_send_scroll_bar_event (bar
->window
, part
, position
, height
, bar
->horizontal
);
4754 #endif /* not USE_GTK and not USE_MOTIF */
4756 #define SCROLL_BAR_NAME "verticalScrollBar"
4757 #define SCROLL_BAR_HORIZONTAL_NAME "horizontalScrollBar"
4759 /* Create the widget for scroll bar BAR on frame F. Record the widget
4760 and X window of the scroll bar in BAR. */
4764 x_create_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
4766 const char *scroll_bar_name
= SCROLL_BAR_NAME
;
4769 xg_create_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
4770 G_CALLBACK (xg_end_scroll_callback
),
4776 x_create_horizontal_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
4778 const char *scroll_bar_name
= SCROLL_BAR_HORIZONTAL_NAME
;
4781 xg_create_horizontal_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
4782 G_CALLBACK (xg_end_scroll_callback
),
4787 #else /* not USE_GTK */
4790 x_create_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
4796 const char *scroll_bar_name
= SCROLL_BAR_NAME
;
4797 unsigned long pixel
;
4802 /* Set resources. Create the widget. */
4803 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4804 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
4805 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
4806 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
4807 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
4808 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
4809 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
4811 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4814 XtSetArg (av
[ac
], XmNforeground
, pixel
);
4818 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4821 XtSetArg (av
[ac
], XmNbackground
, pixel
);
4825 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
4826 (char *) scroll_bar_name
, av
, ac
);
4828 /* Add one callback for everything that can happen. */
4829 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
4831 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
4833 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
4835 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
4837 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
4839 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
4841 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
4844 /* Realize the widget. Only after that is the X window created. */
4845 XtRealizeWidget (widget
);
4847 /* Set the cursor to an arrow. I didn't find a resource to do that.
4848 And I'm wondering why it hasn't an arrow cursor by default. */
4849 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
4850 f
->output_data
.x
->nontext_cursor
);
4852 #else /* !USE_MOTIF i.e. use Xaw */
4854 /* Set resources. Create the widget. The background of the
4855 Xaw3d scroll bar widget is a little bit light for my taste.
4856 We don't alter it here to let users change it according
4857 to their taste with `emacs*verticalScrollBar.background: xxx'. */
4858 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4859 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
4860 /* For smoother scrolling with Xaw3d -sm */
4861 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
4863 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4866 XtSetArg (av
[ac
], XtNforeground
, pixel
);
4870 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4873 XtSetArg (av
[ac
], XtNbackground
, pixel
);
4877 /* Top/bottom shadow colors. */
4879 /* Allocate them, if necessary. */
4880 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
4882 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4885 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
4886 FRAME_X_COLORMAP (f
),
4887 &pixel
, 1.2, 0x8000))
4889 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
4892 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4894 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4897 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
4898 FRAME_X_COLORMAP (f
),
4899 &pixel
, 0.6, 0x4000))
4901 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
4905 #ifdef XtNbeNiceToColormap
4906 /* Tell the toolkit about them. */
4907 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
4908 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4909 /* We tried to allocate a color for the top/bottom shadow, and
4910 failed, so tell Xaw3d to use dithering instead. */
4911 /* But only if we have a small colormap. Xaw3d can allocate nice
4914 XtSetArg (av
[ac
], XtNbeNiceToColormap
,
4915 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)) < 16);
4919 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
4920 be more consistent with other emacs 3d colors, and since Xaw3d is
4921 not good at dealing with allocation failure. */
4923 /* This tells Xaw3d to use real colors instead of dithering for
4925 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
4928 /* Specify the colors. */
4929 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
4932 XtSetArg (av
[ac
], XtNtopShadowPixel
, pixel
);
4935 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
4938 XtSetArg (av
[ac
], XtNbottomShadowPixel
, pixel
);
4944 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
4945 f
->output_data
.x
->edit_widget
, av
, ac
);
4948 char const *initial
= "";
4949 char const *val
= initial
;
4950 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
4951 #ifdef XtNarrowScrollbars
4952 XtNarrowScrollbars
, (XtPointer
) &xaw3d_arrow_scroll
,
4954 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
4955 if (xaw3d_arrow_scroll
|| val
== initial
)
4956 { /* ARROW_SCROLL */
4957 xaw3d_arrow_scroll
= True
;
4958 /* Isn't that just a personal preference ? --Stef */
4959 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
4963 /* Define callbacks. */
4964 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
4965 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
4968 /* Realize the widget. Only after that is the X window created. */
4969 XtRealizeWidget (widget
);
4971 #endif /* !USE_MOTIF */
4973 /* Install an action hook that lets us detect when the user
4974 finishes interacting with a scroll bar. */
4975 if (action_hook_id
== 0)
4976 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
4978 /* Remember X window and widget in the scroll bar vector. */
4979 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
4980 xwindow
= XtWindow (widget
);
4981 bar
->x_window
= xwindow
;
4983 bar
->horizontal
= 0;
4989 x_create_horizontal_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
4995 const char *scroll_bar_name
= SCROLL_BAR_HORIZONTAL_NAME
;
4996 unsigned long pixel
;
5001 /* Set resources. Create the widget. */
5002 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
5003 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
5004 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
5005 XtSetArg (av
[ac
], XmNorientation
, XmHORIZONTAL
); ++ac
;
5006 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_RIGHT
), ++ac
;
5007 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
5008 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
5010 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
5013 XtSetArg (av
[ac
], XmNforeground
, pixel
);
5017 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5020 XtSetArg (av
[ac
], XmNbackground
, pixel
);
5024 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
5025 (char *) scroll_bar_name
, av
, ac
);
5027 /* Add one callback for everything that can happen. */
5028 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
5030 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
5032 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
5034 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
5036 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
5038 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
5040 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
5043 /* Realize the widget. Only after that is the X window created. */
5044 XtRealizeWidget (widget
);
5046 /* Set the cursor to an arrow. I didn't find a resource to do that.
5047 And I'm wondering why it hasn't an arrow cursor by default. */
5048 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
5049 f
->output_data
.x
->nontext_cursor
);
5051 #else /* !USE_MOTIF i.e. use Xaw */
5053 /* Set resources. Create the widget. The background of the
5054 Xaw3d scroll bar widget is a little bit light for my taste.
5055 We don't alter it here to let users change it according
5056 to their taste with `emacs*verticalScrollBar.background: xxx'. */
5057 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
5058 XtSetArg (av
[ac
], XtNorientation
, XtorientHorizontal
); ++ac
;
5059 /* For smoother scrolling with Xaw3d -sm */
5060 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
5062 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
5065 XtSetArg (av
[ac
], XtNforeground
, pixel
);
5069 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5072 XtSetArg (av
[ac
], XtNbackground
, pixel
);
5076 /* Top/bottom shadow colors. */
5078 /* Allocate them, if necessary. */
5079 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
5081 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5084 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
5085 FRAME_X_COLORMAP (f
),
5086 &pixel
, 1.2, 0x8000))
5088 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
5091 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
5093 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5096 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
5097 FRAME_X_COLORMAP (f
),
5098 &pixel
, 0.6, 0x4000))
5100 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
5104 #ifdef XtNbeNiceToColormap
5105 /* Tell the toolkit about them. */
5106 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
5107 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
5108 /* We tried to allocate a color for the top/bottom shadow, and
5109 failed, so tell Xaw3d to use dithering instead. */
5110 /* But only if we have a small colormap. Xaw3d can allocate nice
5113 XtSetArg (av
[ac
], XtNbeNiceToColormap
,
5114 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)) < 16);
5118 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
5119 be more consistent with other emacs 3d colors, and since Xaw3d is
5120 not good at dealing with allocation failure. */
5122 /* This tells Xaw3d to use real colors instead of dithering for
5124 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
5127 /* Specify the colors. */
5128 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
5131 XtSetArg (av
[ac
], XtNtopShadowPixel
, pixel
);
5134 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
5137 XtSetArg (av
[ac
], XtNbottomShadowPixel
, pixel
);
5143 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
5144 f
->output_data
.x
->edit_widget
, av
, ac
);
5147 char const *initial
= "";
5148 char const *val
= initial
;
5149 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
5150 #ifdef XtNarrowScrollbars
5151 XtNarrowScrollbars
, (XtPointer
) &xaw3d_arrow_scroll
,
5153 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
5154 if (xaw3d_arrow_scroll
|| val
== initial
)
5155 { /* ARROW_SCROLL */
5156 xaw3d_arrow_scroll
= True
;
5157 /* Isn't that just a personal preference ? --Stef */
5158 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
5162 /* Define callbacks. */
5163 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
5164 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
5167 /* Realize the widget. Only after that is the X window created. */
5168 XtRealizeWidget (widget
);
5170 #endif /* !USE_MOTIF */
5172 /* Install an action hook that lets us detect when the user
5173 finishes interacting with a scroll bar. */
5174 if (horizontal_action_hook_id
== 0)
5175 horizontal_action_hook_id
5176 = XtAppAddActionHook (Xt_app_con
, xt_horizontal_action_hook
, 0);
5178 /* Remember X window and widget in the scroll bar vector. */
5179 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
5180 xwindow
= XtWindow (widget
);
5181 bar
->x_window
= xwindow
;
5183 bar
->horizontal
= 1;
5187 #endif /* not USE_GTK */
5190 /* Set the thumb size and position of scroll bar BAR. We are currently
5191 displaying PORTION out of a whole WHOLE, and our position POSITION. */
5195 x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
, int whole
)
5197 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
5201 x_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
, int whole
)
5203 xg_set_toolkit_horizontal_scroll_bar_thumb (bar
, portion
, position
, whole
);
5206 #else /* not USE_GTK */
5208 x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
,
5211 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5212 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
5219 if (scroll_bar_adjust_thumb_portion_p
)
5221 /* We use an estimate of 30 chars per line rather than the real
5222 `portion' value. This has the disadvantage that the thumb size
5223 is not very representative, but it makes our life a lot easier.
5224 Otherwise, we have to constantly adjust the thumb size, which
5225 we can't always do quickly enough: while dragging, the size of
5226 the thumb might prevent the user from dragging the thumb all the
5227 way to the end. but Motif and some versions of Xaw3d don't allow
5228 updating the thumb size while dragging. Also, even if we can update
5229 its size, the update will often happen too late.
5230 If you don't believe it, check out revision 1.650 of xterm.c to see
5231 what hoops we were going through and the still poor behavior we got. */
5232 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
5233 /* When the thumb is at the bottom, position == whole.
5234 So we need to increase `whole' to make space for the thumb. */
5242 top
= (float) position
/ whole
;
5243 shown
= (float) portion
/ whole
;
5246 if (bar
->dragging
== -1)
5250 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
5251 is the scroll bar's maximum and MIN is the scroll bar's minimum
5253 size
= clip_to_bounds (1, shown
* XM_SB_MAX
, XM_SB_MAX
);
5255 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
5256 value
= top
* XM_SB_MAX
;
5257 value
= min (value
, XM_SB_MAX
- size
);
5259 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
5261 #else /* !USE_MOTIF i.e. use Xaw */
5267 top
= (float) position
/ whole
;
5268 shown
= (float) portion
/ whole
;
5272 float old_top
, old_shown
;
5274 XtVaGetValues (widget
,
5275 XtNtopOfThumb
, &old_top
,
5276 XtNshown
, &old_shown
,
5280 /* Massage the top+shown values. */
5281 if (bar
->dragging
== -1 || bar
->last_seen_part
== scroll_bar_down_arrow
)
5282 top
= max (0, min (1, top
));
5285 #if ! defined (HAVE_XAW3D)
5286 /* With Xaw, 'top' values too closer to 1.0 may
5287 cause the thumb to disappear. Fix that. */
5288 top
= min (top
, 0.99f
);
5290 /* Keep two pixels available for moving the thumb down. */
5291 shown
= max (0, min (1 - top
- (2.0f
/ height
), shown
));
5292 #if ! defined (HAVE_XAW3D)
5293 /* Likewise with too small 'shown'. */
5294 shown
= max (shown
, 0.01f
);
5297 /* If the call to XawScrollbarSetThumb below doesn't seem to
5298 work, check that 'NARROWPROTO' is defined in src/config.h.
5299 If this is not so, most likely you need to fix configure. */
5300 if (top
!= old_top
|| shown
!= old_shown
)
5302 if (bar
->dragging
== -1)
5303 XawScrollbarSetThumb (widget
, top
, shown
);
5306 /* Try to make the scrolling a tad smoother. */
5307 if (!xaw3d_pick_top
)
5308 shown
= min (shown
, old_shown
);
5310 XawScrollbarSetThumb (widget
, top
, shown
);
5314 #endif /* !USE_MOTIF */
5320 x_set_toolkit_horizontal_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
,
5323 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5324 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
5331 shown
= (float) portion
/ whole
;
5332 top
= (float) position
/ (whole
- portion
);
5334 int size
= clip_to_bounds (1, shown
* XM_SB_MAX
, XM_SB_MAX
);
5335 int value
= clip_to_bounds (0, top
* (XM_SB_MAX
- size
), XM_SB_MAX
- size
);
5337 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
5339 #else /* !USE_MOTIF i.e. use Xaw */
5345 top
= (float) position
/ whole
;
5346 shown
= (float) portion
/ whole
;
5350 float old_top
, old_shown
;
5352 XtVaGetValues (widget
,
5353 XtNtopOfThumb
, &old_top
,
5354 XtNshown
, &old_shown
,
5359 /* Massage the top+shown values. */
5360 if (bar
->dragging
== -1 || bar
->last_seen_part
== scroll_bar_down_arrow
)
5361 top
= max (0, min (1, top
));
5364 #if ! defined (HAVE_XAW3D)
5365 /* With Xaw, 'top' values too closer to 1.0 may
5366 cause the thumb to disappear. Fix that. */
5367 top
= min (top
, 0.99f
);
5369 /* Keep two pixels available for moving the thumb down. */
5370 shown
= max (0, min (1 - top
- (2.0f
/ height
), shown
));
5371 #if ! defined (HAVE_XAW3D)
5372 /* Likewise with too small 'shown'. */
5373 shown
= max (shown
, 0.01f
);
5377 /* If the call to XawScrollbarSetThumb below doesn't seem to
5378 work, check that 'NARROWPROTO' is defined in src/config.h.
5379 If this is not so, most likely you need to fix configure. */
5380 XawScrollbarSetThumb (widget
, top
, shown
);
5382 if (top
!= old_top
|| shown
!= old_shown
)
5384 if (bar
->dragging
== -1)
5385 XawScrollbarSetThumb (widget
, top
, shown
);
5388 /* Try to make the scrolling a tad smoother. */
5389 if (!xaw3d_pick_top
)
5390 shown
= min (shown
, old_shown
);
5392 XawScrollbarSetThumb (widget
, top
, shown
);
5397 #endif /* !USE_MOTIF */
5401 #endif /* not USE_GTK */
5403 #endif /* USE_TOOLKIT_SCROLL_BARS */
5407 /************************************************************************
5408 Scroll bars, general
5409 ************************************************************************/
5411 /* Create a scroll bar and return the scroll bar vector for it. W is
5412 the Emacs window on which to create the scroll bar. TOP, LEFT,
5413 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
5416 static struct scroll_bar
*
5417 x_scroll_bar_create (struct window
*w
, int top
, int left
, int width
, int height
, bool horizontal
)
5419 struct frame
*f
= XFRAME (w
->frame
);
5420 struct scroll_bar
*bar
5421 = ALLOCATE_PSEUDOVECTOR (struct scroll_bar
, x_window
, PVEC_OTHER
);
5426 #ifdef USE_TOOLKIT_SCROLL_BARS
5428 x_create_horizontal_toolkit_scroll_bar (f
, bar
);
5430 x_create_toolkit_scroll_bar (f
, bar
);
5431 #else /* not USE_TOOLKIT_SCROLL_BARS */
5433 XSetWindowAttributes a
;
5437 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
5438 if (a
.background_pixel
== -1)
5439 a
.background_pixel
= FRAME_BACKGROUND_PIXEL (f
);
5441 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
5442 | ButtonMotionMask
| PointerMotionHintMask
5444 a
.cursor
= FRAME_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
5446 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
5448 /* Clear the area of W that will serve as a scroll bar. This is
5449 for the case that a window has been split horizontally. In
5450 this case, no clear_frame is generated to reduce flickering. */
5451 if (width
> 0 && window_box_height (w
) > 0)
5452 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5453 left
, top
, width
, window_box_height (w
));
5455 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5456 /* Position and size of scroll bar. */
5457 left
, top
, width
, height
,
5458 /* Border width, depth, class, and visual. */
5465 bar
->x_window
= window
;
5467 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5469 XSETWINDOW (bar
->window
, w
);
5473 bar
->height
= height
;
5477 #if defined (USE_TOOLKIT_SCROLL_BARS) && defined (USE_LUCID)
5478 bar
->last_seen_part
= scroll_bar_nowhere
;
5481 /* Add bar to its frame's list of scroll bars. */
5482 bar
->next
= FRAME_SCROLL_BARS (f
);
5484 XSETVECTOR (barobj
, bar
);
5485 fset_scroll_bars (f
, barobj
);
5486 if (!NILP (bar
->next
))
5487 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
5489 /* Map the window/widget. */
5490 #ifdef USE_TOOLKIT_SCROLL_BARS
5494 xg_update_horizontal_scrollbar_pos (f
, bar
->x_window
, top
,
5495 left
, width
, max (height
, 1));
5497 xg_update_scrollbar_pos (f
, bar
->x_window
, top
,
5498 left
, width
, max (height
, 1));
5499 #else /* not USE_GTK */
5500 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
5501 XtConfigureWidget (scroll_bar
, left
, top
, width
, max (height
, 1), 0);
5502 XtMapWidget (scroll_bar
);
5503 #endif /* not USE_GTK */
5505 #else /* not USE_TOOLKIT_SCROLL_BARS */
5506 XMapRaised (FRAME_X_DISPLAY (f
), bar
->x_window
);
5507 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5514 #ifndef USE_TOOLKIT_SCROLL_BARS
5516 /* Draw BAR's handle in the proper position.
5518 If the handle is already drawn from START to END, don't bother
5519 redrawing it, unless REBUILD is non-zero; in that case, always
5520 redraw it. (REBUILD is handy for drawing the handle after expose
5523 Normally, we want to constrain the start and end of the handle to
5524 fit inside its rectangle, but if the user is dragging the scroll
5525 bar handle, we want to let them drag it down all the way, so that
5526 the bar's top is as far down as it goes; otherwise, there's no way
5527 to move to the very end of the buffer. */
5530 x_scroll_bar_set_handle (struct scroll_bar
*bar
, int start
, int end
, int rebuild
)
5532 bool dragging
= bar
->dragging
!= -1;
5533 Window w
= bar
->x_window
;
5534 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5535 GC gc
= f
->output_data
.x
->normal_gc
;
5537 /* If the display is already accurate, do nothing. */
5539 && start
== bar
->start
5546 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, bar
->width
);
5547 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, bar
->height
);
5548 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
5550 /* Make sure the values are reasonable, and try to preserve
5551 the distance between start and end. */
5553 int length
= end
- start
;
5557 else if (start
> top_range
)
5559 end
= start
+ length
;
5563 else if (end
> top_range
&& ! dragging
)
5567 /* Store the adjusted setting in the scroll bar. */
5571 /* Clip the end position, just for display. */
5572 if (end
> top_range
)
5575 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
5576 below top positions, to make sure the handle is always at least
5577 that many pixels tall. */
5578 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
5580 /* Draw the empty space above the handle. Note that we can't clear
5581 zero-height areas; that means "clear to end of window." */
5582 if ((inside_width
> 0) && (start
> 0))
5583 x_clear_area (FRAME_X_DISPLAY (f
), w
,
5584 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
5585 VERTICAL_SCROLL_BAR_TOP_BORDER
,
5586 inside_width
, start
);
5588 /* Change to proper foreground color if one is specified. */
5589 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5590 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5591 f
->output_data
.x
->scroll_bar_foreground_pixel
);
5593 /* Draw the handle itself. */
5594 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
5595 /* x, y, width, height */
5596 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
5597 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
5598 inside_width
, end
- start
);
5600 /* Restore the foreground color of the GC if we changed it above. */
5601 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5602 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5603 FRAME_FOREGROUND_PIXEL (f
));
5605 /* Draw the empty space below the handle. Note that we can't
5606 clear zero-height areas; that means "clear to end of window." */
5607 if ((inside_width
> 0) && (end
< inside_height
))
5608 x_clear_area (FRAME_X_DISPLAY (f
), w
,
5609 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
5610 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
5611 inside_width
, inside_height
- end
);
5617 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5619 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
5623 x_scroll_bar_remove (struct scroll_bar
*bar
)
5625 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5628 #ifdef USE_TOOLKIT_SCROLL_BARS
5630 xg_remove_scroll_bar (f
, bar
->x_window
);
5631 #else /* not USE_GTK */
5632 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
5633 #endif /* not USE_GTK */
5635 XDestroyWindow (FRAME_X_DISPLAY (f
), bar
->x_window
);
5638 /* Dissociate this scroll bar from its window. */
5639 if (bar
->horizontal
)
5640 wset_horizontal_scroll_bar (XWINDOW (bar
->window
), Qnil
);
5642 wset_vertical_scroll_bar (XWINDOW (bar
->window
), Qnil
);
5648 /* Set the handle of the vertical scroll bar for WINDOW to indicate
5649 that we are displaying PORTION characters out of a total of WHOLE
5650 characters, starting at POSITION. If WINDOW has no scroll bar,
5654 XTset_vertical_scroll_bar (struct window
*w
, int portion
, int whole
, int position
)
5656 struct frame
*f
= XFRAME (w
->frame
);
5658 struct scroll_bar
*bar
;
5659 int top
, height
, left
, width
;
5660 int window_y
, window_height
;
5662 /* Get window dimensions. */
5663 window_box (w
, ANY_AREA
, 0, &window_y
, 0, &window_height
);
5665 height
= window_height
;
5666 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
5667 width
= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
5669 /* Does the scroll bar exist yet? */
5670 if (NILP (w
->vertical_scroll_bar
))
5672 if (width
> 0 && height
> 0)
5675 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5676 left
, top
, width
, height
);
5680 bar
= x_scroll_bar_create (w
, top
, left
, width
, max (height
, 1), 0);
5684 /* It may just need to be moved and resized. */
5685 unsigned int mask
= 0;
5687 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5691 if (left
!= bar
->left
)
5693 if (top
!= bar
->top
)
5695 if (width
!= bar
->width
)
5697 if (height
!= bar
->height
)
5700 #ifdef USE_TOOLKIT_SCROLL_BARS
5702 /* Move/size the scroll bar widget. */
5705 /* Since toolkit scroll bars are smaller than the space reserved
5706 for them on the frame, we have to clear "under" them. */
5707 if (width
> 0 && height
> 0)
5708 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5709 left
, top
, width
, height
);
5711 xg_update_scrollbar_pos (f
, bar
->x_window
, top
,
5712 left
, width
, max (height
, 1));
5713 #else /* not USE_GTK */
5714 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
5715 left
, top
, width
, max (height
, 1), 0);
5716 #endif /* not USE_GTK */
5718 #else /* not USE_TOOLKIT_SCROLL_BARS */
5720 /* Move/size the scroll bar window. */
5729 XConfigureWindow (FRAME_X_DISPLAY (f
), bar
->x_window
,
5733 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5735 /* Remember new settings. */
5739 bar
->height
= height
;
5744 #ifdef USE_TOOLKIT_SCROLL_BARS
5745 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
5746 #else /* not USE_TOOLKIT_SCROLL_BARS */
5747 /* Set the scroll bar's current state, unless we're currently being
5749 if (bar
->dragging
== -1)
5751 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
5754 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
5757 int start
= ((double) position
* top_range
) / whole
;
5758 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
5759 x_scroll_bar_set_handle (bar
, start
, end
, 0);
5762 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5764 XSETVECTOR (barobj
, bar
);
5765 wset_vertical_scroll_bar (w
, barobj
);
5770 XTset_horizontal_scroll_bar (struct window
*w
, int portion
, int whole
, int position
)
5772 struct frame
*f
= XFRAME (w
->frame
);
5774 struct scroll_bar
*bar
;
5775 int top
, height
, left
, width
;
5776 int window_x
, window_width
;
5777 int pixel_width
= WINDOW_PIXEL_WIDTH (w
);
5779 /* Get window dimensions. */
5780 window_box (w
, ANY_AREA
, &window_x
, 0, &window_width
, 0);
5782 width
= window_width
;
5783 top
= WINDOW_SCROLL_BAR_AREA_Y (w
);
5784 height
= WINDOW_SCROLL_BAR_AREA_HEIGHT (w
);
5786 /* Does the scroll bar exist yet? */
5787 if (NILP (w
->horizontal_scroll_bar
))
5789 if (width
> 0 && height
> 0)
5793 /* Clear also part between window_width and
5794 WINDOW_PIXEL_WIDTH. */
5795 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5796 left
, top
, pixel_width
, height
);
5800 bar
= x_scroll_bar_create (w
, top
, left
, width
, height
, 1);
5804 /* It may just need to be moved and resized. */
5805 unsigned int mask
= 0;
5807 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
5811 if (left
!= bar
->left
)
5813 if (top
!= bar
->top
)
5815 if (width
!= bar
->width
)
5817 if (height
!= bar
->height
)
5820 #ifdef USE_TOOLKIT_SCROLL_BARS
5821 /* Move/size the scroll bar widget. */
5824 /* Since toolkit scroll bars are smaller than the space reserved
5825 for them on the frame, we have to clear "under" them. */
5826 if (width
> 0 && height
> 0)
5827 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5828 WINDOW_LEFT_EDGE_X (w
), top
,
5829 pixel_width
- WINDOW_RIGHT_DIVIDER_WIDTH (w
), height
);
5831 xg_update_horizontal_scrollbar_pos (f
, bar
->x_window
, top
, left
,
5833 #else /* not USE_GTK */
5834 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
5835 left
, top
, width
, height
, 0);
5836 #endif /* not USE_GTK */
5838 #else /* not USE_TOOLKIT_SCROLL_BARS */
5840 /* Clear areas not covered by the scroll bar because it's not as
5841 wide as the area reserved for it. This makes sure a
5842 previous mode line display is cleared after C-x 2 C-x 1, for
5845 int area_height
= WINDOW_CONFIG_SCROLL_BAR_HEIGHT (w
);
5846 int rest
= area_height
- height
;
5847 if (rest
> 0 && width
> 0)
5848 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5849 left
, top
, width
, rest
);
5852 /* Move/size the scroll bar window. */
5861 XConfigureWindow (FRAME_X_DISPLAY (f
), bar
->x_window
,
5865 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5867 /* Remember new settings. */
5871 bar
->height
= height
;
5876 #ifdef USE_TOOLKIT_SCROLL_BARS
5877 x_set_toolkit_horizontal_scroll_bar_thumb (bar
, portion
, position
, whole
);
5878 #else /* not USE_TOOLKIT_SCROLL_BARS */
5879 /* Set the scroll bar's current state, unless we're currently being
5881 if (bar
->dragging
== -1)
5883 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, width
);
5886 x_scroll_bar_set_handle (bar
, 0, left_range
, 0);
5889 int start
= ((double) position
* left_range
) / whole
;
5890 int end
= ((double) (position
+ portion
) * left_range
) / whole
;
5891 x_scroll_bar_set_handle (bar
, start
, end
, 0);
5894 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5896 XSETVECTOR (barobj
, bar
);
5897 wset_horizontal_scroll_bar (w
, barobj
);
5901 /* The following three hooks are used when we're doing a thorough
5902 redisplay of the frame. We don't explicitly know which scroll bars
5903 are going to be deleted, because keeping track of when windows go
5904 away is a real pain - "Can you say set-window-configuration, boys
5905 and girls?" Instead, we just assert at the beginning of redisplay
5906 that *all* scroll bars are to be removed, and then save a scroll bar
5907 from the fiery pit when we actually redisplay its window. */
5909 /* Arrange for all scroll bars on FRAME to be removed at the next call
5910 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
5911 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
5914 XTcondemn_scroll_bars (struct frame
*frame
)
5916 if (!NILP (FRAME_SCROLL_BARS (frame
)))
5918 if (!NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
5920 /* Prepend scrollbars to already condemned ones. */
5921 Lisp_Object last
= FRAME_SCROLL_BARS (frame
);
5923 while (!NILP (XSCROLL_BAR (last
)->next
))
5924 last
= XSCROLL_BAR (last
)->next
;
5926 XSCROLL_BAR (last
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
5927 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= last
;
5930 fset_condemned_scroll_bars (frame
, FRAME_SCROLL_BARS (frame
));
5931 fset_scroll_bars (frame
, Qnil
);
5936 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
5937 Note that WINDOW isn't necessarily condemned at all. */
5940 XTredeem_scroll_bar (struct window
*w
)
5942 struct scroll_bar
*bar
;
5946 /* We can't redeem this window's scroll bar if it doesn't have one. */
5947 if (NILP (w
->vertical_scroll_bar
) && NILP (w
->horizontal_scroll_bar
))
5950 if (!NILP (w
->vertical_scroll_bar
) && WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
5952 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5953 /* Unlink it from the condemned list. */
5954 f
= XFRAME (WINDOW_FRAME (w
));
5955 if (NILP (bar
->prev
))
5957 /* If the prev pointer is nil, it must be the first in one of
5959 if (EQ (FRAME_SCROLL_BARS (f
), w
->vertical_scroll_bar
))
5960 /* It's not condemned. Everything's fine. */
5962 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
5963 w
->vertical_scroll_bar
))
5964 fset_condemned_scroll_bars (f
, bar
->next
);
5966 /* If its prev pointer is nil, it must be at the front of
5967 one or the other! */
5971 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
5973 if (! NILP (bar
->next
))
5974 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
5976 bar
->next
= FRAME_SCROLL_BARS (f
);
5978 XSETVECTOR (barobj
, bar
);
5979 fset_scroll_bars (f
, barobj
);
5980 if (! NILP (bar
->next
))
5981 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
5985 if (!NILP (w
->horizontal_scroll_bar
) && WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w
))
5987 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
5988 /* Unlink it from the condemned list. */
5989 f
= XFRAME (WINDOW_FRAME (w
));
5990 if (NILP (bar
->prev
))
5992 /* If the prev pointer is nil, it must be the first in one of
5994 if (EQ (FRAME_SCROLL_BARS (f
), w
->horizontal_scroll_bar
))
5995 /* It's not condemned. Everything's fine. */
5997 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
5998 w
->horizontal_scroll_bar
))
5999 fset_condemned_scroll_bars (f
, bar
->next
);
6001 /* If its prev pointer is nil, it must be at the front of
6002 one or the other! */
6006 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
6008 if (! NILP (bar
->next
))
6009 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
6011 bar
->next
= FRAME_SCROLL_BARS (f
);
6013 XSETVECTOR (barobj
, bar
);
6014 fset_scroll_bars (f
, barobj
);
6015 if (! NILP (bar
->next
))
6016 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
6020 /* Remove all scroll bars on FRAME that haven't been saved since the
6021 last call to `*condemn_scroll_bars_hook'. */
6024 XTjudge_scroll_bars (struct frame
*f
)
6026 Lisp_Object bar
, next
;
6028 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
6030 /* Clear out the condemned list now so we won't try to process any
6031 more events on the hapless scroll bars. */
6032 fset_condemned_scroll_bars (f
, Qnil
);
6034 for (; ! NILP (bar
); bar
= next
)
6036 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
6038 x_scroll_bar_remove (b
);
6041 b
->next
= b
->prev
= Qnil
;
6044 /* Now there should be no references to the condemned scroll bars,
6045 and they should get garbage-collected. */
6049 #ifndef USE_TOOLKIT_SCROLL_BARS
6050 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
6051 is a no-op when using toolkit scroll bars.
6053 This may be called from a signal handler, so we have to ignore GC
6057 x_scroll_bar_expose (struct scroll_bar
*bar
, const XEvent
*event
)
6059 Window w
= bar
->x_window
;
6060 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6061 GC gc
= f
->output_data
.x
->normal_gc
;
6065 x_scroll_bar_set_handle (bar
, bar
->start
, bar
->end
, 1);
6067 /* Switch to scroll bar foreground color. */
6068 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
6069 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
6070 f
->output_data
.x
->scroll_bar_foreground_pixel
);
6072 /* Draw a one-pixel border just inside the edges of the scroll bar. */
6073 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
6074 /* x, y, width, height */
6075 0, 0, bar
->width
- 1, bar
->height
- 1);
6077 /* Restore the foreground color of the GC if we changed it above. */
6078 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
6079 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
6080 FRAME_FOREGROUND_PIXEL (f
));
6085 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6087 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
6088 is set to something other than NO_EVENT, it is enqueued.
6090 This may be called from a signal handler, so we have to ignore GC
6095 x_scroll_bar_handle_click (struct scroll_bar
*bar
,
6096 const XEvent
*event
,
6097 struct input_event
*emacs_event
)
6099 if (! WINDOWP (bar
->window
))
6102 emacs_event
->kind
= (bar
->horizontal
6103 ? HORIZONTAL_SCROLL_BAR_CLICK_EVENT
6104 : SCROLL_BAR_CLICK_EVENT
);
6105 emacs_event
->code
= event
->xbutton
.button
- Button1
;
6106 emacs_event
->modifiers
6107 = (x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO
6108 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
6109 event
->xbutton
.state
)
6110 | (event
->type
== ButtonRelease
6113 emacs_event
->frame_or_window
= bar
->window
;
6114 emacs_event
->arg
= Qnil
;
6115 emacs_event
->timestamp
= event
->xbutton
.time
;
6116 if (bar
->horizontal
)
6119 = HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
6120 int x
= event
->xbutton
.x
- HORIZONTAL_SCROLL_BAR_LEFT_BORDER
;
6123 if (x
> left_range
) x
= left_range
;
6126 emacs_event
->part
= scroll_bar_before_handle
;
6127 else if (x
< bar
->end
+ HORIZONTAL_SCROLL_BAR_MIN_HANDLE
)
6128 emacs_event
->part
= scroll_bar_horizontal_handle
;
6130 emacs_event
->part
= scroll_bar_after_handle
;
6132 #ifndef USE_TOOLKIT_SCROLL_BARS
6133 /* If the user has released the handle, set it to its final position. */
6134 if (event
->type
== ButtonRelease
&& bar
->dragging
!= -1)
6136 int new_start
= - bar
->dragging
;
6137 int new_end
= new_start
+ bar
->end
- bar
->start
;
6139 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
6144 XSETINT (emacs_event
->x
, left_range
);
6145 XSETINT (emacs_event
->y
, x
);
6150 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
6151 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
6154 if (y
> top_range
) y
= top_range
;
6157 emacs_event
->part
= scroll_bar_above_handle
;
6158 else if (y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
6159 emacs_event
->part
= scroll_bar_handle
;
6161 emacs_event
->part
= scroll_bar_below_handle
;
6163 #ifndef USE_TOOLKIT_SCROLL_BARS
6164 /* If the user has released the handle, set it to its final position. */
6165 if (event
->type
== ButtonRelease
&& bar
->dragging
!= -1)
6167 int new_start
= y
- bar
->dragging
;
6168 int new_end
= new_start
+ bar
->end
- bar
->start
;
6170 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
6175 XSETINT (emacs_event
->x
, y
);
6176 XSETINT (emacs_event
->y
, top_range
);
6180 #ifndef USE_TOOLKIT_SCROLL_BARS
6182 /* Handle some mouse motion while someone is dragging the scroll bar.
6184 This may be called from a signal handler, so we have to ignore GC
6188 x_scroll_bar_note_movement (struct scroll_bar
*bar
,
6189 const XMotionEvent
*event
)
6191 struct frame
*f
= XFRAME (XWINDOW (bar
->window
)->frame
);
6192 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
6194 dpyinfo
->last_mouse_movement_time
= event
->time
;
6195 dpyinfo
->last_mouse_scroll_bar
= bar
;
6198 /* If we're dragging the bar, display it. */
6199 if (bar
->dragging
!= -1)
6201 /* Where should the handle be now? */
6202 int new_start
= event
->y
- bar
->dragging
;
6204 if (new_start
!= bar
->start
)
6206 int new_end
= new_start
+ bar
->end
- bar
->start
;
6208 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
6213 #endif /* !USE_TOOLKIT_SCROLL_BARS */
6215 /* Return information to the user about the current position of the mouse
6216 on the scroll bar. */
6219 x_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
6220 enum scroll_bar_part
*part
, Lisp_Object
*x
,
6221 Lisp_Object
*y
, Time
*timestamp
)
6223 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
6224 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
6225 Window w
= bar
->x_window
;
6226 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6228 Window dummy_window
;
6230 unsigned int dummy_mask
;
6234 /* Get the mouse's position relative to the scroll bar window, and
6236 if (XQueryPointer (FRAME_X_DISPLAY (f
), w
,
6238 /* Root, child, root x and root y. */
6239 &dummy_window
, &dummy_window
,
6240 &dummy_coord
, &dummy_coord
,
6242 /* Position relative to scroll bar. */
6245 /* Mouse buttons and modifier keys. */
6248 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
6250 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
6252 if (bar
->dragging
!= -1)
6253 win_y
-= bar
->dragging
;
6257 if (win_y
> top_range
)
6261 *bar_window
= bar
->window
;
6263 if (bar
->dragging
!= -1)
6264 *part
= scroll_bar_handle
;
6265 else if (win_y
< bar
->start
)
6266 *part
= scroll_bar_above_handle
;
6267 else if (win_y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
6268 *part
= scroll_bar_handle
;
6270 *part
= scroll_bar_below_handle
;
6272 XSETINT (*x
, win_y
);
6273 XSETINT (*y
, top_range
);
6276 dpyinfo
->last_mouse_scroll_bar
= NULL
;
6277 *timestamp
= dpyinfo
->last_mouse_movement_time
;
6284 /* Return information to the user about the current position of the mouse
6285 on the scroll bar. */
6288 x_horizontal_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
6289 enum scroll_bar_part
*part
, Lisp_Object
*x
,
6290 Lisp_Object
*y
, Time
*timestamp
)
6292 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
6293 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
6294 Window w
= bar
->x_window
;
6295 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6297 Window dummy_window
;
6299 unsigned int dummy_mask
;
6303 /* Get the mouse's position relative to the scroll bar window, and
6305 if (XQueryPointer (FRAME_X_DISPLAY (f
), w
,
6307 /* Root, child, root x and root y. */
6308 &dummy_window
, &dummy_window
,
6309 &dummy_coord
, &dummy_coord
,
6311 /* Position relative to scroll bar. */
6314 /* Mouse buttons and modifier keys. */
6317 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
6319 win_x
-= HORIZONTAL_SCROLL_BAR_LEFT_BORDER
;
6321 if (bar
->dragging
!= -1)
6322 win_x
-= bar
->dragging
;
6326 if (win_x
> left_range
)
6330 *bar_window
= bar
->window
;
6332 if (bar
->dragging
!= -1)
6333 *part
= scroll_bar_horizontal_handle
;
6334 else if (win_x
< bar
->start
)
6335 *part
= scroll_bar_before_handle
;
6336 else if (win_x
< bar
->end
+ HORIZONTAL_SCROLL_BAR_MIN_HANDLE
)
6337 *part
= scroll_bar_handle
;
6339 *part
= scroll_bar_after_handle
;
6341 XSETINT (*y
, win_x
);
6342 XSETINT (*x
, left_range
);
6345 dpyinfo
->last_mouse_scroll_bar
= NULL
;
6346 *timestamp
= dpyinfo
->last_mouse_movement_time
;
6353 /* The screen has been cleared so we may have changed foreground or
6354 background colors, and the scroll bars may need to be redrawn.
6355 Clear out the scroll bars, and ask for expose events, so we can
6359 x_scroll_bar_clear (struct frame
*f
)
6361 #ifndef USE_TOOLKIT_SCROLL_BARS
6364 /* We can have scroll bars even if this is 0,
6365 if we just turned off scroll bar mode.
6366 But in that case we should not clear them. */
6367 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
6368 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
6369 bar
= XSCROLL_BAR (bar
)->next
)
6370 XClearArea (FRAME_X_DISPLAY (f
),
6371 XSCROLL_BAR (bar
)->x_window
,
6373 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6376 #ifdef ENABLE_CHECKING
6378 /* Record the last 100 characters stored
6379 to help debug the loss-of-chars-during-GC problem. */
6381 static int temp_index
;
6382 static short temp_buffer
[100];
6384 #define STORE_KEYSYM_FOR_DEBUG(keysym) \
6385 if (temp_index == ARRAYELTS (temp_buffer)) \
6387 temp_buffer[temp_index++] = (keysym)
6389 #else /* not ENABLE_CHECKING */
6391 #define STORE_KEYSYM_FOR_DEBUG(keysym) ((void)0)
6393 #endif /* ENABLE_CHECKING */
6395 /* Set this to nonzero to fake an "X I/O error"
6396 on a particular display. */
6398 static struct x_display_info
*XTread_socket_fake_io_error
;
6400 /* When we find no input here, we occasionally do a no-op command
6401 to verify that the X server is still running and we can still talk with it.
6402 We try all the open displays, one by one.
6403 This variable is used for cycling thru the displays. */
6405 static struct x_display_info
*next_noop_dpyinfo
;
6414 /* Filter events for the current X input method.
6415 DPYINFO is the display this event is for.
6416 EVENT is the X event to filter.
6418 Returns non-zero if the event was filtered, caller shall not process
6420 Returns zero if event is wasn't filtered. */
6424 x_filter_event (struct x_display_info
*dpyinfo
, XEvent
*event
)
6426 /* XFilterEvent returns non-zero if the input method has
6427 consumed the event. We pass the frame's X window to
6428 XFilterEvent because that's the one for which the IC
6431 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
6432 event
->xclient
.window
);
6434 return XFilterEvent (event
, f1
? FRAME_X_WINDOW (f1
) : None
);
6439 static int current_count
;
6440 static int current_finish
;
6441 static struct input_event
*current_hold_quit
;
6443 /* This is the filter function invoked by the GTK event loop.
6444 It is invoked before the XEvent is translated to a GdkEvent,
6445 so we have a chance to act on the event before GTK. */
6446 static GdkFilterReturn
6447 event_handler_gdk (GdkXEvent
*gxev
, GdkEvent
*ev
, gpointer data
)
6449 XEvent
*xev
= (XEvent
*) gxev
;
6452 if (current_count
>= 0)
6454 struct x_display_info
*dpyinfo
;
6456 dpyinfo
= x_display_info_for_display (xev
->xany
.display
);
6459 /* Filter events for the current X input method.
6460 GTK calls XFilterEvent but not for key press and release,
6461 so we do it here. */
6462 if ((xev
->type
== KeyPress
|| xev
->type
== KeyRelease
)
6464 && x_filter_event (dpyinfo
, xev
))
6467 return GDK_FILTER_REMOVE
;
6472 current_finish
= X_EVENT_NORMAL
;
6475 += handle_one_xevent (dpyinfo
, xev
, ¤t_finish
,
6479 current_finish
= x_dispatch_event (xev
, xev
->xany
.display
);
6483 if (current_finish
== X_EVENT_GOTO_OUT
|| current_finish
== X_EVENT_DROP
)
6484 return GDK_FILTER_REMOVE
;
6486 return GDK_FILTER_CONTINUE
;
6488 #endif /* USE_GTK */
6491 static void xembed_send_message (struct frame
*f
, Time
,
6492 enum xembed_message
,
6493 long detail
, long data1
, long data2
);
6496 x_net_wm_state (struct frame
*f
, Window window
)
6498 int value
= FULLSCREEN_NONE
;
6499 Lisp_Object lval
= Qnil
;
6502 (void)get_current_wm_state (f
, window
, &value
, &sticky
);
6506 case FULLSCREEN_WIDTH
:
6509 case FULLSCREEN_HEIGHT
:
6512 case FULLSCREEN_BOTH
:
6515 case FULLSCREEN_MAXIMIZED
:
6520 store_frame_param (f
, Qfullscreen
, lval
);
6521 /** store_frame_param (f, Qsticky, sticky ? Qt : Qnil); **/
6524 /* Handles the XEvent EVENT on display DPYINFO.
6526 *FINISH is X_EVENT_GOTO_OUT if caller should stop reading events.
6527 *FINISH is zero if caller should continue reading events.
6528 *FINISH is X_EVENT_DROP if event should not be passed to the toolkit.
6529 *EVENT is unchanged unless we're processing KeyPress event.
6531 We return the number of characters stored into the buffer. */
6534 handle_one_xevent (struct x_display_info
*dpyinfo
,
6535 const XEvent
*event
,
6536 int *finish
, struct input_event
*hold_quit
)
6539 struct input_event ie
;
6540 struct selection_input_event sie
;
6544 ptrdiff_t nbytes
= 0;
6545 struct frame
*any
, *f
= NULL
;
6546 struct coding_system coding
;
6547 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
6548 /* This holds the state XLookupString needs to implement dead keys
6549 and other tricks known as "compose processing". _X Window System_
6550 says that a portable program can't use this, but Stephen Gildea assures
6551 me that letting the compiler initialize it to zeros will work okay. */
6552 static XComposeStatus compose_status
;
6556 *finish
= X_EVENT_NORMAL
;
6558 EVENT_INIT (inev
.ie
);
6559 inev
.ie
.kind
= NO_EVENT
;
6562 any
= x_any_window_to_frame (dpyinfo
, event
->xany
.window
);
6564 if (any
&& any
->wait_event_type
== event
->type
)
6565 any
->wait_event_type
= 0; /* Indicates we got it. */
6567 switch (event
->type
)
6571 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_protocols
6572 && event
->xclient
.format
== 32)
6574 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_take_focus
)
6576 /* Use the value returned by x_any_window_to_frame
6577 because this could be the shell widget window
6578 if the frame has no title bar. */
6581 /* Not quite sure this is needed -pd */
6582 if (f
&& FRAME_XIC (f
))
6583 XSetICFocus (FRAME_XIC (f
));
6585 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
6586 instructs the WM to set the input focus automatically for
6587 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
6588 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
6589 it has set the focus. So, XSetInputFocus below is not
6592 The call to XSetInputFocus below has also caused trouble. In
6593 cases where the XSetInputFocus done by the WM and the one
6594 below are temporally close (on a fast machine), the call
6595 below can generate additional FocusIn events which confuse
6598 /* Since we set WM_TAKE_FOCUS, we must call
6599 XSetInputFocus explicitly. But not if f is null,
6600 since that might be an event for a deleted frame. */
6603 Display
*d
= event
->xclient
.display
;
6604 /* Catch and ignore errors, in case window has been
6605 iconified by a window manager such as GWM. */
6607 XSetInputFocus (d
, event
->xclient
.window
,
6608 /* The ICCCM says this is
6609 the only valid choice. */
6611 event
->xclient
.data
.l
[1]);
6612 /* This is needed to detect the error
6613 if there is an error. */
6615 x_uncatch_errors ();
6617 /* Not certain about handling scroll bars here */
6622 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_save_yourself
)
6624 /* Save state modify the WM_COMMAND property to
6625 something which can reinstate us. This notifies
6626 the session manager, who's looking for such a
6627 PropertyNotify. Can restart processing when
6628 a keyboard or mouse event arrives. */
6629 /* If we have a session manager, don't set this.
6630 KDE will then start two Emacsen, one for the
6631 session manager and one for this. */
6633 if (! x_session_have_connection ())
6636 f
= x_top_window_to_frame (dpyinfo
,
6637 event
->xclient
.window
);
6638 /* This is just so we only give real data once
6639 for a single Emacs process. */
6640 if (f
== SELECTED_FRAME ())
6641 XSetCommand (FRAME_X_DISPLAY (f
),
6642 event
->xclient
.window
,
6643 initial_argv
, initial_argc
);
6645 XSetCommand (FRAME_X_DISPLAY (f
),
6646 event
->xclient
.window
,
6652 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_delete_window
)
6656 goto OTHER
; /* May be a dialog that is to be removed */
6658 inev
.ie
.kind
= DELETE_WINDOW_EVENT
;
6659 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6666 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_configure_denied
)
6669 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_window_moved
)
6672 f
= x_window_to_frame (dpyinfo
, event
->xclient
.window
);
6674 new_x
= event
->xclient
.data
.s
[0];
6675 new_y
= event
->xclient
.data
.s
[1];
6679 f
->left_pos
= new_x
;
6686 if (event
->xclient
.message_type
== dpyinfo
->Xatom_editres
)
6690 _XEditResCheckMessages (f
->output_data
.x
->widget
,
6691 NULL
, (XEvent
*) event
, NULL
);
6694 #endif /* HACK_EDITRES */
6696 if (event
->xclient
.message_type
== dpyinfo
->Xatom_DONE
6697 || event
->xclient
.message_type
== dpyinfo
->Xatom_PAGE
)
6699 /* Ghostview job completed. Kill it. We could
6700 reply with "Next" if we received "Page", but we
6701 currently never do because we are interested in
6702 images, only, which should have 1 page. */
6703 Pixmap pixmap
= (Pixmap
) event
->xclient
.data
.l
[1];
6704 f
= x_window_to_frame (dpyinfo
, event
->xclient
.window
);
6707 x_kill_gs_process (pixmap
, f
);
6708 expose_frame (f
, 0, 0, 0, 0);
6712 #ifdef USE_TOOLKIT_SCROLL_BARS
6713 /* Scroll bar callbacks send a ClientMessage from which
6714 we construct an input_event. */
6715 if (event
->xclient
.message_type
== dpyinfo
->Xatom_Scrollbar
)
6717 x_scroll_bar_to_input_event (event
, &inev
.ie
);
6718 *finish
= X_EVENT_GOTO_OUT
;
6721 else if (event
->xclient
.message_type
== dpyinfo
->Xatom_Horizontal_Scrollbar
)
6723 x_horizontal_scroll_bar_to_input_event (event
, &inev
.ie
);
6724 *finish
= X_EVENT_GOTO_OUT
;
6727 #endif /* USE_TOOLKIT_SCROLL_BARS */
6729 /* XEmbed messages from the embedder (if any). */
6730 if (event
->xclient
.message_type
== dpyinfo
->Xatom_XEMBED
)
6732 enum xembed_message msg
= event
->xclient
.data
.l
[1];
6733 if (msg
== XEMBED_FOCUS_IN
|| msg
== XEMBED_FOCUS_OUT
)
6734 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
6736 *finish
= X_EVENT_GOTO_OUT
;
6740 xft_settings_event (dpyinfo
, event
);
6745 if (x_handle_dnd_message (f
, &event
->xclient
, dpyinfo
, &inev
.ie
))
6746 *finish
= X_EVENT_DROP
;
6750 case SelectionNotify
:
6751 dpyinfo
->last_user_time
= event
->xselection
.time
;
6752 #ifdef USE_X_TOOLKIT
6753 if (! x_window_to_frame (dpyinfo
, event
->xselection
.requestor
))
6755 #endif /* not USE_X_TOOLKIT */
6756 x_handle_selection_notify (&event
->xselection
);
6759 case SelectionClear
: /* Someone has grabbed ownership. */
6760 dpyinfo
->last_user_time
= event
->xselectionclear
.time
;
6761 #ifdef USE_X_TOOLKIT
6762 if (! x_window_to_frame (dpyinfo
, event
->xselectionclear
.window
))
6764 #endif /* USE_X_TOOLKIT */
6766 const XSelectionClearEvent
*eventp
= &event
->xselectionclear
;
6768 inev
.ie
.kind
= SELECTION_CLEAR_EVENT
;
6769 SELECTION_EVENT_DPYINFO (&inev
.sie
) = dpyinfo
;
6770 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
6771 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
6775 case SelectionRequest
: /* Someone wants our selection. */
6776 dpyinfo
->last_user_time
= event
->xselectionrequest
.time
;
6777 #ifdef USE_X_TOOLKIT
6778 if (!x_window_to_frame (dpyinfo
, event
->xselectionrequest
.owner
))
6780 #endif /* USE_X_TOOLKIT */
6782 const XSelectionRequestEvent
*eventp
= &event
->xselectionrequest
;
6784 inev
.ie
.kind
= SELECTION_REQUEST_EVENT
;
6785 SELECTION_EVENT_DPYINFO (&inev
.sie
) = dpyinfo
;
6786 SELECTION_EVENT_REQUESTOR (&inev
.sie
) = eventp
->requestor
;
6787 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
6788 SELECTION_EVENT_TARGET (&inev
.sie
) = eventp
->target
;
6789 SELECTION_EVENT_PROPERTY (&inev
.sie
) = eventp
->property
;
6790 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
6794 case PropertyNotify
:
6795 dpyinfo
->last_user_time
= event
->xproperty
.time
;
6796 f
= x_top_window_to_frame (dpyinfo
, event
->xproperty
.window
);
6797 if (f
&& event
->xproperty
.atom
== dpyinfo
->Xatom_net_wm_state
)
6798 if (x_handle_net_wm_state (f
, &event
->xproperty
)
6799 && FRAME_ICONIFIED_P (f
)
6800 && f
->output_data
.x
->net_wm_state_hidden_seen
)
6802 /* Gnome shell does not iconify us when C-z is pressed.
6803 It hides the frame. So if our state says we aren't
6804 hidden anymore, treat it as deiconified. */
6805 SET_FRAME_VISIBLE (f
, 1);
6806 SET_FRAME_ICONIFIED (f
, 0);
6807 f
->output_data
.x
->has_been_visible
= 1;
6808 f
->output_data
.x
->net_wm_state_hidden_seen
= 0;
6809 inev
.ie
.kind
= DEICONIFY_EVENT
;
6810 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6813 x_handle_property_notify (&event
->xproperty
);
6814 xft_settings_event (dpyinfo
, event
);
6817 case ReparentNotify
:
6818 f
= x_top_window_to_frame (dpyinfo
, event
->xreparent
.window
);
6821 f
->output_data
.x
->parent_desc
= event
->xreparent
.parent
;
6822 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
6824 /* Perhaps reparented due to a WM restart. Reset this. */
6825 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_UNKNOWN
;
6826 FRAME_DISPLAY_INFO (f
)->net_supported_window
= 0;
6828 x_set_frame_alpha (f
);
6833 f
= x_window_to_frame (dpyinfo
, event
->xexpose
.window
);
6836 if (!FRAME_VISIBLE_P (f
))
6838 SET_FRAME_VISIBLE (f
, 1);
6839 SET_FRAME_ICONIFIED (f
, 0);
6840 f
->output_data
.x
->has_been_visible
= 1;
6841 SET_FRAME_GARBAGED (f
);
6846 /* This seems to be needed for GTK 2.6 and later, see
6847 http://debbugs.gnu.org/cgi/bugreport.cgi?bug=15398. */
6848 x_clear_area (event
->xexpose
.display
,
6849 event
->xexpose
.window
,
6850 event
->xexpose
.x
, event
->xexpose
.y
,
6851 event
->xexpose
.width
, event
->xexpose
.height
);
6853 expose_frame (f
, event
->xexpose
.x
, event
->xexpose
.y
,
6854 event
->xexpose
.width
, event
->xexpose
.height
);
6859 #ifndef USE_TOOLKIT_SCROLL_BARS
6860 struct scroll_bar
*bar
;
6862 #if defined USE_LUCID
6863 /* Submenus of the Lucid menu bar aren't widgets
6864 themselves, so there's no way to dispatch events
6865 to them. Recognize this case separately. */
6867 Widget widget
= x_window_to_menu_bar (event
->xexpose
.window
);
6869 xlwmenu_redisplay (widget
);
6871 #endif /* USE_LUCID */
6873 #ifdef USE_TOOLKIT_SCROLL_BARS
6874 /* Dispatch event to the widget. */
6876 #else /* not USE_TOOLKIT_SCROLL_BARS */
6877 bar
= x_window_to_scroll_bar (event
->xexpose
.display
,
6878 event
->xexpose
.window
, 2);
6881 x_scroll_bar_expose (bar
, event
);
6882 #ifdef USE_X_TOOLKIT
6885 #endif /* USE_X_TOOLKIT */
6886 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6890 case GraphicsExpose
: /* This occurs when an XCopyArea's
6891 source area was obscured or not
6893 f
= x_window_to_frame (dpyinfo
, event
->xgraphicsexpose
.drawable
);
6895 expose_frame (f
, event
->xgraphicsexpose
.x
,
6896 event
->xgraphicsexpose
.y
,
6897 event
->xgraphicsexpose
.width
,
6898 event
->xgraphicsexpose
.height
);
6899 #ifdef USE_X_TOOLKIT
6902 #endif /* USE_X_TOOLKIT */
6905 case NoExpose
: /* This occurs when an XCopyArea's
6906 source area was completely
6911 /* Redo the mouse-highlight after the tooltip has gone. */
6912 if (event
->xunmap
.window
== tip_window
)
6915 x_redo_mouse_highlight (dpyinfo
);
6918 f
= x_top_window_to_frame (dpyinfo
, event
->xunmap
.window
);
6919 if (f
) /* F may no longer exist if
6920 the frame was deleted. */
6922 bool visible
= FRAME_VISIBLE_P (f
);
6923 /* While a frame is unmapped, display generation is
6924 disabled; you don't want to spend time updating a
6925 display that won't ever be seen. */
6926 SET_FRAME_VISIBLE (f
, 0);
6927 /* We can't distinguish, from the event, whether the window
6928 has become iconified or invisible. So assume, if it
6929 was previously visible, than now it is iconified.
6930 But x_make_frame_invisible clears both
6931 the visible flag and the iconified flag;
6932 and that way, we know the window is not iconified now. */
6933 if (visible
|| FRAME_ICONIFIED_P (f
))
6935 SET_FRAME_ICONIFIED (f
, 1);
6936 inev
.ie
.kind
= ICONIFY_EVENT
;
6937 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6943 if (event
->xmap
.window
== tip_window
)
6944 /* The tooltip has been drawn already. Avoid
6945 the SET_FRAME_GARBAGED below. */
6948 /* We use x_top_window_to_frame because map events can
6949 come for sub-windows and they don't mean that the
6950 frame is visible. */
6951 f
= x_top_window_to_frame (dpyinfo
, event
->xmap
.window
);
6954 bool iconified
= FRAME_ICONIFIED_P (f
);
6956 /* Check if fullscreen was specified before we where mapped the
6957 first time, i.e. from the command line. */
6958 if (!f
->output_data
.x
->has_been_visible
)
6959 x_check_fullscreen (f
);
6961 SET_FRAME_VISIBLE (f
, 1);
6962 SET_FRAME_ICONIFIED (f
, 0);
6963 f
->output_data
.x
->has_been_visible
= 1;
6967 inev
.ie
.kind
= DEICONIFY_EVENT
;
6968 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6970 else if (! NILP (Vframe_list
) && ! NILP (XCDR (Vframe_list
)))
6971 /* Force a redisplay sooner or later to update the
6972 frame titles in case this is the second frame. */
6973 record_asynch_buffer_change ();
6976 xg_frame_resized (f
, -1, -1);
6983 dpyinfo
->last_user_time
= event
->xkey
.time
;
6984 ignore_next_mouse_click_timeout
= 0;
6986 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6987 /* Dispatch KeyPress events when in menu. */
6988 if (popup_activated ())
6994 #if ! defined (USE_GTK)
6995 /* If mouse-highlight is an integer, input clears out
6996 mouse highlighting. */
6997 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
6999 || !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
)))
7001 clear_mouse_face (hlinfo
);
7002 hlinfo
->mouse_face_hidden
= 1;
7006 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
7009 /* Scroll bars consume key events, but we want
7010 the keys to go to the scroll bar's frame. */
7011 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
7012 event
->xkey
.window
);
7013 if (widget
&& XmIsScrollBar (widget
))
7015 widget
= XtParent (widget
);
7016 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
7019 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
7023 KeySym keysym
, orig_keysym
;
7024 /* al%imercury@uunet.uu.net says that making this 81
7025 instead of 80 fixed a bug whereby meta chars made
7028 It seems that some version of XmbLookupString has
7029 a bug of not returning XBufferOverflow in
7030 status_return even if the input is too long to
7031 fit in 81 bytes. So, we must prepare sufficient
7032 bytes for copy_buffer. 513 bytes (256 chars for
7033 two-byte character set) seems to be a fairly good
7034 approximation. -- 2000.8.10 handa@etl.go.jp */
7035 unsigned char copy_buffer
[513];
7036 unsigned char *copy_bufptr
= copy_buffer
;
7037 int copy_bufsiz
= sizeof (copy_buffer
);
7039 Lisp_Object coding_system
= Qlatin_1
;
7041 /* Event will be modified. */
7042 XKeyEvent xkey
= event
->xkey
;
7045 /* Don't pass keys to GTK. A Tab will shift focus to the
7046 tool bar in GTK 2.4. Keys will still go to menus and
7047 dialogs because in that case popup_activated is nonzero
7049 *finish
= X_EVENT_DROP
;
7052 xkey
.state
|= x_emacs_to_x_modifiers (FRAME_DISPLAY_INFO (f
),
7053 extra_keyboard_modifiers
);
7054 modifiers
= xkey
.state
;
7056 /* This will have to go some day... */
7058 /* make_lispy_event turns chars into control chars.
7059 Don't do it here because XLookupString is too eager. */
7060 xkey
.state
&= ~ControlMask
;
7061 xkey
.state
&= ~(dpyinfo
->meta_mod_mask
7062 | dpyinfo
->super_mod_mask
7063 | dpyinfo
->hyper_mod_mask
7064 | dpyinfo
->alt_mod_mask
);
7066 /* In case Meta is ComposeCharacter,
7067 clear its status. According to Markus Ehrnsperger
7068 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
7069 this enables ComposeCharacter to work whether or
7070 not it is combined with Meta. */
7071 if (modifiers
& dpyinfo
->meta_mod_mask
)
7072 memset (&compose_status
, 0, sizeof (compose_status
));
7077 Status status_return
;
7079 coding_system
= Vlocale_coding_system
;
7080 nbytes
= XmbLookupString (FRAME_XIC (f
),
7081 &xkey
, (char *) copy_bufptr
,
7082 copy_bufsiz
, &keysym
,
7084 if (status_return
== XBufferOverflow
)
7086 copy_bufsiz
= nbytes
+ 1;
7087 copy_bufptr
= alloca (copy_bufsiz
);
7088 nbytes
= XmbLookupString (FRAME_XIC (f
),
7089 &xkey
, (char *) copy_bufptr
,
7090 copy_bufsiz
, &keysym
,
7093 /* Xutf8LookupString is a new but already deprecated interface. -stef */
7094 if (status_return
== XLookupNone
)
7096 else if (status_return
== XLookupChars
)
7101 else if (status_return
!= XLookupKeySym
7102 && status_return
!= XLookupBoth
)
7106 nbytes
= XLookupString (&xkey
, (char *) copy_bufptr
,
7107 copy_bufsiz
, &keysym
,
7110 nbytes
= XLookupString (&xkey
, (char *) copy_bufptr
,
7111 copy_bufsiz
, &keysym
,
7115 /* If not using XIM/XIC, and a compose sequence is in progress,
7116 we break here. Otherwise, chars_matched is always 0. */
7117 if (compose_status
.chars_matched
> 0 && nbytes
== 0)
7120 memset (&compose_status
, 0, sizeof (compose_status
));
7121 orig_keysym
= keysym
;
7123 /* Common for all keysym input events. */
7124 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7126 = x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), modifiers
);
7127 inev
.ie
.timestamp
= xkey
.time
;
7129 /* First deal with keysyms which have defined
7130 translations to characters. */
7131 if (keysym
>= 32 && keysym
< 128)
7132 /* Avoid explicitly decoding each ASCII character. */
7134 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
7135 inev
.ie
.code
= keysym
;
7139 /* Keysyms directly mapped to Unicode characters. */
7140 if (keysym
>= 0x01000000 && keysym
<= 0x0110FFFF)
7142 if (keysym
< 0x01000080)
7143 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
7145 inev
.ie
.kind
= MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
7146 inev
.ie
.code
= keysym
& 0xFFFFFF;
7150 /* Now non-ASCII. */
7151 if (HASH_TABLE_P (Vx_keysym_table
)
7152 && (c
= Fgethash (make_number (keysym
),
7157 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (XFASTINT (c
))
7158 ? ASCII_KEYSTROKE_EVENT
7159 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
7160 inev
.ie
.code
= XFASTINT (c
);
7164 /* Random non-modifier sorts of keysyms. */
7165 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
7166 || keysym
== XK_Delete
7167 #ifdef XK_ISO_Left_Tab
7168 || (keysym
>= XK_ISO_Left_Tab
7169 && keysym
<= XK_ISO_Enter
)
7171 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
7172 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
7174 /* This recognizes the "extended function
7175 keys". It seems there's no cleaner way.
7176 Test IsModifierKey to avoid handling
7177 mode_switch incorrectly. */
7178 || (XK_Select
<= keysym
&& keysym
< XK_KP_Space
)
7180 #ifdef XK_dead_circumflex
7181 || orig_keysym
== XK_dead_circumflex
7183 #ifdef XK_dead_grave
7184 || orig_keysym
== XK_dead_grave
7186 #ifdef XK_dead_tilde
7187 || orig_keysym
== XK_dead_tilde
7189 #ifdef XK_dead_diaeresis
7190 || orig_keysym
== XK_dead_diaeresis
7192 #ifdef XK_dead_macron
7193 || orig_keysym
== XK_dead_macron
7195 #ifdef XK_dead_degree
7196 || orig_keysym
== XK_dead_degree
7198 #ifdef XK_dead_acute
7199 || orig_keysym
== XK_dead_acute
7201 #ifdef XK_dead_cedilla
7202 || orig_keysym
== XK_dead_cedilla
7204 #ifdef XK_dead_breve
7205 || orig_keysym
== XK_dead_breve
7207 #ifdef XK_dead_ogonek
7208 || orig_keysym
== XK_dead_ogonek
7210 #ifdef XK_dead_caron
7211 || orig_keysym
== XK_dead_caron
7213 #ifdef XK_dead_doubleacute
7214 || orig_keysym
== XK_dead_doubleacute
7216 #ifdef XK_dead_abovedot
7217 || orig_keysym
== XK_dead_abovedot
7219 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
7220 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
7221 /* Any "vendor-specific" key is ok. */
7222 || (orig_keysym
& (1 << 28))
7223 || (keysym
!= NoSymbol
&& nbytes
== 0))
7224 && ! (IsModifierKey (orig_keysym
)
7225 /* The symbols from XK_ISO_Lock
7226 to XK_ISO_Last_Group_Lock
7227 don't have real modifiers but
7228 should be treated similarly to
7229 Mode_switch by Emacs. */
7230 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
7231 || (XK_ISO_Lock
<= orig_keysym
7232 && orig_keysym
<= XK_ISO_Last_Group_Lock
)
7236 STORE_KEYSYM_FOR_DEBUG (keysym
);
7237 /* make_lispy_event will convert this to a symbolic
7239 inev
.ie
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
7240 inev
.ie
.code
= keysym
;
7244 { /* Raw bytes, not keysym. */
7248 for (i
= 0, nchars
= 0; i
< nbytes
; i
++)
7250 if (ASCII_CHAR_P (copy_bufptr
[i
]))
7252 STORE_KEYSYM_FOR_DEBUG (copy_bufptr
[i
]);
7255 if (nchars
< nbytes
)
7257 /* Decode the input data. */
7259 /* The input should be decoded with `coding_system'
7260 which depends on which X*LookupString function
7261 we used just above and the locale. */
7262 setup_coding_system (coding_system
, &coding
);
7263 coding
.src_multibyte
= 0;
7264 coding
.dst_multibyte
= 1;
7265 /* The input is converted to events, thus we can't
7266 handle composition. Anyway, there's no XIM that
7267 gives us composition information. */
7268 coding
.common_flags
&= ~CODING_ANNOTATION_MASK
;
7270 SAFE_NALLOCA (coding
.destination
, MAX_MULTIBYTE_LENGTH
,
7272 coding
.dst_bytes
= MAX_MULTIBYTE_LENGTH
* nbytes
;
7273 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
7274 decode_coding_c_string (&coding
, copy_bufptr
, nbytes
, Qnil
);
7275 nbytes
= coding
.produced
;
7276 nchars
= coding
.produced_char
;
7277 copy_bufptr
= coding
.destination
;
7280 /* Convert the input data to a sequence of
7281 character events. */
7282 for (i
= 0; i
< nbytes
; i
+= len
)
7285 if (nchars
== nbytes
)
7286 ch
= copy_bufptr
[i
], len
= 1;
7288 ch
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
, len
);
7289 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (ch
)
7290 ? ASCII_KEYSTROKE_EVENT
7291 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
7293 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
7298 inev
.ie
.kind
= NO_EVENT
; /* Already stored above. */
7300 if (keysym
== NoSymbol
)
7303 /* FIXME: check side effects and remove this. */
7304 ((XEvent
*) event
)->xkey
= xkey
;
7308 /* Don't dispatch this event since XtDispatchEvent calls
7309 XFilterEvent, and two calls in a row may freeze the
7317 dpyinfo
->last_user_time
= event
->xkey
.time
;
7319 /* Don't dispatch this event since XtDispatchEvent calls
7320 XFilterEvent, and two calls in a row may freeze the
7328 dpyinfo
->last_user_time
= event
->xcrossing
.time
;
7329 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
7333 if (f
&& x_mouse_click_focus_ignore_position
)
7334 ignore_next_mouse_click_timeout
= event
->xmotion
.time
+ 200;
7336 /* EnterNotify counts as mouse movement,
7337 so update things that depend on mouse position. */
7338 if (f
&& !f
->output_data
.x
->hourglass_p
)
7339 note_mouse_movement (f
, &event
->xmotion
);
7341 /* We may get an EnterNotify on the buttons in the toolbar. In that
7342 case we moved out of any highlighted area and need to note this. */
7343 if (!f
&& dpyinfo
->last_mouse_glyph_frame
)
7344 note_mouse_movement (dpyinfo
->last_mouse_glyph_frame
, &event
->xmotion
);
7349 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
7353 dpyinfo
->last_user_time
= event
->xcrossing
.time
;
7354 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
7356 f
= x_top_window_to_frame (dpyinfo
, event
->xcrossing
.window
);
7359 if (f
== hlinfo
->mouse_face_mouse_frame
)
7361 /* If we move outside the frame, then we're
7362 certainly no longer on any text in the frame. */
7363 clear_mouse_face (hlinfo
);
7364 hlinfo
->mouse_face_mouse_frame
= 0;
7367 /* Generate a nil HELP_EVENT to cancel a help-echo.
7368 Do it only if there's something to cancel.
7369 Otherwise, the startup message is cleared when
7370 the mouse leaves the frame. */
7371 if (any_help_event_p
)
7375 /* See comment in EnterNotify above */
7376 else if (dpyinfo
->last_mouse_glyph_frame
)
7377 note_mouse_movement (dpyinfo
->last_mouse_glyph_frame
, &event
->xmotion
);
7382 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
7387 dpyinfo
->last_user_time
= event
->xmotion
.time
;
7388 previous_help_echo_string
= help_echo_string
;
7389 help_echo_string
= Qnil
;
7391 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
7392 : x_window_to_frame (dpyinfo
, event
->xmotion
.window
));
7394 if (hlinfo
->mouse_face_hidden
)
7396 hlinfo
->mouse_face_hidden
= 0;
7397 clear_mouse_face (hlinfo
);
7401 if (f
&& xg_event_is_for_scrollbar (f
, event
))
7407 /* Generate SELECT_WINDOW_EVENTs when needed.
7408 Don't let popup menus influence things (bug#1261). */
7409 if (!NILP (Vmouse_autoselect_window
) && !popup_activated ())
7411 static Lisp_Object last_mouse_window
;
7412 Lisp_Object window
= window_from_coordinates
7413 (f
, event
->xmotion
.x
, event
->xmotion
.y
, 0, 0);
7415 /* Window will be selected only when it is not selected now and
7416 last mouse movement event was not in it. Minibuffer window
7417 will be selected only when it is active. */
7418 if (WINDOWP (window
)
7419 && !EQ (window
, last_mouse_window
)
7420 && !EQ (window
, selected_window
)
7421 /* For click-to-focus window managers
7422 create event iff we don't leave the
7424 && (focus_follows_mouse
7425 || (EQ (XWINDOW (window
)->frame
,
7426 XWINDOW (selected_window
)->frame
))))
7428 inev
.ie
.kind
= SELECT_WINDOW_EVENT
;
7429 inev
.ie
.frame_or_window
= window
;
7431 /* Remember the last window where we saw the mouse. */
7432 last_mouse_window
= window
;
7434 if (!note_mouse_movement (f
, &event
->xmotion
))
7435 help_echo_string
= previous_help_echo_string
;
7439 #ifndef USE_TOOLKIT_SCROLL_BARS
7440 struct scroll_bar
*bar
7441 = x_window_to_scroll_bar (event
->xmotion
.display
,
7442 event
->xmotion
.window
, 2);
7445 x_scroll_bar_note_movement (bar
, &event
->xmotion
);
7446 #endif /* USE_TOOLKIT_SCROLL_BARS */
7448 /* If we move outside the frame, then we're
7449 certainly no longer on any text in the frame. */
7450 clear_mouse_face (hlinfo
);
7453 /* If the contents of the global variable help_echo_string
7454 has changed, generate a HELP_EVENT. */
7455 if (!NILP (help_echo_string
)
7456 || !NILP (previous_help_echo_string
))
7461 case ConfigureNotify
:
7462 f
= x_top_window_to_frame (dpyinfo
, event
->xconfigure
.window
);
7466 && event
->xconfigure
.window
== FRAME_X_WINDOW (f
))
7468 xg_frame_resized (f
, event
->xconfigure
.width
,
7469 event
->xconfigure
.height
);
7475 x_net_wm_state (f
, event
->xconfigure
.window
);
7477 #ifndef USE_X_TOOLKIT
7479 int width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, event
->xconfigure
.width
);
7480 int height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, event
->xconfigure
.height
);
7482 /* In the toolkit version, change_frame_size
7483 is called by the code that handles resizing
7484 of the EmacsFrame widget. */
7486 /* Even if the number of character rows and columns has
7487 not changed, the font size may have changed, so we need
7488 to check the pixel dimensions as well. */
7489 if (width
!= FRAME_TEXT_WIDTH (f
)
7490 || height
!= FRAME_TEXT_HEIGHT (f
)
7491 || event
->xconfigure
.width
!= FRAME_PIXEL_WIDTH (f
)
7492 || event
->xconfigure
.height
!= FRAME_PIXEL_HEIGHT (f
))
7494 change_frame_size (f
, width
, height
, 0, 1, 0, 1);
7495 x_clear_under_internal_border (f
);
7496 SET_FRAME_GARBAGED (f
);
7497 cancel_mouse_face (f
);
7500 /** FRAME_PIXEL_WIDTH (f) = event->xconfigure.width; **/
7501 /** FRAME_PIXEL_HEIGHT (f) = event->xconfigure.height; **/
7502 #endif /* not USE_GTK */
7506 /* GTK creates windows but doesn't map them.
7507 Only get real positions when mapped. */
7508 if (FRAME_GTK_OUTER_WIDGET (f
)
7509 && gtk_widget_get_mapped (FRAME_GTK_OUTER_WIDGET (f
)))
7511 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
7514 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
7515 xic_set_statusarea (f
);
7524 /* If we decide we want to generate an event to be seen
7525 by the rest of Emacs, we put it here. */
7526 bool tool_bar_p
= 0;
7528 memset (&compose_status
, 0, sizeof (compose_status
));
7529 dpyinfo
->last_mouse_glyph_frame
= NULL
;
7530 dpyinfo
->last_user_time
= event
->xbutton
.time
;
7532 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
7533 : x_window_to_frame (dpyinfo
, event
->xbutton
.window
));
7536 if (f
&& xg_event_is_for_scrollbar (f
, event
))
7541 #if ! defined (USE_GTK)
7542 /* Is this in the tool-bar? */
7543 if (WINDOWP (f
->tool_bar_window
)
7544 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
7547 int x
= event
->xbutton
.x
;
7548 int y
= event
->xbutton
.y
;
7550 window
= window_from_coordinates (f
, x
, y
, 0, 1);
7551 tool_bar_p
= EQ (window
, f
->tool_bar_window
);
7553 if (tool_bar_p
&& event
->xbutton
.button
< 4)
7554 handle_tool_bar_click
7555 (f
, x
, y
, event
->xbutton
.type
== ButtonPress
,
7556 x_x_to_emacs_modifiers (dpyinfo
, event
->xbutton
.state
));
7558 #endif /* !USE_GTK */
7561 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
7562 if (! popup_activated ())
7565 if (ignore_next_mouse_click_timeout
)
7567 if (event
->type
== ButtonPress
7568 && event
->xbutton
.time
> ignore_next_mouse_click_timeout
)
7570 ignore_next_mouse_click_timeout
= 0;
7571 construct_mouse_click (&inev
.ie
, &event
->xbutton
, f
);
7573 if (event
->type
== ButtonRelease
)
7574 ignore_next_mouse_click_timeout
= 0;
7577 construct_mouse_click (&inev
.ie
, &event
->xbutton
, f
);
7579 if (FRAME_X_EMBEDDED_P (f
))
7580 xembed_send_message (f
, event
->xbutton
.time
,
7581 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
7585 struct scroll_bar
*bar
7586 = x_window_to_scroll_bar (event
->xbutton
.display
,
7587 event
->xbutton
.window
, 2);
7589 #ifdef USE_TOOLKIT_SCROLL_BARS
7590 /* Make the "Ctrl-Mouse-2 splits window" work for toolkit
7592 if (bar
&& event
->xbutton
.state
& ControlMask
)
7594 x_scroll_bar_handle_click (bar
, event
, &inev
.ie
);
7595 *finish
= X_EVENT_DROP
;
7597 #else /* not USE_TOOLKIT_SCROLL_BARS */
7599 x_scroll_bar_handle_click (bar
, event
, &inev
.ie
);
7600 #endif /* not USE_TOOLKIT_SCROLL_BARS */
7603 if (event
->type
== ButtonPress
)
7605 dpyinfo
->grabbed
|= (1 << event
->xbutton
.button
);
7606 dpyinfo
->last_mouse_frame
= f
;
7607 #if ! defined (USE_GTK)
7608 if (f
&& !tool_bar_p
)
7609 f
->last_tool_bar_item
= -1;
7610 #endif /* not USE_GTK */
7613 dpyinfo
->grabbed
&= ~(1 << event
->xbutton
.button
);
7615 /* Ignore any mouse motion that happened before this event;
7616 any subsequent mouse-movement Emacs events should reflect
7617 only motion after the ButtonPress/Release. */
7621 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
7622 f
= x_menubar_window_to_frame (dpyinfo
, event
);
7623 /* For a down-event in the menu bar,
7624 don't pass it to Xt right now.
7625 Instead, save it away
7626 and we will pass it to Xt from kbd_buffer_get_event.
7627 That way, we can run some Lisp code first. */
7628 if (! popup_activated ()
7630 /* Gtk+ menus only react to the first three buttons. */
7631 && event
->xbutton
.button
< 3
7633 && f
&& event
->type
== ButtonPress
7634 /* Verify the event is really within the menu bar
7635 and not just sent to it due to grabbing. */
7636 && event
->xbutton
.x
>= 0
7637 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
7638 && event
->xbutton
.y
>= 0
7639 && event
->xbutton
.y
< FRAME_MENUBAR_HEIGHT (f
)
7640 && event
->xbutton
.same_screen
)
7642 if (!f
->output_data
.x
->saved_menu_event
)
7643 f
->output_data
.x
->saved_menu_event
= xmalloc (sizeof *event
);
7644 *f
->output_data
.x
->saved_menu_event
= *event
;
7645 inev
.ie
.kind
= MENU_BAR_ACTIVATE_EVENT
;
7646 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7647 *finish
= X_EVENT_DROP
;
7651 #endif /* USE_X_TOOLKIT || USE_GTK */
7655 case CirculateNotify
:
7658 case CirculateRequest
:
7661 case VisibilityNotify
:
7665 /* Someone has changed the keyboard mapping - update the
7667 switch (event
->xmapping
.request
)
7669 case MappingModifier
:
7670 x_find_modifier_meanings (dpyinfo
);
7671 /* This is meant to fall through. */
7672 case MappingKeyboard
:
7673 XRefreshKeyboardMapping ((XMappingEvent
*) &event
->xmapping
);
7678 xft_settings_event (dpyinfo
, event
);
7683 #ifdef USE_X_TOOLKIT
7685 if (*finish
!= X_EVENT_DROP
)
7686 XtDispatchEvent ((XEvent
*) event
);
7688 #endif /* USE_X_TOOLKIT */
7693 if (inev
.ie
.kind
!= NO_EVENT
)
7695 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
7700 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
7705 XSETFRAME (frame
, f
);
7711 any_help_event_p
= 1;
7712 gen_help_event (help_echo_string
, frame
, help_echo_window
,
7713 help_echo_object
, help_echo_pos
);
7717 help_echo_string
= Qnil
;
7718 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
7727 /* Handles the XEvent EVENT on display DISPLAY.
7728 This is used for event loops outside the normal event handling,
7729 i.e. looping while a popup menu or a dialog is posted.
7731 Returns the value handle_one_xevent sets in the finish argument. */
7733 x_dispatch_event (XEvent
*event
, Display
*display
)
7735 struct x_display_info
*dpyinfo
;
7736 int finish
= X_EVENT_NORMAL
;
7738 dpyinfo
= x_display_info_for_display (display
);
7741 handle_one_xevent (dpyinfo
, event
, &finish
, 0);
7746 /* Read events coming from the X server.
7747 Return as soon as there are no more events to be read.
7749 Return the number of characters stored into the buffer,
7750 thus pretending to be `read' (except the characters we store
7751 in the keyboard buffer can be multibyte, so are not necessarily
7755 XTread_socket (struct terminal
*terminal
, struct input_event
*hold_quit
)
7758 int event_found
= 0;
7759 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
7763 /* For debugging, this gives a way to fake an I/O error. */
7764 if (dpyinfo
== XTread_socket_fake_io_error
)
7766 XTread_socket_fake_io_error
= 0;
7767 x_io_error_quitter (dpyinfo
->display
);
7771 while (XPending (dpyinfo
->display
))
7776 XNextEvent (dpyinfo
->display
, &event
);
7779 /* Filter events for the current X input method. */
7780 if (x_filter_event (dpyinfo
, &event
))
7785 count
+= handle_one_xevent (dpyinfo
, &event
, &finish
, hold_quit
);
7787 if (finish
== X_EVENT_GOTO_OUT
)
7793 /* For GTK we must use the GTK event loop. But XEvents gets passed
7794 to our filter function above, and then to the big event switch.
7795 We use a bunch of globals to communicate with our filter function,
7796 that is kind of ugly, but it works.
7798 There is no way to do one display at the time, GTK just does events
7799 from all displays. */
7801 while (gtk_events_pending ())
7803 current_count
= count
;
7804 current_hold_quit
= hold_quit
;
7806 gtk_main_iteration ();
7808 count
= current_count
;
7810 current_hold_quit
= 0;
7812 if (current_finish
== X_EVENT_GOTO_OUT
)
7815 #endif /* USE_GTK */
7817 /* On some systems, an X bug causes Emacs to get no more events
7818 when the window is destroyed. Detect that. (1994.) */
7821 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
7822 One XNOOP in 100 loops will make Emacs terminate.
7823 B. Bretthauer, 1994 */
7825 if (x_noop_count
>= 100)
7829 if (next_noop_dpyinfo
== 0)
7830 next_noop_dpyinfo
= x_display_list
;
7832 XNoOp (next_noop_dpyinfo
->display
);
7834 /* Each time we get here, cycle through the displays now open. */
7835 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
7839 /* If the focus was just given to an auto-raising frame,
7840 raise it now. FIXME: handle more than one such frame. */
7841 if (dpyinfo
->x_pending_autoraise_frame
)
7843 x_raise_frame (dpyinfo
->x_pending_autoraise_frame
);
7844 dpyinfo
->x_pending_autoraise_frame
= NULL
;
7855 /***********************************************************************
7857 ***********************************************************************/
7859 /* Set clipping for output in glyph row ROW. W is the window in which
7860 we operate. GC is the graphics context to set clipping in.
7862 ROW may be a text row or, e.g., a mode line. Text rows must be
7863 clipped to the interior of the window dedicated to text display,
7864 mode lines must be clipped to the whole window. */
7867 x_clip_to_row (struct window
*w
, struct glyph_row
*row
,
7868 enum glyph_row_area area
, GC gc
)
7870 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7871 XRectangle clip_rect
;
7872 int window_x
, window_y
, window_width
;
7874 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
7876 clip_rect
.x
= window_x
;
7877 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, row
->y
));
7878 clip_rect
.y
= max (clip_rect
.y
, window_y
);
7879 clip_rect
.width
= window_width
;
7880 clip_rect
.height
= row
->visible_height
;
7882 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
7886 /* Draw a hollow box cursor on window W in glyph row ROW. */
7889 x_draw_hollow_cursor (struct window
*w
, struct glyph_row
*row
)
7891 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7892 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
7893 Display
*dpy
= FRAME_X_DISPLAY (f
);
7896 struct glyph
*cursor_glyph
;
7899 /* Get the glyph the cursor is on. If we can't tell because
7900 the current matrix is invalid or such, give up. */
7901 cursor_glyph
= get_phys_cursor_glyph (w
);
7902 if (cursor_glyph
== NULL
)
7905 /* Compute frame-relative coordinates for phys cursor. */
7906 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &x
, &y
, &h
);
7907 wd
= w
->phys_cursor_width
;
7909 /* The foreground of cursor_gc is typically the same as the normal
7910 background color, which can cause the cursor box to be invisible. */
7911 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7912 if (dpyinfo
->scratch_cursor_gc
)
7913 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
7915 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
7916 GCForeground
, &xgcv
);
7917 gc
= dpyinfo
->scratch_cursor_gc
;
7919 /* Set clipping, draw the rectangle, and reset clipping again. */
7920 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7921 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
- 1);
7922 XSetClipMask (dpy
, gc
, None
);
7926 /* Draw a bar cursor on window W in glyph row ROW.
7928 Implementation note: One would like to draw a bar cursor with an
7929 angle equal to the one given by the font property XA_ITALIC_ANGLE.
7930 Unfortunately, I didn't find a font yet that has this property set.
7934 x_draw_bar_cursor (struct window
*w
, struct glyph_row
*row
, int width
, enum text_cursor_kinds kind
)
7936 struct frame
*f
= XFRAME (w
->frame
);
7937 struct glyph
*cursor_glyph
;
7939 /* If cursor is out of bounds, don't draw garbage. This can happen
7940 in mini-buffer windows when switching between echo area glyphs
7942 cursor_glyph
= get_phys_cursor_glyph (w
);
7943 if (cursor_glyph
== NULL
)
7946 /* If on an image, draw like a normal cursor. That's usually better
7947 visible than drawing a bar, esp. if the image is large so that
7948 the bar might not be in the window. */
7949 if (cursor_glyph
->type
== IMAGE_GLYPH
)
7951 struct glyph_row
*r
;
7952 r
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
7953 draw_phys_cursor_glyph (w
, r
, DRAW_CURSOR
);
7957 Display
*dpy
= FRAME_X_DISPLAY (f
);
7958 Window window
= FRAME_X_WINDOW (f
);
7959 GC gc
= FRAME_DISPLAY_INFO (f
)->scratch_cursor_gc
;
7960 unsigned long mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
7961 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
7964 /* If the glyph's background equals the color we normally draw
7965 the bars cursor in, the bar cursor in its normal color is
7966 invisible. Use the glyph's foreground color instead in this
7967 case, on the assumption that the glyph's colors are chosen so
7968 that the glyph is legible. */
7969 if (face
->background
== f
->output_data
.x
->cursor_pixel
)
7970 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
7972 xgcv
.background
= xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7973 xgcv
.graphics_exposures
= 0;
7976 XChangeGC (dpy
, gc
, mask
, &xgcv
);
7979 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
7980 FRAME_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
7983 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7985 if (kind
== BAR_CURSOR
)
7987 int x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
7990 width
= FRAME_CURSOR_WIDTH (f
);
7991 width
= min (cursor_glyph
->pixel_width
, width
);
7993 w
->phys_cursor_width
= width
;
7995 /* If the character under cursor is R2L, draw the bar cursor
7996 on the right of its glyph, rather than on the left. */
7997 if ((cursor_glyph
->resolved_level
& 1) != 0)
7998 x
+= cursor_glyph
->pixel_width
- width
;
8000 XFillRectangle (dpy
, window
, gc
, x
,
8001 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
8002 width
, row
->height
);
8006 int dummy_x
, dummy_y
, dummy_h
;
8009 width
= row
->height
;
8011 width
= min (row
->height
, width
);
8013 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &dummy_x
,
8014 &dummy_y
, &dummy_h
);
8016 XFillRectangle (dpy
, window
, gc
,
8017 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
8018 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
8019 row
->height
- width
),
8020 w
->phys_cursor_width
, width
);
8023 XSetClipMask (dpy
, gc
, None
);
8028 /* RIF: Define cursor CURSOR on frame F. */
8031 x_define_frame_cursor (struct frame
*f
, Cursor cursor
)
8033 if (!f
->pointer_invisible
8034 && f
->output_data
.x
->current_cursor
!= cursor
)
8035 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
8036 f
->output_data
.x
->current_cursor
= cursor
;
8040 /* RIF: Clear area on frame F. */
8043 x_clear_frame_area (struct frame
*f
, int x
, int y
, int width
, int height
)
8045 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), x
, y
, width
, height
);
8047 /* Must queue a redraw, because scroll bars might have been cleared. */
8048 if (FRAME_GTK_WIDGET (f
))
8049 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
8054 /* RIF: Draw cursor on window W. */
8057 x_draw_window_cursor (struct window
*w
, struct glyph_row
*glyph_row
, int x
,
8058 int y
, enum text_cursor_kinds cursor_type
,
8059 int cursor_width
, bool on_p
, bool active_p
)
8061 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
8065 w
->phys_cursor_type
= cursor_type
;
8066 w
->phys_cursor_on_p
= 1;
8068 if (glyph_row
->exact_window_width_line_p
8069 && (glyph_row
->reversed_p
8070 ? (w
->phys_cursor
.hpos
< 0)
8071 : (w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])))
8073 glyph_row
->cursor_in_fringe_p
= 1;
8074 draw_fringe_bitmap (w
, glyph_row
, glyph_row
->reversed_p
);
8078 switch (cursor_type
)
8080 case HOLLOW_BOX_CURSOR
:
8081 x_draw_hollow_cursor (w
, glyph_row
);
8084 case FILLED_BOX_CURSOR
:
8085 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
8089 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
8093 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
8097 w
->phys_cursor_width
= 0;
8106 if (w
== XWINDOW (f
->selected_window
))
8107 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
8108 xic_set_preeditarea (w
, x
, y
);
8112 XFlush (FRAME_X_DISPLAY (f
));
8118 /* Make the x-window of frame F use the gnu icon bitmap. */
8121 x_bitmap_icon (struct frame
*f
, Lisp_Object file
)
8123 ptrdiff_t bitmap_id
;
8125 if (FRAME_X_WINDOW (f
) == 0)
8128 /* Free up our existing icon bitmap and mask if any. */
8129 if (f
->output_data
.x
->icon_bitmap
> 0)
8130 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
8131 f
->output_data
.x
->icon_bitmap
= 0;
8136 /* Use gtk_window_set_icon_from_file () if available,
8137 It's not restricted to bitmaps */
8138 if (xg_set_icon (f
, file
))
8140 #endif /* USE_GTK */
8141 bitmap_id
= x_create_bitmap_from_file (f
, file
);
8142 x_create_bitmap_mask (f
, bitmap_id
);
8146 /* Create the GNU bitmap and mask if necessary. */
8147 if (FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
8153 if (FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
== -2
8154 || xg_set_icon (f
, xg_default_icon_file
)
8155 || xg_set_icon_from_xpm_data (f
, gnu_xpm_bits
))
8157 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= -2;
8161 #elif defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
8163 rc
= x_create_bitmap_from_xpm_data (f
, gnu_xpm_bits
);
8165 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
8169 /* If all else fails, use the (black and white) xbm image. */
8172 rc
= x_create_bitmap_from_data (f
, (char *) gnu_xbm_bits
,
8173 gnu_xbm_width
, gnu_xbm_height
);
8177 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
8178 x_create_bitmap_mask (f
, FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
);
8182 /* The first time we create the GNU bitmap and mask,
8183 this increments the ref-count one extra time.
8184 As a result, the GNU bitmap and mask are never freed.
8185 That way, we don't have to worry about allocating it again. */
8186 x_reference_bitmap (f
, FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
);
8188 bitmap_id
= FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
;
8191 x_wm_set_icon_pixmap (f
, bitmap_id
);
8192 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
8198 /* Make the x-window of frame F use a rectangle with text.
8199 Use ICON_NAME as the text. */
8202 x_text_icon (struct frame
*f
, const char *icon_name
)
8204 if (FRAME_X_WINDOW (f
) == 0)
8209 text
.value
= (unsigned char *) icon_name
;
8210 text
.encoding
= XA_STRING
;
8212 text
.nitems
= strlen (icon_name
);
8213 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
8216 if (f
->output_data
.x
->icon_bitmap
> 0)
8217 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
8218 f
->output_data
.x
->icon_bitmap
= 0;
8219 x_wm_set_icon_pixmap (f
, 0);
8224 #define X_ERROR_MESSAGE_SIZE 200
8226 /* If non-nil, this should be a string.
8227 It means catch X errors and store the error message in this string.
8229 The reason we use a stack is that x_catch_error/x_uncatch_error can
8230 be called from a signal handler.
8233 struct x_error_message_stack
{
8234 char string
[X_ERROR_MESSAGE_SIZE
];
8236 struct x_error_message_stack
*prev
;
8238 static struct x_error_message_stack
*x_error_message
;
8240 /* An X error handler which stores the error message in
8241 *x_error_message. This is called from x_error_handler if
8242 x_catch_errors is in effect. */
8245 x_error_catcher (Display
*display
, XErrorEvent
*event
)
8247 XGetErrorText (display
, event
->error_code
,
8248 x_error_message
->string
,
8249 X_ERROR_MESSAGE_SIZE
);
8252 /* Begin trapping X errors for display DPY. Actually we trap X errors
8253 for all displays, but DPY should be the display you are actually
8256 After calling this function, X protocol errors no longer cause
8257 Emacs to exit; instead, they are recorded in the string
8258 stored in *x_error_message.
8260 Calling x_check_errors signals an Emacs error if an X error has
8261 occurred since the last call to x_catch_errors or x_check_errors.
8263 Calling x_uncatch_errors resumes the normal error handling. */
8266 x_catch_errors (Display
*dpy
)
8268 struct x_error_message_stack
*data
= xmalloc (sizeof *data
);
8270 /* Make sure any errors from previous requests have been dealt with. */
8274 data
->string
[0] = 0;
8275 data
->prev
= x_error_message
;
8276 x_error_message
= data
;
8279 /* Undo the last x_catch_errors call.
8280 DPY should be the display that was passed to x_catch_errors. */
8283 x_uncatch_errors (void)
8285 struct x_error_message_stack
*tmp
;
8289 /* The display may have been closed before this function is called.
8290 Check if it is still open before calling XSync. */
8291 if (x_display_info_for_display (x_error_message
->dpy
) != 0)
8292 XSync (x_error_message
->dpy
, False
);
8294 tmp
= x_error_message
;
8295 x_error_message
= x_error_message
->prev
;
8300 /* If any X protocol errors have arrived since the last call to
8301 x_catch_errors or x_check_errors, signal an Emacs error using
8302 sprintf (a buffer, FORMAT, the x error message text) as the text. */
8305 x_check_errors (Display
*dpy
, const char *format
)
8307 /* Make sure to catch any errors incurred so far. */
8310 if (x_error_message
->string
[0])
8312 char string
[X_ERROR_MESSAGE_SIZE
];
8313 memcpy (string
, x_error_message
->string
, X_ERROR_MESSAGE_SIZE
);
8314 x_uncatch_errors ();
8315 error (format
, string
);
8319 /* Nonzero if we had any X protocol errors
8320 since we did x_catch_errors on DPY. */
8323 x_had_errors_p (Display
*dpy
)
8325 /* Make sure to catch any errors incurred so far. */
8328 return x_error_message
->string
[0] != 0;
8331 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
8334 x_clear_errors (Display
*dpy
)
8336 x_error_message
->string
[0] = 0;
8339 #if 0 /* See comment in unwind_to_catch why calling this is a bad
8340 * idea. --lorentey */
8341 /* Close off all unclosed x_catch_errors calls. */
8344 x_fully_uncatch_errors (void)
8346 while (x_error_message
)
8347 x_uncatch_errors ();
8352 static unsigned int x_wire_count
;
8355 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
8360 /************************************************************************
8362 ************************************************************************/
8364 /* Error message passed to x_connection_closed. */
8366 static char *error_msg
;
8368 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
8369 the text of an error message that lead to the connection loss. */
8372 x_connection_closed (Display
*dpy
, const char *error_message
)
8374 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
8375 Lisp_Object frame
, tail
;
8376 ptrdiff_t idx
= SPECPDL_INDEX ();
8378 error_msg
= alloca (strlen (error_message
) + 1);
8379 strcpy (error_msg
, error_message
);
8381 /* Inhibit redisplay while frames are being deleted. */
8382 specbind (Qinhibit_redisplay
, Qt
);
8386 /* Protect display from being closed when we delete the last
8388 dpyinfo
->reference_count
++;
8389 dpyinfo
->terminal
->reference_count
++;
8392 /* First delete frames whose mini-buffers are on frames
8393 that are on the dead display. */
8394 FOR_EACH_FRAME (tail
, frame
)
8396 Lisp_Object minibuf_frame
;
8398 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
8399 if (FRAME_X_P (XFRAME (frame
))
8400 && FRAME_X_P (XFRAME (minibuf_frame
))
8401 && ! EQ (frame
, minibuf_frame
)
8402 && FRAME_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
8403 delete_frame (frame
, Qnoelisp
);
8406 /* Now delete all remaining frames on the dead display.
8407 We are now sure none of these is used as the mini-buffer
8408 for another frame that we need to delete. */
8409 FOR_EACH_FRAME (tail
, frame
)
8410 if (FRAME_X_P (XFRAME (frame
))
8411 && FRAME_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
8413 /* Set this to t so that delete_frame won't get confused
8414 trying to find a replacement. */
8415 kset_default_minibuffer_frame (FRAME_KBOARD (XFRAME (frame
)), Qt
);
8416 delete_frame (frame
, Qnoelisp
);
8419 /* If DPYINFO is null, this means we didn't open the display in the
8420 first place, so don't try to close it. */
8423 /* We can not call XtCloseDisplay here because it calls XSync.
8424 XSync inside the error handler apparently hangs Emacs. On
8425 current Xt versions, this isn't needed either. */
8427 /* A long-standing GTK bug prevents proper disconnect handling
8428 (https://bugzilla.gnome.org/show_bug.cgi?id=85715). Once,
8429 the resulting Glib error message loop filled a user's disk.
8430 To avoid this, kill Emacs unconditionally on disconnect. */
8431 shut_down_emacs (0, Qnil
);
8432 fprintf (stderr
, "%s\n\
8433 When compiled with GTK, Emacs cannot recover from X disconnects.\n\
8434 This is a GTK bug: https://bugzilla.gnome.org/show_bug.cgi?id=85715\n\
8435 For details, see etc/PROBLEMS.\n",
8438 #endif /* USE_GTK */
8440 /* Indicate that this display is dead. */
8441 dpyinfo
->display
= 0;
8443 dpyinfo
->reference_count
--;
8444 dpyinfo
->terminal
->reference_count
--;
8445 if (dpyinfo
->reference_count
!= 0)
8446 /* We have just closed all frames on this display. */
8451 XSETTERMINAL (tmp
, dpyinfo
->terminal
);
8452 Fdelete_terminal (tmp
, Qnoelisp
);
8456 if (terminal_list
== 0)
8458 fprintf (stderr
, "%s\n", error_msg
);
8459 Fkill_emacs (make_number (70));
8463 totally_unblock_input ();
8465 unbind_to (idx
, Qnil
);
8466 clear_waiting_for_input ();
8468 /* Tell GCC not to suggest attribute 'noreturn' for this function. */
8469 IF_LINT (if (! terminal_list
) return; )
8471 /* Here, we absolutely have to use a non-local exit (e.g. signal, throw,
8472 longjmp), because returning from this function would get us back into
8473 Xlib's code which will directly call `exit'. */
8474 error ("%s", error_msg
);
8477 /* We specifically use it before defining it, so that gcc doesn't inline it,
8478 otherwise gdb doesn't know how to properly put a breakpoint on it. */
8479 static void x_error_quitter (Display
*, XErrorEvent
*);
8481 /* This is the first-level handler for X protocol errors.
8482 It calls x_error_quitter or x_error_catcher. */
8485 x_error_handler (Display
*display
, XErrorEvent
*event
)
8487 #if defined USE_GTK && defined HAVE_GTK3
8488 if ((event
->error_code
== BadMatch
|| event
->error_code
== BadWindow
)
8489 && event
->request_code
== X_SetInputFocus
)
8495 if (x_error_message
)
8496 x_error_catcher (display
, event
);
8498 x_error_quitter (display
, event
);
8502 /* This is the usual handler for X protocol errors.
8503 It kills all frames on the display that we got the error for.
8504 If that was the only one, it prints an error message and kills Emacs. */
8506 /* .gdbinit puts a breakpoint here, so make sure it is not inlined. */
8508 /* On older GCC versions, just putting x_error_quitter
8509 after x_error_handler prevents inlining into the former. */
8511 static void NO_INLINE
8512 x_error_quitter (Display
*display
, XErrorEvent
*event
)
8514 char buf
[256], buf1
[356];
8516 /* Ignore BadName errors. They can happen because of fonts
8517 or colors that are not defined. */
8519 if (event
->error_code
== BadName
)
8522 /* Note that there is no real way portable across R3/R4 to get the
8523 original error handler. */
8525 XGetErrorText (display
, event
->error_code
, buf
, sizeof (buf
));
8526 sprintf (buf1
, "X protocol error: %s on protocol request %d",
8527 buf
, event
->request_code
);
8528 x_connection_closed (display
, buf1
);
8532 /* This is the handler for X IO errors, always.
8533 It kills all frames on the display that we lost touch with.
8534 If that was the only one, it prints an error message and kills Emacs. */
8537 x_io_error_quitter (Display
*display
)
8541 snprintf (buf
, sizeof buf
, "Connection lost to X server `%s'",
8542 DisplayString (display
));
8543 x_connection_closed (display
, buf
);
8547 /* Changing the font of the frame. */
8549 /* Give frame F the font FONT-OBJECT as its default font. The return
8550 value is FONT-OBJECT. FONTSET is an ID of the fontset for the
8551 frame. If it is negative, generate a new fontset from
8555 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
8557 struct font
*font
= XFONT_OBJECT (font_object
);
8561 fontset
= fontset_from_font (font_object
);
8562 FRAME_FONTSET (f
) = fontset
;
8563 if (FRAME_FONT (f
) == font
)
8564 /* This font is already set in frame F. There's nothing more to
8568 FRAME_FONT (f
) = font
;
8569 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
8570 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
8571 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (font
);
8573 #ifndef USE_X_TOOLKIT \
8574 /** FRAME_TOOL_BAR_HEIGHT (f) = FRAME_TOOL_BAR_LINES (f) * FRAME_LINE_HEIGHT (f); **/
8575 FRAME_MENU_BAR_HEIGHT (f
) = FRAME_MENU_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
);
8578 /* Compute character columns occupied by scrollbar.
8580 Don't do things differently for non-toolkit scrollbars
8582 unit
= FRAME_COLUMN_WIDTH (f
);
8583 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
8584 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
8585 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + unit
- 1) / unit
;
8587 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + unit
- 1) / unit
;
8589 if (FRAME_X_WINDOW (f
) != 0)
8591 /* Don't change the size of a tip frame; there's no point in
8592 doing it because it's done in Fx_show_tip, and it leads to
8593 problems because the tip frame has no widget. */
8594 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
8595 x_set_window_size (f
, 0, FRAME_COLS (f
) * FRAME_COLUMN_WIDTH (f
),
8596 FRAME_LINES (f
) * FRAME_LINE_HEIGHT (f
), 1);
8601 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
8604 xic_set_xfontset (f
, SSDATA (fontset_ascii (fontset
)));
8613 /***********************************************************************
8615 ***********************************************************************/
8621 /* XIM destroy callback function, which is called whenever the
8622 connection to input method XIM dies. CLIENT_DATA contains a
8623 pointer to the x_display_info structure corresponding to XIM. */
8626 xim_destroy_callback (XIM xim
, XPointer client_data
, XPointer call_data
)
8628 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
8629 Lisp_Object frame
, tail
;
8633 /* No need to call XDestroyIC.. */
8634 FOR_EACH_FRAME (tail
, frame
)
8636 struct frame
*f
= XFRAME (frame
);
8637 if (FRAME_X_P (f
) && FRAME_DISPLAY_INFO (f
) == dpyinfo
)
8639 FRAME_XIC (f
) = NULL
;
8640 xic_free_xfontset (f
);
8644 /* No need to call XCloseIM. */
8645 dpyinfo
->xim
= NULL
;
8646 XFree (dpyinfo
->xim_styles
);
8650 #endif /* HAVE_X11R6 */
8652 /* Open the connection to the XIM server on display DPYINFO.
8653 RESOURCE_NAME is the resource name Emacs uses. */
8656 xim_open_dpy (struct x_display_info
*dpyinfo
, char *resource_name
)
8664 XCloseIM (dpyinfo
->xim
);
8665 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
,
8672 XIMCallback destroy
;
8675 /* Get supported styles and XIM values. */
8676 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
8679 destroy
.callback
= xim_destroy_callback
;
8680 destroy
.client_data
= (XPointer
)dpyinfo
;
8681 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
8687 #endif /* HAVE_XIM */
8688 dpyinfo
->xim
= NULL
;
8692 #ifdef HAVE_X11R6_XIM
8694 /* XIM instantiate callback function, which is called whenever an XIM
8695 server is available. DISPLAY is the display of the XIM.
8696 CLIENT_DATA contains a pointer to an xim_inst_t structure created
8697 when the callback was registered. */
8700 xim_instantiate_callback (Display
*display
, XPointer client_data
, XPointer call_data
)
8702 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
8703 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
8705 /* We don't support multiple XIM connections. */
8709 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
8711 /* Create XIC for the existing frames on the same display, as long
8712 as they have no XIC. */
8713 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
8715 Lisp_Object tail
, frame
;
8718 FOR_EACH_FRAME (tail
, frame
)
8720 struct frame
*f
= XFRAME (frame
);
8723 && FRAME_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
8724 if (FRAME_XIC (f
) == NULL
)
8726 create_frame_xic (f
);
8727 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
8728 xic_set_statusarea (f
);
8729 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
8731 struct window
*w
= XWINDOW (f
->selected_window
);
8732 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
8741 #endif /* HAVE_X11R6_XIM */
8744 /* Open a connection to the XIM server on display DPYINFO.
8745 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
8746 connection only at the first time. On X11R6, open the connection
8747 in the XIM instantiate callback function. */
8750 xim_initialize (struct x_display_info
*dpyinfo
, char *resource_name
)
8752 dpyinfo
->xim
= NULL
;
8756 #ifdef HAVE_X11R6_XIM
8757 struct xim_inst_t
*xim_inst
= xmalloc (sizeof *xim_inst
);
8760 dpyinfo
->xim_callback_data
= xim_inst
;
8761 xim_inst
->dpyinfo
= dpyinfo
;
8762 xim_inst
->resource_name
= xstrdup (resource_name
);
8763 ret
= XRegisterIMInstantiateCallback
8764 (dpyinfo
->display
, dpyinfo
->xrdb
, xim_inst
->resource_name
,
8765 emacs_class
, xim_instantiate_callback
,
8766 /* This is XPointer in XFree86 but (XPointer *)
8767 on Tru64, at least, hence the configure test. */
8768 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
8769 eassert (ret
== True
);
8770 #else /* not HAVE_X11R6_XIM */
8771 xim_open_dpy (dpyinfo
, resource_name
);
8772 #endif /* not HAVE_X11R6_XIM */
8774 #endif /* HAVE_XIM */
8778 /* Close the connection to the XIM server on display DPYINFO. */
8781 xim_close_dpy (struct x_display_info
*dpyinfo
)
8786 #ifdef HAVE_X11R6_XIM
8787 struct xim_inst_t
*xim_inst
= dpyinfo
->xim_callback_data
;
8789 if (dpyinfo
->display
)
8791 Bool ret
= XUnregisterIMInstantiateCallback
8792 (dpyinfo
->display
, dpyinfo
->xrdb
, xim_inst
->resource_name
,
8793 emacs_class
, xim_instantiate_callback
,
8794 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
8795 eassert (ret
== True
);
8797 xfree (xim_inst
->resource_name
);
8799 #endif /* HAVE_X11R6_XIM */
8800 if (dpyinfo
->display
)
8801 XCloseIM (dpyinfo
->xim
);
8802 dpyinfo
->xim
= NULL
;
8803 XFree (dpyinfo
->xim_styles
);
8805 #endif /* HAVE_XIM */
8808 #endif /* not HAVE_X11R6_XIM */
8812 /* Calculate the absolute position in frame F
8813 from its current recorded position values and gravity. */
8816 x_calc_absolute_position (struct frame
*f
)
8818 int flags
= f
->size_hint_flags
;
8820 /* We have nothing to do if the current position
8821 is already for the top-left corner. */
8822 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
8825 /* Treat negative positions as relative to the leftmost bottommost
8826 position that fits on the screen. */
8827 if (flags
& XNegative
)
8828 f
->left_pos
= x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
8829 - FRAME_PIXEL_WIDTH (f
) + f
->left_pos
;
8832 int height
= FRAME_PIXEL_HEIGHT (f
);
8834 #if defined USE_X_TOOLKIT && defined USE_MOTIF
8835 /* Something is fishy here. When using Motif, starting Emacs with
8836 `-g -0-0', the frame appears too low by a few pixels.
8838 This seems to be so because initially, while Emacs is starting,
8839 the column widget's height and the frame's pixel height are
8840 different. The column widget's height is the right one. In
8841 later invocations, when Emacs is up, the frame's pixel height
8844 It's not obvious where the initial small difference comes from.
8845 2000-12-01, gerd. */
8847 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
8850 if (flags
& YNegative
)
8851 f
->top_pos
= x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
8852 - height
+ f
->top_pos
;
8855 /* The left_pos and top_pos
8856 are now relative to the top and left screen edges,
8857 so the flags should correspond. */
8858 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8861 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
8862 to really change the position, and 0 when calling from
8863 x_make_frame_visible (in that case, XOFF and YOFF are the current
8864 position values). It is -1 when calling from x_set_frame_parameters,
8865 which means, do adjust for borders but don't change the gravity. */
8868 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
, int change_gravity
)
8870 int modified_top
, modified_left
;
8872 if (change_gravity
> 0)
8876 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8878 f
->size_hint_flags
|= XNegative
;
8880 f
->size_hint_flags
|= YNegative
;
8881 f
->win_gravity
= NorthWestGravity
;
8883 x_calc_absolute_position (f
);
8886 x_wm_set_size_hint (f
, 0, 0);
8888 modified_left
= f
->left_pos
;
8889 modified_top
= f
->top_pos
;
8891 if (change_gravity
!= 0 && FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
)
8893 /* Some WMs (twm, wmaker at least) has an offset that is smaller
8894 than the WM decorations. So we use the calculated offset instead
8895 of the WM decoration sizes here (x/y_pixels_outer_diff). */
8896 modified_left
+= FRAME_X_OUTPUT (f
)->move_offset_left
;
8897 modified_top
+= FRAME_X_OUTPUT (f
)->move_offset_top
;
8900 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8901 modified_left
, modified_top
);
8903 x_sync_with_move (f
, f
->left_pos
, f
->top_pos
,
8904 FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8907 /* change_gravity is non-zero when this function is called from Lisp to
8908 programmatically move a frame. In that case, we call
8909 x_check_expected_move to discover if we have a "Type A" or "Type B"
8910 window manager, and, for a "Type A" window manager, adjust the position
8913 We call x_check_expected_move if a programmatic move occurred, and
8914 either the window manager type (A/B) is unknown or it is Type A but we
8915 need to compute the top/left offset adjustment for this frame. */
8917 if (change_gravity
!= 0 &&
8918 (FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8919 || (FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
8920 && (FRAME_X_OUTPUT (f
)->move_offset_left
== 0
8921 && FRAME_X_OUTPUT (f
)->move_offset_top
== 0))))
8922 x_check_expected_move (f
, modified_left
, modified_top
);
8927 /* Return non-zero if _NET_SUPPORTING_WM_CHECK window exists and _NET_SUPPORTED
8928 on the root window for frame F contains ATOMNAME.
8929 This is how a WM check shall be done according to the Window Manager
8930 Specification/Extended Window Manager Hints at
8931 http://freedesktop.org/wiki/Specifications/wm-spec. */
8934 wm_supports (struct frame
*f
, Atom want_atom
)
8937 unsigned long actual_size
, bytes_remaining
;
8938 int i
, rc
, actual_format
;
8939 Window wmcheck_window
;
8940 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
8941 Window target_window
= dpyinfo
->root_window
;
8942 long max_len
= 65536;
8943 Display
*dpy
= FRAME_X_DISPLAY (f
);
8944 unsigned char *tmp_data
= NULL
;
8945 Atom target_type
= XA_WINDOW
;
8949 x_catch_errors (dpy
);
8950 rc
= XGetWindowProperty (dpy
, target_window
,
8951 dpyinfo
->Xatom_net_supporting_wm_check
,
8952 0, max_len
, False
, target_type
,
8953 &actual_type
, &actual_format
, &actual_size
,
8954 &bytes_remaining
, &tmp_data
);
8956 if (rc
!= Success
|| actual_type
!= XA_WINDOW
|| x_had_errors_p (dpy
))
8958 if (tmp_data
) XFree (tmp_data
);
8959 x_uncatch_errors ();
8964 wmcheck_window
= *(Window
*) tmp_data
;
8967 /* Check if window exists. */
8968 XSelectInput (dpy
, wmcheck_window
, StructureNotifyMask
);
8970 if (x_had_errors_p (dpy
))
8972 x_uncatch_errors ();
8977 if (dpyinfo
->net_supported_window
!= wmcheck_window
)
8979 /* Window changed, reload atoms */
8980 if (dpyinfo
->net_supported_atoms
!= NULL
)
8981 XFree (dpyinfo
->net_supported_atoms
);
8982 dpyinfo
->net_supported_atoms
= NULL
;
8983 dpyinfo
->nr_net_supported_atoms
= 0;
8984 dpyinfo
->net_supported_window
= 0;
8986 target_type
= XA_ATOM
;
8988 rc
= XGetWindowProperty (dpy
, target_window
,
8989 dpyinfo
->Xatom_net_supported
,
8990 0, max_len
, False
, target_type
,
8991 &actual_type
, &actual_format
, &actual_size
,
8992 &bytes_remaining
, &tmp_data
);
8994 if (rc
!= Success
|| actual_type
!= XA_ATOM
|| x_had_errors_p (dpy
))
8996 if (tmp_data
) XFree (tmp_data
);
8997 x_uncatch_errors ();
9002 dpyinfo
->net_supported_atoms
= (Atom
*)tmp_data
;
9003 dpyinfo
->nr_net_supported_atoms
= actual_size
;
9004 dpyinfo
->net_supported_window
= wmcheck_window
;
9009 for (i
= 0; rc
== 0 && i
< dpyinfo
->nr_net_supported_atoms
; ++i
)
9010 rc
= dpyinfo
->net_supported_atoms
[i
] == want_atom
;
9012 x_uncatch_errors ();
9019 set_wm_state (Lisp_Object frame
, int add
, Atom atom
, Atom value
)
9021 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (XFRAME (frame
));
9023 x_send_client_event (frame
, make_number (0), frame
,
9024 dpyinfo
->Xatom_net_wm_state
,
9026 /* 1 = add, 0 = remove */
9028 (make_number (add
? 1 : 0),
9030 (make_fixnum_or_float (atom
),
9032 ? list1 (make_fixnum_or_float (value
))
9037 x_set_sticky (struct frame
*f
, Lisp_Object new_value
, Lisp_Object old_value
)
9040 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9042 XSETFRAME (frame
, f
);
9044 set_wm_state (frame
, NILP (new_value
) ? 0 : 1,
9045 dpyinfo
->Xatom_net_wm_state_sticky
, None
);
9048 /* Return the current _NET_WM_STATE.
9049 SIZE_STATE is set to one of the FULLSCREEN_* values.
9050 STICKY is set to 1 if the sticky state is set, 0 if not.
9052 Return non-zero if we are not hidden, zero if we are. */
9055 get_current_wm_state (struct frame
*f
,
9061 unsigned long actual_size
, bytes_remaining
;
9062 int i
, rc
, actual_format
, is_hidden
= 0;
9063 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9064 long max_len
= 65536;
9065 Display
*dpy
= FRAME_X_DISPLAY (f
);
9066 unsigned char *tmp_data
= NULL
;
9067 Atom target_type
= XA_ATOM
;
9070 *size_state
= FULLSCREEN_NONE
;
9073 x_catch_errors (dpy
);
9074 rc
= XGetWindowProperty (dpy
, window
, dpyinfo
->Xatom_net_wm_state
,
9075 0, max_len
, False
, target_type
,
9076 &actual_type
, &actual_format
, &actual_size
,
9077 &bytes_remaining
, &tmp_data
);
9079 if (rc
!= Success
|| actual_type
!= target_type
|| x_had_errors_p (dpy
))
9081 if (tmp_data
) XFree (tmp_data
);
9082 x_uncatch_errors ();
9084 return !FRAME_ICONIFIED_P (f
);
9087 x_uncatch_errors ();
9089 for (i
= 0; i
< actual_size
; ++i
)
9091 Atom a
= ((Atom
*)tmp_data
)[i
];
9092 if (a
== dpyinfo
->Xatom_net_wm_state_hidden
)
9095 f
->output_data
.x
->net_wm_state_hidden_seen
= 1;
9097 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_horz
)
9099 if (*size_state
== FULLSCREEN_HEIGHT
)
9100 *size_state
= FULLSCREEN_MAXIMIZED
;
9102 *size_state
= FULLSCREEN_WIDTH
;
9104 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_vert
)
9106 if (*size_state
== FULLSCREEN_WIDTH
)
9107 *size_state
= FULLSCREEN_MAXIMIZED
;
9109 *size_state
= FULLSCREEN_HEIGHT
;
9111 else if (a
== dpyinfo
->Xatom_net_wm_state_fullscreen
)
9112 *size_state
= FULLSCREEN_BOTH
;
9113 else if (a
== dpyinfo
->Xatom_net_wm_state_sticky
)
9117 if (tmp_data
) XFree (tmp_data
);
9122 /* Do fullscreen as specified in extended window manager hints */
9125 do_ewmh_fullscreen (struct frame
*f
)
9127 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9128 int have_net_atom
= wm_supports (f
, dpyinfo
->Xatom_net_wm_state
);
9131 (void)get_current_wm_state (f
, FRAME_OUTER_WINDOW (f
), &cur
, &dummy
);
9133 /* Some window managers don't say they support _NET_WM_STATE, but they do say
9134 they support _NET_WM_STATE_FULLSCREEN. Try that also. */
9136 have_net_atom
= wm_supports (f
, dpyinfo
->Xatom_net_wm_state_fullscreen
);
9138 if (have_net_atom
&& cur
!= f
->want_fullscreen
)
9142 XSETFRAME (frame
, f
);
9144 /* Keep number of calls to set_wm_state as low as possible.
9145 Some window managers, or possible Gtk+, hangs when too many
9146 are sent at once. */
9147 switch (f
->want_fullscreen
)
9149 case FULLSCREEN_BOTH
:
9150 if (cur
== FULLSCREEN_WIDTH
|| cur
== FULLSCREEN_MAXIMIZED
9151 || cur
== FULLSCREEN_HEIGHT
)
9152 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_maximized_horz
,
9153 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
9154 set_wm_state (frame
, 1, dpyinfo
->Xatom_net_wm_state_fullscreen
, None
);
9156 case FULLSCREEN_WIDTH
:
9157 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_HEIGHT
9158 || cur
== FULLSCREEN_MAXIMIZED
)
9159 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_fullscreen
,
9160 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
9161 if (cur
!= FULLSCREEN_MAXIMIZED
)
9162 set_wm_state (frame
, 1, dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
9164 case FULLSCREEN_HEIGHT
:
9165 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_WIDTH
9166 || cur
== FULLSCREEN_MAXIMIZED
)
9167 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_fullscreen
,
9168 dpyinfo
->Xatom_net_wm_state_maximized_horz
);
9169 if (cur
!= FULLSCREEN_MAXIMIZED
)
9170 set_wm_state (frame
, 1, dpyinfo
->Xatom_net_wm_state_maximized_vert
, None
);
9172 case FULLSCREEN_MAXIMIZED
:
9173 if (cur
== FULLSCREEN_BOTH
)
9174 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_fullscreen
, None
);
9175 set_wm_state (frame
, 1, dpyinfo
->Xatom_net_wm_state_maximized_horz
,
9176 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
9178 case FULLSCREEN_NONE
:
9179 if (cur
== FULLSCREEN_BOTH
)
9180 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_fullscreen
, None
);
9182 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_maximized_horz
,
9183 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
9186 f
->want_fullscreen
= FULLSCREEN_NONE
;
9190 return have_net_atom
;
9194 XTfullscreen_hook (struct frame
*f
)
9196 if (FRAME_VISIBLE_P (f
))
9199 x_check_fullscreen (f
);
9207 x_handle_net_wm_state (struct frame
*f
, const XPropertyEvent
*event
)
9209 int value
= FULLSCREEN_NONE
;
9212 int not_hidden
= get_current_wm_state (f
, event
->window
, &value
, &sticky
);
9217 case FULLSCREEN_WIDTH
:
9220 case FULLSCREEN_HEIGHT
:
9223 case FULLSCREEN_BOTH
:
9226 case FULLSCREEN_MAXIMIZED
:
9231 store_frame_param (f
, Qfullscreen
, lval
);
9232 store_frame_param (f
, Qsticky
, sticky
? Qt
: Qnil
);
9237 /* Check if we need to resize the frame due to a fullscreen request.
9238 If so needed, resize the frame. */
9240 x_check_fullscreen (struct frame
*f
)
9242 if (do_ewmh_fullscreen (f
))
9245 if (f
->output_data
.x
->parent_desc
!= FRAME_DISPLAY_INFO (f
)->root_window
)
9246 return; /* Only fullscreen without WM or with EWM hints (above). */
9248 /* Setting fullscreen to nil doesn't do anything. We could save the
9249 last non-fullscreen size and restore it, but it seems like a
9250 lot of work for this unusual case (no window manager running). */
9252 if (f
->want_fullscreen
!= FULLSCREEN_NONE
)
9254 int width
= FRAME_PIXEL_WIDTH (f
), height
= FRAME_PIXEL_HEIGHT (f
);
9255 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9257 switch (f
->want_fullscreen
)
9259 /* No difference between these two when there is no WM */
9260 case FULLSCREEN_BOTH
:
9261 case FULLSCREEN_MAXIMIZED
:
9262 width
= x_display_pixel_width (dpyinfo
);
9263 height
= x_display_pixel_height (dpyinfo
);
9265 case FULLSCREEN_WIDTH
:
9266 width
= x_display_pixel_width (dpyinfo
);
9268 case FULLSCREEN_HEIGHT
:
9269 height
= x_display_pixel_height (dpyinfo
);
9272 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9277 /* This function is called by x_set_offset to determine whether the window
9278 manager interfered with the positioning of the frame. Type A window
9279 managers position the surrounding window manager decorations a small
9280 amount above and left of the user-supplied position. Type B window
9281 managers position the surrounding window manager decorations at the
9282 user-specified position. If we detect a Type A window manager, we
9283 compensate by moving the window right and down by the proper amount. */
9286 x_check_expected_move (struct frame
*f
, int expected_left
, int expected_top
)
9288 int current_left
= 0, current_top
= 0;
9290 /* x_real_positions returns the left and top offsets of the outermost
9291 window manager window around the frame. */
9293 x_real_positions (f
, ¤t_left
, ¤t_top
);
9295 if (current_left
!= expected_left
|| current_top
!= expected_top
)
9297 /* It's a "Type A" window manager. */
9302 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_A
;
9303 FRAME_X_OUTPUT (f
)->move_offset_left
= expected_left
- current_left
;
9304 FRAME_X_OUTPUT (f
)->move_offset_top
= expected_top
- current_top
;
9306 /* Now fix the mispositioned frame's location. */
9308 adjusted_left
= expected_left
+ FRAME_X_OUTPUT (f
)->move_offset_left
;
9309 adjusted_top
= expected_top
+ FRAME_X_OUTPUT (f
)->move_offset_top
;
9311 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9312 adjusted_left
, adjusted_top
);
9314 x_sync_with_move (f
, expected_left
, expected_top
, 0);
9317 /* It's a "Type B" window manager. We don't have to adjust the
9318 frame's position. */
9320 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_B
;
9324 /* Wait for XGetGeometry to return up-to-date position information for a
9325 recently-moved frame. Call this immediately after calling XMoveWindow.
9326 If FUZZY is non-zero, then LEFT and TOP are just estimates of where the
9327 frame has been moved to, so we use a fuzzy position comparison instead
9328 of an exact comparison. */
9331 x_sync_with_move (struct frame
*f
, int left
, int top
, int fuzzy
)
9335 while (count
++ < 50)
9337 int current_left
= 0, current_top
= 0;
9339 /* In theory, this call to XSync only needs to happen once, but in
9340 practice, it doesn't seem to work, hence the need for the surrounding
9343 XSync (FRAME_X_DISPLAY (f
), False
);
9344 x_real_positions (f
, ¤t_left
, ¤t_top
);
9348 /* The left fuzz-factor is 10 pixels. The top fuzz-factor is 40
9351 if (eabs (current_left
- left
) <= 10
9352 && eabs (current_top
- top
) <= 40)
9355 else if (current_left
== left
&& current_top
== top
)
9359 /* As a last resort, just wait 0.5 seconds and hope that XGetGeometry
9360 will then return up-to-date position info. */
9362 wait_reading_process_output (0, 500000, 0, 0, Qnil
, NULL
, 0);
9366 /* Wait for an event on frame F matching EVENTTYPE. */
9368 x_wait_for_event (struct frame
*f
, int eventtype
)
9370 int level
= interrupt_input_blocked
;
9373 struct timespec tmo
, tmo_at
, time_now
;
9374 int fd
= ConnectionNumber (FRAME_X_DISPLAY (f
));
9376 f
->wait_event_type
= eventtype
;
9378 /* Set timeout to 0.1 second. Hopefully not noticeable.
9379 Maybe it should be configurable. */
9380 tmo
= make_timespec (0, 100 * 1000 * 1000);
9381 tmo_at
= timespec_add (current_timespec (), tmo
);
9383 while (f
->wait_event_type
)
9385 pending_signals
= 1;
9386 totally_unblock_input ();
9387 /* XTread_socket is called after unblock. */
9389 interrupt_input_blocked
= level
;
9394 time_now
= current_timespec ();
9395 if (timespec_cmp (tmo_at
, time_now
) < 0)
9398 tmo
= timespec_sub (tmo_at
, time_now
);
9399 if (pselect (fd
+ 1, &fds
, NULL
, NULL
, &tmo
, NULL
) == 0)
9400 break; /* Timeout */
9403 f
->wait_event_type
= 0;
9407 /* Change the size of frame F's X window to WIDTH/HEIGHT in the case F
9408 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
9409 top-left-corner window gravity for this size change and subsequent
9410 size changes. Otherwise we leave the window gravity unchanged. */
9413 x_set_window_size_1 (struct frame
*f
, int change_gravity
, int width
, int height
, bool pixelwise
)
9415 int pixelwidth
, pixelheight
;
9417 /** if (pixelwise) **/
9419 /** pixelwidth = FRAME_TEXT_TO_PIXEL_WIDTH (f, width); **/
9420 /** pixelheight = FRAME_TEXT_TO_PIXEL_HEIGHT (f, height); **/
9424 /** pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, width); **/
9425 /** pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, height); **/
9428 /** FRAME_TOOL_BAR_HEIGHT (f) = FRAME_TOOLBAR_HEIGHT (f); **/
9429 pixelwidth
= (pixelwise
9430 ? FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
)
9431 : FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, width
));
9432 pixelheight
= ((pixelwise
9433 ? FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
)
9434 : FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, height
)));
9436 /** pixelwidth = ((pixelwise ? width : (width * FRAME_COLUMN_WIDTH (f))) **/
9437 /** + FRAME_SCROLL_BAR_AREA_WIDTH (f) **/
9438 /** + FRAME_TOTAL_FRINGE_WIDTH (f) **/
9439 /** + 2 * FRAME_INTERNAL_BORDER_WIDTH (f)); **/
9441 /** pixelheight = ((pixelwise ? height : (height * FRAME_LINE_HEIGHT (f))) **/
9442 /** + FRAME_TOOLBAR_HEIGHT (f) **/
9443 /** + FRAME_SCROLL_BAR_AREA_HEIGHT (f) **/
9444 /** + 2 * FRAME_INTERNAL_BORDER_WIDTH (f)); **/
9446 if (change_gravity
) f
->win_gravity
= NorthWestGravity
;
9447 x_wm_set_size_hint (f
, 0, 0);
9448 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9449 pixelwidth
, pixelheight
+ FRAME_MENUBAR_HEIGHT (f
));
9452 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
9453 receive in the ConfigureNotify event; if we get what we asked
9454 for, then the event won't cause the screen to become garbaged, so
9455 we have to make sure to do it here. */
9456 SET_FRAME_GARBAGED (f
);
9458 /* Now, strictly speaking, we can't be sure that this is accurate,
9459 but the window manager will get around to dealing with the size
9460 change request eventually, and we'll hear how it went when the
9461 ConfigureNotify event gets here.
9463 We could just not bother storing any of this information here,
9464 and let the ConfigureNotify event set everything up, but that
9465 might be kind of confusing to the Lisp code, since size changes
9466 wouldn't be reported in the frame parameters until some random
9467 point in the future when the ConfigureNotify event arrives.
9469 We pass 1 for DELAY since we can't run Lisp code inside of
9472 /* But the ConfigureNotify may in fact never arrive, and then this is
9473 not right if the frame is visible. Instead wait (with timeout)
9474 for the ConfigureNotify. */
9475 if (FRAME_VISIBLE_P (f
))
9476 x_wait_for_event (f
, ConfigureNotify
);
9479 change_frame_size (f
, pixelwidth
, pixelheight
, 0, 1, 0, 1);
9485 /* Call this to change the size of frame F's x-window.
9486 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
9487 for this size change and subsequent size changes.
9488 Otherwise we leave the window gravity unchanged. */
9491 x_set_window_size (struct frame
*f
, int change_gravity
, int width
, int height
, bool pixelwise
)
9495 /* The following breaks our calculations. If it's really needed,
9496 think of something else. */
9498 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
9500 int text_width
, text_height
;
9502 /* When the frame is maximized/fullscreen or running under for
9503 example Xmonad, x_set_window_size_1 will be a no-op.
9504 In that case, the right thing to do is extend rows/width to
9505 the current frame size. We do that first if x_set_window_size_1
9506 turns out to not be a no-op (there is no way to know).
9507 The size will be adjusted again if the frame gets a
9508 ConfigureNotify event as a result of x_set_window_size. */
9509 int pixelh
= FRAME_PIXEL_HEIGHT (f
);
9510 #ifdef USE_X_TOOLKIT
9511 /* The menu bar is not part of text lines. The tool bar
9513 pixelh
-= FRAME_MENUBAR_HEIGHT (f
);
9515 text_width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, FRAME_PIXEL_WIDTH (f
));
9516 text_height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelh
);
9518 change_frame_size (f
, text_width
, text_height
, 0, 1, 0, 1);
9523 if (FRAME_GTK_WIDGET (f
))
9525 xg_frame_set_char_size (f
, width
* FRAME_COLUMN_WIDTH (f
),
9526 height
* FRAME_LINE_HEIGHT (f
));
9528 xg_frame_set_char_size (f
, width
, height
);
9530 x_set_window_size_1 (f
, change_gravity
, width
, height
, pixelwise
);
9531 #else /* not USE_GTK */
9533 x_set_window_size_1 (f
, change_gravity
, width
, height
, pixelwise
);
9534 x_clear_under_internal_border (f
);
9536 #endif /* not USE_GTK */
9538 /* If cursor was outside the new size, mark it as off. */
9539 mark_window_cursors_off (XWINDOW (f
->root_window
));
9541 /* Clear out any recollection of where the mouse highlighting was,
9542 since it might be in a place that's outside the new frame size.
9543 Actually checking whether it is outside is a pain in the neck,
9544 so don't try--just let the highlighting be done afresh with new size. */
9545 cancel_mouse_face (f
);
9549 do_pending_window_change (0);
9552 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
9555 frame_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
9559 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
9560 0, 0, 0, 0, pix_x
, pix_y
);
9564 /* Raise frame F. */
9567 x_raise_frame (struct frame
*f
)
9570 if (FRAME_VISIBLE_P (f
))
9571 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
9572 XFlush (FRAME_X_DISPLAY (f
));
9576 /* Lower frame F. */
9579 x_lower_frame (struct frame
*f
)
9581 if (FRAME_VISIBLE_P (f
))
9584 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
9585 XFlush (FRAME_X_DISPLAY (f
));
9590 /* Request focus with XEmbed */
9593 xembed_request_focus (struct frame
*f
)
9595 /* See XEmbed Protocol Specification at
9596 http://freedesktop.org/wiki/Specifications/xembed-spec */
9597 if (FRAME_VISIBLE_P (f
))
9598 xembed_send_message (f
, CurrentTime
,
9599 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
9602 /* Activate frame with Extended Window Manager Hints */
9605 x_ewmh_activate_frame (struct frame
*f
)
9607 /* See Window Manager Specification/Extended Window Manager Hints at
9608 http://freedesktop.org/wiki/Specifications/wm-spec */
9610 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9612 if (FRAME_VISIBLE_P (f
) && wm_supports (f
, dpyinfo
->Xatom_net_active_window
))
9615 XSETFRAME (frame
, f
);
9616 x_send_client_event (frame
, make_number (0), frame
,
9617 dpyinfo
->Xatom_net_active_window
,
9619 list2i (1, dpyinfo
->last_user_time
));
9624 XTframe_raise_lower (struct frame
*f
, int raise_flag
)
9632 /* XEmbed implementation. */
9634 #if defined USE_X_TOOLKIT || ! defined USE_GTK
9636 /* XEmbed implementation. */
9638 #define XEMBED_VERSION 0
9641 xembed_set_info (struct frame
*f
, enum xembed_info flags
)
9643 unsigned long data
[2];
9644 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9646 data
[0] = XEMBED_VERSION
;
9649 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9650 dpyinfo
->Xatom_XEMBED_INFO
, dpyinfo
->Xatom_XEMBED_INFO
,
9651 32, PropModeReplace
, (unsigned char *) data
, 2);
9653 #endif /* defined USE_X_TOOLKIT || ! defined USE_GTK */
9656 xembed_send_message (struct frame
*f
, Time t
, enum xembed_message msg
,
9657 long int detail
, long int data1
, long int data2
)
9661 event
.xclient
.type
= ClientMessage
;
9662 event
.xclient
.window
= FRAME_X_OUTPUT (f
)->parent_desc
;
9663 event
.xclient
.message_type
= FRAME_DISPLAY_INFO (f
)->Xatom_XEMBED
;
9664 event
.xclient
.format
= 32;
9665 event
.xclient
.data
.l
[0] = t
;
9666 event
.xclient
.data
.l
[1] = msg
;
9667 event
.xclient
.data
.l
[2] = detail
;
9668 event
.xclient
.data
.l
[3] = data1
;
9669 event
.xclient
.data
.l
[4] = data2
;
9671 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_OUTPUT (f
)->parent_desc
,
9672 False
, NoEventMask
, &event
);
9673 XSync (FRAME_X_DISPLAY (f
), False
);
9676 /* Change of visibility. */
9678 /* This tries to wait until the frame is really visible.
9679 However, if the window manager asks the user where to position
9680 the frame, this will return before the user finishes doing that.
9681 The frame will not actually be visible at that time,
9682 but it will become visible later when the window manager
9683 finishes with it. */
9686 x_make_frame_visible (struct frame
*f
)
9688 int original_top
, original_left
;
9693 x_set_bitmap_icon (f
);
9695 if (! FRAME_VISIBLE_P (f
))
9697 /* We test FRAME_GARBAGED_P here to make sure we don't
9698 call x_set_offset a second time
9699 if we get to x_make_frame_visible a second time
9700 before the window gets really visible. */
9701 if (! FRAME_ICONIFIED_P (f
)
9702 && ! FRAME_X_EMBEDDED_P (f
)
9703 && ! f
->output_data
.x
->asked_for_visible
)
9704 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
9706 f
->output_data
.x
->asked_for_visible
= 1;
9708 if (! EQ (Vx_no_window_manager
, Qt
))
9709 x_wm_set_window_state (f
, NormalState
);
9710 #ifdef USE_X_TOOLKIT
9711 if (FRAME_X_EMBEDDED_P (f
))
9712 xembed_set_info (f
, XEMBED_MAPPED
);
9715 /* This was XtPopup, but that did nothing for an iconified frame. */
9716 XtMapWidget (f
->output_data
.x
->widget
);
9718 #else /* not USE_X_TOOLKIT */
9720 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
9721 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
9723 if (FRAME_X_EMBEDDED_P (f
))
9724 xembed_set_info (f
, XEMBED_MAPPED
);
9726 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9727 #endif /* not USE_GTK */
9728 #endif /* not USE_X_TOOLKIT */
9731 XFlush (FRAME_X_DISPLAY (f
));
9733 /* Synchronize to ensure Emacs knows the frame is visible
9734 before we do anything else. We do this loop with input not blocked
9735 so that incoming events are handled. */
9738 /* This must be before UNBLOCK_INPUT
9739 since events that arrive in response to the actions above
9740 will set it when they are handled. */
9741 int previously_visible
= f
->output_data
.x
->has_been_visible
;
9743 original_left
= f
->left_pos
;
9744 original_top
= f
->top_pos
;
9746 /* This must come after we set COUNT. */
9749 /* We unblock here so that arriving X events are processed. */
9751 /* Now move the window back to where it was "supposed to be".
9752 But don't do it if the gravity is negative.
9753 When the gravity is negative, this uses a position
9754 that is 3 pixels too low. Perhaps that's really the border width.
9756 Don't do this if the window has never been visible before,
9757 because the window manager may choose the position
9758 and we don't want to override it. */
9760 if (! FRAME_VISIBLE_P (f
)
9761 && ! FRAME_ICONIFIED_P (f
)
9762 && ! FRAME_X_EMBEDDED_P (f
)
9763 && f
->win_gravity
== NorthWestGravity
9764 && previously_visible
)
9768 unsigned int width
, height
, border
, depth
;
9772 /* On some window managers (such as FVWM) moving an existing
9773 window, even to the same place, causes the window manager
9774 to introduce an offset. This can cause the window to move
9775 to an unexpected location. Check the geometry (a little
9776 slow here) and then verify that the window is in the right
9777 place. If the window is not in the right place, move it
9778 there, and take the potential window manager hit. */
9779 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9780 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
9782 if (original_left
!= x
|| original_top
!= y
)
9783 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9784 original_left
, original_top
);
9789 XSETFRAME (frame
, f
);
9791 /* Process X events until a MapNotify event has been seen. */
9792 while (!FRAME_VISIBLE_P (f
))
9794 /* Force processing of queued events. */
9797 /* If on another desktop, the deiconify/map may be ignored and the
9798 frame never becomes visible. XMonad does this.
9799 Prevent an endless loop. */
9800 if (FRAME_ICONIFIED_P (f
) && ++tries
> 100)
9803 /* This hack is still in use at least for Cygwin. See
9804 http://lists.gnu.org/archive/html/emacs-devel/2013-12/msg00351.html.
9806 Machines that do polling rather than SIGIO have been
9807 observed to go into a busy-wait here. So we'll fake an
9808 alarm signal to let the handler know that there's something
9809 to be read. We used to raise a real alarm, but it seems
9810 that the handler isn't always enabled here. This is
9812 if (input_polling_used ())
9814 /* It could be confusing if a real alarm arrives while
9815 processing the fake one. Turn it off and let the
9816 handler reset it. */
9817 int old_poll_suppress_count
= poll_suppress_count
;
9818 poll_suppress_count
= 1;
9819 poll_for_input_1 ();
9820 poll_suppress_count
= old_poll_suppress_count
;
9823 if (XPending (FRAME_X_DISPLAY (f
)))
9826 XNextEvent (FRAME_X_DISPLAY (f
), &xev
);
9827 x_dispatch_event (&xev
, FRAME_X_DISPLAY (f
));
9833 /* Change from mapped state to withdrawn state. */
9835 /* Make the frame visible (mapped and not iconified). */
9838 x_make_frame_invisible (struct frame
*f
)
9842 /* Use the frame's outermost window, not the one we normally draw on. */
9843 window
= FRAME_OUTER_WINDOW (f
);
9845 /* Don't keep the highlight on an invisible frame. */
9846 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9847 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9851 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
9852 that the current position of the window is user-specified, rather than
9853 program-specified, so that when the window is mapped again, it will be
9854 placed at the same location, without forcing the user to position it
9855 by hand again (they have already done that once for this window.) */
9856 x_wm_set_size_hint (f
, 0, 1);
9859 if (FRAME_GTK_OUTER_WIDGET (f
))
9860 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f
));
9863 if (FRAME_X_EMBEDDED_P (f
))
9864 xembed_set_info (f
, 0);
9869 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
9870 DefaultScreen (FRAME_X_DISPLAY (f
))))
9873 error ("Can't notify window manager of window withdrawal");
9877 /* We can't distinguish this from iconification
9878 just by the event that we get from the server.
9879 So we can't win using the usual strategy of letting
9880 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
9881 and synchronize with the server to make sure we agree. */
9882 SET_FRAME_VISIBLE (f
, 0);
9883 SET_FRAME_ICONIFIED (f
, 0);
9890 /* Change window state from mapped to iconified. */
9893 x_iconify_frame (struct frame
*f
)
9895 #ifdef USE_X_TOOLKIT
9899 /* Don't keep the highlight on an invisible frame. */
9900 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9901 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9903 if (FRAME_ICONIFIED_P (f
))
9908 x_set_bitmap_icon (f
);
9910 #if defined (USE_GTK)
9911 if (FRAME_GTK_OUTER_WIDGET (f
))
9913 if (! FRAME_VISIBLE_P (f
))
9914 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
9916 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
9917 SET_FRAME_VISIBLE (f
, 0);
9918 SET_FRAME_ICONIFIED (f
, 1);
9924 #ifdef USE_X_TOOLKIT
9926 if (! FRAME_VISIBLE_P (f
))
9928 if (! EQ (Vx_no_window_manager
, Qt
))
9929 x_wm_set_window_state (f
, IconicState
);
9930 /* This was XtPopup, but that did nothing for an iconified frame. */
9931 XtMapWidget (f
->output_data
.x
->widget
);
9932 /* The server won't give us any event to indicate
9933 that an invisible frame was changed to an icon,
9934 so we have to record it here. */
9935 SET_FRAME_VISIBLE (f
, 0);
9936 SET_FRAME_ICONIFIED (f
, 1);
9941 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
9942 XtWindow (f
->output_data
.x
->widget
),
9943 DefaultScreen (FRAME_X_DISPLAY (f
)));
9947 error ("Can't notify window manager of iconification");
9949 SET_FRAME_ICONIFIED (f
, 1);
9950 SET_FRAME_VISIBLE (f
, 0);
9953 XFlush (FRAME_X_DISPLAY (f
));
9955 #else /* not USE_X_TOOLKIT */
9957 /* Make sure the X server knows where the window should be positioned,
9958 in case the user deiconifies with the window manager. */
9959 if (! FRAME_VISIBLE_P (f
)
9960 && ! FRAME_ICONIFIED_P (f
)
9961 && ! FRAME_X_EMBEDDED_P (f
))
9962 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
9964 /* Since we don't know which revision of X we're running, we'll use both
9965 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
9967 /* X11R4: send a ClientMessage to the window manager using the
9968 WM_CHANGE_STATE type. */
9972 msg
.xclient
.window
= FRAME_X_WINDOW (f
);
9973 msg
.xclient
.type
= ClientMessage
;
9974 msg
.xclient
.message_type
= FRAME_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
9975 msg
.xclient
.format
= 32;
9976 msg
.xclient
.data
.l
[0] = IconicState
;
9978 if (! XSendEvent (FRAME_X_DISPLAY (f
),
9979 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
9981 SubstructureRedirectMask
| SubstructureNotifyMask
,
9985 error ("Can't notify window manager of iconification");
9989 /* X11R3: set the initial_state field of the window manager hints to
9991 x_wm_set_window_state (f
, IconicState
);
9993 if (!FRAME_VISIBLE_P (f
))
9995 /* If the frame was withdrawn, before, we must map it. */
9996 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9999 SET_FRAME_ICONIFIED (f
, 1);
10000 SET_FRAME_VISIBLE (f
, 0);
10002 XFlush (FRAME_X_DISPLAY (f
));
10004 #endif /* not USE_X_TOOLKIT */
10008 /* Free X resources of frame F. */
10011 x_free_frame_resources (struct frame
*f
)
10013 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10014 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
10015 #ifdef USE_X_TOOLKIT
10017 struct scroll_bar
*b
;
10022 /* If a display connection is dead, don't try sending more
10023 commands to the X server. */
10024 if (dpyinfo
->display
)
10026 /* Always exit with visible pointer to avoid weird issue
10027 with Xfixes (Bug#17609). */
10028 if (f
->pointer_invisible
)
10029 FRAME_DISPLAY_INFO (f
)->toggle_visible_pointer (f
, 0);
10031 /* We must free faces before destroying windows because some
10032 font-driver (e.g. xft) access a window while finishing a
10034 free_frame_faces (f
);
10036 if (f
->output_data
.x
->icon_desc
)
10037 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
10039 #ifdef USE_X_TOOLKIT
10040 /* Explicitly destroy the scroll bars of the frame. Without
10041 this, we get "BadDrawable" errors from the toolkit later on,
10042 presumably from expose events generated for the disappearing
10043 toolkit scroll bars. */
10044 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
10046 b
= XSCROLL_BAR (bar
);
10047 x_scroll_bar_remove (b
);
10053 free_frame_xic (f
);
10056 #ifdef USE_X_TOOLKIT
10057 if (f
->output_data
.x
->widget
)
10059 XtDestroyWidget (f
->output_data
.x
->widget
);
10060 f
->output_data
.x
->widget
= NULL
;
10062 /* Tooltips don't have widgets, only a simple X window, even if
10063 we are using a toolkit. */
10064 else if (FRAME_X_WINDOW (f
))
10065 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10067 free_frame_menubar (f
);
10069 if (f
->shell_position
)
10070 xfree (f
->shell_position
);
10071 #else /* !USE_X_TOOLKIT */
10074 xg_free_frame_widgets (f
);
10075 #endif /* USE_GTK */
10077 if (FRAME_X_WINDOW (f
))
10078 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10079 #endif /* !USE_X_TOOLKIT */
10081 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
10082 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
10083 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
10084 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
10085 unload_color (f
, f
->output_data
.x
->border_pixel
);
10086 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
10088 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
10089 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
10090 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
10091 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
10092 #if defined (USE_LUCID) && defined (USE_TOOLKIT_SCROLL_BARS)
10093 /* Scrollbar shadow colors. */
10094 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
10095 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
10096 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
10097 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
10098 #endif /* USE_LUCID && USE_TOOLKIT_SCROLL_BARS */
10099 if (f
->output_data
.x
->white_relief
.pixel
!= -1)
10100 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
10101 if (f
->output_data
.x
->black_relief
.pixel
!= -1)
10102 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
10106 /* Free extra GCs allocated by x_setup_relief_colors. */
10107 if (f
->output_data
.x
->white_relief
.gc
)
10109 XFreeGC (dpyinfo
->display
, f
->output_data
.x
->white_relief
.gc
);
10110 f
->output_data
.x
->white_relief
.gc
= 0;
10112 if (f
->output_data
.x
->black_relief
.gc
)
10114 XFreeGC (dpyinfo
->display
, f
->output_data
.x
->black_relief
.gc
);
10115 f
->output_data
.x
->black_relief
.gc
= 0;
10118 /* Free cursors. */
10119 if (f
->output_data
.x
->text_cursor
!= 0)
10120 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->text_cursor
);
10121 if (f
->output_data
.x
->nontext_cursor
!= 0)
10122 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->nontext_cursor
);
10123 if (f
->output_data
.x
->modeline_cursor
!= 0)
10124 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->modeline_cursor
);
10125 if (f
->output_data
.x
->hand_cursor
!= 0)
10126 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->hand_cursor
);
10127 if (f
->output_data
.x
->hourglass_cursor
!= 0)
10128 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->hourglass_cursor
);
10129 if (f
->output_data
.x
->horizontal_drag_cursor
!= 0)
10130 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->horizontal_drag_cursor
);
10131 if (f
->output_data
.x
->vertical_drag_cursor
!= 0)
10132 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->vertical_drag_cursor
);
10134 XFlush (FRAME_X_DISPLAY (f
));
10137 xfree (f
->output_data
.x
->saved_menu_event
);
10138 xfree (f
->output_data
.x
);
10139 f
->output_data
.x
= NULL
;
10141 if (f
== dpyinfo
->x_focus_frame
)
10142 dpyinfo
->x_focus_frame
= 0;
10143 if (f
== dpyinfo
->x_focus_event_frame
)
10144 dpyinfo
->x_focus_event_frame
= 0;
10145 if (f
== dpyinfo
->x_highlight_frame
)
10146 dpyinfo
->x_highlight_frame
= 0;
10147 if (f
== hlinfo
->mouse_face_mouse_frame
)
10148 reset_mouse_highlight (hlinfo
);
10154 /* Destroy the X window of frame F. */
10157 x_destroy_window (struct frame
*f
)
10159 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10161 /* If a display connection is dead, don't try sending more
10162 commands to the X server. */
10163 if (dpyinfo
->display
!= 0)
10164 x_free_frame_resources (f
);
10166 dpyinfo
->reference_count
--;
10170 /* Setting window manager hints. */
10172 /* Set the normal size hints for the window manager, for frame F.
10173 FLAGS is the flags word to use--or 0 meaning preserve the flags
10174 that the window now has.
10175 If USER_POSITION, set the USPosition
10176 flag (this is useful when FLAGS is 0).
10177 The GTK version is in gtkutils.c. */
10181 x_wm_set_size_hint (struct frame
*f
, long flags
, bool user_position
)
10183 XSizeHints size_hints
;
10184 Window window
= FRAME_OUTER_WINDOW (f
);
10189 #ifdef USE_X_TOOLKIT
10190 if (f
->output_data
.x
->widget
)
10192 widget_update_wm_size_hints (f
->output_data
.x
->widget
);
10197 /* Setting PMaxSize caused various problems. */
10198 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
10200 size_hints
.x
= f
->left_pos
;
10201 size_hints
.y
= f
->top_pos
;
10203 size_hints
.height
= FRAME_PIXEL_HEIGHT (f
);
10204 size_hints
.width
= FRAME_PIXEL_WIDTH (f
);
10206 size_hints
.width_inc
= frame_resize_pixelwise
? 1 : FRAME_COLUMN_WIDTH (f
);
10207 size_hints
.height_inc
= frame_resize_pixelwise
? 1 : FRAME_LINE_HEIGHT (f
);
10209 size_hints
.max_width
= x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
10210 - FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
10211 size_hints
.max_height
= x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
10212 - FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
10214 /* Calculate the base and minimum sizes. */
10216 int base_width
, base_height
;
10217 int min_rows
= 0, min_cols
= 0;
10219 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
10220 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
10222 if (frame_resize_pixelwise
)
10223 /* Needed to prevent a bad protocol error crash when making the
10224 frame size very small. */
10226 min_cols
= 2 * min_cols
;
10227 min_rows
= 2 * min_rows
;
10230 /* The window manager uses the base width hints to calculate the
10231 current number of rows and columns in the frame while
10232 resizing; min_width and min_height aren't useful for this
10233 purpose, since they might not give the dimensions for a
10234 zero-row, zero-column frame.
10236 We use the base_width and base_height members if we have
10237 them; otherwise, we set the min_width and min_height members
10238 to the size for a zero x zero frame. */
10240 size_hints
.flags
|= PBaseSize
;
10241 size_hints
.base_width
= base_width
;
10242 size_hints
.base_height
= base_height
+ FRAME_MENUBAR_HEIGHT (f
);
10243 size_hints
.min_width
= base_width
+ min_cols
* FRAME_COLUMN_WIDTH (f
);
10244 size_hints
.min_height
= base_height
+ min_rows
* FRAME_LINE_HEIGHT (f
);
10247 /* If we don't need the old flags, we don't need the old hint at all. */
10250 size_hints
.flags
|= flags
;
10255 XSizeHints hints
; /* Sometimes I hate X Windows... */
10256 long supplied_return
;
10259 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
10263 size_hints
.flags
|= flags
;
10268 if (hints
.flags
& PSize
)
10269 size_hints
.flags
|= PSize
;
10270 if (hints
.flags
& PPosition
)
10271 size_hints
.flags
|= PPosition
;
10272 if (hints
.flags
& USPosition
)
10273 size_hints
.flags
|= USPosition
;
10274 if (hints
.flags
& USSize
)
10275 size_hints
.flags
|= USSize
;
10282 size_hints
.win_gravity
= f
->win_gravity
;
10283 size_hints
.flags
|= PWinGravity
;
10287 size_hints
.flags
&= ~ PPosition
;
10288 size_hints
.flags
|= USPosition
;
10290 #endif /* PWinGravity */
10292 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
10294 #endif /* not USE_GTK */
10296 /* Used for IconicState or NormalState */
10299 x_wm_set_window_state (struct frame
*f
, int state
)
10301 #ifdef USE_X_TOOLKIT
10304 XtSetArg (al
[0], XtNinitialState
, state
);
10305 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
10306 #else /* not USE_X_TOOLKIT */
10307 Window window
= FRAME_X_WINDOW (f
);
10309 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
10310 f
->output_data
.x
->wm_hints
.initial_state
= state
;
10312 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
10313 #endif /* not USE_X_TOOLKIT */
10317 x_wm_set_icon_pixmap (struct frame
*f
, ptrdiff_t pixmap_id
)
10319 Pixmap icon_pixmap
, icon_mask
;
10321 #if !defined USE_X_TOOLKIT && !defined USE_GTK
10322 Window window
= FRAME_OUTER_WINDOW (f
);
10327 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
10328 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
10329 icon_mask
= x_bitmap_mask (f
, pixmap_id
);
10330 f
->output_data
.x
->wm_hints
.icon_mask
= icon_mask
;
10334 /* It seems there is no way to turn off use of an icon
10342 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
);
10346 #elif defined (USE_X_TOOLKIT) /* same as in x_wm_set_window_state. */
10350 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
10351 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
10352 XtSetArg (al
[0], XtNiconMask
, icon_mask
);
10353 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
10356 #else /* not USE_X_TOOLKIT && not USE_GTK */
10358 f
->output_data
.x
->wm_hints
.flags
|= (IconPixmapHint
| IconMaskHint
);
10359 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
10361 #endif /* not USE_X_TOOLKIT && not USE_GTK */
10365 x_wm_set_icon_position (struct frame
*f
, int icon_x
, int icon_y
)
10367 Window window
= FRAME_OUTER_WINDOW (f
);
10369 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
10370 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
10371 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
10373 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
10377 /***********************************************************************
10379 ***********************************************************************/
10383 /* Check that FONT is valid on frame F. It is if it can be found in F's
10387 x_check_font (struct frame
*f
, struct font
*font
)
10389 eassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
10390 if (font
->driver
->check
)
10391 eassert (font
->driver
->check (f
, font
) == 0);
10394 #endif /* GLYPH_DEBUG */
10397 /***********************************************************************
10399 ***********************************************************************/
10401 #ifdef USE_X_TOOLKIT
10402 static XrmOptionDescRec emacs_options
[] = {
10403 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
10404 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
10406 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
10407 XrmoptionSepArg
, NULL
},
10408 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
10410 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10411 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10412 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10413 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
10414 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
10415 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
10416 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
10419 /* Whether atimer for Xt timeouts is activated or not. */
10421 static int x_timeout_atimer_activated_flag
;
10423 #endif /* USE_X_TOOLKIT */
10425 static int x_initialized
;
10427 /* Test whether two display-name strings agree up to the dot that separates
10428 the screen number from the server number. */
10430 same_x_server (const char *name1
, const char *name2
)
10432 int seen_colon
= 0;
10433 const char *system_name
= SSDATA (Vsystem_name
);
10434 ptrdiff_t system_name_length
= SBYTES (Vsystem_name
);
10435 ptrdiff_t length_until_period
= 0;
10437 while (system_name
[length_until_period
] != 0
10438 && system_name
[length_until_period
] != '.')
10439 length_until_period
++;
10441 /* Treat `unix' like an empty host name. */
10442 if (! strncmp (name1
, "unix:", 5))
10444 if (! strncmp (name2
, "unix:", 5))
10446 /* Treat this host's name like an empty host name. */
10447 if (! strncmp (name1
, system_name
, system_name_length
)
10448 && name1
[system_name_length
] == ':')
10449 name1
+= system_name_length
;
10450 if (! strncmp (name2
, system_name
, system_name_length
)
10451 && name2
[system_name_length
] == ':')
10452 name2
+= system_name_length
;
10453 /* Treat this host's domainless name like an empty host name. */
10454 if (! strncmp (name1
, system_name
, length_until_period
)
10455 && name1
[length_until_period
] == ':')
10456 name1
+= length_until_period
;
10457 if (! strncmp (name2
, system_name
, length_until_period
)
10458 && name2
[length_until_period
] == ':')
10459 name2
+= length_until_period
;
10461 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
10465 if (seen_colon
&& *name1
== '.')
10469 && (*name1
== '.' || *name1
== '\0')
10470 && (*name2
== '.' || *name2
== '\0'));
10473 /* Count number of set bits in mask and number of bits to shift to
10474 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
10477 get_bits_and_offset (unsigned long mask
, int *bits
, int *offset
)
10482 while (!(mask
& 1))
10498 /* Return 1 if display DISPLAY is available for use, 0 otherwise.
10499 But don't permanently open it, just test its availability. */
10502 x_display_ok (const char *display
)
10504 Display
*dpy
= XOpenDisplay (display
);
10505 return dpy
? (XCloseDisplay (dpy
), 1) : 0;
10510 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
10511 const gchar
*msg
, gpointer user_data
)
10513 if (!strstr (msg
, "g_set_prgname"))
10514 fprintf (stderr
, "%s-WARNING **: %s\n", log_domain
, msg
);
10518 /* Create invisible cursor on X display referred by DPYINFO. */
10521 make_invisible_cursor (struct x_display_info
*dpyinfo
)
10523 Display
*dpy
= dpyinfo
->display
;
10524 static char const no_data
[] = { 0 };
10529 x_catch_errors (dpy
);
10530 pix
= XCreateBitmapFromData (dpy
, dpyinfo
->root_window
, no_data
, 1, 1);
10531 if (! x_had_errors_p (dpy
) && pix
!= None
)
10535 col
.red
= col
.green
= col
.blue
= 0;
10536 col
.flags
= DoRed
| DoGreen
| DoBlue
;
10537 pixc
= XCreatePixmapCursor (dpy
, pix
, pix
, &col
, &col
, 0, 0);
10538 if (! x_had_errors_p (dpy
) && pixc
!= None
)
10540 XFreePixmap (dpy
, pix
);
10543 x_uncatch_errors ();
10548 /* True if DPY supports Xfixes extension >= 4. */
10551 x_probe_xfixes_extension (Display
*dpy
)
10555 return XFixesQueryVersion (dpy
, &major
, &minor
) && major
>= 4;
10558 #endif /* HAVE_XFIXES */
10561 /* Toggle mouse pointer visibility on frame F by using Xfixes functions. */
10564 xfixes_toggle_visible_pointer (struct frame
*f
, bool invisible
)
10568 XFixesHideCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10570 XFixesShowCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10571 f
->pointer_invisible
= invisible
;
10574 #endif /* HAVE_XFIXES */
10577 /* Toggle mouse pointer visibility on frame F by using invisible cursor. */
10580 x_toggle_visible_pointer (struct frame
*f
, bool invisible
)
10582 eassert (FRAME_DISPLAY_INFO (f
)->invisible_cursor
!= 0);
10584 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
10585 FRAME_DISPLAY_INFO (f
)->invisible_cursor
);
10587 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
10588 f
->output_data
.x
->current_cursor
);
10589 f
->pointer_invisible
= invisible
;
10592 /* Setup pointer blanking, prefer Xfixes if available. */
10595 x_setup_pointer_blanking (struct x_display_info
*dpyinfo
)
10597 /* FIXME: the brave tester should set EMACS_XFIXES because we're suspecting
10598 X server bug, see http://debbugs.gnu.org/cgi/bugreport.cgi?bug=17609. */
10599 if (egetenv ("EMACS_XFIXES") && x_probe_xfixes_extension (dpyinfo
->display
))
10600 dpyinfo
->toggle_visible_pointer
= xfixes_toggle_visible_pointer
;
10603 dpyinfo
->toggle_visible_pointer
= x_toggle_visible_pointer
;
10604 dpyinfo
->invisible_cursor
= make_invisible_cursor (dpyinfo
);
10608 /* Current X display connection identifier. Incremented for each next
10609 connection established. */
10610 static unsigned x_display_id
;
10612 /* Open a connection to X display DISPLAY_NAME, and return
10613 the structure that describes the open display.
10614 If we cannot contact the display, return null. */
10616 struct x_display_info
*
10617 x_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
10621 struct terminal
*terminal
;
10622 struct x_display_info
*dpyinfo
;
10628 if (!x_initialized
)
10634 if (! x_display_ok (SSDATA (display_name
)))
10635 error ("Display %s can't be opened", SSDATA (display_name
));
10639 #define NUM_ARGV 10
10641 char *argv
[NUM_ARGV
];
10642 char **argv2
= argv
;
10645 if (x_initialized
++ > 1)
10647 xg_display_open (SSDATA (display_name
), &dpy
);
10651 static char display_opt
[] = "--display";
10652 static char name_opt
[] = "--name";
10654 for (argc
= 0; argc
< NUM_ARGV
; ++argc
)
10658 argv
[argc
++] = initial_argv
[0];
10660 if (! NILP (display_name
))
10662 argv
[argc
++] = display_opt
;
10663 argv
[argc
++] = SSDATA (display_name
);
10666 argv
[argc
++] = name_opt
;
10667 argv
[argc
++] = resource_name
;
10669 XSetLocaleModifiers ("");
10671 /* Emacs can only handle core input events, so make sure
10672 Gtk doesn't use Xinput or Xinput2 extensions. */
10673 xputenv ("GDK_CORE_DEVICE_EVENTS=1");
10675 /* Work around GLib bug that outputs a faulty warning. See
10676 https://bugzilla.gnome.org/show_bug.cgi?id=563627. */
10677 id
= g_log_set_handler ("GLib", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
10678 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
10680 /* NULL window -> events for all windows go to our function.
10681 Call before gtk_init so Gtk+ event filters comes after our. */
10682 gdk_window_add_filter (NULL
, event_handler_gdk
, NULL
);
10684 /* gtk_init does set_locale. Fix locale before and after. */
10686 gtk_init (&argc
, &argv2
);
10689 g_log_remove_handler ("GLib", id
);
10693 dpy
= DEFAULT_GDK_DISPLAY ();
10695 #if ! GTK_CHECK_VERSION (2, 90, 0)
10696 /* Load our own gtkrc if it exists. */
10698 const char *file
= "~/.emacs.d/gtkrc";
10699 Lisp_Object s
, abs_file
;
10701 s
= build_string (file
);
10702 abs_file
= Fexpand_file_name (s
, Qnil
);
10704 if (! NILP (abs_file
) && !NILP (Ffile_readable_p (abs_file
)))
10705 gtk_rc_parse (SSDATA (abs_file
));
10709 XSetErrorHandler (x_error_handler
);
10710 XSetIOErrorHandler (x_io_error_quitter
);
10713 #else /* not USE_GTK */
10714 #ifdef USE_X_TOOLKIT
10715 /* weiner@footloose.sps.mot.com reports that this causes
10717 X protocol error: BadAtom (invalid Atom parameter)
10718 on protocol request 18skiloaf.
10719 So let's not use it until R6. */
10720 #ifdef HAVE_X11XTR6
10721 XtSetLanguageProc (NULL
, NULL
, NULL
);
10732 argv
[argc
++] = "-xrm";
10733 argv
[argc
++] = xrm_option
;
10735 turn_on_atimers (0);
10736 dpy
= XtOpenDisplay (Xt_app_con
, SSDATA (display_name
),
10737 resource_name
, EMACS_CLASS
,
10738 emacs_options
, XtNumber (emacs_options
),
10740 turn_on_atimers (1);
10742 #ifdef HAVE_X11XTR6
10743 /* I think this is to compensate for XtSetLanguageProc. */
10748 #else /* not USE_X_TOOLKIT */
10749 XSetLocaleModifiers ("");
10750 dpy
= XOpenDisplay (SSDATA (display_name
));
10751 #endif /* not USE_X_TOOLKIT */
10752 #endif /* not USE_GTK*/
10754 /* Detect failure. */
10761 /* We have definitely succeeded. Record the new connection. */
10763 dpyinfo
= xzalloc (sizeof *dpyinfo
);
10764 terminal
= x_create_terminal (dpyinfo
);
10767 struct x_display_info
*share
;
10769 for (share
= x_display_list
; share
; share
= share
->next
)
10770 if (same_x_server (SSDATA (XCAR (share
->name_list_element
)),
10771 SSDATA (display_name
)))
10774 terminal
->kboard
= share
->terminal
->kboard
;
10777 terminal
->kboard
= allocate_kboard (Qx
);
10779 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
10781 char *vendor
= ServerVendor (dpy
);
10783 /* Protect terminal from GC before removing it from the
10784 list of terminals. */
10785 struct gcpro gcpro1
;
10786 Lisp_Object gcpro_term
;
10787 XSETTERMINAL (gcpro_term
, terminal
);
10788 GCPRO1 (gcpro_term
);
10790 /* Temporarily hide the partially initialized terminal. */
10791 terminal_list
= terminal
->next_terminal
;
10793 kset_system_key_alist
10795 call1 (Qvendor_specific_keysyms
,
10796 vendor
? build_string (vendor
) : empty_unibyte_string
));
10798 terminal
->next_terminal
= terminal_list
;
10799 terminal_list
= terminal
;
10803 /* Don't let the initial kboard remain current longer than necessary.
10804 That would cause problems if a file loaded on startup tries to
10805 prompt in the mini-buffer. */
10806 if (current_kboard
== initial_kboard
)
10807 current_kboard
= terminal
->kboard
;
10809 terminal
->kboard
->reference_count
++;
10812 /* Put this display on the chain. */
10813 dpyinfo
->next
= x_display_list
;
10814 x_display_list
= dpyinfo
;
10816 dpyinfo
->name_list_element
= Fcons (display_name
, Qnil
);
10817 dpyinfo
->display
= dpy
;
10819 /* Set the name of the terminal. */
10820 terminal
->name
= xlispstrdup (display_name
);
10823 XSetAfterFunction (x_current_display
, x_trace_wire
);
10826 lim
= min (PTRDIFF_MAX
, SIZE_MAX
) - sizeof "@";
10827 if (lim
- SBYTES (Vinvocation_name
) < SBYTES (Vsystem_name
))
10828 memory_full (SIZE_MAX
);
10829 dpyinfo
->x_id
= ++x_display_id
;
10830 dpyinfo
->x_id_name
= xmalloc (SBYTES (Vinvocation_name
)
10831 + SBYTES (Vsystem_name
) + 2);
10832 strcat (strcat (strcpy (dpyinfo
->x_id_name
, SSDATA (Vinvocation_name
)), "@"),
10833 SSDATA (Vsystem_name
));
10835 /* Figure out which modifier bits mean what. */
10836 x_find_modifier_meanings (dpyinfo
);
10838 /* Get the scroll bar cursor. */
10840 /* We must create a GTK cursor, it is required for GTK widgets. */
10841 dpyinfo
->xg_cursor
= xg_create_default_cursor (dpyinfo
->display
);
10842 #endif /* USE_GTK */
10844 dpyinfo
->vertical_scroll_bar_cursor
10845 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
10847 dpyinfo
->horizontal_scroll_bar_cursor
10848 = XCreateFontCursor (dpyinfo
->display
, XC_sb_h_double_arrow
);
10850 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
10851 resource_name
, EMACS_CLASS
);
10852 #ifdef HAVE_XRMSETDATABASE
10853 XrmSetDatabase (dpyinfo
->display
, xrdb
);
10855 dpyinfo
->display
->db
= xrdb
;
10857 /* Put the rdb where we can find it in a way that works on
10859 dpyinfo
->xrdb
= xrdb
;
10861 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
10862 DefaultScreen (dpyinfo
->display
));
10863 select_visual (dpyinfo
);
10864 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
10865 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
10866 dpyinfo
->icon_bitmap_id
= -1;
10867 dpyinfo
->wm_type
= X_WMTYPE_UNKNOWN
;
10869 reset_mouse_highlight (&dpyinfo
->mouse_highlight
);
10871 /* See if we can construct pixel values from RGB values. */
10872 if (dpyinfo
->visual
->class == TrueColor
)
10874 get_bits_and_offset (dpyinfo
->visual
->red_mask
,
10875 &dpyinfo
->red_bits
, &dpyinfo
->red_offset
);
10876 get_bits_and_offset (dpyinfo
->visual
->blue_mask
,
10877 &dpyinfo
->blue_bits
, &dpyinfo
->blue_offset
);
10878 get_bits_and_offset (dpyinfo
->visual
->green_mask
,
10879 &dpyinfo
->green_bits
, &dpyinfo
->green_offset
);
10882 /* See if a private colormap is requested. */
10883 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
10885 if (dpyinfo
->visual
->class == PseudoColor
)
10888 value
= display_x_get_resource (dpyinfo
,
10889 build_string ("privateColormap"),
10890 build_string ("PrivateColormap"),
10892 if (STRINGP (value
)
10893 && (!strcmp (SSDATA (value
), "true")
10894 || !strcmp (SSDATA (value
), "on")))
10895 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
10899 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
10900 dpyinfo
->visual
, AllocNone
);
10904 /* If we are using Xft, the following precautions should be made:
10906 1. Make sure that the Xrender extension is added before the Xft one.
10907 Otherwise, the close-display hook set by Xft is called after the one
10908 for Xrender, and the former tries to re-add the latter. This results
10909 in inconsistency of internal states and leads to X protocol error when
10910 one reconnects to the same X server (Bug#1696).
10912 2. Check dpi value in X resources. It is better we use it as well,
10913 since Xft will use it, as will all Gnome applications. If our real DPI
10914 is smaller or larger than the one Xft uses, our font will look smaller
10915 or larger than other for other applications, even if it is the same
10916 font name (monospace-10 for example). */
10918 int event_base
, error_base
;
10922 XRenderQueryExtension (dpyinfo
->display
, &event_base
, &error_base
);
10924 v
= XGetDefault (dpyinfo
->display
, "Xft", "dpi");
10925 if (v
!= NULL
&& sscanf (v
, "%lf", &d
) == 1)
10926 dpyinfo
->resy
= dpyinfo
->resx
= d
;
10930 if (dpyinfo
->resy
< 1)
10932 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
10933 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
10934 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
10935 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10936 dpyinfo
->resy
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10937 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
10938 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
10939 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10940 dpyinfo
->resx
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10944 static const struct
10949 #define ATOM_REFS_INIT(string, member) \
10950 { string, offsetof (struct x_display_info, member) },
10951 ATOM_REFS_INIT ("WM_PROTOCOLS", Xatom_wm_protocols
)
10952 ATOM_REFS_INIT ("WM_TAKE_FOCUS", Xatom_wm_take_focus
)
10953 ATOM_REFS_INIT ("WM_SAVE_YOURSELF", Xatom_wm_save_yourself
)
10954 ATOM_REFS_INIT ("WM_DELETE_WINDOW", Xatom_wm_delete_window
)
10955 ATOM_REFS_INIT ("WM_CHANGE_STATE", Xatom_wm_change_state
)
10956 ATOM_REFS_INIT ("WM_CONFIGURE_DENIED", Xatom_wm_configure_denied
)
10957 ATOM_REFS_INIT ("WM_MOVED", Xatom_wm_window_moved
)
10958 ATOM_REFS_INIT ("WM_CLIENT_LEADER", Xatom_wm_client_leader
)
10959 ATOM_REFS_INIT ("Editres", Xatom_editres
)
10960 ATOM_REFS_INIT ("CLIPBOARD", Xatom_CLIPBOARD
)
10961 ATOM_REFS_INIT ("TIMESTAMP", Xatom_TIMESTAMP
)
10962 ATOM_REFS_INIT ("TEXT", Xatom_TEXT
)
10963 ATOM_REFS_INIT ("COMPOUND_TEXT", Xatom_COMPOUND_TEXT
)
10964 ATOM_REFS_INIT ("UTF8_STRING", Xatom_UTF8_STRING
)
10965 ATOM_REFS_INIT ("DELETE", Xatom_DELETE
)
10966 ATOM_REFS_INIT ("MULTIPLE", Xatom_MULTIPLE
)
10967 ATOM_REFS_INIT ("INCR", Xatom_INCR
)
10968 ATOM_REFS_INIT ("_EMACS_TMP_", Xatom_EMACS_TMP
)
10969 ATOM_REFS_INIT ("TARGETS", Xatom_TARGETS
)
10970 ATOM_REFS_INIT ("NULL", Xatom_NULL
)
10971 ATOM_REFS_INIT ("ATOM", Xatom_ATOM
)
10972 ATOM_REFS_INIT ("ATOM_PAIR", Xatom_ATOM_PAIR
)
10973 ATOM_REFS_INIT ("CLIPBOARD_MANAGER", Xatom_CLIPBOARD_MANAGER
)
10974 ATOM_REFS_INIT ("_XEMBED_INFO", Xatom_XEMBED_INFO
)
10975 /* For properties of font. */
10976 ATOM_REFS_INIT ("PIXEL_SIZE", Xatom_PIXEL_SIZE
)
10977 ATOM_REFS_INIT ("AVERAGE_WIDTH", Xatom_AVERAGE_WIDTH
)
10978 ATOM_REFS_INIT ("_MULE_BASELINE_OFFSET", Xatom_MULE_BASELINE_OFFSET
)
10979 ATOM_REFS_INIT ("_MULE_RELATIVE_COMPOSE", Xatom_MULE_RELATIVE_COMPOSE
)
10980 ATOM_REFS_INIT ("_MULE_DEFAULT_ASCENT", Xatom_MULE_DEFAULT_ASCENT
)
10981 /* Ghostscript support. */
10982 ATOM_REFS_INIT ("DONE", Xatom_DONE
)
10983 ATOM_REFS_INIT ("PAGE", Xatom_PAGE
)
10984 ATOM_REFS_INIT ("SCROLLBAR", Xatom_Scrollbar
)
10985 ATOM_REFS_INIT ("HORIZONTAL_SCROLLBAR", Xatom_Horizontal_Scrollbar
)
10986 ATOM_REFS_INIT ("_XEMBED", Xatom_XEMBED
)
10988 ATOM_REFS_INIT ("_NET_WM_STATE", Xatom_net_wm_state
)
10989 ATOM_REFS_INIT ("_NET_WM_STATE_FULLSCREEN", Xatom_net_wm_state_fullscreen
)
10990 ATOM_REFS_INIT ("_NET_WM_STATE_MAXIMIZED_HORZ",
10991 Xatom_net_wm_state_maximized_horz
)
10992 ATOM_REFS_INIT ("_NET_WM_STATE_MAXIMIZED_VERT",
10993 Xatom_net_wm_state_maximized_vert
)
10994 ATOM_REFS_INIT ("_NET_WM_STATE_STICKY", Xatom_net_wm_state_sticky
)
10995 ATOM_REFS_INIT ("_NET_WM_STATE_HIDDEN", Xatom_net_wm_state_hidden
)
10996 ATOM_REFS_INIT ("_NET_WM_WINDOW_TYPE", Xatom_net_window_type
)
10997 ATOM_REFS_INIT ("_NET_WM_WINDOW_TYPE_TOOLTIP",
10998 Xatom_net_window_type_tooltip
)
10999 ATOM_REFS_INIT ("_NET_WM_ICON_NAME", Xatom_net_wm_icon_name
)
11000 ATOM_REFS_INIT ("_NET_WM_NAME", Xatom_net_wm_name
)
11001 ATOM_REFS_INIT ("_NET_SUPPORTED", Xatom_net_supported
)
11002 ATOM_REFS_INIT ("_NET_SUPPORTING_WM_CHECK", Xatom_net_supporting_wm_check
)
11003 ATOM_REFS_INIT ("_NET_WM_WINDOW_OPACITY", Xatom_net_wm_window_opacity
)
11004 ATOM_REFS_INIT ("_NET_ACTIVE_WINDOW", Xatom_net_active_window
)
11005 ATOM_REFS_INIT ("_NET_FRAME_EXTENTS", Xatom_net_frame_extents
)
11006 ATOM_REFS_INIT ("_NET_CURRENT_DESKTOP", Xatom_net_current_desktop
)
11007 ATOM_REFS_INIT ("_NET_WORKAREA", Xatom_net_workarea
)
11008 /* Session management */
11009 ATOM_REFS_INIT ("SM_CLIENT_ID", Xatom_SM_CLIENT_ID
)
11010 ATOM_REFS_INIT ("_XSETTINGS_SETTINGS", Xatom_xsettings_prop
)
11011 ATOM_REFS_INIT ("MANAGER", Xatom_xsettings_mgr
)
11015 const int atom_count
= ARRAYELTS (atom_refs
);
11016 /* 1 for _XSETTINGS_SN */
11017 const int total_atom_count
= 1 + atom_count
;
11018 Atom
*atoms_return
= xmalloc (total_atom_count
* sizeof *atoms_return
);
11019 char **atom_names
= xmalloc (total_atom_count
* sizeof *atom_names
);
11020 static char const xsettings_fmt
[] = "_XSETTINGS_S%d";
11021 char xsettings_atom_name
[sizeof xsettings_fmt
- 2
11022 + INT_STRLEN_BOUND (int)];
11024 for (i
= 0; i
< atom_count
; i
++)
11025 atom_names
[i
] = (char *) atom_refs
[i
].name
;
11027 /* Build _XSETTINGS_SN atom name */
11028 sprintf (xsettings_atom_name
, xsettings_fmt
,
11029 XScreenNumberOfScreen (dpyinfo
->screen
));
11030 atom_names
[i
] = xsettings_atom_name
;
11032 XInternAtoms (dpyinfo
->display
, atom_names
, total_atom_count
,
11033 False
, atoms_return
);
11035 for (i
= 0; i
< atom_count
; i
++)
11036 *(Atom
*) ((char *) dpyinfo
+ atom_refs
[i
].offset
) = atoms_return
[i
];
11038 /* Manual copy of last atom */
11039 dpyinfo
->Xatom_xsettings_sel
= atoms_return
[i
];
11041 xfree (atom_names
);
11042 xfree (atoms_return
);
11045 dpyinfo
->x_dnd_atoms_size
= 8;
11046 dpyinfo
->x_dnd_atoms
= xmalloc (sizeof *dpyinfo
->x_dnd_atoms
11047 * dpyinfo
->x_dnd_atoms_size
);
11049 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
11050 gray_bits
, gray_width
, gray_height
,
11053 x_setup_pointer_blanking (dpyinfo
);
11056 xim_initialize (dpyinfo
, resource_name
);
11059 xsettings_initialize (dpyinfo
);
11061 connection
= ConnectionNumber (dpyinfo
->display
);
11063 /* This is only needed for distinguishing keyboard and process input. */
11064 if (connection
!= 0)
11065 add_keyboard_wait_descriptor (connection
);
11068 fcntl (connection
, F_SETOWN
, getpid ());
11069 #endif /* ! defined (F_SETOWN) */
11071 if (interrupt_input
)
11072 init_sigio (connection
);
11076 XFontStruct
*xfont
= NULL
;
11077 XrmValue d
, fr
, to
;
11080 dpy
= dpyinfo
->display
;
11081 d
.addr
= (XPointer
)&dpy
;
11082 d
.size
= sizeof (Display
*);
11083 fr
.addr
= XtDefaultFont
;
11084 fr
.size
= sizeof (XtDefaultFont
);
11085 to
.size
= sizeof (Font
*);
11086 to
.addr
= (XPointer
)&font
;
11087 x_catch_errors (dpy
);
11088 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
11090 if (x_had_errors_p (dpy
) || !((xfont
= XQueryFont (dpy
, font
))))
11091 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
11093 XFreeFont (dpy
, xfont
);
11094 x_uncatch_errors ();
11098 /* See if we should run in synchronous mode. This is useful
11099 for debugging X code. */
11102 value
= display_x_get_resource (dpyinfo
,
11103 build_string ("synchronous"),
11104 build_string ("Synchronous"),
11106 if (STRINGP (value
)
11107 && (!strcmp (SSDATA (value
), "true")
11108 || !strcmp (SSDATA (value
), "on")))
11109 XSynchronize (dpyinfo
->display
, True
);
11114 value
= display_x_get_resource (dpyinfo
,
11115 build_string ("useXIM"),
11116 build_string ("UseXIM"),
11119 if (STRINGP (value
)
11120 && (!strcmp (SSDATA (value
), "false")
11121 || !strcmp (SSDATA (value
), "off")))
11124 if (STRINGP (value
)
11125 && (!strcmp (SSDATA (value
), "true")
11126 || !strcmp (SSDATA (value
), "on")))
11132 /* Only do this for the very first display in the Emacs session.
11133 Ignore X session management when Emacs was first started on a
11135 if (terminal
->id
== 1)
11136 x_session_initialize (dpyinfo
);
11144 /* Get rid of display DPYINFO, deleting all frames on it,
11145 and without sending any more commands to the X server. */
11148 x_delete_display (struct x_display_info
*dpyinfo
)
11150 struct terminal
*t
;
11152 /* Close all frames and delete the generic struct terminal for this
11154 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
11155 if (t
->type
== output_x_window
&& t
->display_info
.x
== dpyinfo
)
11158 /* Close X session management when we close its display. */
11159 if (t
->id
== 1 && x_session_have_connection ())
11160 x_session_close ();
11162 delete_terminal (t
);
11166 if (next_noop_dpyinfo
== dpyinfo
)
11167 next_noop_dpyinfo
= dpyinfo
->next
;
11169 if (x_display_list
== dpyinfo
)
11170 x_display_list
= dpyinfo
->next
;
11173 struct x_display_info
*tail
;
11175 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
11176 if (tail
->next
== dpyinfo
)
11177 tail
->next
= tail
->next
->next
;
11180 xfree (dpyinfo
->x_id_name
);
11181 xfree (dpyinfo
->x_dnd_atoms
);
11182 xfree (dpyinfo
->color_cells
);
11186 #ifdef USE_X_TOOLKIT
11188 /* Atimer callback function for TIMER. Called every 0.1s to process
11189 Xt timeouts, if needed. We must avoid calling XtAppPending as
11190 much as possible because that function does an implicit XFlush
11191 that slows us down. */
11194 x_process_timeouts (struct atimer
*timer
)
11197 x_timeout_atimer_activated_flag
= 0;
11198 if (toolkit_scroll_bar_interaction
|| popup_activated ())
11200 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
11201 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
11202 /* Reactivate the atimer for next time. */
11203 x_activate_timeout_atimer ();
11208 /* Install an asynchronous timer that processes Xt timeout events
11209 every 0.1s as long as either `toolkit_scroll_bar_interaction' or
11210 `popup_activated_flag' (in xmenu.c) is set. Make sure to call this
11211 function whenever these variables are set. This is necessary
11212 because some widget sets use timeouts internally, for example the
11213 LessTif menu bar, or the Xaw3d scroll bar. When Xt timeouts aren't
11214 processed, these widgets don't behave normally. */
11217 x_activate_timeout_atimer (void)
11220 if (!x_timeout_atimer_activated_flag
)
11222 struct timespec interval
= make_timespec (0, 100 * 1000 * 1000);
11223 start_atimer (ATIMER_RELATIVE
, interval
, x_process_timeouts
, 0);
11224 x_timeout_atimer_activated_flag
= 1;
11229 #endif /* USE_X_TOOLKIT */
11232 /* Set up use of X before we make the first connection. */
11234 static struct redisplay_interface x_redisplay_interface
=
11236 x_frame_parm_handlers
,
11240 x_clear_end_of_line
,
11242 x_after_update_window_line
,
11243 x_update_window_begin
,
11244 x_update_window_end
,
11246 x_clear_window_mouse_face
,
11247 x_get_glyph_overhangs
,
11248 x_fix_overlapping_area
,
11249 x_draw_fringe_bitmap
,
11250 0, /* define_fringe_bitmap */
11251 0, /* destroy_fringe_bitmap */
11252 x_compute_glyph_string_overhangs
,
11253 x_draw_glyph_string
,
11254 x_define_frame_cursor
,
11255 x_clear_frame_area
,
11256 x_draw_window_cursor
,
11257 x_draw_vertical_window_border
,
11258 x_draw_window_divider
,
11259 x_shift_glyphs_for_insert
,
11265 /* This function is called when the last frame on a display is deleted. */
11267 x_delete_terminal (struct terminal
*terminal
)
11269 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
11270 int connection
= -1;
11272 /* Protect against recursive calls. delete_frame in
11273 delete_terminal calls us back when it deletes our last frame. */
11274 if (!terminal
->name
)
11279 /* We must close our connection to the XIM server before closing the
11282 xim_close_dpy (dpyinfo
);
11285 /* If called from x_connection_closed, the display may already be closed
11286 and dpyinfo->display was set to 0 to indicate that. */
11287 if (dpyinfo
->display
)
11289 connection
= ConnectionNumber (dpyinfo
->display
);
11291 x_destroy_all_bitmaps (dpyinfo
);
11292 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
11294 /* Whether or not XCloseDisplay destroys the associated resource
11295 database depends on the version of libX11. To avoid both
11296 crash and memory leak, we dissociate the database from the
11297 display and then destroy dpyinfo->xrdb ourselves.
11299 Unfortunately, the above strategy does not work in some
11300 situations due to a bug in newer versions of libX11: because
11301 XrmSetDatabase doesn't clear the flag XlibDisplayDfltRMDB if
11302 dpy->db is NULL, XCloseDisplay destroys the associated
11303 database whereas it has not been created by XGetDefault
11304 (Bug#21974 in freedesktop.org Bugzilla). As a workaround, we
11305 don't destroy the database here in order to avoid the crash
11306 in the above situations for now, though that may cause memory
11307 leaks in other situations. */
11309 #ifdef HAVE_XRMSETDATABASE
11310 XrmSetDatabase (dpyinfo
->display
, NULL
);
11312 dpyinfo
->display
->db
= NULL
;
11314 /* We used to call XrmDestroyDatabase from x_delete_display, but
11315 some older versions of libX11 crash if we call it after
11316 closing all the displays. */
11317 XrmDestroyDatabase (dpyinfo
->xrdb
);
11321 xg_display_close (dpyinfo
->display
);
11323 #ifdef USE_X_TOOLKIT
11324 XtCloseDisplay (dpyinfo
->display
);
11326 XCloseDisplay (dpyinfo
->display
);
11328 #endif /* ! USE_GTK */
11331 /* No more input on this descriptor. */
11332 if (connection
!= -1)
11333 delete_keyboard_wait_descriptor (connection
);
11335 /* Mark as dead. */
11336 dpyinfo
->display
= NULL
;
11337 x_delete_display (dpyinfo
);
11341 /* Create a struct terminal, initialize it with the X11 specific
11342 functions and make DISPLAY->TERMINAL point to it. */
11344 static struct terminal
*
11345 x_create_terminal (struct x_display_info
*dpyinfo
)
11347 struct terminal
*terminal
;
11349 terminal
= create_terminal (output_x_window
, &x_redisplay_interface
);
11351 terminal
->display_info
.x
= dpyinfo
;
11352 dpyinfo
->terminal
= terminal
;
11354 /* kboard is initialized in x_term_init. */
11356 terminal
->clear_frame_hook
= x_clear_frame
;
11357 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
11358 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
11359 terminal
->ring_bell_hook
= XTring_bell
;
11360 terminal
->toggle_invisible_pointer_hook
= XTtoggle_invisible_pointer
;
11361 terminal
->update_begin_hook
= x_update_begin
;
11362 terminal
->update_end_hook
= x_update_end
;
11363 terminal
->read_socket_hook
= XTread_socket
;
11364 terminal
->frame_up_to_date_hook
= XTframe_up_to_date
;
11365 terminal
->mouse_position_hook
= XTmouse_position
;
11366 terminal
->frame_rehighlight_hook
= XTframe_rehighlight
;
11367 terminal
->frame_raise_lower_hook
= XTframe_raise_lower
;
11368 terminal
->fullscreen_hook
= XTfullscreen_hook
;
11369 terminal
->menu_show_hook
= x_menu_show
;
11370 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
11371 terminal
->popup_dialog_hook
= xw_popup_dialog
;
11373 terminal
->set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
11374 terminal
->set_horizontal_scroll_bar_hook
= XTset_horizontal_scroll_bar
;
11375 terminal
->condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
11376 terminal
->redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
11377 terminal
->judge_scroll_bars_hook
= XTjudge_scroll_bars
;
11378 terminal
->delete_frame_hook
= x_destroy_window
;
11379 terminal
->delete_terminal_hook
= x_delete_terminal
;
11380 /* Other hooks are NULL by default. */
11386 x_initialize (void)
11391 any_help_event_p
= 0;
11392 ignore_next_mouse_click_timeout
= 0;
11395 current_count
= -1;
11398 /* Try to use interrupt input; if we can't, then start polling. */
11399 Fset_input_interrupt_mode (Qt
);
11401 #ifdef USE_X_TOOLKIT
11402 XtToolkitInitialize ();
11404 Xt_app_con
= XtCreateApplicationContext ();
11406 /* Register a converter from strings to pixels, which uses
11407 Emacs' color allocation infrastructure. */
11408 XtAppSetTypeConverter (Xt_app_con
,
11409 XtRString
, XtRPixel
, cvt_string_to_pixel
,
11410 cvt_string_to_pixel_args
,
11411 XtNumber (cvt_string_to_pixel_args
),
11412 XtCacheByDisplay
, cvt_pixel_dtor
);
11414 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
11417 #ifdef USE_TOOLKIT_SCROLL_BARS
11419 xaw3d_arrow_scroll
= False
;
11420 xaw3d_pick_top
= True
;
11424 /* Note that there is no real way portable across R3/R4 to get the
11425 original error handler. */
11426 XSetErrorHandler (x_error_handler
);
11427 XSetIOErrorHandler (x_io_error_quitter
);
11432 syms_of_xterm (void)
11434 x_error_message
= NULL
;
11436 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
11437 DEFSYM (Qlatin_1
, "latin-1");
11440 xg_default_icon_file
= build_pure_c_string ("icons/hicolor/scalable/apps/emacs.svg");
11441 staticpro (&xg_default_icon_file
);
11443 DEFSYM (Qx_gtk_map_stock
, "x-gtk-map-stock");
11446 DEFVAR_BOOL ("x-use-underline-position-properties",
11447 x_use_underline_position_properties
,
11448 doc
: /* Non-nil means make use of UNDERLINE_POSITION font properties.
11449 A value of nil means ignore them. If you encounter fonts with bogus
11450 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
11451 to 4.1, set this to nil. You can also use `underline-minimum-offset'
11452 to override the font's UNDERLINE_POSITION for small font display
11454 x_use_underline_position_properties
= 1;
11456 DEFVAR_BOOL ("x-underline-at-descent-line",
11457 x_underline_at_descent_line
,
11458 doc
: /* Non-nil means to draw the underline at the same place as the descent line.
11459 A value of nil means to draw the underline according to the value of the
11460 variable `x-use-underline-position-properties', which is usually at the
11461 baseline level. The default value is nil. */);
11462 x_underline_at_descent_line
= 0;
11464 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
11465 x_mouse_click_focus_ignore_position
,
11466 doc
: /* Non-nil means that a mouse click to focus a frame does not move point.
11467 This variable is only used when the window manager requires that you
11468 click on a frame to select it (give it focus). In that case, a value
11469 of nil, means that the selected window and cursor position changes to
11470 reflect the mouse click position, while a non-nil value means that the
11471 selected window or cursor position is preserved. */);
11472 x_mouse_click_focus_ignore_position
= 0;
11474 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars
,
11475 doc
: /* Which toolkit scroll bars Emacs uses, if any.
11476 A value of nil means Emacs doesn't use toolkit scroll bars.
11477 With the X Window system, the value is a symbol describing the
11478 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
11479 With MS Windows or Nextstep, the value is t. */);
11480 #ifdef USE_TOOLKIT_SCROLL_BARS
11482 Vx_toolkit_scroll_bars
= intern_c_string ("motif");
11483 #elif defined HAVE_XAW3D
11484 Vx_toolkit_scroll_bars
= intern_c_string ("xaw3d");
11486 Vx_toolkit_scroll_bars
= intern_c_string ("gtk");
11488 Vx_toolkit_scroll_bars
= intern_c_string ("xaw");
11491 Vx_toolkit_scroll_bars
= Qnil
;
11494 DEFSYM (Qmodifier_value
, "modifier-value");
11495 DEFSYM (Qalt
, "alt");
11496 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
11497 DEFSYM (Qhyper
, "hyper");
11498 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
11499 DEFSYM (Qmeta
, "meta");
11500 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
11501 DEFSYM (Qsuper
, "super");
11502 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
11504 DEFVAR_LISP ("x-alt-keysym", Vx_alt_keysym
,
11505 doc
: /* Which keys Emacs uses for the alt modifier.
11506 This should be one of the symbols `alt', `hyper', `meta', `super'.
11507 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
11508 is nil, which is the same as `alt'. */);
11509 Vx_alt_keysym
= Qnil
;
11511 DEFVAR_LISP ("x-hyper-keysym", Vx_hyper_keysym
,
11512 doc
: /* Which keys Emacs uses for the hyper modifier.
11513 This should be one of the symbols `alt', `hyper', `meta', `super'.
11514 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
11515 default is nil, which is the same as `hyper'. */);
11516 Vx_hyper_keysym
= Qnil
;
11518 DEFVAR_LISP ("x-meta-keysym", Vx_meta_keysym
,
11519 doc
: /* Which keys Emacs uses for the meta modifier.
11520 This should be one of the symbols `alt', `hyper', `meta', `super'.
11521 For example, `meta' means use the Meta_L and Meta_R keysyms. The
11522 default is nil, which is the same as `meta'. */);
11523 Vx_meta_keysym
= Qnil
;
11525 DEFVAR_LISP ("x-super-keysym", Vx_super_keysym
,
11526 doc
: /* Which keys Emacs uses for the super modifier.
11527 This should be one of the symbols `alt', `hyper', `meta', `super'.
11528 For example, `super' means use the Super_L and Super_R keysyms. The
11529 default is nil, which is the same as `super'. */);
11530 Vx_super_keysym
= Qnil
;
11532 DEFVAR_LISP ("x-keysym-table", Vx_keysym_table
,
11533 doc
: /* Hash table of character codes indexed by X keysym codes. */);
11534 Vx_keysym_table
= make_hash_table (hashtest_eql
, make_number (900),
11535 make_float (DEFAULT_REHASH_SIZE
),
11536 make_float (DEFAULT_REHASH_THRESHOLD
),