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 /* We have to close the display to inform Xt that it doesn't
7674 exist anymore. If we don't, Xt will continue to wait for
7675 events from the display. As a consequence, a sequence of
7677 M-x make-frame-on-display RET :1 RET
7678 ...kill the new frame, so that we get an IO error...
7679 M-x make-frame-on-display RET :1 RET
7681 will indefinitely wait in Xt for events for display `:1', opened
7682 in the first call to make-frame-on-display.
7684 Closing the display is reported to lead to a bus error on
7685 OpenWindows in certain situations. I suspect that is a bug
7686 in OpenWindows. I don't know how to circumvent it here. */
7690 #ifdef USE_X_TOOLKIT
7691 /* If DPYINFO is null, this means we didn't open the display
7692 in the first place, so don't try to close it. */
7694 fatal_error_signal_hook
= x_fatal_error_signal
;
7695 XtCloseDisplay (dpy
);
7696 fatal_error_signal_hook
= NULL
;
7701 /* Due to bugs in some Gtk+ versions, just exit here. */
7703 fprintf (stderr
, "%s\n", error_msg
);
7704 Fkill_emacs (make_number (70));
7705 abort (); /* NOTREACHED */
7709 /* Indicate that this display is dead. */
7710 dpyinfo
->display
= 0;
7712 dpyinfo
->reference_count
--;
7713 dpyinfo
->terminal
->reference_count
--;
7714 if (dpyinfo
->reference_count
!= 0)
7715 /* We have just closed all frames on this display. */
7720 XSETTERMINAL (tmp
, dpyinfo
->terminal
);
7721 Fdelete_terminal (tmp
, Qnoelisp
);
7725 x_uncatch_errors ();
7727 if (terminal_list
== 0)
7729 fprintf (stderr
, "%s\n", error_msg
);
7730 Fkill_emacs (make_number (70));
7734 /* Ordinary stack unwind doesn't deal with these. */
7736 sigunblock (sigmask (SIGIO
));
7738 sigunblock (sigmask (SIGALRM
));
7739 TOTALLY_UNBLOCK_INPUT
;
7741 unbind_to (index
, Qnil
);
7742 clear_waiting_for_input ();
7743 /* Here, we absolutely have to use a non-local exit (e.g. signal, throw,
7744 longjmp), because returning from this function would get us back into
7745 Xlib's code which will directly call `exit'. */
7746 error ("%s", error_msg
);
7749 /* We specifically use it before defining it, so that gcc doesn't inline it,
7750 otherwise gdb doesn't know how to properly put a breakpoint on it. */
7751 static void x_error_quitter (Display
*, XErrorEvent
*);
7753 /* This is the first-level handler for X protocol errors.
7754 It calls x_error_quitter or x_error_catcher. */
7757 x_error_handler (Display
*display
, XErrorEvent
*error
)
7759 if (x_error_message
)
7760 x_error_catcher (display
, error
);
7762 x_error_quitter (display
, error
);
7766 /* This is the usual handler for X protocol errors.
7767 It kills all frames on the display that we got the error for.
7768 If that was the only one, it prints an error message and kills Emacs. */
7770 /* .gdbinit puts a breakpoint here, so make sure it is not inlined. */
7772 /* On older GCC versions, just putting x_error_quitter
7773 after x_error_handler prevents inlining into the former. */
7775 static void NO_INLINE
7776 x_error_quitter (Display
*display
, XErrorEvent
*error
)
7778 char buf
[256], buf1
[356];
7780 /* Ignore BadName errors. They can happen because of fonts
7781 or colors that are not defined. */
7783 if (error
->error_code
== BadName
)
7786 /* Note that there is no real way portable across R3/R4 to get the
7787 original error handler. */
7789 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
7790 sprintf (buf1
, "X protocol error: %s on protocol request %d",
7791 buf
, error
->request_code
);
7792 x_connection_closed (display
, buf1
);
7796 /* This is the handler for X IO errors, always.
7797 It kills all frames on the display that we lost touch with.
7798 If that was the only one, it prints an error message and kills Emacs. */
7801 x_io_error_quitter (Display
*display
)
7805 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
7806 x_connection_closed (display
, buf
);
7810 /* Changing the font of the frame. */
7812 /* Give frame F the font FONT-OBJECT as its default font. The return
7813 value is FONT-OBJECT. FONTSET is an ID of the fontset for the
7814 frame. If it is negative, generate a new fontset from
7818 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
7820 struct font
*font
= XFONT_OBJECT (font_object
);
7823 fontset
= fontset_from_font (font_object
);
7824 FRAME_FONTSET (f
) = fontset
;
7825 if (FRAME_FONT (f
) == font
)
7826 /* This font is already set in frame F. There's nothing more to
7830 FRAME_FONT (f
) = font
;
7831 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
7832 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
7833 FRAME_SPACE_WIDTH (f
) = font
->space_width
;
7834 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (font
);
7836 compute_fringe_widths (f
, 1);
7838 /* Compute the scroll bar width in character columns. */
7839 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
7841 int wid
= FRAME_COLUMN_WIDTH (f
);
7842 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
7843 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
-1) / wid
;
7847 int wid
= FRAME_COLUMN_WIDTH (f
);
7848 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
7851 if (FRAME_X_WINDOW (f
) != 0)
7853 /* Don't change the size of a tip frame; there's no point in
7854 doing it because it's done in Fx_show_tip, and it leads to
7855 problems because the tip frame has no widget. */
7856 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
7857 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
7862 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
7865 xic_set_xfontset (f
, SDATA (fontset_ascii (fontset
)));
7874 /***********************************************************************
7876 ***********************************************************************/
7882 /* XIM destroy callback function, which is called whenever the
7883 connection to input method XIM dies. CLIENT_DATA contains a
7884 pointer to the x_display_info structure corresponding to XIM. */
7887 xim_destroy_callback (XIM xim
, XPointer client_data
, XPointer call_data
)
7889 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
7890 Lisp_Object frame
, tail
;
7894 /* No need to call XDestroyIC.. */
7895 FOR_EACH_FRAME (tail
, frame
)
7897 struct frame
*f
= XFRAME (frame
);
7898 if (FRAME_X_P (f
) && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
7900 FRAME_XIC (f
) = NULL
;
7901 xic_free_xfontset (f
);
7905 /* No need to call XCloseIM. */
7906 dpyinfo
->xim
= NULL
;
7907 XFree (dpyinfo
->xim_styles
);
7911 #endif /* HAVE_X11R6 */
7914 /* This isn't prototyped in OSF 5.0 or 5.1a. */
7915 extern char *XSetIMValues (XIM
, ...);
7918 /* Open the connection to the XIM server on display DPYINFO.
7919 RESOURCE_NAME is the resource name Emacs uses. */
7922 xim_open_dpy (struct x_display_info
*dpyinfo
, char *resource_name
)
7930 XCloseIM (dpyinfo
->xim
);
7931 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
,
7938 XIMCallback destroy
;
7941 /* Get supported styles and XIM values. */
7942 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
7945 destroy
.callback
= xim_destroy_callback
;
7946 destroy
.client_data
= (XPointer
)dpyinfo
;
7947 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
7953 #endif /* HAVE_XIM */
7954 dpyinfo
->xim
= NULL
;
7958 #ifdef HAVE_X11R6_XIM
7960 /* XIM instantiate callback function, which is called whenever an XIM
7961 server is available. DISPLAY is the display of the XIM.
7962 CLIENT_DATA contains a pointer to an xim_inst_t structure created
7963 when the callback was registered. */
7966 xim_instantiate_callback (Display
*display
, XPointer client_data
, XPointer call_data
)
7968 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
7969 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
7971 /* We don't support multiple XIM connections. */
7975 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
7977 /* Create XIC for the existing frames on the same display, as long
7978 as they have no XIC. */
7979 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
7981 Lisp_Object tail
, frame
;
7984 FOR_EACH_FRAME (tail
, frame
)
7986 struct frame
*f
= XFRAME (frame
);
7989 && FRAME_X_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
7990 if (FRAME_XIC (f
) == NULL
)
7992 create_frame_xic (f
);
7993 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
7994 xic_set_statusarea (f
);
7995 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
7997 struct window
*w
= XWINDOW (f
->selected_window
);
7998 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
8007 #endif /* HAVE_X11R6_XIM */
8010 /* Open a connection to the XIM server on display DPYINFO.
8011 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
8012 connection only at the first time. On X11R6, open the connection
8013 in the XIM instantiate callback function. */
8016 xim_initialize (struct x_display_info
*dpyinfo
, char *resource_name
)
8018 dpyinfo
->xim
= NULL
;
8022 #ifdef HAVE_X11R6_XIM
8023 struct xim_inst_t
*xim_inst
;
8026 xim_inst
= (struct xim_inst_t
*) xmalloc (sizeof (struct xim_inst_t
));
8027 dpyinfo
->xim_callback_data
= xim_inst
;
8028 xim_inst
->dpyinfo
= dpyinfo
;
8029 len
= strlen (resource_name
);
8030 xim_inst
->resource_name
= (char *) xmalloc (len
+ 1);
8031 memcpy (xim_inst
->resource_name
, resource_name
, len
+ 1);
8032 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8033 resource_name
, emacs_class
,
8034 xim_instantiate_callback
,
8035 /* This is XPointer in XFree86
8036 but (XPointer *) on Tru64, at
8037 least, hence the configure test. */
8038 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
8039 #else /* not HAVE_X11R6_XIM */
8040 xim_open_dpy (dpyinfo
, resource_name
);
8041 #endif /* not HAVE_X11R6_XIM */
8043 #endif /* HAVE_XIM */
8047 /* Close the connection to the XIM server on display DPYINFO. */
8050 xim_close_dpy (struct x_display_info
*dpyinfo
)
8055 #ifdef HAVE_X11R6_XIM
8056 if (dpyinfo
->display
)
8057 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8059 xim_instantiate_callback
, NULL
);
8060 xfree (dpyinfo
->xim_callback_data
->resource_name
);
8061 xfree (dpyinfo
->xim_callback_data
);
8062 #endif /* HAVE_X11R6_XIM */
8063 if (dpyinfo
->display
)
8064 XCloseIM (dpyinfo
->xim
);
8065 dpyinfo
->xim
= NULL
;
8066 XFree (dpyinfo
->xim_styles
);
8068 #endif /* HAVE_XIM */
8071 #endif /* not HAVE_X11R6_XIM */
8075 /* Calculate the absolute position in frame F
8076 from its current recorded position values and gravity. */
8079 x_calc_absolute_position (struct frame
*f
)
8081 int flags
= f
->size_hint_flags
;
8083 /* We have nothing to do if the current position
8084 is already for the top-left corner. */
8085 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
8088 /* Treat negative positions as relative to the leftmost bottommost
8089 position that fits on the screen. */
8090 if (flags
& XNegative
)
8091 f
->left_pos
= x_display_pixel_width (FRAME_X_DISPLAY_INFO (f
))
8092 - FRAME_PIXEL_WIDTH (f
) + f
->left_pos
;
8095 int height
= FRAME_PIXEL_HEIGHT (f
);
8097 #if defined USE_X_TOOLKIT && defined USE_MOTIF
8098 /* Something is fishy here. When using Motif, starting Emacs with
8099 `-g -0-0', the frame appears too low by a few pixels.
8101 This seems to be so because initially, while Emacs is starting,
8102 the column widget's height and the frame's pixel height are
8103 different. The column widget's height is the right one. In
8104 later invocations, when Emacs is up, the frame's pixel height
8107 It's not obvious where the initial small difference comes from.
8108 2000-12-01, gerd. */
8110 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
8113 if (flags
& YNegative
)
8114 f
->top_pos
= x_display_pixel_height (FRAME_X_DISPLAY_INFO (f
))
8115 - height
+ f
->top_pos
;
8118 /* The left_pos and top_pos
8119 are now relative to the top and left screen edges,
8120 so the flags should correspond. */
8121 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8124 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
8125 to really change the position, and 0 when calling from
8126 x_make_frame_visible (in that case, XOFF and YOFF are the current
8127 position values). It is -1 when calling from x_set_frame_parameters,
8128 which means, do adjust for borders but don't change the gravity. */
8131 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
, int change_gravity
)
8133 int modified_top
, modified_left
;
8135 if (change_gravity
> 0)
8137 FRAME_X_OUTPUT (f
)->left_before_move
= f
->left_pos
;
8138 FRAME_X_OUTPUT (f
)->top_before_move
= f
->top_pos
;
8142 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8144 f
->size_hint_flags
|= XNegative
;
8146 f
->size_hint_flags
|= YNegative
;
8147 f
->win_gravity
= NorthWestGravity
;
8149 x_calc_absolute_position (f
);
8152 x_wm_set_size_hint (f
, (long) 0, 0);
8154 modified_left
= f
->left_pos
;
8155 modified_top
= f
->top_pos
;
8157 if (change_gravity
!= 0 && FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
)
8159 /* Some WMs (twm, wmaker at least) has an offset that is smaller
8160 than the WM decorations. So we use the calculated offset instead
8161 of the WM decoration sizes here (x/y_pixels_outer_diff). */
8162 modified_left
+= FRAME_X_OUTPUT (f
)->move_offset_left
;
8163 modified_top
+= FRAME_X_OUTPUT (f
)->move_offset_top
;
8166 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8167 modified_left
, modified_top
);
8169 x_sync_with_move (f
, f
->left_pos
, f
->top_pos
,
8170 FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8173 /* change_gravity is non-zero when this function is called from Lisp to
8174 programmatically move a frame. In that case, we call
8175 x_check_expected_move to discover if we have a "Type A" or "Type B"
8176 window manager, and, for a "Type A" window manager, adjust the position
8179 We call x_check_expected_move if a programmatic move occurred, and
8180 either the window manager type (A/B) is unknown or it is Type A but we
8181 need to compute the top/left offset adjustment for this frame. */
8183 if (change_gravity
!= 0 &&
8184 (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8185 || (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
8186 && (FRAME_X_OUTPUT (f
)->move_offset_left
== 0
8187 && FRAME_X_OUTPUT (f
)->move_offset_top
== 0))))
8188 x_check_expected_move (f
, modified_left
, modified_top
);
8193 /* Return non-zero if _NET_SUPPORTING_WM_CHECK window exists and _NET_SUPPORTED
8194 on the root window for frame F contains ATOMNAME.
8195 This is how a WM check shall be done according to the Window Manager
8196 Specification/Extended Window Manager Hints at
8197 http://freedesktop.org/wiki/Specifications/wm-spec. */
8200 wm_supports (struct frame
*f
, const char *atomname
)
8203 unsigned long actual_size
, bytes_remaining
;
8204 int i
, rc
, actual_format
;
8206 Window wmcheck_window
;
8207 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8208 Window target_window
= dpyinfo
->root_window
;
8209 long max_len
= 65536;
8210 Display
*dpy
= FRAME_X_DISPLAY (f
);
8211 unsigned char *tmp_data
= NULL
;
8212 Atom target_type
= XA_WINDOW
;
8217 prop_atom
= XInternAtom (dpy
, "_NET_SUPPORTING_WM_CHECK", False
);
8219 x_catch_errors (dpy
);
8220 rc
= XGetWindowProperty (dpy
, target_window
,
8221 prop_atom
, 0, max_len
, False
, target_type
,
8222 &actual_type
, &actual_format
, &actual_size
,
8223 &bytes_remaining
, &tmp_data
);
8225 if (rc
!= Success
|| actual_type
!= XA_WINDOW
|| x_had_errors_p (dpy
))
8227 if (tmp_data
) XFree (tmp_data
);
8228 x_uncatch_errors ();
8233 wmcheck_window
= *(Window
*) tmp_data
;
8236 /* Check if window exists. */
8237 XSelectInput (dpy
, wmcheck_window
, StructureNotifyMask
);
8239 if (x_had_errors_p (dpy
))
8241 x_uncatch_errors ();
8246 if (dpyinfo
->net_supported_window
!= wmcheck_window
)
8248 /* Window changed, reload atoms */
8249 if (dpyinfo
->net_supported_atoms
!= NULL
)
8250 XFree (dpyinfo
->net_supported_atoms
);
8251 dpyinfo
->net_supported_atoms
= NULL
;
8252 dpyinfo
->nr_net_supported_atoms
= 0;
8253 dpyinfo
->net_supported_window
= 0;
8255 target_type
= XA_ATOM
;
8256 prop_atom
= XInternAtom (dpy
, "_NET_SUPPORTED", False
);
8258 rc
= XGetWindowProperty (dpy
, target_window
,
8259 prop_atom
, 0, max_len
, False
, target_type
,
8260 &actual_type
, &actual_format
, &actual_size
,
8261 &bytes_remaining
, &tmp_data
);
8263 if (rc
!= Success
|| actual_type
!= XA_ATOM
|| x_had_errors_p (dpy
))
8265 if (tmp_data
) XFree (tmp_data
);
8266 x_uncatch_errors ();
8271 dpyinfo
->net_supported_atoms
= (Atom
*)tmp_data
;
8272 dpyinfo
->nr_net_supported_atoms
= actual_size
;
8273 dpyinfo
->net_supported_window
= wmcheck_window
;
8277 want_atom
= XInternAtom (dpy
, atomname
, False
);
8279 for (i
= 0; rc
== 0 && i
< dpyinfo
->nr_net_supported_atoms
; ++i
)
8280 rc
= dpyinfo
->net_supported_atoms
[i
] == want_atom
;
8282 x_uncatch_errors ();
8289 set_wm_state (Lisp_Object frame
, int add
, const char *what
, const char *what2
)
8291 const char *atom
= "_NET_WM_STATE";
8292 Fx_send_client_event (frame
, make_number (0), frame
,
8293 make_unibyte_string (atom
, strlen (atom
)),
8295 /* 1 = add, 0 = remove */
8297 (make_number (add
? 1 : 0),
8299 (make_unibyte_string (what
, strlen (what
)),
8301 ? Fcons (make_unibyte_string (what2
, strlen (what2
)),
8307 x_set_sticky (struct frame
*f
, Lisp_Object new_value
, Lisp_Object old_value
)
8311 XSETFRAME (frame
, f
);
8312 set_wm_state (frame
, NILP (new_value
) ? 0 : 1,
8313 "_NET_WM_STATE_STICKY", NULL
);
8316 /* Return the current _NET_WM_STATE.
8317 SIZE_STATE is set to one of the FULLSCREEN_* values.
8318 STICKY is set to 1 if the sticky state is set, 0 if not. */
8321 get_current_vm_state (struct frame
*f
,
8327 unsigned long actual_size
, bytes_remaining
;
8328 int i
, rc
, actual_format
;
8329 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8330 long max_len
= 65536;
8331 Display
*dpy
= FRAME_X_DISPLAY (f
);
8332 unsigned char *tmp_data
= NULL
;
8333 Atom target_type
= XA_ATOM
;
8336 *size_state
= FULLSCREEN_NONE
;
8339 x_catch_errors (dpy
);
8340 rc
= XGetWindowProperty (dpy
, window
, dpyinfo
->Xatom_net_wm_state
,
8341 0, max_len
, False
, target_type
,
8342 &actual_type
, &actual_format
, &actual_size
,
8343 &bytes_remaining
, &tmp_data
);
8345 if (rc
!= Success
|| actual_type
!= target_type
|| x_had_errors_p (dpy
))
8347 if (tmp_data
) XFree (tmp_data
);
8348 x_uncatch_errors ();
8353 x_uncatch_errors ();
8355 for (i
= 0; i
< actual_size
; ++i
)
8357 Atom a
= ((Atom
*)tmp_data
)[i
];
8358 if (a
== dpyinfo
->Xatom_net_wm_state_maximized_horz
)
8360 if (*size_state
== FULLSCREEN_HEIGHT
)
8361 *size_state
= FULLSCREEN_MAXIMIZED
;
8363 *size_state
= FULLSCREEN_WIDTH
;
8365 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_vert
)
8367 if (*size_state
== FULLSCREEN_WIDTH
)
8368 *size_state
= FULLSCREEN_MAXIMIZED
;
8370 *size_state
= FULLSCREEN_HEIGHT
;
8372 else if (a
== dpyinfo
->Xatom_net_wm_state_fullscreen_atom
)
8373 *size_state
= FULLSCREEN_BOTH
;
8374 else if (a
== dpyinfo
->Xatom_net_wm_state_sticky
)
8378 if (tmp_data
) XFree (tmp_data
);
8382 /* Do fullscreen as specified in extended window manager hints */
8385 do_ewmh_fullscreen (struct frame
*f
)
8387 int have_net_atom
= wm_supports (f
, "_NET_WM_STATE");
8388 Lisp_Object lval
= get_frame_param (f
, Qfullscreen
);
8391 get_current_vm_state (f
, FRAME_OUTER_WINDOW (f
), &cur
, &dummy
);
8393 /* Some window managers don't say they support _NET_WM_STATE, but they do say
8394 they support _NET_WM_STATE_FULLSCREEN. Try that also. */
8396 have_net_atom
= wm_supports (f
, "_NET_WM_STATE_FULLSCREEN");
8398 if (have_net_atom
&& cur
!= f
->want_fullscreen
)
8401 const char *fs
= "_NET_WM_STATE_FULLSCREEN";
8402 const char *fw
= "_NET_WM_STATE_MAXIMIZED_HORZ";
8403 const char *fh
= "_NET_WM_STATE_MAXIMIZED_VERT";
8405 XSETFRAME (frame
, f
);
8407 /* Keep number of calls to set_wm_state as low as possible.
8408 Some window managers, or possible Gtk+, hangs when too many
8409 are sent at once. */
8410 switch (f
->want_fullscreen
)
8412 case FULLSCREEN_BOTH
:
8413 if (cur
== FULLSCREEN_WIDTH
|| cur
== FULLSCREEN_MAXIMIZED
8414 || cur
== FULLSCREEN_HEIGHT
)
8415 set_wm_state (frame
, 0, fw
, fh
);
8416 set_wm_state (frame
, 1, fs
, NULL
);
8418 case FULLSCREEN_WIDTH
:
8419 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_HEIGHT
8420 || cur
== FULLSCREEN_MAXIMIZED
)
8421 set_wm_state (frame
, 0, fs
, fh
);
8422 if (cur
!= FULLSCREEN_MAXIMIZED
)
8423 set_wm_state (frame
, 1, fw
, NULL
);
8425 case FULLSCREEN_HEIGHT
:
8426 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_WIDTH
8427 || cur
== FULLSCREEN_MAXIMIZED
)
8428 set_wm_state (frame
, 0, fs
, fw
);
8429 if (cur
!= FULLSCREEN_MAXIMIZED
)
8430 set_wm_state (frame
, 1, fh
, NULL
);
8432 case FULLSCREEN_MAXIMIZED
:
8433 if (cur
== FULLSCREEN_BOTH
)
8434 set_wm_state (frame
, 0, fs
, NULL
);
8435 set_wm_state (frame
, 1, fw
, fh
);
8437 case FULLSCREEN_NONE
:
8438 if (cur
== FULLSCREEN_BOTH
)
8439 set_wm_state (frame
, 0, fs
, NULL
);
8441 set_wm_state (frame
, 0, fw
, fh
);
8444 f
->want_fullscreen
= FULLSCREEN_NONE
;
8448 return have_net_atom
;
8452 XTfullscreen_hook (FRAME_PTR f
)
8454 if (f
->async_visible
)
8457 x_check_fullscreen (f
);
8465 x_handle_net_wm_state (struct frame
*f
, XPropertyEvent
*event
)
8467 int value
= FULLSCREEN_NONE
;
8471 get_current_vm_state (f
, event
->window
, &value
, &sticky
);
8475 case FULLSCREEN_WIDTH
:
8478 case FULLSCREEN_HEIGHT
:
8481 case FULLSCREEN_BOTH
:
8484 case FULLSCREEN_MAXIMIZED
:
8489 store_frame_param (f
, Qfullscreen
, lval
);
8490 store_frame_param (f
, Qsticky
, sticky
? Qt
: Qnil
);
8493 /* Check if we need to resize the frame due to a fullscreen request.
8494 If so needed, resize the frame. */
8496 x_check_fullscreen (struct frame
*f
)
8498 if (do_ewmh_fullscreen (f
))
8501 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
8502 return; /* Only fullscreen without WM or with EWM hints (above). */
8504 if (f
->want_fullscreen
!= FULLSCREEN_NONE
)
8506 int width
= FRAME_COLS (f
), height
= FRAME_LINES (f
);
8507 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8509 switch (f
->want_fullscreen
)
8511 /* No difference between these two when there is no WM */
8512 case FULLSCREEN_BOTH
:
8513 case FULLSCREEN_MAXIMIZED
:
8514 width
= x_display_pixel_width (dpyinfo
);
8515 height
= x_display_pixel_height (dpyinfo
);
8517 case FULLSCREEN_WIDTH
:
8518 width
= x_display_pixel_width (dpyinfo
);
8520 case FULLSCREEN_HEIGHT
:
8521 height
= x_display_pixel_height (dpyinfo
);
8524 if (FRAME_COLS (f
) != width
|| FRAME_LINES (f
) != height
)
8526 change_frame_size (f
, height
, width
, 0, 1, 0);
8527 SET_FRAME_GARBAGED (f
);
8528 cancel_mouse_face (f
);
8533 /* This function is called by x_set_offset to determine whether the window
8534 manager interfered with the positioning of the frame. Type A window
8535 managers position the surrounding window manager decorations a small
8536 amount above and left of the user-supplied position. Type B window
8537 managers position the surrounding window manager decorations at the
8538 user-specified position. If we detect a Type A window manager, we
8539 compensate by moving the window right and down by the proper amount. */
8542 x_check_expected_move (struct frame
*f
, int expected_left
, int expected_top
)
8544 int current_left
= 0, current_top
= 0;
8546 /* x_real_positions returns the left and top offsets of the outermost
8547 window manager window around the frame. */
8549 x_real_positions (f
, ¤t_left
, ¤t_top
);
8551 if (current_left
!= expected_left
|| current_top
!= expected_top
)
8553 /* It's a "Type A" window manager. */
8558 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_A
;
8559 FRAME_X_OUTPUT (f
)->move_offset_left
= expected_left
- current_left
;
8560 FRAME_X_OUTPUT (f
)->move_offset_top
= expected_top
- current_top
;
8562 /* Now fix the mispositioned frame's location. */
8564 adjusted_left
= expected_left
+ FRAME_X_OUTPUT (f
)->move_offset_left
;
8565 adjusted_top
= expected_top
+ FRAME_X_OUTPUT (f
)->move_offset_top
;
8567 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8568 adjusted_left
, adjusted_top
);
8570 x_sync_with_move (f
, expected_left
, expected_top
, 0);
8573 /* It's a "Type B" window manager. We don't have to adjust the
8574 frame's position. */
8576 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_B
;
8580 /* Wait for XGetGeometry to return up-to-date position information for a
8581 recently-moved frame. Call this immediately after calling XMoveWindow.
8582 If FUZZY is non-zero, then LEFT and TOP are just estimates of where the
8583 frame has been moved to, so we use a fuzzy position comparison instead
8584 of an exact comparison. */
8587 x_sync_with_move (struct frame
*f
, int left
, int top
, int fuzzy
)
8591 while (count
++ < 50)
8593 int current_left
= 0, current_top
= 0;
8595 /* In theory, this call to XSync only needs to happen once, but in
8596 practice, it doesn't seem to work, hence the need for the surrounding
8599 XSync (FRAME_X_DISPLAY (f
), False
);
8600 x_real_positions (f
, ¤t_left
, ¤t_top
);
8604 /* The left fuzz-factor is 10 pixels. The top fuzz-factor is 40
8607 if (eabs (current_left
- left
) <= 10
8608 && eabs (current_top
- top
) <= 40)
8611 else if (current_left
== left
&& current_top
== top
)
8615 /* As a last resort, just wait 0.5 seconds and hope that XGetGeometry
8616 will then return up-to-date position info. */
8618 wait_reading_process_output (0, 500000, 0, 0, Qnil
, NULL
, 0);
8622 /* Wait for an event on frame F matching EVENTTYPE. */
8624 x_wait_for_event (struct frame
*f
, int eventtype
)
8626 int level
= interrupt_input_blocked
;
8629 EMACS_TIME tmo
, tmo_at
, time_now
;
8630 int fd
= ConnectionNumber (FRAME_X_DISPLAY (f
));
8632 pending_event_wait
.f
= f
;
8633 pending_event_wait
.eventtype
= eventtype
;
8635 /* Set timeout to 0.1 second. Hopefully not noticable.
8636 Maybe it should be configurable. */
8637 EMACS_SET_SECS_USECS (tmo
, 0, 100000);
8638 EMACS_GET_TIME (tmo_at
);
8639 EMACS_ADD_TIME (tmo_at
, tmo_at
, tmo
);
8641 while (pending_event_wait
.eventtype
)
8643 interrupt_input_pending
= 1;
8644 TOTALLY_UNBLOCK_INPUT
;
8645 /* XTread_socket is called after unblock. */
8647 interrupt_input_blocked
= level
;
8652 EMACS_GET_TIME (time_now
);
8653 EMACS_SUB_TIME (tmo
, tmo_at
, time_now
);
8655 if (EMACS_TIME_NEG_P (tmo
) || select (fd
+1, &fds
, NULL
, NULL
, &tmo
) == 0)
8656 break; /* Timeout */
8658 pending_event_wait
.f
= 0;
8659 pending_event_wait
.eventtype
= 0;
8663 /* Change the size of frame F's X window to COLS/ROWS in the case F
8664 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
8665 top-left-corner window gravity for this size change and subsequent
8666 size changes. Otherwise we leave the window gravity unchanged. */
8669 x_set_window_size_1 (struct frame
*f
, int change_gravity
, int cols
, int rows
)
8671 int pixelwidth
, pixelheight
;
8673 check_frame_size (f
, &rows
, &cols
);
8674 f
->scroll_bar_actual_width
8675 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
8677 : FRAME_CONFIG_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
));
8679 compute_fringe_widths (f
, 0);
8681 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
)
8682 + FRAME_TOOLBAR_WIDTH (f
);
8683 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
8684 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
8686 if (change_gravity
) f
->win_gravity
= NorthWestGravity
;
8687 x_wm_set_size_hint (f
, (long) 0, 0);
8688 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8689 pixelwidth
, pixelheight
);
8692 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
8693 receive in the ConfigureNotify event; if we get what we asked
8694 for, then the event won't cause the screen to become garbaged, so
8695 we have to make sure to do it here. */
8696 SET_FRAME_GARBAGED (f
);
8698 /* Now, strictly speaking, we can't be sure that this is accurate,
8699 but the window manager will get around to dealing with the size
8700 change request eventually, and we'll hear how it went when the
8701 ConfigureNotify event gets here.
8703 We could just not bother storing any of this information here,
8704 and let the ConfigureNotify event set everything up, but that
8705 might be kind of confusing to the Lisp code, since size changes
8706 wouldn't be reported in the frame parameters until some random
8707 point in the future when the ConfigureNotify event arrives.
8709 We pass 1 for DELAY since we can't run Lisp code inside of
8712 /* But the ConfigureNotify may in fact never arrive, and then this is
8713 not right if the frame is visible. Instead wait (with timeout)
8714 for the ConfigureNotify. */
8715 if (f
->async_visible
)
8716 x_wait_for_event (f
, ConfigureNotify
);
8719 change_frame_size (f
, rows
, cols
, 0, 1, 0);
8720 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
8721 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
8727 /* Call this to change the size of frame F's x-window.
8728 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
8729 for this size change and subsequent size changes.
8730 Otherwise we leave the window gravity unchanged. */
8733 x_set_window_size (struct frame
*f
, int change_gravity
, int cols
, int rows
)
8737 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
8741 /* When the frame is maximized/fullscreen or running under for
8742 example Xmonad, x_set_window_size_1 will be a no-op.
8743 In that case, the right thing to do is extend rows/cols to
8744 the current frame size. We do that first if x_set_window_size_1
8745 turns out to not be a no-op (there is no way to know).
8746 The size will be adjusted again if the frame gets a
8747 ConfigureNotify event as a result of x_set_window_size. */
8748 int pixelh
= FRAME_PIXEL_HEIGHT (f
);
8749 #ifdef USE_X_TOOLKIT
8750 /* The menu bar is not part of text lines. The tool bar
8752 pixelh
-= FRAME_MENUBAR_HEIGHT (f
);
8754 r
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelh
);
8755 /* Update f->scroll_bar_actual_width because it is used in
8756 FRAME_PIXEL_WIDTH_TO_TEXT_COLS. */
8757 f
->scroll_bar_actual_width
8758 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
8759 c
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, FRAME_PIXEL_WIDTH (f
));
8760 change_frame_size (f
, r
, c
, 0, 1, 0);
8764 if (FRAME_GTK_WIDGET (f
))
8765 xg_frame_set_char_size (f
, cols
, rows
);
8767 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8768 #else /* not USE_GTK */
8770 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8772 #endif /* not USE_GTK */
8774 /* If cursor was outside the new size, mark it as off. */
8775 mark_window_cursors_off (XWINDOW (f
->root_window
));
8777 /* Clear out any recollection of where the mouse highlighting was,
8778 since it might be in a place that's outside the new frame size.
8779 Actually checking whether it is outside is a pain in the neck,
8780 so don't try--just let the highlighting be done afresh with new size. */
8781 cancel_mouse_face (f
);
8786 /* Mouse warping. */
8789 x_set_mouse_position (struct frame
*f
, int x
, int y
)
8793 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
8794 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
8796 if (pix_x
< 0) pix_x
= 0;
8797 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
8799 if (pix_y
< 0) pix_y
= 0;
8800 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
8804 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8805 0, 0, 0, 0, pix_x
, pix_y
);
8809 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
8812 x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
8816 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8817 0, 0, 0, 0, pix_x
, pix_y
);
8821 /* focus shifting, raising and lowering. */
8824 x_focus_on_frame (struct frame
*f
)
8827 /* I don't think that the ICCCM allows programs to do things like this
8828 without the interaction of the window manager. Whatever you end up
8829 doing with this code, do it to x_unfocus_frame too. */
8830 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8831 RevertToPointerRoot
, CurrentTime
);
8836 x_unfocus_frame (struct frame
*f
)
8839 /* Look at the remarks in x_focus_on_frame. */
8840 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
8841 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
8842 RevertToPointerRoot
, CurrentTime
);
8846 /* Raise frame F. */
8849 x_raise_frame (struct frame
*f
)
8852 if (f
->async_visible
)
8853 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8855 XFlush (FRAME_X_DISPLAY (f
));
8859 /* Lower frame F. */
8862 x_lower_frame (struct frame
*f
)
8864 if (f
->async_visible
)
8867 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8868 XFlush (FRAME_X_DISPLAY (f
));
8873 /* Activate frame with Extended Window Manager Hints */
8876 x_ewmh_activate_frame (FRAME_PTR f
)
8878 /* See Window Manager Specification/Extended Window Manager Hints at
8879 http://freedesktop.org/wiki/Specifications/wm-spec */
8881 const char *atom
= "_NET_ACTIVE_WINDOW";
8882 if (f
->async_visible
&& wm_supports (f
, atom
))
8885 XSETFRAME (frame
, f
);
8886 Fx_send_client_event (frame
, make_number (0), frame
,
8887 make_unibyte_string (atom
, strlen (atom
)),
8889 Fcons (make_number (1),
8890 Fcons (make_number (last_user_time
),
8896 XTframe_raise_lower (FRAME_PTR f
, int raise_flag
)
8904 /* XEmbed implementation. */
8907 xembed_set_info (struct frame
*f
, enum xembed_info flags
)
8910 unsigned long data
[2];
8912 atom
= XInternAtom (FRAME_X_DISPLAY (f
), "_XEMBED_INFO", False
);
8914 data
[0] = XEMBED_VERSION
;
8917 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), atom
, atom
,
8918 32, PropModeReplace
, (unsigned char *) data
, 2);
8922 xembed_send_message (struct frame
*f
, Time time
, enum xembed_message message
, long int detail
, long int data1
, long int data2
)
8926 event
.xclient
.type
= ClientMessage
;
8927 event
.xclient
.window
= FRAME_X_OUTPUT (f
)->parent_desc
;
8928 event
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_XEMBED
;
8929 event
.xclient
.format
= 32;
8930 event
.xclient
.data
.l
[0] = time
;
8931 event
.xclient
.data
.l
[1] = message
;
8932 event
.xclient
.data
.l
[2] = detail
;
8933 event
.xclient
.data
.l
[3] = data1
;
8934 event
.xclient
.data
.l
[4] = data2
;
8936 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_OUTPUT (f
)->parent_desc
,
8937 False
, NoEventMask
, &event
);
8938 XSync (FRAME_X_DISPLAY (f
), False
);
8941 /* Change of visibility. */
8943 /* This tries to wait until the frame is really visible.
8944 However, if the window manager asks the user where to position
8945 the frame, this will return before the user finishes doing that.
8946 The frame will not actually be visible at that time,
8947 but it will become visible later when the window manager
8948 finishes with it. */
8951 x_make_frame_visible (struct frame
*f
)
8954 int original_top
, original_left
;
8955 int retry_count
= 2;
8961 type
= x_icon_type (f
);
8963 x_bitmap_icon (f
, type
);
8965 if (! FRAME_VISIBLE_P (f
))
8967 /* We test FRAME_GARBAGED_P here to make sure we don't
8968 call x_set_offset a second time
8969 if we get to x_make_frame_visible a second time
8970 before the window gets really visible. */
8971 if (! FRAME_ICONIFIED_P (f
)
8972 && ! FRAME_X_EMBEDDED_P (f
)
8973 && ! f
->output_data
.x
->asked_for_visible
)
8974 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
8976 f
->output_data
.x
->asked_for_visible
= 1;
8978 if (! EQ (Vx_no_window_manager
, Qt
))
8979 x_wm_set_window_state (f
, NormalState
);
8980 #ifdef USE_X_TOOLKIT
8981 if (FRAME_X_EMBEDDED_P (f
))
8982 xembed_set_info (f
, XEMBED_MAPPED
);
8985 /* This was XtPopup, but that did nothing for an iconified frame. */
8986 XtMapWidget (f
->output_data
.x
->widget
);
8988 #else /* not USE_X_TOOLKIT */
8990 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
8991 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
8993 if (FRAME_X_EMBEDDED_P (f
))
8994 xembed_set_info (f
, XEMBED_MAPPED
);
8996 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8997 #endif /* not USE_GTK */
8998 #endif /* not USE_X_TOOLKIT */
9001 XFlush (FRAME_X_DISPLAY (f
));
9003 /* Synchronize to ensure Emacs knows the frame is visible
9004 before we do anything else. We do this loop with input not blocked
9005 so that incoming events are handled. */
9009 /* This must be before UNBLOCK_INPUT
9010 since events that arrive in response to the actions above
9011 will set it when they are handled. */
9012 int previously_visible
= f
->output_data
.x
->has_been_visible
;
9014 original_left
= f
->left_pos
;
9015 original_top
= f
->top_pos
;
9017 /* This must come after we set COUNT. */
9020 /* We unblock here so that arriving X events are processed. */
9022 /* Now move the window back to where it was "supposed to be".
9023 But don't do it if the gravity is negative.
9024 When the gravity is negative, this uses a position
9025 that is 3 pixels too low. Perhaps that's really the border width.
9027 Don't do this if the window has never been visible before,
9028 because the window manager may choose the position
9029 and we don't want to override it. */
9031 if (! FRAME_VISIBLE_P (f
)
9032 && ! FRAME_ICONIFIED_P (f
)
9033 && ! FRAME_X_EMBEDDED_P (f
)
9034 && f
->win_gravity
== NorthWestGravity
9035 && previously_visible
)
9039 unsigned int width
, height
, border
, depth
;
9043 /* On some window managers (such as FVWM) moving an existing
9044 window, even to the same place, causes the window manager
9045 to introduce an offset. This can cause the window to move
9046 to an unexpected location. Check the geometry (a little
9047 slow here) and then verify that the window is in the right
9048 place. If the window is not in the right place, move it
9049 there, and take the potential window manager hit. */
9050 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9051 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
9053 if (original_left
!= x
|| original_top
!= y
)
9054 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9055 original_left
, original_top
);
9060 XSETFRAME (frame
, f
);
9062 /* Wait until the frame is visible. Process X events until a
9063 MapNotify event has been seen, or until we think we won't get a
9064 MapNotify at all.. */
9065 for (count
= input_signal_count
+ 10;
9066 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
9068 /* Force processing of queued events. */
9071 /* Machines that do polling rather than SIGIO have been
9072 observed to go into a busy-wait here. So we'll fake an
9073 alarm signal to let the handler know that there's something
9074 to be read. We used to raise a real alarm, but it seems
9075 that the handler isn't always enabled here. This is
9077 if (input_polling_used ())
9079 /* It could be confusing if a real alarm arrives while
9080 processing the fake one. Turn it off and let the
9081 handler reset it. */
9082 int old_poll_suppress_count
= poll_suppress_count
;
9083 poll_suppress_count
= 1;
9084 poll_for_input_1 ();
9085 poll_suppress_count
= old_poll_suppress_count
;
9088 /* See if a MapNotify event has been processed. */
9089 FRAME_SAMPLE_VISIBILITY (f
);
9094 (let ((f (selected-frame)))
9098 the frame is not raised with various window managers on
9099 FreeBSD, GNU/Linux and Solaris. It turns out that, for some
9100 unknown reason, the call to XtMapWidget is completely ignored.
9101 Mapping the widget a second time works. */
9103 if (!FRAME_VISIBLE_P (f
) && --retry_count
> 0)
9108 /* Change from mapped state to withdrawn state. */
9110 /* Make the frame visible (mapped and not iconified). */
9113 x_make_frame_invisible (struct frame
*f
)
9117 /* Use the frame's outermost window, not the one we normally draw on. */
9118 window
= FRAME_OUTER_WINDOW (f
);
9120 /* Don't keep the highlight on an invisible frame. */
9121 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9122 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9126 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
9127 that the current position of the window is user-specified, rather than
9128 program-specified, so that when the window is mapped again, it will be
9129 placed at the same location, without forcing the user to position it
9130 by hand again (they have already done that once for this window.) */
9131 x_wm_set_size_hint (f
, (long) 0, 1);
9134 if (FRAME_GTK_OUTER_WIDGET (f
))
9135 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f
));
9138 if (FRAME_X_EMBEDDED_P (f
))
9139 xembed_set_info (f
, 0);
9144 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
9145 DefaultScreen (FRAME_X_DISPLAY (f
))))
9147 UNBLOCK_INPUT_RESIGNAL
;
9148 error ("Can't notify window manager of window withdrawal");
9152 /* We can't distinguish this from iconification
9153 just by the event that we get from the server.
9154 So we can't win using the usual strategy of letting
9155 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
9156 and synchronize with the server to make sure we agree. */
9158 FRAME_ICONIFIED_P (f
) = 0;
9159 f
->async_visible
= 0;
9160 f
->async_iconified
= 0;
9167 /* Change window state from mapped to iconified. */
9170 x_iconify_frame (struct frame
*f
)
9175 /* Don't keep the highlight on an invisible frame. */
9176 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9177 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9179 if (f
->async_iconified
)
9184 FRAME_SAMPLE_VISIBILITY (f
);
9186 type
= x_icon_type (f
);
9188 x_bitmap_icon (f
, type
);
9191 if (FRAME_GTK_OUTER_WIDGET (f
))
9193 if (! FRAME_VISIBLE_P (f
))
9194 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
9196 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
9199 f
->async_iconified
= 1;
9200 f
->async_visible
= 0;
9206 #ifdef USE_X_TOOLKIT
9208 if (! FRAME_VISIBLE_P (f
))
9210 if (! EQ (Vx_no_window_manager
, Qt
))
9211 x_wm_set_window_state (f
, IconicState
);
9212 /* This was XtPopup, but that did nothing for an iconified frame. */
9213 XtMapWidget (f
->output_data
.x
->widget
);
9214 /* The server won't give us any event to indicate
9215 that an invisible frame was changed to an icon,
9216 so we have to record it here. */
9219 f
->async_iconified
= 1;
9220 f
->async_visible
= 0;
9225 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
9226 XtWindow (f
->output_data
.x
->widget
),
9227 DefaultScreen (FRAME_X_DISPLAY (f
)));
9231 error ("Can't notify window manager of iconification");
9233 f
->async_iconified
= 1;
9234 f
->async_visible
= 0;
9238 XFlush (FRAME_X_DISPLAY (f
));
9240 #else /* not USE_X_TOOLKIT */
9242 /* Make sure the X server knows where the window should be positioned,
9243 in case the user deiconifies with the window manager. */
9244 if (! FRAME_VISIBLE_P (f
)
9245 && ! FRAME_ICONIFIED_P (f
)
9246 && ! FRAME_X_EMBEDDED_P (f
))
9247 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
9249 /* Since we don't know which revision of X we're running, we'll use both
9250 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
9252 /* X11R4: send a ClientMessage to the window manager using the
9253 WM_CHANGE_STATE type. */
9257 message
.xclient
.window
= FRAME_X_WINDOW (f
);
9258 message
.xclient
.type
= ClientMessage
;
9259 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
9260 message
.xclient
.format
= 32;
9261 message
.xclient
.data
.l
[0] = IconicState
;
9263 if (! XSendEvent (FRAME_X_DISPLAY (f
),
9264 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
9266 SubstructureRedirectMask
| SubstructureNotifyMask
,
9269 UNBLOCK_INPUT_RESIGNAL
;
9270 error ("Can't notify window manager of iconification");
9274 /* X11R3: set the initial_state field of the window manager hints to
9276 x_wm_set_window_state (f
, IconicState
);
9278 if (!FRAME_VISIBLE_P (f
))
9280 /* If the frame was withdrawn, before, we must map it. */
9281 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9284 f
->async_iconified
= 1;
9285 f
->async_visible
= 0;
9287 XFlush (FRAME_X_DISPLAY (f
));
9289 #endif /* not USE_X_TOOLKIT */
9293 /* Free X resources of frame F. */
9296 x_free_frame_resources (struct frame
*f
)
9298 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9300 struct scroll_bar
*b
;
9304 /* If a display connection is dead, don't try sending more
9305 commands to the X server. */
9306 if (dpyinfo
->display
)
9308 /* We must free faces before destroying windows because some
9309 font-driver (e.g. xft) access a window while finishing a
9311 if (FRAME_FACE_CACHE (f
))
9312 free_frame_faces (f
);
9314 if (f
->output_data
.x
->icon_desc
)
9315 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
9317 #ifdef USE_X_TOOLKIT
9318 /* Explicitly destroy the scroll bars of the frame. Without
9319 this, we get "BadDrawable" errors from the toolkit later on,
9320 presumably from expose events generated for the disappearing
9321 toolkit scroll bars. */
9322 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
9324 b
= XSCROLL_BAR (bar
);
9325 x_scroll_bar_remove (b
);
9334 #ifdef USE_X_TOOLKIT
9335 if (f
->output_data
.x
->widget
)
9337 XtDestroyWidget (f
->output_data
.x
->widget
);
9338 f
->output_data
.x
->widget
= NULL
;
9340 /* Tooltips don't have widgets, only a simple X window, even if
9341 we are using a toolkit. */
9342 else if (FRAME_X_WINDOW (f
))
9343 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9345 free_frame_menubar (f
);
9346 #else /* !USE_X_TOOLKIT */
9349 xg_free_frame_widgets (f
);
9350 #endif /* USE_GTK */
9352 if (FRAME_X_WINDOW (f
))
9353 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9354 #endif /* !USE_X_TOOLKIT */
9356 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
9357 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
9358 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
9359 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
9360 unload_color (f
, f
->output_data
.x
->border_pixel
);
9361 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
9363 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
9364 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
9365 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
9366 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
9367 #ifdef USE_TOOLKIT_SCROLL_BARS
9368 /* Scrollbar shadow colors. */
9369 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
9370 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
9371 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
9372 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
9373 #endif /* USE_TOOLKIT_SCROLL_BARS */
9374 if (f
->output_data
.x
->white_relief
.allocated_p
)
9375 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
9376 if (f
->output_data
.x
->black_relief
.allocated_p
)
9377 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
9380 XFlush (FRAME_X_DISPLAY (f
));
9383 xfree (f
->output_data
.x
->saved_menu_event
);
9384 xfree (f
->output_data
.x
);
9385 f
->output_data
.x
= NULL
;
9387 if (f
== dpyinfo
->x_focus_frame
)
9388 dpyinfo
->x_focus_frame
= 0;
9389 if (f
== dpyinfo
->x_focus_event_frame
)
9390 dpyinfo
->x_focus_event_frame
= 0;
9391 if (f
== dpyinfo
->x_highlight_frame
)
9392 dpyinfo
->x_highlight_frame
= 0;
9394 if (f
== dpyinfo
->mouse_face_mouse_frame
)
9396 dpyinfo
->mouse_face_beg_row
9397 = dpyinfo
->mouse_face_beg_col
= -1;
9398 dpyinfo
->mouse_face_end_row
9399 = dpyinfo
->mouse_face_end_col
= -1;
9400 dpyinfo
->mouse_face_window
= Qnil
;
9401 dpyinfo
->mouse_face_deferred_gc
= 0;
9402 dpyinfo
->mouse_face_mouse_frame
= 0;
9409 /* Destroy the X window of frame F. */
9412 x_destroy_window (struct frame
*f
)
9414 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9416 /* If a display connection is dead, don't try sending more
9417 commands to the X server. */
9418 if (dpyinfo
->display
!= 0)
9419 x_free_frame_resources (f
);
9421 dpyinfo
->reference_count
--;
9425 /* Setting window manager hints. */
9427 /* Set the normal size hints for the window manager, for frame F.
9428 FLAGS is the flags word to use--or 0 meaning preserve the flags
9429 that the window now has.
9430 If USER_POSITION is nonzero, we set the USPosition
9431 flag (this is useful when FLAGS is 0).
9432 The GTK version is in gtkutils.c */
9436 x_wm_set_size_hint (struct frame
*f
, long flags
, int user_position
)
9438 XSizeHints size_hints
;
9439 Window window
= FRAME_OUTER_WINDOW (f
);
9441 /* Setting PMaxSize caused various problems. */
9442 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
9444 size_hints
.x
= f
->left_pos
;
9445 size_hints
.y
= f
->top_pos
;
9447 size_hints
.height
= FRAME_PIXEL_HEIGHT (f
);
9448 size_hints
.width
= FRAME_PIXEL_WIDTH (f
);
9450 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
9451 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
9452 size_hints
.max_width
= x_display_pixel_width (FRAME_X_DISPLAY_INFO (f
))
9453 - FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9454 size_hints
.max_height
= x_display_pixel_height (FRAME_X_DISPLAY_INFO (f
))
9455 - FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9457 /* Calculate the base and minimum sizes. */
9459 int base_width
, base_height
;
9460 int min_rows
= 0, min_cols
= 0;
9462 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9463 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9465 check_frame_size (f
, &min_rows
, &min_cols
);
9467 /* The window manager uses the base width hints to calculate the
9468 current number of rows and columns in the frame while
9469 resizing; min_width and min_height aren't useful for this
9470 purpose, since they might not give the dimensions for a
9471 zero-row, zero-column frame.
9473 We use the base_width and base_height members if we have
9474 them; otherwise, we set the min_width and min_height members
9475 to the size for a zero x zero frame. */
9477 size_hints
.flags
|= PBaseSize
;
9478 size_hints
.base_width
= base_width
;
9479 size_hints
.base_height
= base_height
+ FRAME_MENUBAR_HEIGHT (f
);
9480 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
9481 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
9484 /* If we don't need the old flags, we don't need the old hint at all. */
9487 size_hints
.flags
|= flags
;
9492 XSizeHints hints
; /* Sometimes I hate X Windows... */
9493 long supplied_return
;
9496 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
9500 size_hints
.flags
|= flags
;
9505 if (hints
.flags
& PSize
)
9506 size_hints
.flags
|= PSize
;
9507 if (hints
.flags
& PPosition
)
9508 size_hints
.flags
|= PPosition
;
9509 if (hints
.flags
& USPosition
)
9510 size_hints
.flags
|= USPosition
;
9511 if (hints
.flags
& USSize
)
9512 size_hints
.flags
|= USSize
;
9519 size_hints
.win_gravity
= f
->win_gravity
;
9520 size_hints
.flags
|= PWinGravity
;
9524 size_hints
.flags
&= ~ PPosition
;
9525 size_hints
.flags
|= USPosition
;
9527 #endif /* PWinGravity */
9529 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
9531 #endif /* not USE_GTK */
9533 /* Used for IconicState or NormalState */
9536 x_wm_set_window_state (struct frame
*f
, int state
)
9538 #ifdef USE_X_TOOLKIT
9541 XtSetArg (al
[0], XtNinitialState
, state
);
9542 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9543 #else /* not USE_X_TOOLKIT */
9544 Window window
= FRAME_X_WINDOW (f
);
9546 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
9547 f
->output_data
.x
->wm_hints
.initial_state
= state
;
9549 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9550 #endif /* not USE_X_TOOLKIT */
9554 x_wm_set_icon_pixmap (struct frame
*f
, int pixmap_id
)
9556 Pixmap icon_pixmap
, icon_mask
;
9558 #if !defined USE_X_TOOLKIT && !defined USE_GTK
9559 Window window
= FRAME_OUTER_WINDOW (f
);
9564 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
9565 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
9566 icon_mask
= x_bitmap_mask (f
, pixmap_id
);
9567 f
->output_data
.x
->wm_hints
.icon_mask
= icon_mask
;
9571 /* It seems there is no way to turn off use of an icon
9579 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
);
9583 #elif defined (USE_X_TOOLKIT) /* same as in x_wm_set_window_state. */
9587 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
9588 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9589 XtSetArg (al
[0], XtNiconMask
, icon_mask
);
9590 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9593 #else /* not USE_X_TOOLKIT && not USE_GTK */
9595 f
->output_data
.x
->wm_hints
.flags
|= (IconPixmapHint
| IconMaskHint
);
9596 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9598 #endif /* not USE_X_TOOLKIT && not USE_GTK */
9602 x_wm_set_icon_position (struct frame
*f
, int icon_x
, int icon_y
)
9604 Window window
= FRAME_OUTER_WINDOW (f
);
9606 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
9607 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
9608 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
9610 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9614 /***********************************************************************
9616 ***********************************************************************/
9620 /* Check that FONT is valid on frame F. It is if it can be found in F's
9624 x_check_font (struct frame
*f
, struct font
*font
)
9628 xassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
9629 if (font
->driver
->check
)
9630 xassert (font
->driver
->check (f
, font
) == 0);
9633 #endif /* GLYPH_DEBUG != 0 */
9636 /***********************************************************************
9638 ***********************************************************************/
9640 #ifdef USE_X_TOOLKIT
9641 static XrmOptionDescRec emacs_options
[] = {
9642 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
9643 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
9645 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
9646 XrmoptionSepArg
, NULL
},
9647 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
9649 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9650 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9651 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9652 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
9653 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
9654 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
9655 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
9658 /* Whether atimer for Xt timeouts is activated or not. */
9660 static int x_timeout_atimer_activated_flag
;
9662 #endif /* USE_X_TOOLKIT */
9664 static int x_initialized
;
9667 static int x_session_initialized
;
9670 /* Test whether two display-name strings agree up to the dot that separates
9671 the screen number from the server number. */
9673 same_x_server (const char *name1
, const char *name2
)
9676 const unsigned char *system_name
= SDATA (Vsystem_name
);
9677 int system_name_length
= strlen (system_name
);
9678 int length_until_period
= 0;
9680 while (system_name
[length_until_period
] != 0
9681 && system_name
[length_until_period
] != '.')
9682 length_until_period
++;
9684 /* Treat `unix' like an empty host name. */
9685 if (! strncmp (name1
, "unix:", 5))
9687 if (! strncmp (name2
, "unix:", 5))
9689 /* Treat this host's name like an empty host name. */
9690 if (! strncmp (name1
, system_name
, system_name_length
)
9691 && name1
[system_name_length
] == ':')
9692 name1
+= system_name_length
;
9693 if (! strncmp (name2
, system_name
, system_name_length
)
9694 && name2
[system_name_length
] == ':')
9695 name2
+= system_name_length
;
9696 /* Treat this host's domainless name like an empty host name. */
9697 if (! strncmp (name1
, system_name
, length_until_period
)
9698 && name1
[length_until_period
] == ':')
9699 name1
+= length_until_period
;
9700 if (! strncmp (name2
, system_name
, length_until_period
)
9701 && name2
[length_until_period
] == ':')
9702 name2
+= length_until_period
;
9704 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
9708 if (seen_colon
&& *name1
== '.')
9712 && (*name1
== '.' || *name1
== '\0')
9713 && (*name2
== '.' || *name2
== '\0'));
9716 /* Count number of set bits in mask and number of bits to shift to
9717 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
9720 get_bits_and_offset (long unsigned int mask
, int *bits
, int *offset
)
9741 /* Return 1 if display DISPLAY is available for use, 0 otherwise.
9742 But don't permanently open it, just test its availability. */
9745 x_display_ok (const char *display
)
9750 dpy
= XOpenDisplay (display
);
9752 XCloseDisplay (dpy
);
9760 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
, const gchar
*message
, gpointer user_data
)
9762 if (!strstr (message
, "g_set_prgname"))
9763 fprintf (stderr
, "%s-WARNING **: %s\n", log_domain
, message
);
9767 /* Open a connection to X display DISPLAY_NAME, and return
9768 the structure that describes the open display.
9769 If we cannot contact the display, return null. */
9771 struct x_display_info
*
9772 x_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
9776 struct terminal
*terminal
;
9777 struct x_display_info
*dpyinfo
;
9788 if (! x_display_ok (SDATA (display_name
)))
9789 error ("Display %s can't be opened", SDATA (display_name
));
9795 char *argv
[NUM_ARGV
];
9796 char **argv2
= argv
;
9799 if (x_initialized
++ > 1)
9801 xg_display_open (SDATA (display_name
), &dpy
);
9805 static char display_opt
[] = "--display";
9806 static char name_opt
[] = "--name";
9808 for (argc
= 0; argc
< NUM_ARGV
; ++argc
)
9812 argv
[argc
++] = initial_argv
[0];
9814 if (! NILP (display_name
))
9816 argv
[argc
++] = display_opt
;
9817 argv
[argc
++] = SDATA (display_name
);
9820 argv
[argc
++] = name_opt
;
9821 argv
[argc
++] = resource_name
;
9823 XSetLocaleModifiers ("");
9825 /* Work around GLib bug that outputs a faulty warning. See
9826 https://bugzilla.gnome.org/show_bug.cgi?id=563627. */
9827 id
= g_log_set_handler ("GLib", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
9828 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
9829 gtk_init (&argc
, &argv2
);
9830 g_log_remove_handler ("GLib", id
);
9832 /* gtk_init does set_locale. We must fix locale after calling it. */
9836 dpy
= GDK_DISPLAY ();
9838 /* NULL window -> events for all windows go to our function */
9839 gdk_window_add_filter (NULL
, event_handler_gdk
, NULL
);
9841 /* Load our own gtkrc if it exists. */
9843 const char *file
= "~/.emacs.d/gtkrc";
9844 Lisp_Object s
, abs_file
;
9846 s
= make_string (file
, strlen (file
));
9847 abs_file
= Fexpand_file_name (s
, Qnil
);
9849 if (! NILP (abs_file
) && !NILP (Ffile_readable_p (abs_file
)))
9850 gtk_rc_parse (SDATA (abs_file
));
9853 XSetErrorHandler (x_error_handler
);
9854 XSetIOErrorHandler (x_io_error_quitter
);
9857 #else /* not USE_GTK */
9858 #ifdef USE_X_TOOLKIT
9859 /* weiner@footloose.sps.mot.com reports that this causes
9861 X protocol error: BadAtom (invalid Atom parameter)
9862 on protocol request 18skiloaf.
9863 So let's not use it until R6. */
9865 XtSetLanguageProc (NULL
, NULL
, NULL
);
9876 argv
[argc
++] = "-xrm";
9877 argv
[argc
++] = xrm_option
;
9879 turn_on_atimers (0);
9880 dpy
= XtOpenDisplay (Xt_app_con
, SDATA (display_name
),
9881 resource_name
, EMACS_CLASS
,
9882 emacs_options
, XtNumber (emacs_options
),
9884 turn_on_atimers (1);
9887 /* I think this is to compensate for XtSetLanguageProc. */
9892 #else /* not USE_X_TOOLKIT */
9893 XSetLocaleModifiers ("");
9894 dpy
= XOpenDisplay (SDATA (display_name
));
9895 #endif /* not USE_X_TOOLKIT */
9896 #endif /* not USE_GTK*/
9898 /* Detect failure. */
9905 /* We have definitely succeeded. Record the new connection. */
9907 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
9908 memset (dpyinfo
, 0, sizeof *dpyinfo
);
9910 terminal
= x_create_terminal (dpyinfo
);
9913 struct x_display_info
*share
;
9916 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
9917 share
= share
->next
, tail
= XCDR (tail
))
9918 if (same_x_server (SDATA (XCAR (XCAR (tail
))),
9919 SDATA (display_name
)))
9922 terminal
->kboard
= share
->terminal
->kboard
;
9925 terminal
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
9926 init_kboard (terminal
->kboard
);
9927 terminal
->kboard
->Vwindow_system
= Qx
;
9929 /* Add the keyboard to the list before running Lisp code (via
9930 Qvendor_specific_keysyms below), since these are not traced
9931 via terminals but only through all_kboards. */
9932 terminal
->kboard
->next_kboard
= all_kboards
;
9933 all_kboards
= terminal
->kboard
;
9935 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
9937 char *vendor
= ServerVendor (dpy
);
9939 /* Protect terminal from GC before removing it from the
9940 list of terminals. */
9941 struct gcpro gcpro1
;
9942 Lisp_Object gcpro_term
;
9943 XSETTERMINAL (gcpro_term
, terminal
);
9944 GCPRO1 (gcpro_term
);
9946 /* Temporarily hide the partially initialized terminal. */
9947 terminal_list
= terminal
->next_terminal
;
9949 terminal
->kboard
->Vsystem_key_alist
9950 = call1 (Qvendor_specific_keysyms
,
9951 vendor
? build_string (vendor
) : empty_unibyte_string
);
9953 terminal
->next_terminal
= terminal_list
;
9954 terminal_list
= terminal
;
9958 /* Don't let the initial kboard remain current longer than necessary.
9959 That would cause problems if a file loaded on startup tries to
9960 prompt in the mini-buffer. */
9961 if (current_kboard
== initial_kboard
)
9962 current_kboard
= terminal
->kboard
;
9964 terminal
->kboard
->reference_count
++;
9967 /* Put this display on the chain. */
9968 dpyinfo
->next
= x_display_list
;
9969 x_display_list
= dpyinfo
;
9971 /* Put it on x_display_name_list as well, to keep them parallel. */
9972 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
9973 x_display_name_list
);
9974 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
9976 dpyinfo
->display
= dpy
;
9978 /* Set the name of the terminal. */
9979 terminal
->name
= (char *) xmalloc (SBYTES (display_name
) + 1);
9980 strncpy (terminal
->name
, SDATA (display_name
), SBYTES (display_name
));
9981 terminal
->name
[SBYTES (display_name
)] = 0;
9984 XSetAfterFunction (x_current_display
, x_trace_wire
);
9988 = (char *) xmalloc (SBYTES (Vinvocation_name
)
9989 + SBYTES (Vsystem_name
)
9991 sprintf (dpyinfo
->x_id_name
, "%s@%s",
9992 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
9994 /* Figure out which modifier bits mean what. */
9995 x_find_modifier_meanings (dpyinfo
);
9997 /* Get the scroll bar cursor. */
9999 /* We must create a GTK cursor, it is required for GTK widgets. */
10000 dpyinfo
->xg_cursor
= xg_create_default_cursor (dpyinfo
->display
);
10001 #endif /* USE_GTK */
10003 dpyinfo
->vertical_scroll_bar_cursor
10004 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
10006 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
10007 resource_name
, EMACS_CLASS
);
10008 #ifdef HAVE_XRMSETDATABASE
10009 XrmSetDatabase (dpyinfo
->display
, xrdb
);
10011 dpyinfo
->display
->db
= xrdb
;
10013 /* Put the rdb where we can find it in a way that works on
10015 dpyinfo
->xrdb
= xrdb
;
10017 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
10018 DefaultScreen (dpyinfo
->display
));
10019 select_visual (dpyinfo
);
10020 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
10021 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
10022 dpyinfo
->client_leader_window
= 0;
10023 dpyinfo
->grabbed
= 0;
10024 dpyinfo
->reference_count
= 0;
10025 dpyinfo
->icon_bitmap_id
= -1;
10026 dpyinfo
->n_fonts
= 0;
10027 dpyinfo
->bitmaps
= 0;
10028 dpyinfo
->bitmaps_size
= 0;
10029 dpyinfo
->bitmaps_last
= 0;
10030 dpyinfo
->scratch_cursor_gc
= 0;
10031 dpyinfo
->mouse_face_mouse_frame
= 0;
10032 dpyinfo
->mouse_face_deferred_gc
= 0;
10033 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
10034 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
10035 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
10036 dpyinfo
->mouse_face_window
= Qnil
;
10037 dpyinfo
->mouse_face_overlay
= Qnil
;
10038 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
10039 dpyinfo
->mouse_face_defer
= 0;
10040 dpyinfo
->mouse_face_hidden
= 0;
10041 dpyinfo
->x_focus_frame
= 0;
10042 dpyinfo
->x_focus_event_frame
= 0;
10043 dpyinfo
->x_highlight_frame
= 0;
10044 dpyinfo
->wm_type
= X_WMTYPE_UNKNOWN
;
10046 /* See if we can construct pixel values from RGB values. */
10047 dpyinfo
->red_bits
= dpyinfo
->blue_bits
= dpyinfo
->green_bits
= 0;
10048 dpyinfo
->red_offset
= dpyinfo
->blue_offset
= dpyinfo
->green_offset
= 0;
10050 if (dpyinfo
->visual
->class == TrueColor
)
10052 get_bits_and_offset (dpyinfo
->visual
->red_mask
,
10053 &dpyinfo
->red_bits
, &dpyinfo
->red_offset
);
10054 get_bits_and_offset (dpyinfo
->visual
->blue_mask
,
10055 &dpyinfo
->blue_bits
, &dpyinfo
->blue_offset
);
10056 get_bits_and_offset (dpyinfo
->visual
->green_mask
,
10057 &dpyinfo
->green_bits
, &dpyinfo
->green_offset
);
10060 /* See if a private colormap is requested. */
10061 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
10063 if (dpyinfo
->visual
->class == PseudoColor
)
10066 value
= display_x_get_resource (dpyinfo
,
10067 build_string ("privateColormap"),
10068 build_string ("PrivateColormap"),
10070 if (STRINGP (value
)
10071 && (!strcmp (SDATA (value
), "true")
10072 || !strcmp (SDATA (value
), "on")))
10073 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
10077 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
10078 dpyinfo
->visual
, AllocNone
);
10082 /* If we are using Xft, check dpi value in X resources.
10083 It is better we use it as well, since Xft will use it, as will all
10084 Gnome applications. If our real DPI is smaller or larger than the
10085 one Xft uses, our font will look smaller or larger than other
10086 for other applications, even if it is the same font name (monospace-10
10088 char *v
= XGetDefault (dpyinfo
->display
, "Xft", "dpi");
10090 if (v
!= NULL
&& sscanf (v
, "%lf", &d
) == 1)
10091 dpyinfo
->resy
= dpyinfo
->resx
= d
;
10095 if (dpyinfo
->resy
< 1)
10097 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
10098 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
10099 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
10100 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10101 dpyinfo
->resy
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10102 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
10103 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
10104 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10105 dpyinfo
->resx
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10108 dpyinfo
->Xatom_wm_protocols
10109 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
10110 dpyinfo
->Xatom_wm_take_focus
10111 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
10112 dpyinfo
->Xatom_wm_save_yourself
10113 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
10114 dpyinfo
->Xatom_wm_delete_window
10115 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
10116 dpyinfo
->Xatom_wm_change_state
10117 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
10118 dpyinfo
->Xatom_wm_configure_denied
10119 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
10120 dpyinfo
->Xatom_wm_window_moved
10121 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
10122 dpyinfo
->Xatom_wm_client_leader
10123 = XInternAtom (dpyinfo
->display
, "WM_CLIENT_LEADER", False
);
10124 dpyinfo
->Xatom_editres
10125 = XInternAtom (dpyinfo
->display
, "Editres", False
);
10126 dpyinfo
->Xatom_CLIPBOARD
10127 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
10128 dpyinfo
->Xatom_TIMESTAMP
10129 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
10130 dpyinfo
->Xatom_TEXT
10131 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
10132 dpyinfo
->Xatom_COMPOUND_TEXT
10133 = XInternAtom (dpyinfo
->display
, "COMPOUND_TEXT", False
);
10134 dpyinfo
->Xatom_UTF8_STRING
10135 = XInternAtom (dpyinfo
->display
, "UTF8_STRING", False
);
10136 dpyinfo
->Xatom_DELETE
10137 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
10138 dpyinfo
->Xatom_MULTIPLE
10139 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
10140 dpyinfo
->Xatom_INCR
10141 = XInternAtom (dpyinfo
->display
, "INCR", False
);
10142 dpyinfo
->Xatom_EMACS_TMP
10143 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
10144 dpyinfo
->Xatom_TARGETS
10145 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
10146 dpyinfo
->Xatom_NULL
10147 = XInternAtom (dpyinfo
->display
, "NULL", False
);
10148 dpyinfo
->Xatom_ATOM_PAIR
10149 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
10150 /* For properties of font. */
10151 dpyinfo
->Xatom_PIXEL_SIZE
10152 = XInternAtom (dpyinfo
->display
, "PIXEL_SIZE", False
);
10153 dpyinfo
->Xatom_AVERAGE_WIDTH
10154 = XInternAtom (dpyinfo
->display
, "AVERAGE_WIDTH", False
);
10155 dpyinfo
->Xatom_MULE_BASELINE_OFFSET
10156 = XInternAtom (dpyinfo
->display
, "_MULE_BASELINE_OFFSET", False
);
10157 dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
10158 = XInternAtom (dpyinfo
->display
, "_MULE_RELATIVE_COMPOSE", False
);
10159 dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
10160 = XInternAtom (dpyinfo
->display
, "_MULE_DEFAULT_ASCENT", False
);
10162 /* Ghostscript support. */
10163 dpyinfo
->Xatom_PAGE
= XInternAtom (dpyinfo
->display
, "PAGE", False
);
10164 dpyinfo
->Xatom_DONE
= XInternAtom (dpyinfo
->display
, "DONE", False
);
10166 dpyinfo
->Xatom_Scrollbar
= XInternAtom (dpyinfo
->display
, "SCROLLBAR",
10169 dpyinfo
->Xatom_XEMBED
= XInternAtom (dpyinfo
->display
, "_XEMBED",
10172 dpyinfo
->Xatom_net_wm_state
10173 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE", False
);
10174 dpyinfo
->Xatom_net_wm_state_fullscreen_atom
10175 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE_FULLSCREEN", False
);
10176 dpyinfo
->Xatom_net_wm_state_maximized_horz
10177 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE_MAXIMIZED_HORZ", False
);
10178 dpyinfo
->Xatom_net_wm_state_maximized_vert
10179 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE_MAXIMIZED_VERT", False
);
10180 dpyinfo
->Xatom_net_wm_state_sticky
10181 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE_STICKY", False
);
10182 dpyinfo
->Xatom_net_window_type
10183 = XInternAtom (dpyinfo
->display
, "_NET_WM_WINDOW_TYPE", False
);
10184 dpyinfo
->Xatom_net_window_type_tooltip
10185 = XInternAtom (dpyinfo
->display
, "_NET_WM_WINDOW_TYPE_TOOLTIP", False
);
10186 dpyinfo
->Xatom_net_wm_icon_name
10187 = XInternAtom (dpyinfo
->display
, "_NET_WM_ICON_NAME", False
);
10188 dpyinfo
->Xatom_net_wm_name
10189 = XInternAtom (dpyinfo
->display
, "_NET_WM_NAME", False
);
10191 dpyinfo
->x_dnd_atoms_size
= 8;
10192 dpyinfo
->x_dnd_atoms_length
= 0;
10193 dpyinfo
->x_dnd_atoms
= xmalloc (sizeof (*dpyinfo
->x_dnd_atoms
)
10194 * dpyinfo
->x_dnd_atoms_size
);
10196 dpyinfo
->net_supported_atoms
= NULL
;
10197 dpyinfo
->nr_net_supported_atoms
= 0;
10198 dpyinfo
->net_supported_window
= 0;
10200 connection
= ConnectionNumber (dpyinfo
->display
);
10201 dpyinfo
->connection
= connection
;
10205 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
10207 gray_bitmap_width
, gray_bitmap_height
,
10208 (unsigned long) 1, (unsigned long) 0, 1);
10212 xim_initialize (dpyinfo
, resource_name
);
10215 xsettings_initialize (dpyinfo
);
10217 /* This is only needed for distinguishing keyboard and process input. */
10218 if (connection
!= 0)
10219 add_keyboard_wait_descriptor (connection
);
10222 fcntl (connection
, F_SETOWN
, getpid ());
10223 #endif /* ! defined (F_SETOWN) */
10226 if (interrupt_input
)
10227 init_sigio (connection
);
10228 #endif /* ! defined (SIGIO) */
10232 Display
*dpy
= dpyinfo
->display
;
10233 XrmValue d
, fr
, to
;
10236 d
.addr
= (XPointer
)&dpy
;
10237 d
.size
= sizeof (Display
*);
10238 fr
.addr
= XtDefaultFont
;
10239 fr
.size
= sizeof (XtDefaultFont
);
10240 to
.size
= sizeof (Font
*);
10241 to
.addr
= (XPointer
)&font
;
10242 x_catch_errors (dpy
);
10243 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
10245 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
10246 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
10247 x_uncatch_errors ();
10251 /* See if we should run in synchronous mode. This is useful
10252 for debugging X code. */
10255 value
= display_x_get_resource (dpyinfo
,
10256 build_string ("synchronous"),
10257 build_string ("Synchronous"),
10259 if (STRINGP (value
)
10260 && (!strcmp (SDATA (value
), "true")
10261 || !strcmp (SDATA (value
), "on")))
10262 XSynchronize (dpyinfo
->display
, True
);
10267 value
= display_x_get_resource (dpyinfo
,
10268 build_string ("useXIM"),
10269 build_string ("UseXIM"),
10272 if (STRINGP (value
)
10273 && (!strcmp (SDATA (value
), "false")
10274 || !strcmp (SDATA (value
), "off")))
10277 if (STRINGP (value
)
10278 && (!strcmp (SDATA (value
), "true")
10279 || !strcmp (SDATA (value
), "on")))
10285 /* Only do this for the very first display in the Emacs session.
10286 Ignore X session management when Emacs was first started on a
10288 if (terminal
->id
== 1)
10289 x_session_initialize (dpyinfo
);
10297 /* Get rid of display DPYINFO, deleting all frames on it,
10298 and without sending any more commands to the X server. */
10301 x_delete_display (struct x_display_info
*dpyinfo
)
10303 struct terminal
*t
;
10305 /* Close all frames and delete the generic struct terminal for this
10307 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
10308 if (t
->type
== output_x_window
&& t
->display_info
.x
== dpyinfo
)
10311 /* Close X session management when we close its display. */
10312 if (t
->id
== 1 && x_session_have_connection ())
10313 x_session_close ();
10315 delete_terminal (t
);
10319 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
10321 /* Discard this display from x_display_name_list and x_display_list.
10322 We can't use Fdelq because that can quit. */
10323 if (! NILP (x_display_name_list
)
10324 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
10325 x_display_name_list
= XCDR (x_display_name_list
);
10330 tail
= x_display_name_list
;
10331 while (CONSP (tail
) && CONSP (XCDR (tail
)))
10333 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
10335 XSETCDR (tail
, XCDR (XCDR (tail
)));
10338 tail
= XCDR (tail
);
10342 if (next_noop_dpyinfo
== dpyinfo
)
10343 next_noop_dpyinfo
= dpyinfo
->next
;
10345 if (x_display_list
== dpyinfo
)
10346 x_display_list
= dpyinfo
->next
;
10349 struct x_display_info
*tail
;
10351 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
10352 if (tail
->next
== dpyinfo
)
10353 tail
->next
= tail
->next
->next
;
10356 xfree (dpyinfo
->x_id_name
);
10357 xfree (dpyinfo
->x_dnd_atoms
);
10358 xfree (dpyinfo
->color_cells
);
10362 #ifdef USE_X_TOOLKIT
10364 /* Atimer callback function for TIMER. Called every 0.1s to process
10365 Xt timeouts, if needed. We must avoid calling XtAppPending as
10366 much as possible because that function does an implicit XFlush
10367 that slows us down. */
10370 x_process_timeouts (struct atimer
*timer
)
10373 x_timeout_atimer_activated_flag
= 0;
10374 if (toolkit_scroll_bar_interaction
|| popup_activated ())
10376 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
10377 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
10378 /* Reactivate the atimer for next time. */
10379 x_activate_timeout_atimer ();
10384 /* Install an asynchronous timer that processes Xt timeout events
10385 every 0.1s as long as either `toolkit_scroll_bar_interaction' or
10386 `popup_activated_flag' (in xmenu.c) is set. Make sure to call this
10387 function whenever these variables are set. This is necessary
10388 because some widget sets use timeouts internally, for example the
10389 LessTif menu bar, or the Xaw3d scroll bar. When Xt timeouts aren't
10390 processed, these widgets don't behave normally. */
10393 x_activate_timeout_atimer (void)
10396 if (!x_timeout_atimer_activated_flag
)
10398 EMACS_TIME interval
;
10400 EMACS_SET_SECS_USECS (interval
, 0, 100000);
10401 start_atimer (ATIMER_RELATIVE
, interval
, x_process_timeouts
, 0);
10402 x_timeout_atimer_activated_flag
= 1;
10407 #endif /* USE_X_TOOLKIT */
10410 /* Set up use of X before we make the first connection. */
10412 extern frame_parm_handler x_frame_parm_handlers
[];
10414 static struct redisplay_interface x_redisplay_interface
=
10416 x_frame_parm_handlers
,
10420 x_clear_end_of_line
,
10422 x_after_update_window_line
,
10423 x_update_window_begin
,
10424 x_update_window_end
,
10430 0, /* flush_display_optional */
10432 x_clear_window_mouse_face
,
10433 x_get_glyph_overhangs
,
10434 x_fix_overlapping_area
,
10435 x_draw_fringe_bitmap
,
10436 0, /* define_fringe_bitmap */
10437 0, /* destroy_fringe_bitmap */
10438 x_compute_glyph_string_overhangs
,
10439 x_draw_glyph_string
,
10440 x_define_frame_cursor
,
10441 x_clear_frame_area
,
10442 x_draw_window_cursor
,
10443 x_draw_vertical_window_border
,
10444 x_shift_glyphs_for_insert
10448 /* This function is called when the last frame on a display is deleted. */
10450 x_delete_terminal (struct terminal
*terminal
)
10452 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
10454 /* Protect against recursive calls. delete_frame in
10455 delete_terminal calls us back when it deletes our last frame. */
10456 if (!terminal
->name
)
10461 /* We must close our connection to the XIM server before closing the
10464 xim_close_dpy (dpyinfo
);
10467 /* If called from x_connection_closed, the display may already be closed
10468 and dpyinfo->display was set to 0 to indicate that. */
10469 if (dpyinfo
->display
)
10471 x_destroy_all_bitmaps (dpyinfo
);
10472 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
10474 /* Whether or not XCloseDisplay destroys the associated resource
10475 database depends on the version of libX11. To avoid both
10476 crash and memory leak, we dissociate the database from the
10477 display and then destroy dpyinfo->xrdb ourselves.
10479 Unfortunately, the above strategy does not work in some
10480 situations due to a bug in newer versions of libX11: because
10481 XrmSetDatabase doesn't clear the flag XlibDisplayDfltRMDB if
10482 dpy->db is NULL, XCloseDisplay destroys the associated
10483 database whereas it has not been created by XGetDefault
10484 (Bug#21974 in freedesktop.org Bugzilla). As a workaround, we
10485 don't destroy the database here in order to avoid the crash
10486 in the above situations for now, though that may cause memory
10487 leaks in other situations. */
10489 #ifdef HAVE_XRMSETDATABASE
10490 XrmSetDatabase (dpyinfo
->display
, NULL
);
10492 dpyinfo
->display
->db
= NULL
;
10494 /* We used to call XrmDestroyDatabase from x_delete_display, but
10495 some older versions of libX11 crash if we call it after
10496 closing all the displays. */
10497 XrmDestroyDatabase (dpyinfo
->xrdb
);
10501 xg_display_close (dpyinfo
->display
);
10503 #ifdef USE_X_TOOLKIT
10504 XtCloseDisplay (dpyinfo
->display
);
10506 XCloseDisplay (dpyinfo
->display
);
10508 #endif /* ! USE_GTK */
10511 /* Mark as dead. */
10512 dpyinfo
->display
= NULL
;
10513 x_delete_display (dpyinfo
);
10517 /* Create a struct terminal, initialize it with the X11 specific
10518 functions and make DISPLAY->TERMINAL point to it. */
10520 static struct terminal
*
10521 x_create_terminal (struct x_display_info
*dpyinfo
)
10523 struct terminal
*terminal
;
10525 terminal
= create_terminal ();
10527 terminal
->type
= output_x_window
;
10528 terminal
->display_info
.x
= dpyinfo
;
10529 dpyinfo
->terminal
= terminal
;
10531 /* kboard is initialized in x_term_init. */
10533 terminal
->clear_frame_hook
= x_clear_frame
;
10534 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
10535 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
10536 terminal
->ring_bell_hook
= XTring_bell
;
10537 terminal
->toggle_invisible_pointer_hook
= XTtoggle_invisible_pointer
;
10538 terminal
->reset_terminal_modes_hook
= XTreset_terminal_modes
;
10539 terminal
->set_terminal_modes_hook
= XTset_terminal_modes
;
10540 terminal
->update_begin_hook
= x_update_begin
;
10541 terminal
->update_end_hook
= x_update_end
;
10542 terminal
->set_terminal_window_hook
= XTset_terminal_window
;
10543 terminal
->read_socket_hook
= XTread_socket
;
10544 terminal
->frame_up_to_date_hook
= XTframe_up_to_date
;
10545 terminal
->mouse_position_hook
= XTmouse_position
;
10546 terminal
->frame_rehighlight_hook
= XTframe_rehighlight
;
10547 terminal
->frame_raise_lower_hook
= XTframe_raise_lower
;
10548 terminal
->fullscreen_hook
= XTfullscreen_hook
;
10549 terminal
->set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
10550 terminal
->condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
10551 terminal
->redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
10552 terminal
->judge_scroll_bars_hook
= XTjudge_scroll_bars
;
10554 terminal
->delete_frame_hook
= x_destroy_window
;
10555 terminal
->delete_terminal_hook
= x_delete_terminal
;
10557 terminal
->rif
= &x_redisplay_interface
;
10558 terminal
->scroll_region_ok
= 1; /* We'll scroll partial frames. */
10559 terminal
->char_ins_del_ok
= 1;
10560 terminal
->line_ins_del_ok
= 1; /* We'll just blt 'em. */
10561 terminal
->fast_clear_end_of_line
= 1; /* X does this well. */
10562 terminal
->memory_below_frame
= 0; /* We don't remember what scrolls
10569 x_initialize (void)
10574 last_tool_bar_item
= -1;
10575 any_help_event_p
= 0;
10576 ignore_next_mouse_click_timeout
= 0;
10578 x_session_initialized
= 0;
10582 current_count
= -1;
10585 /* Try to use interrupt input; if we can't, then start polling. */
10586 Fset_input_interrupt_mode (Qt
);
10588 #ifdef USE_X_TOOLKIT
10589 XtToolkitInitialize ();
10591 Xt_app_con
= XtCreateApplicationContext ();
10593 /* Register a converter from strings to pixels, which uses
10594 Emacs' color allocation infrastructure. */
10595 XtAppSetTypeConverter (Xt_app_con
,
10596 XtRString
, XtRPixel
, cvt_string_to_pixel
,
10597 cvt_string_to_pixel_args
,
10598 XtNumber (cvt_string_to_pixel_args
),
10599 XtCacheByDisplay
, cvt_pixel_dtor
);
10601 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
10604 #ifdef USE_TOOLKIT_SCROLL_BARS
10606 xaw3d_arrow_scroll
= False
;
10607 xaw3d_pick_top
= True
;
10611 pending_autoraise_frame
= 0;
10612 pending_event_wait
.f
= 0;
10613 pending_event_wait
.eventtype
= 0;
10615 /* Note that there is no real way portable across R3/R4 to get the
10616 original error handler. */
10617 XSetErrorHandler (x_error_handler
);
10618 XSetIOErrorHandler (x_io_error_quitter
);
10620 signal (SIGPIPE
, x_connection_signal
);
10622 xgselect_initialize ();
10627 syms_of_xterm (void)
10629 x_error_message
= NULL
;
10631 staticpro (&x_display_name_list
);
10632 x_display_name_list
= Qnil
;
10634 staticpro (&last_mouse_scroll_bar
);
10635 last_mouse_scroll_bar
= Qnil
;
10637 staticpro (&Qvendor_specific_keysyms
);
10638 Qvendor_specific_keysyms
= intern_c_string ("vendor-specific-keysyms");
10640 staticpro (&Qlatin_1
);
10641 Qlatin_1
= intern_c_string ("latin-1");
10643 staticpro (&last_mouse_press_frame
);
10644 last_mouse_press_frame
= Qnil
;
10647 xg_default_icon_file
= make_pure_c_string ("icons/hicolor/scalable/apps/emacs.svg");
10648 staticpro (&xg_default_icon_file
);
10650 Qx_gtk_map_stock
= intern_c_string ("x-gtk-map-stock");
10651 staticpro (&Qx_gtk_map_stock
);
10654 DEFVAR_BOOL ("x-use-underline-position-properties",
10655 &x_use_underline_position_properties
,
10656 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
10657 A value of nil means ignore them. If you encounter fonts with bogus
10658 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
10659 to 4.1, set this to nil. You can also use `underline-minimum-offset'
10660 to override the font's UNDERLINE_POSITION for small font display
10662 x_use_underline_position_properties
= 1;
10664 DEFVAR_BOOL ("x-underline-at-descent-line",
10665 &x_underline_at_descent_line
,
10666 doc
: /* *Non-nil means to draw the underline at the same place as the descent line.
10667 A value of nil means to draw the underline according to the value of the
10668 variable `x-use-underline-position-properties', which is usually at the
10669 baseline level. The default value is nil. */);
10670 x_underline_at_descent_line
= 0;
10672 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
10673 &x_mouse_click_focus_ignore_position
,
10674 doc
: /* Non-nil means that a mouse click to focus a frame does not move point.
10675 This variable is only used when the window manager requires that you
10676 click on a frame to select it (give it focus). In that case, a value
10677 of nil, means that the selected window and cursor position changes to
10678 reflect the mouse click position, while a non-nil value means that the
10679 selected window or cursor position is preserved. */);
10680 x_mouse_click_focus_ignore_position
= 0;
10682 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
10683 doc
: /* Which toolkit scroll bars Emacs uses, if any.
10684 A value of nil means Emacs doesn't use toolkit scroll bars.
10685 With the X Window system, the value is a symbol describing the
10686 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
10687 With MS Windows, the value is t. */);
10688 #ifdef USE_TOOLKIT_SCROLL_BARS
10690 Vx_toolkit_scroll_bars
= intern_c_string ("motif");
10691 #elif defined HAVE_XAW3D
10692 Vx_toolkit_scroll_bars
= intern_c_string ("xaw3d");
10694 Vx_toolkit_scroll_bars
= intern_c_string ("gtk");
10696 Vx_toolkit_scroll_bars
= intern_c_string ("xaw");
10699 Vx_toolkit_scroll_bars
= Qnil
;
10702 staticpro (&last_mouse_motion_frame
);
10703 last_mouse_motion_frame
= Qnil
;
10705 Qmodifier_value
= intern_c_string ("modifier-value");
10706 Qalt
= intern_c_string ("alt");
10707 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
10708 Qhyper
= intern_c_string ("hyper");
10709 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
10710 Qmeta
= intern_c_string ("meta");
10711 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
10712 Qsuper
= intern_c_string ("super");
10713 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
10715 DEFVAR_LISP ("x-alt-keysym", &Vx_alt_keysym
,
10716 doc
: /* Which keys Emacs uses for the alt modifier.
10717 This should be one of the symbols `alt', `hyper', `meta', `super'.
10718 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
10719 is nil, which is the same as `alt'. */);
10720 Vx_alt_keysym
= Qnil
;
10722 DEFVAR_LISP ("x-hyper-keysym", &Vx_hyper_keysym
,
10723 doc
: /* Which keys Emacs uses for the hyper modifier.
10724 This should be one of the symbols `alt', `hyper', `meta', `super'.
10725 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
10726 default is nil, which is the same as `hyper'. */);
10727 Vx_hyper_keysym
= Qnil
;
10729 DEFVAR_LISP ("x-meta-keysym", &Vx_meta_keysym
,
10730 doc
: /* Which keys Emacs uses for the meta modifier.
10731 This should be one of the symbols `alt', `hyper', `meta', `super'.
10732 For example, `meta' means use the Meta_L and Meta_R keysyms. The
10733 default is nil, which is the same as `meta'. */);
10734 Vx_meta_keysym
= Qnil
;
10736 DEFVAR_LISP ("x-super-keysym", &Vx_super_keysym
,
10737 doc
: /* Which keys Emacs uses for the super modifier.
10738 This should be one of the symbols `alt', `hyper', `meta', `super'.
10739 For example, `super' means use the Super_L and Super_R keysyms. The
10740 default is nil, which is the same as `super'. */);
10741 Vx_super_keysym
= Qnil
;
10743 DEFVAR_LISP ("x-keysym-table", &Vx_keysym_table
,
10744 doc
: /* Hash table of character codes indexed by X keysym codes. */);
10745 Vx_keysym_table
= make_hash_table (Qeql
, make_number (900),
10746 make_float (DEFAULT_REHASH_SIZE
),
10747 make_float (DEFAULT_REHASH_THRESHOLD
),
10751 #endif /* HAVE_X_WINDOWS */