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 bar
->horizontal
= horizontal
;
5478 #if defined (USE_TOOLKIT_SCROLL_BARS) && defined (USE_LUCID)
5479 bar
->last_seen_part
= scroll_bar_nowhere
;
5482 /* Add bar to its frame's list of scroll bars. */
5483 bar
->next
= FRAME_SCROLL_BARS (f
);
5485 XSETVECTOR (barobj
, bar
);
5486 fset_scroll_bars (f
, barobj
);
5487 if (!NILP (bar
->next
))
5488 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
5490 /* Map the window/widget. */
5491 #ifdef USE_TOOLKIT_SCROLL_BARS
5495 xg_update_horizontal_scrollbar_pos (f
, bar
->x_window
, top
,
5496 left
, width
, max (height
, 1));
5498 xg_update_scrollbar_pos (f
, bar
->x_window
, top
,
5499 left
, width
, max (height
, 1));
5500 #else /* not USE_GTK */
5501 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
5502 XtConfigureWidget (scroll_bar
, left
, top
, width
, max (height
, 1), 0);
5503 XtMapWidget (scroll_bar
);
5504 #endif /* not USE_GTK */
5506 #else /* not USE_TOOLKIT_SCROLL_BARS */
5507 XMapRaised (FRAME_X_DISPLAY (f
), bar
->x_window
);
5508 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5515 #ifndef USE_TOOLKIT_SCROLL_BARS
5517 /* Draw BAR's handle in the proper position.
5519 If the handle is already drawn from START to END, don't bother
5520 redrawing it, unless REBUILD is non-zero; in that case, always
5521 redraw it. (REBUILD is handy for drawing the handle after expose
5524 Normally, we want to constrain the start and end of the handle to
5525 fit inside its rectangle, but if the user is dragging the scroll
5526 bar handle, we want to let them drag it down all the way, so that
5527 the bar's top is as far down as it goes; otherwise, there's no way
5528 to move to the very end of the buffer. */
5531 x_scroll_bar_set_handle (struct scroll_bar
*bar
, int start
, int end
, int rebuild
)
5533 bool dragging
= bar
->dragging
!= -1;
5534 Window w
= bar
->x_window
;
5535 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5536 GC gc
= f
->output_data
.x
->normal_gc
;
5538 /* If the display is already accurate, do nothing. */
5540 && start
== bar
->start
5547 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, bar
->width
);
5548 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, bar
->height
);
5549 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
5551 /* Make sure the values are reasonable, and try to preserve
5552 the distance between start and end. */
5554 int length
= end
- start
;
5558 else if (start
> top_range
)
5560 end
= start
+ length
;
5564 else if (end
> top_range
&& ! dragging
)
5568 /* Store the adjusted setting in the scroll bar. */
5572 /* Clip the end position, just for display. */
5573 if (end
> top_range
)
5576 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
5577 below top positions, to make sure the handle is always at least
5578 that many pixels tall. */
5579 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
5581 /* Draw the empty space above the handle. Note that we can't clear
5582 zero-height areas; that means "clear to end of window." */
5583 if ((inside_width
> 0) && (start
> 0))
5584 x_clear_area (FRAME_X_DISPLAY (f
), w
,
5585 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
5586 VERTICAL_SCROLL_BAR_TOP_BORDER
,
5587 inside_width
, start
);
5589 /* Change to proper foreground color if one is specified. */
5590 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5591 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5592 f
->output_data
.x
->scroll_bar_foreground_pixel
);
5594 /* Draw the handle itself. */
5595 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
5596 /* x, y, width, height */
5597 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
5598 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
5599 inside_width
, end
- start
);
5601 /* Restore the foreground color of the GC if we changed it above. */
5602 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5603 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5604 FRAME_FOREGROUND_PIXEL (f
));
5606 /* Draw the empty space below the handle. Note that we can't
5607 clear zero-height areas; that means "clear to end of window." */
5608 if ((inside_width
> 0) && (end
< inside_height
))
5609 x_clear_area (FRAME_X_DISPLAY (f
), w
,
5610 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
5611 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
5612 inside_width
, inside_height
- end
);
5618 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5620 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
5624 x_scroll_bar_remove (struct scroll_bar
*bar
)
5626 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5629 #ifdef USE_TOOLKIT_SCROLL_BARS
5631 xg_remove_scroll_bar (f
, bar
->x_window
);
5632 #else /* not USE_GTK */
5633 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
5634 #endif /* not USE_GTK */
5636 XDestroyWindow (FRAME_X_DISPLAY (f
), bar
->x_window
);
5639 /* Dissociate this scroll bar from its window. */
5640 if (bar
->horizontal
)
5641 wset_horizontal_scroll_bar (XWINDOW (bar
->window
), Qnil
);
5643 wset_vertical_scroll_bar (XWINDOW (bar
->window
), Qnil
);
5649 /* Set the handle of the vertical scroll bar for WINDOW to indicate
5650 that we are displaying PORTION characters out of a total of WHOLE
5651 characters, starting at POSITION. If WINDOW has no scroll bar,
5655 XTset_vertical_scroll_bar (struct window
*w
, int portion
, int whole
, int position
)
5657 struct frame
*f
= XFRAME (w
->frame
);
5659 struct scroll_bar
*bar
;
5660 int top
, height
, left
, width
;
5661 int window_y
, window_height
;
5663 /* Get window dimensions. */
5664 window_box (w
, ANY_AREA
, 0, &window_y
, 0, &window_height
);
5666 height
= window_height
;
5667 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
5668 width
= WINDOW_SCROLL_BAR_AREA_WIDTH (w
);
5670 /* Does the scroll bar exist yet? */
5671 if (NILP (w
->vertical_scroll_bar
))
5673 if (width
> 0 && height
> 0)
5676 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5677 left
, top
, width
, height
);
5681 bar
= x_scroll_bar_create (w
, top
, left
, width
, max (height
, 1), 0);
5685 /* It may just need to be moved and resized. */
5686 unsigned int mask
= 0;
5688 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5692 if (left
!= bar
->left
)
5694 if (top
!= bar
->top
)
5696 if (width
!= bar
->width
)
5698 if (height
!= bar
->height
)
5701 #ifdef USE_TOOLKIT_SCROLL_BARS
5703 /* Move/size the scroll bar widget. */
5706 /* Since toolkit scroll bars are smaller than the space reserved
5707 for them on the frame, we have to clear "under" them. */
5708 if (width
> 0 && height
> 0)
5709 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5710 left
, top
, width
, height
);
5712 xg_update_scrollbar_pos (f
, bar
->x_window
, top
,
5713 left
, width
, max (height
, 1));
5714 #else /* not USE_GTK */
5715 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
5716 left
, top
, width
, max (height
, 1), 0);
5717 #endif /* not USE_GTK */
5719 #else /* not USE_TOOLKIT_SCROLL_BARS */
5721 /* Move/size the scroll bar window. */
5730 XConfigureWindow (FRAME_X_DISPLAY (f
), bar
->x_window
,
5734 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5736 /* Remember new settings. */
5740 bar
->height
= height
;
5745 #ifdef USE_TOOLKIT_SCROLL_BARS
5746 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
5747 #else /* not USE_TOOLKIT_SCROLL_BARS */
5748 /* Set the scroll bar's current state, unless we're currently being
5750 if (bar
->dragging
== -1)
5752 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
5755 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
5758 int start
= ((double) position
* top_range
) / whole
;
5759 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
5760 x_scroll_bar_set_handle (bar
, start
, end
, 0);
5763 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5765 XSETVECTOR (barobj
, bar
);
5766 wset_vertical_scroll_bar (w
, barobj
);
5771 XTset_horizontal_scroll_bar (struct window
*w
, int portion
, int whole
, int position
)
5773 struct frame
*f
= XFRAME (w
->frame
);
5775 struct scroll_bar
*bar
;
5776 int top
, height
, left
, width
;
5777 int window_x
, window_width
;
5778 int pixel_width
= WINDOW_PIXEL_WIDTH (w
);
5780 /* Get window dimensions. */
5781 window_box (w
, ANY_AREA
, &window_x
, 0, &window_width
, 0);
5783 width
= window_width
;
5784 top
= WINDOW_SCROLL_BAR_AREA_Y (w
);
5785 height
= WINDOW_SCROLL_BAR_AREA_HEIGHT (w
);
5787 /* Does the scroll bar exist yet? */
5788 if (NILP (w
->horizontal_scroll_bar
))
5790 if (width
> 0 && height
> 0)
5794 /* Clear also part between window_width and
5795 WINDOW_PIXEL_WIDTH. */
5796 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5797 left
, top
, pixel_width
, height
);
5801 bar
= x_scroll_bar_create (w
, top
, left
, width
, height
, 1);
5805 /* It may just need to be moved and resized. */
5806 unsigned int mask
= 0;
5808 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
5812 if (left
!= bar
->left
)
5814 if (top
!= bar
->top
)
5816 if (width
!= bar
->width
)
5818 if (height
!= bar
->height
)
5821 #ifdef USE_TOOLKIT_SCROLL_BARS
5822 /* Move/size the scroll bar widget. */
5825 /* Since toolkit scroll bars are smaller than the space reserved
5826 for them on the frame, we have to clear "under" them. */
5827 if (width
> 0 && height
> 0)
5828 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5829 WINDOW_LEFT_EDGE_X (w
), top
,
5830 pixel_width
- WINDOW_RIGHT_DIVIDER_WIDTH (w
), height
);
5832 xg_update_horizontal_scrollbar_pos (f
, bar
->x_window
, top
, left
,
5834 #else /* not USE_GTK */
5835 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
5836 left
, top
, width
, height
, 0);
5837 #endif /* not USE_GTK */
5839 #else /* not USE_TOOLKIT_SCROLL_BARS */
5841 /* Clear areas not covered by the scroll bar because it's not as
5842 wide as the area reserved for it. This makes sure a
5843 previous mode line display is cleared after C-x 2 C-x 1, for
5846 int area_height
= WINDOW_CONFIG_SCROLL_BAR_HEIGHT (w
);
5847 int rest
= area_height
- height
;
5848 if (rest
> 0 && width
> 0)
5849 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5850 left
, top
, width
, rest
);
5853 /* Move/size the scroll bar window. */
5862 XConfigureWindow (FRAME_X_DISPLAY (f
), bar
->x_window
,
5866 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5868 /* Remember new settings. */
5872 bar
->height
= height
;
5877 #ifdef USE_TOOLKIT_SCROLL_BARS
5878 x_set_toolkit_horizontal_scroll_bar_thumb (bar
, portion
, position
, whole
);
5879 #else /* not USE_TOOLKIT_SCROLL_BARS */
5880 /* Set the scroll bar's current state, unless we're currently being
5882 if (bar
->dragging
== -1)
5884 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, width
);
5887 x_scroll_bar_set_handle (bar
, 0, left_range
, 0);
5890 int start
= ((double) position
* left_range
) / whole
;
5891 int end
= ((double) (position
+ portion
) * left_range
) / whole
;
5892 x_scroll_bar_set_handle (bar
, start
, end
, 0);
5895 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5897 XSETVECTOR (barobj
, bar
);
5898 wset_horizontal_scroll_bar (w
, barobj
);
5902 /* The following three hooks are used when we're doing a thorough
5903 redisplay of the frame. We don't explicitly know which scroll bars
5904 are going to be deleted, because keeping track of when windows go
5905 away is a real pain - "Can you say set-window-configuration, boys
5906 and girls?" Instead, we just assert at the beginning of redisplay
5907 that *all* scroll bars are to be removed, and then save a scroll bar
5908 from the fiery pit when we actually redisplay its window. */
5910 /* Arrange for all scroll bars on FRAME to be removed at the next call
5911 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
5912 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
5915 XTcondemn_scroll_bars (struct frame
*frame
)
5917 if (!NILP (FRAME_SCROLL_BARS (frame
)))
5919 if (!NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
5921 /* Prepend scrollbars to already condemned ones. */
5922 Lisp_Object last
= FRAME_SCROLL_BARS (frame
);
5924 while (!NILP (XSCROLL_BAR (last
)->next
))
5925 last
= XSCROLL_BAR (last
)->next
;
5927 XSCROLL_BAR (last
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
5928 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= last
;
5931 fset_condemned_scroll_bars (frame
, FRAME_SCROLL_BARS (frame
));
5932 fset_scroll_bars (frame
, Qnil
);
5937 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
5938 Note that WINDOW isn't necessarily condemned at all. */
5941 XTredeem_scroll_bar (struct window
*w
)
5943 struct scroll_bar
*bar
;
5947 /* We can't redeem this window's scroll bar if it doesn't have one. */
5948 if (NILP (w
->vertical_scroll_bar
) && NILP (w
->horizontal_scroll_bar
))
5951 if (!NILP (w
->vertical_scroll_bar
) && WINDOW_HAS_VERTICAL_SCROLL_BAR (w
))
5953 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5954 /* Unlink it from the condemned list. */
5955 f
= XFRAME (WINDOW_FRAME (w
));
5956 if (NILP (bar
->prev
))
5958 /* If the prev pointer is nil, it must be the first in one of
5960 if (EQ (FRAME_SCROLL_BARS (f
), w
->vertical_scroll_bar
))
5961 /* It's not condemned. Everything's fine. */
5963 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
5964 w
->vertical_scroll_bar
))
5965 fset_condemned_scroll_bars (f
, bar
->next
);
5967 /* If its prev pointer is nil, it must be at the front of
5968 one or the other! */
5972 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
5974 if (! NILP (bar
->next
))
5975 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
5977 bar
->next
= FRAME_SCROLL_BARS (f
);
5979 XSETVECTOR (barobj
, bar
);
5980 fset_scroll_bars (f
, barobj
);
5981 if (! NILP (bar
->next
))
5982 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
5986 if (!NILP (w
->horizontal_scroll_bar
) && WINDOW_HAS_HORIZONTAL_SCROLL_BAR (w
))
5988 bar
= XSCROLL_BAR (w
->horizontal_scroll_bar
);
5989 /* Unlink it from the condemned list. */
5990 f
= XFRAME (WINDOW_FRAME (w
));
5991 if (NILP (bar
->prev
))
5993 /* If the prev pointer is nil, it must be the first in one of
5995 if (EQ (FRAME_SCROLL_BARS (f
), w
->horizontal_scroll_bar
))
5996 /* It's not condemned. Everything's fine. */
5998 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
5999 w
->horizontal_scroll_bar
))
6000 fset_condemned_scroll_bars (f
, bar
->next
);
6002 /* If its prev pointer is nil, it must be at the front of
6003 one or the other! */
6007 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
6009 if (! NILP (bar
->next
))
6010 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
6012 bar
->next
= FRAME_SCROLL_BARS (f
);
6014 XSETVECTOR (barobj
, bar
);
6015 fset_scroll_bars (f
, barobj
);
6016 if (! NILP (bar
->next
))
6017 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
6021 /* Remove all scroll bars on FRAME that haven't been saved since the
6022 last call to `*condemn_scroll_bars_hook'. */
6025 XTjudge_scroll_bars (struct frame
*f
)
6027 Lisp_Object bar
, next
;
6029 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
6031 /* Clear out the condemned list now so we won't try to process any
6032 more events on the hapless scroll bars. */
6033 fset_condemned_scroll_bars (f
, Qnil
);
6035 for (; ! NILP (bar
); bar
= next
)
6037 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
6039 x_scroll_bar_remove (b
);
6042 b
->next
= b
->prev
= Qnil
;
6045 /* Now there should be no references to the condemned scroll bars,
6046 and they should get garbage-collected. */
6050 #ifndef USE_TOOLKIT_SCROLL_BARS
6051 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
6052 is a no-op when using toolkit scroll bars.
6054 This may be called from a signal handler, so we have to ignore GC
6058 x_scroll_bar_expose (struct scroll_bar
*bar
, const XEvent
*event
)
6060 Window w
= bar
->x_window
;
6061 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6062 GC gc
= f
->output_data
.x
->normal_gc
;
6066 x_scroll_bar_set_handle (bar
, bar
->start
, bar
->end
, 1);
6068 /* Switch to scroll bar foreground color. */
6069 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
6070 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
6071 f
->output_data
.x
->scroll_bar_foreground_pixel
);
6073 /* Draw a one-pixel border just inside the edges of the scroll bar. */
6074 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
6075 /* x, y, width, height */
6076 0, 0, bar
->width
- 1, bar
->height
- 1);
6078 /* Restore the foreground color of the GC if we changed it above. */
6079 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
6080 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
6081 FRAME_FOREGROUND_PIXEL (f
));
6086 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6088 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
6089 is set to something other than NO_EVENT, it is enqueued.
6091 This may be called from a signal handler, so we have to ignore GC
6096 x_scroll_bar_handle_click (struct scroll_bar
*bar
,
6097 const XEvent
*event
,
6098 struct input_event
*emacs_event
)
6100 if (! WINDOWP (bar
->window
))
6103 emacs_event
->kind
= (bar
->horizontal
6104 ? HORIZONTAL_SCROLL_BAR_CLICK_EVENT
6105 : SCROLL_BAR_CLICK_EVENT
);
6106 emacs_event
->code
= event
->xbutton
.button
- Button1
;
6107 emacs_event
->modifiers
6108 = (x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO
6109 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
6110 event
->xbutton
.state
)
6111 | (event
->type
== ButtonRelease
6114 emacs_event
->frame_or_window
= bar
->window
;
6115 emacs_event
->arg
= Qnil
;
6116 emacs_event
->timestamp
= event
->xbutton
.time
;
6117 if (bar
->horizontal
)
6120 = HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
6121 int x
= event
->xbutton
.x
- HORIZONTAL_SCROLL_BAR_LEFT_BORDER
;
6124 if (x
> left_range
) x
= left_range
;
6127 emacs_event
->part
= scroll_bar_before_handle
;
6128 else if (x
< bar
->end
+ HORIZONTAL_SCROLL_BAR_MIN_HANDLE
)
6129 emacs_event
->part
= scroll_bar_horizontal_handle
;
6131 emacs_event
->part
= scroll_bar_after_handle
;
6133 #ifndef USE_TOOLKIT_SCROLL_BARS
6134 /* If the user has released the handle, set it to its final position. */
6135 if (event
->type
== ButtonRelease
&& bar
->dragging
!= -1)
6137 int new_start
= - bar
->dragging
;
6138 int new_end
= new_start
+ bar
->end
- bar
->start
;
6140 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
6145 XSETINT (emacs_event
->x
, left_range
);
6146 XSETINT (emacs_event
->y
, x
);
6151 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
6152 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
6155 if (y
> top_range
) y
= top_range
;
6158 emacs_event
->part
= scroll_bar_above_handle
;
6159 else if (y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
6160 emacs_event
->part
= scroll_bar_handle
;
6162 emacs_event
->part
= scroll_bar_below_handle
;
6164 #ifndef USE_TOOLKIT_SCROLL_BARS
6165 /* If the user has released the handle, set it to its final position. */
6166 if (event
->type
== ButtonRelease
&& bar
->dragging
!= -1)
6168 int new_start
= y
- bar
->dragging
;
6169 int new_end
= new_start
+ bar
->end
- bar
->start
;
6171 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
6176 XSETINT (emacs_event
->x
, y
);
6177 XSETINT (emacs_event
->y
, top_range
);
6181 #ifndef USE_TOOLKIT_SCROLL_BARS
6183 /* Handle some mouse motion while someone is dragging the scroll bar.
6185 This may be called from a signal handler, so we have to ignore GC
6189 x_scroll_bar_note_movement (struct scroll_bar
*bar
,
6190 const XMotionEvent
*event
)
6192 struct frame
*f
= XFRAME (XWINDOW (bar
->window
)->frame
);
6193 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
6195 dpyinfo
->last_mouse_movement_time
= event
->time
;
6196 dpyinfo
->last_mouse_scroll_bar
= bar
;
6199 /* If we're dragging the bar, display it. */
6200 if (bar
->dragging
!= -1)
6202 /* Where should the handle be now? */
6203 int new_start
= event
->y
- bar
->dragging
;
6205 if (new_start
!= bar
->start
)
6207 int new_end
= new_start
+ bar
->end
- bar
->start
;
6209 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
6214 #endif /* !USE_TOOLKIT_SCROLL_BARS */
6216 /* Return information to the user about the current position of the mouse
6217 on the scroll bar. */
6220 x_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
6221 enum scroll_bar_part
*part
, Lisp_Object
*x
,
6222 Lisp_Object
*y
, Time
*timestamp
)
6224 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
6225 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
6226 Window w
= bar
->x_window
;
6227 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6229 Window dummy_window
;
6231 unsigned int dummy_mask
;
6235 /* Get the mouse's position relative to the scroll bar window, and
6237 if (XQueryPointer (FRAME_X_DISPLAY (f
), w
,
6239 /* Root, child, root x and root y. */
6240 &dummy_window
, &dummy_window
,
6241 &dummy_coord
, &dummy_coord
,
6243 /* Position relative to scroll bar. */
6246 /* Mouse buttons and modifier keys. */
6249 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
6251 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
6253 if (bar
->dragging
!= -1)
6254 win_y
-= bar
->dragging
;
6258 if (win_y
> top_range
)
6262 *bar_window
= bar
->window
;
6264 if (bar
->dragging
!= -1)
6265 *part
= scroll_bar_handle
;
6266 else if (win_y
< bar
->start
)
6267 *part
= scroll_bar_above_handle
;
6268 else if (win_y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
6269 *part
= scroll_bar_handle
;
6271 *part
= scroll_bar_below_handle
;
6273 XSETINT (*x
, win_y
);
6274 XSETINT (*y
, top_range
);
6277 dpyinfo
->last_mouse_scroll_bar
= NULL
;
6278 *timestamp
= dpyinfo
->last_mouse_movement_time
;
6285 /* Return information to the user about the current position of the mouse
6286 on the scroll bar. */
6289 x_horizontal_scroll_bar_report_motion (struct frame
**fp
, Lisp_Object
*bar_window
,
6290 enum scroll_bar_part
*part
, Lisp_Object
*x
,
6291 Lisp_Object
*y
, Time
*timestamp
)
6293 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (*fp
);
6294 struct scroll_bar
*bar
= dpyinfo
->last_mouse_scroll_bar
;
6295 Window w
= bar
->x_window
;
6296 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
6298 Window dummy_window
;
6300 unsigned int dummy_mask
;
6304 /* Get the mouse's position relative to the scroll bar window, and
6306 if (XQueryPointer (FRAME_X_DISPLAY (f
), w
,
6308 /* Root, child, root x and root y. */
6309 &dummy_window
, &dummy_window
,
6310 &dummy_coord
, &dummy_coord
,
6312 /* Position relative to scroll bar. */
6315 /* Mouse buttons and modifier keys. */
6318 int left_range
= HORIZONTAL_SCROLL_BAR_LEFT_RANGE (f
, bar
->width
);
6320 win_x
-= HORIZONTAL_SCROLL_BAR_LEFT_BORDER
;
6322 if (bar
->dragging
!= -1)
6323 win_x
-= bar
->dragging
;
6327 if (win_x
> left_range
)
6331 *bar_window
= bar
->window
;
6333 if (bar
->dragging
!= -1)
6334 *part
= scroll_bar_horizontal_handle
;
6335 else if (win_x
< bar
->start
)
6336 *part
= scroll_bar_before_handle
;
6337 else if (win_x
< bar
->end
+ HORIZONTAL_SCROLL_BAR_MIN_HANDLE
)
6338 *part
= scroll_bar_handle
;
6340 *part
= scroll_bar_after_handle
;
6342 XSETINT (*y
, win_x
);
6343 XSETINT (*x
, left_range
);
6346 dpyinfo
->last_mouse_scroll_bar
= NULL
;
6347 *timestamp
= dpyinfo
->last_mouse_movement_time
;
6354 /* The screen has been cleared so we may have changed foreground or
6355 background colors, and the scroll bars may need to be redrawn.
6356 Clear out the scroll bars, and ask for expose events, so we can
6360 x_scroll_bar_clear (struct frame
*f
)
6362 #ifndef USE_TOOLKIT_SCROLL_BARS
6365 /* We can have scroll bars even if this is 0,
6366 if we just turned off scroll bar mode.
6367 But in that case we should not clear them. */
6368 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
6369 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
6370 bar
= XSCROLL_BAR (bar
)->next
)
6371 XClearArea (FRAME_X_DISPLAY (f
),
6372 XSCROLL_BAR (bar
)->x_window
,
6374 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6377 #ifdef ENABLE_CHECKING
6379 /* Record the last 100 characters stored
6380 to help debug the loss-of-chars-during-GC problem. */
6382 static int temp_index
;
6383 static short temp_buffer
[100];
6385 #define STORE_KEYSYM_FOR_DEBUG(keysym) \
6386 if (temp_index == ARRAYELTS (temp_buffer)) \
6388 temp_buffer[temp_index++] = (keysym)
6390 #else /* not ENABLE_CHECKING */
6392 #define STORE_KEYSYM_FOR_DEBUG(keysym) ((void)0)
6394 #endif /* ENABLE_CHECKING */
6396 /* Set this to nonzero to fake an "X I/O error"
6397 on a particular display. */
6399 static struct x_display_info
*XTread_socket_fake_io_error
;
6401 /* When we find no input here, we occasionally do a no-op command
6402 to verify that the X server is still running and we can still talk with it.
6403 We try all the open displays, one by one.
6404 This variable is used for cycling thru the displays. */
6406 static struct x_display_info
*next_noop_dpyinfo
;
6415 /* Filter events for the current X input method.
6416 DPYINFO is the display this event is for.
6417 EVENT is the X event to filter.
6419 Returns non-zero if the event was filtered, caller shall not process
6421 Returns zero if event is wasn't filtered. */
6425 x_filter_event (struct x_display_info
*dpyinfo
, XEvent
*event
)
6427 /* XFilterEvent returns non-zero if the input method has
6428 consumed the event. We pass the frame's X window to
6429 XFilterEvent because that's the one for which the IC
6432 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
6433 event
->xclient
.window
);
6435 return XFilterEvent (event
, f1
? FRAME_X_WINDOW (f1
) : None
);
6440 static int current_count
;
6441 static int current_finish
;
6442 static struct input_event
*current_hold_quit
;
6444 /* This is the filter function invoked by the GTK event loop.
6445 It is invoked before the XEvent is translated to a GdkEvent,
6446 so we have a chance to act on the event before GTK. */
6447 static GdkFilterReturn
6448 event_handler_gdk (GdkXEvent
*gxev
, GdkEvent
*ev
, gpointer data
)
6450 XEvent
*xev
= (XEvent
*) gxev
;
6453 if (current_count
>= 0)
6455 struct x_display_info
*dpyinfo
;
6457 dpyinfo
= x_display_info_for_display (xev
->xany
.display
);
6460 /* Filter events for the current X input method.
6461 GTK calls XFilterEvent but not for key press and release,
6462 so we do it here. */
6463 if ((xev
->type
== KeyPress
|| xev
->type
== KeyRelease
)
6465 && x_filter_event (dpyinfo
, xev
))
6468 return GDK_FILTER_REMOVE
;
6473 current_finish
= X_EVENT_NORMAL
;
6476 += handle_one_xevent (dpyinfo
, xev
, ¤t_finish
,
6480 current_finish
= x_dispatch_event (xev
, xev
->xany
.display
);
6484 if (current_finish
== X_EVENT_GOTO_OUT
|| current_finish
== X_EVENT_DROP
)
6485 return GDK_FILTER_REMOVE
;
6487 return GDK_FILTER_CONTINUE
;
6489 #endif /* USE_GTK */
6492 static void xembed_send_message (struct frame
*f
, Time
,
6493 enum xembed_message
,
6494 long detail
, long data1
, long data2
);
6497 x_net_wm_state (struct frame
*f
, Window window
)
6499 int value
= FULLSCREEN_NONE
;
6500 Lisp_Object lval
= Qnil
;
6503 (void)get_current_wm_state (f
, window
, &value
, &sticky
);
6507 case FULLSCREEN_WIDTH
:
6510 case FULLSCREEN_HEIGHT
:
6513 case FULLSCREEN_BOTH
:
6516 case FULLSCREEN_MAXIMIZED
:
6521 store_frame_param (f
, Qfullscreen
, lval
);
6522 /** store_frame_param (f, Qsticky, sticky ? Qt : Qnil); **/
6525 /* Handles the XEvent EVENT on display DPYINFO.
6527 *FINISH is X_EVENT_GOTO_OUT if caller should stop reading events.
6528 *FINISH is zero if caller should continue reading events.
6529 *FINISH is X_EVENT_DROP if event should not be passed to the toolkit.
6530 *EVENT is unchanged unless we're processing KeyPress event.
6532 We return the number of characters stored into the buffer. */
6535 handle_one_xevent (struct x_display_info
*dpyinfo
,
6536 const XEvent
*event
,
6537 int *finish
, struct input_event
*hold_quit
)
6540 struct input_event ie
;
6541 struct selection_input_event sie
;
6545 ptrdiff_t nbytes
= 0;
6546 struct frame
*any
, *f
= NULL
;
6547 struct coding_system coding
;
6548 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
6549 /* This holds the state XLookupString needs to implement dead keys
6550 and other tricks known as "compose processing". _X Window System_
6551 says that a portable program can't use this, but Stephen Gildea assures
6552 me that letting the compiler initialize it to zeros will work okay. */
6553 static XComposeStatus compose_status
;
6557 *finish
= X_EVENT_NORMAL
;
6559 EVENT_INIT (inev
.ie
);
6560 inev
.ie
.kind
= NO_EVENT
;
6563 any
= x_any_window_to_frame (dpyinfo
, event
->xany
.window
);
6565 if (any
&& any
->wait_event_type
== event
->type
)
6566 any
->wait_event_type
= 0; /* Indicates we got it. */
6568 switch (event
->type
)
6572 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_protocols
6573 && event
->xclient
.format
== 32)
6575 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_take_focus
)
6577 /* Use the value returned by x_any_window_to_frame
6578 because this could be the shell widget window
6579 if the frame has no title bar. */
6582 /* Not quite sure this is needed -pd */
6583 if (f
&& FRAME_XIC (f
))
6584 XSetICFocus (FRAME_XIC (f
));
6586 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
6587 instructs the WM to set the input focus automatically for
6588 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
6589 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
6590 it has set the focus. So, XSetInputFocus below is not
6593 The call to XSetInputFocus below has also caused trouble. In
6594 cases where the XSetInputFocus done by the WM and the one
6595 below are temporally close (on a fast machine), the call
6596 below can generate additional FocusIn events which confuse
6599 /* Since we set WM_TAKE_FOCUS, we must call
6600 XSetInputFocus explicitly. But not if f is null,
6601 since that might be an event for a deleted frame. */
6604 Display
*d
= event
->xclient
.display
;
6605 /* Catch and ignore errors, in case window has been
6606 iconified by a window manager such as GWM. */
6608 XSetInputFocus (d
, event
->xclient
.window
,
6609 /* The ICCCM says this is
6610 the only valid choice. */
6612 event
->xclient
.data
.l
[1]);
6613 /* This is needed to detect the error
6614 if there is an error. */
6616 x_uncatch_errors ();
6618 /* Not certain about handling scroll bars here */
6623 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_save_yourself
)
6625 /* Save state modify the WM_COMMAND property to
6626 something which can reinstate us. This notifies
6627 the session manager, who's looking for such a
6628 PropertyNotify. Can restart processing when
6629 a keyboard or mouse event arrives. */
6630 /* If we have a session manager, don't set this.
6631 KDE will then start two Emacsen, one for the
6632 session manager and one for this. */
6634 if (! x_session_have_connection ())
6637 f
= x_top_window_to_frame (dpyinfo
,
6638 event
->xclient
.window
);
6639 /* This is just so we only give real data once
6640 for a single Emacs process. */
6641 if (f
== SELECTED_FRAME ())
6642 XSetCommand (FRAME_X_DISPLAY (f
),
6643 event
->xclient
.window
,
6644 initial_argv
, initial_argc
);
6646 XSetCommand (FRAME_X_DISPLAY (f
),
6647 event
->xclient
.window
,
6653 if (event
->xclient
.data
.l
[0] == dpyinfo
->Xatom_wm_delete_window
)
6657 goto OTHER
; /* May be a dialog that is to be removed */
6659 inev
.ie
.kind
= DELETE_WINDOW_EVENT
;
6660 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6667 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_configure_denied
)
6670 if (event
->xclient
.message_type
== dpyinfo
->Xatom_wm_window_moved
)
6673 f
= x_window_to_frame (dpyinfo
, event
->xclient
.window
);
6675 new_x
= event
->xclient
.data
.s
[0];
6676 new_y
= event
->xclient
.data
.s
[1];
6680 f
->left_pos
= new_x
;
6687 if (event
->xclient
.message_type
== dpyinfo
->Xatom_editres
)
6691 _XEditResCheckMessages (f
->output_data
.x
->widget
,
6692 NULL
, (XEvent
*) event
, NULL
);
6695 #endif /* HACK_EDITRES */
6697 if (event
->xclient
.message_type
== dpyinfo
->Xatom_DONE
6698 || event
->xclient
.message_type
== dpyinfo
->Xatom_PAGE
)
6700 /* Ghostview job completed. Kill it. We could
6701 reply with "Next" if we received "Page", but we
6702 currently never do because we are interested in
6703 images, only, which should have 1 page. */
6704 Pixmap pixmap
= (Pixmap
) event
->xclient
.data
.l
[1];
6705 f
= x_window_to_frame (dpyinfo
, event
->xclient
.window
);
6708 x_kill_gs_process (pixmap
, f
);
6709 expose_frame (f
, 0, 0, 0, 0);
6713 #ifdef USE_TOOLKIT_SCROLL_BARS
6714 /* Scroll bar callbacks send a ClientMessage from which
6715 we construct an input_event. */
6716 if (event
->xclient
.message_type
== dpyinfo
->Xatom_Scrollbar
)
6718 x_scroll_bar_to_input_event (event
, &inev
.ie
);
6719 *finish
= X_EVENT_GOTO_OUT
;
6722 else if (event
->xclient
.message_type
== dpyinfo
->Xatom_Horizontal_Scrollbar
)
6724 x_horizontal_scroll_bar_to_input_event (event
, &inev
.ie
);
6725 *finish
= X_EVENT_GOTO_OUT
;
6728 #endif /* USE_TOOLKIT_SCROLL_BARS */
6730 /* XEmbed messages from the embedder (if any). */
6731 if (event
->xclient
.message_type
== dpyinfo
->Xatom_XEMBED
)
6733 enum xembed_message msg
= event
->xclient
.data
.l
[1];
6734 if (msg
== XEMBED_FOCUS_IN
|| msg
== XEMBED_FOCUS_OUT
)
6735 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
6737 *finish
= X_EVENT_GOTO_OUT
;
6741 xft_settings_event (dpyinfo
, event
);
6746 if (x_handle_dnd_message (f
, &event
->xclient
, dpyinfo
, &inev
.ie
))
6747 *finish
= X_EVENT_DROP
;
6751 case SelectionNotify
:
6752 dpyinfo
->last_user_time
= event
->xselection
.time
;
6753 #ifdef USE_X_TOOLKIT
6754 if (! x_window_to_frame (dpyinfo
, event
->xselection
.requestor
))
6756 #endif /* not USE_X_TOOLKIT */
6757 x_handle_selection_notify (&event
->xselection
);
6760 case SelectionClear
: /* Someone has grabbed ownership. */
6761 dpyinfo
->last_user_time
= event
->xselectionclear
.time
;
6762 #ifdef USE_X_TOOLKIT
6763 if (! x_window_to_frame (dpyinfo
, event
->xselectionclear
.window
))
6765 #endif /* USE_X_TOOLKIT */
6767 const XSelectionClearEvent
*eventp
= &event
->xselectionclear
;
6769 inev
.ie
.kind
= SELECTION_CLEAR_EVENT
;
6770 SELECTION_EVENT_DPYINFO (&inev
.sie
) = dpyinfo
;
6771 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
6772 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
6776 case SelectionRequest
: /* Someone wants our selection. */
6777 dpyinfo
->last_user_time
= event
->xselectionrequest
.time
;
6778 #ifdef USE_X_TOOLKIT
6779 if (!x_window_to_frame (dpyinfo
, event
->xselectionrequest
.owner
))
6781 #endif /* USE_X_TOOLKIT */
6783 const XSelectionRequestEvent
*eventp
= &event
->xselectionrequest
;
6785 inev
.ie
.kind
= SELECTION_REQUEST_EVENT
;
6786 SELECTION_EVENT_DPYINFO (&inev
.sie
) = dpyinfo
;
6787 SELECTION_EVENT_REQUESTOR (&inev
.sie
) = eventp
->requestor
;
6788 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
6789 SELECTION_EVENT_TARGET (&inev
.sie
) = eventp
->target
;
6790 SELECTION_EVENT_PROPERTY (&inev
.sie
) = eventp
->property
;
6791 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
6795 case PropertyNotify
:
6796 dpyinfo
->last_user_time
= event
->xproperty
.time
;
6797 f
= x_top_window_to_frame (dpyinfo
, event
->xproperty
.window
);
6798 if (f
&& event
->xproperty
.atom
== dpyinfo
->Xatom_net_wm_state
)
6799 if (x_handle_net_wm_state (f
, &event
->xproperty
)
6800 && FRAME_ICONIFIED_P (f
)
6801 && f
->output_data
.x
->net_wm_state_hidden_seen
)
6803 /* Gnome shell does not iconify us when C-z is pressed.
6804 It hides the frame. So if our state says we aren't
6805 hidden anymore, treat it as deiconified. */
6806 SET_FRAME_VISIBLE (f
, 1);
6807 SET_FRAME_ICONIFIED (f
, 0);
6808 f
->output_data
.x
->has_been_visible
= 1;
6809 f
->output_data
.x
->net_wm_state_hidden_seen
= 0;
6810 inev
.ie
.kind
= DEICONIFY_EVENT
;
6811 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6814 x_handle_property_notify (&event
->xproperty
);
6815 xft_settings_event (dpyinfo
, event
);
6818 case ReparentNotify
:
6819 f
= x_top_window_to_frame (dpyinfo
, event
->xreparent
.window
);
6822 f
->output_data
.x
->parent_desc
= event
->xreparent
.parent
;
6823 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
6825 /* Perhaps reparented due to a WM restart. Reset this. */
6826 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_UNKNOWN
;
6827 FRAME_DISPLAY_INFO (f
)->net_supported_window
= 0;
6829 x_set_frame_alpha (f
);
6834 f
= x_window_to_frame (dpyinfo
, event
->xexpose
.window
);
6837 if (!FRAME_VISIBLE_P (f
))
6839 SET_FRAME_VISIBLE (f
, 1);
6840 SET_FRAME_ICONIFIED (f
, 0);
6841 f
->output_data
.x
->has_been_visible
= 1;
6842 SET_FRAME_GARBAGED (f
);
6847 /* This seems to be needed for GTK 2.6 and later, see
6848 http://debbugs.gnu.org/cgi/bugreport.cgi?bug=15398. */
6849 x_clear_area (event
->xexpose
.display
,
6850 event
->xexpose
.window
,
6851 event
->xexpose
.x
, event
->xexpose
.y
,
6852 event
->xexpose
.width
, event
->xexpose
.height
);
6854 expose_frame (f
, event
->xexpose
.x
, event
->xexpose
.y
,
6855 event
->xexpose
.width
, event
->xexpose
.height
);
6860 #ifndef USE_TOOLKIT_SCROLL_BARS
6861 struct scroll_bar
*bar
;
6863 #if defined USE_LUCID
6864 /* Submenus of the Lucid menu bar aren't widgets
6865 themselves, so there's no way to dispatch events
6866 to them. Recognize this case separately. */
6868 Widget widget
= x_window_to_menu_bar (event
->xexpose
.window
);
6870 xlwmenu_redisplay (widget
);
6872 #endif /* USE_LUCID */
6874 #ifdef USE_TOOLKIT_SCROLL_BARS
6875 /* Dispatch event to the widget. */
6877 #else /* not USE_TOOLKIT_SCROLL_BARS */
6878 bar
= x_window_to_scroll_bar (event
->xexpose
.display
,
6879 event
->xexpose
.window
, 2);
6882 x_scroll_bar_expose (bar
, event
);
6883 #ifdef USE_X_TOOLKIT
6886 #endif /* USE_X_TOOLKIT */
6887 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6891 case GraphicsExpose
: /* This occurs when an XCopyArea's
6892 source area was obscured or not
6894 f
= x_window_to_frame (dpyinfo
, event
->xgraphicsexpose
.drawable
);
6896 expose_frame (f
, event
->xgraphicsexpose
.x
,
6897 event
->xgraphicsexpose
.y
,
6898 event
->xgraphicsexpose
.width
,
6899 event
->xgraphicsexpose
.height
);
6900 #ifdef USE_X_TOOLKIT
6903 #endif /* USE_X_TOOLKIT */
6906 case NoExpose
: /* This occurs when an XCopyArea's
6907 source area was completely
6912 /* Redo the mouse-highlight after the tooltip has gone. */
6913 if (event
->xunmap
.window
== tip_window
)
6916 x_redo_mouse_highlight (dpyinfo
);
6919 f
= x_top_window_to_frame (dpyinfo
, event
->xunmap
.window
);
6920 if (f
) /* F may no longer exist if
6921 the frame was deleted. */
6923 bool visible
= FRAME_VISIBLE_P (f
);
6924 /* While a frame is unmapped, display generation is
6925 disabled; you don't want to spend time updating a
6926 display that won't ever be seen. */
6927 SET_FRAME_VISIBLE (f
, 0);
6928 /* We can't distinguish, from the event, whether the window
6929 has become iconified or invisible. So assume, if it
6930 was previously visible, than now it is iconified.
6931 But x_make_frame_invisible clears both
6932 the visible flag and the iconified flag;
6933 and that way, we know the window is not iconified now. */
6934 if (visible
|| FRAME_ICONIFIED_P (f
))
6936 SET_FRAME_ICONIFIED (f
, 1);
6937 inev
.ie
.kind
= ICONIFY_EVENT
;
6938 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6944 if (event
->xmap
.window
== tip_window
)
6945 /* The tooltip has been drawn already. Avoid
6946 the SET_FRAME_GARBAGED below. */
6949 /* We use x_top_window_to_frame because map events can
6950 come for sub-windows and they don't mean that the
6951 frame is visible. */
6952 f
= x_top_window_to_frame (dpyinfo
, event
->xmap
.window
);
6955 bool iconified
= FRAME_ICONIFIED_P (f
);
6957 /* Check if fullscreen was specified before we where mapped the
6958 first time, i.e. from the command line. */
6959 if (!f
->output_data
.x
->has_been_visible
)
6960 x_check_fullscreen (f
);
6962 SET_FRAME_VISIBLE (f
, 1);
6963 SET_FRAME_ICONIFIED (f
, 0);
6964 f
->output_data
.x
->has_been_visible
= 1;
6968 inev
.ie
.kind
= DEICONIFY_EVENT
;
6969 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6971 else if (! NILP (Vframe_list
) && ! NILP (XCDR (Vframe_list
)))
6972 /* Force a redisplay sooner or later to update the
6973 frame titles in case this is the second frame. */
6974 record_asynch_buffer_change ();
6977 xg_frame_resized (f
, -1, -1);
6984 dpyinfo
->last_user_time
= event
->xkey
.time
;
6985 ignore_next_mouse_click_timeout
= 0;
6987 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6988 /* Dispatch KeyPress events when in menu. */
6989 if (popup_activated ())
6995 #if ! defined (USE_GTK)
6996 /* If mouse-highlight is an integer, input clears out
6997 mouse highlighting. */
6998 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
7000 || !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
)))
7002 clear_mouse_face (hlinfo
);
7003 hlinfo
->mouse_face_hidden
= 1;
7007 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
7010 /* Scroll bars consume key events, but we want
7011 the keys to go to the scroll bar's frame. */
7012 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
7013 event
->xkey
.window
);
7014 if (widget
&& XmIsScrollBar (widget
))
7016 widget
= XtParent (widget
);
7017 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
7020 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
7024 KeySym keysym
, orig_keysym
;
7025 /* al%imercury@uunet.uu.net says that making this 81
7026 instead of 80 fixed a bug whereby meta chars made
7029 It seems that some version of XmbLookupString has
7030 a bug of not returning XBufferOverflow in
7031 status_return even if the input is too long to
7032 fit in 81 bytes. So, we must prepare sufficient
7033 bytes for copy_buffer. 513 bytes (256 chars for
7034 two-byte character set) seems to be a fairly good
7035 approximation. -- 2000.8.10 handa@etl.go.jp */
7036 unsigned char copy_buffer
[513];
7037 unsigned char *copy_bufptr
= copy_buffer
;
7038 int copy_bufsiz
= sizeof (copy_buffer
);
7040 Lisp_Object coding_system
= Qlatin_1
;
7042 /* Event will be modified. */
7043 XKeyEvent xkey
= event
->xkey
;
7046 /* Don't pass keys to GTK. A Tab will shift focus to the
7047 tool bar in GTK 2.4. Keys will still go to menus and
7048 dialogs because in that case popup_activated is nonzero
7050 *finish
= X_EVENT_DROP
;
7053 xkey
.state
|= x_emacs_to_x_modifiers (FRAME_DISPLAY_INFO (f
),
7054 extra_keyboard_modifiers
);
7055 modifiers
= xkey
.state
;
7057 /* This will have to go some day... */
7059 /* make_lispy_event turns chars into control chars.
7060 Don't do it here because XLookupString is too eager. */
7061 xkey
.state
&= ~ControlMask
;
7062 xkey
.state
&= ~(dpyinfo
->meta_mod_mask
7063 | dpyinfo
->super_mod_mask
7064 | dpyinfo
->hyper_mod_mask
7065 | dpyinfo
->alt_mod_mask
);
7067 /* In case Meta is ComposeCharacter,
7068 clear its status. According to Markus Ehrnsperger
7069 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
7070 this enables ComposeCharacter to work whether or
7071 not it is combined with Meta. */
7072 if (modifiers
& dpyinfo
->meta_mod_mask
)
7073 memset (&compose_status
, 0, sizeof (compose_status
));
7078 Status status_return
;
7080 coding_system
= Vlocale_coding_system
;
7081 nbytes
= XmbLookupString (FRAME_XIC (f
),
7082 &xkey
, (char *) copy_bufptr
,
7083 copy_bufsiz
, &keysym
,
7085 if (status_return
== XBufferOverflow
)
7087 copy_bufsiz
= nbytes
+ 1;
7088 copy_bufptr
= alloca (copy_bufsiz
);
7089 nbytes
= XmbLookupString (FRAME_XIC (f
),
7090 &xkey
, (char *) copy_bufptr
,
7091 copy_bufsiz
, &keysym
,
7094 /* Xutf8LookupString is a new but already deprecated interface. -stef */
7095 if (status_return
== XLookupNone
)
7097 else if (status_return
== XLookupChars
)
7102 else if (status_return
!= XLookupKeySym
7103 && status_return
!= XLookupBoth
)
7107 nbytes
= XLookupString (&xkey
, (char *) copy_bufptr
,
7108 copy_bufsiz
, &keysym
,
7111 nbytes
= XLookupString (&xkey
, (char *) copy_bufptr
,
7112 copy_bufsiz
, &keysym
,
7116 /* If not using XIM/XIC, and a compose sequence is in progress,
7117 we break here. Otherwise, chars_matched is always 0. */
7118 if (compose_status
.chars_matched
> 0 && nbytes
== 0)
7121 memset (&compose_status
, 0, sizeof (compose_status
));
7122 orig_keysym
= keysym
;
7124 /* Common for all keysym input events. */
7125 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7127 = x_x_to_emacs_modifiers (FRAME_DISPLAY_INFO (f
), modifiers
);
7128 inev
.ie
.timestamp
= xkey
.time
;
7130 /* First deal with keysyms which have defined
7131 translations to characters. */
7132 if (keysym
>= 32 && keysym
< 128)
7133 /* Avoid explicitly decoding each ASCII character. */
7135 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
7136 inev
.ie
.code
= keysym
;
7140 /* Keysyms directly mapped to Unicode characters. */
7141 if (keysym
>= 0x01000000 && keysym
<= 0x0110FFFF)
7143 if (keysym
< 0x01000080)
7144 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
7146 inev
.ie
.kind
= MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
7147 inev
.ie
.code
= keysym
& 0xFFFFFF;
7151 /* Now non-ASCII. */
7152 if (HASH_TABLE_P (Vx_keysym_table
)
7153 && (c
= Fgethash (make_number (keysym
),
7158 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (XFASTINT (c
))
7159 ? ASCII_KEYSTROKE_EVENT
7160 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
7161 inev
.ie
.code
= XFASTINT (c
);
7165 /* Random non-modifier sorts of keysyms. */
7166 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
7167 || keysym
== XK_Delete
7168 #ifdef XK_ISO_Left_Tab
7169 || (keysym
>= XK_ISO_Left_Tab
7170 && keysym
<= XK_ISO_Enter
)
7172 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
7173 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
7175 /* This recognizes the "extended function
7176 keys". It seems there's no cleaner way.
7177 Test IsModifierKey to avoid handling
7178 mode_switch incorrectly. */
7179 || (XK_Select
<= keysym
&& keysym
< XK_KP_Space
)
7181 #ifdef XK_dead_circumflex
7182 || orig_keysym
== XK_dead_circumflex
7184 #ifdef XK_dead_grave
7185 || orig_keysym
== XK_dead_grave
7187 #ifdef XK_dead_tilde
7188 || orig_keysym
== XK_dead_tilde
7190 #ifdef XK_dead_diaeresis
7191 || orig_keysym
== XK_dead_diaeresis
7193 #ifdef XK_dead_macron
7194 || orig_keysym
== XK_dead_macron
7196 #ifdef XK_dead_degree
7197 || orig_keysym
== XK_dead_degree
7199 #ifdef XK_dead_acute
7200 || orig_keysym
== XK_dead_acute
7202 #ifdef XK_dead_cedilla
7203 || orig_keysym
== XK_dead_cedilla
7205 #ifdef XK_dead_breve
7206 || orig_keysym
== XK_dead_breve
7208 #ifdef XK_dead_ogonek
7209 || orig_keysym
== XK_dead_ogonek
7211 #ifdef XK_dead_caron
7212 || orig_keysym
== XK_dead_caron
7214 #ifdef XK_dead_doubleacute
7215 || orig_keysym
== XK_dead_doubleacute
7217 #ifdef XK_dead_abovedot
7218 || orig_keysym
== XK_dead_abovedot
7220 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
7221 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
7222 /* Any "vendor-specific" key is ok. */
7223 || (orig_keysym
& (1 << 28))
7224 || (keysym
!= NoSymbol
&& nbytes
== 0))
7225 && ! (IsModifierKey (orig_keysym
)
7226 /* The symbols from XK_ISO_Lock
7227 to XK_ISO_Last_Group_Lock
7228 don't have real modifiers but
7229 should be treated similarly to
7230 Mode_switch by Emacs. */
7231 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
7232 || (XK_ISO_Lock
<= orig_keysym
7233 && orig_keysym
<= XK_ISO_Last_Group_Lock
)
7237 STORE_KEYSYM_FOR_DEBUG (keysym
);
7238 /* make_lispy_event will convert this to a symbolic
7240 inev
.ie
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
7241 inev
.ie
.code
= keysym
;
7245 { /* Raw bytes, not keysym. */
7249 for (i
= 0, nchars
= 0; i
< nbytes
; i
++)
7251 if (ASCII_CHAR_P (copy_bufptr
[i
]))
7253 STORE_KEYSYM_FOR_DEBUG (copy_bufptr
[i
]);
7256 if (nchars
< nbytes
)
7258 /* Decode the input data. */
7260 /* The input should be decoded with `coding_system'
7261 which depends on which X*LookupString function
7262 we used just above and the locale. */
7263 setup_coding_system (coding_system
, &coding
);
7264 coding
.src_multibyte
= 0;
7265 coding
.dst_multibyte
= 1;
7266 /* The input is converted to events, thus we can't
7267 handle composition. Anyway, there's no XIM that
7268 gives us composition information. */
7269 coding
.common_flags
&= ~CODING_ANNOTATION_MASK
;
7271 SAFE_NALLOCA (coding
.destination
, MAX_MULTIBYTE_LENGTH
,
7273 coding
.dst_bytes
= MAX_MULTIBYTE_LENGTH
* nbytes
;
7274 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
7275 decode_coding_c_string (&coding
, copy_bufptr
, nbytes
, Qnil
);
7276 nbytes
= coding
.produced
;
7277 nchars
= coding
.produced_char
;
7278 copy_bufptr
= coding
.destination
;
7281 /* Convert the input data to a sequence of
7282 character events. */
7283 for (i
= 0; i
< nbytes
; i
+= len
)
7286 if (nchars
== nbytes
)
7287 ch
= copy_bufptr
[i
], len
= 1;
7289 ch
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
, len
);
7290 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (ch
)
7291 ? ASCII_KEYSTROKE_EVENT
7292 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
7294 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
7299 inev
.ie
.kind
= NO_EVENT
; /* Already stored above. */
7301 if (keysym
== NoSymbol
)
7304 /* FIXME: check side effects and remove this. */
7305 ((XEvent
*) event
)->xkey
= xkey
;
7309 /* Don't dispatch this event since XtDispatchEvent calls
7310 XFilterEvent, and two calls in a row may freeze the
7318 dpyinfo
->last_user_time
= event
->xkey
.time
;
7320 /* Don't dispatch this event since XtDispatchEvent calls
7321 XFilterEvent, and two calls in a row may freeze the
7329 dpyinfo
->last_user_time
= event
->xcrossing
.time
;
7330 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
7334 if (f
&& x_mouse_click_focus_ignore_position
)
7335 ignore_next_mouse_click_timeout
= event
->xmotion
.time
+ 200;
7337 /* EnterNotify counts as mouse movement,
7338 so update things that depend on mouse position. */
7339 if (f
&& !f
->output_data
.x
->hourglass_p
)
7340 note_mouse_movement (f
, &event
->xmotion
);
7342 /* We may get an EnterNotify on the buttons in the toolbar. In that
7343 case we moved out of any highlighted area and need to note this. */
7344 if (!f
&& dpyinfo
->last_mouse_glyph_frame
)
7345 note_mouse_movement (dpyinfo
->last_mouse_glyph_frame
, &event
->xmotion
);
7350 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
7354 dpyinfo
->last_user_time
= event
->xcrossing
.time
;
7355 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
7357 f
= x_top_window_to_frame (dpyinfo
, event
->xcrossing
.window
);
7360 if (f
== hlinfo
->mouse_face_mouse_frame
)
7362 /* If we move outside the frame, then we're
7363 certainly no longer on any text in the frame. */
7364 clear_mouse_face (hlinfo
);
7365 hlinfo
->mouse_face_mouse_frame
= 0;
7368 /* Generate a nil HELP_EVENT to cancel a help-echo.
7369 Do it only if there's something to cancel.
7370 Otherwise, the startup message is cleared when
7371 the mouse leaves the frame. */
7372 if (any_help_event_p
)
7376 /* See comment in EnterNotify above */
7377 else if (dpyinfo
->last_mouse_glyph_frame
)
7378 note_mouse_movement (dpyinfo
->last_mouse_glyph_frame
, &event
->xmotion
);
7383 x_detect_focus_change (dpyinfo
, any
, event
, &inev
.ie
);
7388 dpyinfo
->last_user_time
= event
->xmotion
.time
;
7389 previous_help_echo_string
= help_echo_string
;
7390 help_echo_string
= Qnil
;
7392 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
7393 : x_window_to_frame (dpyinfo
, event
->xmotion
.window
));
7395 if (hlinfo
->mouse_face_hidden
)
7397 hlinfo
->mouse_face_hidden
= 0;
7398 clear_mouse_face (hlinfo
);
7402 if (f
&& xg_event_is_for_scrollbar (f
, event
))
7408 /* Generate SELECT_WINDOW_EVENTs when needed.
7409 Don't let popup menus influence things (bug#1261). */
7410 if (!NILP (Vmouse_autoselect_window
) && !popup_activated ())
7412 static Lisp_Object last_mouse_window
;
7413 Lisp_Object window
= window_from_coordinates
7414 (f
, event
->xmotion
.x
, event
->xmotion
.y
, 0, 0);
7416 /* Window will be selected only when it is not selected now and
7417 last mouse movement event was not in it. Minibuffer window
7418 will be selected only when it is active. */
7419 if (WINDOWP (window
)
7420 && !EQ (window
, last_mouse_window
)
7421 && !EQ (window
, selected_window
)
7422 /* For click-to-focus window managers
7423 create event iff we don't leave the
7425 && (focus_follows_mouse
7426 || (EQ (XWINDOW (window
)->frame
,
7427 XWINDOW (selected_window
)->frame
))))
7429 inev
.ie
.kind
= SELECT_WINDOW_EVENT
;
7430 inev
.ie
.frame_or_window
= window
;
7432 /* Remember the last window where we saw the mouse. */
7433 last_mouse_window
= window
;
7435 if (!note_mouse_movement (f
, &event
->xmotion
))
7436 help_echo_string
= previous_help_echo_string
;
7440 #ifndef USE_TOOLKIT_SCROLL_BARS
7441 struct scroll_bar
*bar
7442 = x_window_to_scroll_bar (event
->xmotion
.display
,
7443 event
->xmotion
.window
, 2);
7446 x_scroll_bar_note_movement (bar
, &event
->xmotion
);
7447 #endif /* USE_TOOLKIT_SCROLL_BARS */
7449 /* If we move outside the frame, then we're
7450 certainly no longer on any text in the frame. */
7451 clear_mouse_face (hlinfo
);
7454 /* If the contents of the global variable help_echo_string
7455 has changed, generate a HELP_EVENT. */
7456 if (!NILP (help_echo_string
)
7457 || !NILP (previous_help_echo_string
))
7462 case ConfigureNotify
:
7463 f
= x_top_window_to_frame (dpyinfo
, event
->xconfigure
.window
);
7467 && event
->xconfigure
.window
== FRAME_X_WINDOW (f
))
7469 xg_frame_resized (f
, event
->xconfigure
.width
,
7470 event
->xconfigure
.height
);
7476 x_net_wm_state (f
, event
->xconfigure
.window
);
7478 #ifndef USE_X_TOOLKIT
7480 int width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, event
->xconfigure
.width
);
7481 int height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, event
->xconfigure
.height
);
7483 /* In the toolkit version, change_frame_size
7484 is called by the code that handles resizing
7485 of the EmacsFrame widget. */
7487 /* Even if the number of character rows and columns has
7488 not changed, the font size may have changed, so we need
7489 to check the pixel dimensions as well. */
7490 if (width
!= FRAME_TEXT_WIDTH (f
)
7491 || height
!= FRAME_TEXT_HEIGHT (f
)
7492 || event
->xconfigure
.width
!= FRAME_PIXEL_WIDTH (f
)
7493 || event
->xconfigure
.height
!= FRAME_PIXEL_HEIGHT (f
))
7495 change_frame_size (f
, width
, height
, 0, 1, 0, 1);
7496 x_clear_under_internal_border (f
);
7497 SET_FRAME_GARBAGED (f
);
7498 cancel_mouse_face (f
);
7501 /** FRAME_PIXEL_WIDTH (f) = event->xconfigure.width; **/
7502 /** FRAME_PIXEL_HEIGHT (f) = event->xconfigure.height; **/
7503 #endif /* not USE_GTK */
7507 /* GTK creates windows but doesn't map them.
7508 Only get real positions when mapped. */
7509 if (FRAME_GTK_OUTER_WIDGET (f
)
7510 && gtk_widget_get_mapped (FRAME_GTK_OUTER_WIDGET (f
)))
7512 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
7515 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
7516 xic_set_statusarea (f
);
7525 /* If we decide we want to generate an event to be seen
7526 by the rest of Emacs, we put it here. */
7527 bool tool_bar_p
= 0;
7529 memset (&compose_status
, 0, sizeof (compose_status
));
7530 dpyinfo
->last_mouse_glyph_frame
= NULL
;
7531 dpyinfo
->last_user_time
= event
->xbutton
.time
;
7533 f
= (x_mouse_grabbed (dpyinfo
) ? dpyinfo
->last_mouse_frame
7534 : x_window_to_frame (dpyinfo
, event
->xbutton
.window
));
7537 if (f
&& xg_event_is_for_scrollbar (f
, event
))
7542 #if ! defined (USE_GTK)
7543 /* Is this in the tool-bar? */
7544 if (WINDOWP (f
->tool_bar_window
)
7545 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
7548 int x
= event
->xbutton
.x
;
7549 int y
= event
->xbutton
.y
;
7551 window
= window_from_coordinates (f
, x
, y
, 0, 1);
7552 tool_bar_p
= EQ (window
, f
->tool_bar_window
);
7554 if (tool_bar_p
&& event
->xbutton
.button
< 4)
7555 handle_tool_bar_click
7556 (f
, x
, y
, event
->xbutton
.type
== ButtonPress
,
7557 x_x_to_emacs_modifiers (dpyinfo
, event
->xbutton
.state
));
7559 #endif /* !USE_GTK */
7562 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
7563 if (! popup_activated ())
7566 if (ignore_next_mouse_click_timeout
)
7568 if (event
->type
== ButtonPress
7569 && event
->xbutton
.time
> ignore_next_mouse_click_timeout
)
7571 ignore_next_mouse_click_timeout
= 0;
7572 construct_mouse_click (&inev
.ie
, &event
->xbutton
, f
);
7574 if (event
->type
== ButtonRelease
)
7575 ignore_next_mouse_click_timeout
= 0;
7578 construct_mouse_click (&inev
.ie
, &event
->xbutton
, f
);
7580 if (FRAME_X_EMBEDDED_P (f
))
7581 xembed_send_message (f
, event
->xbutton
.time
,
7582 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
7586 struct scroll_bar
*bar
7587 = x_window_to_scroll_bar (event
->xbutton
.display
,
7588 event
->xbutton
.window
, 2);
7590 #ifdef USE_TOOLKIT_SCROLL_BARS
7591 /* Make the "Ctrl-Mouse-2 splits window" work for toolkit
7593 if (bar
&& event
->xbutton
.state
& ControlMask
)
7595 x_scroll_bar_handle_click (bar
, event
, &inev
.ie
);
7596 *finish
= X_EVENT_DROP
;
7598 #else /* not USE_TOOLKIT_SCROLL_BARS */
7600 x_scroll_bar_handle_click (bar
, event
, &inev
.ie
);
7601 #endif /* not USE_TOOLKIT_SCROLL_BARS */
7604 if (event
->type
== ButtonPress
)
7606 dpyinfo
->grabbed
|= (1 << event
->xbutton
.button
);
7607 dpyinfo
->last_mouse_frame
= f
;
7608 #if ! defined (USE_GTK)
7609 if (f
&& !tool_bar_p
)
7610 f
->last_tool_bar_item
= -1;
7611 #endif /* not USE_GTK */
7614 dpyinfo
->grabbed
&= ~(1 << event
->xbutton
.button
);
7616 /* Ignore any mouse motion that happened before this event;
7617 any subsequent mouse-movement Emacs events should reflect
7618 only motion after the ButtonPress/Release. */
7622 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
7623 f
= x_menubar_window_to_frame (dpyinfo
, event
);
7624 /* For a down-event in the menu bar,
7625 don't pass it to Xt right now.
7626 Instead, save it away
7627 and we will pass it to Xt from kbd_buffer_get_event.
7628 That way, we can run some Lisp code first. */
7629 if (! popup_activated ()
7631 /* Gtk+ menus only react to the first three buttons. */
7632 && event
->xbutton
.button
< 3
7634 && f
&& event
->type
== ButtonPress
7635 /* Verify the event is really within the menu bar
7636 and not just sent to it due to grabbing. */
7637 && event
->xbutton
.x
>= 0
7638 && event
->xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
7639 && event
->xbutton
.y
>= 0
7640 && event
->xbutton
.y
< FRAME_MENUBAR_HEIGHT (f
)
7641 && event
->xbutton
.same_screen
)
7643 if (!f
->output_data
.x
->saved_menu_event
)
7644 f
->output_data
.x
->saved_menu_event
= xmalloc (sizeof *event
);
7645 *f
->output_data
.x
->saved_menu_event
= *event
;
7646 inev
.ie
.kind
= MENU_BAR_ACTIVATE_EVENT
;
7647 XSETFRAME (inev
.ie
.frame_or_window
, f
);
7648 *finish
= X_EVENT_DROP
;
7652 #endif /* USE_X_TOOLKIT || USE_GTK */
7656 case CirculateNotify
:
7659 case CirculateRequest
:
7662 case VisibilityNotify
:
7666 /* Someone has changed the keyboard mapping - update the
7668 switch (event
->xmapping
.request
)
7670 case MappingModifier
:
7671 x_find_modifier_meanings (dpyinfo
);
7672 /* This is meant to fall through. */
7673 case MappingKeyboard
:
7674 XRefreshKeyboardMapping ((XMappingEvent
*) &event
->xmapping
);
7679 xft_settings_event (dpyinfo
, event
);
7684 #ifdef USE_X_TOOLKIT
7686 if (*finish
!= X_EVENT_DROP
)
7687 XtDispatchEvent ((XEvent
*) event
);
7689 #endif /* USE_X_TOOLKIT */
7694 if (inev
.ie
.kind
!= NO_EVENT
)
7696 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
7701 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
7706 XSETFRAME (frame
, f
);
7712 any_help_event_p
= 1;
7713 gen_help_event (help_echo_string
, frame
, help_echo_window
,
7714 help_echo_object
, help_echo_pos
);
7718 help_echo_string
= Qnil
;
7719 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
7728 /* Handles the XEvent EVENT on display DISPLAY.
7729 This is used for event loops outside the normal event handling,
7730 i.e. looping while a popup menu or a dialog is posted.
7732 Returns the value handle_one_xevent sets in the finish argument. */
7734 x_dispatch_event (XEvent
*event
, Display
*display
)
7736 struct x_display_info
*dpyinfo
;
7737 int finish
= X_EVENT_NORMAL
;
7739 dpyinfo
= x_display_info_for_display (display
);
7742 handle_one_xevent (dpyinfo
, event
, &finish
, 0);
7747 /* Read events coming from the X server.
7748 Return as soon as there are no more events to be read.
7750 Return the number of characters stored into the buffer,
7751 thus pretending to be `read' (except the characters we store
7752 in the keyboard buffer can be multibyte, so are not necessarily
7756 XTread_socket (struct terminal
*terminal
, struct input_event
*hold_quit
)
7759 int event_found
= 0;
7760 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
7764 /* For debugging, this gives a way to fake an I/O error. */
7765 if (dpyinfo
== XTread_socket_fake_io_error
)
7767 XTread_socket_fake_io_error
= 0;
7768 x_io_error_quitter (dpyinfo
->display
);
7772 while (XPending (dpyinfo
->display
))
7777 XNextEvent (dpyinfo
->display
, &event
);
7780 /* Filter events for the current X input method. */
7781 if (x_filter_event (dpyinfo
, &event
))
7786 count
+= handle_one_xevent (dpyinfo
, &event
, &finish
, hold_quit
);
7788 if (finish
== X_EVENT_GOTO_OUT
)
7794 /* For GTK we must use the GTK event loop. But XEvents gets passed
7795 to our filter function above, and then to the big event switch.
7796 We use a bunch of globals to communicate with our filter function,
7797 that is kind of ugly, but it works.
7799 There is no way to do one display at the time, GTK just does events
7800 from all displays. */
7802 while (gtk_events_pending ())
7804 current_count
= count
;
7805 current_hold_quit
= hold_quit
;
7807 gtk_main_iteration ();
7809 count
= current_count
;
7811 current_hold_quit
= 0;
7813 if (current_finish
== X_EVENT_GOTO_OUT
)
7816 #endif /* USE_GTK */
7818 /* On some systems, an X bug causes Emacs to get no more events
7819 when the window is destroyed. Detect that. (1994.) */
7822 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
7823 One XNOOP in 100 loops will make Emacs terminate.
7824 B. Bretthauer, 1994 */
7826 if (x_noop_count
>= 100)
7830 if (next_noop_dpyinfo
== 0)
7831 next_noop_dpyinfo
= x_display_list
;
7833 XNoOp (next_noop_dpyinfo
->display
);
7835 /* Each time we get here, cycle through the displays now open. */
7836 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
7840 /* If the focus was just given to an auto-raising frame,
7841 raise it now. FIXME: handle more than one such frame. */
7842 if (dpyinfo
->x_pending_autoraise_frame
)
7844 x_raise_frame (dpyinfo
->x_pending_autoraise_frame
);
7845 dpyinfo
->x_pending_autoraise_frame
= NULL
;
7856 /***********************************************************************
7858 ***********************************************************************/
7860 /* Set clipping for output in glyph row ROW. W is the window in which
7861 we operate. GC is the graphics context to set clipping in.
7863 ROW may be a text row or, e.g., a mode line. Text rows must be
7864 clipped to the interior of the window dedicated to text display,
7865 mode lines must be clipped to the whole window. */
7868 x_clip_to_row (struct window
*w
, struct glyph_row
*row
,
7869 enum glyph_row_area area
, GC gc
)
7871 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7872 XRectangle clip_rect
;
7873 int window_x
, window_y
, window_width
;
7875 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
7877 clip_rect
.x
= window_x
;
7878 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, row
->y
));
7879 clip_rect
.y
= max (clip_rect
.y
, window_y
);
7880 clip_rect
.width
= window_width
;
7881 clip_rect
.height
= row
->visible_height
;
7883 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
7887 /* Draw a hollow box cursor on window W in glyph row ROW. */
7890 x_draw_hollow_cursor (struct window
*w
, struct glyph_row
*row
)
7892 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7893 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
7894 Display
*dpy
= FRAME_X_DISPLAY (f
);
7897 struct glyph
*cursor_glyph
;
7900 /* Get the glyph the cursor is on. If we can't tell because
7901 the current matrix is invalid or such, give up. */
7902 cursor_glyph
= get_phys_cursor_glyph (w
);
7903 if (cursor_glyph
== NULL
)
7906 /* Compute frame-relative coordinates for phys cursor. */
7907 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &x
, &y
, &h
);
7908 wd
= w
->phys_cursor_width
;
7910 /* The foreground of cursor_gc is typically the same as the normal
7911 background color, which can cause the cursor box to be invisible. */
7912 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7913 if (dpyinfo
->scratch_cursor_gc
)
7914 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
7916 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
7917 GCForeground
, &xgcv
);
7918 gc
= dpyinfo
->scratch_cursor_gc
;
7920 /* Set clipping, draw the rectangle, and reset clipping again. */
7921 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7922 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
- 1);
7923 XSetClipMask (dpy
, gc
, None
);
7927 /* Draw a bar cursor on window W in glyph row ROW.
7929 Implementation note: One would like to draw a bar cursor with an
7930 angle equal to the one given by the font property XA_ITALIC_ANGLE.
7931 Unfortunately, I didn't find a font yet that has this property set.
7935 x_draw_bar_cursor (struct window
*w
, struct glyph_row
*row
, int width
, enum text_cursor_kinds kind
)
7937 struct frame
*f
= XFRAME (w
->frame
);
7938 struct glyph
*cursor_glyph
;
7940 /* If cursor is out of bounds, don't draw garbage. This can happen
7941 in mini-buffer windows when switching between echo area glyphs
7943 cursor_glyph
= get_phys_cursor_glyph (w
);
7944 if (cursor_glyph
== NULL
)
7947 /* If on an image, draw like a normal cursor. That's usually better
7948 visible than drawing a bar, esp. if the image is large so that
7949 the bar might not be in the window. */
7950 if (cursor_glyph
->type
== IMAGE_GLYPH
)
7952 struct glyph_row
*r
;
7953 r
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
7954 draw_phys_cursor_glyph (w
, r
, DRAW_CURSOR
);
7958 Display
*dpy
= FRAME_X_DISPLAY (f
);
7959 Window window
= FRAME_X_WINDOW (f
);
7960 GC gc
= FRAME_DISPLAY_INFO (f
)->scratch_cursor_gc
;
7961 unsigned long mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
7962 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
7965 /* If the glyph's background equals the color we normally draw
7966 the bars cursor in, the bar cursor in its normal color is
7967 invisible. Use the glyph's foreground color instead in this
7968 case, on the assumption that the glyph's colors are chosen so
7969 that the glyph is legible. */
7970 if (face
->background
== f
->output_data
.x
->cursor_pixel
)
7971 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
7973 xgcv
.background
= xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7974 xgcv
.graphics_exposures
= 0;
7977 XChangeGC (dpy
, gc
, mask
, &xgcv
);
7980 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
7981 FRAME_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
7984 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7986 if (kind
== BAR_CURSOR
)
7988 int x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
7991 width
= FRAME_CURSOR_WIDTH (f
);
7992 width
= min (cursor_glyph
->pixel_width
, width
);
7994 w
->phys_cursor_width
= width
;
7996 /* If the character under cursor is R2L, draw the bar cursor
7997 on the right of its glyph, rather than on the left. */
7998 if ((cursor_glyph
->resolved_level
& 1) != 0)
7999 x
+= cursor_glyph
->pixel_width
- width
;
8001 XFillRectangle (dpy
, window
, gc
, x
,
8002 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
8003 width
, row
->height
);
8007 int dummy_x
, dummy_y
, dummy_h
;
8010 width
= row
->height
;
8012 width
= min (row
->height
, width
);
8014 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &dummy_x
,
8015 &dummy_y
, &dummy_h
);
8017 XFillRectangle (dpy
, window
, gc
,
8018 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
8019 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
8020 row
->height
- width
),
8021 w
->phys_cursor_width
, width
);
8024 XSetClipMask (dpy
, gc
, None
);
8029 /* RIF: Define cursor CURSOR on frame F. */
8032 x_define_frame_cursor (struct frame
*f
, Cursor cursor
)
8034 if (!f
->pointer_invisible
8035 && f
->output_data
.x
->current_cursor
!= cursor
)
8036 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
8037 f
->output_data
.x
->current_cursor
= cursor
;
8041 /* RIF: Clear area on frame F. */
8044 x_clear_frame_area (struct frame
*f
, int x
, int y
, int width
, int height
)
8046 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), x
, y
, width
, height
);
8048 /* Must queue a redraw, because scroll bars might have been cleared. */
8049 if (FRAME_GTK_WIDGET (f
))
8050 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
8055 /* RIF: Draw cursor on window W. */
8058 x_draw_window_cursor (struct window
*w
, struct glyph_row
*glyph_row
, int x
,
8059 int y
, enum text_cursor_kinds cursor_type
,
8060 int cursor_width
, bool on_p
, bool active_p
)
8062 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
8066 w
->phys_cursor_type
= cursor_type
;
8067 w
->phys_cursor_on_p
= 1;
8069 if (glyph_row
->exact_window_width_line_p
8070 && (glyph_row
->reversed_p
8071 ? (w
->phys_cursor
.hpos
< 0)
8072 : (w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])))
8074 glyph_row
->cursor_in_fringe_p
= 1;
8075 draw_fringe_bitmap (w
, glyph_row
, glyph_row
->reversed_p
);
8079 switch (cursor_type
)
8081 case HOLLOW_BOX_CURSOR
:
8082 x_draw_hollow_cursor (w
, glyph_row
);
8085 case FILLED_BOX_CURSOR
:
8086 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
8090 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
8094 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
8098 w
->phys_cursor_width
= 0;
8107 if (w
== XWINDOW (f
->selected_window
))
8108 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
8109 xic_set_preeditarea (w
, x
, y
);
8113 XFlush (FRAME_X_DISPLAY (f
));
8119 /* Make the x-window of frame F use the gnu icon bitmap. */
8122 x_bitmap_icon (struct frame
*f
, Lisp_Object file
)
8124 ptrdiff_t bitmap_id
;
8126 if (FRAME_X_WINDOW (f
) == 0)
8129 /* Free up our existing icon bitmap and mask if any. */
8130 if (f
->output_data
.x
->icon_bitmap
> 0)
8131 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
8132 f
->output_data
.x
->icon_bitmap
= 0;
8137 /* Use gtk_window_set_icon_from_file () if available,
8138 It's not restricted to bitmaps */
8139 if (xg_set_icon (f
, file
))
8141 #endif /* USE_GTK */
8142 bitmap_id
= x_create_bitmap_from_file (f
, file
);
8143 x_create_bitmap_mask (f
, bitmap_id
);
8147 /* Create the GNU bitmap and mask if necessary. */
8148 if (FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
8154 if (FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
== -2
8155 || xg_set_icon (f
, xg_default_icon_file
)
8156 || xg_set_icon_from_xpm_data (f
, gnu_xpm_bits
))
8158 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= -2;
8162 #elif defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
8164 rc
= x_create_bitmap_from_xpm_data (f
, gnu_xpm_bits
);
8166 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
8170 /* If all else fails, use the (black and white) xbm image. */
8173 rc
= x_create_bitmap_from_data (f
, (char *) gnu_xbm_bits
,
8174 gnu_xbm_width
, gnu_xbm_height
);
8178 FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
8179 x_create_bitmap_mask (f
, FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
);
8183 /* The first time we create the GNU bitmap and mask,
8184 this increments the ref-count one extra time.
8185 As a result, the GNU bitmap and mask are never freed.
8186 That way, we don't have to worry about allocating it again. */
8187 x_reference_bitmap (f
, FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
);
8189 bitmap_id
= FRAME_DISPLAY_INFO (f
)->icon_bitmap_id
;
8192 x_wm_set_icon_pixmap (f
, bitmap_id
);
8193 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
8199 /* Make the x-window of frame F use a rectangle with text.
8200 Use ICON_NAME as the text. */
8203 x_text_icon (struct frame
*f
, const char *icon_name
)
8205 if (FRAME_X_WINDOW (f
) == 0)
8210 text
.value
= (unsigned char *) icon_name
;
8211 text
.encoding
= XA_STRING
;
8213 text
.nitems
= strlen (icon_name
);
8214 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
8217 if (f
->output_data
.x
->icon_bitmap
> 0)
8218 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
8219 f
->output_data
.x
->icon_bitmap
= 0;
8220 x_wm_set_icon_pixmap (f
, 0);
8225 #define X_ERROR_MESSAGE_SIZE 200
8227 /* If non-nil, this should be a string.
8228 It means catch X errors and store the error message in this string.
8230 The reason we use a stack is that x_catch_error/x_uncatch_error can
8231 be called from a signal handler.
8234 struct x_error_message_stack
{
8235 char string
[X_ERROR_MESSAGE_SIZE
];
8237 struct x_error_message_stack
*prev
;
8239 static struct x_error_message_stack
*x_error_message
;
8241 /* An X error handler which stores the error message in
8242 *x_error_message. This is called from x_error_handler if
8243 x_catch_errors is in effect. */
8246 x_error_catcher (Display
*display
, XErrorEvent
*event
)
8248 XGetErrorText (display
, event
->error_code
,
8249 x_error_message
->string
,
8250 X_ERROR_MESSAGE_SIZE
);
8253 /* Begin trapping X errors for display DPY. Actually we trap X errors
8254 for all displays, but DPY should be the display you are actually
8257 After calling this function, X protocol errors no longer cause
8258 Emacs to exit; instead, they are recorded in the string
8259 stored in *x_error_message.
8261 Calling x_check_errors signals an Emacs error if an X error has
8262 occurred since the last call to x_catch_errors or x_check_errors.
8264 Calling x_uncatch_errors resumes the normal error handling. */
8267 x_catch_errors (Display
*dpy
)
8269 struct x_error_message_stack
*data
= xmalloc (sizeof *data
);
8271 /* Make sure any errors from previous requests have been dealt with. */
8275 data
->string
[0] = 0;
8276 data
->prev
= x_error_message
;
8277 x_error_message
= data
;
8280 /* Undo the last x_catch_errors call.
8281 DPY should be the display that was passed to x_catch_errors. */
8284 x_uncatch_errors (void)
8286 struct x_error_message_stack
*tmp
;
8290 /* The display may have been closed before this function is called.
8291 Check if it is still open before calling XSync. */
8292 if (x_display_info_for_display (x_error_message
->dpy
) != 0)
8293 XSync (x_error_message
->dpy
, False
);
8295 tmp
= x_error_message
;
8296 x_error_message
= x_error_message
->prev
;
8301 /* If any X protocol errors have arrived since the last call to
8302 x_catch_errors or x_check_errors, signal an Emacs error using
8303 sprintf (a buffer, FORMAT, the x error message text) as the text. */
8306 x_check_errors (Display
*dpy
, const char *format
)
8308 /* Make sure to catch any errors incurred so far. */
8311 if (x_error_message
->string
[0])
8313 char string
[X_ERROR_MESSAGE_SIZE
];
8314 memcpy (string
, x_error_message
->string
, X_ERROR_MESSAGE_SIZE
);
8315 x_uncatch_errors ();
8316 error (format
, string
);
8320 /* Nonzero if we had any X protocol errors
8321 since we did x_catch_errors on DPY. */
8324 x_had_errors_p (Display
*dpy
)
8326 /* Make sure to catch any errors incurred so far. */
8329 return x_error_message
->string
[0] != 0;
8332 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
8335 x_clear_errors (Display
*dpy
)
8337 x_error_message
->string
[0] = 0;
8340 #if 0 /* See comment in unwind_to_catch why calling this is a bad
8341 * idea. --lorentey */
8342 /* Close off all unclosed x_catch_errors calls. */
8345 x_fully_uncatch_errors (void)
8347 while (x_error_message
)
8348 x_uncatch_errors ();
8353 static unsigned int x_wire_count
;
8356 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
8361 /************************************************************************
8363 ************************************************************************/
8365 /* Error message passed to x_connection_closed. */
8367 static char *error_msg
;
8369 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
8370 the text of an error message that lead to the connection loss. */
8373 x_connection_closed (Display
*dpy
, const char *error_message
)
8375 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
8376 Lisp_Object frame
, tail
;
8377 ptrdiff_t idx
= SPECPDL_INDEX ();
8379 error_msg
= alloca (strlen (error_message
) + 1);
8380 strcpy (error_msg
, error_message
);
8382 /* Inhibit redisplay while frames are being deleted. */
8383 specbind (Qinhibit_redisplay
, Qt
);
8387 /* Protect display from being closed when we delete the last
8389 dpyinfo
->reference_count
++;
8390 dpyinfo
->terminal
->reference_count
++;
8393 /* First delete frames whose mini-buffers are on frames
8394 that are on the dead display. */
8395 FOR_EACH_FRAME (tail
, frame
)
8397 Lisp_Object minibuf_frame
;
8399 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
8400 if (FRAME_X_P (XFRAME (frame
))
8401 && FRAME_X_P (XFRAME (minibuf_frame
))
8402 && ! EQ (frame
, minibuf_frame
)
8403 && FRAME_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
8404 delete_frame (frame
, Qnoelisp
);
8407 /* Now delete all remaining frames on the dead display.
8408 We are now sure none of these is used as the mini-buffer
8409 for another frame that we need to delete. */
8410 FOR_EACH_FRAME (tail
, frame
)
8411 if (FRAME_X_P (XFRAME (frame
))
8412 && FRAME_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
8414 /* Set this to t so that delete_frame won't get confused
8415 trying to find a replacement. */
8416 kset_default_minibuffer_frame (FRAME_KBOARD (XFRAME (frame
)), Qt
);
8417 delete_frame (frame
, Qnoelisp
);
8420 /* If DPYINFO is null, this means we didn't open the display in the
8421 first place, so don't try to close it. */
8424 /* We can not call XtCloseDisplay here because it calls XSync.
8425 XSync inside the error handler apparently hangs Emacs. On
8426 current Xt versions, this isn't needed either. */
8428 /* A long-standing GTK bug prevents proper disconnect handling
8429 (https://bugzilla.gnome.org/show_bug.cgi?id=85715). Once,
8430 the resulting Glib error message loop filled a user's disk.
8431 To avoid this, kill Emacs unconditionally on disconnect. */
8432 shut_down_emacs (0, Qnil
);
8433 fprintf (stderr
, "%s\n\
8434 When compiled with GTK, Emacs cannot recover from X disconnects.\n\
8435 This is a GTK bug: https://bugzilla.gnome.org/show_bug.cgi?id=85715\n\
8436 For details, see etc/PROBLEMS.\n",
8439 #endif /* USE_GTK */
8441 /* Indicate that this display is dead. */
8442 dpyinfo
->display
= 0;
8444 dpyinfo
->reference_count
--;
8445 dpyinfo
->terminal
->reference_count
--;
8446 if (dpyinfo
->reference_count
!= 0)
8447 /* We have just closed all frames on this display. */
8452 XSETTERMINAL (tmp
, dpyinfo
->terminal
);
8453 Fdelete_terminal (tmp
, Qnoelisp
);
8457 if (terminal_list
== 0)
8459 fprintf (stderr
, "%s\n", error_msg
);
8460 Fkill_emacs (make_number (70));
8464 totally_unblock_input ();
8466 unbind_to (idx
, Qnil
);
8467 clear_waiting_for_input ();
8469 /* Tell GCC not to suggest attribute 'noreturn' for this function. */
8470 IF_LINT (if (! terminal_list
) return; )
8472 /* Here, we absolutely have to use a non-local exit (e.g. signal, throw,
8473 longjmp), because returning from this function would get us back into
8474 Xlib's code which will directly call `exit'. */
8475 error ("%s", error_msg
);
8478 /* We specifically use it before defining it, so that gcc doesn't inline it,
8479 otherwise gdb doesn't know how to properly put a breakpoint on it. */
8480 static void x_error_quitter (Display
*, XErrorEvent
*);
8482 /* This is the first-level handler for X protocol errors.
8483 It calls x_error_quitter or x_error_catcher. */
8486 x_error_handler (Display
*display
, XErrorEvent
*event
)
8488 #if defined USE_GTK && defined HAVE_GTK3
8489 if ((event
->error_code
== BadMatch
|| event
->error_code
== BadWindow
)
8490 && event
->request_code
== X_SetInputFocus
)
8496 if (x_error_message
)
8497 x_error_catcher (display
, event
);
8499 x_error_quitter (display
, event
);
8503 /* This is the usual handler for X protocol errors.
8504 It kills all frames on the display that we got the error for.
8505 If that was the only one, it prints an error message and kills Emacs. */
8507 /* .gdbinit puts a breakpoint here, so make sure it is not inlined. */
8509 /* On older GCC versions, just putting x_error_quitter
8510 after x_error_handler prevents inlining into the former. */
8512 static void NO_INLINE
8513 x_error_quitter (Display
*display
, XErrorEvent
*event
)
8515 char buf
[256], buf1
[356];
8517 /* Ignore BadName errors. They can happen because of fonts
8518 or colors that are not defined. */
8520 if (event
->error_code
== BadName
)
8523 /* Note that there is no real way portable across R3/R4 to get the
8524 original error handler. */
8526 XGetErrorText (display
, event
->error_code
, buf
, sizeof (buf
));
8527 sprintf (buf1
, "X protocol error: %s on protocol request %d",
8528 buf
, event
->request_code
);
8529 x_connection_closed (display
, buf1
);
8533 /* This is the handler for X IO errors, always.
8534 It kills all frames on the display that we lost touch with.
8535 If that was the only one, it prints an error message and kills Emacs. */
8538 x_io_error_quitter (Display
*display
)
8542 snprintf (buf
, sizeof buf
, "Connection lost to X server `%s'",
8543 DisplayString (display
));
8544 x_connection_closed (display
, buf
);
8548 /* Changing the font of the frame. */
8550 /* Give frame F the font FONT-OBJECT as its default font. The return
8551 value is FONT-OBJECT. FONTSET is an ID of the fontset for the
8552 frame. If it is negative, generate a new fontset from
8556 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
8558 struct font
*font
= XFONT_OBJECT (font_object
);
8562 fontset
= fontset_from_font (font_object
);
8563 FRAME_FONTSET (f
) = fontset
;
8564 if (FRAME_FONT (f
) == font
)
8565 /* This font is already set in frame F. There's nothing more to
8569 FRAME_FONT (f
) = font
;
8570 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
8571 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
8572 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (font
);
8574 #ifndef USE_X_TOOLKIT \
8575 /** FRAME_TOOL_BAR_HEIGHT (f) = FRAME_TOOL_BAR_LINES (f) * FRAME_LINE_HEIGHT (f); **/
8576 FRAME_MENU_BAR_HEIGHT (f
) = FRAME_MENU_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
);
8579 /* Compute character columns occupied by scrollbar.
8581 Don't do things differently for non-toolkit scrollbars
8583 unit
= FRAME_COLUMN_WIDTH (f
);
8584 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
8585 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
8586 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + unit
- 1) / unit
;
8588 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + unit
- 1) / unit
;
8590 if (FRAME_X_WINDOW (f
) != 0)
8592 /* Don't change the size of a tip frame; there's no point in
8593 doing it because it's done in Fx_show_tip, and it leads to
8594 problems because the tip frame has no widget. */
8595 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
8596 x_set_window_size (f
, 0, FRAME_COLS (f
) * FRAME_COLUMN_WIDTH (f
),
8597 FRAME_LINES (f
) * FRAME_LINE_HEIGHT (f
), 1);
8602 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
8605 xic_set_xfontset (f
, SSDATA (fontset_ascii (fontset
)));
8614 /***********************************************************************
8616 ***********************************************************************/
8622 /* XIM destroy callback function, which is called whenever the
8623 connection to input method XIM dies. CLIENT_DATA contains a
8624 pointer to the x_display_info structure corresponding to XIM. */
8627 xim_destroy_callback (XIM xim
, XPointer client_data
, XPointer call_data
)
8629 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
8630 Lisp_Object frame
, tail
;
8634 /* No need to call XDestroyIC.. */
8635 FOR_EACH_FRAME (tail
, frame
)
8637 struct frame
*f
= XFRAME (frame
);
8638 if (FRAME_X_P (f
) && FRAME_DISPLAY_INFO (f
) == dpyinfo
)
8640 FRAME_XIC (f
) = NULL
;
8641 xic_free_xfontset (f
);
8645 /* No need to call XCloseIM. */
8646 dpyinfo
->xim
= NULL
;
8647 XFree (dpyinfo
->xim_styles
);
8651 #endif /* HAVE_X11R6 */
8653 /* Open the connection to the XIM server on display DPYINFO.
8654 RESOURCE_NAME is the resource name Emacs uses. */
8657 xim_open_dpy (struct x_display_info
*dpyinfo
, char *resource_name
)
8665 XCloseIM (dpyinfo
->xim
);
8666 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
,
8673 XIMCallback destroy
;
8676 /* Get supported styles and XIM values. */
8677 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
8680 destroy
.callback
= xim_destroy_callback
;
8681 destroy
.client_data
= (XPointer
)dpyinfo
;
8682 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
8688 #endif /* HAVE_XIM */
8689 dpyinfo
->xim
= NULL
;
8693 #ifdef HAVE_X11R6_XIM
8695 /* XIM instantiate callback function, which is called whenever an XIM
8696 server is available. DISPLAY is the display of the XIM.
8697 CLIENT_DATA contains a pointer to an xim_inst_t structure created
8698 when the callback was registered. */
8701 xim_instantiate_callback (Display
*display
, XPointer client_data
, XPointer call_data
)
8703 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
8704 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
8706 /* We don't support multiple XIM connections. */
8710 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
8712 /* Create XIC for the existing frames on the same display, as long
8713 as they have no XIC. */
8714 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
8716 Lisp_Object tail
, frame
;
8719 FOR_EACH_FRAME (tail
, frame
)
8721 struct frame
*f
= XFRAME (frame
);
8724 && FRAME_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
8725 if (FRAME_XIC (f
) == NULL
)
8727 create_frame_xic (f
);
8728 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
8729 xic_set_statusarea (f
);
8730 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
8732 struct window
*w
= XWINDOW (f
->selected_window
);
8733 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
8742 #endif /* HAVE_X11R6_XIM */
8745 /* Open a connection to the XIM server on display DPYINFO.
8746 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
8747 connection only at the first time. On X11R6, open the connection
8748 in the XIM instantiate callback function. */
8751 xim_initialize (struct x_display_info
*dpyinfo
, char *resource_name
)
8753 dpyinfo
->xim
= NULL
;
8757 #ifdef HAVE_X11R6_XIM
8758 struct xim_inst_t
*xim_inst
= xmalloc (sizeof *xim_inst
);
8761 dpyinfo
->xim_callback_data
= xim_inst
;
8762 xim_inst
->dpyinfo
= dpyinfo
;
8763 xim_inst
->resource_name
= xstrdup (resource_name
);
8764 ret
= XRegisterIMInstantiateCallback
8765 (dpyinfo
->display
, dpyinfo
->xrdb
, xim_inst
->resource_name
,
8766 emacs_class
, xim_instantiate_callback
,
8767 /* This is XPointer in XFree86 but (XPointer *)
8768 on Tru64, at least, hence the configure test. */
8769 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
8770 eassert (ret
== True
);
8771 #else /* not HAVE_X11R6_XIM */
8772 xim_open_dpy (dpyinfo
, resource_name
);
8773 #endif /* not HAVE_X11R6_XIM */
8775 #endif /* HAVE_XIM */
8779 /* Close the connection to the XIM server on display DPYINFO. */
8782 xim_close_dpy (struct x_display_info
*dpyinfo
)
8787 #ifdef HAVE_X11R6_XIM
8788 struct xim_inst_t
*xim_inst
= dpyinfo
->xim_callback_data
;
8790 if (dpyinfo
->display
)
8792 Bool ret
= XUnregisterIMInstantiateCallback
8793 (dpyinfo
->display
, dpyinfo
->xrdb
, xim_inst
->resource_name
,
8794 emacs_class
, xim_instantiate_callback
,
8795 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
8796 eassert (ret
== True
);
8798 xfree (xim_inst
->resource_name
);
8800 #endif /* HAVE_X11R6_XIM */
8801 if (dpyinfo
->display
)
8802 XCloseIM (dpyinfo
->xim
);
8803 dpyinfo
->xim
= NULL
;
8804 XFree (dpyinfo
->xim_styles
);
8806 #endif /* HAVE_XIM */
8809 #endif /* not HAVE_X11R6_XIM */
8813 /* Calculate the absolute position in frame F
8814 from its current recorded position values and gravity. */
8817 x_calc_absolute_position (struct frame
*f
)
8819 int flags
= f
->size_hint_flags
;
8821 /* We have nothing to do if the current position
8822 is already for the top-left corner. */
8823 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
8826 /* Treat negative positions as relative to the leftmost bottommost
8827 position that fits on the screen. */
8828 if (flags
& XNegative
)
8829 f
->left_pos
= x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
8830 - FRAME_PIXEL_WIDTH (f
) + f
->left_pos
;
8833 int height
= FRAME_PIXEL_HEIGHT (f
);
8835 #if defined USE_X_TOOLKIT && defined USE_MOTIF
8836 /* Something is fishy here. When using Motif, starting Emacs with
8837 `-g -0-0', the frame appears too low by a few pixels.
8839 This seems to be so because initially, while Emacs is starting,
8840 the column widget's height and the frame's pixel height are
8841 different. The column widget's height is the right one. In
8842 later invocations, when Emacs is up, the frame's pixel height
8845 It's not obvious where the initial small difference comes from.
8846 2000-12-01, gerd. */
8848 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
8851 if (flags
& YNegative
)
8852 f
->top_pos
= x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
8853 - height
+ f
->top_pos
;
8856 /* The left_pos and top_pos
8857 are now relative to the top and left screen edges,
8858 so the flags should correspond. */
8859 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8862 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
8863 to really change the position, and 0 when calling from
8864 x_make_frame_visible (in that case, XOFF and YOFF are the current
8865 position values). It is -1 when calling from x_set_frame_parameters,
8866 which means, do adjust for borders but don't change the gravity. */
8869 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
, int change_gravity
)
8871 int modified_top
, modified_left
;
8873 if (change_gravity
> 0)
8877 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8879 f
->size_hint_flags
|= XNegative
;
8881 f
->size_hint_flags
|= YNegative
;
8882 f
->win_gravity
= NorthWestGravity
;
8884 x_calc_absolute_position (f
);
8887 x_wm_set_size_hint (f
, 0, 0);
8889 modified_left
= f
->left_pos
;
8890 modified_top
= f
->top_pos
;
8892 if (change_gravity
!= 0 && FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
)
8894 /* Some WMs (twm, wmaker at least) has an offset that is smaller
8895 than the WM decorations. So we use the calculated offset instead
8896 of the WM decoration sizes here (x/y_pixels_outer_diff). */
8897 modified_left
+= FRAME_X_OUTPUT (f
)->move_offset_left
;
8898 modified_top
+= FRAME_X_OUTPUT (f
)->move_offset_top
;
8901 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8902 modified_left
, modified_top
);
8904 x_sync_with_move (f
, f
->left_pos
, f
->top_pos
,
8905 FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8908 /* change_gravity is non-zero when this function is called from Lisp to
8909 programmatically move a frame. In that case, we call
8910 x_check_expected_move to discover if we have a "Type A" or "Type B"
8911 window manager, and, for a "Type A" window manager, adjust the position
8914 We call x_check_expected_move if a programmatic move occurred, and
8915 either the window manager type (A/B) is unknown or it is Type A but we
8916 need to compute the top/left offset adjustment for this frame. */
8918 if (change_gravity
!= 0 &&
8919 (FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8920 || (FRAME_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
8921 && (FRAME_X_OUTPUT (f
)->move_offset_left
== 0
8922 && FRAME_X_OUTPUT (f
)->move_offset_top
== 0))))
8923 x_check_expected_move (f
, modified_left
, modified_top
);
8928 /* Return non-zero if _NET_SUPPORTING_WM_CHECK window exists and _NET_SUPPORTED
8929 on the root window for frame F contains ATOMNAME.
8930 This is how a WM check shall be done according to the Window Manager
8931 Specification/Extended Window Manager Hints at
8932 http://freedesktop.org/wiki/Specifications/wm-spec. */
8935 wm_supports (struct frame
*f
, Atom want_atom
)
8938 unsigned long actual_size
, bytes_remaining
;
8939 int i
, rc
, actual_format
;
8940 Window wmcheck_window
;
8941 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
8942 Window target_window
= dpyinfo
->root_window
;
8943 long max_len
= 65536;
8944 Display
*dpy
= FRAME_X_DISPLAY (f
);
8945 unsigned char *tmp_data
= NULL
;
8946 Atom target_type
= XA_WINDOW
;
8950 x_catch_errors (dpy
);
8951 rc
= XGetWindowProperty (dpy
, target_window
,
8952 dpyinfo
->Xatom_net_supporting_wm_check
,
8953 0, max_len
, False
, target_type
,
8954 &actual_type
, &actual_format
, &actual_size
,
8955 &bytes_remaining
, &tmp_data
);
8957 if (rc
!= Success
|| actual_type
!= XA_WINDOW
|| x_had_errors_p (dpy
))
8959 if (tmp_data
) XFree (tmp_data
);
8960 x_uncatch_errors ();
8965 wmcheck_window
= *(Window
*) tmp_data
;
8968 /* Check if window exists. */
8969 XSelectInput (dpy
, wmcheck_window
, StructureNotifyMask
);
8971 if (x_had_errors_p (dpy
))
8973 x_uncatch_errors ();
8978 if (dpyinfo
->net_supported_window
!= wmcheck_window
)
8980 /* Window changed, reload atoms */
8981 if (dpyinfo
->net_supported_atoms
!= NULL
)
8982 XFree (dpyinfo
->net_supported_atoms
);
8983 dpyinfo
->net_supported_atoms
= NULL
;
8984 dpyinfo
->nr_net_supported_atoms
= 0;
8985 dpyinfo
->net_supported_window
= 0;
8987 target_type
= XA_ATOM
;
8989 rc
= XGetWindowProperty (dpy
, target_window
,
8990 dpyinfo
->Xatom_net_supported
,
8991 0, max_len
, False
, target_type
,
8992 &actual_type
, &actual_format
, &actual_size
,
8993 &bytes_remaining
, &tmp_data
);
8995 if (rc
!= Success
|| actual_type
!= XA_ATOM
|| x_had_errors_p (dpy
))
8997 if (tmp_data
) XFree (tmp_data
);
8998 x_uncatch_errors ();
9003 dpyinfo
->net_supported_atoms
= (Atom
*)tmp_data
;
9004 dpyinfo
->nr_net_supported_atoms
= actual_size
;
9005 dpyinfo
->net_supported_window
= wmcheck_window
;
9010 for (i
= 0; rc
== 0 && i
< dpyinfo
->nr_net_supported_atoms
; ++i
)
9011 rc
= dpyinfo
->net_supported_atoms
[i
] == want_atom
;
9013 x_uncatch_errors ();
9020 set_wm_state (Lisp_Object frame
, int add
, Atom atom
, Atom value
)
9022 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (XFRAME (frame
));
9024 x_send_client_event (frame
, make_number (0), frame
,
9025 dpyinfo
->Xatom_net_wm_state
,
9027 /* 1 = add, 0 = remove */
9029 (make_number (add
? 1 : 0),
9031 (make_fixnum_or_float (atom
),
9033 ? list1 (make_fixnum_or_float (value
))
9038 x_set_sticky (struct frame
*f
, Lisp_Object new_value
, Lisp_Object old_value
)
9041 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9043 XSETFRAME (frame
, f
);
9045 set_wm_state (frame
, NILP (new_value
) ? 0 : 1,
9046 dpyinfo
->Xatom_net_wm_state_sticky
, None
);
9049 /* Return the current _NET_WM_STATE.
9050 SIZE_STATE is set to one of the FULLSCREEN_* values.
9051 STICKY is set to 1 if the sticky state is set, 0 if not.
9053 Return non-zero if we are not hidden, zero if we are. */
9056 get_current_wm_state (struct frame
*f
,
9062 unsigned long actual_size
, bytes_remaining
;
9063 int i
, rc
, actual_format
, is_hidden
= 0;
9064 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9065 long max_len
= 65536;
9066 Display
*dpy
= FRAME_X_DISPLAY (f
);
9067 unsigned char *tmp_data
= NULL
;
9068 Atom target_type
= XA_ATOM
;
9071 *size_state
= FULLSCREEN_NONE
;
9074 x_catch_errors (dpy
);
9075 rc
= XGetWindowProperty (dpy
, window
, dpyinfo
->Xatom_net_wm_state
,
9076 0, max_len
, False
, target_type
,
9077 &actual_type
, &actual_format
, &actual_size
,
9078 &bytes_remaining
, &tmp_data
);
9080 if (rc
!= Success
|| actual_type
!= target_type
|| x_had_errors_p (dpy
))
9082 if (tmp_data
) XFree (tmp_data
);
9083 x_uncatch_errors ();
9085 return !FRAME_ICONIFIED_P (f
);
9088 x_uncatch_errors ();
9090 for (i
= 0; i
< actual_size
; ++i
)
9092 Atom a
= ((Atom
*)tmp_data
)[i
];
9093 if (a
== dpyinfo
->Xatom_net_wm_state_hidden
)
9096 f
->output_data
.x
->net_wm_state_hidden_seen
= 1;
9098 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_horz
)
9100 if (*size_state
== FULLSCREEN_HEIGHT
)
9101 *size_state
= FULLSCREEN_MAXIMIZED
;
9103 *size_state
= FULLSCREEN_WIDTH
;
9105 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_vert
)
9107 if (*size_state
== FULLSCREEN_WIDTH
)
9108 *size_state
= FULLSCREEN_MAXIMIZED
;
9110 *size_state
= FULLSCREEN_HEIGHT
;
9112 else if (a
== dpyinfo
->Xatom_net_wm_state_fullscreen
)
9113 *size_state
= FULLSCREEN_BOTH
;
9114 else if (a
== dpyinfo
->Xatom_net_wm_state_sticky
)
9118 if (tmp_data
) XFree (tmp_data
);
9123 /* Do fullscreen as specified in extended window manager hints */
9126 do_ewmh_fullscreen (struct frame
*f
)
9128 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9129 int have_net_atom
= wm_supports (f
, dpyinfo
->Xatom_net_wm_state
);
9132 (void)get_current_wm_state (f
, FRAME_OUTER_WINDOW (f
), &cur
, &dummy
);
9134 /* Some window managers don't say they support _NET_WM_STATE, but they do say
9135 they support _NET_WM_STATE_FULLSCREEN. Try that also. */
9137 have_net_atom
= wm_supports (f
, dpyinfo
->Xatom_net_wm_state_fullscreen
);
9139 if (have_net_atom
&& cur
!= f
->want_fullscreen
)
9143 XSETFRAME (frame
, f
);
9145 /* Keep number of calls to set_wm_state as low as possible.
9146 Some window managers, or possible Gtk+, hangs when too many
9147 are sent at once. */
9148 switch (f
->want_fullscreen
)
9150 case FULLSCREEN_BOTH
:
9151 if (cur
== FULLSCREEN_WIDTH
|| cur
== FULLSCREEN_MAXIMIZED
9152 || cur
== FULLSCREEN_HEIGHT
)
9153 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_maximized_horz
,
9154 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
9155 set_wm_state (frame
, 1, dpyinfo
->Xatom_net_wm_state_fullscreen
, None
);
9157 case FULLSCREEN_WIDTH
:
9158 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_HEIGHT
9159 || cur
== FULLSCREEN_MAXIMIZED
)
9160 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_fullscreen
,
9161 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
9162 if (cur
!= FULLSCREEN_MAXIMIZED
)
9163 set_wm_state (frame
, 1, dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
9165 case FULLSCREEN_HEIGHT
:
9166 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_WIDTH
9167 || cur
== FULLSCREEN_MAXIMIZED
)
9168 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_fullscreen
,
9169 dpyinfo
->Xatom_net_wm_state_maximized_horz
);
9170 if (cur
!= FULLSCREEN_MAXIMIZED
)
9171 set_wm_state (frame
, 1, dpyinfo
->Xatom_net_wm_state_maximized_vert
, None
);
9173 case FULLSCREEN_MAXIMIZED
:
9174 if (cur
== FULLSCREEN_BOTH
)
9175 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_fullscreen
, None
);
9176 set_wm_state (frame
, 1, dpyinfo
->Xatom_net_wm_state_maximized_horz
,
9177 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
9179 case FULLSCREEN_NONE
:
9180 if (cur
== FULLSCREEN_BOTH
)
9181 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_fullscreen
, None
);
9183 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_maximized_horz
,
9184 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
9187 f
->want_fullscreen
= FULLSCREEN_NONE
;
9191 return have_net_atom
;
9195 XTfullscreen_hook (struct frame
*f
)
9197 if (FRAME_VISIBLE_P (f
))
9200 x_check_fullscreen (f
);
9208 x_handle_net_wm_state (struct frame
*f
, const XPropertyEvent
*event
)
9210 int value
= FULLSCREEN_NONE
;
9213 int not_hidden
= get_current_wm_state (f
, event
->window
, &value
, &sticky
);
9218 case FULLSCREEN_WIDTH
:
9221 case FULLSCREEN_HEIGHT
:
9224 case FULLSCREEN_BOTH
:
9227 case FULLSCREEN_MAXIMIZED
:
9232 store_frame_param (f
, Qfullscreen
, lval
);
9233 store_frame_param (f
, Qsticky
, sticky
? Qt
: Qnil
);
9238 /* Check if we need to resize the frame due to a fullscreen request.
9239 If so needed, resize the frame. */
9241 x_check_fullscreen (struct frame
*f
)
9243 if (do_ewmh_fullscreen (f
))
9246 if (f
->output_data
.x
->parent_desc
!= FRAME_DISPLAY_INFO (f
)->root_window
)
9247 return; /* Only fullscreen without WM or with EWM hints (above). */
9249 /* Setting fullscreen to nil doesn't do anything. We could save the
9250 last non-fullscreen size and restore it, but it seems like a
9251 lot of work for this unusual case (no window manager running). */
9253 if (f
->want_fullscreen
!= FULLSCREEN_NONE
)
9255 int width
= FRAME_PIXEL_WIDTH (f
), height
= FRAME_PIXEL_HEIGHT (f
);
9256 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9258 switch (f
->want_fullscreen
)
9260 /* No difference between these two when there is no WM */
9261 case FULLSCREEN_BOTH
:
9262 case FULLSCREEN_MAXIMIZED
:
9263 width
= x_display_pixel_width (dpyinfo
);
9264 height
= x_display_pixel_height (dpyinfo
);
9266 case FULLSCREEN_WIDTH
:
9267 width
= x_display_pixel_width (dpyinfo
);
9269 case FULLSCREEN_HEIGHT
:
9270 height
= x_display_pixel_height (dpyinfo
);
9273 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9278 /* This function is called by x_set_offset to determine whether the window
9279 manager interfered with the positioning of the frame. Type A window
9280 managers position the surrounding window manager decorations a small
9281 amount above and left of the user-supplied position. Type B window
9282 managers position the surrounding window manager decorations at the
9283 user-specified position. If we detect a Type A window manager, we
9284 compensate by moving the window right and down by the proper amount. */
9287 x_check_expected_move (struct frame
*f
, int expected_left
, int expected_top
)
9289 int current_left
= 0, current_top
= 0;
9291 /* x_real_positions returns the left and top offsets of the outermost
9292 window manager window around the frame. */
9294 x_real_positions (f
, ¤t_left
, ¤t_top
);
9296 if (current_left
!= expected_left
|| current_top
!= expected_top
)
9298 /* It's a "Type A" window manager. */
9303 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_A
;
9304 FRAME_X_OUTPUT (f
)->move_offset_left
= expected_left
- current_left
;
9305 FRAME_X_OUTPUT (f
)->move_offset_top
= expected_top
- current_top
;
9307 /* Now fix the mispositioned frame's location. */
9309 adjusted_left
= expected_left
+ FRAME_X_OUTPUT (f
)->move_offset_left
;
9310 adjusted_top
= expected_top
+ FRAME_X_OUTPUT (f
)->move_offset_top
;
9312 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9313 adjusted_left
, adjusted_top
);
9315 x_sync_with_move (f
, expected_left
, expected_top
, 0);
9318 /* It's a "Type B" window manager. We don't have to adjust the
9319 frame's position. */
9321 FRAME_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_B
;
9325 /* Wait for XGetGeometry to return up-to-date position information for a
9326 recently-moved frame. Call this immediately after calling XMoveWindow.
9327 If FUZZY is non-zero, then LEFT and TOP are just estimates of where the
9328 frame has been moved to, so we use a fuzzy position comparison instead
9329 of an exact comparison. */
9332 x_sync_with_move (struct frame
*f
, int left
, int top
, int fuzzy
)
9336 while (count
++ < 50)
9338 int current_left
= 0, current_top
= 0;
9340 /* In theory, this call to XSync only needs to happen once, but in
9341 practice, it doesn't seem to work, hence the need for the surrounding
9344 XSync (FRAME_X_DISPLAY (f
), False
);
9345 x_real_positions (f
, ¤t_left
, ¤t_top
);
9349 /* The left fuzz-factor is 10 pixels. The top fuzz-factor is 40
9352 if (eabs (current_left
- left
) <= 10
9353 && eabs (current_top
- top
) <= 40)
9356 else if (current_left
== left
&& current_top
== top
)
9360 /* As a last resort, just wait 0.5 seconds and hope that XGetGeometry
9361 will then return up-to-date position info. */
9363 wait_reading_process_output (0, 500000000, 0, 0, Qnil
, NULL
, 0);
9367 /* Wait for an event on frame F matching EVENTTYPE. */
9369 x_wait_for_event (struct frame
*f
, int eventtype
)
9371 int level
= interrupt_input_blocked
;
9374 struct timespec tmo
, tmo_at
, time_now
;
9375 int fd
= ConnectionNumber (FRAME_X_DISPLAY (f
));
9377 f
->wait_event_type
= eventtype
;
9379 /* Set timeout to 0.1 second. Hopefully not noticeable.
9380 Maybe it should be configurable. */
9381 tmo
= make_timespec (0, 100 * 1000 * 1000);
9382 tmo_at
= timespec_add (current_timespec (), tmo
);
9384 while (f
->wait_event_type
)
9386 pending_signals
= 1;
9387 totally_unblock_input ();
9388 /* XTread_socket is called after unblock. */
9390 interrupt_input_blocked
= level
;
9395 time_now
= current_timespec ();
9396 if (timespec_cmp (tmo_at
, time_now
) < 0)
9399 tmo
= timespec_sub (tmo_at
, time_now
);
9400 if (pselect (fd
+ 1, &fds
, NULL
, NULL
, &tmo
, NULL
) == 0)
9401 break; /* Timeout */
9404 f
->wait_event_type
= 0;
9408 /* Change the size of frame F's X window to WIDTH/HEIGHT in the case F
9409 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
9410 top-left-corner window gravity for this size change and subsequent
9411 size changes. Otherwise we leave the window gravity unchanged. */
9414 x_set_window_size_1 (struct frame
*f
, int change_gravity
, int width
, int height
, bool pixelwise
)
9416 int pixelwidth
, pixelheight
;
9418 /** if (pixelwise) **/
9420 /** pixelwidth = FRAME_TEXT_TO_PIXEL_WIDTH (f, width); **/
9421 /** pixelheight = FRAME_TEXT_TO_PIXEL_HEIGHT (f, height); **/
9425 /** pixelwidth = FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f, width); **/
9426 /** pixelheight = FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f, height); **/
9429 /** FRAME_TOOL_BAR_HEIGHT (f) = FRAME_TOOLBAR_HEIGHT (f); **/
9430 pixelwidth
= (pixelwise
9431 ? FRAME_TEXT_TO_PIXEL_WIDTH (f
, width
)
9432 : FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, width
));
9433 pixelheight
= ((pixelwise
9434 ? FRAME_TEXT_TO_PIXEL_HEIGHT (f
, height
)
9435 : FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, height
)));
9437 /** pixelwidth = ((pixelwise ? width : (width * FRAME_COLUMN_WIDTH (f))) **/
9438 /** + FRAME_SCROLL_BAR_AREA_WIDTH (f) **/
9439 /** + FRAME_TOTAL_FRINGE_WIDTH (f) **/
9440 /** + 2 * FRAME_INTERNAL_BORDER_WIDTH (f)); **/
9442 /** pixelheight = ((pixelwise ? height : (height * FRAME_LINE_HEIGHT (f))) **/
9443 /** + FRAME_TOOLBAR_HEIGHT (f) **/
9444 /** + FRAME_SCROLL_BAR_AREA_HEIGHT (f) **/
9445 /** + 2 * FRAME_INTERNAL_BORDER_WIDTH (f)); **/
9447 if (change_gravity
) f
->win_gravity
= NorthWestGravity
;
9448 x_wm_set_size_hint (f
, 0, 0);
9449 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9450 pixelwidth
, pixelheight
+ FRAME_MENUBAR_HEIGHT (f
));
9453 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
9454 receive in the ConfigureNotify event; if we get what we asked
9455 for, then the event won't cause the screen to become garbaged, so
9456 we have to make sure to do it here. */
9457 SET_FRAME_GARBAGED (f
);
9459 /* Now, strictly speaking, we can't be sure that this is accurate,
9460 but the window manager will get around to dealing with the size
9461 change request eventually, and we'll hear how it went when the
9462 ConfigureNotify event gets here.
9464 We could just not bother storing any of this information here,
9465 and let the ConfigureNotify event set everything up, but that
9466 might be kind of confusing to the Lisp code, since size changes
9467 wouldn't be reported in the frame parameters until some random
9468 point in the future when the ConfigureNotify event arrives.
9470 We pass 1 for DELAY since we can't run Lisp code inside of
9473 /* But the ConfigureNotify may in fact never arrive, and then this is
9474 not right if the frame is visible. Instead wait (with timeout)
9475 for the ConfigureNotify. */
9476 if (FRAME_VISIBLE_P (f
))
9477 x_wait_for_event (f
, ConfigureNotify
);
9480 change_frame_size (f
, pixelwidth
, pixelheight
, 0, 1, 0, 1);
9486 /* Call this to change the size of frame F's x-window.
9487 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
9488 for this size change and subsequent size changes.
9489 Otherwise we leave the window gravity unchanged. */
9492 x_set_window_size (struct frame
*f
, int change_gravity
, int width
, int height
, bool pixelwise
)
9496 /* The following breaks our calculations. If it's really needed,
9497 think of something else. */
9499 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
9501 int text_width
, text_height
;
9503 /* When the frame is maximized/fullscreen or running under for
9504 example Xmonad, x_set_window_size_1 will be a no-op.
9505 In that case, the right thing to do is extend rows/width to
9506 the current frame size. We do that first if x_set_window_size_1
9507 turns out to not be a no-op (there is no way to know).
9508 The size will be adjusted again if the frame gets a
9509 ConfigureNotify event as a result of x_set_window_size. */
9510 int pixelh
= FRAME_PIXEL_HEIGHT (f
);
9511 #ifdef USE_X_TOOLKIT
9512 /* The menu bar is not part of text lines. The tool bar
9514 pixelh
-= FRAME_MENUBAR_HEIGHT (f
);
9516 text_width
= FRAME_PIXEL_TO_TEXT_WIDTH (f
, FRAME_PIXEL_WIDTH (f
));
9517 text_height
= FRAME_PIXEL_TO_TEXT_HEIGHT (f
, pixelh
);
9519 change_frame_size (f
, text_width
, text_height
, 0, 1, 0, 1);
9524 if (FRAME_GTK_WIDGET (f
))
9526 xg_frame_set_char_size (f
, width
* FRAME_COLUMN_WIDTH (f
),
9527 height
* FRAME_LINE_HEIGHT (f
));
9529 xg_frame_set_char_size (f
, width
, height
);
9531 x_set_window_size_1 (f
, change_gravity
, width
, height
, pixelwise
);
9532 #else /* not USE_GTK */
9534 x_set_window_size_1 (f
, change_gravity
, width
, height
, pixelwise
);
9535 x_clear_under_internal_border (f
);
9537 #endif /* not USE_GTK */
9539 /* If cursor was outside the new size, mark it as off. */
9540 mark_window_cursors_off (XWINDOW (f
->root_window
));
9542 /* Clear out any recollection of where the mouse highlighting was,
9543 since it might be in a place that's outside the new frame size.
9544 Actually checking whether it is outside is a pain in the neck,
9545 so don't try--just let the highlighting be done afresh with new size. */
9546 cancel_mouse_face (f
);
9550 do_pending_window_change (0);
9553 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
9556 frame_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
9560 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
9561 0, 0, 0, 0, pix_x
, pix_y
);
9565 /* Raise frame F. */
9568 x_raise_frame (struct frame
*f
)
9571 if (FRAME_VISIBLE_P (f
))
9572 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
9573 XFlush (FRAME_X_DISPLAY (f
));
9577 /* Lower frame F. */
9580 x_lower_frame (struct frame
*f
)
9582 if (FRAME_VISIBLE_P (f
))
9585 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
9586 XFlush (FRAME_X_DISPLAY (f
));
9591 /* Request focus with XEmbed */
9594 xembed_request_focus (struct frame
*f
)
9596 /* See XEmbed Protocol Specification at
9597 http://freedesktop.org/wiki/Specifications/xembed-spec */
9598 if (FRAME_VISIBLE_P (f
))
9599 xembed_send_message (f
, CurrentTime
,
9600 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
9603 /* Activate frame with Extended Window Manager Hints */
9606 x_ewmh_activate_frame (struct frame
*f
)
9608 /* See Window Manager Specification/Extended Window Manager Hints at
9609 http://freedesktop.org/wiki/Specifications/wm-spec */
9611 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9613 if (FRAME_VISIBLE_P (f
) && wm_supports (f
, dpyinfo
->Xatom_net_active_window
))
9616 XSETFRAME (frame
, f
);
9617 x_send_client_event (frame
, make_number (0), frame
,
9618 dpyinfo
->Xatom_net_active_window
,
9620 list2i (1, dpyinfo
->last_user_time
));
9625 XTframe_raise_lower (struct frame
*f
, int raise_flag
)
9633 /* XEmbed implementation. */
9635 #if defined USE_X_TOOLKIT || ! defined USE_GTK
9637 /* XEmbed implementation. */
9639 #define XEMBED_VERSION 0
9642 xembed_set_info (struct frame
*f
, enum xembed_info flags
)
9644 unsigned long data
[2];
9645 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
9647 data
[0] = XEMBED_VERSION
;
9650 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9651 dpyinfo
->Xatom_XEMBED_INFO
, dpyinfo
->Xatom_XEMBED_INFO
,
9652 32, PropModeReplace
, (unsigned char *) data
, 2);
9654 #endif /* defined USE_X_TOOLKIT || ! defined USE_GTK */
9657 xembed_send_message (struct frame
*f
, Time t
, enum xembed_message msg
,
9658 long int detail
, long int data1
, long int data2
)
9662 event
.xclient
.type
= ClientMessage
;
9663 event
.xclient
.window
= FRAME_X_OUTPUT (f
)->parent_desc
;
9664 event
.xclient
.message_type
= FRAME_DISPLAY_INFO (f
)->Xatom_XEMBED
;
9665 event
.xclient
.format
= 32;
9666 event
.xclient
.data
.l
[0] = t
;
9667 event
.xclient
.data
.l
[1] = msg
;
9668 event
.xclient
.data
.l
[2] = detail
;
9669 event
.xclient
.data
.l
[3] = data1
;
9670 event
.xclient
.data
.l
[4] = data2
;
9672 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_OUTPUT (f
)->parent_desc
,
9673 False
, NoEventMask
, &event
);
9674 XSync (FRAME_X_DISPLAY (f
), False
);
9677 /* Change of visibility. */
9679 /* This tries to wait until the frame is really visible.
9680 However, if the window manager asks the user where to position
9681 the frame, this will return before the user finishes doing that.
9682 The frame will not actually be visible at that time,
9683 but it will become visible later when the window manager
9684 finishes with it. */
9687 x_make_frame_visible (struct frame
*f
)
9689 int original_top
, original_left
;
9694 x_set_bitmap_icon (f
);
9696 if (! FRAME_VISIBLE_P (f
))
9698 /* We test FRAME_GARBAGED_P here to make sure we don't
9699 call x_set_offset a second time
9700 if we get to x_make_frame_visible a second time
9701 before the window gets really visible. */
9702 if (! FRAME_ICONIFIED_P (f
)
9703 && ! FRAME_X_EMBEDDED_P (f
)
9704 && ! f
->output_data
.x
->asked_for_visible
)
9705 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
9707 f
->output_data
.x
->asked_for_visible
= 1;
9709 if (! EQ (Vx_no_window_manager
, Qt
))
9710 x_wm_set_window_state (f
, NormalState
);
9711 #ifdef USE_X_TOOLKIT
9712 if (FRAME_X_EMBEDDED_P (f
))
9713 xembed_set_info (f
, XEMBED_MAPPED
);
9716 /* This was XtPopup, but that did nothing for an iconified frame. */
9717 XtMapWidget (f
->output_data
.x
->widget
);
9719 #else /* not USE_X_TOOLKIT */
9721 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
9722 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
9724 if (FRAME_X_EMBEDDED_P (f
))
9725 xembed_set_info (f
, XEMBED_MAPPED
);
9727 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9728 #endif /* not USE_GTK */
9729 #endif /* not USE_X_TOOLKIT */
9732 XFlush (FRAME_X_DISPLAY (f
));
9734 /* Synchronize to ensure Emacs knows the frame is visible
9735 before we do anything else. We do this loop with input not blocked
9736 so that incoming events are handled. */
9739 /* This must be before UNBLOCK_INPUT
9740 since events that arrive in response to the actions above
9741 will set it when they are handled. */
9742 int previously_visible
= f
->output_data
.x
->has_been_visible
;
9744 original_left
= f
->left_pos
;
9745 original_top
= f
->top_pos
;
9747 /* This must come after we set COUNT. */
9750 /* We unblock here so that arriving X events are processed. */
9752 /* Now move the window back to where it was "supposed to be".
9753 But don't do it if the gravity is negative.
9754 When the gravity is negative, this uses a position
9755 that is 3 pixels too low. Perhaps that's really the border width.
9757 Don't do this if the window has never been visible before,
9758 because the window manager may choose the position
9759 and we don't want to override it. */
9761 if (! FRAME_VISIBLE_P (f
)
9762 && ! FRAME_ICONIFIED_P (f
)
9763 && ! FRAME_X_EMBEDDED_P (f
)
9764 && f
->win_gravity
== NorthWestGravity
9765 && previously_visible
)
9769 unsigned int width
, height
, border
, depth
;
9773 /* On some window managers (such as FVWM) moving an existing
9774 window, even to the same place, causes the window manager
9775 to introduce an offset. This can cause the window to move
9776 to an unexpected location. Check the geometry (a little
9777 slow here) and then verify that the window is in the right
9778 place. If the window is not in the right place, move it
9779 there, and take the potential window manager hit. */
9780 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9781 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
9783 if (original_left
!= x
|| original_top
!= y
)
9784 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9785 original_left
, original_top
);
9790 XSETFRAME (frame
, f
);
9792 /* Process X events until a MapNotify event has been seen. */
9793 while (!FRAME_VISIBLE_P (f
))
9795 /* Force processing of queued events. */
9798 /* If on another desktop, the deiconify/map may be ignored and the
9799 frame never becomes visible. XMonad does this.
9800 Prevent an endless loop. */
9801 if (FRAME_ICONIFIED_P (f
) && ++tries
> 100)
9804 /* This hack is still in use at least for Cygwin. See
9805 http://lists.gnu.org/archive/html/emacs-devel/2013-12/msg00351.html.
9807 Machines that do polling rather than SIGIO have been
9808 observed to go into a busy-wait here. So we'll fake an
9809 alarm signal to let the handler know that there's something
9810 to be read. We used to raise a real alarm, but it seems
9811 that the handler isn't always enabled here. This is
9813 if (input_polling_used ())
9815 /* It could be confusing if a real alarm arrives while
9816 processing the fake one. Turn it off and let the
9817 handler reset it. */
9818 int old_poll_suppress_count
= poll_suppress_count
;
9819 poll_suppress_count
= 1;
9820 poll_for_input_1 ();
9821 poll_suppress_count
= old_poll_suppress_count
;
9824 if (XPending (FRAME_X_DISPLAY (f
)))
9827 XNextEvent (FRAME_X_DISPLAY (f
), &xev
);
9828 x_dispatch_event (&xev
, FRAME_X_DISPLAY (f
));
9834 /* Change from mapped state to withdrawn state. */
9836 /* Make the frame visible (mapped and not iconified). */
9839 x_make_frame_invisible (struct frame
*f
)
9843 /* Use the frame's outermost window, not the one we normally draw on. */
9844 window
= FRAME_OUTER_WINDOW (f
);
9846 /* Don't keep the highlight on an invisible frame. */
9847 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9848 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9852 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
9853 that the current position of the window is user-specified, rather than
9854 program-specified, so that when the window is mapped again, it will be
9855 placed at the same location, without forcing the user to position it
9856 by hand again (they have already done that once for this window.) */
9857 x_wm_set_size_hint (f
, 0, 1);
9860 if (FRAME_GTK_OUTER_WIDGET (f
))
9861 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f
));
9864 if (FRAME_X_EMBEDDED_P (f
))
9865 xembed_set_info (f
, 0);
9870 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
9871 DefaultScreen (FRAME_X_DISPLAY (f
))))
9874 error ("Can't notify window manager of window withdrawal");
9878 /* We can't distinguish this from iconification
9879 just by the event that we get from the server.
9880 So we can't win using the usual strategy of letting
9881 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
9882 and synchronize with the server to make sure we agree. */
9883 SET_FRAME_VISIBLE (f
, 0);
9884 SET_FRAME_ICONIFIED (f
, 0);
9891 /* Change window state from mapped to iconified. */
9894 x_iconify_frame (struct frame
*f
)
9896 #ifdef USE_X_TOOLKIT
9900 /* Don't keep the highlight on an invisible frame. */
9901 if (FRAME_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9902 FRAME_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9904 if (FRAME_ICONIFIED_P (f
))
9909 x_set_bitmap_icon (f
);
9911 #if defined (USE_GTK)
9912 if (FRAME_GTK_OUTER_WIDGET (f
))
9914 if (! FRAME_VISIBLE_P (f
))
9915 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
9917 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
9918 SET_FRAME_VISIBLE (f
, 0);
9919 SET_FRAME_ICONIFIED (f
, 1);
9925 #ifdef USE_X_TOOLKIT
9927 if (! FRAME_VISIBLE_P (f
))
9929 if (! EQ (Vx_no_window_manager
, Qt
))
9930 x_wm_set_window_state (f
, IconicState
);
9931 /* This was XtPopup, but that did nothing for an iconified frame. */
9932 XtMapWidget (f
->output_data
.x
->widget
);
9933 /* The server won't give us any event to indicate
9934 that an invisible frame was changed to an icon,
9935 so we have to record it here. */
9936 SET_FRAME_VISIBLE (f
, 0);
9937 SET_FRAME_ICONIFIED (f
, 1);
9942 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
9943 XtWindow (f
->output_data
.x
->widget
),
9944 DefaultScreen (FRAME_X_DISPLAY (f
)));
9948 error ("Can't notify window manager of iconification");
9950 SET_FRAME_ICONIFIED (f
, 1);
9951 SET_FRAME_VISIBLE (f
, 0);
9954 XFlush (FRAME_X_DISPLAY (f
));
9956 #else /* not USE_X_TOOLKIT */
9958 /* Make sure the X server knows where the window should be positioned,
9959 in case the user deiconifies with the window manager. */
9960 if (! FRAME_VISIBLE_P (f
)
9961 && ! FRAME_ICONIFIED_P (f
)
9962 && ! FRAME_X_EMBEDDED_P (f
))
9963 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
9965 /* Since we don't know which revision of X we're running, we'll use both
9966 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
9968 /* X11R4: send a ClientMessage to the window manager using the
9969 WM_CHANGE_STATE type. */
9973 msg
.xclient
.window
= FRAME_X_WINDOW (f
);
9974 msg
.xclient
.type
= ClientMessage
;
9975 msg
.xclient
.message_type
= FRAME_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
9976 msg
.xclient
.format
= 32;
9977 msg
.xclient
.data
.l
[0] = IconicState
;
9979 if (! XSendEvent (FRAME_X_DISPLAY (f
),
9980 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
9982 SubstructureRedirectMask
| SubstructureNotifyMask
,
9986 error ("Can't notify window manager of iconification");
9990 /* X11R3: set the initial_state field of the window manager hints to
9992 x_wm_set_window_state (f
, IconicState
);
9994 if (!FRAME_VISIBLE_P (f
))
9996 /* If the frame was withdrawn, before, we must map it. */
9997 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10000 SET_FRAME_ICONIFIED (f
, 1);
10001 SET_FRAME_VISIBLE (f
, 0);
10003 XFlush (FRAME_X_DISPLAY (f
));
10005 #endif /* not USE_X_TOOLKIT */
10009 /* Free X resources of frame F. */
10012 x_free_frame_resources (struct frame
*f
)
10014 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10015 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
10016 #ifdef USE_X_TOOLKIT
10018 struct scroll_bar
*b
;
10023 /* If a display connection is dead, don't try sending more
10024 commands to the X server. */
10025 if (dpyinfo
->display
)
10027 /* Always exit with visible pointer to avoid weird issue
10028 with Xfixes (Bug#17609). */
10029 if (f
->pointer_invisible
)
10030 FRAME_DISPLAY_INFO (f
)->toggle_visible_pointer (f
, 0);
10032 /* We must free faces before destroying windows because some
10033 font-driver (e.g. xft) access a window while finishing a
10035 free_frame_faces (f
);
10037 if (f
->output_data
.x
->icon_desc
)
10038 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
10040 #ifdef USE_X_TOOLKIT
10041 /* Explicitly destroy the scroll bars of the frame. Without
10042 this, we get "BadDrawable" errors from the toolkit later on,
10043 presumably from expose events generated for the disappearing
10044 toolkit scroll bars. */
10045 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
10047 b
= XSCROLL_BAR (bar
);
10048 x_scroll_bar_remove (b
);
10054 free_frame_xic (f
);
10057 #ifdef USE_X_TOOLKIT
10058 if (f
->output_data
.x
->widget
)
10060 XtDestroyWidget (f
->output_data
.x
->widget
);
10061 f
->output_data
.x
->widget
= NULL
;
10063 /* Tooltips don't have widgets, only a simple X window, even if
10064 we are using a toolkit. */
10065 else if (FRAME_X_WINDOW (f
))
10066 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10068 free_frame_menubar (f
);
10070 if (f
->shell_position
)
10071 xfree (f
->shell_position
);
10072 #else /* !USE_X_TOOLKIT */
10075 xg_free_frame_widgets (f
);
10076 #endif /* USE_GTK */
10078 if (FRAME_X_WINDOW (f
))
10079 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10080 #endif /* !USE_X_TOOLKIT */
10082 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
10083 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
10084 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
10085 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
10086 unload_color (f
, f
->output_data
.x
->border_pixel
);
10087 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
10089 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
10090 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
10091 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
10092 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
10093 #if defined (USE_LUCID) && defined (USE_TOOLKIT_SCROLL_BARS)
10094 /* Scrollbar shadow colors. */
10095 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
10096 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
10097 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
10098 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
10099 #endif /* USE_LUCID && USE_TOOLKIT_SCROLL_BARS */
10100 if (f
->output_data
.x
->white_relief
.pixel
!= -1)
10101 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
10102 if (f
->output_data
.x
->black_relief
.pixel
!= -1)
10103 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
10107 /* Free extra GCs allocated by x_setup_relief_colors. */
10108 if (f
->output_data
.x
->white_relief
.gc
)
10110 XFreeGC (dpyinfo
->display
, f
->output_data
.x
->white_relief
.gc
);
10111 f
->output_data
.x
->white_relief
.gc
= 0;
10113 if (f
->output_data
.x
->black_relief
.gc
)
10115 XFreeGC (dpyinfo
->display
, f
->output_data
.x
->black_relief
.gc
);
10116 f
->output_data
.x
->black_relief
.gc
= 0;
10119 /* Free cursors. */
10120 if (f
->output_data
.x
->text_cursor
!= 0)
10121 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->text_cursor
);
10122 if (f
->output_data
.x
->nontext_cursor
!= 0)
10123 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->nontext_cursor
);
10124 if (f
->output_data
.x
->modeline_cursor
!= 0)
10125 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->modeline_cursor
);
10126 if (f
->output_data
.x
->hand_cursor
!= 0)
10127 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->hand_cursor
);
10128 if (f
->output_data
.x
->hourglass_cursor
!= 0)
10129 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->hourglass_cursor
);
10130 if (f
->output_data
.x
->horizontal_drag_cursor
!= 0)
10131 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->horizontal_drag_cursor
);
10132 if (f
->output_data
.x
->vertical_drag_cursor
!= 0)
10133 XFreeCursor (FRAME_X_DISPLAY (f
), f
->output_data
.x
->vertical_drag_cursor
);
10135 XFlush (FRAME_X_DISPLAY (f
));
10138 xfree (f
->output_data
.x
->saved_menu_event
);
10139 xfree (f
->output_data
.x
);
10140 f
->output_data
.x
= NULL
;
10142 if (f
== dpyinfo
->x_focus_frame
)
10143 dpyinfo
->x_focus_frame
= 0;
10144 if (f
== dpyinfo
->x_focus_event_frame
)
10145 dpyinfo
->x_focus_event_frame
= 0;
10146 if (f
== dpyinfo
->x_highlight_frame
)
10147 dpyinfo
->x_highlight_frame
= 0;
10148 if (f
== hlinfo
->mouse_face_mouse_frame
)
10149 reset_mouse_highlight (hlinfo
);
10155 /* Destroy the X window of frame F. */
10158 x_destroy_window (struct frame
*f
)
10160 struct x_display_info
*dpyinfo
= FRAME_DISPLAY_INFO (f
);
10162 /* If a display connection is dead, don't try sending more
10163 commands to the X server. */
10164 if (dpyinfo
->display
!= 0)
10165 x_free_frame_resources (f
);
10167 dpyinfo
->reference_count
--;
10171 /* Setting window manager hints. */
10173 /* Set the normal size hints for the window manager, for frame F.
10174 FLAGS is the flags word to use--or 0 meaning preserve the flags
10175 that the window now has.
10176 If USER_POSITION, set the USPosition
10177 flag (this is useful when FLAGS is 0).
10178 The GTK version is in gtkutils.c. */
10182 x_wm_set_size_hint (struct frame
*f
, long flags
, bool user_position
)
10184 XSizeHints size_hints
;
10185 Window window
= FRAME_OUTER_WINDOW (f
);
10190 #ifdef USE_X_TOOLKIT
10191 if (f
->output_data
.x
->widget
)
10193 widget_update_wm_size_hints (f
->output_data
.x
->widget
);
10198 /* Setting PMaxSize caused various problems. */
10199 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
10201 size_hints
.x
= f
->left_pos
;
10202 size_hints
.y
= f
->top_pos
;
10204 size_hints
.height
= FRAME_PIXEL_HEIGHT (f
);
10205 size_hints
.width
= FRAME_PIXEL_WIDTH (f
);
10207 size_hints
.width_inc
= frame_resize_pixelwise
? 1 : FRAME_COLUMN_WIDTH (f
);
10208 size_hints
.height_inc
= frame_resize_pixelwise
? 1 : FRAME_LINE_HEIGHT (f
);
10210 size_hints
.max_width
= x_display_pixel_width (FRAME_DISPLAY_INFO (f
))
10211 - FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
10212 size_hints
.max_height
= x_display_pixel_height (FRAME_DISPLAY_INFO (f
))
10213 - FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
10215 /* Calculate the base and minimum sizes. */
10217 int base_width
, base_height
;
10218 int min_rows
= 0, min_cols
= 0;
10220 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
10221 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
10223 if (frame_resize_pixelwise
)
10224 /* Needed to prevent a bad protocol error crash when making the
10225 frame size very small. */
10227 min_cols
= 2 * min_cols
;
10228 min_rows
= 2 * min_rows
;
10231 /* The window manager uses the base width hints to calculate the
10232 current number of rows and columns in the frame while
10233 resizing; min_width and min_height aren't useful for this
10234 purpose, since they might not give the dimensions for a
10235 zero-row, zero-column frame.
10237 We use the base_width and base_height members if we have
10238 them; otherwise, we set the min_width and min_height members
10239 to the size for a zero x zero frame. */
10241 size_hints
.flags
|= PBaseSize
;
10242 size_hints
.base_width
= base_width
;
10243 size_hints
.base_height
= base_height
+ FRAME_MENUBAR_HEIGHT (f
);
10244 size_hints
.min_width
= base_width
+ min_cols
* FRAME_COLUMN_WIDTH (f
);
10245 size_hints
.min_height
= base_height
+ min_rows
* FRAME_LINE_HEIGHT (f
);
10248 /* If we don't need the old flags, we don't need the old hint at all. */
10251 size_hints
.flags
|= flags
;
10256 XSizeHints hints
; /* Sometimes I hate X Windows... */
10257 long supplied_return
;
10260 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
10264 size_hints
.flags
|= flags
;
10269 if (hints
.flags
& PSize
)
10270 size_hints
.flags
|= PSize
;
10271 if (hints
.flags
& PPosition
)
10272 size_hints
.flags
|= PPosition
;
10273 if (hints
.flags
& USPosition
)
10274 size_hints
.flags
|= USPosition
;
10275 if (hints
.flags
& USSize
)
10276 size_hints
.flags
|= USSize
;
10283 size_hints
.win_gravity
= f
->win_gravity
;
10284 size_hints
.flags
|= PWinGravity
;
10288 size_hints
.flags
&= ~ PPosition
;
10289 size_hints
.flags
|= USPosition
;
10291 #endif /* PWinGravity */
10293 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
10295 #endif /* not USE_GTK */
10297 /* Used for IconicState or NormalState */
10300 x_wm_set_window_state (struct frame
*f
, int state
)
10302 #ifdef USE_X_TOOLKIT
10305 XtSetArg (al
[0], XtNinitialState
, state
);
10306 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
10307 #else /* not USE_X_TOOLKIT */
10308 Window window
= FRAME_X_WINDOW (f
);
10310 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
10311 f
->output_data
.x
->wm_hints
.initial_state
= state
;
10313 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
10314 #endif /* not USE_X_TOOLKIT */
10318 x_wm_set_icon_pixmap (struct frame
*f
, ptrdiff_t pixmap_id
)
10320 Pixmap icon_pixmap
, icon_mask
;
10322 #if !defined USE_X_TOOLKIT && !defined USE_GTK
10323 Window window
= FRAME_OUTER_WINDOW (f
);
10328 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
10329 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
10330 icon_mask
= x_bitmap_mask (f
, pixmap_id
);
10331 f
->output_data
.x
->wm_hints
.icon_mask
= icon_mask
;
10335 /* It seems there is no way to turn off use of an icon
10343 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
);
10347 #elif defined (USE_X_TOOLKIT) /* same as in x_wm_set_window_state. */
10351 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
10352 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
10353 XtSetArg (al
[0], XtNiconMask
, icon_mask
);
10354 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
10357 #else /* not USE_X_TOOLKIT && not USE_GTK */
10359 f
->output_data
.x
->wm_hints
.flags
|= (IconPixmapHint
| IconMaskHint
);
10360 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
10362 #endif /* not USE_X_TOOLKIT && not USE_GTK */
10366 x_wm_set_icon_position (struct frame
*f
, int icon_x
, int icon_y
)
10368 Window window
= FRAME_OUTER_WINDOW (f
);
10370 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
10371 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
10372 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
10374 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
10378 /***********************************************************************
10380 ***********************************************************************/
10384 /* Check that FONT is valid on frame F. It is if it can be found in F's
10388 x_check_font (struct frame
*f
, struct font
*font
)
10390 eassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
10391 if (font
->driver
->check
)
10392 eassert (font
->driver
->check (f
, font
) == 0);
10395 #endif /* GLYPH_DEBUG */
10398 /***********************************************************************
10400 ***********************************************************************/
10402 #ifdef USE_X_TOOLKIT
10403 static XrmOptionDescRec emacs_options
[] = {
10404 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
10405 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
10407 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
10408 XrmoptionSepArg
, NULL
},
10409 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
10411 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10412 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10413 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10414 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
10415 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
10416 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
10417 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
10420 /* Whether atimer for Xt timeouts is activated or not. */
10422 static int x_timeout_atimer_activated_flag
;
10424 #endif /* USE_X_TOOLKIT */
10426 static int x_initialized
;
10428 /* Test whether two display-name strings agree up to the dot that separates
10429 the screen number from the server number. */
10431 same_x_server (const char *name1
, const char *name2
)
10433 int seen_colon
= 0;
10434 const char *system_name
= SSDATA (Vsystem_name
);
10435 ptrdiff_t system_name_length
= SBYTES (Vsystem_name
);
10436 ptrdiff_t length_until_period
= 0;
10438 while (system_name
[length_until_period
] != 0
10439 && system_name
[length_until_period
] != '.')
10440 length_until_period
++;
10442 /* Treat `unix' like an empty host name. */
10443 if (! strncmp (name1
, "unix:", 5))
10445 if (! strncmp (name2
, "unix:", 5))
10447 /* Treat this host's name like an empty host name. */
10448 if (! strncmp (name1
, system_name
, system_name_length
)
10449 && name1
[system_name_length
] == ':')
10450 name1
+= system_name_length
;
10451 if (! strncmp (name2
, system_name
, system_name_length
)
10452 && name2
[system_name_length
] == ':')
10453 name2
+= system_name_length
;
10454 /* Treat this host's domainless name like an empty host name. */
10455 if (! strncmp (name1
, system_name
, length_until_period
)
10456 && name1
[length_until_period
] == ':')
10457 name1
+= length_until_period
;
10458 if (! strncmp (name2
, system_name
, length_until_period
)
10459 && name2
[length_until_period
] == ':')
10460 name2
+= length_until_period
;
10462 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
10466 if (seen_colon
&& *name1
== '.')
10470 && (*name1
== '.' || *name1
== '\0')
10471 && (*name2
== '.' || *name2
== '\0'));
10474 /* Count number of set bits in mask and number of bits to shift to
10475 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
10478 get_bits_and_offset (unsigned long mask
, int *bits
, int *offset
)
10483 while (!(mask
& 1))
10499 /* Return 1 if display DISPLAY is available for use, 0 otherwise.
10500 But don't permanently open it, just test its availability. */
10503 x_display_ok (const char *display
)
10505 Display
*dpy
= XOpenDisplay (display
);
10506 return dpy
? (XCloseDisplay (dpy
), 1) : 0;
10511 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
,
10512 const gchar
*msg
, gpointer user_data
)
10514 if (!strstr (msg
, "g_set_prgname"))
10515 fprintf (stderr
, "%s-WARNING **: %s\n", log_domain
, msg
);
10519 /* Create invisible cursor on X display referred by DPYINFO. */
10522 make_invisible_cursor (struct x_display_info
*dpyinfo
)
10524 Display
*dpy
= dpyinfo
->display
;
10525 static char const no_data
[] = { 0 };
10530 x_catch_errors (dpy
);
10531 pix
= XCreateBitmapFromData (dpy
, dpyinfo
->root_window
, no_data
, 1, 1);
10532 if (! x_had_errors_p (dpy
) && pix
!= None
)
10536 col
.red
= col
.green
= col
.blue
= 0;
10537 col
.flags
= DoRed
| DoGreen
| DoBlue
;
10538 pixc
= XCreatePixmapCursor (dpy
, pix
, pix
, &col
, &col
, 0, 0);
10539 if (! x_had_errors_p (dpy
) && pixc
!= None
)
10541 XFreePixmap (dpy
, pix
);
10544 x_uncatch_errors ();
10549 /* True if DPY supports Xfixes extension >= 4. */
10552 x_probe_xfixes_extension (Display
*dpy
)
10556 return XFixesQueryVersion (dpy
, &major
, &minor
) && major
>= 4;
10559 #endif /* HAVE_XFIXES */
10562 /* Toggle mouse pointer visibility on frame F by using Xfixes functions. */
10565 xfixes_toggle_visible_pointer (struct frame
*f
, bool invisible
)
10569 XFixesHideCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10571 XFixesShowCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10572 f
->pointer_invisible
= invisible
;
10575 #endif /* HAVE_XFIXES */
10578 /* Toggle mouse pointer visibility on frame F by using invisible cursor. */
10581 x_toggle_visible_pointer (struct frame
*f
, bool invisible
)
10583 eassert (FRAME_DISPLAY_INFO (f
)->invisible_cursor
!= 0);
10585 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
10586 FRAME_DISPLAY_INFO (f
)->invisible_cursor
);
10588 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
10589 f
->output_data
.x
->current_cursor
);
10590 f
->pointer_invisible
= invisible
;
10593 /* Setup pointer blanking, prefer Xfixes if available. */
10596 x_setup_pointer_blanking (struct x_display_info
*dpyinfo
)
10598 /* FIXME: the brave tester should set EMACS_XFIXES because we're suspecting
10599 X server bug, see http://debbugs.gnu.org/cgi/bugreport.cgi?bug=17609. */
10600 if (egetenv ("EMACS_XFIXES") && x_probe_xfixes_extension (dpyinfo
->display
))
10601 dpyinfo
->toggle_visible_pointer
= xfixes_toggle_visible_pointer
;
10604 dpyinfo
->toggle_visible_pointer
= x_toggle_visible_pointer
;
10605 dpyinfo
->invisible_cursor
= make_invisible_cursor (dpyinfo
);
10609 /* Current X display connection identifier. Incremented for each next
10610 connection established. */
10611 static unsigned x_display_id
;
10613 /* Open a connection to X display DISPLAY_NAME, and return
10614 the structure that describes the open display.
10615 If we cannot contact the display, return null. */
10617 struct x_display_info
*
10618 x_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
10622 struct terminal
*terminal
;
10623 struct x_display_info
*dpyinfo
;
10629 if (!x_initialized
)
10635 if (! x_display_ok (SSDATA (display_name
)))
10636 error ("Display %s can't be opened", SSDATA (display_name
));
10640 #define NUM_ARGV 10
10642 char *argv
[NUM_ARGV
];
10643 char **argv2
= argv
;
10646 if (x_initialized
++ > 1)
10648 xg_display_open (SSDATA (display_name
), &dpy
);
10652 static char display_opt
[] = "--display";
10653 static char name_opt
[] = "--name";
10655 for (argc
= 0; argc
< NUM_ARGV
; ++argc
)
10659 argv
[argc
++] = initial_argv
[0];
10661 if (! NILP (display_name
))
10663 argv
[argc
++] = display_opt
;
10664 argv
[argc
++] = SSDATA (display_name
);
10667 argv
[argc
++] = name_opt
;
10668 argv
[argc
++] = resource_name
;
10670 XSetLocaleModifiers ("");
10672 /* Emacs can only handle core input events, so make sure
10673 Gtk doesn't use Xinput or Xinput2 extensions. */
10674 xputenv ("GDK_CORE_DEVICE_EVENTS=1");
10676 /* Work around GLib bug that outputs a faulty warning. See
10677 https://bugzilla.gnome.org/show_bug.cgi?id=563627. */
10678 id
= g_log_set_handler ("GLib", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
10679 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
10681 /* NULL window -> events for all windows go to our function.
10682 Call before gtk_init so Gtk+ event filters comes after our. */
10683 gdk_window_add_filter (NULL
, event_handler_gdk
, NULL
);
10685 /* gtk_init does set_locale. Fix locale before and after. */
10687 gtk_init (&argc
, &argv2
);
10690 g_log_remove_handler ("GLib", id
);
10694 dpy
= DEFAULT_GDK_DISPLAY ();
10696 #if ! GTK_CHECK_VERSION (2, 90, 0)
10697 /* Load our own gtkrc if it exists. */
10699 const char *file
= "~/.emacs.d/gtkrc";
10700 Lisp_Object s
, abs_file
;
10702 s
= build_string (file
);
10703 abs_file
= Fexpand_file_name (s
, Qnil
);
10705 if (! NILP (abs_file
) && !NILP (Ffile_readable_p (abs_file
)))
10706 gtk_rc_parse (SSDATA (abs_file
));
10710 XSetErrorHandler (x_error_handler
);
10711 XSetIOErrorHandler (x_io_error_quitter
);
10714 #else /* not USE_GTK */
10715 #ifdef USE_X_TOOLKIT
10716 /* weiner@footloose.sps.mot.com reports that this causes
10718 X protocol error: BadAtom (invalid Atom parameter)
10719 on protocol request 18skiloaf.
10720 So let's not use it until R6. */
10721 #ifdef HAVE_X11XTR6
10722 XtSetLanguageProc (NULL
, NULL
, NULL
);
10733 argv
[argc
++] = "-xrm";
10734 argv
[argc
++] = xrm_option
;
10736 turn_on_atimers (0);
10737 dpy
= XtOpenDisplay (Xt_app_con
, SSDATA (display_name
),
10738 resource_name
, EMACS_CLASS
,
10739 emacs_options
, XtNumber (emacs_options
),
10741 turn_on_atimers (1);
10743 #ifdef HAVE_X11XTR6
10744 /* I think this is to compensate for XtSetLanguageProc. */
10749 #else /* not USE_X_TOOLKIT */
10750 XSetLocaleModifiers ("");
10751 dpy
= XOpenDisplay (SSDATA (display_name
));
10752 #endif /* not USE_X_TOOLKIT */
10753 #endif /* not USE_GTK*/
10755 /* Detect failure. */
10762 /* We have definitely succeeded. Record the new connection. */
10764 dpyinfo
= xzalloc (sizeof *dpyinfo
);
10765 terminal
= x_create_terminal (dpyinfo
);
10768 struct x_display_info
*share
;
10770 for (share
= x_display_list
; share
; share
= share
->next
)
10771 if (same_x_server (SSDATA (XCAR (share
->name_list_element
)),
10772 SSDATA (display_name
)))
10775 terminal
->kboard
= share
->terminal
->kboard
;
10778 terminal
->kboard
= allocate_kboard (Qx
);
10780 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
10782 char *vendor
= ServerVendor (dpy
);
10784 /* Protect terminal from GC before removing it from the
10785 list of terminals. */
10786 struct gcpro gcpro1
;
10787 Lisp_Object gcpro_term
;
10788 XSETTERMINAL (gcpro_term
, terminal
);
10789 GCPRO1 (gcpro_term
);
10791 /* Temporarily hide the partially initialized terminal. */
10792 terminal_list
= terminal
->next_terminal
;
10794 kset_system_key_alist
10796 call1 (Qvendor_specific_keysyms
,
10797 vendor
? build_string (vendor
) : empty_unibyte_string
));
10799 terminal
->next_terminal
= terminal_list
;
10800 terminal_list
= terminal
;
10804 /* Don't let the initial kboard remain current longer than necessary.
10805 That would cause problems if a file loaded on startup tries to
10806 prompt in the mini-buffer. */
10807 if (current_kboard
== initial_kboard
)
10808 current_kboard
= terminal
->kboard
;
10810 terminal
->kboard
->reference_count
++;
10813 /* Put this display on the chain. */
10814 dpyinfo
->next
= x_display_list
;
10815 x_display_list
= dpyinfo
;
10817 dpyinfo
->name_list_element
= Fcons (display_name
, Qnil
);
10818 dpyinfo
->display
= dpy
;
10819 dpyinfo
->connection
= ConnectionNumber (dpyinfo
->display
);
10821 /* Set the name of the terminal. */
10822 terminal
->name
= xlispstrdup (display_name
);
10825 XSetAfterFunction (x_current_display
, x_trace_wire
);
10828 lim
= min (PTRDIFF_MAX
, SIZE_MAX
) - sizeof "@";
10829 if (lim
- SBYTES (Vinvocation_name
) < SBYTES (Vsystem_name
))
10830 memory_full (SIZE_MAX
);
10831 dpyinfo
->x_id
= ++x_display_id
;
10832 dpyinfo
->x_id_name
= xmalloc (SBYTES (Vinvocation_name
)
10833 + SBYTES (Vsystem_name
) + 2);
10834 strcat (strcat (strcpy (dpyinfo
->x_id_name
, SSDATA (Vinvocation_name
)), "@"),
10835 SSDATA (Vsystem_name
));
10837 /* Figure out which modifier bits mean what. */
10838 x_find_modifier_meanings (dpyinfo
);
10840 /* Get the scroll bar cursor. */
10842 /* We must create a GTK cursor, it is required for GTK widgets. */
10843 dpyinfo
->xg_cursor
= xg_create_default_cursor (dpyinfo
->display
);
10844 #endif /* USE_GTK */
10846 dpyinfo
->vertical_scroll_bar_cursor
10847 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
10849 dpyinfo
->horizontal_scroll_bar_cursor
10850 = XCreateFontCursor (dpyinfo
->display
, XC_sb_h_double_arrow
);
10852 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
10853 resource_name
, EMACS_CLASS
);
10854 #ifdef HAVE_XRMSETDATABASE
10855 XrmSetDatabase (dpyinfo
->display
, xrdb
);
10857 dpyinfo
->display
->db
= xrdb
;
10859 /* Put the rdb where we can find it in a way that works on
10861 dpyinfo
->xrdb
= xrdb
;
10863 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
10864 DefaultScreen (dpyinfo
->display
));
10865 select_visual (dpyinfo
);
10866 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
10867 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
10868 dpyinfo
->icon_bitmap_id
= -1;
10869 dpyinfo
->wm_type
= X_WMTYPE_UNKNOWN
;
10871 reset_mouse_highlight (&dpyinfo
->mouse_highlight
);
10873 /* See if we can construct pixel values from RGB values. */
10874 if (dpyinfo
->visual
->class == TrueColor
)
10876 get_bits_and_offset (dpyinfo
->visual
->red_mask
,
10877 &dpyinfo
->red_bits
, &dpyinfo
->red_offset
);
10878 get_bits_and_offset (dpyinfo
->visual
->blue_mask
,
10879 &dpyinfo
->blue_bits
, &dpyinfo
->blue_offset
);
10880 get_bits_and_offset (dpyinfo
->visual
->green_mask
,
10881 &dpyinfo
->green_bits
, &dpyinfo
->green_offset
);
10884 /* See if a private colormap is requested. */
10885 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
10887 if (dpyinfo
->visual
->class == PseudoColor
)
10890 value
= display_x_get_resource (dpyinfo
,
10891 build_string ("privateColormap"),
10892 build_string ("PrivateColormap"),
10894 if (STRINGP (value
)
10895 && (!strcmp (SSDATA (value
), "true")
10896 || !strcmp (SSDATA (value
), "on")))
10897 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
10901 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
10902 dpyinfo
->visual
, AllocNone
);
10906 /* If we are using Xft, the following precautions should be made:
10908 1. Make sure that the Xrender extension is added before the Xft one.
10909 Otherwise, the close-display hook set by Xft is called after the one
10910 for Xrender, and the former tries to re-add the latter. This results
10911 in inconsistency of internal states and leads to X protocol error when
10912 one reconnects to the same X server (Bug#1696).
10914 2. Check dpi value in X resources. It is better we use it as well,
10915 since Xft will use it, as will all Gnome applications. If our real DPI
10916 is smaller or larger than the one Xft uses, our font will look smaller
10917 or larger than other for other applications, even if it is the same
10918 font name (monospace-10 for example). */
10920 int event_base
, error_base
;
10924 XRenderQueryExtension (dpyinfo
->display
, &event_base
, &error_base
);
10926 v
= XGetDefault (dpyinfo
->display
, "Xft", "dpi");
10927 if (v
!= NULL
&& sscanf (v
, "%lf", &d
) == 1)
10928 dpyinfo
->resy
= dpyinfo
->resx
= d
;
10932 if (dpyinfo
->resy
< 1)
10934 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
10935 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
10936 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
10937 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10938 dpyinfo
->resy
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10939 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
10940 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
10941 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10942 dpyinfo
->resx
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10946 static const struct
10951 #define ATOM_REFS_INIT(string, member) \
10952 { string, offsetof (struct x_display_info, member) },
10953 ATOM_REFS_INIT ("WM_PROTOCOLS", Xatom_wm_protocols
)
10954 ATOM_REFS_INIT ("WM_TAKE_FOCUS", Xatom_wm_take_focus
)
10955 ATOM_REFS_INIT ("WM_SAVE_YOURSELF", Xatom_wm_save_yourself
)
10956 ATOM_REFS_INIT ("WM_DELETE_WINDOW", Xatom_wm_delete_window
)
10957 ATOM_REFS_INIT ("WM_CHANGE_STATE", Xatom_wm_change_state
)
10958 ATOM_REFS_INIT ("WM_CONFIGURE_DENIED", Xatom_wm_configure_denied
)
10959 ATOM_REFS_INIT ("WM_MOVED", Xatom_wm_window_moved
)
10960 ATOM_REFS_INIT ("WM_CLIENT_LEADER", Xatom_wm_client_leader
)
10961 ATOM_REFS_INIT ("Editres", Xatom_editres
)
10962 ATOM_REFS_INIT ("CLIPBOARD", Xatom_CLIPBOARD
)
10963 ATOM_REFS_INIT ("TIMESTAMP", Xatom_TIMESTAMP
)
10964 ATOM_REFS_INIT ("TEXT", Xatom_TEXT
)
10965 ATOM_REFS_INIT ("COMPOUND_TEXT", Xatom_COMPOUND_TEXT
)
10966 ATOM_REFS_INIT ("UTF8_STRING", Xatom_UTF8_STRING
)
10967 ATOM_REFS_INIT ("DELETE", Xatom_DELETE
)
10968 ATOM_REFS_INIT ("MULTIPLE", Xatom_MULTIPLE
)
10969 ATOM_REFS_INIT ("INCR", Xatom_INCR
)
10970 ATOM_REFS_INIT ("_EMACS_TMP_", Xatom_EMACS_TMP
)
10971 ATOM_REFS_INIT ("TARGETS", Xatom_TARGETS
)
10972 ATOM_REFS_INIT ("NULL", Xatom_NULL
)
10973 ATOM_REFS_INIT ("ATOM", Xatom_ATOM
)
10974 ATOM_REFS_INIT ("ATOM_PAIR", Xatom_ATOM_PAIR
)
10975 ATOM_REFS_INIT ("CLIPBOARD_MANAGER", Xatom_CLIPBOARD_MANAGER
)
10976 ATOM_REFS_INIT ("_XEMBED_INFO", Xatom_XEMBED_INFO
)
10977 /* For properties of font. */
10978 ATOM_REFS_INIT ("PIXEL_SIZE", Xatom_PIXEL_SIZE
)
10979 ATOM_REFS_INIT ("AVERAGE_WIDTH", Xatom_AVERAGE_WIDTH
)
10980 ATOM_REFS_INIT ("_MULE_BASELINE_OFFSET", Xatom_MULE_BASELINE_OFFSET
)
10981 ATOM_REFS_INIT ("_MULE_RELATIVE_COMPOSE", Xatom_MULE_RELATIVE_COMPOSE
)
10982 ATOM_REFS_INIT ("_MULE_DEFAULT_ASCENT", Xatom_MULE_DEFAULT_ASCENT
)
10983 /* Ghostscript support. */
10984 ATOM_REFS_INIT ("DONE", Xatom_DONE
)
10985 ATOM_REFS_INIT ("PAGE", Xatom_PAGE
)
10986 ATOM_REFS_INIT ("SCROLLBAR", Xatom_Scrollbar
)
10987 ATOM_REFS_INIT ("HORIZONTAL_SCROLLBAR", Xatom_Horizontal_Scrollbar
)
10988 ATOM_REFS_INIT ("_XEMBED", Xatom_XEMBED
)
10990 ATOM_REFS_INIT ("_NET_WM_STATE", Xatom_net_wm_state
)
10991 ATOM_REFS_INIT ("_NET_WM_STATE_FULLSCREEN", Xatom_net_wm_state_fullscreen
)
10992 ATOM_REFS_INIT ("_NET_WM_STATE_MAXIMIZED_HORZ",
10993 Xatom_net_wm_state_maximized_horz
)
10994 ATOM_REFS_INIT ("_NET_WM_STATE_MAXIMIZED_VERT",
10995 Xatom_net_wm_state_maximized_vert
)
10996 ATOM_REFS_INIT ("_NET_WM_STATE_STICKY", Xatom_net_wm_state_sticky
)
10997 ATOM_REFS_INIT ("_NET_WM_STATE_HIDDEN", Xatom_net_wm_state_hidden
)
10998 ATOM_REFS_INIT ("_NET_WM_WINDOW_TYPE", Xatom_net_window_type
)
10999 ATOM_REFS_INIT ("_NET_WM_WINDOW_TYPE_TOOLTIP",
11000 Xatom_net_window_type_tooltip
)
11001 ATOM_REFS_INIT ("_NET_WM_ICON_NAME", Xatom_net_wm_icon_name
)
11002 ATOM_REFS_INIT ("_NET_WM_NAME", Xatom_net_wm_name
)
11003 ATOM_REFS_INIT ("_NET_SUPPORTED", Xatom_net_supported
)
11004 ATOM_REFS_INIT ("_NET_SUPPORTING_WM_CHECK", Xatom_net_supporting_wm_check
)
11005 ATOM_REFS_INIT ("_NET_WM_WINDOW_OPACITY", Xatom_net_wm_window_opacity
)
11006 ATOM_REFS_INIT ("_NET_ACTIVE_WINDOW", Xatom_net_active_window
)
11007 ATOM_REFS_INIT ("_NET_FRAME_EXTENTS", Xatom_net_frame_extents
)
11008 ATOM_REFS_INIT ("_NET_CURRENT_DESKTOP", Xatom_net_current_desktop
)
11009 ATOM_REFS_INIT ("_NET_WORKAREA", Xatom_net_workarea
)
11010 /* Session management */
11011 ATOM_REFS_INIT ("SM_CLIENT_ID", Xatom_SM_CLIENT_ID
)
11012 ATOM_REFS_INIT ("_XSETTINGS_SETTINGS", Xatom_xsettings_prop
)
11013 ATOM_REFS_INIT ("MANAGER", Xatom_xsettings_mgr
)
11017 const int atom_count
= ARRAYELTS (atom_refs
);
11018 /* 1 for _XSETTINGS_SN */
11019 const int total_atom_count
= 1 + atom_count
;
11020 Atom
*atoms_return
= xmalloc (total_atom_count
* sizeof *atoms_return
);
11021 char **atom_names
= xmalloc (total_atom_count
* sizeof *atom_names
);
11022 static char const xsettings_fmt
[] = "_XSETTINGS_S%d";
11023 char xsettings_atom_name
[sizeof xsettings_fmt
- 2
11024 + INT_STRLEN_BOUND (int)];
11026 for (i
= 0; i
< atom_count
; i
++)
11027 atom_names
[i
] = (char *) atom_refs
[i
].name
;
11029 /* Build _XSETTINGS_SN atom name */
11030 sprintf (xsettings_atom_name
, xsettings_fmt
,
11031 XScreenNumberOfScreen (dpyinfo
->screen
));
11032 atom_names
[i
] = xsettings_atom_name
;
11034 XInternAtoms (dpyinfo
->display
, atom_names
, total_atom_count
,
11035 False
, atoms_return
);
11037 for (i
= 0; i
< atom_count
; i
++)
11038 *(Atom
*) ((char *) dpyinfo
+ atom_refs
[i
].offset
) = atoms_return
[i
];
11040 /* Manual copy of last atom */
11041 dpyinfo
->Xatom_xsettings_sel
= atoms_return
[i
];
11043 xfree (atom_names
);
11044 xfree (atoms_return
);
11047 dpyinfo
->x_dnd_atoms_size
= 8;
11048 dpyinfo
->x_dnd_atoms
= xmalloc (sizeof *dpyinfo
->x_dnd_atoms
11049 * dpyinfo
->x_dnd_atoms_size
);
11051 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
11052 gray_bits
, gray_width
, gray_height
,
11055 x_setup_pointer_blanking (dpyinfo
);
11058 xim_initialize (dpyinfo
, resource_name
);
11061 xsettings_initialize (dpyinfo
);
11063 connection
= ConnectionNumber (dpyinfo
->display
);
11065 /* This is only needed for distinguishing keyboard and process input. */
11066 if (connection
!= 0)
11067 add_keyboard_wait_descriptor (connection
);
11070 fcntl (connection
, F_SETOWN
, getpid ());
11071 #endif /* ! defined (F_SETOWN) */
11073 if (interrupt_input
)
11074 init_sigio (connection
);
11078 XFontStruct
*xfont
= NULL
;
11079 XrmValue d
, fr
, to
;
11082 dpy
= dpyinfo
->display
;
11083 d
.addr
= (XPointer
)&dpy
;
11084 d
.size
= sizeof (Display
*);
11085 fr
.addr
= XtDefaultFont
;
11086 fr
.size
= sizeof (XtDefaultFont
);
11087 to
.size
= sizeof (Font
*);
11088 to
.addr
= (XPointer
)&font
;
11089 x_catch_errors (dpy
);
11090 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
11092 if (x_had_errors_p (dpy
) || !((xfont
= XQueryFont (dpy
, font
))))
11093 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
11095 XFreeFont (dpy
, xfont
);
11096 x_uncatch_errors ();
11100 /* See if we should run in synchronous mode. This is useful
11101 for debugging X code. */
11104 value
= display_x_get_resource (dpyinfo
,
11105 build_string ("synchronous"),
11106 build_string ("Synchronous"),
11108 if (STRINGP (value
)
11109 && (!strcmp (SSDATA (value
), "true")
11110 || !strcmp (SSDATA (value
), "on")))
11111 XSynchronize (dpyinfo
->display
, True
);
11116 value
= display_x_get_resource (dpyinfo
,
11117 build_string ("useXIM"),
11118 build_string ("UseXIM"),
11121 if (STRINGP (value
)
11122 && (!strcmp (SSDATA (value
), "false")
11123 || !strcmp (SSDATA (value
), "off")))
11126 if (STRINGP (value
)
11127 && (!strcmp (SSDATA (value
), "true")
11128 || !strcmp (SSDATA (value
), "on")))
11134 /* Only do this for the very first display in the Emacs session.
11135 Ignore X session management when Emacs was first started on a
11137 if (terminal
->id
== 1)
11138 x_session_initialize (dpyinfo
);
11146 /* Get rid of display DPYINFO, deleting all frames on it,
11147 and without sending any more commands to the X server. */
11150 x_delete_display (struct x_display_info
*dpyinfo
)
11152 struct terminal
*t
;
11154 /* Close all frames and delete the generic struct terminal for this
11156 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
11157 if (t
->type
== output_x_window
&& t
->display_info
.x
== dpyinfo
)
11160 /* Close X session management when we close its display. */
11161 if (t
->id
== 1 && x_session_have_connection ())
11162 x_session_close ();
11164 delete_terminal (t
);
11168 if (next_noop_dpyinfo
== dpyinfo
)
11169 next_noop_dpyinfo
= dpyinfo
->next
;
11171 if (x_display_list
== dpyinfo
)
11172 x_display_list
= dpyinfo
->next
;
11175 struct x_display_info
*tail
;
11177 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
11178 if (tail
->next
== dpyinfo
)
11179 tail
->next
= tail
->next
->next
;
11182 xfree (dpyinfo
->x_id_name
);
11183 xfree (dpyinfo
->x_dnd_atoms
);
11184 xfree (dpyinfo
->color_cells
);
11188 #ifdef USE_X_TOOLKIT
11190 /* Atimer callback function for TIMER. Called every 0.1s to process
11191 Xt timeouts, if needed. We must avoid calling XtAppPending as
11192 much as possible because that function does an implicit XFlush
11193 that slows us down. */
11196 x_process_timeouts (struct atimer
*timer
)
11199 x_timeout_atimer_activated_flag
= 0;
11200 if (toolkit_scroll_bar_interaction
|| popup_activated ())
11202 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
11203 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
11204 /* Reactivate the atimer for next time. */
11205 x_activate_timeout_atimer ();
11210 /* Install an asynchronous timer that processes Xt timeout events
11211 every 0.1s as long as either `toolkit_scroll_bar_interaction' or
11212 `popup_activated_flag' (in xmenu.c) is set. Make sure to call this
11213 function whenever these variables are set. This is necessary
11214 because some widget sets use timeouts internally, for example the
11215 LessTif menu bar, or the Xaw3d scroll bar. When Xt timeouts aren't
11216 processed, these widgets don't behave normally. */
11219 x_activate_timeout_atimer (void)
11222 if (!x_timeout_atimer_activated_flag
)
11224 struct timespec interval
= make_timespec (0, 100 * 1000 * 1000);
11225 start_atimer (ATIMER_RELATIVE
, interval
, x_process_timeouts
, 0);
11226 x_timeout_atimer_activated_flag
= 1;
11231 #endif /* USE_X_TOOLKIT */
11234 /* Set up use of X before we make the first connection. */
11236 static struct redisplay_interface x_redisplay_interface
=
11238 x_frame_parm_handlers
,
11242 x_clear_end_of_line
,
11244 x_after_update_window_line
,
11245 x_update_window_begin
,
11246 x_update_window_end
,
11248 x_clear_window_mouse_face
,
11249 x_get_glyph_overhangs
,
11250 x_fix_overlapping_area
,
11251 x_draw_fringe_bitmap
,
11252 0, /* define_fringe_bitmap */
11253 0, /* destroy_fringe_bitmap */
11254 x_compute_glyph_string_overhangs
,
11255 x_draw_glyph_string
,
11256 x_define_frame_cursor
,
11257 x_clear_frame_area
,
11258 x_draw_window_cursor
,
11259 x_draw_vertical_window_border
,
11260 x_draw_window_divider
,
11261 x_shift_glyphs_for_insert
,
11267 /* This function is called when the last frame on a display is deleted. */
11269 x_delete_terminal (struct terminal
*terminal
)
11271 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
11273 /* Protect against recursive calls. delete_frame in
11274 delete_terminal calls us back when it deletes our last frame. */
11275 if (!terminal
->name
)
11280 /* We must close our connection to the XIM server before closing the
11283 xim_close_dpy (dpyinfo
);
11286 /* If called from x_connection_closed, the display may already be closed
11287 and dpyinfo->display was set to 0 to indicate that. */
11288 if (dpyinfo
->display
)
11290 x_destroy_all_bitmaps (dpyinfo
);
11291 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
11293 /* Whether or not XCloseDisplay destroys the associated resource
11294 database depends on the version of libX11. To avoid both
11295 crash and memory leak, we dissociate the database from the
11296 display and then destroy dpyinfo->xrdb ourselves.
11298 Unfortunately, the above strategy does not work in some
11299 situations due to a bug in newer versions of libX11: because
11300 XrmSetDatabase doesn't clear the flag XlibDisplayDfltRMDB if
11301 dpy->db is NULL, XCloseDisplay destroys the associated
11302 database whereas it has not been created by XGetDefault
11303 (Bug#21974 in freedesktop.org Bugzilla). As a workaround, we
11304 don't destroy the database here in order to avoid the crash
11305 in the above situations for now, though that may cause memory
11306 leaks in other situations. */
11308 #ifdef HAVE_XRMSETDATABASE
11309 XrmSetDatabase (dpyinfo
->display
, NULL
);
11311 dpyinfo
->display
->db
= NULL
;
11313 /* We used to call XrmDestroyDatabase from x_delete_display, but
11314 some older versions of libX11 crash if we call it after
11315 closing all the displays. */
11316 XrmDestroyDatabase (dpyinfo
->xrdb
);
11320 xg_display_close (dpyinfo
->display
);
11322 #ifdef USE_X_TOOLKIT
11323 XtCloseDisplay (dpyinfo
->display
);
11325 XCloseDisplay (dpyinfo
->display
);
11327 #endif /* ! USE_GTK */
11330 /* No more input on this descriptor. */
11331 if (0 <= dpyinfo
->connection
)
11333 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
11334 emacs_close (dpyinfo
->connection
);
11337 /* Mark as dead. */
11338 dpyinfo
->display
= NULL
;
11339 dpyinfo
->connection
= -1;
11340 x_delete_display (dpyinfo
);
11344 /* Create a struct terminal, initialize it with the X11 specific
11345 functions and make DISPLAY->TERMINAL point to it. */
11347 static struct terminal
*
11348 x_create_terminal (struct x_display_info
*dpyinfo
)
11350 struct terminal
*terminal
;
11352 terminal
= create_terminal (output_x_window
, &x_redisplay_interface
);
11354 terminal
->display_info
.x
= dpyinfo
;
11355 dpyinfo
->terminal
= terminal
;
11357 /* kboard is initialized in x_term_init. */
11359 terminal
->clear_frame_hook
= x_clear_frame
;
11360 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
11361 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
11362 terminal
->ring_bell_hook
= XTring_bell
;
11363 terminal
->toggle_invisible_pointer_hook
= XTtoggle_invisible_pointer
;
11364 terminal
->update_begin_hook
= x_update_begin
;
11365 terminal
->update_end_hook
= x_update_end
;
11366 terminal
->read_socket_hook
= XTread_socket
;
11367 terminal
->frame_up_to_date_hook
= XTframe_up_to_date
;
11368 terminal
->mouse_position_hook
= XTmouse_position
;
11369 terminal
->frame_rehighlight_hook
= XTframe_rehighlight
;
11370 terminal
->frame_raise_lower_hook
= XTframe_raise_lower
;
11371 terminal
->fullscreen_hook
= XTfullscreen_hook
;
11372 terminal
->menu_show_hook
= x_menu_show
;
11373 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
11374 terminal
->popup_dialog_hook
= xw_popup_dialog
;
11376 terminal
->set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
11377 terminal
->set_horizontal_scroll_bar_hook
= XTset_horizontal_scroll_bar
;
11378 terminal
->condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
11379 terminal
->redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
11380 terminal
->judge_scroll_bars_hook
= XTjudge_scroll_bars
;
11381 terminal
->delete_frame_hook
= x_destroy_window
;
11382 terminal
->delete_terminal_hook
= x_delete_terminal
;
11383 /* Other hooks are NULL by default. */
11389 x_initialize (void)
11394 any_help_event_p
= 0;
11395 ignore_next_mouse_click_timeout
= 0;
11398 current_count
= -1;
11401 /* Try to use interrupt input; if we can't, then start polling. */
11402 Fset_input_interrupt_mode (Qt
);
11404 #ifdef USE_X_TOOLKIT
11405 XtToolkitInitialize ();
11407 Xt_app_con
= XtCreateApplicationContext ();
11409 /* Register a converter from strings to pixels, which uses
11410 Emacs' color allocation infrastructure. */
11411 XtAppSetTypeConverter (Xt_app_con
,
11412 XtRString
, XtRPixel
, cvt_string_to_pixel
,
11413 cvt_string_to_pixel_args
,
11414 XtNumber (cvt_string_to_pixel_args
),
11415 XtCacheByDisplay
, cvt_pixel_dtor
);
11417 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
11420 #ifdef USE_TOOLKIT_SCROLL_BARS
11422 xaw3d_arrow_scroll
= False
;
11423 xaw3d_pick_top
= True
;
11427 /* Note that there is no real way portable across R3/R4 to get the
11428 original error handler. */
11429 XSetErrorHandler (x_error_handler
);
11430 XSetIOErrorHandler (x_io_error_quitter
);
11435 syms_of_xterm (void)
11437 x_error_message
= NULL
;
11439 DEFSYM (Qvendor_specific_keysyms
, "vendor-specific-keysyms");
11440 DEFSYM (Qlatin_1
, "latin-1");
11443 xg_default_icon_file
= build_pure_c_string ("icons/hicolor/scalable/apps/emacs.svg");
11444 staticpro (&xg_default_icon_file
);
11446 DEFSYM (Qx_gtk_map_stock
, "x-gtk-map-stock");
11449 DEFVAR_BOOL ("x-use-underline-position-properties",
11450 x_use_underline_position_properties
,
11451 doc
: /* Non-nil means make use of UNDERLINE_POSITION font properties.
11452 A value of nil means ignore them. If you encounter fonts with bogus
11453 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
11454 to 4.1, set this to nil. You can also use `underline-minimum-offset'
11455 to override the font's UNDERLINE_POSITION for small font display
11457 x_use_underline_position_properties
= 1;
11459 DEFVAR_BOOL ("x-underline-at-descent-line",
11460 x_underline_at_descent_line
,
11461 doc
: /* Non-nil means to draw the underline at the same place as the descent line.
11462 A value of nil means to draw the underline according to the value of the
11463 variable `x-use-underline-position-properties', which is usually at the
11464 baseline level. The default value is nil. */);
11465 x_underline_at_descent_line
= 0;
11467 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
11468 x_mouse_click_focus_ignore_position
,
11469 doc
: /* Non-nil means that a mouse click to focus a frame does not move point.
11470 This variable is only used when the window manager requires that you
11471 click on a frame to select it (give it focus). In that case, a value
11472 of nil, means that the selected window and cursor position changes to
11473 reflect the mouse click position, while a non-nil value means that the
11474 selected window or cursor position is preserved. */);
11475 x_mouse_click_focus_ignore_position
= 0;
11477 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars
,
11478 doc
: /* Which toolkit scroll bars Emacs uses, if any.
11479 A value of nil means Emacs doesn't use toolkit scroll bars.
11480 With the X Window system, the value is a symbol describing the
11481 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
11482 With MS Windows or Nextstep, the value is t. */);
11483 #ifdef USE_TOOLKIT_SCROLL_BARS
11485 Vx_toolkit_scroll_bars
= intern_c_string ("motif");
11486 #elif defined HAVE_XAW3D
11487 Vx_toolkit_scroll_bars
= intern_c_string ("xaw3d");
11489 Vx_toolkit_scroll_bars
= intern_c_string ("gtk");
11491 Vx_toolkit_scroll_bars
= intern_c_string ("xaw");
11494 Vx_toolkit_scroll_bars
= Qnil
;
11497 DEFSYM (Qmodifier_value
, "modifier-value");
11498 DEFSYM (Qalt
, "alt");
11499 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
11500 DEFSYM (Qhyper
, "hyper");
11501 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
11502 DEFSYM (Qmeta
, "meta");
11503 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
11504 DEFSYM (Qsuper
, "super");
11505 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
11507 DEFVAR_LISP ("x-alt-keysym", Vx_alt_keysym
,
11508 doc
: /* Which keys Emacs uses for the alt modifier.
11509 This should be one of the symbols `alt', `hyper', `meta', `super'.
11510 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
11511 is nil, which is the same as `alt'. */);
11512 Vx_alt_keysym
= Qnil
;
11514 DEFVAR_LISP ("x-hyper-keysym", Vx_hyper_keysym
,
11515 doc
: /* Which keys Emacs uses for the hyper modifier.
11516 This should be one of the symbols `alt', `hyper', `meta', `super'.
11517 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
11518 default is nil, which is the same as `hyper'. */);
11519 Vx_hyper_keysym
= Qnil
;
11521 DEFVAR_LISP ("x-meta-keysym", Vx_meta_keysym
,
11522 doc
: /* Which keys Emacs uses for the meta modifier.
11523 This should be one of the symbols `alt', `hyper', `meta', `super'.
11524 For example, `meta' means use the Meta_L and Meta_R keysyms. The
11525 default is nil, which is the same as `meta'. */);
11526 Vx_meta_keysym
= Qnil
;
11528 DEFVAR_LISP ("x-super-keysym", Vx_super_keysym
,
11529 doc
: /* Which keys Emacs uses for the super modifier.
11530 This should be one of the symbols `alt', `hyper', `meta', `super'.
11531 For example, `super' means use the Super_L and Super_R keysyms. The
11532 default is nil, which is the same as `super'. */);
11533 Vx_super_keysym
= Qnil
;
11535 DEFVAR_LISP ("x-keysym-table", Vx_keysym_table
,
11536 doc
: /* Hash table of character codes indexed by X keysym codes. */);
11537 Vx_keysym_table
= make_hash_table (hashtest_eql
, make_number (900),
11538 make_float (DEFAULT_REHASH_SIZE
),
11539 make_float (DEFAULT_REHASH_THRESHOLD
),