1 /* X Communication module for terminals which understand the X protocol.
3 Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
4 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
5 Free Software Foundation, Inc.
7 This file is part of GNU Emacs.
9 GNU Emacs is free software: you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation, either version 3 of the License, or
12 (at your option) any later version.
14 GNU Emacs is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
22 /* New display code by Gerd Moellmann <gerd@gnu.org>. */
23 /* Xt features made by Fred Pierresteguy. */
33 #include "blockinput.h"
35 /* Need syssignal.h for various externs and definitions that may be required
36 by some configurations for calls to signal later in this source file. */
37 #include "syssignal.h"
39 /* This may include sys/types.h, and that somehow loses
40 if this is not done before the other system files. */
42 #include <X11/cursorfont.h>
44 /* Load sys/types.h if not already loaded.
45 In some systems loading it twice is suicidal. */
47 #include <sys/types.h>
50 #ifdef HAVE_SYS_IOCTL_H
51 #include <sys/ioctl.h>
52 #endif /* ! defined (HAVE_SYS_IOCTL_H) */
61 /* Caused redefinition of DBL_DIG on Netbsd; seems not to be needed. */
62 /* #include <sys/param.h> */
65 #include "character.h"
68 #include "dispextern.h"
70 #include "termhooks.h"
73 #include "emacs-icon.h"
78 #include "intervals.h"
84 #include "xsettings.h"
86 #include "sysselect.h"
89 #include <X11/Shell.h>
92 #ifdef HAVE_SYS_TIME_H
104 #include "../lwlib/xlwmenu.h"
108 #if !defined(NO_EDITRES)
110 extern void _XEditResCheckMessages ();
111 #endif /* not NO_EDITRES */
113 /* Include toolkit specific headers for the scroll bar widget. */
115 #ifdef USE_TOOLKIT_SCROLL_BARS
116 #if defined USE_MOTIF
117 #include <Xm/Xm.h> /* for LESSTIF_VERSION */
118 #include <Xm/ScrollBar.h>
119 #else /* !USE_MOTIF i.e. use Xaw */
122 #include <X11/Xaw3d/Simple.h>
123 #include <X11/Xaw3d/Scrollbar.h>
124 #include <X11/Xaw3d/ThreeD.h>
125 #else /* !HAVE_XAW3D */
126 #include <X11/Xaw/Simple.h>
127 #include <X11/Xaw/Scrollbar.h>
128 #endif /* !HAVE_XAW3D */
130 #define XtNpickTop "pickTop"
131 #endif /* !XtNpickTop */
132 #endif /* !USE_MOTIF */
133 #endif /* USE_TOOLKIT_SCROLL_BARS */
135 #endif /* USE_X_TOOLKIT */
139 #ifndef XtNinitialState
140 #define XtNinitialState "initialState"
144 /* Default to using XIM if available. */
148 int use_xim
= 0; /* configure --without-xim */
153 /* Non-nil means Emacs uses toolkit scroll bars. */
155 Lisp_Object Vx_toolkit_scroll_bars
;
157 /* Non-zero means that a HELP_EVENT has been generated since Emacs
160 static int any_help_event_p
;
162 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
163 static Lisp_Object last_window
;
165 /* Non-zero means make use of UNDERLINE_POSITION font properties. */
167 int x_use_underline_position_properties
;
169 /* Non-zero means to draw the underline at the same place as the descent line. */
171 int x_underline_at_descent_line
;
173 /* This is a chain of structures for all the X displays currently in
176 struct x_display_info
*x_display_list
;
178 /* This is a list of cons cells, each of the form (NAME
179 . FONT-LIST-CACHE), one for each element of x_display_list and in
180 the same order. NAME is the name of the frame. FONT-LIST-CACHE
181 records previous values returned by x-list-fonts. */
183 Lisp_Object x_display_name_list
;
185 /* Frame being updated by update_frame. This is declared in term.c.
186 This is set by update_begin and looked at by all the XT functions.
187 It is zero while not inside an update. In that case, the XT
188 functions assume that `selected_frame' is the frame to apply to. */
190 extern struct frame
*updating_frame
;
192 /* This is a frame waiting to be auto-raised, within XTread_socket. */
194 static struct frame
*pending_autoraise_frame
;
196 /* This is a frame waiting for an event matching mask, within XTread_socket. */
201 } pending_event_wait
;
204 /* The application context for Xt use. */
205 XtAppContext Xt_app_con
;
206 static String Xt_default_resources
[] = {0};
207 #endif /* USE_X_TOOLKIT */
209 /* Non-zero means user is interacting with a toolkit scroll bar. */
211 static int toolkit_scroll_bar_interaction
;
213 /* Non-zero means to not move point as a result of clicking on a
214 frame to focus it (when focus-follows-mouse is nil). */
216 int x_mouse_click_focus_ignore_position
;
218 /* Non-zero timeout value means ignore next mouse click if it arrives
219 before that timeout elapses (i.e. as part of the same sequence of
220 events resulting from clicking on a frame to select it). */
222 static unsigned long ignore_next_mouse_click_timeout
;
226 Formerly, we used PointerMotionHintMask (in standard_event_mask)
227 so that we would have to call XQueryPointer after each MotionNotify
228 event to ask for another such event. However, this made mouse tracking
229 slow, and there was a bug that made it eventually stop.
231 Simply asking for MotionNotify all the time seems to work better.
233 In order to avoid asking for motion events and then throwing most
234 of them away or busy-polling the server for mouse positions, we ask
235 the server for pointer motion hints. This means that we get only
236 one event per group of mouse movements. "Groups" are delimited by
237 other kinds of events (focus changes and button clicks, for
238 example), or by XQueryPointer calls; when one of these happens, we
239 get another MotionNotify event the next time the mouse moves. This
240 is at least as efficient as getting motion events when mouse
241 tracking is on, and I suspect only negligibly worse when tracking
244 /* Where the mouse was last time we reported a mouse event. */
246 static XRectangle last_mouse_glyph
;
247 static FRAME_PTR last_mouse_glyph_frame
;
248 static Lisp_Object last_mouse_press_frame
;
250 /* The scroll bar in which the last X motion event occurred.
252 If the last X motion event occurred in a scroll bar, we set this so
253 XTmouse_position can know whether to report a scroll bar motion or
256 If the last X motion event didn't occur in a scroll bar, we set
257 this to Qnil, to tell XTmouse_position to return an ordinary motion
260 static Lisp_Object last_mouse_scroll_bar
;
262 /* This is a hack. We would really prefer that XTmouse_position would
263 return the time associated with the position it returns, but there
264 doesn't seem to be any way to wrest the time-stamp from the server
265 along with the position query. So, we just keep track of the time
266 of the last movement we received, and return that in hopes that
267 it's somewhat accurate. */
269 static Time last_mouse_movement_time
;
271 /* Time for last user interaction as returned in X events. */
273 static Time last_user_time
;
275 /* Incremented by XTread_socket whenever it really tries to read
279 static int volatile input_signal_count
;
281 static int input_signal_count
;
284 /* Used locally within XTread_socket. */
286 static int x_noop_count
;
288 /* The keysyms to use for the various modifiers. */
290 Lisp_Object Vx_alt_keysym
, Vx_hyper_keysym
, Vx_meta_keysym
, Vx_super_keysym
;
291 Lisp_Object Vx_keysym_table
;
292 static Lisp_Object Qalt
, Qhyper
, Qmeta
, Qsuper
, Qmodifier_value
;
294 static Lisp_Object Qvendor_specific_keysyms
;
295 static Lisp_Object Qlatin_1
;
298 /* The name of the Emacs icon file. */
299 static Lisp_Object xg_default_icon_file
;
301 /* Used in gtkutil.c. */
302 Lisp_Object Qx_gtk_map_stock
;
305 /* Some functions take this as char *, not const char *. */
306 static char emacs_class
[] = EMACS_CLASS
;
308 /* Used in x_flush. */
310 extern XrmDatabase
x_load_resources (Display
*, const char *, const char *,
312 extern int x_bitmap_mask (FRAME_PTR
, int);
314 static int x_alloc_nearest_color_1 (Display
*, Colormap
, XColor
*);
315 static void x_set_window_size_1 (struct frame
*, int, int, int);
316 static const XColor
*x_color_cells (Display
*, int *);
317 static void x_update_window_end (struct window
*, int, int);
319 static int x_io_error_quitter (Display
*);
320 static struct terminal
*x_create_terminal (struct x_display_info
*);
321 void x_delete_terminal (struct terminal
*);
322 static void x_update_end (struct frame
*);
323 static void XTframe_up_to_date (struct frame
*);
324 static void XTset_terminal_modes (struct terminal
*);
325 static void XTreset_terminal_modes (struct terminal
*);
326 static void x_clear_frame (struct frame
*);
327 static void frame_highlight (struct frame
*);
328 static void frame_unhighlight (struct frame
*);
329 static void x_new_focus_frame (struct x_display_info
*, struct frame
*);
330 static void x_focus_changed (int, int, struct x_display_info
*,
331 struct frame
*, struct input_event
*);
332 static void x_detect_focus_change (struct x_display_info
*,
333 XEvent
*, struct input_event
*);
334 static void XTframe_rehighlight (struct frame
*);
335 static void x_frame_rehighlight (struct x_display_info
*);
336 static void x_draw_hollow_cursor (struct window
*, struct glyph_row
*);
337 static void x_draw_bar_cursor (struct window
*, struct glyph_row
*, int,
338 enum text_cursor_kinds
);
340 static void x_clip_to_row (struct window
*, struct glyph_row
*, int, GC
);
341 static void x_flush (struct frame
*f
);
342 static void x_update_begin (struct frame
*);
343 static void x_update_window_begin (struct window
*);
344 static void x_after_update_window_line (struct glyph_row
*);
345 static struct scroll_bar
*x_window_to_scroll_bar (Display
*, Window
);
346 static void x_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
347 enum scroll_bar_part
*,
348 Lisp_Object
*, Lisp_Object
*,
350 static void x_handle_net_wm_state (struct frame
*, XPropertyEvent
*);
351 static void x_check_fullscreen (struct frame
*);
352 static void x_check_expected_move (struct frame
*, int, int);
353 static void x_sync_with_move (struct frame
*, int, int, int);
354 static int handle_one_xevent (struct x_display_info
*, XEvent
*,
355 int *, struct input_event
*);
356 /* Don't declare this NO_RETURN because we want no
357 interference with debugging failing X calls. */
358 static SIGTYPE
x_connection_closed (Display
*, const char *);
361 /* Flush display of frame F, or of all frames if F is null. */
364 x_flush (struct frame
*f
)
366 /* Don't call XFlush when it is not safe to redisplay; the X
367 connection may be broken. */
368 if (!NILP (Vinhibit_redisplay
))
374 Lisp_Object rest
, frame
;
375 FOR_EACH_FRAME (rest
, frame
)
376 if (FRAME_X_P (XFRAME (frame
)))
377 x_flush (XFRAME (frame
));
379 else if (FRAME_X_P (f
))
380 XFlush (FRAME_X_DISPLAY (f
));
385 /* Remove calls to XFlush by defining XFlush to an empty replacement.
386 Calls to XFlush should be unnecessary because the X output buffer
387 is flushed automatically as needed by calls to XPending,
388 XNextEvent, or XWindowEvent according to the XFlush man page.
389 XTread_socket calls XPending. Removing XFlush improves
392 #define XFlush(DISPLAY) (void) 0
395 /***********************************************************************
397 ***********************************************************************/
401 /* This is a function useful for recording debugging information about
402 the sequence of occurrences in this file. */
410 struct record event_record
[100];
412 int event_record_index
;
414 record_event (locus
, type
)
418 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
419 event_record_index
= 0;
421 event_record
[event_record_index
].locus
= locus
;
422 event_record
[event_record_index
].type
= type
;
423 event_record_index
++;
430 /* Return the struct x_display_info corresponding to DPY. */
432 struct x_display_info
*
433 x_display_info_for_display (Display
*dpy
)
435 struct x_display_info
*dpyinfo
;
437 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
438 if (dpyinfo
->display
== dpy
)
444 #define OPAQUE 0xffffffff
445 #define OPACITY "_NET_WM_WINDOW_OPACITY"
448 x_set_frame_alpha (struct frame
*f
)
450 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
451 Display
*dpy
= FRAME_X_DISPLAY (f
);
452 Window win
= FRAME_OUTER_WINDOW (f
);
454 double alpha_min
= 1.0;
457 if (FRAME_X_DISPLAY_INFO (f
)->root_window
!= FRAME_X_OUTPUT (f
)->parent_desc
)
458 /* Since the WM decoration lies under the FRAME_OUTER_WINDOW,
459 we must treat the former instead of the latter. */
460 win
= FRAME_X_OUTPUT (f
)->parent_desc
;
462 if (dpyinfo
->x_highlight_frame
== f
)
467 if (FLOATP (Vframe_alpha_lower_limit
))
468 alpha_min
= XFLOAT_DATA (Vframe_alpha_lower_limit
);
469 else if (INTEGERP (Vframe_alpha_lower_limit
))
470 alpha_min
= (XINT (Vframe_alpha_lower_limit
)) / 100.0;
474 else if (alpha
> 1.0)
476 else if (0.0 <= alpha
&& alpha
< alpha_min
&& alpha_min
<= 1.0)
479 opac
= alpha
* OPAQUE
;
481 /* return unless necessary */
486 unsigned long n
, left
;
488 x_catch_errors (dpy
);
489 rc
= XGetWindowProperty (dpy
, win
, XInternAtom(dpy
, OPACITY
, False
),
490 0L, 1L, False
, XA_CARDINAL
,
491 &actual
, &format
, &n
, &left
,
494 if (rc
== Success
&& actual
!= None
)
495 if (*(unsigned long *)data
== opac
)
497 XFree ((void *) data
);
502 XFree ((void *) data
);
506 x_catch_errors (dpy
);
507 XChangeProperty (dpy
, win
, XInternAtom (dpy
, OPACITY
, False
),
508 XA_CARDINAL
, 32, PropModeReplace
,
509 (unsigned char *) &opac
, 1L);
514 x_display_pixel_height (struct x_display_info
*dpyinfo
)
516 return HeightOfScreen (dpyinfo
->screen
);
520 x_display_pixel_width (struct x_display_info
*dpyinfo
)
522 return WidthOfScreen (dpyinfo
->screen
);
526 /***********************************************************************
527 Starting and ending an update
528 ***********************************************************************/
530 /* Start an update of frame F. This function is installed as a hook
531 for update_begin, i.e. it is called when update_begin is called.
532 This function is called prior to calls to x_update_window_begin for
533 each window being updated. Currently, there is nothing to do here
534 because all interesting stuff is done on a window basis. */
537 x_update_begin (struct frame
*f
)
543 /* Start update of window W. Set the global variable updated_window
544 to the window being updated and set output_cursor to the cursor
548 x_update_window_begin (struct window
*w
)
550 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
551 struct x_display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
554 set_output_cursor (&w
->cursor
);
558 if (f
== display_info
->mouse_face_mouse_frame
)
560 /* Don't do highlighting for mouse motion during the update. */
561 display_info
->mouse_face_defer
= 1;
563 /* If F needs to be redrawn, simply forget about any prior mouse
565 if (FRAME_GARBAGED_P (f
))
566 display_info
->mouse_face_window
= Qnil
;
573 /* Draw a vertical window border from (x,y0) to (x,y1) */
576 x_draw_vertical_window_border (struct window
*w
, int x
, int y0
, int y1
)
578 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
581 face
= FACE_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
583 XSetForeground (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
586 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
587 f
->output_data
.x
->normal_gc
, x
, y0
, x
, y1
);
590 /* End update of window W (which is equal to updated_window).
592 Draw vertical borders between horizontally adjacent windows, and
593 display W's cursor if CURSOR_ON_P is non-zero.
595 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
596 glyphs in mouse-face were overwritten. In that case we have to
597 make sure that the mouse-highlight is properly redrawn.
599 W may be a menu bar pseudo-window in case we don't have X toolkit
600 support. Such windows don't have a cursor, so don't display it
604 x_update_window_end (struct window
*w
, int cursor_on_p
, int mouse_face_overwritten_p
)
606 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
608 if (!w
->pseudo_window_p
)
613 display_and_set_cursor (w
, 1, output_cursor
.hpos
,
615 output_cursor
.x
, output_cursor
.y
);
617 if (draw_window_fringes (w
, 1))
618 x_draw_vertical_border (w
);
623 /* If a row with mouse-face was overwritten, arrange for
624 XTframe_up_to_date to redisplay the mouse highlight. */
625 if (mouse_face_overwritten_p
)
627 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
628 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
629 dpyinfo
->mouse_face_window
= Qnil
;
632 updated_window
= NULL
;
636 /* End update of frame F. This function is installed as a hook in
640 x_update_end (struct frame
*f
)
642 /* Mouse highlight may be displayed again. */
643 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
647 XFlush (FRAME_X_DISPLAY (f
));
653 /* This function is called from various places in xdisp.c whenever a
654 complete update has been performed. The global variable
655 updated_window is not available here. */
658 XTframe_up_to_date (struct frame
*f
)
662 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
664 if (dpyinfo
->mouse_face_deferred_gc
665 || f
== dpyinfo
->mouse_face_mouse_frame
)
668 if (dpyinfo
->mouse_face_mouse_frame
)
669 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
670 dpyinfo
->mouse_face_mouse_x
,
671 dpyinfo
->mouse_face_mouse_y
);
672 dpyinfo
->mouse_face_deferred_gc
= 0;
679 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
680 arrow bitmaps, or clear the fringes if no bitmaps are required
681 before DESIRED_ROW is made current. The window being updated is
682 found in updated_window. This function It is called from
683 update_window_line only if it is known that there are differences
684 between bitmaps to be drawn between current row and DESIRED_ROW. */
687 x_after_update_window_line (struct glyph_row
*desired_row
)
689 struct window
*w
= updated_window
;
695 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
696 desired_row
->redraw_fringe_bitmaps_p
= 1;
698 /* When a window has disappeared, make sure that no rest of
699 full-width rows stays visible in the internal border. Could
700 check here if updated_window is the leftmost/rightmost window,
701 but I guess it's not worth doing since vertically split windows
702 are almost never used, internal border is rarely set, and the
703 overhead is very small. */
704 if (windows_or_buffers_changed
705 && desired_row
->full_width_p
706 && (f
= XFRAME (w
->frame
),
707 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
709 && (height
= desired_row
->visible_height
,
712 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
715 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
716 0, y
, width
, height
, False
);
717 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
718 FRAME_PIXEL_WIDTH (f
) - width
,
719 y
, width
, height
, False
);
725 x_draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
, struct draw_fringe_bitmap_params
*p
)
727 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
728 Display
*display
= FRAME_X_DISPLAY (f
);
729 Window window
= FRAME_X_WINDOW (f
);
730 GC gc
= f
->output_data
.x
->normal_gc
;
731 struct face
*face
= p
->face
;
733 /* Must clip because of partially visible lines. */
734 x_clip_to_row (w
, row
, -1, gc
);
738 int bx
= p
->bx
, by
= p
->by
, nx
= p
->nx
, ny
= p
->ny
;
740 /* In case the same realized face is used for fringes and
741 for something displayed in the text (e.g. face `region' on
742 mono-displays, the fill style may have been changed to
743 FillSolid in x_draw_glyph_string_background. */
745 XSetFillStyle (display
, face
->gc
, FillOpaqueStippled
);
747 XSetForeground (display
, face
->gc
, face
->background
);
749 #ifdef USE_TOOLKIT_SCROLL_BARS
750 /* If the fringe is adjacent to the left (right) scroll bar of a
751 leftmost (rightmost, respectively) window, then extend its
752 background to the gap between the fringe and the bar. */
753 if ((WINDOW_LEFTMOST_P (w
)
754 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
755 || (WINDOW_RIGHTMOST_P (w
)
756 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
)))
758 int sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
762 int left
= WINDOW_SCROLL_BAR_AREA_X (w
);
763 int width
= (WINDOW_CONFIG_SCROLL_BAR_COLS (w
)
764 * FRAME_COLUMN_WIDTH (f
));
768 /* Bitmap fills the fringe. */
769 if (left
+ width
== p
->x
)
770 bx
= left
+ sb_width
;
771 else if (p
->x
+ p
->wd
== left
)
775 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
777 nx
= width
- sb_width
;
778 by
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
780 ny
= row
->visible_height
;
785 if (left
+ width
== bx
)
787 bx
= left
+ sb_width
;
788 nx
+= width
- sb_width
;
790 else if (bx
+ nx
== left
)
791 nx
+= width
- sb_width
;
796 if (bx
>= 0 && nx
> 0)
797 XFillRectangle (display
, window
, face
->gc
, bx
, by
, nx
, ny
);
800 XSetForeground (display
, face
->gc
, face
->foreground
);
806 Pixmap pixmap
, clipmask
= (Pixmap
) 0;
807 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
811 bits
= (unsigned char *)(p
->bits
+ p
->dh
);
813 bits
= (unsigned char *)p
->bits
+ p
->dh
;
815 /* Draw the bitmap. I believe these small pixmaps can be cached
817 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, p
->wd
, p
->h
,
819 ? (p
->overlay_p
? face
->background
820 : f
->output_data
.x
->cursor_pixel
)
822 face
->background
, depth
);
826 clipmask
= XCreatePixmapFromBitmapData (display
,
827 FRAME_X_DISPLAY_INFO (f
)->root_window
,
830 gcv
.clip_mask
= clipmask
;
831 gcv
.clip_x_origin
= p
->x
;
832 gcv
.clip_y_origin
= p
->y
;
833 XChangeGC (display
, gc
, GCClipMask
| GCClipXOrigin
| GCClipYOrigin
, &gcv
);
836 XCopyArea (display
, pixmap
, window
, gc
, 0, 0,
837 p
->wd
, p
->h
, p
->x
, p
->y
);
838 XFreePixmap (display
, pixmap
);
842 gcv
.clip_mask
= (Pixmap
) 0;
843 XChangeGC (display
, gc
, GCClipMask
, &gcv
);
844 XFreePixmap (display
, clipmask
);
848 XSetClipMask (display
, gc
, None
);
853 /* This is called when starting Emacs and when restarting after
854 suspend. When starting Emacs, no X window is mapped. And nothing
855 must be done to Emacs's own window if it is suspended (though that
859 XTset_terminal_modes (struct terminal
*terminal
)
863 /* This is called when exiting or suspending Emacs. Exiting will make
864 the X-windows go away, and suspending requires no action. */
867 XTreset_terminal_modes (struct terminal
*terminal
)
872 /***********************************************************************
874 ***********************************************************************/
878 static void x_set_glyph_string_clipping (struct glyph_string
*);
879 static void x_set_glyph_string_gc (struct glyph_string
*);
880 static void x_draw_glyph_string_background (struct glyph_string
*,
882 static void x_draw_glyph_string_foreground (struct glyph_string
*);
883 static void x_draw_composite_glyph_string_foreground (struct glyph_string
*);
884 static void x_draw_glyph_string_box (struct glyph_string
*);
885 static void x_draw_glyph_string (struct glyph_string
*);
886 static void x_compute_glyph_string_overhangs (struct glyph_string
*);
887 static void x_set_cursor_gc (struct glyph_string
*);
888 static void x_set_mode_line_face_gc (struct glyph_string
*);
889 static void x_set_mouse_face_gc (struct glyph_string
*);
890 static int x_alloc_lighter_color (struct frame
*, Display
*, Colormap
,
891 unsigned long *, double, int);
892 static void x_setup_relief_color (struct frame
*, struct relief
*,
893 double, int, unsigned long);
894 static void x_setup_relief_colors (struct glyph_string
*);
895 static void x_draw_image_glyph_string (struct glyph_string
*);
896 static void x_draw_image_relief (struct glyph_string
*);
897 static void x_draw_image_foreground (struct glyph_string
*);
898 static void x_draw_image_foreground_1 (struct glyph_string
*, Pixmap
);
899 static void x_clear_glyph_string_rect (struct glyph_string
*, int,
901 static void x_draw_relief_rect (struct frame
*, int, int, int, int,
902 int, int, int, int, int, int,
904 static void x_draw_box_rect (struct glyph_string
*, int, int, int, int,
905 int, int, int, XRectangle
*);
908 static void x_check_font (struct frame
*, struct font
*);
912 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
916 x_set_cursor_gc (struct glyph_string
*s
)
918 if (s
->font
== FRAME_FONT (s
->f
)
919 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
920 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
922 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
925 /* Cursor on non-default face: must merge. */
929 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
930 xgcv
.foreground
= s
->face
->background
;
932 /* If the glyph would be invisible, try a different foreground. */
933 if (xgcv
.foreground
== xgcv
.background
)
934 xgcv
.foreground
= s
->face
->foreground
;
935 if (xgcv
.foreground
== xgcv
.background
)
936 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
937 if (xgcv
.foreground
== xgcv
.background
)
938 xgcv
.foreground
= s
->face
->foreground
;
940 /* Make sure the cursor is distinct from text in this face. */
941 if (xgcv
.background
== s
->face
->background
942 && xgcv
.foreground
== s
->face
->foreground
)
944 xgcv
.background
= s
->face
->foreground
;
945 xgcv
.foreground
= s
->face
->background
;
948 IF_DEBUG (x_check_font (s
->f
, s
->font
));
949 xgcv
.graphics_exposures
= False
;
950 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
952 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
953 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
956 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
957 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
959 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
964 /* Set up S->gc of glyph string S for drawing text in mouse face. */
967 x_set_mouse_face_gc (struct glyph_string
*s
)
972 /* What face has to be used last for the mouse face? */
973 face_id
= FRAME_X_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
974 face
= FACE_FROM_ID (s
->f
, face_id
);
976 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
978 if (s
->first_glyph
->type
== CHAR_GLYPH
)
979 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
981 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
982 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
983 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
985 if (s
->font
== s
->face
->font
)
989 /* Otherwise construct scratch_cursor_gc with values from FACE
994 xgcv
.background
= s
->face
->background
;
995 xgcv
.foreground
= s
->face
->foreground
;
996 xgcv
.graphics_exposures
= False
;
997 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
999 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1000 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1003 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1004 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
1006 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1009 xassert (s
->gc
!= 0);
1013 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1014 Faces to use in the mode line have already been computed when the
1015 matrix was built, so there isn't much to do, here. */
1018 x_set_mode_line_face_gc (struct glyph_string
*s
)
1020 s
->gc
= s
->face
->gc
;
1024 /* Set S->gc of glyph string S for drawing that glyph string. Set
1025 S->stippled_p to a non-zero value if the face of S has a stipple
1029 x_set_glyph_string_gc (struct glyph_string
*s
)
1031 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1033 if (s
->hl
== DRAW_NORMAL_TEXT
)
1035 s
->gc
= s
->face
->gc
;
1036 s
->stippled_p
= s
->face
->stipple
!= 0;
1038 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1040 x_set_mode_line_face_gc (s
);
1041 s
->stippled_p
= s
->face
->stipple
!= 0;
1043 else if (s
->hl
== DRAW_CURSOR
)
1045 x_set_cursor_gc (s
);
1048 else if (s
->hl
== DRAW_MOUSE_FACE
)
1050 x_set_mouse_face_gc (s
);
1051 s
->stippled_p
= s
->face
->stipple
!= 0;
1053 else if (s
->hl
== DRAW_IMAGE_RAISED
1054 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1056 s
->gc
= s
->face
->gc
;
1057 s
->stippled_p
= s
->face
->stipple
!= 0;
1061 s
->gc
= s
->face
->gc
;
1062 s
->stippled_p
= s
->face
->stipple
!= 0;
1065 /* GC must have been set. */
1066 xassert (s
->gc
!= 0);
1070 /* Set clipping for output of glyph string S. S may be part of a mode
1071 line or menu if we don't have X toolkit support. */
1074 x_set_glyph_string_clipping (struct glyph_string
*s
)
1076 XRectangle
*r
= s
->clip
;
1077 int n
= get_glyph_string_clip_rects (s
, r
, 2);
1080 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, r
, n
, Unsorted
);
1085 /* Set SRC's clipping for output of glyph string DST. This is called
1086 when we are drawing DST's left_overhang or right_overhang only in
1090 x_set_glyph_string_clipping_exactly (struct glyph_string
*src
, struct glyph_string
*dst
)
1095 r
.width
= src
->width
;
1097 r
.height
= src
->height
;
1100 XSetClipRectangles (dst
->display
, dst
->gc
, 0, 0, &r
, 1, Unsorted
);
1105 Compute left and right overhang of glyph string S. */
1108 x_compute_glyph_string_overhangs (struct glyph_string
*s
)
1111 && (s
->first_glyph
->type
== CHAR_GLYPH
1112 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
1114 struct font_metrics metrics
;
1116 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1118 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1119 struct font
*font
= s
->font
;
1122 for (i
= 0; i
< s
->nchars
; i
++)
1123 code
[i
] = (s
->char2b
[i
].byte1
<< 8) | s
->char2b
[i
].byte2
;
1124 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1128 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1130 composition_gstring_width (gstring
, s
->cmp_from
, s
->cmp_to
, &metrics
);
1132 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1133 ? metrics
.rbearing
- metrics
.width
: 0);
1134 s
->left_overhang
= metrics
.lbearing
< 0 ? - metrics
.lbearing
: 0;
1138 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1139 s
->left_overhang
= - s
->cmp
->lbearing
;
1144 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1147 x_clear_glyph_string_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
1150 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
1151 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
1152 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
1153 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
1157 /* Draw the background of glyph_string S. If S->background_filled_p
1158 is non-zero don't draw it. FORCE_P non-zero means draw the
1159 background even if it wouldn't be drawn normally. This is used
1160 when a string preceding S draws into the background of S, or S
1161 contains the first component of a composition. */
1164 x_draw_glyph_string_background (struct glyph_string
*s
, int force_p
)
1166 /* Nothing to do if background has already been drawn or if it
1167 shouldn't be drawn in the first place. */
1168 if (!s
->background_filled_p
)
1170 int box_line_width
= max (s
->face
->box_line_width
, 0);
1174 /* Fill background with a stipple pattern. */
1175 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1176 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1177 s
->y
+ box_line_width
,
1178 s
->background_width
,
1179 s
->height
- 2 * box_line_width
);
1180 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1181 s
->background_filled_p
= 1;
1183 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1184 || s
->font_not_found_p
1185 || s
->extends_to_end_of_line_p
1188 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1189 s
->background_width
,
1190 s
->height
- 2 * box_line_width
);
1191 s
->background_filled_p
= 1;
1197 /* Draw the foreground of glyph string S. */
1200 x_draw_glyph_string_foreground (struct glyph_string
*s
)
1204 /* If first glyph of S has a left box line, start drawing the text
1205 of S to the right of that box line. */
1206 if (s
->face
->box
!= FACE_NO_BOX
1207 && s
->first_glyph
->left_box_line_p
)
1208 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1212 /* Draw characters of S as rectangles if S's font could not be
1214 if (s
->font_not_found_p
)
1216 for (i
= 0; i
< s
->nchars
; ++i
)
1218 struct glyph
*g
= s
->first_glyph
+ i
;
1219 XDrawRectangle (s
->display
, s
->window
,
1220 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1222 x
+= g
->pixel_width
;
1227 struct font
*font
= s
->font
;
1228 int boff
= font
->baseline_offset
;
1231 if (font
->vertical_centering
)
1232 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1234 y
= s
->ybase
- boff
;
1236 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1237 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 0);
1239 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 1);
1240 if (s
->face
->overstrike
)
1241 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, 0);
1245 /* Draw the foreground of composite glyph string S. */
1248 x_draw_composite_glyph_string_foreground (struct glyph_string
*s
)
1251 struct font
*font
= s
->font
;
1253 /* If first glyph of S has a left box line, start drawing the text
1254 of S to the right of that box line. */
1255 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1256 && s
->first_glyph
->left_box_line_p
)
1257 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1261 /* S is a glyph string for a composition. S->cmp_from is the index
1262 of the first character drawn for glyphs of this composition.
1263 S->cmp_from == 0 means we are drawing the very first character of
1264 this composition. */
1266 /* Draw a rectangle for the composition if the font for the very
1267 first character of the composition could not be loaded. */
1268 if (s
->font_not_found_p
)
1270 if (s
->cmp_from
== 0)
1271 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, s
->y
,
1272 s
->width
- 1, s
->height
- 1);
1274 else if (! s
->first_glyph
->u
.cmp
.automatic
)
1278 for (i
= 0, j
= s
->cmp_from
; i
< s
->nchars
; i
++, j
++)
1279 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1281 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1282 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1284 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, 0);
1285 if (s
->face
->overstrike
)
1286 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, 0);
1291 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1296 for (i
= j
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
1298 glyph
= LGSTRING_GLYPH (gstring
, i
);
1299 if (NILP (LGLYPH_ADJUSTMENT (glyph
)))
1300 width
+= LGLYPH_WIDTH (glyph
);
1303 int xoff
, yoff
, wadjust
;
1307 font
->driver
->draw (s
, j
, i
, x
, y
, 0);
1308 if (s
->face
->overstrike
)
1309 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, 0);
1312 xoff
= LGLYPH_XOFF (glyph
);
1313 yoff
= LGLYPH_YOFF (glyph
);
1314 wadjust
= LGLYPH_WADJUST (glyph
);
1315 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, 0);
1316 if (s
->face
->overstrike
)
1317 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
+ 1, y
+ yoff
, 0);
1325 font
->driver
->draw (s
, j
, i
, x
, y
, 0);
1326 if (s
->face
->overstrike
)
1327 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, 0);
1333 #ifdef USE_X_TOOLKIT
1335 static struct frame
*x_frame_of_widget (Widget
);
1336 static Boolean
cvt_string_to_pixel (Display
*, XrmValue
*, Cardinal
*,
1337 XrmValue
*, XrmValue
*, XtPointer
*);
1338 static void cvt_pixel_dtor (XtAppContext
, XrmValue
*, XtPointer
,
1339 XrmValue
*, Cardinal
*);
1342 /* Return the frame on which widget WIDGET is used.. Abort if frame
1343 cannot be determined. */
1345 static struct frame
*
1346 x_frame_of_widget (Widget widget
)
1348 struct x_display_info
*dpyinfo
;
1352 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
1354 /* Find the top-level shell of the widget. Note that this function
1355 can be called when the widget is not yet realized, so XtWindow
1356 (widget) == 0. That's the reason we can't simply use
1357 x_any_window_to_frame. */
1358 while (!XtIsTopLevelShell (widget
))
1359 widget
= XtParent (widget
);
1361 /* Look for a frame with that top-level widget. Allocate the color
1362 on that frame to get the right gamma correction value. */
1363 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1364 if (FRAMEP (XCAR (tail
))
1365 && (f
= XFRAME (XCAR (tail
)),
1367 && f
->output_data
.nothing
!= 1
1368 && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
))
1369 && f
->output_data
.x
->widget
== widget
)
1376 /* Allocate the color COLOR->pixel on the screen and display of
1377 widget WIDGET in colormap CMAP. If an exact match cannot be
1378 allocated, try the nearest color available. Value is non-zero
1379 if successful. This is called from lwlib. */
1382 x_alloc_nearest_color_for_widget (Widget widget
, Colormap cmap
, XColor
*color
)
1384 struct frame
*f
= x_frame_of_widget (widget
);
1385 return x_alloc_nearest_color (f
, cmap
, color
);
1389 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1390 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1391 If this produces the same color as PIXEL, try a color where all RGB
1392 values have DELTA added. Return the allocated color in *PIXEL.
1393 DISPLAY is the X display, CMAP is the colormap to operate on.
1394 Value is non-zero if successful. */
1397 x_alloc_lighter_color_for_widget (Widget widget
, Display
*display
, Colormap cmap
,
1398 unsigned long *pixel
, double factor
, int delta
)
1400 struct frame
*f
= x_frame_of_widget (widget
);
1401 return x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
);
1405 /* Structure specifying which arguments should be passed by Xt to
1406 cvt_string_to_pixel. We want the widget's screen and colormap. */
1408 static XtConvertArgRec cvt_string_to_pixel_args
[] =
1410 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.screen
),
1412 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.colormap
),
1417 /* The address of this variable is returned by
1418 cvt_string_to_pixel. */
1420 static Pixel cvt_string_to_pixel_value
;
1423 /* Convert a color name to a pixel color.
1425 DPY is the display we are working on.
1427 ARGS is an array of *NARGS XrmValue structures holding additional
1428 information about the widget for which the conversion takes place.
1429 The contents of this array are determined by the specification
1430 in cvt_string_to_pixel_args.
1432 FROM is a pointer to an XrmValue which points to the color name to
1433 convert. TO is an XrmValue in which to return the pixel color.
1435 CLOSURE_RET is a pointer to user-data, in which we record if
1436 we allocated the color or not.
1438 Value is True if successful, False otherwise. */
1441 cvt_string_to_pixel (Display
*dpy
, XrmValue
*args
, Cardinal
*nargs
,
1442 XrmValue
*from
, XrmValue
*to
,
1443 XtPointer
*closure_ret
)
1453 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1454 "wrongParameters", "cvt_string_to_pixel",
1456 "Screen and colormap args required", NULL
, NULL
);
1460 screen
= *(Screen
**) args
[0].addr
;
1461 cmap
= *(Colormap
*) args
[1].addr
;
1462 color_name
= (String
) from
->addr
;
1464 if (strcmp (color_name
, XtDefaultBackground
) == 0)
1466 *closure_ret
= (XtPointer
) False
;
1467 pixel
= WhitePixelOfScreen (screen
);
1469 else if (strcmp (color_name
, XtDefaultForeground
) == 0)
1471 *closure_ret
= (XtPointer
) False
;
1472 pixel
= BlackPixelOfScreen (screen
);
1474 else if (XParseColor (dpy
, cmap
, color_name
, &color
)
1475 && x_alloc_nearest_color_1 (dpy
, cmap
, &color
))
1477 pixel
= color
.pixel
;
1478 *closure_ret
= (XtPointer
) True
;
1483 Cardinal nparams
= 1;
1485 params
[0] = color_name
;
1486 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1487 "badValue", "cvt_string_to_pixel",
1488 "XtToolkitError", "Invalid color `%s'",
1493 if (to
->addr
!= NULL
)
1495 if (to
->size
< sizeof (Pixel
))
1497 to
->size
= sizeof (Pixel
);
1501 *(Pixel
*) to
->addr
= pixel
;
1505 cvt_string_to_pixel_value
= pixel
;
1506 to
->addr
= (XtPointer
) &cvt_string_to_pixel_value
;
1509 to
->size
= sizeof (Pixel
);
1514 /* Free a pixel color which was previously allocated via
1515 cvt_string_to_pixel. This is registered as the destructor
1516 for this type of resource via XtSetTypeConverter.
1518 APP is the application context in which we work.
1520 TO is a pointer to an XrmValue holding the color to free.
1521 CLOSURE is the value we stored in CLOSURE_RET for this color
1522 in cvt_string_to_pixel.
1524 ARGS and NARGS are like for cvt_string_to_pixel. */
1527 cvt_pixel_dtor (XtAppContext app
, XrmValuePtr to
, XtPointer closure
, XrmValuePtr args
,
1532 XtAppWarningMsg (app
, "wrongParameters", "cvt_pixel_dtor",
1534 "Screen and colormap arguments required",
1537 else if (closure
!= NULL
)
1539 /* We did allocate the pixel, so free it. */
1540 Screen
*screen
= *(Screen
**) args
[0].addr
;
1541 Colormap cmap
= *(Colormap
*) args
[1].addr
;
1542 x_free_dpy_colors (DisplayOfScreen (screen
), screen
, cmap
,
1543 (Pixel
*) to
->addr
, 1);
1548 #endif /* USE_X_TOOLKIT */
1551 /* Value is an array of XColor structures for the contents of the
1552 color map of display DPY. Set *NCELLS to the size of the array.
1553 Note that this probably shouldn't be called for large color maps,
1554 say a 24-bit TrueColor map. */
1556 static const XColor
*
1557 x_color_cells (Display
*dpy
, int *ncells
)
1559 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1561 if (dpyinfo
->color_cells
== NULL
)
1563 Screen
*screen
= dpyinfo
->screen
;
1566 dpyinfo
->ncolor_cells
1567 = XDisplayCells (dpy
, XScreenNumberOfScreen (screen
));
1568 dpyinfo
->color_cells
1569 = (XColor
*) xmalloc (dpyinfo
->ncolor_cells
1570 * sizeof *dpyinfo
->color_cells
);
1572 for (i
= 0; i
< dpyinfo
->ncolor_cells
; ++i
)
1573 dpyinfo
->color_cells
[i
].pixel
= i
;
1575 XQueryColors (dpy
, dpyinfo
->cmap
,
1576 dpyinfo
->color_cells
, dpyinfo
->ncolor_cells
);
1579 *ncells
= dpyinfo
->ncolor_cells
;
1580 return dpyinfo
->color_cells
;
1584 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1585 colors in COLORS. Use cached information, if available. */
1588 x_query_colors (struct frame
*f
, XColor
*colors
, int ncolors
)
1590 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1592 if (dpyinfo
->color_cells
)
1595 for (i
= 0; i
< ncolors
; ++i
)
1597 unsigned long pixel
= colors
[i
].pixel
;
1598 xassert (pixel
< dpyinfo
->ncolor_cells
);
1599 xassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
1600 colors
[i
] = dpyinfo
->color_cells
[pixel
];
1604 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
1608 /* On frame F, translate pixel color to RGB values for the color in
1609 COLOR. Use cached information, if available. */
1612 x_query_color (struct frame
*f
, XColor
*color
)
1614 x_query_colors (f
, color
, 1);
1618 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
1619 exact match can't be allocated, try the nearest color available.
1620 Value is non-zero if successful. Set *COLOR to the color
1624 x_alloc_nearest_color_1 (Display
*dpy
, Colormap cmap
, XColor
*color
)
1628 rc
= XAllocColor (dpy
, cmap
, color
);
1631 /* If we got to this point, the colormap is full, so we're going
1632 to try to get the next closest color. The algorithm used is
1633 a least-squares matching, which is what X uses for closest
1634 color matching with StaticColor visuals. */
1636 unsigned long nearest_delta
= ~0;
1638 const XColor
*cells
= x_color_cells (dpy
, &ncells
);
1640 for (nearest
= i
= 0; i
< ncells
; ++i
)
1642 long dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
1643 long dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
1644 long dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
1645 unsigned long delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
1647 if (delta
< nearest_delta
)
1650 nearest_delta
= delta
;
1654 color
->red
= cells
[nearest
].red
;
1655 color
->green
= cells
[nearest
].green
;
1656 color
->blue
= cells
[nearest
].blue
;
1657 rc
= XAllocColor (dpy
, cmap
, color
);
1661 /* If allocation succeeded, and the allocated pixel color is not
1662 equal to a cached pixel color recorded earlier, there was a
1663 change in the colormap, so clear the color cache. */
1664 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1665 XColor
*cached_color
;
1667 if (dpyinfo
->color_cells
1668 && (cached_color
= &dpyinfo
->color_cells
[color
->pixel
],
1669 (cached_color
->red
!= color
->red
1670 || cached_color
->blue
!= color
->blue
1671 || cached_color
->green
!= color
->green
)))
1673 xfree (dpyinfo
->color_cells
);
1674 dpyinfo
->color_cells
= NULL
;
1675 dpyinfo
->ncolor_cells
= 0;
1679 #ifdef DEBUG_X_COLORS
1681 register_color (color
->pixel
);
1682 #endif /* DEBUG_X_COLORS */
1688 /* Allocate the color COLOR->pixel on frame F, colormap CMAP. If an
1689 exact match can't be allocated, try the nearest color available.
1690 Value is non-zero if successful. Set *COLOR to the color
1694 x_alloc_nearest_color (struct frame
*f
, Colormap cmap
, XColor
*color
)
1696 gamma_correct (f
, color
);
1697 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f
), cmap
, color
);
1701 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
1702 It's necessary to do this instead of just using PIXEL directly to
1703 get color reference counts right. */
1706 x_copy_color (struct frame
*f
, long unsigned int pixel
)
1710 color
.pixel
= pixel
;
1712 x_query_color (f
, &color
);
1713 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
1715 #ifdef DEBUG_X_COLORS
1716 register_color (pixel
);
1722 /* Allocate color PIXEL on display DPY. PIXEL must already be allocated.
1723 It's necessary to do this instead of just using PIXEL directly to
1724 get color reference counts right. */
1727 x_copy_dpy_color (Display
*dpy
, Colormap cmap
, long unsigned int pixel
)
1731 color
.pixel
= pixel
;
1733 XQueryColor (dpy
, cmap
, &color
);
1734 XAllocColor (dpy
, cmap
, &color
);
1736 #ifdef DEBUG_X_COLORS
1737 register_color (pixel
);
1743 /* Brightness beyond which a color won't have its highlight brightness
1746 Nominally, highlight colors for `3d' faces are calculated by
1747 brightening an object's color by a constant scale factor, but this
1748 doesn't yield good results for dark colors, so for colors who's
1749 brightness is less than this value (on a scale of 0-65535) have an
1750 use an additional additive factor.
1752 The value here is set so that the default menu-bar/mode-line color
1753 (grey75) will not have its highlights changed at all. */
1754 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
1757 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1758 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1759 If this produces the same color as PIXEL, try a color where all RGB
1760 values have DELTA added. Return the allocated color in *PIXEL.
1761 DISPLAY is the X display, CMAP is the colormap to operate on.
1762 Value is non-zero if successful. */
1765 x_alloc_lighter_color (struct frame
*f
, Display
*display
, Colormap cmap
, long unsigned int *pixel
, double factor
, int delta
)
1771 /* Get RGB color values. */
1772 color
.pixel
= *pixel
;
1773 x_query_color (f
, &color
);
1775 /* Change RGB values by specified FACTOR. Avoid overflow! */
1776 xassert (factor
>= 0);
1777 new.red
= min (0xffff, factor
* color
.red
);
1778 new.green
= min (0xffff, factor
* color
.green
);
1779 new.blue
= min (0xffff, factor
* color
.blue
);
1781 /* Calculate brightness of COLOR. */
1782 bright
= (2 * color
.red
+ 3 * color
.green
+ color
.blue
) / 6;
1784 /* We only boost colors that are darker than
1785 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1786 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1787 /* Make an additive adjustment to NEW, because it's dark enough so
1788 that scaling by FACTOR alone isn't enough. */
1790 /* How far below the limit this color is (0 - 1, 1 being darker). */
1791 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1792 /* The additive adjustment. */
1793 int min_delta
= delta
* dimness
* factor
/ 2;
1797 new.red
= max (0, new.red
- min_delta
);
1798 new.green
= max (0, new.green
- min_delta
);
1799 new.blue
= max (0, new.blue
- min_delta
);
1803 new.red
= min (0xffff, min_delta
+ new.red
);
1804 new.green
= min (0xffff, min_delta
+ new.green
);
1805 new.blue
= min (0xffff, min_delta
+ new.blue
);
1809 /* Try to allocate the color. */
1810 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1813 if (new.pixel
== *pixel
)
1815 /* If we end up with the same color as before, try adding
1816 delta to the RGB values. */
1817 x_free_colors (f
, &new.pixel
, 1);
1819 new.red
= min (0xffff, delta
+ color
.red
);
1820 new.green
= min (0xffff, delta
+ color
.green
);
1821 new.blue
= min (0xffff, delta
+ color
.blue
);
1822 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1833 /* Set up the foreground color for drawing relief lines of glyph
1834 string S. RELIEF is a pointer to a struct relief containing the GC
1835 with which lines will be drawn. Use a color that is FACTOR or
1836 DELTA lighter or darker than the relief's background which is found
1837 in S->f->output_data.x->relief_background. If such a color cannot
1838 be allocated, use DEFAULT_PIXEL, instead. */
1841 x_setup_relief_color (struct frame
*f
, struct relief
*relief
, double factor
, int delta
, long unsigned int default_pixel
)
1844 struct x_output
*di
= f
->output_data
.x
;
1845 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
1846 unsigned long pixel
;
1847 unsigned long background
= di
->relief_background
;
1848 Colormap cmap
= FRAME_X_COLORMAP (f
);
1849 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1850 Display
*dpy
= FRAME_X_DISPLAY (f
);
1852 xgcv
.graphics_exposures
= False
;
1853 xgcv
.line_width
= 1;
1855 /* Free previously allocated color. The color cell will be reused
1856 when it has been freed as many times as it was allocated, so this
1857 doesn't affect faces using the same colors. */
1859 && relief
->allocated_p
)
1861 x_free_colors (f
, &relief
->pixel
, 1);
1862 relief
->allocated_p
= 0;
1865 /* Allocate new color. */
1866 xgcv
.foreground
= default_pixel
;
1868 if (dpyinfo
->n_planes
!= 1
1869 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
1871 relief
->allocated_p
= 1;
1872 xgcv
.foreground
= relief
->pixel
= pixel
;
1875 if (relief
->gc
== 0)
1877 xgcv
.stipple
= dpyinfo
->gray
;
1879 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
1882 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
1886 /* Set up colors for the relief lines around glyph string S. */
1889 x_setup_relief_colors (struct glyph_string
*s
)
1891 struct x_output
*di
= s
->f
->output_data
.x
;
1892 unsigned long color
;
1894 if (s
->face
->use_box_color_for_shadows_p
)
1895 color
= s
->face
->box_color
;
1896 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1898 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1899 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1904 /* Get the background color of the face. */
1905 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
1906 color
= xgcv
.background
;
1909 if (di
->white_relief
.gc
== 0
1910 || color
!= di
->relief_background
)
1912 di
->relief_background
= color
;
1913 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
1914 WHITE_PIX_DEFAULT (s
->f
));
1915 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
1916 BLACK_PIX_DEFAULT (s
->f
));
1921 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1922 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1923 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1924 relief. LEFT_P non-zero means draw a relief on the left side of
1925 the rectangle. RIGHT_P non-zero means draw a relief on the right
1926 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1930 x_draw_relief_rect (struct frame
*f
,
1931 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
1932 int raised_p
, int top_p
, int bot_p
, int left_p
, int right_p
,
1933 XRectangle
*clip_rect
)
1935 Display
*dpy
= FRAME_X_DISPLAY (f
);
1936 Window window
= FRAME_X_WINDOW (f
);
1941 gc
= f
->output_data
.x
->white_relief
.gc
;
1943 gc
= f
->output_data
.x
->black_relief
.gc
;
1944 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
1946 /* This code is more complicated than it has to be, because of two
1947 minor hacks to make the boxes look nicer: (i) if width > 1, draw
1948 the outermost line using the black relief. (ii) Omit the four
1955 XDrawLine (dpy
, window
, gc
,
1956 left_x
+ (left_p
? 1 : 0), top_y
,
1957 right_x
+ (right_p
? 0 : 1), top_y
);
1959 for (i
= 1; i
< width
; ++i
)
1960 XDrawLine (dpy
, window
, gc
,
1961 left_x
+ i
* left_p
, top_y
+ i
,
1962 right_x
+ 1 - i
* right_p
, top_y
+ i
);
1969 XDrawLine (dpy
, window
, gc
, left_x
, top_y
+ 1, left_x
, bottom_y
);
1971 XClearArea (dpy
, window
, left_x
, top_y
, 1, 1, False
);
1972 XClearArea (dpy
, window
, left_x
, bottom_y
, 1, 1, False
);
1974 for (i
= (width
> 1 ? 1 : 0); i
< width
; ++i
)
1975 XDrawLine (dpy
, window
, gc
,
1976 left_x
+ i
, top_y
+ i
, left_x
+ i
, bottom_y
- i
+ 1);
1979 XSetClipMask (dpy
, gc
, None
);
1981 gc
= f
->output_data
.x
->black_relief
.gc
;
1983 gc
= f
->output_data
.x
->white_relief
.gc
;
1984 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
1988 /* Outermost top line. */
1990 XDrawLine (dpy
, window
, gc
,
1991 left_x
+ (left_p
? 1 : 0), top_y
,
1992 right_x
+ (right_p
? 0 : 1), top_y
);
1994 /* Outermost left line. */
1996 XDrawLine (dpy
, window
, gc
, left_x
, top_y
+ 1, left_x
, bottom_y
);
2002 XDrawLine (dpy
, window
, gc
,
2003 left_x
+ (left_p
? 1 : 0), bottom_y
,
2004 right_x
+ (right_p
? 0 : 1), bottom_y
);
2005 for (i
= 1; i
< width
; ++i
)
2006 XDrawLine (dpy
, window
, gc
,
2007 left_x
+ i
* left_p
, bottom_y
- i
,
2008 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
2014 XClearArea (dpy
, window
, right_x
, top_y
, 1, 1, False
);
2015 XClearArea (dpy
, window
, right_x
, bottom_y
, 1, 1, False
);
2016 for (i
= 0; i
< width
; ++i
)
2017 XDrawLine (dpy
, window
, gc
,
2018 right_x
- i
, top_y
+ i
+ 1, right_x
- i
, bottom_y
- i
);
2021 XSetClipMask (dpy
, gc
, None
);
2025 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
2026 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
2027 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
2028 left side of the rectangle. RIGHT_P non-zero means draw a line
2029 on the right side of the rectangle. CLIP_RECT is the clipping
2030 rectangle to use when drawing. */
2033 x_draw_box_rect (struct glyph_string
*s
,
2034 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
2035 int left_p
, int right_p
, XRectangle
*clip_rect
)
2039 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2040 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
2041 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, clip_rect
, 1, Unsorted
);
2044 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2045 left_x
, top_y
, right_x
- left_x
+ 1, width
);
2049 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2050 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
2053 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2054 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
2058 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2059 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
2061 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2062 XSetClipMask (s
->display
, s
->gc
, None
);
2066 /* Draw a box around glyph string S. */
2069 x_draw_glyph_string_box (struct glyph_string
*s
)
2071 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
2072 int left_p
, right_p
;
2073 struct glyph
*last_glyph
;
2074 XRectangle clip_rect
;
2076 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
2077 ? WINDOW_RIGHT_EDGE_X (s
->w
)
2078 : window_box_right (s
->w
, s
->area
));
2080 /* The glyph that may have a right box line. */
2081 last_glyph
= (s
->cmp
|| s
->img
2083 : s
->first_glyph
+ s
->nchars
- 1);
2085 width
= eabs (s
->face
->box_line_width
);
2086 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
2088 right_x
= (s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
2090 : min (last_x
, s
->x
+ s
->background_width
) - 1);
2092 bottom_y
= top_y
+ s
->height
- 1;
2094 left_p
= (s
->first_glyph
->left_box_line_p
2095 || (s
->hl
== DRAW_MOUSE_FACE
2097 || s
->prev
->hl
!= s
->hl
)));
2098 right_p
= (last_glyph
->right_box_line_p
2099 || (s
->hl
== DRAW_MOUSE_FACE
2101 || s
->next
->hl
!= s
->hl
)));
2103 get_glyph_string_clip_rect (s
, &clip_rect
);
2105 if (s
->face
->box
== FACE_SIMPLE_BOX
)
2106 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2107 left_p
, right_p
, &clip_rect
);
2110 x_setup_relief_colors (s
);
2111 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
2112 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
2117 /* Draw foreground of image glyph string S. */
2120 x_draw_image_foreground (struct glyph_string
*s
)
2123 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2125 /* If first glyph of S has a left box line, start drawing it to the
2126 right of that line. */
2127 if (s
->face
->box
!= FACE_NO_BOX
2128 && s
->first_glyph
->left_box_line_p
2130 x
+= eabs (s
->face
->box_line_width
);
2132 /* If there is a margin around the image, adjust x- and y-position
2134 if (s
->slice
.x
== 0)
2135 x
+= s
->img
->hmargin
;
2136 if (s
->slice
.y
== 0)
2137 y
+= s
->img
->vmargin
;
2143 /* We can't set both a clip mask and use XSetClipRectangles
2144 because the latter also sets a clip mask. We also can't
2145 trust on the shape extension to be available
2146 (XShapeCombineRegion). So, compute the rectangle to draw
2148 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2151 XRectangle clip_rect
, image_rect
, r
;
2153 xgcv
.clip_mask
= s
->img
->mask
;
2154 xgcv
.clip_x_origin
= x
;
2155 xgcv
.clip_y_origin
= y
;
2156 xgcv
.function
= GXcopy
;
2157 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2159 get_glyph_string_clip_rect (s
, &clip_rect
);
2162 image_rect
.width
= s
->slice
.width
;
2163 image_rect
.height
= s
->slice
.height
;
2164 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2165 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2166 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2167 r
.width
, r
.height
, r
.x
, r
.y
);
2171 XRectangle clip_rect
, image_rect
, r
;
2173 get_glyph_string_clip_rect (s
, &clip_rect
);
2176 image_rect
.width
= s
->slice
.width
;
2177 image_rect
.height
= s
->slice
.height
;
2178 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2179 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2180 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2181 r
.width
, r
.height
, r
.x
, r
.y
);
2183 /* When the image has a mask, we can expect that at
2184 least part of a mouse highlight or a block cursor will
2185 be visible. If the image doesn't have a mask, make
2186 a block cursor visible by drawing a rectangle around
2187 the image. I believe it's looking better if we do
2188 nothing here for mouse-face. */
2189 if (s
->hl
== DRAW_CURSOR
)
2191 int r
= s
->img
->relief
;
2193 XDrawRectangle (s
->display
, s
->window
, s
->gc
,
2195 s
->slice
.width
+ r
*2 - 1,
2196 s
->slice
.height
+ r
*2 - 1);
2201 /* Draw a rectangle if image could not be loaded. */
2202 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
2203 s
->slice
.width
- 1, s
->slice
.height
- 1);
2207 /* Draw a relief around the image glyph string S. */
2210 x_draw_image_relief (struct glyph_string
*s
)
2212 int x0
, y0
, x1
, y1
, thick
, raised_p
, extra
;
2215 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2217 /* If first glyph of S has a left box line, start drawing it to the
2218 right of that line. */
2219 if (s
->face
->box
!= FACE_NO_BOX
2220 && s
->first_glyph
->left_box_line_p
2222 x
+= eabs (s
->face
->box_line_width
);
2224 /* If there is a margin around the image, adjust x- and y-position
2226 if (s
->slice
.x
== 0)
2227 x
+= s
->img
->hmargin
;
2228 if (s
->slice
.y
== 0)
2229 y
+= s
->img
->vmargin
;
2231 if (s
->hl
== DRAW_IMAGE_SUNKEN
2232 || s
->hl
== DRAW_IMAGE_RAISED
)
2234 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
2235 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
2239 thick
= eabs (s
->img
->relief
);
2240 raised_p
= s
->img
->relief
> 0;
2243 extra
= s
->face
->id
== TOOL_BAR_FACE_ID
2244 ? XINT (Vtool_bar_button_margin
) : 0;
2246 x0
= x
- thick
- extra
;
2247 y0
= y
- thick
- extra
;
2248 x1
= x
+ s
->slice
.width
+ thick
- 1 + extra
;
2249 y1
= y
+ s
->slice
.height
+ thick
- 1 + extra
;
2251 x_setup_relief_colors (s
);
2252 get_glyph_string_clip_rect (s
, &r
);
2253 x_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
,
2255 s
->slice
.y
+ s
->slice
.height
== s
->img
->height
,
2257 s
->slice
.x
+ s
->slice
.width
== s
->img
->width
,
2262 /* Draw the foreground of image glyph string S to PIXMAP. */
2265 x_draw_image_foreground_1 (struct glyph_string
*s
, Pixmap pixmap
)
2268 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2270 /* If first glyph of S has a left box line, start drawing it to the
2271 right of that line. */
2272 if (s
->face
->box
!= FACE_NO_BOX
2273 && s
->first_glyph
->left_box_line_p
2275 x
+= eabs (s
->face
->box_line_width
);
2277 /* If there is a margin around the image, adjust x- and y-position
2279 if (s
->slice
.x
== 0)
2280 x
+= s
->img
->hmargin
;
2281 if (s
->slice
.y
== 0)
2282 y
+= s
->img
->vmargin
;
2288 /* We can't set both a clip mask and use XSetClipRectangles
2289 because the latter also sets a clip mask. We also can't
2290 trust on the shape extension to be available
2291 (XShapeCombineRegion). So, compute the rectangle to draw
2293 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2297 xgcv
.clip_mask
= s
->img
->mask
;
2298 xgcv
.clip_x_origin
= x
- s
->slice
.x
;
2299 xgcv
.clip_y_origin
= y
- s
->slice
.y
;
2300 xgcv
.function
= GXcopy
;
2301 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2303 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2304 s
->slice
.x
, s
->slice
.y
,
2305 s
->slice
.width
, s
->slice
.height
, x
, y
);
2306 XSetClipMask (s
->display
, s
->gc
, None
);
2310 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2311 s
->slice
.x
, s
->slice
.y
,
2312 s
->slice
.width
, s
->slice
.height
, x
, y
);
2314 /* When the image has a mask, we can expect that at
2315 least part of a mouse highlight or a block cursor will
2316 be visible. If the image doesn't have a mask, make
2317 a block cursor visible by drawing a rectangle around
2318 the image. I believe it's looking better if we do
2319 nothing here for mouse-face. */
2320 if (s
->hl
== DRAW_CURSOR
)
2322 int r
= s
->img
->relief
;
2324 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
- r
, y
- r
,
2325 s
->slice
.width
+ r
*2 - 1,
2326 s
->slice
.height
+ r
*2 - 1);
2331 /* Draw a rectangle if image could not be loaded. */
2332 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
2333 s
->slice
.width
- 1, s
->slice
.height
- 1);
2337 /* Draw part of the background of glyph string S. X, Y, W, and H
2338 give the rectangle to draw. */
2341 x_draw_glyph_string_bg_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
2345 /* Fill background with a stipple pattern. */
2346 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2347 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2348 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2351 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2355 /* Draw image glyph string S.
2358 s->x +-------------------------
2361 | +-------------------------
2364 | | +-------------------
2370 x_draw_image_glyph_string (struct glyph_string
*s
)
2372 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
2373 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2375 Pixmap pixmap
= None
;
2378 if (s
->slice
.y
== 0)
2379 height
-= box_line_vwidth
;
2380 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
2381 height
-= box_line_vwidth
;
2383 /* Fill background with face under the image. Do it only if row is
2384 taller than image or if image has a clip mask to reduce
2386 s
->stippled_p
= s
->face
->stipple
!= 0;
2387 if (height
> s
->slice
.height
2391 || s
->img
->pixmap
== 0
2392 || s
->width
!= s
->background_width
)
2396 /* Create a pixmap as large as the glyph string. Fill it
2397 with the background color. Copy the image to it, using
2398 its mask. Copy the temporary pixmap to the display. */
2399 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2400 int depth
= DefaultDepthOfScreen (screen
);
2402 /* Create a pixmap as large as the glyph string. */
2403 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2404 s
->background_width
,
2407 /* Don't clip in the following because we're working on the
2409 XSetClipMask (s
->display
, s
->gc
, None
);
2411 /* Fill the pixmap with the background color/stipple. */
2414 /* Fill background with a stipple pattern. */
2415 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2416 XSetTSOrigin (s
->display
, s
->gc
, - s
->x
, - s
->y
);
2417 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2418 0, 0, s
->background_width
, s
->height
);
2419 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2420 XSetTSOrigin (s
->display
, s
->gc
, 0, 0);
2425 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2427 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2428 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2429 0, 0, s
->background_width
, s
->height
);
2430 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2438 if (s
->first_glyph
->left_box_line_p
2440 x
+= box_line_hwidth
;
2442 if (s
->slice
.y
== 0)
2443 y
+= box_line_vwidth
;
2445 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
2448 s
->background_filled_p
= 1;
2451 /* Draw the foreground. */
2454 x_draw_image_foreground_1 (s
, pixmap
);
2455 x_set_glyph_string_clipping (s
);
2456 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
2457 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
2458 XFreePixmap (s
->display
, pixmap
);
2461 x_draw_image_foreground (s
);
2463 /* If we must draw a relief around the image, do it. */
2465 || s
->hl
== DRAW_IMAGE_RAISED
2466 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2467 x_draw_image_relief (s
);
2471 /* Draw stretch glyph string S. */
2474 x_draw_stretch_glyph_string (struct glyph_string
*s
)
2476 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2478 if (s
->hl
== DRAW_CURSOR
2479 && !x_stretch_cursor_p
)
2481 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
2482 wide as the stretch glyph. */
2483 int width
, background_width
= s
->background_width
;
2486 if (!s
->row
->reversed_p
)
2488 int left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2492 background_width
-= left_x
- x
;
2498 /* In R2L rows, draw the cursor on the right edge of the
2500 int right_x
= window_box_right_offset (s
->w
, TEXT_AREA
);
2502 if (x
+ background_width
> right_x
)
2503 background_width
-= x
- right_x
;
2504 x
+= background_width
;
2506 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
2507 if (s
->row
->reversed_p
)
2511 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
2513 /* Clear rest using the GC of the original non-cursor face. */
2514 if (width
< background_width
)
2517 int w
= background_width
- width
, h
= s
->height
;
2521 if (!s
->row
->reversed_p
)
2525 if (s
->row
->mouse_face_p
2526 && cursor_in_mouse_face_p (s
->w
))
2528 x_set_mouse_face_gc (s
);
2534 get_glyph_string_clip_rect (s
, &r
);
2535 XSetClipRectangles (s
->display
, gc
, 0, 0, &r
, 1, Unsorted
);
2537 if (s
->face
->stipple
)
2539 /* Fill background with a stipple pattern. */
2540 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2541 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2542 XSetFillStyle (s
->display
, gc
, FillSolid
);
2547 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
2548 XSetForeground (s
->display
, gc
, xgcv
.background
);
2549 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2550 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
2554 else if (!s
->background_filled_p
)
2556 int background_width
= s
->background_width
;
2557 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2559 /* Don't draw into left margin, fringe or scrollbar area
2560 except for header line and mode line. */
2561 if (x
< left_x
&& !s
->row
->mode_line_p
)
2563 background_width
-= left_x
- x
;
2566 if (background_width
> 0)
2567 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2570 s
->background_filled_p
= 1;
2574 /* Draw glyph string S. */
2577 x_draw_glyph_string (struct glyph_string
*s
)
2579 int relief_drawn_p
= 0;
2581 /* If S draws into the background of its successors, draw the
2582 background of the successors first so that S can draw into it.
2583 This makes S->next use XDrawString instead of XDrawImageString. */
2584 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2587 struct glyph_string
*next
;
2589 for (width
= 0, next
= s
->next
;
2590 next
&& width
< s
->right_overhang
;
2591 width
+= next
->width
, next
= next
->next
)
2592 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
2594 x_set_glyph_string_gc (next
);
2595 x_set_glyph_string_clipping (next
);
2596 if (next
->first_glyph
->type
== STRETCH_GLYPH
)
2597 x_draw_stretch_glyph_string (next
);
2599 x_draw_glyph_string_background (next
, 1);
2600 next
->num_clips
= 0;
2604 /* Set up S->gc, set clipping and draw S. */
2605 x_set_glyph_string_gc (s
);
2607 /* Draw relief (if any) in advance for char/composition so that the
2608 glyph string can be drawn over it. */
2609 if (!s
->for_overlaps
2610 && s
->face
->box
!= FACE_NO_BOX
2611 && (s
->first_glyph
->type
== CHAR_GLYPH
2612 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2615 x_set_glyph_string_clipping (s
);
2616 x_draw_glyph_string_background (s
, 1);
2617 x_draw_glyph_string_box (s
);
2618 x_set_glyph_string_clipping (s
);
2621 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
2623 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2624 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
2625 /* We must clip just this glyph. left_overhang part has already
2626 drawn when s->prev was drawn, and right_overhang part will be
2627 drawn later when s->next is drawn. */
2628 x_set_glyph_string_clipping_exactly (s
, s
);
2630 x_set_glyph_string_clipping (s
);
2632 switch (s
->first_glyph
->type
)
2635 x_draw_image_glyph_string (s
);
2639 x_draw_stretch_glyph_string (s
);
2643 if (s
->for_overlaps
)
2644 s
->background_filled_p
= 1;
2646 x_draw_glyph_string_background (s
, 0);
2647 x_draw_glyph_string_foreground (s
);
2650 case COMPOSITE_GLYPH
:
2651 if (s
->for_overlaps
|| (s
->cmp_from
> 0
2652 && ! s
->first_glyph
->u
.cmp
.automatic
))
2653 s
->background_filled_p
= 1;
2655 x_draw_glyph_string_background (s
, 1);
2656 x_draw_composite_glyph_string_foreground (s
);
2663 if (!s
->for_overlaps
)
2665 /* Draw underline. */
2666 if (s
->face
->underline_p
)
2668 unsigned long thickness
, position
;
2671 if (s
->prev
&& s
->prev
->face
->underline_p
)
2673 /* We use the same underline style as the previous one. */
2674 thickness
= s
->prev
->underline_thickness
;
2675 position
= s
->prev
->underline_position
;
2679 /* Get the underline thickness. Default is 1 pixel. */
2680 if (s
->font
&& s
->font
->underline_thickness
> 0)
2681 thickness
= s
->font
->underline_thickness
;
2684 if (x_underline_at_descent_line
)
2685 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
2688 /* Get the underline position. This is the recommended
2689 vertical offset in pixels from the baseline to the top of
2690 the underline. This is a signed value according to the
2691 specs, and its default is
2693 ROUND ((maximum descent) / 2), with
2694 ROUND(x) = floor (x + 0.5) */
2696 if (x_use_underline_position_properties
2697 && s
->font
&& s
->font
->underline_position
>= 0)
2698 position
= s
->font
->underline_position
;
2700 position
= (s
->font
->descent
+ 1) / 2;
2702 position
= underline_minimum_offset
;
2704 position
= max (position
, underline_minimum_offset
);
2706 /* Check the sanity of thickness and position. We should
2707 avoid drawing underline out of the current line area. */
2708 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
2709 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
2710 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
2711 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
2712 s
->underline_thickness
= thickness
;
2713 s
->underline_position
= position
;
2714 y
= s
->ybase
+ position
;
2715 if (s
->face
->underline_defaulted_p
)
2716 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2717 s
->x
, y
, s
->width
, thickness
);
2721 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2722 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
2723 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2724 s
->x
, y
, s
->width
, thickness
);
2725 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2729 /* Draw overline. */
2730 if (s
->face
->overline_p
)
2732 unsigned long dy
= 0, h
= 1;
2734 if (s
->face
->overline_color_defaulted_p
)
2735 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2740 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2741 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
2742 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2744 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2748 /* Draw strike-through. */
2749 if (s
->face
->strike_through_p
)
2751 unsigned long h
= 1;
2752 unsigned long dy
= (s
->height
- h
) / 2;
2754 if (s
->face
->strike_through_color_defaulted_p
)
2755 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2760 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2761 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
2762 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2764 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2768 /* Draw relief if not yet drawn. */
2769 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2770 x_draw_glyph_string_box (s
);
2774 struct glyph_string
*prev
;
2776 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2777 if (prev
->hl
!= s
->hl
2778 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2780 /* As prev was drawn while clipped to its own area, we
2781 must draw the right_overhang part using s->hl now. */
2782 enum draw_glyphs_face save
= prev
->hl
;
2785 x_set_glyph_string_gc (prev
);
2786 x_set_glyph_string_clipping_exactly (s
, prev
);
2787 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2788 x_draw_glyph_string_foreground (prev
);
2790 x_draw_composite_glyph_string_foreground (prev
);
2791 XSetClipMask (prev
->display
, prev
->gc
, None
);
2793 prev
->num_clips
= 0;
2799 struct glyph_string
*next
;
2801 for (next
= s
->next
; next
; next
= next
->next
)
2802 if (next
->hl
!= s
->hl
2803 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
2805 /* As next will be drawn while clipped to its own area,
2806 we must draw the left_overhang part using s->hl now. */
2807 enum draw_glyphs_face save
= next
->hl
;
2810 x_set_glyph_string_gc (next
);
2811 x_set_glyph_string_clipping_exactly (s
, next
);
2812 if (next
->first_glyph
->type
== CHAR_GLYPH
)
2813 x_draw_glyph_string_foreground (next
);
2815 x_draw_composite_glyph_string_foreground (next
);
2816 XSetClipMask (next
->display
, next
->gc
, None
);
2818 next
->num_clips
= 0;
2823 /* Reset clipping. */
2824 XSetClipMask (s
->display
, s
->gc
, None
);
2828 /* Shift display to make room for inserted glyphs. */
2831 x_shift_glyphs_for_insert (struct frame
*f
, int x
, int y
, int width
, int height
, int shift_by
)
2833 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
2834 f
->output_data
.x
->normal_gc
,
2835 x
, y
, width
, height
,
2839 /* Delete N glyphs at the nominal cursor position. Not implemented
2843 x_delete_glyphs (struct frame
*f
, register int n
)
2849 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
2850 If they are <= 0, this is probably an error. */
2853 x_clear_area (Display
*dpy
, Window window
, int x
, int y
, int width
, int height
, int exposures
)
2855 xassert (width
> 0 && height
> 0);
2856 XClearArea (dpy
, window
, x
, y
, width
, height
, exposures
);
2860 /* Clear an entire frame. */
2863 x_clear_frame (struct frame
*f
)
2865 /* Clearing the frame will erase any cursor, so mark them all as no
2867 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2868 output_cursor
.hpos
= output_cursor
.vpos
= 0;
2869 output_cursor
.x
= -1;
2871 /* We don't set the output cursor here because there will always
2872 follow an explicit cursor_to. */
2874 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
2876 /* We have to clear the scroll bars, too. If we have changed
2877 colors or something like that, then they should be notified. */
2878 x_scroll_bar_clear (f
);
2880 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
2881 /* Make sure scroll bars are redrawn. As they aren't redrawn by
2882 redisplay, do it here. */
2883 if (FRAME_GTK_WIDGET (f
))
2884 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
2887 XFlush (FRAME_X_DISPLAY (f
));
2894 /* Invert the middle quarter of the frame for .15 sec. */
2896 /* We use the select system call to do the waiting, so we have to make
2897 sure it's available. If it isn't, we just won't do visual bells. */
2899 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
2902 /* Subtract the `struct timeval' values X and Y, storing the result in
2903 *RESULT. Return 1 if the difference is negative, otherwise 0. */
2906 timeval_subtract (struct timeval
*result
, struct timeval x
, struct timeval y
)
2908 /* Perform the carry for the later subtraction by updating y. This
2909 is safer because on some systems the tv_sec member is unsigned. */
2910 if (x
.tv_usec
< y
.tv_usec
)
2912 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
2913 y
.tv_usec
-= 1000000 * nsec
;
2917 if (x
.tv_usec
- y
.tv_usec
> 1000000)
2919 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
2920 y
.tv_usec
+= 1000000 * nsec
;
2924 /* Compute the time remaining to wait. tv_usec is certainly
2926 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
2927 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
2929 /* Return indication of whether the result should be considered
2931 return x
.tv_sec
< y
.tv_sec
;
2935 XTflash (struct frame
*f
)
2941 /* Use Gdk routines to draw. This way, we won't draw over scroll bars
2942 when the scroll bars and the edit widget share the same X window. */
2943 GdkWindow
*window
= gtk_widget_get_window (FRAME_GTK_WIDGET (f
));
2946 vals
.foreground
.pixel
= (FRAME_FOREGROUND_PIXEL (f
)
2947 ^ FRAME_BACKGROUND_PIXEL (f
));
2948 vals
.function
= GDK_XOR
;
2949 gc
= gdk_gc_new_with_values (window
,
2950 &vals
, GDK_GC_FUNCTION
| GDK_GC_FOREGROUND
);
2951 #define XFillRectangle(d, win, gc, x, y, w, h) \
2952 gdk_draw_rectangle (window, gc, TRUE, x, y, w, h)
2956 /* Create a GC that will use the GXxor function to flip foreground
2957 pixels into background pixels. */
2961 values
.function
= GXxor
;
2962 values
.foreground
= (FRAME_FOREGROUND_PIXEL (f
)
2963 ^ FRAME_BACKGROUND_PIXEL (f
));
2965 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2966 GCFunction
| GCForeground
, &values
);
2970 /* Get the height not including a menu bar widget. */
2971 int height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, FRAME_LINES (f
));
2972 /* Height of each line to flash. */
2973 int flash_height
= FRAME_LINE_HEIGHT (f
);
2974 /* These will be the left and right margins of the rectangles. */
2975 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
2976 int flash_right
= FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
2980 /* Don't flash the area between a scroll bar and the frame
2981 edge it is next to. */
2982 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f
))
2984 case vertical_scroll_bar_left
:
2985 flash_left
+= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
2988 case vertical_scroll_bar_right
:
2989 flash_right
-= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
2996 width
= flash_right
- flash_left
;
2998 /* If window is tall, flash top and bottom line. */
2999 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3001 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3003 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3004 + FRAME_TOP_MARGIN_HEIGHT (f
)),
3005 width
, flash_height
);
3006 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3008 (height
- flash_height
3009 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3010 width
, flash_height
);
3014 /* If it is short, flash it all. */
3015 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3016 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3017 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3022 struct timeval wakeup
;
3024 EMACS_GET_TIME (wakeup
);
3026 /* Compute time to wait until, propagating carry from usecs. */
3027 wakeup
.tv_usec
+= 150000;
3028 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
3029 wakeup
.tv_usec
%= 1000000;
3031 /* Keep waiting until past the time wakeup or any input gets
3033 while (! detect_input_pending ())
3035 struct timeval current
;
3036 struct timeval timeout
;
3038 EMACS_GET_TIME (current
);
3040 /* Break if result would be negative. */
3041 if (timeval_subtract (¤t
, wakeup
, current
))
3044 /* How long `select' should wait. */
3046 timeout
.tv_usec
= 10000;
3048 /* Try to wait that long--but we might wake up sooner. */
3049 select (0, NULL
, NULL
, NULL
, &timeout
);
3053 /* If window is tall, flash top and bottom line. */
3054 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3056 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3058 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3059 + FRAME_TOP_MARGIN_HEIGHT (f
)),
3060 width
, flash_height
);
3061 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3063 (height
- flash_height
3064 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3065 width
, flash_height
);
3068 /* If it is short, flash it all. */
3069 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3070 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3071 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3074 g_object_unref (G_OBJECT (gc
));
3075 #undef XFillRectangle
3077 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
3086 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
3090 XTtoggle_invisible_pointer (FRAME_PTR f
, int invisible
)
3095 if (FRAME_X_DISPLAY_INFO (f
)->invisible_cursor
!= 0)
3096 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3097 FRAME_X_DISPLAY_INFO (f
)->invisible_cursor
);
3100 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3101 f
->output_data
.x
->current_cursor
);
3102 f
->pointer_invisible
= invisible
;
3107 /* Make audible bell. */
3110 XTring_bell (struct frame
*f
)
3112 if (FRAME_X_DISPLAY (f
))
3114 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
3121 XBell (FRAME_X_DISPLAY (f
), 0);
3122 XFlush (FRAME_X_DISPLAY (f
));
3129 /* Specify how many text lines, from the top of the window,
3130 should be affected by insert-lines and delete-lines operations.
3131 This, and those operations, are used only within an update
3132 that is bounded by calls to x_update_begin and x_update_end. */
3135 XTset_terminal_window (struct frame
*f
, int n
)
3137 /* This function intentionally left blank. */
3142 /***********************************************************************
3144 ***********************************************************************/
3146 /* Perform an insert-lines or delete-lines operation, inserting N
3147 lines or deleting -N lines at vertical position VPOS. */
3150 x_ins_del_lines (struct frame
*f
, int vpos
, int n
)
3156 /* Scroll part of the display as described by RUN. */
3159 x_scroll_run (struct window
*w
, struct run
*run
)
3161 struct frame
*f
= XFRAME (w
->frame
);
3162 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
3164 /* Get frame-relative bounding box of the text display area of W,
3165 without mode lines. Include in this box the left and right
3167 window_box (w
, -1, &x
, &y
, &width
, &height
);
3169 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
3170 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
3171 bottom_y
= y
+ height
;
3175 /* Scrolling up. Make sure we don't copy part of the mode
3176 line at the bottom. */
3177 if (from_y
+ run
->height
> bottom_y
)
3178 height
= bottom_y
- from_y
;
3180 height
= run
->height
;
3184 /* Scolling down. Make sure we don't copy over the mode line.
3186 if (to_y
+ run
->height
> bottom_y
)
3187 height
= bottom_y
- to_y
;
3189 height
= run
->height
;
3194 /* Cursor off. Will be switched on again in x_update_window_end. */
3198 XCopyArea (FRAME_X_DISPLAY (f
),
3199 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
3200 f
->output_data
.x
->normal_gc
,
3210 /***********************************************************************
3212 ***********************************************************************/
3216 frame_highlight (struct frame
*f
)
3218 /* We used to only do this if Vx_no_window_manager was non-nil, but
3219 the ICCCM (section 4.1.6) says that the window's border pixmap
3220 and border pixel are window attributes which are "private to the
3221 client", so we can always change it to whatever we want. */
3223 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3224 f
->output_data
.x
->border_pixel
);
3226 x_update_cursor (f
, 1);
3227 x_set_frame_alpha (f
);
3231 frame_unhighlight (struct frame
*f
)
3233 /* We used to only do this if Vx_no_window_manager was non-nil, but
3234 the ICCCM (section 4.1.6) says that the window's border pixmap
3235 and border pixel are window attributes which are "private to the
3236 client", so we can always change it to whatever we want. */
3238 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3239 f
->output_data
.x
->border_tile
);
3241 x_update_cursor (f
, 1);
3242 x_set_frame_alpha (f
);
3245 /* The focus has changed. Update the frames as necessary to reflect
3246 the new situation. Note that we can't change the selected frame
3247 here, because the Lisp code we are interrupting might become confused.
3248 Each event gets marked with the frame in which it occurred, so the
3249 Lisp code can tell when the switch took place by examining the events. */
3252 x_new_focus_frame (struct x_display_info
*dpyinfo
, struct frame
*frame
)
3254 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
3256 if (frame
!= dpyinfo
->x_focus_frame
)
3258 /* Set this before calling other routines, so that they see
3259 the correct value of x_focus_frame. */
3260 dpyinfo
->x_focus_frame
= frame
;
3262 if (old_focus
&& old_focus
->auto_lower
)
3263 x_lower_frame (old_focus
);
3265 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
3266 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
3268 pending_autoraise_frame
= 0;
3271 x_frame_rehighlight (dpyinfo
);
3274 /* Handle FocusIn and FocusOut state changes for FRAME.
3275 If FRAME has focus and there exists more than one frame, puts
3276 a FOCUS_IN_EVENT into *BUFP. */
3279 x_focus_changed (int type
, int state
, struct x_display_info
*dpyinfo
, struct frame
*frame
, struct input_event
*bufp
)
3281 if (type
== FocusIn
)
3283 if (dpyinfo
->x_focus_event_frame
!= frame
)
3285 x_new_focus_frame (dpyinfo
, frame
);
3286 dpyinfo
->x_focus_event_frame
= frame
;
3288 /* Don't stop displaying the initial startup message
3289 for a switch-frame event we don't need. */
3290 if (NILP (Vterminal_frame
)
3291 && CONSP (Vframe_list
)
3292 && !NILP (XCDR (Vframe_list
)))
3294 bufp
->kind
= FOCUS_IN_EVENT
;
3295 XSETFRAME (bufp
->frame_or_window
, frame
);
3299 frame
->output_data
.x
->focus_state
|= state
;
3302 if (FRAME_XIC (frame
))
3303 XSetICFocus (FRAME_XIC (frame
));
3306 else if (type
== FocusOut
)
3308 frame
->output_data
.x
->focus_state
&= ~state
;
3310 if (dpyinfo
->x_focus_event_frame
== frame
)
3312 dpyinfo
->x_focus_event_frame
= 0;
3313 x_new_focus_frame (dpyinfo
, 0);
3317 if (FRAME_XIC (frame
))
3318 XUnsetICFocus (FRAME_XIC (frame
));
3320 if (frame
->pointer_invisible
)
3321 XTtoggle_invisible_pointer (frame
, 0);
3325 /* The focus may have changed. Figure out if it is a real focus change,
3326 by checking both FocusIn/Out and Enter/LeaveNotify events.
3328 Returns FOCUS_IN_EVENT event in *BUFP. */
3331 x_detect_focus_change (struct x_display_info
*dpyinfo
, XEvent
*event
, struct input_event
*bufp
)
3333 struct frame
*frame
;
3335 frame
= x_any_window_to_frame (dpyinfo
, event
->xany
.window
);
3339 switch (event
->type
)
3344 struct frame
*focus_frame
= dpyinfo
->x_focus_event_frame
;
3346 = focus_frame
? focus_frame
->output_data
.x
->focus_state
: 0;
3348 if (event
->xcrossing
.detail
!= NotifyInferior
3349 && event
->xcrossing
.focus
3350 && ! (focus_state
& FOCUS_EXPLICIT
))
3351 x_focus_changed ((event
->type
== EnterNotify
? FocusIn
: FocusOut
),
3353 dpyinfo
, frame
, bufp
);
3359 x_focus_changed (event
->type
,
3360 (event
->xfocus
.detail
== NotifyPointer
?
3361 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
3362 dpyinfo
, frame
, bufp
);
3366 if (event
->xclient
.message_type
== dpyinfo
->Xatom_XEMBED
)
3368 enum xembed_message msg
= event
->xclient
.data
.l
[1];
3369 x_focus_changed ((msg
== XEMBED_FOCUS_IN
? FocusIn
: FocusOut
),
3370 FOCUS_EXPLICIT
, dpyinfo
, frame
, bufp
);
3377 /* Handle an event saying the mouse has moved out of an Emacs frame. */
3380 x_mouse_leave (struct x_display_info
*dpyinfo
)
3382 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
3385 /* The focus has changed, or we have redirected a frame's focus to
3386 another frame (this happens when a frame uses a surrogate
3387 mini-buffer frame). Shift the highlight as appropriate.
3389 The FRAME argument doesn't necessarily have anything to do with which
3390 frame is being highlighted or un-highlighted; we only use it to find
3391 the appropriate X display info. */
3394 XTframe_rehighlight (struct frame
*frame
)
3396 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
3400 x_frame_rehighlight (struct x_display_info
*dpyinfo
)
3402 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
3404 if (dpyinfo
->x_focus_frame
)
3406 dpyinfo
->x_highlight_frame
3407 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
3408 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
3409 : dpyinfo
->x_focus_frame
);
3410 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
3412 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
3413 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
3417 dpyinfo
->x_highlight_frame
= 0;
3419 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
3422 frame_unhighlight (old_highlight
);
3423 if (dpyinfo
->x_highlight_frame
)
3424 frame_highlight (dpyinfo
->x_highlight_frame
);
3430 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
3432 /* Initialize mode_switch_bit and modifier_meaning. */
3434 x_find_modifier_meanings (struct x_display_info
*dpyinfo
)
3436 int min_code
, max_code
;
3439 XModifierKeymap
*mods
;
3441 dpyinfo
->meta_mod_mask
= 0;
3442 dpyinfo
->shift_lock_mask
= 0;
3443 dpyinfo
->alt_mod_mask
= 0;
3444 dpyinfo
->super_mod_mask
= 0;
3445 dpyinfo
->hyper_mod_mask
= 0;
3447 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
3449 syms
= XGetKeyboardMapping (dpyinfo
->display
,
3450 min_code
, max_code
- min_code
+ 1,
3452 mods
= XGetModifierMapping (dpyinfo
->display
);
3454 /* Scan the modifier table to see which modifier bits the Meta and
3455 Alt keysyms are on. */
3457 int row
, col
; /* The row and column in the modifier table. */
3458 int found_alt_or_meta
;
3460 for (row
= 3; row
< 8; row
++)
3462 found_alt_or_meta
= 0;
3463 for (col
= 0; col
< mods
->max_keypermod
; col
++)
3465 KeyCode code
= mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
3467 /* Zeroes are used for filler. Skip them. */
3471 /* Are any of this keycode's keysyms a meta key? */
3475 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
3477 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
3483 found_alt_or_meta
= 1;
3484 dpyinfo
->meta_mod_mask
|= (1 << row
);
3489 found_alt_or_meta
= 1;
3490 dpyinfo
->alt_mod_mask
|= (1 << row
);
3495 if (!found_alt_or_meta
)
3496 dpyinfo
->hyper_mod_mask
|= (1 << row
);
3497 code_col
= syms_per_code
;
3498 col
= mods
->max_keypermod
;
3503 if (!found_alt_or_meta
)
3504 dpyinfo
->super_mod_mask
|= (1 << row
);
3505 code_col
= syms_per_code
;
3506 col
= mods
->max_keypermod
;
3510 /* Ignore this if it's not on the lock modifier. */
3511 if (!found_alt_or_meta
&& ((1 << row
) == LockMask
))
3512 dpyinfo
->shift_lock_mask
= LockMask
;
3513 code_col
= syms_per_code
;
3514 col
= mods
->max_keypermod
;
3523 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
3524 if (! dpyinfo
->meta_mod_mask
)
3526 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
3527 dpyinfo
->alt_mod_mask
= 0;
3530 /* If some keys are both alt and meta,
3531 make them just meta, not alt. */
3532 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
3534 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
3537 XFree ((char *) syms
);
3538 XFreeModifiermap (mods
);
3541 /* Convert between the modifier bits X uses and the modifier bits
3545 x_x_to_emacs_modifiers (struct x_display_info
*dpyinfo
, unsigned int state
)
3547 EMACS_UINT mod_meta
= meta_modifier
;
3548 EMACS_UINT mod_alt
= alt_modifier
;
3549 EMACS_UINT mod_hyper
= hyper_modifier
;
3550 EMACS_UINT mod_super
= super_modifier
;
3553 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3554 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
3555 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3556 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
3557 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3558 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
3559 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3560 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
3563 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
3564 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
3565 | ((state
& dpyinfo
->meta_mod_mask
) ? mod_meta
: 0)
3566 | ((state
& dpyinfo
->alt_mod_mask
) ? mod_alt
: 0)
3567 | ((state
& dpyinfo
->super_mod_mask
) ? mod_super
: 0)
3568 | ((state
& dpyinfo
->hyper_mod_mask
) ? mod_hyper
: 0));
3572 x_emacs_to_x_modifiers (struct x_display_info
*dpyinfo
, unsigned int state
)
3574 EMACS_UINT mod_meta
= meta_modifier
;
3575 EMACS_UINT mod_alt
= alt_modifier
;
3576 EMACS_UINT mod_hyper
= hyper_modifier
;
3577 EMACS_UINT mod_super
= super_modifier
;
3581 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3582 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
3583 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3584 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
3585 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3586 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
3587 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3588 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
3591 return ( ((state
& mod_alt
) ? dpyinfo
->alt_mod_mask
: 0)
3592 | ((state
& mod_super
) ? dpyinfo
->super_mod_mask
: 0)
3593 | ((state
& mod_hyper
) ? dpyinfo
->hyper_mod_mask
: 0)
3594 | ((state
& shift_modifier
) ? ShiftMask
: 0)
3595 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
3596 | ((state
& mod_meta
) ? dpyinfo
->meta_mod_mask
: 0));
3599 /* Convert a keysym to its name. */
3602 x_get_keysym_name (int keysym
)
3607 value
= XKeysymToString (keysym
);
3615 /* Mouse clicks and mouse movement. Rah. */
3617 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3619 If the event is a button press, then note that we have grabbed
3623 construct_mouse_click (struct input_event
*result
, XButtonEvent
*event
, struct frame
*f
)
3625 /* Make the event type NO_EVENT; we'll change that when we decide
3627 result
->kind
= MOUSE_CLICK_EVENT
;
3628 result
->code
= event
->button
- Button1
;
3629 result
->timestamp
= event
->time
;
3630 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
3632 | (event
->type
== ButtonRelease
3636 XSETINT (result
->x
, event
->x
);
3637 XSETINT (result
->y
, event
->y
);
3638 XSETFRAME (result
->frame_or_window
, f
);
3644 /* Function to report a mouse movement to the mainstream Emacs code.
3645 The input handler calls this.
3647 We have received a mouse movement event, which is given in *event.
3648 If the mouse is over a different glyph than it was last time, tell
3649 the mainstream emacs code by setting mouse_moved. If not, ask for
3650 another motion event, so we can check again the next time it moves. */
3652 static XMotionEvent last_mouse_motion_event
;
3653 static Lisp_Object last_mouse_motion_frame
;
3656 note_mouse_movement (FRAME_PTR frame
, XMotionEvent
*event
)
3658 last_mouse_movement_time
= event
->time
;
3659 last_mouse_motion_event
= *event
;
3660 XSETFRAME (last_mouse_motion_frame
, frame
);
3662 if (!FRAME_X_OUTPUT (frame
))
3665 if (event
->window
!= FRAME_X_WINDOW (frame
))
3667 frame
->mouse_moved
= 1;
3668 last_mouse_scroll_bar
= Qnil
;
3669 note_mouse_highlight (frame
, -1, -1);
3670 last_mouse_glyph_frame
= 0;
3675 /* Has the mouse moved off the glyph it was on at the last sighting? */
3676 if (frame
!= last_mouse_glyph_frame
3677 || event
->x
< last_mouse_glyph
.x
3678 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
3679 || event
->y
< last_mouse_glyph
.y
3680 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
3682 frame
->mouse_moved
= 1;
3683 last_mouse_scroll_bar
= Qnil
;
3684 note_mouse_highlight (frame
, event
->x
, event
->y
);
3685 /* Remember which glyph we're now on. */
3686 remember_mouse_glyph (frame
, event
->x
, event
->y
, &last_mouse_glyph
);
3687 last_mouse_glyph_frame
= frame
;
3695 /************************************************************************
3697 ************************************************************************/
3700 redo_mouse_highlight (void)
3702 if (!NILP (last_mouse_motion_frame
)
3703 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
3704 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
3705 last_mouse_motion_event
.x
,
3706 last_mouse_motion_event
.y
);
3711 /* Return the current position of the mouse.
3712 *FP should be a frame which indicates which display to ask about.
3714 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
3715 and *PART to the frame, window, and scroll bar part that the mouse
3716 is over. Set *X and *Y to the portion and whole of the mouse's
3717 position on the scroll bar.
3719 If the mouse movement started elsewhere, set *FP to the frame the
3720 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
3723 Set *TIME to the server time-stamp for the time at which the mouse
3724 was at this position.
3726 Don't store anything if we don't have a valid set of values to report.
3728 This clears the mouse_moved flag, so we can wait for the next mouse
3732 XTmouse_position (FRAME_PTR
*fp
, int insist
, Lisp_Object
*bar_window
, enum scroll_bar_part
*part
, Lisp_Object
*x
, Lisp_Object
*y
, long unsigned int *time
)
3738 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
3739 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3745 Window dummy_window
;
3748 Lisp_Object frame
, tail
;
3750 /* Clear the mouse-moved flag for every frame on this display. */
3751 FOR_EACH_FRAME (tail
, frame
)
3752 if (FRAME_X_P (XFRAME (frame
))
3753 && FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
3754 XFRAME (frame
)->mouse_moved
= 0;
3756 last_mouse_scroll_bar
= Qnil
;
3758 /* Figure out which root window we're on. */
3759 XQueryPointer (FRAME_X_DISPLAY (*fp
),
3760 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
3762 /* The root window which contains the pointer. */
3765 /* Trash which we can't trust if the pointer is on
3766 a different screen. */
3769 /* The position on that root window. */
3772 /* More trash we can't trust. */
3775 /* Modifier keys and pointer buttons, about which
3777 (unsigned int *) &dummy
);
3779 /* Now we have a position on the root; find the innermost window
3780 containing the pointer. */
3784 int parent_x
= 0, parent_y
= 0;
3788 /* XTranslateCoordinates can get errors if the window
3789 structure is changing at the same time this function
3790 is running. So at least we must not crash from them. */
3792 x_catch_errors (FRAME_X_DISPLAY (*fp
));
3794 if (FRAME_X_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
3795 && FRAME_LIVE_P (last_mouse_frame
))
3797 /* If mouse was grabbed on a frame, give coords for that frame
3798 even if the mouse is now outside it. */
3799 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3801 /* From-window, to-window. */
3802 root
, FRAME_X_WINDOW (last_mouse_frame
),
3804 /* From-position, to-position. */
3805 root_x
, root_y
, &win_x
, &win_y
,
3809 f1
= last_mouse_frame
;
3815 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3817 /* From-window, to-window. */
3820 /* From-position, to-position. */
3821 root_x
, root_y
, &win_x
, &win_y
,
3826 if (child
== None
|| child
== win
)
3829 /* We don't wan't to know the innermost window. We
3830 want the edit window. For non-Gtk+ the innermost
3831 window is the edit window. For Gtk+ it might not
3832 be. It might be the tool bar for example. */
3833 if (x_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
))
3841 /* Now we know that:
3842 win is the innermost window containing the pointer
3843 (XTC says it has no child containing the pointer),
3844 win_x and win_y are the pointer's position in it
3845 (XTC did this the last time through), and
3846 parent_x and parent_y are the pointer's position in win's parent.
3847 (They are what win_x and win_y were when win was child.
3848 If win is the root window, it has no parent, and
3849 parent_{x,y} are invalid, but that's okay, because we'll
3850 never use them in that case.) */
3853 /* We don't wan't to know the innermost window. We
3854 want the edit window. */
3855 f1
= x_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
3857 /* Is win one of our frames? */
3858 f1
= x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
3861 #ifdef USE_X_TOOLKIT
3862 /* If we end up with the menu bar window, say it's not
3865 && f1
->output_data
.x
->menubar_widget
3866 && win
== XtWindow (f1
->output_data
.x
->menubar_widget
))
3868 #endif /* USE_X_TOOLKIT */
3871 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
3874 x_uncatch_errors ();
3876 /* If not, is it one of our scroll bars? */
3879 struct scroll_bar
*bar
;
3881 bar
= x_window_to_scroll_bar (FRAME_X_DISPLAY (*fp
), win
);
3885 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3891 if (f1
== 0 && insist
> 0)
3892 f1
= SELECTED_FRAME ();
3896 /* Ok, we found a frame. Store all the values.
3897 last_mouse_glyph is a rectangle used to reduce the
3898 generation of mouse events. To not miss any motion
3899 events, we must divide the frame into rectangles of the
3900 size of the smallest character that could be displayed
3901 on it, i.e. into the same rectangles that matrices on
3902 the frame are divided into. */
3904 remember_mouse_glyph (f1
, win_x
, win_y
, &last_mouse_glyph
);
3905 last_mouse_glyph_frame
= f1
;
3910 XSETINT (*x
, win_x
);
3911 XSETINT (*y
, win_y
);
3912 *time
= last_mouse_movement_time
;
3922 /***********************************************************************
3924 ***********************************************************************/
3926 /* Scroll bar support. */
3928 /* Given an X window ID and a DISPLAY, find the struct scroll_bar which
3930 This can be called in GC, so we have to make sure to strip off mark
3933 static struct scroll_bar
*
3934 x_window_to_scroll_bar (Display
*display
, Window window_id
)
3938 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
3939 window_id
= (Window
) xg_get_scroll_id_for_window (display
, window_id
);
3940 #endif /* USE_GTK && USE_TOOLKIT_SCROLL_BARS */
3942 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
3944 Lisp_Object frame
, bar
, condemned
;
3946 frame
= XCAR (tail
);
3947 /* All elements of Vframe_list should be frames. */
3948 if (! FRAMEP (frame
))
3951 if (! FRAME_X_P (XFRAME (frame
)))
3954 /* Scan this frame's scroll bar list for a scroll bar with the
3956 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3957 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3958 /* This trick allows us to search both the ordinary and
3959 condemned scroll bar lists with one loop. */
3960 ! NILP (bar
) || (bar
= condemned
,
3963 bar
= XSCROLL_BAR (bar
)->next
)
3964 if (XSCROLL_BAR (bar
)->x_window
== window_id
&&
3965 FRAME_X_DISPLAY (XFRAME (frame
)) == display
)
3966 return XSCROLL_BAR (bar
);
3973 #if defined USE_LUCID
3975 /* Return the Lucid menu bar WINDOW is part of. Return null
3976 if WINDOW is not part of a menu bar. */
3979 x_window_to_menu_bar (Window window
)
3983 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
3985 if (FRAME_X_P (XFRAME (XCAR (tail
))))
3987 Lisp_Object frame
= XCAR (tail
);
3988 Widget menu_bar
= XFRAME (frame
)->output_data
.x
->menubar_widget
;
3990 if (menu_bar
&& xlwmenu_window_p (menu_bar
, window
))
3998 #endif /* USE_LUCID */
4001 /************************************************************************
4003 ************************************************************************/
4005 #ifdef USE_TOOLKIT_SCROLL_BARS
4007 static void x_scroll_bar_to_input_event (XEvent
*, struct input_event
*);
4008 static void x_send_scroll_bar_event (Lisp_Object
, int, int, int);
4009 static void x_create_toolkit_scroll_bar (struct frame
*,
4010 struct scroll_bar
*);
4011 static void x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*,
4015 /* Lisp window being scrolled. Set when starting to interact with
4016 a toolkit scroll bar, reset to nil when ending the interaction. */
4018 static Lisp_Object window_being_scrolled
;
4020 /* Last scroll bar part sent in xm_scroll_callback. */
4022 static int last_scroll_bar_part
;
4024 /* Whether this is an Xaw with arrow-scrollbars. This should imply
4025 that movements of 1/20 of the screen size are mapped to up/down. */
4028 /* Id of action hook installed for scroll bars. */
4030 static XtActionHookId action_hook_id
;
4032 static Boolean xaw3d_arrow_scroll
;
4034 /* Whether the drag scrolling maintains the mouse at the top of the
4035 thumb. If not, resizing the thumb needs to be done more carefully
4036 to avoid jerkyness. */
4038 static Boolean xaw3d_pick_top
;
4040 /* Action hook installed via XtAppAddActionHook when toolkit scroll
4041 bars are used.. The hook is responsible for detecting when
4042 the user ends an interaction with the scroll bar, and generates
4043 a `end-scroll' SCROLL_BAR_CLICK_EVENT' event if so. */
4046 xt_action_hook (Widget widget
, XtPointer client_data
, String action_name
,
4047 XEvent
*event
, String
*params
, Cardinal
*num_params
)
4050 const char *end_action
;
4053 scroll_bar_p
= XmIsScrollBar (widget
);
4054 end_action
= "Release";
4055 #else /* !USE_MOTIF i.e. use Xaw */
4056 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
4057 end_action
= "EndScroll";
4058 #endif /* USE_MOTIF */
4061 && strcmp (action_name
, end_action
) == 0
4062 && WINDOWP (window_being_scrolled
))
4066 x_send_scroll_bar_event (window_being_scrolled
,
4067 scroll_bar_end_scroll
, 0, 0);
4068 w
= XWINDOW (window_being_scrolled
);
4070 if (!NILP (XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
))
4072 XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
= Qnil
;
4073 /* The thumb size is incorrect while dragging: fix it. */
4074 set_vertical_scroll_bar (w
);
4076 window_being_scrolled
= Qnil
;
4077 last_scroll_bar_part
= -1;
4079 /* Xt timeouts no longer needed. */
4080 toolkit_scroll_bar_interaction
= 0;
4083 #endif /* not USE_GTK */
4085 /* A vector of windows used for communication between
4086 x_send_scroll_bar_event and x_scroll_bar_to_input_event. */
4088 static struct window
**scroll_bar_windows
;
4089 static int scroll_bar_windows_size
;
4092 /* Send a client message with message type Xatom_Scrollbar for a
4093 scroll action to the frame of WINDOW. PART is a value identifying
4094 the part of the scroll bar that was clicked on. PORTION is the
4095 amount to scroll of a whole of WHOLE. */
4098 x_send_scroll_bar_event (Lisp_Object window
, int part
, int portion
, int whole
)
4101 XClientMessageEvent
*ev
= (XClientMessageEvent
*) &event
;
4102 struct window
*w
= XWINDOW (window
);
4103 struct frame
*f
= XFRAME (w
->frame
);
4108 /* Construct a ClientMessage event to send to the frame. */
4109 ev
->type
= ClientMessage
;
4110 ev
->message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_Scrollbar
;
4111 ev
->display
= FRAME_X_DISPLAY (f
);
4112 ev
->window
= FRAME_X_WINDOW (f
);
4115 /* We can only transfer 32 bits in the XClientMessageEvent, which is
4116 not enough to store a pointer or Lisp_Object on a 64 bit system.
4117 So, store the window in scroll_bar_windows and pass the index
4118 into that array in the event. */
4119 for (i
= 0; i
< scroll_bar_windows_size
; ++i
)
4120 if (scroll_bar_windows
[i
] == NULL
)
4123 if (i
== scroll_bar_windows_size
)
4125 int new_size
= max (10, 2 * scroll_bar_windows_size
);
4126 size_t nbytes
= new_size
* sizeof *scroll_bar_windows
;
4127 size_t old_nbytes
= scroll_bar_windows_size
* sizeof *scroll_bar_windows
;
4129 scroll_bar_windows
= (struct window
**) xrealloc (scroll_bar_windows
,
4131 memset (&scroll_bar_windows
[i
], 0, nbytes
- old_nbytes
);
4132 scroll_bar_windows_size
= new_size
;
4135 scroll_bar_windows
[i
] = w
;
4136 ev
->data
.l
[0] = (long) i
;
4137 ev
->data
.l
[1] = (long) part
;
4138 ev
->data
.l
[2] = (long) 0;
4139 ev
->data
.l
[3] = (long) portion
;
4140 ev
->data
.l
[4] = (long) whole
;
4142 /* Make Xt timeouts work while the scroll bar is active. */
4143 toolkit_scroll_bar_interaction
= 1;
4144 #ifdef USE_X_TOOLKIT
4145 x_activate_timeout_atimer ();
4148 /* Setting the event mask to zero means that the message will
4149 be sent to the client that created the window, and if that
4150 window no longer exists, no event will be sent. */
4151 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
4156 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
4160 x_scroll_bar_to_input_event (XEvent
*event
, struct input_event
*ievent
)
4162 XClientMessageEvent
*ev
= (XClientMessageEvent
*) event
;
4167 w
= scroll_bar_windows
[ev
->data
.l
[0]];
4168 scroll_bar_windows
[ev
->data
.l
[0]] = NULL
;
4170 XSETWINDOW (window
, w
);
4171 f
= XFRAME (w
->frame
);
4173 ievent
->kind
= SCROLL_BAR_CLICK_EVENT
;
4174 ievent
->frame_or_window
= window
;
4177 ievent
->timestamp
= CurrentTime
;
4179 ievent
->timestamp
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
4181 ievent
->part
= ev
->data
.l
[1];
4182 ievent
->code
= ev
->data
.l
[2];
4183 ievent
->x
= make_number ((int) ev
->data
.l
[3]);
4184 ievent
->y
= make_number ((int) ev
->data
.l
[4]);
4185 ievent
->modifiers
= 0;
4191 /* Minimum and maximum values used for Motif scroll bars. */
4193 #define XM_SB_MAX 10000000
4196 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
4197 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
4198 CALL_DATA is a pointer to a XmScrollBarCallbackStruct. */
4201 xm_scroll_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
4203 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4204 XmScrollBarCallbackStruct
*cs
= (XmScrollBarCallbackStruct
*) call_data
;
4205 int part
= -1, whole
= 0, portion
= 0;
4209 case XmCR_DECREMENT
:
4210 bar
->dragging
= Qnil
;
4211 part
= scroll_bar_up_arrow
;
4214 case XmCR_INCREMENT
:
4215 bar
->dragging
= Qnil
;
4216 part
= scroll_bar_down_arrow
;
4219 case XmCR_PAGE_DECREMENT
:
4220 bar
->dragging
= Qnil
;
4221 part
= scroll_bar_above_handle
;
4224 case XmCR_PAGE_INCREMENT
:
4225 bar
->dragging
= Qnil
;
4226 part
= scroll_bar_below_handle
;
4230 bar
->dragging
= Qnil
;
4231 part
= scroll_bar_to_top
;
4234 case XmCR_TO_BOTTOM
:
4235 bar
->dragging
= Qnil
;
4236 part
= scroll_bar_to_bottom
;
4243 /* Get the slider size. */
4245 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
4248 whole
= XM_SB_MAX
- slider_size
;
4249 portion
= min (cs
->value
, whole
);
4250 part
= scroll_bar_handle
;
4251 bar
->dragging
= make_number (cs
->value
);
4255 case XmCR_VALUE_CHANGED
:
4261 window_being_scrolled
= bar
->window
;
4262 last_scroll_bar_part
= part
;
4263 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4267 #elif defined USE_GTK
4269 /* Scroll bar callback for GTK scroll bars. WIDGET is the scroll
4270 bar widget. DATA is a pointer to the scroll_bar structure. */
4273 xg_scroll_callback (GtkRange
*range
,
4274 GtkScrollType scroll
,
4278 struct scroll_bar
*bar
= (struct scroll_bar
*) user_data
;
4280 int part
= -1, whole
= 0, portion
= 0;
4281 GtkAdjustment
*adj
= GTK_ADJUSTMENT (gtk_range_get_adjustment (range
));
4282 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (range
), XG_FRAME_DATA
);
4284 if (xg_ignore_gtk_scrollbar
) return FALSE
;
4285 position
= gtk_adjustment_get_value (adj
);
4290 case GTK_SCROLL_JUMP
:
4291 /* Buttons 1 2 or 3 must be grabbed. */
4292 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
!= 0
4293 && FRAME_X_DISPLAY_INFO (f
)->grabbed
< (1 << 4))
4295 part
= scroll_bar_handle
;
4296 whole
= gtk_adjustment_get_upper (adj
) -
4297 gtk_adjustment_get_page_size (adj
);
4298 portion
= min ((int)position
, whole
);
4299 bar
->dragging
= make_number ((int)portion
);
4302 case GTK_SCROLL_STEP_BACKWARD
:
4303 part
= scroll_bar_up_arrow
;
4304 bar
->dragging
= Qnil
;
4306 case GTK_SCROLL_STEP_FORWARD
:
4307 part
= scroll_bar_down_arrow
;
4308 bar
->dragging
= Qnil
;
4310 case GTK_SCROLL_PAGE_BACKWARD
:
4311 part
= scroll_bar_above_handle
;
4312 bar
->dragging
= Qnil
;
4314 case GTK_SCROLL_PAGE_FORWARD
:
4315 part
= scroll_bar_below_handle
;
4316 bar
->dragging
= Qnil
;
4322 window_being_scrolled
= bar
->window
;
4323 last_scroll_bar_part
= part
;
4324 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4330 /* Callback for button release. Sets dragging to Qnil when dragging is done. */
4333 xg_end_scroll_callback (GtkWidget
*widget
,
4334 GdkEventButton
*event
,
4337 struct scroll_bar
*bar
= (struct scroll_bar
*) user_data
;
4338 bar
->dragging
= Qnil
;
4339 if (WINDOWP (window_being_scrolled
))
4341 x_send_scroll_bar_event (window_being_scrolled
,
4342 scroll_bar_end_scroll
, 0, 0);
4343 window_being_scrolled
= Qnil
;
4350 #else /* not USE_GTK and not USE_MOTIF */
4352 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
4353 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
4354 scroll bar struct. CALL_DATA is a pointer to a float saying where
4358 xaw_jump_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
4360 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4361 float top
= *(float *) call_data
;
4363 int whole
, portion
, height
;
4366 /* Get the size of the thumb, a value between 0 and 1. */
4368 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
4372 portion
= shown
< 1 ? top
* whole
: 0;
4374 if (shown
< 1 && (eabs (top
+ shown
- 1) < 1.0/height
))
4375 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
4376 the bottom, so we force the scrolling whenever we see that we're
4377 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
4378 we try to ensure that we always stay two pixels away from the
4380 part
= scroll_bar_down_arrow
;
4382 part
= scroll_bar_handle
;
4384 window_being_scrolled
= bar
->window
;
4385 bar
->dragging
= make_number (portion
);
4386 last_scroll_bar_part
= part
;
4387 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4391 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
4392 i.e. line or page up or down. WIDGET is the Xaw scroll bar
4393 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
4394 the scroll bar. CALL_DATA is an integer specifying the action that
4395 has taken place. Its magnitude is in the range 0..height of the
4396 scroll bar. Negative values mean scroll towards buffer start.
4397 Values < height of scroll bar mean line-wise movement. */
4400 xaw_scroll_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
4402 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4403 /* The position really is stored cast to a pointer. */
4404 int position
= (long) call_data
;
4408 /* Get the height of the scroll bar. */
4410 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
4413 if (eabs (position
) >= height
)
4414 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
4416 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
4417 it maps line-movement to call_data = max(5, height/20). */
4418 else if (xaw3d_arrow_scroll
&& eabs (position
) <= max (5, height
/ 20))
4419 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
4421 part
= scroll_bar_move_ratio
;
4423 window_being_scrolled
= bar
->window
;
4424 bar
->dragging
= Qnil
;
4425 last_scroll_bar_part
= part
;
4426 x_send_scroll_bar_event (bar
->window
, part
, position
, height
);
4429 #endif /* not USE_GTK and not USE_MOTIF */
4431 #define SCROLL_BAR_NAME "verticalScrollBar"
4433 /* Create the widget for scroll bar BAR on frame F. Record the widget
4434 and X window of the scroll bar in BAR. */
4438 x_create_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
4440 const char *scroll_bar_name
= SCROLL_BAR_NAME
;
4443 xg_create_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
4444 G_CALLBACK (xg_end_scroll_callback
),
4449 #else /* not USE_GTK */
4452 x_create_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
4458 char *scroll_bar_name
= SCROLL_BAR_NAME
;
4459 unsigned long pixel
;
4464 /* Set resources. Create the widget. */
4465 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4466 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
4467 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
4468 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
4469 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
4470 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
4471 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
4473 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4476 XtSetArg (av
[ac
], XmNforeground
, pixel
);
4480 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4483 XtSetArg (av
[ac
], XmNbackground
, pixel
);
4487 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
4488 scroll_bar_name
, av
, ac
);
4490 /* Add one callback for everything that can happen. */
4491 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
4493 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
4495 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
4497 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
4499 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
4501 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
4503 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
4506 /* Realize the widget. Only after that is the X window created. */
4507 XtRealizeWidget (widget
);
4509 /* Set the cursor to an arrow. I didn't find a resource to do that.
4510 And I'm wondering why it hasn't an arrow cursor by default. */
4511 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
4512 f
->output_data
.x
->nontext_cursor
);
4514 #else /* !USE_MOTIF i.e. use Xaw */
4516 /* Set resources. Create the widget. The background of the
4517 Xaw3d scroll bar widget is a little bit light for my taste.
4518 We don't alter it here to let users change it according
4519 to their taste with `emacs*verticalScrollBar.background: xxx'. */
4520 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4521 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
4522 /* For smoother scrolling with Xaw3d -sm */
4523 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
4525 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4528 XtSetArg (av
[ac
], XtNforeground
, pixel
);
4532 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4535 XtSetArg (av
[ac
], XtNbackground
, pixel
);
4539 /* Top/bottom shadow colors. */
4541 /* Allocate them, if necessary. */
4542 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
4544 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4547 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
4548 FRAME_X_COLORMAP (f
),
4549 &pixel
, 1.2, 0x8000))
4551 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
4554 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4556 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4559 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
4560 FRAME_X_COLORMAP (f
),
4561 &pixel
, 0.6, 0x4000))
4563 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
4567 #ifdef XtNbeNiceToColormap
4568 /* Tell the toolkit about them. */
4569 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
4570 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4571 /* We tried to allocate a color for the top/bottom shadow, and
4572 failed, so tell Xaw3d to use dithering instead. */
4573 /* But only if we have a small colormap. Xaw3d can allocate nice
4576 XtSetArg (av
[ac
], XtNbeNiceToColormap
,
4577 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)) < 16);
4581 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
4582 be more consistent with other emacs 3d colors, and since Xaw3d is
4583 not good at dealing with allocation failure. */
4585 /* This tells Xaw3d to use real colors instead of dithering for
4587 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
4590 /* Specify the colors. */
4591 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
4594 XtSetArg (av
[ac
], XtNtopShadowPixel
, pixel
);
4597 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
4600 XtSetArg (av
[ac
], XtNbottomShadowPixel
, pixel
);
4606 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
4607 f
->output_data
.x
->edit_widget
, av
, ac
);
4611 char *val
= initial
;
4612 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
4613 #ifdef XtNarrowScrollbars
4614 XtNarrowScrollbars
, (XtPointer
) &xaw3d_arrow_scroll
,
4616 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
4617 if (xaw3d_arrow_scroll
|| val
== initial
)
4618 { /* ARROW_SCROLL */
4619 xaw3d_arrow_scroll
= True
;
4620 /* Isn't that just a personal preference ? --Stef */
4621 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
4625 /* Define callbacks. */
4626 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
4627 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
4630 /* Realize the widget. Only after that is the X window created. */
4631 XtRealizeWidget (widget
);
4633 #endif /* !USE_MOTIF */
4635 /* Install an action hook that lets us detect when the user
4636 finishes interacting with a scroll bar. */
4637 if (action_hook_id
== 0)
4638 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
4640 /* Remember X window and widget in the scroll bar vector. */
4641 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
4642 xwindow
= XtWindow (widget
);
4643 bar
->x_window
= xwindow
;
4647 #endif /* not USE_GTK */
4650 /* Set the thumb size and position of scroll bar BAR. We are currently
4651 displaying PORTION out of a whole WHOLE, and our position POSITION. */
4655 x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
, int whole
)
4657 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
4660 #else /* not USE_GTK */
4662 x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
,
4665 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4666 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4673 /* We use an estimate of 30 chars per line rather than the real
4674 `portion' value. This has the disadvantage that the thumb size
4675 is not very representative, but it makes our life a lot easier.
4676 Otherwise, we have to constantly adjust the thumb size, which
4677 we can't always do quickly enough: while dragging, the size of
4678 the thumb might prevent the user from dragging the thumb all the
4679 way to the end. but Motif and some versions of Xaw3d don't allow
4680 updating the thumb size while dragging. Also, even if we can update
4681 its size, the update will often happen too late.
4682 If you don't believe it, check out revision 1.650 of xterm.c to see
4683 what hoops we were going through and the still poor behavior we got. */
4684 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
4685 /* When the thumb is at the bottom, position == whole.
4686 So we need to increase `whole' to make space for the thumb. */
4693 top
= (float) position
/ whole
;
4694 shown
= (float) portion
/ whole
;
4697 if (NILP (bar
->dragging
))
4701 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
4702 is the scroll bar's maximum and MIN is the scroll bar's minimum
4704 size
= shown
* XM_SB_MAX
;
4705 size
= min (size
, XM_SB_MAX
);
4706 size
= max (size
, 1);
4708 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
4709 value
= top
* XM_SB_MAX
;
4710 value
= min (value
, XM_SB_MAX
- size
);
4712 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
4714 #else /* !USE_MOTIF i.e. use Xaw */
4720 top
= (float) position
/ whole
;
4721 shown
= (float) portion
/ whole
;
4725 float old_top
, old_shown
;
4727 XtVaGetValues (widget
,
4728 XtNtopOfThumb
, &old_top
,
4729 XtNshown
, &old_shown
,
4733 /* Massage the top+shown values. */
4734 if (NILP (bar
->dragging
) || last_scroll_bar_part
== scroll_bar_down_arrow
)
4735 top
= max (0, min (1, top
));
4738 /* Keep two pixels available for moving the thumb down. */
4739 shown
= max (0, min (1 - top
- (2.0 / height
), shown
));
4741 /* If the call to XawScrollbarSetThumb below doesn't seem to work,
4742 check that your system's configuration file contains a define
4743 for `NARROWPROTO'. See s/freebsd.h for an example. */
4744 if (top
!= old_top
|| shown
!= old_shown
)
4746 if (NILP (bar
->dragging
))
4747 XawScrollbarSetThumb (widget
, top
, shown
);
4750 /* Try to make the scrolling a tad smoother. */
4751 if (!xaw3d_pick_top
)
4752 shown
= min (shown
, old_shown
);
4754 XawScrollbarSetThumb (widget
, top
, shown
);
4758 #endif /* !USE_MOTIF */
4762 #endif /* not USE_GTK */
4764 #endif /* USE_TOOLKIT_SCROLL_BARS */
4768 /************************************************************************
4769 Scroll bars, general
4770 ************************************************************************/
4772 /* Create a scroll bar and return the scroll bar vector for it. W is
4773 the Emacs window on which to create the scroll bar. TOP, LEFT,
4774 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
4777 static struct scroll_bar
*
4778 x_scroll_bar_create (struct window
*w
, int top
, int left
, int width
, int height
)
4780 struct frame
*f
= XFRAME (w
->frame
);
4781 struct scroll_bar
*bar
4782 = ALLOCATE_PSEUDOVECTOR (struct scroll_bar
, x_window
, PVEC_OTHER
);
4786 #ifdef USE_TOOLKIT_SCROLL_BARS
4787 x_create_toolkit_scroll_bar (f
, bar
);
4788 #else /* not USE_TOOLKIT_SCROLL_BARS */
4790 XSetWindowAttributes a
;
4794 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4795 if (a
.background_pixel
== -1)
4796 a
.background_pixel
= FRAME_BACKGROUND_PIXEL (f
);
4798 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
4799 | ButtonMotionMask
| PointerMotionHintMask
4801 a
.cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
4803 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
4805 /* Clear the area of W that will serve as a scroll bar. This is
4806 for the case that a window has been split horizontally. In
4807 this case, no clear_frame is generated to reduce flickering. */
4808 if (width
> 0 && height
> 0)
4809 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4811 window_box_height (w
), False
);
4813 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4814 /* Position and size of scroll bar. */
4815 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4817 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4819 /* Border width, depth, class, and visual. */
4826 bar
->x_window
= window
;
4828 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4830 XSETWINDOW (bar
->window
, w
);
4834 bar
->height
= height
;
4837 bar
->dragging
= Qnil
;
4838 bar
->fringe_extended_p
= 0;
4840 /* Add bar to its frame's list of scroll bars. */
4841 bar
->next
= FRAME_SCROLL_BARS (f
);
4843 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
4844 if (!NILP (bar
->next
))
4845 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4847 /* Map the window/widget. */
4848 #ifdef USE_TOOLKIT_SCROLL_BARS
4851 xg_update_scrollbar_pos (f
,
4854 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4855 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4857 #else /* not USE_GTK */
4858 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4859 XtConfigureWidget (scroll_bar
,
4860 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4862 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4863 max (height
, 1), 0);
4864 XtMapWidget (scroll_bar
);
4865 #endif /* not USE_GTK */
4867 #else /* not USE_TOOLKIT_SCROLL_BARS */
4868 XMapRaised (FRAME_X_DISPLAY (f
), bar
->x_window
);
4869 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4876 #ifndef USE_TOOLKIT_SCROLL_BARS
4878 /* Draw BAR's handle in the proper position.
4880 If the handle is already drawn from START to END, don't bother
4881 redrawing it, unless REBUILD is non-zero; in that case, always
4882 redraw it. (REBUILD is handy for drawing the handle after expose
4885 Normally, we want to constrain the start and end of the handle to
4886 fit inside its rectangle, but if the user is dragging the scroll
4887 bar handle, we want to let them drag it down all the way, so that
4888 the bar's top is as far down as it goes; otherwise, there's no way
4889 to move to the very end of the buffer. */
4892 x_scroll_bar_set_handle (struct scroll_bar
*bar
, int start
, int end
, int rebuild
)
4894 int dragging
= ! NILP (bar
->dragging
);
4895 Window w
= bar
->x_window
;
4896 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4897 GC gc
= f
->output_data
.x
->normal_gc
;
4899 /* If the display is already accurate, do nothing. */
4901 && start
== bar
->start
4908 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, bar
->width
);
4909 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, bar
->height
);
4910 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
4912 /* Make sure the values are reasonable, and try to preserve
4913 the distance between start and end. */
4915 int length
= end
- start
;
4919 else if (start
> top_range
)
4921 end
= start
+ length
;
4925 else if (end
> top_range
&& ! dragging
)
4929 /* Store the adjusted setting in the scroll bar. */
4933 /* Clip the end position, just for display. */
4934 if (end
> top_range
)
4937 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
4938 below top positions, to make sure the handle is always at least
4939 that many pixels tall. */
4940 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4942 /* Draw the empty space above the handle. Note that we can't clear
4943 zero-height areas; that means "clear to end of window." */
4945 x_clear_area (FRAME_X_DISPLAY (f
), w
,
4946 /* x, y, width, height, and exposures. */
4947 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4948 VERTICAL_SCROLL_BAR_TOP_BORDER
,
4949 inside_width
, start
,
4952 /* Change to proper foreground color if one is specified. */
4953 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
4954 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
4955 f
->output_data
.x
->scroll_bar_foreground_pixel
);
4957 /* Draw the handle itself. */
4958 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
4959 /* x, y, width, height */
4960 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4961 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
4962 inside_width
, end
- start
);
4964 /* Restore the foreground color of the GC if we changed it above. */
4965 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
4966 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
4967 FRAME_FOREGROUND_PIXEL (f
));
4969 /* Draw the empty space below the handle. Note that we can't
4970 clear zero-height areas; that means "clear to end of window." */
4971 if (end
< inside_height
)
4972 x_clear_area (FRAME_X_DISPLAY (f
), w
,
4973 /* x, y, width, height, and exposures. */
4974 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4975 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
4976 inside_width
, inside_height
- end
,
4984 #endif /* !USE_TOOLKIT_SCROLL_BARS */
4986 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
4990 x_scroll_bar_remove (struct scroll_bar
*bar
)
4992 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4995 #ifdef USE_TOOLKIT_SCROLL_BARS
4997 xg_remove_scroll_bar (f
, bar
->x_window
);
4998 #else /* not USE_GTK */
4999 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
5000 #endif /* not USE_GTK */
5002 XDestroyWindow (FRAME_X_DISPLAY (f
), bar
->x_window
);
5005 /* Disassociate this scroll bar from its window. */
5006 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
5012 /* Set the handle of the vertical scroll bar for WINDOW to indicate
5013 that we are displaying PORTION characters out of a total of WHOLE
5014 characters, starting at POSITION. If WINDOW has no scroll bar,
5018 XTset_vertical_scroll_bar (struct window
*w
, int portion
, int whole
, int position
)
5020 struct frame
*f
= XFRAME (w
->frame
);
5021 struct scroll_bar
*bar
;
5022 int top
, height
, left
, sb_left
, width
, sb_width
;
5023 int window_y
, window_height
;
5024 #ifdef USE_TOOLKIT_SCROLL_BARS
5025 int fringe_extended_p
;
5028 /* Get window dimensions. */
5029 window_box (w
, -1, 0, &window_y
, 0, &window_height
);
5031 width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
5032 height
= window_height
;
5034 /* Compute the left edge of the scroll bar area. */
5035 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
5037 /* Compute the width of the scroll bar which might be less than
5038 the width of the area reserved for the scroll bar. */
5039 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
) > 0)
5040 sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
5044 /* Compute the left edge of the scroll bar. */
5045 #ifdef USE_TOOLKIT_SCROLL_BARS
5046 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
5047 sb_left
= left
+ (WINDOW_RIGHTMOST_P (w
) ? width
- sb_width
: 0);
5049 sb_left
= left
+ (WINDOW_LEFTMOST_P (w
) ? 0 : width
- sb_width
);
5051 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
5052 sb_left
= left
+ width
- sb_width
;
5057 #ifdef USE_TOOLKIT_SCROLL_BARS
5058 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
5059 fringe_extended_p
= (WINDOW_LEFTMOST_P (w
)
5060 && WINDOW_LEFT_FRINGE_WIDTH (w
)
5061 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5062 || WINDOW_LEFT_MARGIN_COLS (w
) == 0));
5064 fringe_extended_p
= (WINDOW_RIGHTMOST_P (w
)
5065 && WINDOW_RIGHT_FRINGE_WIDTH (w
)
5066 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5067 || WINDOW_RIGHT_MARGIN_COLS (w
) == 0));
5070 /* Does the scroll bar exist yet? */
5071 if (NILP (w
->vertical_scroll_bar
))
5073 if (width
> 0 && height
> 0)
5076 #ifdef USE_TOOLKIT_SCROLL_BARS
5077 if (fringe_extended_p
)
5078 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5079 sb_left
, top
, sb_width
, height
, False
);
5082 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5083 left
, top
, width
, height
, False
);
5087 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
5091 /* It may just need to be moved and resized. */
5092 unsigned int mask
= 0;
5094 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5098 if (sb_left
!= bar
->left
)
5100 if (top
!= bar
->top
)
5102 if (sb_width
!= bar
->width
)
5104 if (height
!= bar
->height
)
5107 #ifdef USE_TOOLKIT_SCROLL_BARS
5109 /* Move/size the scroll bar widget. */
5110 if (mask
|| bar
->fringe_extended_p
!= fringe_extended_p
)
5112 /* Since toolkit scroll bars are smaller than the space reserved
5113 for them on the frame, we have to clear "under" them. */
5114 if (width
> 0 && height
> 0)
5116 if (fringe_extended_p
)
5117 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5118 sb_left
, top
, sb_width
, height
, False
);
5120 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5121 left
, top
, width
, height
, False
);
5124 xg_update_scrollbar_pos (f
,
5127 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5128 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
*2,
5130 #else /* not USE_GTK */
5131 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
5132 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5134 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
5135 max (height
, 1), 0);
5136 #endif /* not USE_GTK */
5138 #else /* not USE_TOOLKIT_SCROLL_BARS */
5140 /* Clear areas not covered by the scroll bar because of
5141 VERTICAL_SCROLL_BAR_WIDTH_TRIM. */
5142 if (VERTICAL_SCROLL_BAR_WIDTH_TRIM
)
5144 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5145 left
, top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5147 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5148 left
+ width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5149 top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5153 /* Clear areas not covered by the scroll bar because it's not as
5154 wide as the area reserved for it. This makes sure a
5155 previous mode line display is cleared after C-x 2 C-x 1, for
5158 int area_width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
5159 int rest
= area_width
- sb_width
;
5160 if (rest
> 0 && height
> 0)
5162 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
5163 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5164 left
+ area_width
- rest
, top
,
5165 rest
, height
, False
);
5167 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5168 left
, top
, rest
, height
, False
);
5172 /* Move/size the scroll bar window. */
5177 wc
.x
= sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5179 wc
.width
= sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2;
5181 XConfigureWindow (FRAME_X_DISPLAY (f
), bar
->x_window
,
5185 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5187 /* Remember new settings. */
5188 bar
->left
= sb_left
;
5190 bar
->width
= sb_width
;
5191 bar
->height
= height
;
5196 #ifdef USE_TOOLKIT_SCROLL_BARS
5197 bar
->fringe_extended_p
= fringe_extended_p
;
5199 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
5200 #else /* not USE_TOOLKIT_SCROLL_BARS */
5201 /* Set the scroll bar's current state, unless we're currently being
5203 if (NILP (bar
->dragging
))
5205 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
5208 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
5211 int start
= ((double) position
* top_range
) / whole
;
5212 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
5213 x_scroll_bar_set_handle (bar
, start
, end
, 0);
5216 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5218 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
5222 /* The following three hooks are used when we're doing a thorough
5223 redisplay of the frame. We don't explicitly know which scroll bars
5224 are going to be deleted, because keeping track of when windows go
5225 away is a real pain - "Can you say set-window-configuration, boys
5226 and girls?" Instead, we just assert at the beginning of redisplay
5227 that *all* scroll bars are to be removed, and then save a scroll bar
5228 from the fiery pit when we actually redisplay its window. */
5230 /* Arrange for all scroll bars on FRAME to be removed at the next call
5231 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
5232 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
5235 XTcondemn_scroll_bars (FRAME_PTR frame
)
5237 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
5238 while (! NILP (FRAME_SCROLL_BARS (frame
)))
5241 bar
= FRAME_SCROLL_BARS (frame
);
5242 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
5243 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
5244 XSCROLL_BAR (bar
)->prev
= Qnil
;
5245 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
5246 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
5247 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
5252 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
5253 Note that WINDOW isn't necessarily condemned at all. */
5256 XTredeem_scroll_bar (struct window
*window
)
5258 struct scroll_bar
*bar
;
5261 /* We can't redeem this window's scroll bar if it doesn't have one. */
5262 if (NILP (window
->vertical_scroll_bar
))
5265 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
5267 /* Unlink it from the condemned list. */
5268 f
= XFRAME (WINDOW_FRAME (window
));
5269 if (NILP (bar
->prev
))
5271 /* If the prev pointer is nil, it must be the first in one of
5273 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
5274 /* It's not condemned. Everything's fine. */
5276 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
5277 window
->vertical_scroll_bar
))
5278 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
5280 /* If its prev pointer is nil, it must be at the front of
5281 one or the other! */
5285 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
5287 if (! NILP (bar
->next
))
5288 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
5290 bar
->next
= FRAME_SCROLL_BARS (f
);
5292 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
5293 if (! NILP (bar
->next
))
5294 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
5297 /* Remove all scroll bars on FRAME that haven't been saved since the
5298 last call to `*condemn_scroll_bars_hook'. */
5301 XTjudge_scroll_bars (FRAME_PTR f
)
5303 Lisp_Object bar
, next
;
5305 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
5307 /* Clear out the condemned list now so we won't try to process any
5308 more events on the hapless scroll bars. */
5309 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
5311 for (; ! NILP (bar
); bar
= next
)
5313 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
5315 x_scroll_bar_remove (b
);
5318 b
->next
= b
->prev
= Qnil
;
5321 /* Now there should be no references to the condemned scroll bars,
5322 and they should get garbage-collected. */
5326 #ifndef USE_TOOLKIT_SCROLL_BARS
5327 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
5328 is a no-op when using toolkit scroll bars.
5330 This may be called from a signal handler, so we have to ignore GC
5334 x_scroll_bar_expose (struct scroll_bar
*bar
, XEvent
*event
)
5336 Window w
= bar
->x_window
;
5337 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5338 GC gc
= f
->output_data
.x
->normal_gc
;
5339 int width_trim
= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5343 x_scroll_bar_set_handle (bar
, bar
->start
, bar
->end
, 1);
5345 /* Switch to scroll bar foreground color. */
5346 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5347 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5348 f
->output_data
.x
->scroll_bar_foreground_pixel
);
5350 /* Draw a one-pixel border just inside the edges of the scroll bar. */
5351 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
5353 /* x, y, width, height */
5355 bar
->width
- 1 - width_trim
- width_trim
,
5358 /* Restore the foreground color of the GC if we changed it above. */
5359 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5360 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5361 FRAME_FOREGROUND_PIXEL (f
));
5366 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5368 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
5369 is set to something other than NO_EVENT, it is enqueued.
5371 This may be called from a signal handler, so we have to ignore GC
5376 x_scroll_bar_handle_click (struct scroll_bar
*bar
, XEvent
*event
, struct input_event
*emacs_event
)
5378 if (! WINDOWP (bar
->window
))
5381 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
5382 emacs_event
->code
= event
->xbutton
.button
- Button1
;
5383 emacs_event
->modifiers
5384 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
5385 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
5386 event
->xbutton
.state
)
5387 | (event
->type
== ButtonRelease
5390 emacs_event
->frame_or_window
= bar
->window
;
5391 emacs_event
->arg
= Qnil
;
5392 emacs_event
->timestamp
= event
->xbutton
.time
;
5395 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
5396 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
5399 if (y
> top_range
) y
= top_range
;
5402 emacs_event
->part
= scroll_bar_above_handle
;
5403 else if (y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5404 emacs_event
->part
= scroll_bar_handle
;
5406 emacs_event
->part
= scroll_bar_below_handle
;
5408 #ifndef USE_TOOLKIT_SCROLL_BARS
5409 /* If the user has released the handle, set it to its final position. */
5410 if (event
->type
== ButtonRelease
5411 && ! NILP (bar
->dragging
))
5413 int new_start
= y
- XINT (bar
->dragging
);
5414 int new_end
= new_start
+ bar
->end
- bar
->start
;
5416 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5417 bar
->dragging
= Qnil
;
5421 XSETINT (emacs_event
->x
, y
);
5422 XSETINT (emacs_event
->y
, top_range
);
5426 #ifndef USE_TOOLKIT_SCROLL_BARS
5428 /* Handle some mouse motion while someone is dragging the scroll bar.
5430 This may be called from a signal handler, so we have to ignore GC
5434 x_scroll_bar_note_movement (struct scroll_bar
*bar
, XEvent
*event
)
5436 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
5438 last_mouse_movement_time
= event
->xmotion
.time
;
5441 XSETVECTOR (last_mouse_scroll_bar
, bar
);
5443 /* If we're dragging the bar, display it. */
5444 if (! NILP (bar
->dragging
))
5446 /* Where should the handle be now? */
5447 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
5449 if (new_start
!= bar
->start
)
5451 int new_end
= new_start
+ bar
->end
- bar
->start
;
5453 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5458 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5460 /* Return information to the user about the current position of the mouse
5461 on the scroll bar. */
5464 x_scroll_bar_report_motion (FRAME_PTR
*fp
, Lisp_Object
*bar_window
, enum scroll_bar_part
*part
, Lisp_Object
*x
, Lisp_Object
*y
, long unsigned int *time
)
5466 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
5467 Window w
= bar
->x_window
;
5468 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5470 Window dummy_window
;
5472 unsigned int dummy_mask
;
5476 /* Get the mouse's position relative to the scroll bar window, and
5478 if (! XQueryPointer (FRAME_X_DISPLAY (f
), w
,
5480 /* Root, child, root x and root y. */
5481 &dummy_window
, &dummy_window
,
5482 &dummy_coord
, &dummy_coord
,
5484 /* Position relative to scroll bar. */
5487 /* Mouse buttons and modifier keys. */
5493 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
5495 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
5497 if (! NILP (bar
->dragging
))
5498 win_y
-= XINT (bar
->dragging
);
5502 if (win_y
> top_range
)
5506 *bar_window
= bar
->window
;
5508 if (! NILP (bar
->dragging
))
5509 *part
= scroll_bar_handle
;
5510 else if (win_y
< bar
->start
)
5511 *part
= scroll_bar_above_handle
;
5512 else if (win_y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5513 *part
= scroll_bar_handle
;
5515 *part
= scroll_bar_below_handle
;
5517 XSETINT (*x
, win_y
);
5518 XSETINT (*y
, top_range
);
5521 last_mouse_scroll_bar
= Qnil
;
5524 *time
= last_mouse_movement_time
;
5530 /* The screen has been cleared so we may have changed foreground or
5531 background colors, and the scroll bars may need to be redrawn.
5532 Clear out the scroll bars, and ask for expose events, so we can
5536 x_scroll_bar_clear (FRAME_PTR f
)
5538 #ifndef USE_TOOLKIT_SCROLL_BARS
5541 /* We can have scroll bars even if this is 0,
5542 if we just turned off scroll bar mode.
5543 But in that case we should not clear them. */
5544 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5545 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
5546 bar
= XSCROLL_BAR (bar
)->next
)
5547 XClearArea (FRAME_X_DISPLAY (f
),
5548 XSCROLL_BAR (bar
)->x_window
,
5550 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5554 /* The main X event-reading loop - XTread_socket. */
5556 /* This holds the state XLookupString needs to implement dead keys
5557 and other tricks known as "compose processing". _X Window System_
5558 says that a portable program can't use this, but Stephen Gildea assures
5559 me that letting the compiler initialize it to zeros will work okay.
5561 This must be defined outside of XTread_socket, for the same reasons
5562 given for enter_timestamp, above. */
5564 static XComposeStatus compose_status
;
5566 /* Record the last 100 characters stored
5567 to help debug the loss-of-chars-during-GC problem. */
5569 static int temp_index
;
5570 static short temp_buffer
[100];
5572 #define STORE_KEYSYM_FOR_DEBUG(keysym) \
5573 if (temp_index == sizeof temp_buffer / sizeof (short)) \
5575 temp_buffer[temp_index++] = (keysym)
5577 /* Set this to nonzero to fake an "X I/O error"
5578 on a particular display. */
5580 struct x_display_info
*XTread_socket_fake_io_error
;
5582 /* When we find no input here, we occasionally do a no-op command
5583 to verify that the X server is still running and we can still talk with it.
5584 We try all the open displays, one by one.
5585 This variable is used for cycling thru the displays. */
5587 static struct x_display_info
*next_noop_dpyinfo
;
5589 #define SET_SAVED_BUTTON_EVENT \
5592 if (f->output_data.x->saved_menu_event == 0) \
5593 f->output_data.x->saved_menu_event \
5594 = (XEvent *) xmalloc (sizeof (XEvent)); \
5595 *f->output_data.x->saved_menu_event = event; \
5596 inev.ie.kind = MENU_BAR_ACTIVATE_EVENT; \
5597 XSETFRAME (inev.ie.frame_or_window, f); \
5608 /* Filter events for the current X input method.
5609 DPYINFO is the display this event is for.
5610 EVENT is the X event to filter.
5612 Returns non-zero if the event was filtered, caller shall not process
5614 Returns zero if event is wasn't filtered. */
5618 x_filter_event (struct x_display_info
*dpyinfo
, XEvent
*event
)
5620 /* XFilterEvent returns non-zero if the input method has
5621 consumed the event. We pass the frame's X window to
5622 XFilterEvent because that's the one for which the IC
5625 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
5626 event
->xclient
.window
);
5628 return XFilterEvent (event
, f1
? FRAME_X_WINDOW (f1
) : None
);
5633 static int current_count
;
5634 static int current_finish
;
5635 static struct input_event
*current_hold_quit
;
5637 /* This is the filter function invoked by the GTK event loop.
5638 It is invoked before the XEvent is translated to a GdkEvent,
5639 so we have a chance to act on the event before GTK. */
5640 static GdkFilterReturn
5641 event_handler_gdk (GdkXEvent
*gxev
, GdkEvent
*ev
, gpointer data
)
5643 XEvent
*xev
= (XEvent
*) gxev
;
5646 if (current_count
>= 0)
5648 struct x_display_info
*dpyinfo
;
5650 dpyinfo
= x_display_info_for_display (xev
->xany
.display
);
5653 /* Filter events for the current X input method.
5654 GTK calls XFilterEvent but not for key press and release,
5655 so we do it here. */
5656 if ((xev
->type
== KeyPress
|| xev
->type
== KeyRelease
)
5658 && x_filter_event (dpyinfo
, xev
))
5661 return GDK_FILTER_REMOVE
;
5666 current_finish
= X_EVENT_NORMAL
;
5669 handle_one_xevent (dpyinfo
, xev
, ¤t_finish
,
5673 current_finish
= x_dispatch_event (xev
, xev
->xany
.display
);
5677 if (current_finish
== X_EVENT_GOTO_OUT
|| current_finish
== X_EVENT_DROP
)
5678 return GDK_FILTER_REMOVE
;
5680 return GDK_FILTER_CONTINUE
;
5682 #endif /* USE_GTK */
5685 /* Handles the XEvent EVENT on display DPYINFO.
5687 *FINISH is X_EVENT_GOTO_OUT if caller should stop reading events.
5688 *FINISH is zero if caller should continue reading events.
5689 *FINISH is X_EVENT_DROP if event should not be passed to the toolkit.
5691 We return the number of characters stored into the buffer. */
5694 handle_one_xevent (struct x_display_info
*dpyinfo
, XEvent
*eventp
, int *finish
, struct input_event
*hold_quit
)
5697 struct input_event ie
;
5698 struct selection_input_event sie
;
5703 struct frame
*f
= NULL
;
5704 struct coding_system coding
;
5705 XEvent event
= *eventp
;
5707 *finish
= X_EVENT_NORMAL
;
5709 EVENT_INIT (inev
.ie
);
5710 inev
.ie
.kind
= NO_EVENT
;
5713 if (pending_event_wait
.eventtype
== event
.type
)
5714 pending_event_wait
.eventtype
= 0; /* Indicates we got it. */
5720 if (event
.xclient
.message_type
5721 == dpyinfo
->Xatom_wm_protocols
5722 && event
.xclient
.format
== 32)
5724 if (event
.xclient
.data
.l
[0]
5725 == dpyinfo
->Xatom_wm_take_focus
)
5727 /* Use x_any_window_to_frame because this
5728 could be the shell widget window
5729 if the frame has no title bar. */
5730 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5732 /* Not quite sure this is needed -pd */
5733 if (f
&& FRAME_XIC (f
))
5734 XSetICFocus (FRAME_XIC (f
));
5736 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
5737 instructs the WM to set the input focus automatically for
5738 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
5739 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
5740 it has set the focus. So, XSetInputFocus below is not
5743 The call to XSetInputFocus below has also caused trouble. In
5744 cases where the XSetInputFocus done by the WM and the one
5745 below are temporally close (on a fast machine), the call
5746 below can generate additional FocusIn events which confuse
5749 /* Since we set WM_TAKE_FOCUS, we must call
5750 XSetInputFocus explicitly. But not if f is null,
5751 since that might be an event for a deleted frame. */
5754 Display
*d
= event
.xclient
.display
;
5755 /* Catch and ignore errors, in case window has been
5756 iconified by a window manager such as GWM. */
5758 XSetInputFocus (d
, event
.xclient
.window
,
5759 /* The ICCCM says this is
5760 the only valid choice. */
5762 event
.xclient
.data
.l
[1]);
5763 /* This is needed to detect the error
5764 if there is an error. */
5766 x_uncatch_errors ();
5768 /* Not certain about handling scroll bars here */
5773 if (event
.xclient
.data
.l
[0]
5774 == dpyinfo
->Xatom_wm_save_yourself
)
5776 /* Save state modify the WM_COMMAND property to
5777 something which can reinstate us. This notifies
5778 the session manager, who's looking for such a
5779 PropertyNotify. Can restart processing when
5780 a keyboard or mouse event arrives. */
5781 /* If we have a session manager, don't set this.
5782 KDE will then start two Emacsen, one for the
5783 session manager and one for this. */
5785 if (! x_session_have_connection ())
5788 f
= x_top_window_to_frame (dpyinfo
,
5789 event
.xclient
.window
);
5790 /* This is just so we only give real data once
5791 for a single Emacs process. */
5792 if (f
== SELECTED_FRAME ())
5793 XSetCommand (FRAME_X_DISPLAY (f
),
5794 event
.xclient
.window
,
5795 initial_argv
, initial_argc
);
5797 XSetCommand (FRAME_X_DISPLAY (f
),
5798 event
.xclient
.window
,
5804 if (event
.xclient
.data
.l
[0]
5805 == dpyinfo
->Xatom_wm_delete_window
)
5807 f
= x_any_window_to_frame (dpyinfo
,
5808 event
.xclient
.window
);
5810 goto OTHER
; /* May be a dialog that is to be removed */
5812 inev
.ie
.kind
= DELETE_WINDOW_EVENT
;
5813 XSETFRAME (inev
.ie
.frame_or_window
, f
);
5820 if (event
.xclient
.message_type
5821 == dpyinfo
->Xatom_wm_configure_denied
)
5826 if (event
.xclient
.message_type
5827 == dpyinfo
->Xatom_wm_window_moved
)
5830 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
5832 new_x
= event
.xclient
.data
.s
[0];
5833 new_y
= event
.xclient
.data
.s
[1];
5837 f
->left_pos
= new_x
;
5844 if (event
.xclient
.message_type
5845 == dpyinfo
->Xatom_editres
)
5847 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5849 _XEditResCheckMessages (f
->output_data
.x
->widget
, NULL
,
5853 #endif /* HACK_EDITRES */
5855 if ((event
.xclient
.message_type
5856 == dpyinfo
->Xatom_DONE
)
5857 || (event
.xclient
.message_type
5858 == dpyinfo
->Xatom_PAGE
))
5860 /* Ghostview job completed. Kill it. We could
5861 reply with "Next" if we received "Page", but we
5862 currently never do because we are interested in
5863 images, only, which should have 1 page. */
5864 Pixmap pixmap
= (Pixmap
) event
.xclient
.data
.l
[1];
5865 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
5868 x_kill_gs_process (pixmap
, f
);
5869 expose_frame (f
, 0, 0, 0, 0);
5873 #ifdef USE_TOOLKIT_SCROLL_BARS
5874 /* Scroll bar callbacks send a ClientMessage from which
5875 we construct an input_event. */
5876 if (event
.xclient
.message_type
5877 == dpyinfo
->Xatom_Scrollbar
)
5879 x_scroll_bar_to_input_event (&event
, &inev
.ie
);
5880 *finish
= X_EVENT_GOTO_OUT
;
5883 #endif /* USE_TOOLKIT_SCROLL_BARS */
5885 /* XEmbed messages from the embedder (if any). */
5886 if (event
.xclient
.message_type
5887 == dpyinfo
->Xatom_XEMBED
)
5889 enum xembed_message msg
= event
.xclient
.data
.l
[1];
5890 if (msg
== XEMBED_FOCUS_IN
|| msg
== XEMBED_FOCUS_OUT
)
5891 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
5893 *finish
= X_EVENT_GOTO_OUT
;
5897 xft_settings_event (dpyinfo
, &event
);
5899 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5902 if (x_handle_dnd_message (f
, &event
.xclient
, dpyinfo
, &inev
.ie
))
5903 *finish
= X_EVENT_DROP
;
5907 case SelectionNotify
:
5908 last_user_time
= event
.xselection
.time
;
5909 #ifdef USE_X_TOOLKIT
5910 if (! x_window_to_frame (dpyinfo
, event
.xselection
.requestor
))
5912 #endif /* not USE_X_TOOLKIT */
5913 x_handle_selection_notify (&event
.xselection
);
5916 case SelectionClear
: /* Someone has grabbed ownership. */
5917 last_user_time
= event
.xselectionclear
.time
;
5918 #ifdef USE_X_TOOLKIT
5919 if (! x_window_to_frame (dpyinfo
, event
.xselectionclear
.window
))
5921 #endif /* USE_X_TOOLKIT */
5923 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
5925 inev
.ie
.kind
= SELECTION_CLEAR_EVENT
;
5926 SELECTION_EVENT_DISPLAY (&inev
.sie
) = eventp
->display
;
5927 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
5928 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
5929 inev
.ie
.frame_or_window
= Qnil
;
5933 case SelectionRequest
: /* Someone wants our selection. */
5934 last_user_time
= event
.xselectionrequest
.time
;
5935 #ifdef USE_X_TOOLKIT
5936 if (!x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
))
5938 #endif /* USE_X_TOOLKIT */
5940 XSelectionRequestEvent
*eventp
5941 = (XSelectionRequestEvent
*) &event
;
5943 inev
.ie
.kind
= SELECTION_REQUEST_EVENT
;
5944 SELECTION_EVENT_DISPLAY (&inev
.sie
) = eventp
->display
;
5945 SELECTION_EVENT_REQUESTOR (&inev
.sie
) = eventp
->requestor
;
5946 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
5947 SELECTION_EVENT_TARGET (&inev
.sie
) = eventp
->target
;
5948 SELECTION_EVENT_PROPERTY (&inev
.sie
) = eventp
->property
;
5949 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
5950 inev
.ie
.frame_or_window
= Qnil
;
5954 case PropertyNotify
:
5955 last_user_time
= event
.xproperty
.time
;
5956 f
= x_top_window_to_frame (dpyinfo
, event
.xproperty
.window
);
5957 if (f
&& event
.xproperty
.atom
== dpyinfo
->Xatom_net_wm_state
)
5958 x_handle_net_wm_state (f
, &event
.xproperty
);
5960 x_handle_property_notify (&event
.xproperty
);
5961 xft_settings_event (dpyinfo
, &event
);
5964 case ReparentNotify
:
5965 f
= x_top_window_to_frame (dpyinfo
, event
.xreparent
.window
);
5969 f
->output_data
.x
->parent_desc
= event
.xreparent
.parent
;
5970 x_real_positions (f
, &x
, &y
);
5974 /* Perhaps reparented due to a WM restart. Reset this. */
5975 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_UNKNOWN
;
5976 FRAME_X_DISPLAY_INFO (f
)->net_supported_window
= 0;
5981 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
5985 /* This seems to be needed for GTK 2.6. */
5986 x_clear_area (event
.xexpose
.display
,
5987 event
.xexpose
.window
,
5988 event
.xexpose
.x
, event
.xexpose
.y
,
5989 event
.xexpose
.width
, event
.xexpose
.height
,
5992 if (f
->async_visible
== 0)
5994 f
->async_visible
= 1;
5995 f
->async_iconified
= 0;
5996 f
->output_data
.x
->has_been_visible
= 1;
5997 SET_FRAME_GARBAGED (f
);
6001 event
.xexpose
.x
, event
.xexpose
.y
,
6002 event
.xexpose
.width
, event
.xexpose
.height
);
6006 #ifndef USE_TOOLKIT_SCROLL_BARS
6007 struct scroll_bar
*bar
;
6009 #if defined USE_LUCID
6010 /* Submenus of the Lucid menu bar aren't widgets
6011 themselves, so there's no way to dispatch events
6012 to them. Recognize this case separately. */
6015 = x_window_to_menu_bar (event
.xexpose
.window
);
6017 xlwmenu_redisplay (widget
);
6019 #endif /* USE_LUCID */
6021 #ifdef USE_TOOLKIT_SCROLL_BARS
6022 /* Dispatch event to the widget. */
6024 #else /* not USE_TOOLKIT_SCROLL_BARS */
6025 bar
= x_window_to_scroll_bar (event
.xexpose
.display
,
6026 event
.xexpose
.window
);
6029 x_scroll_bar_expose (bar
, &event
);
6030 #ifdef USE_X_TOOLKIT
6033 #endif /* USE_X_TOOLKIT */
6034 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6038 case GraphicsExpose
: /* This occurs when an XCopyArea's
6039 source area was obscured or not
6041 f
= x_window_to_frame (dpyinfo
, event
.xgraphicsexpose
.drawable
);
6045 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
6046 event
.xgraphicsexpose
.width
,
6047 event
.xgraphicsexpose
.height
);
6049 #ifdef USE_X_TOOLKIT
6052 #endif /* USE_X_TOOLKIT */
6055 case NoExpose
: /* This occurs when an XCopyArea's
6056 source area was completely
6061 /* Redo the mouse-highlight after the tooltip has gone. */
6062 if (event
.xmap
.window
== tip_window
)
6065 redo_mouse_highlight ();
6068 f
= x_top_window_to_frame (dpyinfo
, event
.xunmap
.window
);
6069 if (f
) /* F may no longer exist if
6070 the frame was deleted. */
6072 /* While a frame is unmapped, display generation is
6073 disabled; you don't want to spend time updating a
6074 display that won't ever be seen. */
6075 f
->async_visible
= 0;
6076 /* We can't distinguish, from the event, whether the window
6077 has become iconified or invisible. So assume, if it
6078 was previously visible, than now it is iconified.
6079 But x_make_frame_invisible clears both
6080 the visible flag and the iconified flag;
6081 and that way, we know the window is not iconified now. */
6082 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
6084 f
->async_iconified
= 1;
6086 inev
.ie
.kind
= ICONIFY_EVENT
;
6087 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6093 if (event
.xmap
.window
== tip_window
)
6094 /* The tooltip has been drawn already. Avoid
6095 the SET_FRAME_GARBAGED below. */
6098 /* We use x_top_window_to_frame because map events can
6099 come for sub-windows and they don't mean that the
6100 frame is visible. */
6101 f
= x_top_window_to_frame (dpyinfo
, event
.xmap
.window
);
6104 /* wait_reading_process_output will notice this and update
6105 the frame's display structures.
6106 If we where iconified, we should not set garbaged,
6107 because that stops redrawing on Expose events. This looks
6108 bad if we are called from a recursive event loop
6109 (x_dispatch_event), for example when a dialog is up. */
6110 if (! f
->async_iconified
)
6111 SET_FRAME_GARBAGED (f
);
6113 /* Check if fullscreen was specified before we where mapped the
6114 first time, i.e. from the command line. */
6115 if (!f
->output_data
.x
->has_been_visible
)
6116 x_check_fullscreen (f
);
6118 f
->async_visible
= 1;
6119 f
->async_iconified
= 0;
6120 f
->output_data
.x
->has_been_visible
= 1;
6124 inev
.ie
.kind
= DEICONIFY_EVENT
;
6125 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6127 else if (! NILP (Vframe_list
)
6128 && ! NILP (XCDR (Vframe_list
)))
6129 /* Force a redisplay sooner or later
6130 to update the frame titles
6131 in case this is the second frame. */
6132 record_asynch_buffer_change ();
6135 xg_frame_resized (f
, -1, -1);
6142 last_user_time
= event
.xkey
.time
;
6143 ignore_next_mouse_click_timeout
= 0;
6145 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6146 /* Dispatch KeyPress events when in menu. */
6147 if (popup_activated ())
6151 f
= x_any_window_to_frame (dpyinfo
, event
.xkey
.window
);
6153 /* If mouse-highlight is an integer, input clears out
6154 mouse highlighting. */
6155 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
6157 || !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
)))
6159 clear_mouse_face (dpyinfo
);
6160 dpyinfo
->mouse_face_hidden
= 1;
6163 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
6166 /* Scroll bars consume key events, but we want
6167 the keys to go to the scroll bar's frame. */
6168 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
6170 if (widget
&& XmIsScrollBar (widget
))
6172 widget
= XtParent (widget
);
6173 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
6176 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
6180 KeySym keysym
, orig_keysym
;
6181 /* al%imercury@uunet.uu.net says that making this 81
6182 instead of 80 fixed a bug whereby meta chars made
6185 It seems that some version of XmbLookupString has
6186 a bug of not returning XBufferOverflow in
6187 status_return even if the input is too long to
6188 fit in 81 bytes. So, we must prepare sufficient
6189 bytes for copy_buffer. 513 bytes (256 chars for
6190 two-byte character set) seems to be a fairly good
6191 approximation. -- 2000.8.10 handa@etl.go.jp */
6192 unsigned char copy_buffer
[513];
6193 unsigned char *copy_bufptr
= copy_buffer
;
6194 int copy_bufsiz
= sizeof (copy_buffer
);
6196 Lisp_Object coding_system
= Qlatin_1
;
6200 /* Don't pass keys to GTK. A Tab will shift focus to the
6201 tool bar in GTK 2.4. Keys will still go to menus and
6202 dialogs because in that case popup_activated is TRUE
6204 *finish
= X_EVENT_DROP
;
6208 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f
),
6209 extra_keyboard_modifiers
);
6210 modifiers
= event
.xkey
.state
;
6212 /* This will have to go some day... */
6214 /* make_lispy_event turns chars into control chars.
6215 Don't do it here because XLookupString is too eager. */
6216 event
.xkey
.state
&= ~ControlMask
;
6217 event
.xkey
.state
&= ~(dpyinfo
->meta_mod_mask
6218 | dpyinfo
->super_mod_mask
6219 | dpyinfo
->hyper_mod_mask
6220 | dpyinfo
->alt_mod_mask
);
6222 /* In case Meta is ComposeCharacter,
6223 clear its status. According to Markus Ehrnsperger
6224 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
6225 this enables ComposeCharacter to work whether or
6226 not it is combined with Meta. */
6227 if (modifiers
& dpyinfo
->meta_mod_mask
)
6228 memset (&compose_status
, 0, sizeof (compose_status
));
6233 Status status_return
;
6235 coding_system
= Vlocale_coding_system
;
6236 nbytes
= XmbLookupString (FRAME_XIC (f
),
6237 &event
.xkey
, copy_bufptr
,
6238 copy_bufsiz
, &keysym
,
6240 if (status_return
== XBufferOverflow
)
6242 copy_bufsiz
= nbytes
+ 1;
6243 copy_bufptr
= (unsigned char *) alloca (copy_bufsiz
);
6244 nbytes
= XmbLookupString (FRAME_XIC (f
),
6245 &event
.xkey
, copy_bufptr
,
6246 copy_bufsiz
, &keysym
,
6249 /* Xutf8LookupString is a new but already deprecated interface. -stef */
6250 if (status_return
== XLookupNone
)
6252 else if (status_return
== XLookupChars
)
6257 else if (status_return
!= XLookupKeySym
6258 && status_return
!= XLookupBoth
)
6262 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
6263 copy_bufsiz
, &keysym
,
6266 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
6267 copy_bufsiz
, &keysym
,
6271 /* If not using XIM/XIC, and a compose sequence is in progress,
6272 we break here. Otherwise, chars_matched is always 0. */
6273 if (compose_status
.chars_matched
> 0 && nbytes
== 0)
6276 memset (&compose_status
, 0, sizeof (compose_status
));
6277 orig_keysym
= keysym
;
6279 /* Common for all keysym input events. */
6280 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6282 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), modifiers
);
6283 inev
.ie
.timestamp
= event
.xkey
.time
;
6285 /* First deal with keysyms which have defined
6286 translations to characters. */
6287 if (keysym
>= 32 && keysym
< 128)
6288 /* Avoid explicitly decoding each ASCII character. */
6290 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
6291 inev
.ie
.code
= keysym
;
6295 /* Keysyms directly mapped to Unicode characters. */
6296 if (keysym
>= 0x01000000 && keysym
<= 0x0110FFFF)
6298 if (keysym
< 0x01000080)
6299 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
6301 inev
.ie
.kind
= MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
6302 inev
.ie
.code
= keysym
& 0xFFFFFF;
6306 /* Now non-ASCII. */
6307 if (HASH_TABLE_P (Vx_keysym_table
)
6308 && (NATNUMP (c
= Fgethash (make_number (keysym
),
6312 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (XFASTINT (c
))
6313 ? ASCII_KEYSTROKE_EVENT
6314 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6315 inev
.ie
.code
= XFASTINT (c
);
6319 /* Random non-modifier sorts of keysyms. */
6320 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
6321 || keysym
== XK_Delete
6322 #ifdef XK_ISO_Left_Tab
6323 || (keysym
>= XK_ISO_Left_Tab
6324 && keysym
<= XK_ISO_Enter
)
6326 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
6327 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
6329 /* This recognizes the "extended function
6330 keys". It seems there's no cleaner way.
6331 Test IsModifierKey to avoid handling
6332 mode_switch incorrectly. */
6333 || ((unsigned) (keysym
) >= XK_Select
6334 && (unsigned)(keysym
) < XK_KP_Space
)
6336 #ifdef XK_dead_circumflex
6337 || orig_keysym
== XK_dead_circumflex
6339 #ifdef XK_dead_grave
6340 || orig_keysym
== XK_dead_grave
6342 #ifdef XK_dead_tilde
6343 || orig_keysym
== XK_dead_tilde
6345 #ifdef XK_dead_diaeresis
6346 || orig_keysym
== XK_dead_diaeresis
6348 #ifdef XK_dead_macron
6349 || orig_keysym
== XK_dead_macron
6351 #ifdef XK_dead_degree
6352 || orig_keysym
== XK_dead_degree
6354 #ifdef XK_dead_acute
6355 || orig_keysym
== XK_dead_acute
6357 #ifdef XK_dead_cedilla
6358 || orig_keysym
== XK_dead_cedilla
6360 #ifdef XK_dead_breve
6361 || orig_keysym
== XK_dead_breve
6363 #ifdef XK_dead_ogonek
6364 || orig_keysym
== XK_dead_ogonek
6366 #ifdef XK_dead_caron
6367 || orig_keysym
== XK_dead_caron
6369 #ifdef XK_dead_doubleacute
6370 || orig_keysym
== XK_dead_doubleacute
6372 #ifdef XK_dead_abovedot
6373 || orig_keysym
== XK_dead_abovedot
6375 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
6376 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
6377 /* Any "vendor-specific" key is ok. */
6378 || (orig_keysym
& (1 << 28))
6379 || (keysym
!= NoSymbol
&& nbytes
== 0))
6380 && ! (IsModifierKey (orig_keysym
)
6381 /* The symbols from XK_ISO_Lock
6382 to XK_ISO_Last_Group_Lock
6383 don't have real modifiers but
6384 should be treated similarly to
6385 Mode_switch by Emacs. */
6386 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
6387 || ((unsigned)(orig_keysym
)
6389 && (unsigned)(orig_keysym
)
6390 <= XK_ISO_Last_Group_Lock
)
6394 STORE_KEYSYM_FOR_DEBUG (keysym
);
6395 /* make_lispy_event will convert this to a symbolic
6397 inev
.ie
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
6398 inev
.ie
.code
= keysym
;
6402 { /* Raw bytes, not keysym. */
6407 for (i
= 0, nchars
= 0; i
< nbytes
; i
++)
6409 if (ASCII_BYTE_P (copy_bufptr
[i
]))
6411 STORE_KEYSYM_FOR_DEBUG (copy_bufptr
[i
]);
6414 if (nchars
< nbytes
)
6416 /* Decode the input data. */
6420 /* The input should be decoded with `coding_system'
6421 which depends on which X*LookupString function
6422 we used just above and the locale. */
6423 setup_coding_system (coding_system
, &coding
);
6424 coding
.src_multibyte
= 0;
6425 coding
.dst_multibyte
= 1;
6426 /* The input is converted to events, thus we can't
6427 handle composition. Anyway, there's no XIM that
6428 gives us composition information. */
6429 coding
.common_flags
&= ~CODING_ANNOTATION_MASK
;
6431 require
= MAX_MULTIBYTE_LENGTH
* nbytes
;
6432 coding
.destination
= alloca (require
);
6433 coding
.dst_bytes
= require
;
6434 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
6435 decode_coding_c_string (&coding
, copy_bufptr
, nbytes
, Qnil
);
6436 nbytes
= coding
.produced
;
6437 nchars
= coding
.produced_char
;
6438 copy_bufptr
= coding
.destination
;
6441 /* Convert the input data to a sequence of
6442 character events. */
6443 for (i
= 0; i
< nbytes
; i
+= len
)
6445 if (nchars
== nbytes
)
6446 c
= copy_bufptr
[i
], len
= 1;
6448 c
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
, len
);
6449 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (c
)
6450 ? ASCII_KEYSTROKE_EVENT
6451 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6453 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
6458 inev
.ie
.kind
= NO_EVENT
; /* Already stored above. */
6460 if (keysym
== NoSymbol
)
6466 /* Don't dispatch this event since XtDispatchEvent calls
6467 XFilterEvent, and two calls in a row may freeze the
6475 last_user_time
= event
.xkey
.time
;
6477 /* Don't dispatch this event since XtDispatchEvent calls
6478 XFilterEvent, and two calls in a row may freeze the
6486 last_user_time
= event
.xcrossing
.time
;
6487 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6489 f
= x_any_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
6491 if (f
&& x_mouse_click_focus_ignore_position
)
6492 ignore_next_mouse_click_timeout
= event
.xmotion
.time
+ 200;
6494 /* EnterNotify counts as mouse movement,
6495 so update things that depend on mouse position. */
6496 if (f
&& !f
->output_data
.x
->hourglass_p
)
6497 note_mouse_movement (f
, &event
.xmotion
);
6499 /* We may get an EnterNotify on the buttons in the toolbar. In that
6500 case we moved out of any highlighted area and need to note this. */
6501 if (!f
&& last_mouse_glyph_frame
)
6502 note_mouse_movement (last_mouse_glyph_frame
, &event
.xmotion
);
6507 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6511 last_user_time
= event
.xcrossing
.time
;
6512 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6514 f
= x_top_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
6517 if (f
== dpyinfo
->mouse_face_mouse_frame
)
6519 /* If we move outside the frame, then we're
6520 certainly no longer on any text in the frame. */
6521 clear_mouse_face (dpyinfo
);
6522 dpyinfo
->mouse_face_mouse_frame
= 0;
6525 /* Generate a nil HELP_EVENT to cancel a help-echo.
6526 Do it only if there's something to cancel.
6527 Otherwise, the startup message is cleared when
6528 the mouse leaves the frame. */
6529 if (any_help_event_p
)
6533 /* See comment in EnterNotify above */
6534 else if (last_mouse_glyph_frame
)
6535 note_mouse_movement (last_mouse_glyph_frame
, &event
.xmotion
);
6540 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6545 last_user_time
= event
.xmotion
.time
;
6546 previous_help_echo_string
= help_echo_string
;
6547 help_echo_string
= Qnil
;
6549 if (dpyinfo
->grabbed
&& last_mouse_frame
6550 && FRAME_LIVE_P (last_mouse_frame
))
6551 f
= last_mouse_frame
;
6553 f
= x_window_to_frame (dpyinfo
, event
.xmotion
.window
);
6555 if (dpyinfo
->mouse_face_hidden
)
6557 dpyinfo
->mouse_face_hidden
= 0;
6558 clear_mouse_face (dpyinfo
);
6562 if (f
&& xg_event_is_for_scrollbar (f
, &event
))
6568 /* Generate SELECT_WINDOW_EVENTs when needed.
6569 Don't let popup menus influence things (bug#1261). */
6570 if (!NILP (Vmouse_autoselect_window
) && !popup_activated ())
6574 window
= window_from_coordinates (f
,
6575 event
.xmotion
.x
, event
.xmotion
.y
,
6578 /* Window will be selected only when it is not selected now and
6579 last mouse movement event was not in it. Minibuffer window
6580 will be selected only when it is active. */
6581 if (WINDOWP (window
)
6582 && !EQ (window
, last_window
)
6583 && !EQ (window
, selected_window
)
6584 /* For click-to-focus window managers
6585 create event iff we don't leave the
6587 && (focus_follows_mouse
6588 || (EQ (XWINDOW (window
)->frame
,
6589 XWINDOW (selected_window
)->frame
))))
6591 inev
.ie
.kind
= SELECT_WINDOW_EVENT
;
6592 inev
.ie
.frame_or_window
= window
;
6597 if (!note_mouse_movement (f
, &event
.xmotion
))
6598 help_echo_string
= previous_help_echo_string
;
6602 #ifndef USE_TOOLKIT_SCROLL_BARS
6603 struct scroll_bar
*bar
6604 = x_window_to_scroll_bar (event
.xmotion
.display
,
6605 event
.xmotion
.window
);
6608 x_scroll_bar_note_movement (bar
, &event
);
6609 #endif /* USE_TOOLKIT_SCROLL_BARS */
6611 /* If we move outside the frame, then we're
6612 certainly no longer on any text in the frame. */
6613 clear_mouse_face (dpyinfo
);
6616 /* If the contents of the global variable help_echo_string
6617 has changed, generate a HELP_EVENT. */
6618 if (!NILP (help_echo_string
)
6619 || !NILP (previous_help_echo_string
))
6624 case ConfigureNotify
:
6625 f
= x_top_window_to_frame (dpyinfo
, event
.xconfigure
.window
);
6628 && (f
= x_any_window_to_frame (dpyinfo
, event
.xconfigure
.window
))
6629 && event
.xconfigure
.window
== FRAME_X_WINDOW (f
))
6631 xg_frame_resized (f
, event
.xconfigure
.width
,
6632 event
.xconfigure
.height
);
6638 #ifndef USE_X_TOOLKIT
6640 int rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, event
.xconfigure
.height
);
6641 int columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, event
.xconfigure
.width
);
6643 /* In the toolkit version, change_frame_size
6644 is called by the code that handles resizing
6645 of the EmacsFrame widget. */
6647 /* Even if the number of character rows and columns has
6648 not changed, the font size may have changed, so we need
6649 to check the pixel dimensions as well. */
6650 if (columns
!= FRAME_COLS (f
)
6651 || rows
!= FRAME_LINES (f
)
6652 || event
.xconfigure
.width
!= FRAME_PIXEL_WIDTH (f
)
6653 || event
.xconfigure
.height
!= FRAME_PIXEL_HEIGHT (f
))
6655 change_frame_size (f
, rows
, columns
, 0, 1, 0);
6656 SET_FRAME_GARBAGED (f
);
6657 cancel_mouse_face (f
);
6660 FRAME_PIXEL_WIDTH (f
) = event
.xconfigure
.width
;
6661 FRAME_PIXEL_HEIGHT (f
) = event
.xconfigure
.height
;
6662 #endif /* not USE_GTK */
6666 /* GTK creates windows but doesn't map them.
6667 Only get real positions when mapped. */
6668 if (FRAME_GTK_OUTER_WIDGET (f
)
6669 && gtk_widget_get_mapped (FRAME_GTK_OUTER_WIDGET (f
)))
6672 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
6676 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
6677 xic_set_statusarea (f
);
6686 /* If we decide we want to generate an event to be seen
6687 by the rest of Emacs, we put it here. */
6690 memset (&compose_status
, 0, sizeof (compose_status
));
6691 last_mouse_glyph_frame
= 0;
6692 last_user_time
= event
.xbutton
.time
;
6694 if (dpyinfo
->grabbed
6696 && FRAME_LIVE_P (last_mouse_frame
))
6697 f
= last_mouse_frame
;
6699 f
= x_window_to_frame (dpyinfo
, event
.xbutton
.window
);
6702 if (f
&& xg_event_is_for_scrollbar (f
, &event
))
6707 /* Is this in the tool-bar? */
6708 if (WINDOWP (f
->tool_bar_window
)
6709 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
6712 int x
= event
.xbutton
.x
;
6713 int y
= event
.xbutton
.y
;
6715 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 1);
6716 tool_bar_p
= EQ (window
, f
->tool_bar_window
);
6718 if (tool_bar_p
&& event
.xbutton
.button
< 4)
6720 handle_tool_bar_click (f
, x
, y
,
6721 event
.xbutton
.type
== ButtonPress
,
6722 x_x_to_emacs_modifiers (dpyinfo
,
6723 event
.xbutton
.state
));
6728 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6729 if (! popup_activated ())
6732 if (ignore_next_mouse_click_timeout
)
6734 if (event
.type
== ButtonPress
6735 && (int)(event
.xbutton
.time
- ignore_next_mouse_click_timeout
) > 0)
6737 ignore_next_mouse_click_timeout
= 0;
6738 construct_mouse_click (&inev
.ie
, &event
.xbutton
, f
);
6740 if (event
.type
== ButtonRelease
)
6741 ignore_next_mouse_click_timeout
= 0;
6744 construct_mouse_click (&inev
.ie
, &event
.xbutton
, f
);
6746 if (FRAME_X_EMBEDDED_P (f
))
6747 xembed_send_message (f
, event
.xbutton
.time
,
6748 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
6752 struct scroll_bar
*bar
6753 = x_window_to_scroll_bar (event
.xbutton
.display
,
6754 event
.xbutton
.window
);
6756 #ifdef USE_TOOLKIT_SCROLL_BARS
6757 /* Make the "Ctrl-Mouse-2 splits window" work for toolkit
6759 if (bar
&& event
.xbutton
.state
& ControlMask
)
6761 x_scroll_bar_handle_click (bar
, &event
, &inev
.ie
);
6762 *finish
= X_EVENT_DROP
;
6764 #else /* not USE_TOOLKIT_SCROLL_BARS */
6766 x_scroll_bar_handle_click (bar
, &event
, &inev
.ie
);
6767 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6770 if (event
.type
== ButtonPress
)
6772 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
6773 last_mouse_frame
= f
;
6776 last_tool_bar_item
= -1;
6779 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
6781 /* Ignore any mouse motion that happened before this event;
6782 any subsequent mouse-movement Emacs events should reflect
6783 only motion after the ButtonPress/Release. */
6787 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6788 f
= x_menubar_window_to_frame (dpyinfo
, &event
);
6789 /* For a down-event in the menu bar,
6790 don't pass it to Xt right now.
6791 Instead, save it away
6792 and we will pass it to Xt from kbd_buffer_get_event.
6793 That way, we can run some Lisp code first. */
6794 if (! popup_activated ()
6796 /* Gtk+ menus only react to the first three buttons. */
6797 && event
.xbutton
.button
< 3
6799 && f
&& event
.type
== ButtonPress
6800 /* Verify the event is really within the menu bar
6801 and not just sent to it due to grabbing. */
6802 && event
.xbutton
.x
>= 0
6803 && event
.xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
6804 && event
.xbutton
.y
>= 0
6805 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
6806 && event
.xbutton
.same_screen
)
6808 SET_SAVED_BUTTON_EVENT
;
6809 XSETFRAME (last_mouse_press_frame
, f
);
6810 *finish
= X_EVENT_DROP
;
6812 else if (event
.type
== ButtonPress
)
6814 last_mouse_press_frame
= Qnil
;
6819 #endif /* USE_X_TOOLKIT || USE_GTK */
6823 case CirculateNotify
:
6826 case CirculateRequest
:
6829 case VisibilityNotify
:
6833 /* Someone has changed the keyboard mapping - update the
6835 switch (event
.xmapping
.request
)
6837 case MappingModifier
:
6838 x_find_modifier_meanings (dpyinfo
);
6839 /* This is meant to fall through. */
6840 case MappingKeyboard
:
6841 XRefreshKeyboardMapping (&event
.xmapping
);
6846 xft_settings_event (dpyinfo
, &event
);
6851 #ifdef USE_X_TOOLKIT
6853 if (*finish
!= X_EVENT_DROP
)
6854 XtDispatchEvent (&event
);
6856 #endif /* USE_X_TOOLKIT */
6861 if (inev
.ie
.kind
!= NO_EVENT
)
6863 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
6868 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
6873 XSETFRAME (frame
, f
);
6879 any_help_event_p
= 1;
6880 gen_help_event (help_echo_string
, frame
, help_echo_window
,
6881 help_echo_object
, help_echo_pos
);
6885 help_echo_string
= Qnil
;
6886 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
6896 /* Handles the XEvent EVENT on display DISPLAY.
6897 This is used for event loops outside the normal event handling,
6898 i.e. looping while a popup menu or a dialog is posted.
6900 Returns the value handle_one_xevent sets in the finish argument. */
6902 x_dispatch_event (XEvent
*event
, Display
*display
)
6904 struct x_display_info
*dpyinfo
;
6905 int finish
= X_EVENT_NORMAL
;
6907 dpyinfo
= x_display_info_for_display (display
);
6910 handle_one_xevent (dpyinfo
, event
, &finish
, 0);
6916 /* Read events coming from the X server.
6917 This routine is called by the SIGIO handler.
6918 We return as soon as there are no more events to be read.
6920 We return the number of characters stored into the buffer,
6921 thus pretending to be `read' (except the characters we store
6922 in the keyboard buffer can be multibyte, so are not necessarily
6925 EXPECTED is nonzero if the caller knows input is available. */
6928 XTread_socket (struct terminal
*terminal
, int expected
, struct input_event
*hold_quit
)
6932 int event_found
= 0;
6934 if (interrupt_input_blocked
)
6936 interrupt_input_pending
= 1;
6938 pending_signals
= 1;
6943 interrupt_input_pending
= 0;
6945 pending_signals
= pending_atimers
;
6949 /* So people can tell when we have read the available input. */
6950 input_signal_count
++;
6955 /* Only check session manager input for the primary display. */
6956 if (terminal
->id
== 1 && x_session_have_connection ())
6958 struct input_event inev
;
6960 /* We don't need to EVENT_INIT (inev) here, as
6961 x_session_check_input copies an entire input_event. */
6962 if (x_session_check_input (&inev
))
6964 kbd_buffer_store_event_hold (&inev
, hold_quit
);
6971 /* For debugging, this gives a way to fake an I/O error. */
6972 if (terminal
->display_info
.x
== XTread_socket_fake_io_error
)
6974 XTread_socket_fake_io_error
= 0;
6975 x_io_error_quitter (terminal
->display_info
.x
->display
);
6979 while (XPending (terminal
->display_info
.x
->display
))
6983 XNextEvent (terminal
->display_info
.x
->display
, &event
);
6986 /* Filter events for the current X input method. */
6987 if (x_filter_event (terminal
->display_info
.x
, &event
))
6992 count
+= handle_one_xevent (terminal
->display_info
.x
,
6993 &event
, &finish
, hold_quit
);
6995 if (finish
== X_EVENT_GOTO_OUT
)
7001 /* For GTK we must use the GTK event loop. But XEvents gets passed
7002 to our filter function above, and then to the big event switch.
7003 We use a bunch of globals to communicate with our filter function,
7004 that is kind of ugly, but it works.
7006 There is no way to do one display at the time, GTK just does events
7007 from all displays. */
7009 while (gtk_events_pending ())
7011 current_count
= count
;
7012 current_hold_quit
= hold_quit
;
7014 gtk_main_iteration ();
7016 count
= current_count
;
7018 current_hold_quit
= 0;
7020 if (current_finish
== X_EVENT_GOTO_OUT
)
7023 #endif /* USE_GTK */
7027 /* On some systems, an X bug causes Emacs to get no more events
7028 when the window is destroyed. Detect that. (1994.) */
7031 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
7032 One XNOOP in 100 loops will make Emacs terminate.
7033 B. Bretthauer, 1994 */
7035 if (x_noop_count
>= 100)
7039 if (next_noop_dpyinfo
== 0)
7040 next_noop_dpyinfo
= x_display_list
;
7042 XNoOp (next_noop_dpyinfo
->display
);
7044 /* Each time we get here, cycle through the displays now open. */
7045 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
7049 /* If the focus was just given to an auto-raising frame,
7051 /* ??? This ought to be able to handle more than one such frame. */
7052 if (pending_autoraise_frame
)
7054 x_raise_frame (pending_autoraise_frame
);
7055 pending_autoraise_frame
= 0;
7067 /***********************************************************************
7069 ***********************************************************************/
7071 /* Set clipping for output in glyph row ROW. W is the window in which
7072 we operate. GC is the graphics context to set clipping in.
7074 ROW may be a text row or, e.g., a mode line. Text rows must be
7075 clipped to the interior of the window dedicated to text display,
7076 mode lines must be clipped to the whole window. */
7079 x_clip_to_row (struct window
*w
, struct glyph_row
*row
, int area
, GC gc
)
7081 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7082 XRectangle clip_rect
;
7083 int window_x
, window_y
, window_width
;
7085 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
7087 clip_rect
.x
= window_x
;
7088 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, row
->y
));
7089 clip_rect
.y
= max (clip_rect
.y
, window_y
);
7090 clip_rect
.width
= window_width
;
7091 clip_rect
.height
= row
->visible_height
;
7093 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
7097 /* Draw a hollow box cursor on window W in glyph row ROW. */
7100 x_draw_hollow_cursor (struct window
*w
, struct glyph_row
*row
)
7102 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7103 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7104 Display
*dpy
= FRAME_X_DISPLAY (f
);
7107 struct glyph
*cursor_glyph
;
7110 /* Get the glyph the cursor is on. If we can't tell because
7111 the current matrix is invalid or such, give up. */
7112 cursor_glyph
= get_phys_cursor_glyph (w
);
7113 if (cursor_glyph
== NULL
)
7116 /* Compute frame-relative coordinates for phys cursor. */
7117 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &x
, &y
, &h
);
7118 wd
= w
->phys_cursor_width
;
7120 /* The foreground of cursor_gc is typically the same as the normal
7121 background color, which can cause the cursor box to be invisible. */
7122 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7123 if (dpyinfo
->scratch_cursor_gc
)
7124 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
7126 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
7127 GCForeground
, &xgcv
);
7128 gc
= dpyinfo
->scratch_cursor_gc
;
7130 /* Set clipping, draw the rectangle, and reset clipping again. */
7131 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7132 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
- 1);
7133 XSetClipMask (dpy
, gc
, None
);
7137 /* Draw a bar cursor on window W in glyph row ROW.
7139 Implementation note: One would like to draw a bar cursor with an
7140 angle equal to the one given by the font property XA_ITALIC_ANGLE.
7141 Unfortunately, I didn't find a font yet that has this property set.
7145 x_draw_bar_cursor (struct window
*w
, struct glyph_row
*row
, int width
, enum text_cursor_kinds kind
)
7147 struct frame
*f
= XFRAME (w
->frame
);
7148 struct glyph
*cursor_glyph
;
7150 /* If cursor is out of bounds, don't draw garbage. This can happen
7151 in mini-buffer windows when switching between echo area glyphs
7153 cursor_glyph
= get_phys_cursor_glyph (w
);
7154 if (cursor_glyph
== NULL
)
7157 /* If on an image, draw like a normal cursor. That's usually better
7158 visible than drawing a bar, esp. if the image is large so that
7159 the bar might not be in the window. */
7160 if (cursor_glyph
->type
== IMAGE_GLYPH
)
7162 struct glyph_row
*row
;
7163 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
7164 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
7168 Display
*dpy
= FRAME_X_DISPLAY (f
);
7169 Window window
= FRAME_X_WINDOW (f
);
7170 GC gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
7171 unsigned long mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
7172 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
7175 /* If the glyph's background equals the color we normally draw
7176 the bars cursor in, the bar cursor in its normal color is
7177 invisible. Use the glyph's foreground color instead in this
7178 case, on the assumption that the glyph's colors are chosen so
7179 that the glyph is legible. */
7180 if (face
->background
== f
->output_data
.x
->cursor_pixel
)
7181 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
7183 xgcv
.background
= xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7184 xgcv
.graphics_exposures
= 0;
7187 XChangeGC (dpy
, gc
, mask
, &xgcv
);
7190 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
7191 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
7194 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7196 if (kind
== BAR_CURSOR
)
7198 int x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
7201 width
= FRAME_CURSOR_WIDTH (f
);
7202 width
= min (cursor_glyph
->pixel_width
, width
);
7204 w
->phys_cursor_width
= width
;
7206 /* If the character under cursor is R2L, draw the bar cursor
7207 on the right of its glyph, rather than on the left. */
7208 if ((cursor_glyph
->resolved_level
& 1) != 0)
7209 x
+= cursor_glyph
->pixel_width
- width
;
7211 XFillRectangle (dpy
, window
, gc
, x
,
7212 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
7213 width
, row
->height
);
7217 int dummy_x
, dummy_y
, dummy_h
;
7220 width
= row
->height
;
7222 width
= min (row
->height
, width
);
7224 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &dummy_x
,
7225 &dummy_y
, &dummy_h
);
7227 XFillRectangle (dpy
, window
, gc
,
7228 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
7229 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
7230 row
->height
- width
),
7231 w
->phys_cursor_width
, width
);
7234 XSetClipMask (dpy
, gc
, None
);
7239 /* RIF: Define cursor CURSOR on frame F. */
7242 x_define_frame_cursor (struct frame
*f
, Cursor cursor
)
7244 if (!f
->pointer_invisible
7245 && f
->output_data
.x
->current_cursor
!= cursor
)
7246 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
7247 f
->output_data
.x
->current_cursor
= cursor
;
7251 /* RIF: Clear area on frame F. */
7254 x_clear_frame_area (struct frame
*f
, int x
, int y
, int width
, int height
)
7256 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7257 x
, y
, width
, height
, False
);
7259 /* Must queue a redraw, because scroll bars might have been cleared. */
7260 if (FRAME_GTK_WIDGET (f
))
7261 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
7266 /* RIF: Draw cursor on window W. */
7269 x_draw_window_cursor (struct window
*w
, struct glyph_row
*glyph_row
, int x
, int y
, int cursor_type
, int cursor_width
, int on_p
, int active_p
)
7271 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7275 w
->phys_cursor_type
= cursor_type
;
7276 w
->phys_cursor_on_p
= 1;
7278 if (glyph_row
->exact_window_width_line_p
7279 && (glyph_row
->reversed_p
7280 ? (w
->phys_cursor
.hpos
< 0)
7281 : (w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])))
7283 glyph_row
->cursor_in_fringe_p
= 1;
7284 draw_fringe_bitmap (w
, glyph_row
, glyph_row
->reversed_p
);
7288 switch (cursor_type
)
7290 case HOLLOW_BOX_CURSOR
:
7291 x_draw_hollow_cursor (w
, glyph_row
);
7294 case FILLED_BOX_CURSOR
:
7295 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
7299 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
7303 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
7307 w
->phys_cursor_width
= 0;
7316 if (w
== XWINDOW (f
->selected_window
))
7317 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
7318 xic_set_preeditarea (w
, x
, y
);
7323 XFlush (FRAME_X_DISPLAY (f
));
7330 /* Make the x-window of frame F use the gnu icon bitmap. */
7333 x_bitmap_icon (struct frame
*f
, Lisp_Object file
)
7337 if (FRAME_X_WINDOW (f
) == 0)
7340 /* Free up our existing icon bitmap and mask if any. */
7341 if (f
->output_data
.x
->icon_bitmap
> 0)
7342 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7343 f
->output_data
.x
->icon_bitmap
= 0;
7348 /* Use gtk_window_set_icon_from_file () if available,
7349 It's not restricted to bitmaps */
7350 if (xg_set_icon (f
, file
))
7352 #endif /* USE_GTK */
7353 bitmap_id
= x_create_bitmap_from_file (f
, file
);
7354 x_create_bitmap_mask (f
, bitmap_id
);
7358 /* Create the GNU bitmap and mask if necessary. */
7359 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
7365 if (xg_set_icon (f
, xg_default_icon_file
)
7366 || xg_set_icon_from_xpm_data (f
, gnu_xpm_bits
))
7369 #elif defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
7371 rc
= x_create_bitmap_from_xpm_data (f
, gnu_xpm_bits
);
7373 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
7377 /* If all else fails, use the (black and white) xbm image. */
7380 rc
= x_create_bitmap_from_data (f
, gnu_xbm_bits
,
7381 gnu_xbm_width
, gnu_xbm_height
);
7385 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
7386 x_create_bitmap_mask (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
7390 /* The first time we create the GNU bitmap and mask,
7391 this increments the ref-count one extra time.
7392 As a result, the GNU bitmap and mask are never freed.
7393 That way, we don't have to worry about allocating it again. */
7394 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
7396 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
7399 x_wm_set_icon_pixmap (f
, bitmap_id
);
7400 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
7406 /* Make the x-window of frame F use a rectangle with text.
7407 Use ICON_NAME as the text. */
7410 x_text_icon (struct frame
*f
, const char *icon_name
)
7412 if (FRAME_X_WINDOW (f
) == 0)
7417 text
.value
= (unsigned char *) icon_name
;
7418 text
.encoding
= XA_STRING
;
7420 text
.nitems
= strlen (icon_name
);
7421 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
7424 if (f
->output_data
.x
->icon_bitmap
> 0)
7425 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7426 f
->output_data
.x
->icon_bitmap
= 0;
7427 x_wm_set_icon_pixmap (f
, 0);
7432 #define X_ERROR_MESSAGE_SIZE 200
7434 /* If non-nil, this should be a string.
7435 It means catch X errors and store the error message in this string.
7437 The reason we use a stack is that x_catch_error/x_uncatch_error can
7438 be called from a signal handler.
7441 struct x_error_message_stack
{
7442 char string
[X_ERROR_MESSAGE_SIZE
];
7444 struct x_error_message_stack
*prev
;
7446 static struct x_error_message_stack
*x_error_message
;
7448 /* An X error handler which stores the error message in
7449 *x_error_message. This is called from x_error_handler if
7450 x_catch_errors is in effect. */
7453 x_error_catcher (Display
*display
, XErrorEvent
*error
)
7455 XGetErrorText (display
, error
->error_code
,
7456 x_error_message
->string
,
7457 X_ERROR_MESSAGE_SIZE
);
7460 /* Begin trapping X errors for display DPY. Actually we trap X errors
7461 for all displays, but DPY should be the display you are actually
7464 After calling this function, X protocol errors no longer cause
7465 Emacs to exit; instead, they are recorded in the string
7466 stored in *x_error_message.
7468 Calling x_check_errors signals an Emacs error if an X error has
7469 occurred since the last call to x_catch_errors or x_check_errors.
7471 Calling x_uncatch_errors resumes the normal error handling. */
7473 void x_check_errors (Display
*dpy
, const char *format
);
7476 x_catch_errors (Display
*dpy
)
7478 struct x_error_message_stack
*data
= xmalloc (sizeof (*data
));
7480 /* Make sure any errors from previous requests have been dealt with. */
7484 data
->string
[0] = 0;
7485 data
->prev
= x_error_message
;
7486 x_error_message
= data
;
7489 /* Undo the last x_catch_errors call.
7490 DPY should be the display that was passed to x_catch_errors. */
7493 x_uncatch_errors (void)
7495 struct x_error_message_stack
*tmp
;
7499 /* The display may have been closed before this function is called.
7500 Check if it is still open before calling XSync. */
7501 if (x_display_info_for_display (x_error_message
->dpy
) != 0)
7502 XSync (x_error_message
->dpy
, False
);
7504 tmp
= x_error_message
;
7505 x_error_message
= x_error_message
->prev
;
7510 /* If any X protocol errors have arrived since the last call to
7511 x_catch_errors or x_check_errors, signal an Emacs error using
7512 sprintf (a buffer, FORMAT, the x error message text) as the text. */
7515 x_check_errors (Display
*dpy
, const char *format
)
7517 /* Make sure to catch any errors incurred so far. */
7520 if (x_error_message
->string
[0])
7522 char string
[X_ERROR_MESSAGE_SIZE
];
7523 memcpy (string
, x_error_message
->string
, X_ERROR_MESSAGE_SIZE
);
7524 x_uncatch_errors ();
7525 error (format
, string
);
7529 /* Nonzero if we had any X protocol errors
7530 since we did x_catch_errors on DPY. */
7533 x_had_errors_p (Display
*dpy
)
7535 /* Make sure to catch any errors incurred so far. */
7538 return x_error_message
->string
[0] != 0;
7541 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
7544 x_clear_errors (Display
*dpy
)
7546 x_error_message
->string
[0] = 0;
7549 #if 0 /* See comment in unwind_to_catch why calling this is a bad
7550 * idea. --lorentey */
7551 /* Close off all unclosed x_catch_errors calls. */
7554 x_fully_uncatch_errors (void)
7556 while (x_error_message
)
7557 x_uncatch_errors ();
7561 /* Nonzero if x_catch_errors has been done and not yet canceled. */
7564 x_catching_errors (void)
7566 return x_error_message
!= 0;
7570 static unsigned int x_wire_count
;
7573 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
7578 /* Handle SIGPIPE, which can happen when the connection to a server
7579 simply goes away. SIGPIPE is handled by x_connection_signal.
7580 Don't need to do anything, because the write which caused the
7581 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
7582 which will do the appropriate cleanup for us. */
7585 x_connection_signal (int signalnum
) /* If we don't have an argument, */
7586 /* some compilers complain in signal calls. */
7589 /* USG systems forget handlers when they are used;
7590 must reestablish each time */
7591 signal (signalnum
, x_connection_signal
);
7596 /************************************************************************
7598 ************************************************************************/
7600 /* Error message passed to x_connection_closed. */
7602 static char *error_msg
;
7604 /* Function installed as fatal_error_signal_hook in
7605 x_connection_closed. Print the X error message, and exit normally,
7606 instead of dumping core when XtCloseDisplay fails. */
7609 x_fatal_error_signal (void)
7611 fprintf (stderr
, "%s\n", error_msg
);
7615 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
7616 the text of an error message that lead to the connection loss. */
7619 x_connection_closed (Display
*dpy
, const char *error_message
)
7621 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
7622 Lisp_Object frame
, tail
;
7623 int index
= SPECPDL_INDEX ();
7625 error_msg
= (char *) alloca (strlen (error_message
) + 1);
7626 strcpy (error_msg
, error_message
);
7627 handling_signal
= 0;
7629 /* Prevent being called recursively because of an error condition
7630 below. Otherwise, we might end up with printing ``can't find per
7631 display information'' in the recursive call instead of printing
7632 the original message here. */
7633 x_catch_errors (dpy
);
7635 /* Inhibit redisplay while frames are being deleted. */
7636 specbind (Qinhibit_redisplay
, Qt
);
7640 /* Protect display from being closed when we delete the last
7642 dpyinfo
->reference_count
++;
7643 dpyinfo
->terminal
->reference_count
++;
7646 /* First delete frames whose mini-buffers are on frames
7647 that are on the dead display. */
7648 FOR_EACH_FRAME (tail
, frame
)
7650 Lisp_Object minibuf_frame
;
7652 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
7653 if (FRAME_X_P (XFRAME (frame
))
7654 && FRAME_X_P (XFRAME (minibuf_frame
))
7655 && ! EQ (frame
, minibuf_frame
)
7656 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
7657 delete_frame (frame
, Qnoelisp
);
7660 /* Now delete all remaining frames on the dead display.
7661 We are now sure none of these is used as the mini-buffer
7662 for another frame that we need to delete. */
7663 FOR_EACH_FRAME (tail
, frame
)
7664 if (FRAME_X_P (XFRAME (frame
))
7665 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
7667 /* Set this to t so that delete_frame won't get confused
7668 trying to find a replacement. */
7669 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
7670 delete_frame (frame
, Qnoelisp
);
7673 /* If DPYINFO is null, this means we didn't open the display in the
7674 first place, so don't try to close it. */
7677 #ifdef USE_X_TOOLKIT
7678 /* We have to close the display to inform Xt that it doesn't
7679 exist anymore. If we don't, Xt will continue to wait for
7680 events from the display. As a consequence, a sequence of
7682 M-x make-frame-on-display RET :1 RET
7683 ...kill the new frame, so that we get an IO error...
7684 M-x make-frame-on-display RET :1 RET
7686 will indefinitely wait in Xt for events for display `:1',
7687 opened in the first call to make-frame-on-display.
7689 Closing the display is reported to lead to a bus error on
7690 OpenWindows in certain situations. I suspect that is a bug
7691 in OpenWindows. I don't know how to circumvent it here. */
7692 fatal_error_signal_hook
= x_fatal_error_signal
;
7693 XtCloseDisplay (dpy
);
7694 fatal_error_signal_hook
= NULL
;
7695 #endif /* USE_X_TOOLKIT */
7698 /* A long-standing GTK bug prevents proper disconnect handling
7699 (https://bugzilla.gnome.org/show_bug.cgi?id=85715). Once,
7700 the resulting Glib error message loop filled a user's disk.
7701 To avoid this, kill Emacs unconditionally on disconnect. */
7702 shut_down_emacs (0, 0, Qnil
);
7703 fprintf (stderr
, "%s\n\
7704 When compiled with GTK, Emacs cannot recover from X disconnects.\n\
7705 This is a GTK bug: https://bugzilla.gnome.org/show_bug.cgi?id=85715\n\
7706 For details, see etc/PROBLEMS.\n",
7709 #endif /* USE_GTK */
7711 /* Indicate that this display is dead. */
7712 dpyinfo
->display
= 0;
7714 dpyinfo
->reference_count
--;
7715 dpyinfo
->terminal
->reference_count
--;
7716 if (dpyinfo
->reference_count
!= 0)
7717 /* We have just closed all frames on this display. */
7722 XSETTERMINAL (tmp
, dpyinfo
->terminal
);
7723 Fdelete_terminal (tmp
, Qnoelisp
);
7727 x_uncatch_errors ();
7729 if (terminal_list
== 0)
7731 fprintf (stderr
, "%s\n", error_msg
);
7732 Fkill_emacs (make_number (70));
7736 /* Ordinary stack unwind doesn't deal with these. */
7738 sigunblock (sigmask (SIGIO
));
7740 sigunblock (sigmask (SIGALRM
));
7741 TOTALLY_UNBLOCK_INPUT
;
7743 unbind_to (index
, Qnil
);
7744 clear_waiting_for_input ();
7745 /* Here, we absolutely have to use a non-local exit (e.g. signal, throw,
7746 longjmp), because returning from this function would get us back into
7747 Xlib's code which will directly call `exit'. */
7748 error ("%s", error_msg
);
7751 /* We specifically use it before defining it, so that gcc doesn't inline it,
7752 otherwise gdb doesn't know how to properly put a breakpoint on it. */
7753 static void x_error_quitter (Display
*, XErrorEvent
*);
7755 /* This is the first-level handler for X protocol errors.
7756 It calls x_error_quitter or x_error_catcher. */
7759 x_error_handler (Display
*display
, XErrorEvent
*error
)
7761 if (x_error_message
)
7762 x_error_catcher (display
, error
);
7764 x_error_quitter (display
, error
);
7768 /* This is the usual handler for X protocol errors.
7769 It kills all frames on the display that we got the error for.
7770 If that was the only one, it prints an error message and kills Emacs. */
7772 /* .gdbinit puts a breakpoint here, so make sure it is not inlined. */
7774 /* On older GCC versions, just putting x_error_quitter
7775 after x_error_handler prevents inlining into the former. */
7777 static void NO_INLINE
7778 x_error_quitter (Display
*display
, XErrorEvent
*error
)
7780 char buf
[256], buf1
[356];
7782 /* Ignore BadName errors. They can happen because of fonts
7783 or colors that are not defined. */
7785 if (error
->error_code
== BadName
)
7788 /* Note that there is no real way portable across R3/R4 to get the
7789 original error handler. */
7791 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
7792 sprintf (buf1
, "X protocol error: %s on protocol request %d",
7793 buf
, error
->request_code
);
7794 x_connection_closed (display
, buf1
);
7798 /* This is the handler for X IO errors, always.
7799 It kills all frames on the display that we lost touch with.
7800 If that was the only one, it prints an error message and kills Emacs. */
7803 x_io_error_quitter (Display
*display
)
7807 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
7808 x_connection_closed (display
, buf
);
7812 /* Changing the font of the frame. */
7814 /* Give frame F the font FONT-OBJECT as its default font. The return
7815 value is FONT-OBJECT. FONTSET is an ID of the fontset for the
7816 frame. If it is negative, generate a new fontset from
7820 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
7822 struct font
*font
= XFONT_OBJECT (font_object
);
7825 fontset
= fontset_from_font (font_object
);
7826 FRAME_FONTSET (f
) = fontset
;
7827 if (FRAME_FONT (f
) == font
)
7828 /* This font is already set in frame F. There's nothing more to
7832 FRAME_FONT (f
) = font
;
7833 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
7834 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
7835 FRAME_SPACE_WIDTH (f
) = font
->space_width
;
7836 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (font
);
7838 compute_fringe_widths (f
, 1);
7840 /* Compute the scroll bar width in character columns. */
7841 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
7843 int wid
= FRAME_COLUMN_WIDTH (f
);
7844 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
7845 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
-1) / wid
;
7849 int wid
= FRAME_COLUMN_WIDTH (f
);
7850 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
7853 if (FRAME_X_WINDOW (f
) != 0)
7855 /* Don't change the size of a tip frame; there's no point in
7856 doing it because it's done in Fx_show_tip, and it leads to
7857 problems because the tip frame has no widget. */
7858 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
7859 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
7864 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
7867 xic_set_xfontset (f
, SDATA (fontset_ascii (fontset
)));
7876 /***********************************************************************
7878 ***********************************************************************/
7884 /* XIM destroy callback function, which is called whenever the
7885 connection to input method XIM dies. CLIENT_DATA contains a
7886 pointer to the x_display_info structure corresponding to XIM. */
7889 xim_destroy_callback (XIM xim
, XPointer client_data
, XPointer call_data
)
7891 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
7892 Lisp_Object frame
, tail
;
7896 /* No need to call XDestroyIC.. */
7897 FOR_EACH_FRAME (tail
, frame
)
7899 struct frame
*f
= XFRAME (frame
);
7900 if (FRAME_X_P (f
) && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
7902 FRAME_XIC (f
) = NULL
;
7903 xic_free_xfontset (f
);
7907 /* No need to call XCloseIM. */
7908 dpyinfo
->xim
= NULL
;
7909 XFree (dpyinfo
->xim_styles
);
7913 #endif /* HAVE_X11R6 */
7916 /* This isn't prototyped in OSF 5.0 or 5.1a. */
7917 extern char *XSetIMValues (XIM
, ...);
7920 /* Open the connection to the XIM server on display DPYINFO.
7921 RESOURCE_NAME is the resource name Emacs uses. */
7924 xim_open_dpy (struct x_display_info
*dpyinfo
, char *resource_name
)
7932 XCloseIM (dpyinfo
->xim
);
7933 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
,
7940 XIMCallback destroy
;
7943 /* Get supported styles and XIM values. */
7944 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
7947 destroy
.callback
= xim_destroy_callback
;
7948 destroy
.client_data
= (XPointer
)dpyinfo
;
7949 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
7955 #endif /* HAVE_XIM */
7956 dpyinfo
->xim
= NULL
;
7960 #ifdef HAVE_X11R6_XIM
7962 /* XIM instantiate callback function, which is called whenever an XIM
7963 server is available. DISPLAY is the display of the XIM.
7964 CLIENT_DATA contains a pointer to an xim_inst_t structure created
7965 when the callback was registered. */
7968 xim_instantiate_callback (Display
*display
, XPointer client_data
, XPointer call_data
)
7970 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
7971 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
7973 /* We don't support multiple XIM connections. */
7977 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
7979 /* Create XIC for the existing frames on the same display, as long
7980 as they have no XIC. */
7981 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
7983 Lisp_Object tail
, frame
;
7986 FOR_EACH_FRAME (tail
, frame
)
7988 struct frame
*f
= XFRAME (frame
);
7991 && FRAME_X_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
7992 if (FRAME_XIC (f
) == NULL
)
7994 create_frame_xic (f
);
7995 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
7996 xic_set_statusarea (f
);
7997 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
7999 struct window
*w
= XWINDOW (f
->selected_window
);
8000 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
8009 #endif /* HAVE_X11R6_XIM */
8012 /* Open a connection to the XIM server on display DPYINFO.
8013 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
8014 connection only at the first time. On X11R6, open the connection
8015 in the XIM instantiate callback function. */
8018 xim_initialize (struct x_display_info
*dpyinfo
, char *resource_name
)
8020 dpyinfo
->xim
= NULL
;
8024 #ifdef HAVE_X11R6_XIM
8025 struct xim_inst_t
*xim_inst
;
8028 xim_inst
= (struct xim_inst_t
*) xmalloc (sizeof (struct xim_inst_t
));
8029 dpyinfo
->xim_callback_data
= xim_inst
;
8030 xim_inst
->dpyinfo
= dpyinfo
;
8031 len
= strlen (resource_name
);
8032 xim_inst
->resource_name
= (char *) xmalloc (len
+ 1);
8033 memcpy (xim_inst
->resource_name
, resource_name
, len
+ 1);
8034 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8035 resource_name
, emacs_class
,
8036 xim_instantiate_callback
,
8037 /* This is XPointer in XFree86
8038 but (XPointer *) on Tru64, at
8039 least, hence the configure test. */
8040 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
8041 #else /* not HAVE_X11R6_XIM */
8042 xim_open_dpy (dpyinfo
, resource_name
);
8043 #endif /* not HAVE_X11R6_XIM */
8045 #endif /* HAVE_XIM */
8049 /* Close the connection to the XIM server on display DPYINFO. */
8052 xim_close_dpy (struct x_display_info
*dpyinfo
)
8057 #ifdef HAVE_X11R6_XIM
8058 if (dpyinfo
->display
)
8059 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8061 xim_instantiate_callback
, NULL
);
8062 xfree (dpyinfo
->xim_callback_data
->resource_name
);
8063 xfree (dpyinfo
->xim_callback_data
);
8064 #endif /* HAVE_X11R6_XIM */
8065 if (dpyinfo
->display
)
8066 XCloseIM (dpyinfo
->xim
);
8067 dpyinfo
->xim
= NULL
;
8068 XFree (dpyinfo
->xim_styles
);
8070 #endif /* HAVE_XIM */
8073 #endif /* not HAVE_X11R6_XIM */
8077 /* Calculate the absolute position in frame F
8078 from its current recorded position values and gravity. */
8081 x_calc_absolute_position (struct frame
*f
)
8083 int flags
= f
->size_hint_flags
;
8085 /* We have nothing to do if the current position
8086 is already for the top-left corner. */
8087 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
8090 /* Treat negative positions as relative to the leftmost bottommost
8091 position that fits on the screen. */
8092 if (flags
& XNegative
)
8093 f
->left_pos
= x_display_pixel_width (FRAME_X_DISPLAY_INFO (f
))
8094 - FRAME_PIXEL_WIDTH (f
) + f
->left_pos
;
8097 int height
= FRAME_PIXEL_HEIGHT (f
);
8099 #if defined USE_X_TOOLKIT && defined USE_MOTIF
8100 /* Something is fishy here. When using Motif, starting Emacs with
8101 `-g -0-0', the frame appears too low by a few pixels.
8103 This seems to be so because initially, while Emacs is starting,
8104 the column widget's height and the frame's pixel height are
8105 different. The column widget's height is the right one. In
8106 later invocations, when Emacs is up, the frame's pixel height
8109 It's not obvious where the initial small difference comes from.
8110 2000-12-01, gerd. */
8112 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
8115 if (flags
& YNegative
)
8116 f
->top_pos
= x_display_pixel_height (FRAME_X_DISPLAY_INFO (f
))
8117 - height
+ f
->top_pos
;
8120 /* The left_pos and top_pos
8121 are now relative to the top and left screen edges,
8122 so the flags should correspond. */
8123 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8126 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
8127 to really change the position, and 0 when calling from
8128 x_make_frame_visible (in that case, XOFF and YOFF are the current
8129 position values). It is -1 when calling from x_set_frame_parameters,
8130 which means, do adjust for borders but don't change the gravity. */
8133 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
, int change_gravity
)
8135 int modified_top
, modified_left
;
8137 if (change_gravity
> 0)
8139 FRAME_X_OUTPUT (f
)->left_before_move
= f
->left_pos
;
8140 FRAME_X_OUTPUT (f
)->top_before_move
= f
->top_pos
;
8144 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8146 f
->size_hint_flags
|= XNegative
;
8148 f
->size_hint_flags
|= YNegative
;
8149 f
->win_gravity
= NorthWestGravity
;
8151 x_calc_absolute_position (f
);
8154 x_wm_set_size_hint (f
, (long) 0, 0);
8156 modified_left
= f
->left_pos
;
8157 modified_top
= f
->top_pos
;
8159 if (change_gravity
!= 0 && FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
)
8161 /* Some WMs (twm, wmaker at least) has an offset that is smaller
8162 than the WM decorations. So we use the calculated offset instead
8163 of the WM decoration sizes here (x/y_pixels_outer_diff). */
8164 modified_left
+= FRAME_X_OUTPUT (f
)->move_offset_left
;
8165 modified_top
+= FRAME_X_OUTPUT (f
)->move_offset_top
;
8168 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8169 modified_left
, modified_top
);
8171 x_sync_with_move (f
, f
->left_pos
, f
->top_pos
,
8172 FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8175 /* change_gravity is non-zero when this function is called from Lisp to
8176 programmatically move a frame. In that case, we call
8177 x_check_expected_move to discover if we have a "Type A" or "Type B"
8178 window manager, and, for a "Type A" window manager, adjust the position
8181 We call x_check_expected_move if a programmatic move occurred, and
8182 either the window manager type (A/B) is unknown or it is Type A but we
8183 need to compute the top/left offset adjustment for this frame. */
8185 if (change_gravity
!= 0 &&
8186 (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8187 || (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
8188 && (FRAME_X_OUTPUT (f
)->move_offset_left
== 0
8189 && FRAME_X_OUTPUT (f
)->move_offset_top
== 0))))
8190 x_check_expected_move (f
, modified_left
, modified_top
);
8195 /* Return non-zero if _NET_SUPPORTING_WM_CHECK window exists and _NET_SUPPORTED
8196 on the root window for frame F contains ATOMNAME.
8197 This is how a WM check shall be done according to the Window Manager
8198 Specification/Extended Window Manager Hints at
8199 http://freedesktop.org/wiki/Specifications/wm-spec. */
8202 wm_supports (struct frame
*f
, const char *atomname
)
8205 unsigned long actual_size
, bytes_remaining
;
8206 int i
, rc
, actual_format
;
8208 Window wmcheck_window
;
8209 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8210 Window target_window
= dpyinfo
->root_window
;
8211 long max_len
= 65536;
8212 Display
*dpy
= FRAME_X_DISPLAY (f
);
8213 unsigned char *tmp_data
= NULL
;
8214 Atom target_type
= XA_WINDOW
;
8219 prop_atom
= XInternAtom (dpy
, "_NET_SUPPORTING_WM_CHECK", False
);
8221 x_catch_errors (dpy
);
8222 rc
= XGetWindowProperty (dpy
, target_window
,
8223 prop_atom
, 0, max_len
, False
, target_type
,
8224 &actual_type
, &actual_format
, &actual_size
,
8225 &bytes_remaining
, &tmp_data
);
8227 if (rc
!= Success
|| actual_type
!= XA_WINDOW
|| x_had_errors_p (dpy
))
8229 if (tmp_data
) XFree (tmp_data
);
8230 x_uncatch_errors ();
8235 wmcheck_window
= *(Window
*) tmp_data
;
8238 /* Check if window exists. */
8239 XSelectInput (dpy
, wmcheck_window
, StructureNotifyMask
);
8241 if (x_had_errors_p (dpy
))
8243 x_uncatch_errors ();
8248 if (dpyinfo
->net_supported_window
!= wmcheck_window
)
8250 /* Window changed, reload atoms */
8251 if (dpyinfo
->net_supported_atoms
!= NULL
)
8252 XFree (dpyinfo
->net_supported_atoms
);
8253 dpyinfo
->net_supported_atoms
= NULL
;
8254 dpyinfo
->nr_net_supported_atoms
= 0;
8255 dpyinfo
->net_supported_window
= 0;
8257 target_type
= XA_ATOM
;
8258 prop_atom
= XInternAtom (dpy
, "_NET_SUPPORTED", False
);
8260 rc
= XGetWindowProperty (dpy
, target_window
,
8261 prop_atom
, 0, max_len
, False
, target_type
,
8262 &actual_type
, &actual_format
, &actual_size
,
8263 &bytes_remaining
, &tmp_data
);
8265 if (rc
!= Success
|| actual_type
!= XA_ATOM
|| x_had_errors_p (dpy
))
8267 if (tmp_data
) XFree (tmp_data
);
8268 x_uncatch_errors ();
8273 dpyinfo
->net_supported_atoms
= (Atom
*)tmp_data
;
8274 dpyinfo
->nr_net_supported_atoms
= actual_size
;
8275 dpyinfo
->net_supported_window
= wmcheck_window
;
8279 want_atom
= XInternAtom (dpy
, atomname
, False
);
8281 for (i
= 0; rc
== 0 && i
< dpyinfo
->nr_net_supported_atoms
; ++i
)
8282 rc
= dpyinfo
->net_supported_atoms
[i
] == want_atom
;
8284 x_uncatch_errors ();
8291 set_wm_state (Lisp_Object frame
, int add
, const char *what
, const char *what2
)
8293 const char *atom
= "_NET_WM_STATE";
8294 Fx_send_client_event (frame
, make_number (0), frame
,
8295 make_unibyte_string (atom
, strlen (atom
)),
8297 /* 1 = add, 0 = remove */
8299 (make_number (add
? 1 : 0),
8301 (make_unibyte_string (what
, strlen (what
)),
8303 ? Fcons (make_unibyte_string (what2
, strlen (what2
)),
8309 x_set_sticky (struct frame
*f
, Lisp_Object new_value
, Lisp_Object old_value
)
8313 XSETFRAME (frame
, f
);
8314 set_wm_state (frame
, NILP (new_value
) ? 0 : 1,
8315 "_NET_WM_STATE_STICKY", NULL
);
8318 /* Return the current _NET_WM_STATE.
8319 SIZE_STATE is set to one of the FULLSCREEN_* values.
8320 STICKY is set to 1 if the sticky state is set, 0 if not. */
8323 get_current_vm_state (struct frame
*f
,
8329 unsigned long actual_size
, bytes_remaining
;
8330 int i
, rc
, actual_format
;
8331 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8332 long max_len
= 65536;
8333 Display
*dpy
= FRAME_X_DISPLAY (f
);
8334 unsigned char *tmp_data
= NULL
;
8335 Atom target_type
= XA_ATOM
;
8338 *size_state
= FULLSCREEN_NONE
;
8341 x_catch_errors (dpy
);
8342 rc
= XGetWindowProperty (dpy
, window
, dpyinfo
->Xatom_net_wm_state
,
8343 0, max_len
, False
, target_type
,
8344 &actual_type
, &actual_format
, &actual_size
,
8345 &bytes_remaining
, &tmp_data
);
8347 if (rc
!= Success
|| actual_type
!= target_type
|| x_had_errors_p (dpy
))
8349 if (tmp_data
) XFree (tmp_data
);
8350 x_uncatch_errors ();
8355 x_uncatch_errors ();
8357 for (i
= 0; i
< actual_size
; ++i
)
8359 Atom a
= ((Atom
*)tmp_data
)[i
];
8360 if (a
== dpyinfo
->Xatom_net_wm_state_maximized_horz
)
8362 if (*size_state
== FULLSCREEN_HEIGHT
)
8363 *size_state
= FULLSCREEN_MAXIMIZED
;
8365 *size_state
= FULLSCREEN_WIDTH
;
8367 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_vert
)
8369 if (*size_state
== FULLSCREEN_WIDTH
)
8370 *size_state
= FULLSCREEN_MAXIMIZED
;
8372 *size_state
= FULLSCREEN_HEIGHT
;
8374 else if (a
== dpyinfo
->Xatom_net_wm_state_fullscreen_atom
)
8375 *size_state
= FULLSCREEN_BOTH
;
8376 else if (a
== dpyinfo
->Xatom_net_wm_state_sticky
)
8380 if (tmp_data
) XFree (tmp_data
);
8384 /* Do fullscreen as specified in extended window manager hints */
8387 do_ewmh_fullscreen (struct frame
*f
)
8389 int have_net_atom
= wm_supports (f
, "_NET_WM_STATE");
8390 Lisp_Object lval
= get_frame_param (f
, Qfullscreen
);
8393 get_current_vm_state (f
, FRAME_OUTER_WINDOW (f
), &cur
, &dummy
);
8395 /* Some window managers don't say they support _NET_WM_STATE, but they do say
8396 they support _NET_WM_STATE_FULLSCREEN. Try that also. */
8398 have_net_atom
= wm_supports (f
, "_NET_WM_STATE_FULLSCREEN");
8400 if (have_net_atom
&& cur
!= f
->want_fullscreen
)
8403 const char *fs
= "_NET_WM_STATE_FULLSCREEN";
8404 const char *fw
= "_NET_WM_STATE_MAXIMIZED_HORZ";
8405 const char *fh
= "_NET_WM_STATE_MAXIMIZED_VERT";
8407 XSETFRAME (frame
, f
);
8409 /* Keep number of calls to set_wm_state as low as possible.
8410 Some window managers, or possible Gtk+, hangs when too many
8411 are sent at once. */
8412 switch (f
->want_fullscreen
)
8414 case FULLSCREEN_BOTH
:
8415 if (cur
== FULLSCREEN_WIDTH
|| cur
== FULLSCREEN_MAXIMIZED
8416 || cur
== FULLSCREEN_HEIGHT
)
8417 set_wm_state (frame
, 0, fw
, fh
);
8418 set_wm_state (frame
, 1, fs
, NULL
);
8420 case FULLSCREEN_WIDTH
:
8421 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_HEIGHT
8422 || cur
== FULLSCREEN_MAXIMIZED
)
8423 set_wm_state (frame
, 0, fs
, fh
);
8424 if (cur
!= FULLSCREEN_MAXIMIZED
)
8425 set_wm_state (frame
, 1, fw
, NULL
);
8427 case FULLSCREEN_HEIGHT
:
8428 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_WIDTH
8429 || cur
== FULLSCREEN_MAXIMIZED
)
8430 set_wm_state (frame
, 0, fs
, fw
);
8431 if (cur
!= FULLSCREEN_MAXIMIZED
)
8432 set_wm_state (frame
, 1, fh
, NULL
);
8434 case FULLSCREEN_MAXIMIZED
:
8435 if (cur
== FULLSCREEN_BOTH
)
8436 set_wm_state (frame
, 0, fs
, NULL
);
8437 set_wm_state (frame
, 1, fw
, fh
);
8439 case FULLSCREEN_NONE
:
8440 if (cur
== FULLSCREEN_BOTH
)
8441 set_wm_state (frame
, 0, fs
, NULL
);
8443 set_wm_state (frame
, 0, fw
, fh
);
8446 f
->want_fullscreen
= FULLSCREEN_NONE
;
8450 return have_net_atom
;
8454 XTfullscreen_hook (FRAME_PTR f
)
8456 if (f
->async_visible
)
8459 x_check_fullscreen (f
);
8467 x_handle_net_wm_state (struct frame
*f
, XPropertyEvent
*event
)
8469 int value
= FULLSCREEN_NONE
;
8473 get_current_vm_state (f
, event
->window
, &value
, &sticky
);
8477 case FULLSCREEN_WIDTH
:
8480 case FULLSCREEN_HEIGHT
:
8483 case FULLSCREEN_BOTH
:
8486 case FULLSCREEN_MAXIMIZED
:
8491 store_frame_param (f
, Qfullscreen
, lval
);
8492 store_frame_param (f
, Qsticky
, sticky
? Qt
: Qnil
);
8495 /* Check if we need to resize the frame due to a fullscreen request.
8496 If so needed, resize the frame. */
8498 x_check_fullscreen (struct frame
*f
)
8500 if (do_ewmh_fullscreen (f
))
8503 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
8504 return; /* Only fullscreen without WM or with EWM hints (above). */
8506 if (f
->want_fullscreen
!= FULLSCREEN_NONE
)
8508 int width
= FRAME_COLS (f
), height
= FRAME_LINES (f
);
8509 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8511 switch (f
->want_fullscreen
)
8513 /* No difference between these two when there is no WM */
8514 case FULLSCREEN_BOTH
:
8515 case FULLSCREEN_MAXIMIZED
:
8516 width
= x_display_pixel_width (dpyinfo
);
8517 height
= x_display_pixel_height (dpyinfo
);
8519 case FULLSCREEN_WIDTH
:
8520 width
= x_display_pixel_width (dpyinfo
);
8522 case FULLSCREEN_HEIGHT
:
8523 height
= x_display_pixel_height (dpyinfo
);
8526 if (FRAME_COLS (f
) != width
|| FRAME_LINES (f
) != height
)
8528 change_frame_size (f
, height
, width
, 0, 1, 0);
8529 SET_FRAME_GARBAGED (f
);
8530 cancel_mouse_face (f
);
8535 /* This function is called by x_set_offset to determine whether the window
8536 manager interfered with the positioning of the frame. Type A window
8537 managers position the surrounding window manager decorations a small
8538 amount above and left of the user-supplied position. Type B window
8539 managers position the surrounding window manager decorations at the
8540 user-specified position. If we detect a Type A window manager, we
8541 compensate by moving the window right and down by the proper amount. */
8544 x_check_expected_move (struct frame
*f
, int expected_left
, int expected_top
)
8546 int current_left
= 0, current_top
= 0;
8548 /* x_real_positions returns the left and top offsets of the outermost
8549 window manager window around the frame. */
8551 x_real_positions (f
, ¤t_left
, ¤t_top
);
8553 if (current_left
!= expected_left
|| current_top
!= expected_top
)
8555 /* It's a "Type A" window manager. */
8560 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_A
;
8561 FRAME_X_OUTPUT (f
)->move_offset_left
= expected_left
- current_left
;
8562 FRAME_X_OUTPUT (f
)->move_offset_top
= expected_top
- current_top
;
8564 /* Now fix the mispositioned frame's location. */
8566 adjusted_left
= expected_left
+ FRAME_X_OUTPUT (f
)->move_offset_left
;
8567 adjusted_top
= expected_top
+ FRAME_X_OUTPUT (f
)->move_offset_top
;
8569 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8570 adjusted_left
, adjusted_top
);
8572 x_sync_with_move (f
, expected_left
, expected_top
, 0);
8575 /* It's a "Type B" window manager. We don't have to adjust the
8576 frame's position. */
8578 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_B
;
8582 /* Wait for XGetGeometry to return up-to-date position information for a
8583 recently-moved frame. Call this immediately after calling XMoveWindow.
8584 If FUZZY is non-zero, then LEFT and TOP are just estimates of where the
8585 frame has been moved to, so we use a fuzzy position comparison instead
8586 of an exact comparison. */
8589 x_sync_with_move (struct frame
*f
, int left
, int top
, int fuzzy
)
8593 while (count
++ < 50)
8595 int current_left
= 0, current_top
= 0;
8597 /* In theory, this call to XSync only needs to happen once, but in
8598 practice, it doesn't seem to work, hence the need for the surrounding
8601 XSync (FRAME_X_DISPLAY (f
), False
);
8602 x_real_positions (f
, ¤t_left
, ¤t_top
);
8606 /* The left fuzz-factor is 10 pixels. The top fuzz-factor is 40
8609 if (eabs (current_left
- left
) <= 10
8610 && eabs (current_top
- top
) <= 40)
8613 else if (current_left
== left
&& current_top
== top
)
8617 /* As a last resort, just wait 0.5 seconds and hope that XGetGeometry
8618 will then return up-to-date position info. */
8620 wait_reading_process_output (0, 500000, 0, 0, Qnil
, NULL
, 0);
8624 /* Wait for an event on frame F matching EVENTTYPE. */
8626 x_wait_for_event (struct frame
*f
, int eventtype
)
8628 int level
= interrupt_input_blocked
;
8631 EMACS_TIME tmo
, tmo_at
, time_now
;
8632 int fd
= ConnectionNumber (FRAME_X_DISPLAY (f
));
8634 pending_event_wait
.f
= f
;
8635 pending_event_wait
.eventtype
= eventtype
;
8637 /* Set timeout to 0.1 second. Hopefully not noticable.
8638 Maybe it should be configurable. */
8639 EMACS_SET_SECS_USECS (tmo
, 0, 100000);
8640 EMACS_GET_TIME (tmo_at
);
8641 EMACS_ADD_TIME (tmo_at
, tmo_at
, tmo
);
8643 while (pending_event_wait
.eventtype
)
8645 interrupt_input_pending
= 1;
8646 TOTALLY_UNBLOCK_INPUT
;
8647 /* XTread_socket is called after unblock. */
8649 interrupt_input_blocked
= level
;
8654 EMACS_GET_TIME (time_now
);
8655 EMACS_SUB_TIME (tmo
, tmo_at
, time_now
);
8657 if (EMACS_TIME_NEG_P (tmo
) || select (fd
+1, &fds
, NULL
, NULL
, &tmo
) == 0)
8658 break; /* Timeout */
8660 pending_event_wait
.f
= 0;
8661 pending_event_wait
.eventtype
= 0;
8665 /* Change the size of frame F's X window to COLS/ROWS in the case F
8666 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
8667 top-left-corner window gravity for this size change and subsequent
8668 size changes. Otherwise we leave the window gravity unchanged. */
8671 x_set_window_size_1 (struct frame
*f
, int change_gravity
, int cols
, int rows
)
8673 int pixelwidth
, pixelheight
;
8675 check_frame_size (f
, &rows
, &cols
);
8676 f
->scroll_bar_actual_width
8677 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
8679 : FRAME_CONFIG_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
));
8681 compute_fringe_widths (f
, 0);
8683 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
)
8684 + FRAME_TOOLBAR_WIDTH (f
);
8685 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
8686 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
8688 if (change_gravity
) f
->win_gravity
= NorthWestGravity
;
8689 x_wm_set_size_hint (f
, (long) 0, 0);
8690 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8691 pixelwidth
, pixelheight
);
8694 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
8695 receive in the ConfigureNotify event; if we get what we asked
8696 for, then the event won't cause the screen to become garbaged, so
8697 we have to make sure to do it here. */
8698 SET_FRAME_GARBAGED (f
);
8700 /* Now, strictly speaking, we can't be sure that this is accurate,
8701 but the window manager will get around to dealing with the size
8702 change request eventually, and we'll hear how it went when the
8703 ConfigureNotify event gets here.
8705 We could just not bother storing any of this information here,
8706 and let the ConfigureNotify event set everything up, but that
8707 might be kind of confusing to the Lisp code, since size changes
8708 wouldn't be reported in the frame parameters until some random
8709 point in the future when the ConfigureNotify event arrives.
8711 We pass 1 for DELAY since we can't run Lisp code inside of
8714 /* But the ConfigureNotify may in fact never arrive, and then this is
8715 not right if the frame is visible. Instead wait (with timeout)
8716 for the ConfigureNotify. */
8717 if (f
->async_visible
)
8718 x_wait_for_event (f
, ConfigureNotify
);
8721 change_frame_size (f
, rows
, cols
, 0, 1, 0);
8722 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
8723 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
8729 /* Call this to change the size of frame F's x-window.
8730 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
8731 for this size change and subsequent size changes.
8732 Otherwise we leave the window gravity unchanged. */
8735 x_set_window_size (struct frame
*f
, int change_gravity
, int cols
, int rows
)
8739 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
8743 /* When the frame is maximized/fullscreen or running under for
8744 example Xmonad, x_set_window_size_1 will be a no-op.
8745 In that case, the right thing to do is extend rows/cols to
8746 the current frame size. We do that first if x_set_window_size_1
8747 turns out to not be a no-op (there is no way to know).
8748 The size will be adjusted again if the frame gets a
8749 ConfigureNotify event as a result of x_set_window_size. */
8750 int pixelh
= FRAME_PIXEL_HEIGHT (f
);
8751 #ifdef USE_X_TOOLKIT
8752 /* The menu bar is not part of text lines. The tool bar
8754 pixelh
-= FRAME_MENUBAR_HEIGHT (f
);
8756 r
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelh
);
8757 /* Update f->scroll_bar_actual_width because it is used in
8758 FRAME_PIXEL_WIDTH_TO_TEXT_COLS. */
8759 f
->scroll_bar_actual_width
8760 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
8761 c
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, FRAME_PIXEL_WIDTH (f
));
8762 change_frame_size (f
, r
, c
, 0, 1, 0);
8766 if (FRAME_GTK_WIDGET (f
))
8767 xg_frame_set_char_size (f
, cols
, rows
);
8769 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8770 #else /* not USE_GTK */
8772 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8774 #endif /* not USE_GTK */
8776 /* If cursor was outside the new size, mark it as off. */
8777 mark_window_cursors_off (XWINDOW (f
->root_window
));
8779 /* Clear out any recollection of where the mouse highlighting was,
8780 since it might be in a place that's outside the new frame size.
8781 Actually checking whether it is outside is a pain in the neck,
8782 so don't try--just let the highlighting be done afresh with new size. */
8783 cancel_mouse_face (f
);
8788 /* Mouse warping. */
8791 x_set_mouse_position (struct frame
*f
, int x
, int y
)
8795 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
8796 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
8798 if (pix_x
< 0) pix_x
= 0;
8799 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
8801 if (pix_y
< 0) pix_y
= 0;
8802 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
8806 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8807 0, 0, 0, 0, pix_x
, pix_y
);
8811 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
8814 x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
8818 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8819 0, 0, 0, 0, pix_x
, pix_y
);
8823 /* focus shifting, raising and lowering. */
8826 x_focus_on_frame (struct frame
*f
)
8829 /* I don't think that the ICCCM allows programs to do things like this
8830 without the interaction of the window manager. Whatever you end up
8831 doing with this code, do it to x_unfocus_frame too. */
8832 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8833 RevertToPointerRoot
, CurrentTime
);
8838 x_unfocus_frame (struct frame
*f
)
8841 /* Look at the remarks in x_focus_on_frame. */
8842 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
8843 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
8844 RevertToPointerRoot
, CurrentTime
);
8848 /* Raise frame F. */
8851 x_raise_frame (struct frame
*f
)
8854 if (f
->async_visible
)
8855 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8857 XFlush (FRAME_X_DISPLAY (f
));
8861 /* Lower frame F. */
8864 x_lower_frame (struct frame
*f
)
8866 if (f
->async_visible
)
8869 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8870 XFlush (FRAME_X_DISPLAY (f
));
8875 /* Activate frame with Extended Window Manager Hints */
8878 x_ewmh_activate_frame (FRAME_PTR f
)
8880 /* See Window Manager Specification/Extended Window Manager Hints at
8881 http://freedesktop.org/wiki/Specifications/wm-spec */
8883 const char *atom
= "_NET_ACTIVE_WINDOW";
8884 if (f
->async_visible
&& wm_supports (f
, atom
))
8887 XSETFRAME (frame
, f
);
8888 Fx_send_client_event (frame
, make_number (0), frame
,
8889 make_unibyte_string (atom
, strlen (atom
)),
8891 Fcons (make_number (1),
8892 Fcons (make_number (last_user_time
),
8898 XTframe_raise_lower (FRAME_PTR f
, int raise_flag
)
8906 /* XEmbed implementation. */
8909 xembed_set_info (struct frame
*f
, enum xembed_info flags
)
8912 unsigned long data
[2];
8914 atom
= XInternAtom (FRAME_X_DISPLAY (f
), "_XEMBED_INFO", False
);
8916 data
[0] = XEMBED_VERSION
;
8919 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), atom
, atom
,
8920 32, PropModeReplace
, (unsigned char *) data
, 2);
8924 xembed_send_message (struct frame
*f
, Time time
, enum xembed_message message
, long int detail
, long int data1
, long int data2
)
8928 event
.xclient
.type
= ClientMessage
;
8929 event
.xclient
.window
= FRAME_X_OUTPUT (f
)->parent_desc
;
8930 event
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_XEMBED
;
8931 event
.xclient
.format
= 32;
8932 event
.xclient
.data
.l
[0] = time
;
8933 event
.xclient
.data
.l
[1] = message
;
8934 event
.xclient
.data
.l
[2] = detail
;
8935 event
.xclient
.data
.l
[3] = data1
;
8936 event
.xclient
.data
.l
[4] = data2
;
8938 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_OUTPUT (f
)->parent_desc
,
8939 False
, NoEventMask
, &event
);
8940 XSync (FRAME_X_DISPLAY (f
), False
);
8943 /* Change of visibility. */
8945 /* This tries to wait until the frame is really visible.
8946 However, if the window manager asks the user where to position
8947 the frame, this will return before the user finishes doing that.
8948 The frame will not actually be visible at that time,
8949 but it will become visible later when the window manager
8950 finishes with it. */
8953 x_make_frame_visible (struct frame
*f
)
8956 int original_top
, original_left
;
8957 int retry_count
= 2;
8963 type
= x_icon_type (f
);
8965 x_bitmap_icon (f
, type
);
8967 if (! FRAME_VISIBLE_P (f
))
8969 /* We test FRAME_GARBAGED_P here to make sure we don't
8970 call x_set_offset a second time
8971 if we get to x_make_frame_visible a second time
8972 before the window gets really visible. */
8973 if (! FRAME_ICONIFIED_P (f
)
8974 && ! FRAME_X_EMBEDDED_P (f
)
8975 && ! f
->output_data
.x
->asked_for_visible
)
8976 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
8978 f
->output_data
.x
->asked_for_visible
= 1;
8980 if (! EQ (Vx_no_window_manager
, Qt
))
8981 x_wm_set_window_state (f
, NormalState
);
8982 #ifdef USE_X_TOOLKIT
8983 if (FRAME_X_EMBEDDED_P (f
))
8984 xembed_set_info (f
, XEMBED_MAPPED
);
8987 /* This was XtPopup, but that did nothing for an iconified frame. */
8988 XtMapWidget (f
->output_data
.x
->widget
);
8990 #else /* not USE_X_TOOLKIT */
8992 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
8993 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
8995 if (FRAME_X_EMBEDDED_P (f
))
8996 xembed_set_info (f
, XEMBED_MAPPED
);
8998 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8999 #endif /* not USE_GTK */
9000 #endif /* not USE_X_TOOLKIT */
9003 XFlush (FRAME_X_DISPLAY (f
));
9005 /* Synchronize to ensure Emacs knows the frame is visible
9006 before we do anything else. We do this loop with input not blocked
9007 so that incoming events are handled. */
9011 /* This must be before UNBLOCK_INPUT
9012 since events that arrive in response to the actions above
9013 will set it when they are handled. */
9014 int previously_visible
= f
->output_data
.x
->has_been_visible
;
9016 original_left
= f
->left_pos
;
9017 original_top
= f
->top_pos
;
9019 /* This must come after we set COUNT. */
9022 /* We unblock here so that arriving X events are processed. */
9024 /* Now move the window back to where it was "supposed to be".
9025 But don't do it if the gravity is negative.
9026 When the gravity is negative, this uses a position
9027 that is 3 pixels too low. Perhaps that's really the border width.
9029 Don't do this if the window has never been visible before,
9030 because the window manager may choose the position
9031 and we don't want to override it. */
9033 if (! FRAME_VISIBLE_P (f
)
9034 && ! FRAME_ICONIFIED_P (f
)
9035 && ! FRAME_X_EMBEDDED_P (f
)
9036 && f
->win_gravity
== NorthWestGravity
9037 && previously_visible
)
9041 unsigned int width
, height
, border
, depth
;
9045 /* On some window managers (such as FVWM) moving an existing
9046 window, even to the same place, causes the window manager
9047 to introduce an offset. This can cause the window to move
9048 to an unexpected location. Check the geometry (a little
9049 slow here) and then verify that the window is in the right
9050 place. If the window is not in the right place, move it
9051 there, and take the potential window manager hit. */
9052 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9053 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
9055 if (original_left
!= x
|| original_top
!= y
)
9056 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9057 original_left
, original_top
);
9062 XSETFRAME (frame
, f
);
9064 /* Wait until the frame is visible. Process X events until a
9065 MapNotify event has been seen, or until we think we won't get a
9066 MapNotify at all.. */
9067 for (count
= input_signal_count
+ 10;
9068 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
9070 /* Force processing of queued events. */
9073 /* Machines that do polling rather than SIGIO have been
9074 observed to go into a busy-wait here. So we'll fake an
9075 alarm signal to let the handler know that there's something
9076 to be read. We used to raise a real alarm, but it seems
9077 that the handler isn't always enabled here. This is
9079 if (input_polling_used ())
9081 /* It could be confusing if a real alarm arrives while
9082 processing the fake one. Turn it off and let the
9083 handler reset it. */
9084 int old_poll_suppress_count
= poll_suppress_count
;
9085 poll_suppress_count
= 1;
9086 poll_for_input_1 ();
9087 poll_suppress_count
= old_poll_suppress_count
;
9090 /* See if a MapNotify event has been processed. */
9091 FRAME_SAMPLE_VISIBILITY (f
);
9096 (let ((f (selected-frame)))
9100 the frame is not raised with various window managers on
9101 FreeBSD, GNU/Linux and Solaris. It turns out that, for some
9102 unknown reason, the call to XtMapWidget is completely ignored.
9103 Mapping the widget a second time works. */
9105 if (!FRAME_VISIBLE_P (f
) && --retry_count
> 0)
9110 /* Change from mapped state to withdrawn state. */
9112 /* Make the frame visible (mapped and not iconified). */
9115 x_make_frame_invisible (struct frame
*f
)
9119 /* Use the frame's outermost window, not the one we normally draw on. */
9120 window
= FRAME_OUTER_WINDOW (f
);
9122 /* Don't keep the highlight on an invisible frame. */
9123 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9124 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9128 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
9129 that the current position of the window is user-specified, rather than
9130 program-specified, so that when the window is mapped again, it will be
9131 placed at the same location, without forcing the user to position it
9132 by hand again (they have already done that once for this window.) */
9133 x_wm_set_size_hint (f
, (long) 0, 1);
9136 if (FRAME_GTK_OUTER_WIDGET (f
))
9137 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f
));
9140 if (FRAME_X_EMBEDDED_P (f
))
9141 xembed_set_info (f
, 0);
9146 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
9147 DefaultScreen (FRAME_X_DISPLAY (f
))))
9149 UNBLOCK_INPUT_RESIGNAL
;
9150 error ("Can't notify window manager of window withdrawal");
9154 /* We can't distinguish this from iconification
9155 just by the event that we get from the server.
9156 So we can't win using the usual strategy of letting
9157 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
9158 and synchronize with the server to make sure we agree. */
9160 FRAME_ICONIFIED_P (f
) = 0;
9161 f
->async_visible
= 0;
9162 f
->async_iconified
= 0;
9169 /* Change window state from mapped to iconified. */
9172 x_iconify_frame (struct frame
*f
)
9177 /* Don't keep the highlight on an invisible frame. */
9178 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9179 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9181 if (f
->async_iconified
)
9186 FRAME_SAMPLE_VISIBILITY (f
);
9188 type
= x_icon_type (f
);
9190 x_bitmap_icon (f
, type
);
9193 if (FRAME_GTK_OUTER_WIDGET (f
))
9195 if (! FRAME_VISIBLE_P (f
))
9196 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
9198 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
9201 f
->async_iconified
= 1;
9202 f
->async_visible
= 0;
9208 #ifdef USE_X_TOOLKIT
9210 if (! FRAME_VISIBLE_P (f
))
9212 if (! EQ (Vx_no_window_manager
, Qt
))
9213 x_wm_set_window_state (f
, IconicState
);
9214 /* This was XtPopup, but that did nothing for an iconified frame. */
9215 XtMapWidget (f
->output_data
.x
->widget
);
9216 /* The server won't give us any event to indicate
9217 that an invisible frame was changed to an icon,
9218 so we have to record it here. */
9221 f
->async_iconified
= 1;
9222 f
->async_visible
= 0;
9227 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
9228 XtWindow (f
->output_data
.x
->widget
),
9229 DefaultScreen (FRAME_X_DISPLAY (f
)));
9233 error ("Can't notify window manager of iconification");
9235 f
->async_iconified
= 1;
9236 f
->async_visible
= 0;
9240 XFlush (FRAME_X_DISPLAY (f
));
9242 #else /* not USE_X_TOOLKIT */
9244 /* Make sure the X server knows where the window should be positioned,
9245 in case the user deiconifies with the window manager. */
9246 if (! FRAME_VISIBLE_P (f
)
9247 && ! FRAME_ICONIFIED_P (f
)
9248 && ! FRAME_X_EMBEDDED_P (f
))
9249 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
9251 /* Since we don't know which revision of X we're running, we'll use both
9252 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
9254 /* X11R4: send a ClientMessage to the window manager using the
9255 WM_CHANGE_STATE type. */
9259 message
.xclient
.window
= FRAME_X_WINDOW (f
);
9260 message
.xclient
.type
= ClientMessage
;
9261 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
9262 message
.xclient
.format
= 32;
9263 message
.xclient
.data
.l
[0] = IconicState
;
9265 if (! XSendEvent (FRAME_X_DISPLAY (f
),
9266 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
9268 SubstructureRedirectMask
| SubstructureNotifyMask
,
9271 UNBLOCK_INPUT_RESIGNAL
;
9272 error ("Can't notify window manager of iconification");
9276 /* X11R3: set the initial_state field of the window manager hints to
9278 x_wm_set_window_state (f
, IconicState
);
9280 if (!FRAME_VISIBLE_P (f
))
9282 /* If the frame was withdrawn, before, we must map it. */
9283 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9286 f
->async_iconified
= 1;
9287 f
->async_visible
= 0;
9289 XFlush (FRAME_X_DISPLAY (f
));
9291 #endif /* not USE_X_TOOLKIT */
9295 /* Free X resources of frame F. */
9298 x_free_frame_resources (struct frame
*f
)
9300 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9302 struct scroll_bar
*b
;
9306 /* If a display connection is dead, don't try sending more
9307 commands to the X server. */
9308 if (dpyinfo
->display
)
9310 /* We must free faces before destroying windows because some
9311 font-driver (e.g. xft) access a window while finishing a
9313 if (FRAME_FACE_CACHE (f
))
9314 free_frame_faces (f
);
9316 if (f
->output_data
.x
->icon_desc
)
9317 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
9319 #ifdef USE_X_TOOLKIT
9320 /* Explicitly destroy the scroll bars of the frame. Without
9321 this, we get "BadDrawable" errors from the toolkit later on,
9322 presumably from expose events generated for the disappearing
9323 toolkit scroll bars. */
9324 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
9326 b
= XSCROLL_BAR (bar
);
9327 x_scroll_bar_remove (b
);
9336 #ifdef USE_X_TOOLKIT
9337 if (f
->output_data
.x
->widget
)
9339 XtDestroyWidget (f
->output_data
.x
->widget
);
9340 f
->output_data
.x
->widget
= NULL
;
9342 /* Tooltips don't have widgets, only a simple X window, even if
9343 we are using a toolkit. */
9344 else if (FRAME_X_WINDOW (f
))
9345 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9347 free_frame_menubar (f
);
9348 #else /* !USE_X_TOOLKIT */
9351 xg_free_frame_widgets (f
);
9352 #endif /* USE_GTK */
9354 if (FRAME_X_WINDOW (f
))
9355 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9356 #endif /* !USE_X_TOOLKIT */
9358 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
9359 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
9360 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
9361 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
9362 unload_color (f
, f
->output_data
.x
->border_pixel
);
9363 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
9365 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
9366 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
9367 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
9368 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
9369 #ifdef USE_TOOLKIT_SCROLL_BARS
9370 /* Scrollbar shadow colors. */
9371 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
9372 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
9373 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
9374 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
9375 #endif /* USE_TOOLKIT_SCROLL_BARS */
9376 if (f
->output_data
.x
->white_relief
.allocated_p
)
9377 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
9378 if (f
->output_data
.x
->black_relief
.allocated_p
)
9379 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
9382 XFlush (FRAME_X_DISPLAY (f
));
9385 xfree (f
->output_data
.x
->saved_menu_event
);
9386 xfree (f
->output_data
.x
);
9387 f
->output_data
.x
= NULL
;
9389 if (f
== dpyinfo
->x_focus_frame
)
9390 dpyinfo
->x_focus_frame
= 0;
9391 if (f
== dpyinfo
->x_focus_event_frame
)
9392 dpyinfo
->x_focus_event_frame
= 0;
9393 if (f
== dpyinfo
->x_highlight_frame
)
9394 dpyinfo
->x_highlight_frame
= 0;
9396 if (f
== dpyinfo
->mouse_face_mouse_frame
)
9398 dpyinfo
->mouse_face_beg_row
9399 = dpyinfo
->mouse_face_beg_col
= -1;
9400 dpyinfo
->mouse_face_end_row
9401 = dpyinfo
->mouse_face_end_col
= -1;
9402 dpyinfo
->mouse_face_window
= Qnil
;
9403 dpyinfo
->mouse_face_deferred_gc
= 0;
9404 dpyinfo
->mouse_face_mouse_frame
= 0;
9411 /* Destroy the X window of frame F. */
9414 x_destroy_window (struct frame
*f
)
9416 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9418 /* If a display connection is dead, don't try sending more
9419 commands to the X server. */
9420 if (dpyinfo
->display
!= 0)
9421 x_free_frame_resources (f
);
9423 dpyinfo
->reference_count
--;
9427 /* Setting window manager hints. */
9429 /* Set the normal size hints for the window manager, for frame F.
9430 FLAGS is the flags word to use--or 0 meaning preserve the flags
9431 that the window now has.
9432 If USER_POSITION is nonzero, we set the USPosition
9433 flag (this is useful when FLAGS is 0).
9434 The GTK version is in gtkutils.c */
9438 x_wm_set_size_hint (struct frame
*f
, long flags
, int user_position
)
9440 XSizeHints size_hints
;
9441 Window window
= FRAME_OUTER_WINDOW (f
);
9443 /* Setting PMaxSize caused various problems. */
9444 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
9446 size_hints
.x
= f
->left_pos
;
9447 size_hints
.y
= f
->top_pos
;
9449 size_hints
.height
= FRAME_PIXEL_HEIGHT (f
);
9450 size_hints
.width
= FRAME_PIXEL_WIDTH (f
);
9452 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
9453 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
9454 size_hints
.max_width
= x_display_pixel_width (FRAME_X_DISPLAY_INFO (f
))
9455 - FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9456 size_hints
.max_height
= x_display_pixel_height (FRAME_X_DISPLAY_INFO (f
))
9457 - FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9459 /* Calculate the base and minimum sizes. */
9461 int base_width
, base_height
;
9462 int min_rows
= 0, min_cols
= 0;
9464 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9465 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9467 check_frame_size (f
, &min_rows
, &min_cols
);
9469 /* The window manager uses the base width hints to calculate the
9470 current number of rows and columns in the frame while
9471 resizing; min_width and min_height aren't useful for this
9472 purpose, since they might not give the dimensions for a
9473 zero-row, zero-column frame.
9475 We use the base_width and base_height members if we have
9476 them; otherwise, we set the min_width and min_height members
9477 to the size for a zero x zero frame. */
9479 size_hints
.flags
|= PBaseSize
;
9480 size_hints
.base_width
= base_width
;
9481 size_hints
.base_height
= base_height
+ FRAME_MENUBAR_HEIGHT (f
);
9482 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
9483 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
9486 /* If we don't need the old flags, we don't need the old hint at all. */
9489 size_hints
.flags
|= flags
;
9494 XSizeHints hints
; /* Sometimes I hate X Windows... */
9495 long supplied_return
;
9498 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
9502 size_hints
.flags
|= flags
;
9507 if (hints
.flags
& PSize
)
9508 size_hints
.flags
|= PSize
;
9509 if (hints
.flags
& PPosition
)
9510 size_hints
.flags
|= PPosition
;
9511 if (hints
.flags
& USPosition
)
9512 size_hints
.flags
|= USPosition
;
9513 if (hints
.flags
& USSize
)
9514 size_hints
.flags
|= USSize
;
9521 size_hints
.win_gravity
= f
->win_gravity
;
9522 size_hints
.flags
|= PWinGravity
;
9526 size_hints
.flags
&= ~ PPosition
;
9527 size_hints
.flags
|= USPosition
;
9529 #endif /* PWinGravity */
9531 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
9533 #endif /* not USE_GTK */
9535 /* Used for IconicState or NormalState */
9538 x_wm_set_window_state (struct frame
*f
, int state
)
9540 #ifdef USE_X_TOOLKIT
9543 XtSetArg (al
[0], XtNinitialState
, state
);
9544 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9545 #else /* not USE_X_TOOLKIT */
9546 Window window
= FRAME_X_WINDOW (f
);
9548 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
9549 f
->output_data
.x
->wm_hints
.initial_state
= state
;
9551 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9552 #endif /* not USE_X_TOOLKIT */
9556 x_wm_set_icon_pixmap (struct frame
*f
, int pixmap_id
)
9558 Pixmap icon_pixmap
, icon_mask
;
9560 #if !defined USE_X_TOOLKIT && !defined USE_GTK
9561 Window window
= FRAME_OUTER_WINDOW (f
);
9566 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
9567 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
9568 icon_mask
= x_bitmap_mask (f
, pixmap_id
);
9569 f
->output_data
.x
->wm_hints
.icon_mask
= icon_mask
;
9573 /* It seems there is no way to turn off use of an icon
9581 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
);
9585 #elif defined (USE_X_TOOLKIT) /* same as in x_wm_set_window_state. */
9589 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
9590 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9591 XtSetArg (al
[0], XtNiconMask
, icon_mask
);
9592 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9595 #else /* not USE_X_TOOLKIT && not USE_GTK */
9597 f
->output_data
.x
->wm_hints
.flags
|= (IconPixmapHint
| IconMaskHint
);
9598 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9600 #endif /* not USE_X_TOOLKIT && not USE_GTK */
9604 x_wm_set_icon_position (struct frame
*f
, int icon_x
, int icon_y
)
9606 Window window
= FRAME_OUTER_WINDOW (f
);
9608 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
9609 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
9610 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
9612 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9616 /***********************************************************************
9618 ***********************************************************************/
9622 /* Check that FONT is valid on frame F. It is if it can be found in F's
9626 x_check_font (struct frame
*f
, struct font
*font
)
9630 xassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
9631 if (font
->driver
->check
)
9632 xassert (font
->driver
->check (f
, font
) == 0);
9635 #endif /* GLYPH_DEBUG != 0 */
9638 /***********************************************************************
9640 ***********************************************************************/
9642 #ifdef USE_X_TOOLKIT
9643 static XrmOptionDescRec emacs_options
[] = {
9644 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
9645 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
9647 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
9648 XrmoptionSepArg
, NULL
},
9649 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
9651 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9652 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9653 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9654 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
9655 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
9656 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
9657 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
9660 /* Whether atimer for Xt timeouts is activated or not. */
9662 static int x_timeout_atimer_activated_flag
;
9664 #endif /* USE_X_TOOLKIT */
9666 static int x_initialized
;
9669 static int x_session_initialized
;
9672 /* Test whether two display-name strings agree up to the dot that separates
9673 the screen number from the server number. */
9675 same_x_server (const char *name1
, const char *name2
)
9678 const unsigned char *system_name
= SDATA (Vsystem_name
);
9679 int system_name_length
= strlen (system_name
);
9680 int length_until_period
= 0;
9682 while (system_name
[length_until_period
] != 0
9683 && system_name
[length_until_period
] != '.')
9684 length_until_period
++;
9686 /* Treat `unix' like an empty host name. */
9687 if (! strncmp (name1
, "unix:", 5))
9689 if (! strncmp (name2
, "unix:", 5))
9691 /* Treat this host's name like an empty host name. */
9692 if (! strncmp (name1
, system_name
, system_name_length
)
9693 && name1
[system_name_length
] == ':')
9694 name1
+= system_name_length
;
9695 if (! strncmp (name2
, system_name
, system_name_length
)
9696 && name2
[system_name_length
] == ':')
9697 name2
+= system_name_length
;
9698 /* Treat this host's domainless name like an empty host name. */
9699 if (! strncmp (name1
, system_name
, length_until_period
)
9700 && name1
[length_until_period
] == ':')
9701 name1
+= length_until_period
;
9702 if (! strncmp (name2
, system_name
, length_until_period
)
9703 && name2
[length_until_period
] == ':')
9704 name2
+= length_until_period
;
9706 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
9710 if (seen_colon
&& *name1
== '.')
9714 && (*name1
== '.' || *name1
== '\0')
9715 && (*name2
== '.' || *name2
== '\0'));
9718 /* Count number of set bits in mask and number of bits to shift to
9719 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
9722 get_bits_and_offset (long unsigned int mask
, int *bits
, int *offset
)
9743 /* Return 1 if display DISPLAY is available for use, 0 otherwise.
9744 But don't permanently open it, just test its availability. */
9747 x_display_ok (const char *display
)
9752 dpy
= XOpenDisplay (display
);
9754 XCloseDisplay (dpy
);
9762 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
, const gchar
*message
, gpointer user_data
)
9764 if (!strstr (message
, "g_set_prgname"))
9765 fprintf (stderr
, "%s-WARNING **: %s\n", log_domain
, message
);
9769 /* Open a connection to X display DISPLAY_NAME, and return
9770 the structure that describes the open display.
9771 If we cannot contact the display, return null. */
9773 struct x_display_info
*
9774 x_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
9778 struct terminal
*terminal
;
9779 struct x_display_info
*dpyinfo
;
9790 if (! x_display_ok (SDATA (display_name
)))
9791 error ("Display %s can't be opened", SDATA (display_name
));
9797 char *argv
[NUM_ARGV
];
9798 char **argv2
= argv
;
9801 if (x_initialized
++ > 1)
9803 xg_display_open (SDATA (display_name
), &dpy
);
9807 static char display_opt
[] = "--display";
9808 static char name_opt
[] = "--name";
9810 for (argc
= 0; argc
< NUM_ARGV
; ++argc
)
9814 argv
[argc
++] = initial_argv
[0];
9816 if (! NILP (display_name
))
9818 argv
[argc
++] = display_opt
;
9819 argv
[argc
++] = SDATA (display_name
);
9822 argv
[argc
++] = name_opt
;
9823 argv
[argc
++] = resource_name
;
9825 XSetLocaleModifiers ("");
9827 /* Work around GLib bug that outputs a faulty warning. See
9828 https://bugzilla.gnome.org/show_bug.cgi?id=563627. */
9829 id
= g_log_set_handler ("GLib", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
9830 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
9831 gtk_init (&argc
, &argv2
);
9832 g_log_remove_handler ("GLib", id
);
9834 /* gtk_init does set_locale. We must fix locale after calling it. */
9838 dpy
= GDK_DISPLAY ();
9840 /* NULL window -> events for all windows go to our function */
9841 gdk_window_add_filter (NULL
, event_handler_gdk
, NULL
);
9843 /* Load our own gtkrc if it exists. */
9845 const char *file
= "~/.emacs.d/gtkrc";
9846 Lisp_Object s
, abs_file
;
9848 s
= make_string (file
, strlen (file
));
9849 abs_file
= Fexpand_file_name (s
, Qnil
);
9851 if (! NILP (abs_file
) && !NILP (Ffile_readable_p (abs_file
)))
9852 gtk_rc_parse (SDATA (abs_file
));
9855 XSetErrorHandler (x_error_handler
);
9856 XSetIOErrorHandler (x_io_error_quitter
);
9859 #else /* not USE_GTK */
9860 #ifdef USE_X_TOOLKIT
9861 /* weiner@footloose.sps.mot.com reports that this causes
9863 X protocol error: BadAtom (invalid Atom parameter)
9864 on protocol request 18skiloaf.
9865 So let's not use it until R6. */
9867 XtSetLanguageProc (NULL
, NULL
, NULL
);
9878 argv
[argc
++] = "-xrm";
9879 argv
[argc
++] = xrm_option
;
9881 turn_on_atimers (0);
9882 dpy
= XtOpenDisplay (Xt_app_con
, SDATA (display_name
),
9883 resource_name
, EMACS_CLASS
,
9884 emacs_options
, XtNumber (emacs_options
),
9886 turn_on_atimers (1);
9889 /* I think this is to compensate for XtSetLanguageProc. */
9894 #else /* not USE_X_TOOLKIT */
9895 XSetLocaleModifiers ("");
9896 dpy
= XOpenDisplay (SDATA (display_name
));
9897 #endif /* not USE_X_TOOLKIT */
9898 #endif /* not USE_GTK*/
9900 /* Detect failure. */
9907 /* We have definitely succeeded. Record the new connection. */
9909 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
9910 memset (dpyinfo
, 0, sizeof *dpyinfo
);
9912 terminal
= x_create_terminal (dpyinfo
);
9915 struct x_display_info
*share
;
9918 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
9919 share
= share
->next
, tail
= XCDR (tail
))
9920 if (same_x_server (SDATA (XCAR (XCAR (tail
))),
9921 SDATA (display_name
)))
9924 terminal
->kboard
= share
->terminal
->kboard
;
9927 terminal
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
9928 init_kboard (terminal
->kboard
);
9929 terminal
->kboard
->Vwindow_system
= Qx
;
9931 /* Add the keyboard to the list before running Lisp code (via
9932 Qvendor_specific_keysyms below), since these are not traced
9933 via terminals but only through all_kboards. */
9934 terminal
->kboard
->next_kboard
= all_kboards
;
9935 all_kboards
= terminal
->kboard
;
9937 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
9939 char *vendor
= ServerVendor (dpy
);
9941 /* Protect terminal from GC before removing it from the
9942 list of terminals. */
9943 struct gcpro gcpro1
;
9944 Lisp_Object gcpro_term
;
9945 XSETTERMINAL (gcpro_term
, terminal
);
9946 GCPRO1 (gcpro_term
);
9948 /* Temporarily hide the partially initialized terminal. */
9949 terminal_list
= terminal
->next_terminal
;
9951 terminal
->kboard
->Vsystem_key_alist
9952 = call1 (Qvendor_specific_keysyms
,
9953 vendor
? build_string (vendor
) : empty_unibyte_string
);
9955 terminal
->next_terminal
= terminal_list
;
9956 terminal_list
= terminal
;
9960 /* Don't let the initial kboard remain current longer than necessary.
9961 That would cause problems if a file loaded on startup tries to
9962 prompt in the mini-buffer. */
9963 if (current_kboard
== initial_kboard
)
9964 current_kboard
= terminal
->kboard
;
9966 terminal
->kboard
->reference_count
++;
9969 /* Put this display on the chain. */
9970 dpyinfo
->next
= x_display_list
;
9971 x_display_list
= dpyinfo
;
9973 /* Put it on x_display_name_list as well, to keep them parallel. */
9974 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
9975 x_display_name_list
);
9976 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
9978 dpyinfo
->display
= dpy
;
9980 /* Set the name of the terminal. */
9981 terminal
->name
= (char *) xmalloc (SBYTES (display_name
) + 1);
9982 strncpy (terminal
->name
, SDATA (display_name
), SBYTES (display_name
));
9983 terminal
->name
[SBYTES (display_name
)] = 0;
9986 XSetAfterFunction (x_current_display
, x_trace_wire
);
9990 = (char *) xmalloc (SBYTES (Vinvocation_name
)
9991 + SBYTES (Vsystem_name
)
9993 sprintf (dpyinfo
->x_id_name
, "%s@%s",
9994 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
9996 /* Figure out which modifier bits mean what. */
9997 x_find_modifier_meanings (dpyinfo
);
9999 /* Get the scroll bar cursor. */
10001 /* We must create a GTK cursor, it is required for GTK widgets. */
10002 dpyinfo
->xg_cursor
= xg_create_default_cursor (dpyinfo
->display
);
10003 #endif /* USE_GTK */
10005 dpyinfo
->vertical_scroll_bar_cursor
10006 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
10008 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
10009 resource_name
, EMACS_CLASS
);
10010 #ifdef HAVE_XRMSETDATABASE
10011 XrmSetDatabase (dpyinfo
->display
, xrdb
);
10013 dpyinfo
->display
->db
= xrdb
;
10015 /* Put the rdb where we can find it in a way that works on
10017 dpyinfo
->xrdb
= xrdb
;
10019 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
10020 DefaultScreen (dpyinfo
->display
));
10021 select_visual (dpyinfo
);
10022 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
10023 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
10024 dpyinfo
->client_leader_window
= 0;
10025 dpyinfo
->grabbed
= 0;
10026 dpyinfo
->reference_count
= 0;
10027 dpyinfo
->icon_bitmap_id
= -1;
10028 dpyinfo
->n_fonts
= 0;
10029 dpyinfo
->bitmaps
= 0;
10030 dpyinfo
->bitmaps_size
= 0;
10031 dpyinfo
->bitmaps_last
= 0;
10032 dpyinfo
->scratch_cursor_gc
= 0;
10033 dpyinfo
->mouse_face_mouse_frame
= 0;
10034 dpyinfo
->mouse_face_deferred_gc
= 0;
10035 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
10036 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
10037 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
10038 dpyinfo
->mouse_face_window
= Qnil
;
10039 dpyinfo
->mouse_face_overlay
= Qnil
;
10040 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
10041 dpyinfo
->mouse_face_defer
= 0;
10042 dpyinfo
->mouse_face_hidden
= 0;
10043 dpyinfo
->x_focus_frame
= 0;
10044 dpyinfo
->x_focus_event_frame
= 0;
10045 dpyinfo
->x_highlight_frame
= 0;
10046 dpyinfo
->wm_type
= X_WMTYPE_UNKNOWN
;
10048 /* See if we can construct pixel values from RGB values. */
10049 dpyinfo
->red_bits
= dpyinfo
->blue_bits
= dpyinfo
->green_bits
= 0;
10050 dpyinfo
->red_offset
= dpyinfo
->blue_offset
= dpyinfo
->green_offset
= 0;
10052 if (dpyinfo
->visual
->class == TrueColor
)
10054 get_bits_and_offset (dpyinfo
->visual
->red_mask
,
10055 &dpyinfo
->red_bits
, &dpyinfo
->red_offset
);
10056 get_bits_and_offset (dpyinfo
->visual
->blue_mask
,
10057 &dpyinfo
->blue_bits
, &dpyinfo
->blue_offset
);
10058 get_bits_and_offset (dpyinfo
->visual
->green_mask
,
10059 &dpyinfo
->green_bits
, &dpyinfo
->green_offset
);
10062 /* See if a private colormap is requested. */
10063 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
10065 if (dpyinfo
->visual
->class == PseudoColor
)
10068 value
= display_x_get_resource (dpyinfo
,
10069 build_string ("privateColormap"),
10070 build_string ("PrivateColormap"),
10072 if (STRINGP (value
)
10073 && (!strcmp (SDATA (value
), "true")
10074 || !strcmp (SDATA (value
), "on")))
10075 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
10079 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
10080 dpyinfo
->visual
, AllocNone
);
10084 /* If we are using Xft, check dpi value in X resources.
10085 It is better we use it as well, since Xft will use it, as will all
10086 Gnome applications. If our real DPI is smaller or larger than the
10087 one Xft uses, our font will look smaller or larger than other
10088 for other applications, even if it is the same font name (monospace-10
10090 char *v
= XGetDefault (dpyinfo
->display
, "Xft", "dpi");
10092 if (v
!= NULL
&& sscanf (v
, "%lf", &d
) == 1)
10093 dpyinfo
->resy
= dpyinfo
->resx
= d
;
10097 if (dpyinfo
->resy
< 1)
10099 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
10100 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
10101 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
10102 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10103 dpyinfo
->resy
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10104 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
10105 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
10106 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10107 dpyinfo
->resx
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10110 dpyinfo
->Xatom_wm_protocols
10111 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
10112 dpyinfo
->Xatom_wm_take_focus
10113 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
10114 dpyinfo
->Xatom_wm_save_yourself
10115 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
10116 dpyinfo
->Xatom_wm_delete_window
10117 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
10118 dpyinfo
->Xatom_wm_change_state
10119 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
10120 dpyinfo
->Xatom_wm_configure_denied
10121 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
10122 dpyinfo
->Xatom_wm_window_moved
10123 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
10124 dpyinfo
->Xatom_wm_client_leader
10125 = XInternAtom (dpyinfo
->display
, "WM_CLIENT_LEADER", False
);
10126 dpyinfo
->Xatom_editres
10127 = XInternAtom (dpyinfo
->display
, "Editres", False
);
10128 dpyinfo
->Xatom_CLIPBOARD
10129 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
10130 dpyinfo
->Xatom_TIMESTAMP
10131 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
10132 dpyinfo
->Xatom_TEXT
10133 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
10134 dpyinfo
->Xatom_COMPOUND_TEXT
10135 = XInternAtom (dpyinfo
->display
, "COMPOUND_TEXT", False
);
10136 dpyinfo
->Xatom_UTF8_STRING
10137 = XInternAtom (dpyinfo
->display
, "UTF8_STRING", False
);
10138 dpyinfo
->Xatom_DELETE
10139 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
10140 dpyinfo
->Xatom_MULTIPLE
10141 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
10142 dpyinfo
->Xatom_INCR
10143 = XInternAtom (dpyinfo
->display
, "INCR", False
);
10144 dpyinfo
->Xatom_EMACS_TMP
10145 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
10146 dpyinfo
->Xatom_TARGETS
10147 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
10148 dpyinfo
->Xatom_NULL
10149 = XInternAtom (dpyinfo
->display
, "NULL", False
);
10150 dpyinfo
->Xatom_ATOM_PAIR
10151 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
10152 /* For properties of font. */
10153 dpyinfo
->Xatom_PIXEL_SIZE
10154 = XInternAtom (dpyinfo
->display
, "PIXEL_SIZE", False
);
10155 dpyinfo
->Xatom_AVERAGE_WIDTH
10156 = XInternAtom (dpyinfo
->display
, "AVERAGE_WIDTH", False
);
10157 dpyinfo
->Xatom_MULE_BASELINE_OFFSET
10158 = XInternAtom (dpyinfo
->display
, "_MULE_BASELINE_OFFSET", False
);
10159 dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
10160 = XInternAtom (dpyinfo
->display
, "_MULE_RELATIVE_COMPOSE", False
);
10161 dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
10162 = XInternAtom (dpyinfo
->display
, "_MULE_DEFAULT_ASCENT", False
);
10164 /* Ghostscript support. */
10165 dpyinfo
->Xatom_PAGE
= XInternAtom (dpyinfo
->display
, "PAGE", False
);
10166 dpyinfo
->Xatom_DONE
= XInternAtom (dpyinfo
->display
, "DONE", False
);
10168 dpyinfo
->Xatom_Scrollbar
= XInternAtom (dpyinfo
->display
, "SCROLLBAR",
10171 dpyinfo
->Xatom_XEMBED
= XInternAtom (dpyinfo
->display
, "_XEMBED",
10174 dpyinfo
->Xatom_net_wm_state
10175 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE", False
);
10176 dpyinfo
->Xatom_net_wm_state_fullscreen_atom
10177 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE_FULLSCREEN", False
);
10178 dpyinfo
->Xatom_net_wm_state_maximized_horz
10179 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE_MAXIMIZED_HORZ", False
);
10180 dpyinfo
->Xatom_net_wm_state_maximized_vert
10181 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE_MAXIMIZED_VERT", False
);
10182 dpyinfo
->Xatom_net_wm_state_sticky
10183 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE_STICKY", False
);
10184 dpyinfo
->Xatom_net_window_type
10185 = XInternAtom (dpyinfo
->display
, "_NET_WM_WINDOW_TYPE", False
);
10186 dpyinfo
->Xatom_net_window_type_tooltip
10187 = XInternAtom (dpyinfo
->display
, "_NET_WM_WINDOW_TYPE_TOOLTIP", False
);
10188 dpyinfo
->Xatom_net_wm_icon_name
10189 = XInternAtom (dpyinfo
->display
, "_NET_WM_ICON_NAME", False
);
10190 dpyinfo
->Xatom_net_wm_name
10191 = XInternAtom (dpyinfo
->display
, "_NET_WM_NAME", False
);
10193 dpyinfo
->x_dnd_atoms_size
= 8;
10194 dpyinfo
->x_dnd_atoms_length
= 0;
10195 dpyinfo
->x_dnd_atoms
= xmalloc (sizeof (*dpyinfo
->x_dnd_atoms
)
10196 * dpyinfo
->x_dnd_atoms_size
);
10198 dpyinfo
->net_supported_atoms
= NULL
;
10199 dpyinfo
->nr_net_supported_atoms
= 0;
10200 dpyinfo
->net_supported_window
= 0;
10202 connection
= ConnectionNumber (dpyinfo
->display
);
10203 dpyinfo
->connection
= connection
;
10207 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
10209 gray_bitmap_width
, gray_bitmap_height
,
10210 (unsigned long) 1, (unsigned long) 0, 1);
10214 xim_initialize (dpyinfo
, resource_name
);
10217 xsettings_initialize (dpyinfo
);
10219 /* This is only needed for distinguishing keyboard and process input. */
10220 if (connection
!= 0)
10221 add_keyboard_wait_descriptor (connection
);
10224 fcntl (connection
, F_SETOWN
, getpid ());
10225 #endif /* ! defined (F_SETOWN) */
10228 if (interrupt_input
)
10229 init_sigio (connection
);
10230 #endif /* ! defined (SIGIO) */
10234 Display
*dpy
= dpyinfo
->display
;
10235 XrmValue d
, fr
, to
;
10238 d
.addr
= (XPointer
)&dpy
;
10239 d
.size
= sizeof (Display
*);
10240 fr
.addr
= XtDefaultFont
;
10241 fr
.size
= sizeof (XtDefaultFont
);
10242 to
.size
= sizeof (Font
*);
10243 to
.addr
= (XPointer
)&font
;
10244 x_catch_errors (dpy
);
10245 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
10247 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
10248 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
10249 x_uncatch_errors ();
10253 /* See if we should run in synchronous mode. This is useful
10254 for debugging X code. */
10257 value
= display_x_get_resource (dpyinfo
,
10258 build_string ("synchronous"),
10259 build_string ("Synchronous"),
10261 if (STRINGP (value
)
10262 && (!strcmp (SDATA (value
), "true")
10263 || !strcmp (SDATA (value
), "on")))
10264 XSynchronize (dpyinfo
->display
, True
);
10269 value
= display_x_get_resource (dpyinfo
,
10270 build_string ("useXIM"),
10271 build_string ("UseXIM"),
10274 if (STRINGP (value
)
10275 && (!strcmp (SDATA (value
), "false")
10276 || !strcmp (SDATA (value
), "off")))
10279 if (STRINGP (value
)
10280 && (!strcmp (SDATA (value
), "true")
10281 || !strcmp (SDATA (value
), "on")))
10287 /* Only do this for the very first display in the Emacs session.
10288 Ignore X session management when Emacs was first started on a
10290 if (terminal
->id
== 1)
10291 x_session_initialize (dpyinfo
);
10299 /* Get rid of display DPYINFO, deleting all frames on it,
10300 and without sending any more commands to the X server. */
10303 x_delete_display (struct x_display_info
*dpyinfo
)
10305 struct terminal
*t
;
10307 /* Close all frames and delete the generic struct terminal for this
10309 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
10310 if (t
->type
== output_x_window
&& t
->display_info
.x
== dpyinfo
)
10313 /* Close X session management when we close its display. */
10314 if (t
->id
== 1 && x_session_have_connection ())
10315 x_session_close ();
10317 delete_terminal (t
);
10321 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
10323 /* Discard this display from x_display_name_list and x_display_list.
10324 We can't use Fdelq because that can quit. */
10325 if (! NILP (x_display_name_list
)
10326 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
10327 x_display_name_list
= XCDR (x_display_name_list
);
10332 tail
= x_display_name_list
;
10333 while (CONSP (tail
) && CONSP (XCDR (tail
)))
10335 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
10337 XSETCDR (tail
, XCDR (XCDR (tail
)));
10340 tail
= XCDR (tail
);
10344 if (next_noop_dpyinfo
== dpyinfo
)
10345 next_noop_dpyinfo
= dpyinfo
->next
;
10347 if (x_display_list
== dpyinfo
)
10348 x_display_list
= dpyinfo
->next
;
10351 struct x_display_info
*tail
;
10353 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
10354 if (tail
->next
== dpyinfo
)
10355 tail
->next
= tail
->next
->next
;
10358 xfree (dpyinfo
->x_id_name
);
10359 xfree (dpyinfo
->x_dnd_atoms
);
10360 xfree (dpyinfo
->color_cells
);
10364 #ifdef USE_X_TOOLKIT
10366 /* Atimer callback function for TIMER. Called every 0.1s to process
10367 Xt timeouts, if needed. We must avoid calling XtAppPending as
10368 much as possible because that function does an implicit XFlush
10369 that slows us down. */
10372 x_process_timeouts (struct atimer
*timer
)
10375 x_timeout_atimer_activated_flag
= 0;
10376 if (toolkit_scroll_bar_interaction
|| popup_activated ())
10378 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
10379 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
10380 /* Reactivate the atimer for next time. */
10381 x_activate_timeout_atimer ();
10386 /* Install an asynchronous timer that processes Xt timeout events
10387 every 0.1s as long as either `toolkit_scroll_bar_interaction' or
10388 `popup_activated_flag' (in xmenu.c) is set. Make sure to call this
10389 function whenever these variables are set. This is necessary
10390 because some widget sets use timeouts internally, for example the
10391 LessTif menu bar, or the Xaw3d scroll bar. When Xt timeouts aren't
10392 processed, these widgets don't behave normally. */
10395 x_activate_timeout_atimer (void)
10398 if (!x_timeout_atimer_activated_flag
)
10400 EMACS_TIME interval
;
10402 EMACS_SET_SECS_USECS (interval
, 0, 100000);
10403 start_atimer (ATIMER_RELATIVE
, interval
, x_process_timeouts
, 0);
10404 x_timeout_atimer_activated_flag
= 1;
10409 #endif /* USE_X_TOOLKIT */
10412 /* Set up use of X before we make the first connection. */
10414 extern frame_parm_handler x_frame_parm_handlers
[];
10416 static struct redisplay_interface x_redisplay_interface
=
10418 x_frame_parm_handlers
,
10422 x_clear_end_of_line
,
10424 x_after_update_window_line
,
10425 x_update_window_begin
,
10426 x_update_window_end
,
10432 0, /* flush_display_optional */
10434 x_clear_window_mouse_face
,
10435 x_get_glyph_overhangs
,
10436 x_fix_overlapping_area
,
10437 x_draw_fringe_bitmap
,
10438 0, /* define_fringe_bitmap */
10439 0, /* destroy_fringe_bitmap */
10440 x_compute_glyph_string_overhangs
,
10441 x_draw_glyph_string
,
10442 x_define_frame_cursor
,
10443 x_clear_frame_area
,
10444 x_draw_window_cursor
,
10445 x_draw_vertical_window_border
,
10446 x_shift_glyphs_for_insert
10450 /* This function is called when the last frame on a display is deleted. */
10452 x_delete_terminal (struct terminal
*terminal
)
10454 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
10456 /* Protect against recursive calls. delete_frame in
10457 delete_terminal calls us back when it deletes our last frame. */
10458 if (!terminal
->name
)
10463 /* We must close our connection to the XIM server before closing the
10466 xim_close_dpy (dpyinfo
);
10469 /* If called from x_connection_closed, the display may already be closed
10470 and dpyinfo->display was set to 0 to indicate that. */
10471 if (dpyinfo
->display
)
10473 x_destroy_all_bitmaps (dpyinfo
);
10474 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
10476 /* Whether or not XCloseDisplay destroys the associated resource
10477 database depends on the version of libX11. To avoid both
10478 crash and memory leak, we dissociate the database from the
10479 display and then destroy dpyinfo->xrdb ourselves.
10481 Unfortunately, the above strategy does not work in some
10482 situations due to a bug in newer versions of libX11: because
10483 XrmSetDatabase doesn't clear the flag XlibDisplayDfltRMDB if
10484 dpy->db is NULL, XCloseDisplay destroys the associated
10485 database whereas it has not been created by XGetDefault
10486 (Bug#21974 in freedesktop.org Bugzilla). As a workaround, we
10487 don't destroy the database here in order to avoid the crash
10488 in the above situations for now, though that may cause memory
10489 leaks in other situations. */
10491 #ifdef HAVE_XRMSETDATABASE
10492 XrmSetDatabase (dpyinfo
->display
, NULL
);
10494 dpyinfo
->display
->db
= NULL
;
10496 /* We used to call XrmDestroyDatabase from x_delete_display, but
10497 some older versions of libX11 crash if we call it after
10498 closing all the displays. */
10499 XrmDestroyDatabase (dpyinfo
->xrdb
);
10503 xg_display_close (dpyinfo
->display
);
10505 #ifdef USE_X_TOOLKIT
10506 XtCloseDisplay (dpyinfo
->display
);
10508 XCloseDisplay (dpyinfo
->display
);
10510 #endif /* ! USE_GTK */
10513 /* Mark as dead. */
10514 dpyinfo
->display
= NULL
;
10515 x_delete_display (dpyinfo
);
10519 /* Create a struct terminal, initialize it with the X11 specific
10520 functions and make DISPLAY->TERMINAL point to it. */
10522 static struct terminal
*
10523 x_create_terminal (struct x_display_info
*dpyinfo
)
10525 struct terminal
*terminal
;
10527 terminal
= create_terminal ();
10529 terminal
->type
= output_x_window
;
10530 terminal
->display_info
.x
= dpyinfo
;
10531 dpyinfo
->terminal
= terminal
;
10533 /* kboard is initialized in x_term_init. */
10535 terminal
->clear_frame_hook
= x_clear_frame
;
10536 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
10537 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
10538 terminal
->ring_bell_hook
= XTring_bell
;
10539 terminal
->toggle_invisible_pointer_hook
= XTtoggle_invisible_pointer
;
10540 terminal
->reset_terminal_modes_hook
= XTreset_terminal_modes
;
10541 terminal
->set_terminal_modes_hook
= XTset_terminal_modes
;
10542 terminal
->update_begin_hook
= x_update_begin
;
10543 terminal
->update_end_hook
= x_update_end
;
10544 terminal
->set_terminal_window_hook
= XTset_terminal_window
;
10545 terminal
->read_socket_hook
= XTread_socket
;
10546 terminal
->frame_up_to_date_hook
= XTframe_up_to_date
;
10547 terminal
->mouse_position_hook
= XTmouse_position
;
10548 terminal
->frame_rehighlight_hook
= XTframe_rehighlight
;
10549 terminal
->frame_raise_lower_hook
= XTframe_raise_lower
;
10550 terminal
->fullscreen_hook
= XTfullscreen_hook
;
10551 terminal
->set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
10552 terminal
->condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
10553 terminal
->redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
10554 terminal
->judge_scroll_bars_hook
= XTjudge_scroll_bars
;
10556 terminal
->delete_frame_hook
= x_destroy_window
;
10557 terminal
->delete_terminal_hook
= x_delete_terminal
;
10559 terminal
->rif
= &x_redisplay_interface
;
10560 terminal
->scroll_region_ok
= 1; /* We'll scroll partial frames. */
10561 terminal
->char_ins_del_ok
= 1;
10562 terminal
->line_ins_del_ok
= 1; /* We'll just blt 'em. */
10563 terminal
->fast_clear_end_of_line
= 1; /* X does this well. */
10564 terminal
->memory_below_frame
= 0; /* We don't remember what scrolls
10571 x_initialize (void)
10576 last_tool_bar_item
= -1;
10577 any_help_event_p
= 0;
10578 ignore_next_mouse_click_timeout
= 0;
10580 x_session_initialized
= 0;
10584 current_count
= -1;
10587 /* Try to use interrupt input; if we can't, then start polling. */
10588 Fset_input_interrupt_mode (Qt
);
10590 #ifdef USE_X_TOOLKIT
10591 XtToolkitInitialize ();
10593 Xt_app_con
= XtCreateApplicationContext ();
10595 /* Register a converter from strings to pixels, which uses
10596 Emacs' color allocation infrastructure. */
10597 XtAppSetTypeConverter (Xt_app_con
,
10598 XtRString
, XtRPixel
, cvt_string_to_pixel
,
10599 cvt_string_to_pixel_args
,
10600 XtNumber (cvt_string_to_pixel_args
),
10601 XtCacheByDisplay
, cvt_pixel_dtor
);
10603 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
10606 #ifdef USE_TOOLKIT_SCROLL_BARS
10608 xaw3d_arrow_scroll
= False
;
10609 xaw3d_pick_top
= True
;
10613 pending_autoraise_frame
= 0;
10614 pending_event_wait
.f
= 0;
10615 pending_event_wait
.eventtype
= 0;
10617 /* Note that there is no real way portable across R3/R4 to get the
10618 original error handler. */
10619 XSetErrorHandler (x_error_handler
);
10620 XSetIOErrorHandler (x_io_error_quitter
);
10622 signal (SIGPIPE
, x_connection_signal
);
10624 xgselect_initialize ();
10629 syms_of_xterm (void)
10631 x_error_message
= NULL
;
10633 staticpro (&x_display_name_list
);
10634 x_display_name_list
= Qnil
;
10636 staticpro (&last_mouse_scroll_bar
);
10637 last_mouse_scroll_bar
= Qnil
;
10639 staticpro (&Qvendor_specific_keysyms
);
10640 Qvendor_specific_keysyms
= intern_c_string ("vendor-specific-keysyms");
10642 staticpro (&Qlatin_1
);
10643 Qlatin_1
= intern_c_string ("latin-1");
10645 staticpro (&last_mouse_press_frame
);
10646 last_mouse_press_frame
= Qnil
;
10649 xg_default_icon_file
= make_pure_c_string ("icons/hicolor/scalable/apps/emacs.svg");
10650 staticpro (&xg_default_icon_file
);
10652 Qx_gtk_map_stock
= intern_c_string ("x-gtk-map-stock");
10653 staticpro (&Qx_gtk_map_stock
);
10656 DEFVAR_BOOL ("x-use-underline-position-properties",
10657 &x_use_underline_position_properties
,
10658 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
10659 A value of nil means ignore them. If you encounter fonts with bogus
10660 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
10661 to 4.1, set this to nil. You can also use `underline-minimum-offset'
10662 to override the font's UNDERLINE_POSITION for small font display
10664 x_use_underline_position_properties
= 1;
10666 DEFVAR_BOOL ("x-underline-at-descent-line",
10667 &x_underline_at_descent_line
,
10668 doc
: /* *Non-nil means to draw the underline at the same place as the descent line.
10669 A value of nil means to draw the underline according to the value of the
10670 variable `x-use-underline-position-properties', which is usually at the
10671 baseline level. The default value is nil. */);
10672 x_underline_at_descent_line
= 0;
10674 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
10675 &x_mouse_click_focus_ignore_position
,
10676 doc
: /* Non-nil means that a mouse click to focus a frame does not move point.
10677 This variable is only used when the window manager requires that you
10678 click on a frame to select it (give it focus). In that case, a value
10679 of nil, means that the selected window and cursor position changes to
10680 reflect the mouse click position, while a non-nil value means that the
10681 selected window or cursor position is preserved. */);
10682 x_mouse_click_focus_ignore_position
= 0;
10684 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
10685 doc
: /* Which toolkit scroll bars Emacs uses, if any.
10686 A value of nil means Emacs doesn't use toolkit scroll bars.
10687 With the X Window system, the value is a symbol describing the
10688 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
10689 With MS Windows, the value is t. */);
10690 #ifdef USE_TOOLKIT_SCROLL_BARS
10692 Vx_toolkit_scroll_bars
= intern_c_string ("motif");
10693 #elif defined HAVE_XAW3D
10694 Vx_toolkit_scroll_bars
= intern_c_string ("xaw3d");
10696 Vx_toolkit_scroll_bars
= intern_c_string ("gtk");
10698 Vx_toolkit_scroll_bars
= intern_c_string ("xaw");
10701 Vx_toolkit_scroll_bars
= Qnil
;
10704 staticpro (&last_mouse_motion_frame
);
10705 last_mouse_motion_frame
= Qnil
;
10707 Qmodifier_value
= intern_c_string ("modifier-value");
10708 Qalt
= intern_c_string ("alt");
10709 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
10710 Qhyper
= intern_c_string ("hyper");
10711 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
10712 Qmeta
= intern_c_string ("meta");
10713 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
10714 Qsuper
= intern_c_string ("super");
10715 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
10717 DEFVAR_LISP ("x-alt-keysym", &Vx_alt_keysym
,
10718 doc
: /* Which keys Emacs uses for the alt modifier.
10719 This should be one of the symbols `alt', `hyper', `meta', `super'.
10720 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
10721 is nil, which is the same as `alt'. */);
10722 Vx_alt_keysym
= Qnil
;
10724 DEFVAR_LISP ("x-hyper-keysym", &Vx_hyper_keysym
,
10725 doc
: /* Which keys Emacs uses for the hyper modifier.
10726 This should be one of the symbols `alt', `hyper', `meta', `super'.
10727 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
10728 default is nil, which is the same as `hyper'. */);
10729 Vx_hyper_keysym
= Qnil
;
10731 DEFVAR_LISP ("x-meta-keysym", &Vx_meta_keysym
,
10732 doc
: /* Which keys Emacs uses for the meta modifier.
10733 This should be one of the symbols `alt', `hyper', `meta', `super'.
10734 For example, `meta' means use the Meta_L and Meta_R keysyms. The
10735 default is nil, which is the same as `meta'. */);
10736 Vx_meta_keysym
= Qnil
;
10738 DEFVAR_LISP ("x-super-keysym", &Vx_super_keysym
,
10739 doc
: /* Which keys Emacs uses for the super modifier.
10740 This should be one of the symbols `alt', `hyper', `meta', `super'.
10741 For example, `super' means use the Super_L and Super_R keysyms. The
10742 default is nil, which is the same as `super'. */);
10743 Vx_super_keysym
= Qnil
;
10745 DEFVAR_LISP ("x-keysym-table", &Vx_keysym_table
,
10746 doc
: /* Hash table of character codes indexed by X keysym codes. */);
10747 Vx_keysym_table
= make_hash_table (Qeql
, make_number (900),
10748 make_float (DEFAULT_REHASH_SIZE
),
10749 make_float (DEFAULT_REHASH_THRESHOLD
),
10753 #endif /* HAVE_X_WINDOWS */