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 /* There is a long-standing bug in GTK that prevents the GTK
7702 main loop from recovering gracefully from disconnects
7703 (https://bugzilla.gnome.org/show_bug.cgi?id=85715). Among
7704 other problems, this gives rise to a stream of Glib error
7705 messages that, in one incident, filled up a user's hard disk
7706 (http://lists.gnu.org/archive/html/emacs-devel/2010-10/msg00927.html).
7707 So, kill Emacs unconditionally if the display is closed. */
7709 fprintf (stderr
, "%s\n", error_msg
);
7710 Fkill_emacs (make_number (70));
7711 abort (); /* NOTREACHED */
7715 /* Indicate that this display is dead. */
7716 dpyinfo
->display
= 0;
7718 dpyinfo
->reference_count
--;
7719 dpyinfo
->terminal
->reference_count
--;
7720 if (dpyinfo
->reference_count
!= 0)
7721 /* We have just closed all frames on this display. */
7726 XSETTERMINAL (tmp
, dpyinfo
->terminal
);
7727 Fdelete_terminal (tmp
, Qnoelisp
);
7731 x_uncatch_errors ();
7733 if (terminal_list
== 0)
7735 fprintf (stderr
, "%s\n", error_msg
);
7736 Fkill_emacs (make_number (70));
7740 /* Ordinary stack unwind doesn't deal with these. */
7742 sigunblock (sigmask (SIGIO
));
7744 sigunblock (sigmask (SIGALRM
));
7745 TOTALLY_UNBLOCK_INPUT
;
7747 unbind_to (index
, Qnil
);
7748 clear_waiting_for_input ();
7749 /* Here, we absolutely have to use a non-local exit (e.g. signal, throw,
7750 longjmp), because returning from this function would get us back into
7751 Xlib's code which will directly call `exit'. */
7752 error ("%s", error_msg
);
7755 /* We specifically use it before defining it, so that gcc doesn't inline it,
7756 otherwise gdb doesn't know how to properly put a breakpoint on it. */
7757 static void x_error_quitter (Display
*, XErrorEvent
*);
7759 /* This is the first-level handler for X protocol errors.
7760 It calls x_error_quitter or x_error_catcher. */
7763 x_error_handler (Display
*display
, XErrorEvent
*error
)
7765 if (x_error_message
)
7766 x_error_catcher (display
, error
);
7768 x_error_quitter (display
, error
);
7772 /* This is the usual handler for X protocol errors.
7773 It kills all frames on the display that we got the error for.
7774 If that was the only one, it prints an error message and kills Emacs. */
7776 /* .gdbinit puts a breakpoint here, so make sure it is not inlined. */
7778 /* On older GCC versions, just putting x_error_quitter
7779 after x_error_handler prevents inlining into the former. */
7781 static void NO_INLINE
7782 x_error_quitter (Display
*display
, XErrorEvent
*error
)
7784 char buf
[256], buf1
[356];
7786 /* Ignore BadName errors. They can happen because of fonts
7787 or colors that are not defined. */
7789 if (error
->error_code
== BadName
)
7792 /* Note that there is no real way portable across R3/R4 to get the
7793 original error handler. */
7795 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
7796 sprintf (buf1
, "X protocol error: %s on protocol request %d",
7797 buf
, error
->request_code
);
7798 x_connection_closed (display
, buf1
);
7802 /* This is the handler for X IO errors, always.
7803 It kills all frames on the display that we lost touch with.
7804 If that was the only one, it prints an error message and kills Emacs. */
7807 x_io_error_quitter (Display
*display
)
7811 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
7812 x_connection_closed (display
, buf
);
7816 /* Changing the font of the frame. */
7818 /* Give frame F the font FONT-OBJECT as its default font. The return
7819 value is FONT-OBJECT. FONTSET is an ID of the fontset for the
7820 frame. If it is negative, generate a new fontset from
7824 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
7826 struct font
*font
= XFONT_OBJECT (font_object
);
7829 fontset
= fontset_from_font (font_object
);
7830 FRAME_FONTSET (f
) = fontset
;
7831 if (FRAME_FONT (f
) == font
)
7832 /* This font is already set in frame F. There's nothing more to
7836 FRAME_FONT (f
) = font
;
7837 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
7838 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
7839 FRAME_SPACE_WIDTH (f
) = font
->space_width
;
7840 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (font
);
7842 compute_fringe_widths (f
, 1);
7844 /* Compute the scroll bar width in character columns. */
7845 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
7847 int wid
= FRAME_COLUMN_WIDTH (f
);
7848 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
7849 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
-1) / wid
;
7853 int wid
= FRAME_COLUMN_WIDTH (f
);
7854 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
7857 if (FRAME_X_WINDOW (f
) != 0)
7859 /* Don't change the size of a tip frame; there's no point in
7860 doing it because it's done in Fx_show_tip, and it leads to
7861 problems because the tip frame has no widget. */
7862 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
7863 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
7868 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
7871 xic_set_xfontset (f
, SDATA (fontset_ascii (fontset
)));
7880 /***********************************************************************
7882 ***********************************************************************/
7888 /* XIM destroy callback function, which is called whenever the
7889 connection to input method XIM dies. CLIENT_DATA contains a
7890 pointer to the x_display_info structure corresponding to XIM. */
7893 xim_destroy_callback (XIM xim
, XPointer client_data
, XPointer call_data
)
7895 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
7896 Lisp_Object frame
, tail
;
7900 /* No need to call XDestroyIC.. */
7901 FOR_EACH_FRAME (tail
, frame
)
7903 struct frame
*f
= XFRAME (frame
);
7904 if (FRAME_X_P (f
) && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
7906 FRAME_XIC (f
) = NULL
;
7907 xic_free_xfontset (f
);
7911 /* No need to call XCloseIM. */
7912 dpyinfo
->xim
= NULL
;
7913 XFree (dpyinfo
->xim_styles
);
7917 #endif /* HAVE_X11R6 */
7920 /* This isn't prototyped in OSF 5.0 or 5.1a. */
7921 extern char *XSetIMValues (XIM
, ...);
7924 /* Open the connection to the XIM server on display DPYINFO.
7925 RESOURCE_NAME is the resource name Emacs uses. */
7928 xim_open_dpy (struct x_display_info
*dpyinfo
, char *resource_name
)
7936 XCloseIM (dpyinfo
->xim
);
7937 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
,
7944 XIMCallback destroy
;
7947 /* Get supported styles and XIM values. */
7948 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
7951 destroy
.callback
= xim_destroy_callback
;
7952 destroy
.client_data
= (XPointer
)dpyinfo
;
7953 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
7959 #endif /* HAVE_XIM */
7960 dpyinfo
->xim
= NULL
;
7964 #ifdef HAVE_X11R6_XIM
7966 /* XIM instantiate callback function, which is called whenever an XIM
7967 server is available. DISPLAY is the display of the XIM.
7968 CLIENT_DATA contains a pointer to an xim_inst_t structure created
7969 when the callback was registered. */
7972 xim_instantiate_callback (Display
*display
, XPointer client_data
, XPointer call_data
)
7974 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
7975 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
7977 /* We don't support multiple XIM connections. */
7981 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
7983 /* Create XIC for the existing frames on the same display, as long
7984 as they have no XIC. */
7985 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
7987 Lisp_Object tail
, frame
;
7990 FOR_EACH_FRAME (tail
, frame
)
7992 struct frame
*f
= XFRAME (frame
);
7995 && FRAME_X_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
7996 if (FRAME_XIC (f
) == NULL
)
7998 create_frame_xic (f
);
7999 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
8000 xic_set_statusarea (f
);
8001 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
8003 struct window
*w
= XWINDOW (f
->selected_window
);
8004 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
8013 #endif /* HAVE_X11R6_XIM */
8016 /* Open a connection to the XIM server on display DPYINFO.
8017 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
8018 connection only at the first time. On X11R6, open the connection
8019 in the XIM instantiate callback function. */
8022 xim_initialize (struct x_display_info
*dpyinfo
, char *resource_name
)
8024 dpyinfo
->xim
= NULL
;
8028 #ifdef HAVE_X11R6_XIM
8029 struct xim_inst_t
*xim_inst
;
8032 xim_inst
= (struct xim_inst_t
*) xmalloc (sizeof (struct xim_inst_t
));
8033 dpyinfo
->xim_callback_data
= xim_inst
;
8034 xim_inst
->dpyinfo
= dpyinfo
;
8035 len
= strlen (resource_name
);
8036 xim_inst
->resource_name
= (char *) xmalloc (len
+ 1);
8037 memcpy (xim_inst
->resource_name
, resource_name
, len
+ 1);
8038 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8039 resource_name
, emacs_class
,
8040 xim_instantiate_callback
,
8041 /* This is XPointer in XFree86
8042 but (XPointer *) on Tru64, at
8043 least, hence the configure test. */
8044 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
8045 #else /* not HAVE_X11R6_XIM */
8046 xim_open_dpy (dpyinfo
, resource_name
);
8047 #endif /* not HAVE_X11R6_XIM */
8049 #endif /* HAVE_XIM */
8053 /* Close the connection to the XIM server on display DPYINFO. */
8056 xim_close_dpy (struct x_display_info
*dpyinfo
)
8061 #ifdef HAVE_X11R6_XIM
8062 if (dpyinfo
->display
)
8063 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8065 xim_instantiate_callback
, NULL
);
8066 xfree (dpyinfo
->xim_callback_data
->resource_name
);
8067 xfree (dpyinfo
->xim_callback_data
);
8068 #endif /* HAVE_X11R6_XIM */
8069 if (dpyinfo
->display
)
8070 XCloseIM (dpyinfo
->xim
);
8071 dpyinfo
->xim
= NULL
;
8072 XFree (dpyinfo
->xim_styles
);
8074 #endif /* HAVE_XIM */
8077 #endif /* not HAVE_X11R6_XIM */
8081 /* Calculate the absolute position in frame F
8082 from its current recorded position values and gravity. */
8085 x_calc_absolute_position (struct frame
*f
)
8087 int flags
= f
->size_hint_flags
;
8089 /* We have nothing to do if the current position
8090 is already for the top-left corner. */
8091 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
8094 /* Treat negative positions as relative to the leftmost bottommost
8095 position that fits on the screen. */
8096 if (flags
& XNegative
)
8097 f
->left_pos
= x_display_pixel_width (FRAME_X_DISPLAY_INFO (f
))
8098 - FRAME_PIXEL_WIDTH (f
) + f
->left_pos
;
8101 int height
= FRAME_PIXEL_HEIGHT (f
);
8103 #if defined USE_X_TOOLKIT && defined USE_MOTIF
8104 /* Something is fishy here. When using Motif, starting Emacs with
8105 `-g -0-0', the frame appears too low by a few pixels.
8107 This seems to be so because initially, while Emacs is starting,
8108 the column widget's height and the frame's pixel height are
8109 different. The column widget's height is the right one. In
8110 later invocations, when Emacs is up, the frame's pixel height
8113 It's not obvious where the initial small difference comes from.
8114 2000-12-01, gerd. */
8116 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
8119 if (flags
& YNegative
)
8120 f
->top_pos
= x_display_pixel_height (FRAME_X_DISPLAY_INFO (f
))
8121 - height
+ f
->top_pos
;
8124 /* The left_pos and top_pos
8125 are now relative to the top and left screen edges,
8126 so the flags should correspond. */
8127 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8130 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
8131 to really change the position, and 0 when calling from
8132 x_make_frame_visible (in that case, XOFF and YOFF are the current
8133 position values). It is -1 when calling from x_set_frame_parameters,
8134 which means, do adjust for borders but don't change the gravity. */
8137 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
, int change_gravity
)
8139 int modified_top
, modified_left
;
8141 if (change_gravity
> 0)
8143 FRAME_X_OUTPUT (f
)->left_before_move
= f
->left_pos
;
8144 FRAME_X_OUTPUT (f
)->top_before_move
= f
->top_pos
;
8148 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8150 f
->size_hint_flags
|= XNegative
;
8152 f
->size_hint_flags
|= YNegative
;
8153 f
->win_gravity
= NorthWestGravity
;
8155 x_calc_absolute_position (f
);
8158 x_wm_set_size_hint (f
, (long) 0, 0);
8160 modified_left
= f
->left_pos
;
8161 modified_top
= f
->top_pos
;
8163 if (change_gravity
!= 0 && FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
)
8165 /* Some WMs (twm, wmaker at least) has an offset that is smaller
8166 than the WM decorations. So we use the calculated offset instead
8167 of the WM decoration sizes here (x/y_pixels_outer_diff). */
8168 modified_left
+= FRAME_X_OUTPUT (f
)->move_offset_left
;
8169 modified_top
+= FRAME_X_OUTPUT (f
)->move_offset_top
;
8172 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8173 modified_left
, modified_top
);
8175 x_sync_with_move (f
, f
->left_pos
, f
->top_pos
,
8176 FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8179 /* change_gravity is non-zero when this function is called from Lisp to
8180 programmatically move a frame. In that case, we call
8181 x_check_expected_move to discover if we have a "Type A" or "Type B"
8182 window manager, and, for a "Type A" window manager, adjust the position
8185 We call x_check_expected_move if a programmatic move occurred, and
8186 either the window manager type (A/B) is unknown or it is Type A but we
8187 need to compute the top/left offset adjustment for this frame. */
8189 if (change_gravity
!= 0 &&
8190 (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8191 || (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
8192 && (FRAME_X_OUTPUT (f
)->move_offset_left
== 0
8193 && FRAME_X_OUTPUT (f
)->move_offset_top
== 0))))
8194 x_check_expected_move (f
, modified_left
, modified_top
);
8199 /* Return non-zero if _NET_SUPPORTING_WM_CHECK window exists and _NET_SUPPORTED
8200 on the root window for frame F contains ATOMNAME.
8201 This is how a WM check shall be done according to the Window Manager
8202 Specification/Extended Window Manager Hints at
8203 http://freedesktop.org/wiki/Specifications/wm-spec. */
8206 wm_supports (struct frame
*f
, const char *atomname
)
8209 unsigned long actual_size
, bytes_remaining
;
8210 int i
, rc
, actual_format
;
8212 Window wmcheck_window
;
8213 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8214 Window target_window
= dpyinfo
->root_window
;
8215 long max_len
= 65536;
8216 Display
*dpy
= FRAME_X_DISPLAY (f
);
8217 unsigned char *tmp_data
= NULL
;
8218 Atom target_type
= XA_WINDOW
;
8223 prop_atom
= XInternAtom (dpy
, "_NET_SUPPORTING_WM_CHECK", False
);
8225 x_catch_errors (dpy
);
8226 rc
= XGetWindowProperty (dpy
, target_window
,
8227 prop_atom
, 0, max_len
, False
, target_type
,
8228 &actual_type
, &actual_format
, &actual_size
,
8229 &bytes_remaining
, &tmp_data
);
8231 if (rc
!= Success
|| actual_type
!= XA_WINDOW
|| x_had_errors_p (dpy
))
8233 if (tmp_data
) XFree (tmp_data
);
8234 x_uncatch_errors ();
8239 wmcheck_window
= *(Window
*) tmp_data
;
8242 /* Check if window exists. */
8243 XSelectInput (dpy
, wmcheck_window
, StructureNotifyMask
);
8245 if (x_had_errors_p (dpy
))
8247 x_uncatch_errors ();
8252 if (dpyinfo
->net_supported_window
!= wmcheck_window
)
8254 /* Window changed, reload atoms */
8255 if (dpyinfo
->net_supported_atoms
!= NULL
)
8256 XFree (dpyinfo
->net_supported_atoms
);
8257 dpyinfo
->net_supported_atoms
= NULL
;
8258 dpyinfo
->nr_net_supported_atoms
= 0;
8259 dpyinfo
->net_supported_window
= 0;
8261 target_type
= XA_ATOM
;
8262 prop_atom
= XInternAtom (dpy
, "_NET_SUPPORTED", False
);
8264 rc
= XGetWindowProperty (dpy
, target_window
,
8265 prop_atom
, 0, max_len
, False
, target_type
,
8266 &actual_type
, &actual_format
, &actual_size
,
8267 &bytes_remaining
, &tmp_data
);
8269 if (rc
!= Success
|| actual_type
!= XA_ATOM
|| x_had_errors_p (dpy
))
8271 if (tmp_data
) XFree (tmp_data
);
8272 x_uncatch_errors ();
8277 dpyinfo
->net_supported_atoms
= (Atom
*)tmp_data
;
8278 dpyinfo
->nr_net_supported_atoms
= actual_size
;
8279 dpyinfo
->net_supported_window
= wmcheck_window
;
8283 want_atom
= XInternAtom (dpy
, atomname
, False
);
8285 for (i
= 0; rc
== 0 && i
< dpyinfo
->nr_net_supported_atoms
; ++i
)
8286 rc
= dpyinfo
->net_supported_atoms
[i
] == want_atom
;
8288 x_uncatch_errors ();
8295 set_wm_state (Lisp_Object frame
, int add
, const char *what
, const char *what2
)
8297 const char *atom
= "_NET_WM_STATE";
8298 Fx_send_client_event (frame
, make_number (0), frame
,
8299 make_unibyte_string (atom
, strlen (atom
)),
8301 /* 1 = add, 0 = remove */
8303 (make_number (add
? 1 : 0),
8305 (make_unibyte_string (what
, strlen (what
)),
8307 ? Fcons (make_unibyte_string (what2
, strlen (what2
)),
8313 x_set_sticky (struct frame
*f
, Lisp_Object new_value
, Lisp_Object old_value
)
8317 XSETFRAME (frame
, f
);
8318 set_wm_state (frame
, NILP (new_value
) ? 0 : 1,
8319 "_NET_WM_STATE_STICKY", NULL
);
8322 /* Return the current _NET_WM_STATE.
8323 SIZE_STATE is set to one of the FULLSCREEN_* values.
8324 STICKY is set to 1 if the sticky state is set, 0 if not. */
8327 get_current_vm_state (struct frame
*f
,
8333 unsigned long actual_size
, bytes_remaining
;
8334 int i
, rc
, actual_format
;
8335 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8336 long max_len
= 65536;
8337 Display
*dpy
= FRAME_X_DISPLAY (f
);
8338 unsigned char *tmp_data
= NULL
;
8339 Atom target_type
= XA_ATOM
;
8342 *size_state
= FULLSCREEN_NONE
;
8345 x_catch_errors (dpy
);
8346 rc
= XGetWindowProperty (dpy
, window
, dpyinfo
->Xatom_net_wm_state
,
8347 0, max_len
, False
, target_type
,
8348 &actual_type
, &actual_format
, &actual_size
,
8349 &bytes_remaining
, &tmp_data
);
8351 if (rc
!= Success
|| actual_type
!= target_type
|| x_had_errors_p (dpy
))
8353 if (tmp_data
) XFree (tmp_data
);
8354 x_uncatch_errors ();
8359 x_uncatch_errors ();
8361 for (i
= 0; i
< actual_size
; ++i
)
8363 Atom a
= ((Atom
*)tmp_data
)[i
];
8364 if (a
== dpyinfo
->Xatom_net_wm_state_maximized_horz
)
8366 if (*size_state
== FULLSCREEN_HEIGHT
)
8367 *size_state
= FULLSCREEN_MAXIMIZED
;
8369 *size_state
= FULLSCREEN_WIDTH
;
8371 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_vert
)
8373 if (*size_state
== FULLSCREEN_WIDTH
)
8374 *size_state
= FULLSCREEN_MAXIMIZED
;
8376 *size_state
= FULLSCREEN_HEIGHT
;
8378 else if (a
== dpyinfo
->Xatom_net_wm_state_fullscreen_atom
)
8379 *size_state
= FULLSCREEN_BOTH
;
8380 else if (a
== dpyinfo
->Xatom_net_wm_state_sticky
)
8384 if (tmp_data
) XFree (tmp_data
);
8388 /* Do fullscreen as specified in extended window manager hints */
8391 do_ewmh_fullscreen (struct frame
*f
)
8393 int have_net_atom
= wm_supports (f
, "_NET_WM_STATE");
8394 Lisp_Object lval
= get_frame_param (f
, Qfullscreen
);
8397 get_current_vm_state (f
, FRAME_OUTER_WINDOW (f
), &cur
, &dummy
);
8399 /* Some window managers don't say they support _NET_WM_STATE, but they do say
8400 they support _NET_WM_STATE_FULLSCREEN. Try that also. */
8402 have_net_atom
= wm_supports (f
, "_NET_WM_STATE_FULLSCREEN");
8404 if (have_net_atom
&& cur
!= f
->want_fullscreen
)
8407 const char *fs
= "_NET_WM_STATE_FULLSCREEN";
8408 const char *fw
= "_NET_WM_STATE_MAXIMIZED_HORZ";
8409 const char *fh
= "_NET_WM_STATE_MAXIMIZED_VERT";
8411 XSETFRAME (frame
, f
);
8413 /* Keep number of calls to set_wm_state as low as possible.
8414 Some window managers, or possible Gtk+, hangs when too many
8415 are sent at once. */
8416 switch (f
->want_fullscreen
)
8418 case FULLSCREEN_BOTH
:
8419 if (cur
== FULLSCREEN_WIDTH
|| cur
== FULLSCREEN_MAXIMIZED
8420 || cur
== FULLSCREEN_HEIGHT
)
8421 set_wm_state (frame
, 0, fw
, fh
);
8422 set_wm_state (frame
, 1, fs
, NULL
);
8424 case FULLSCREEN_WIDTH
:
8425 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_HEIGHT
8426 || cur
== FULLSCREEN_MAXIMIZED
)
8427 set_wm_state (frame
, 0, fs
, fh
);
8428 if (cur
!= FULLSCREEN_MAXIMIZED
)
8429 set_wm_state (frame
, 1, fw
, NULL
);
8431 case FULLSCREEN_HEIGHT
:
8432 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_WIDTH
8433 || cur
== FULLSCREEN_MAXIMIZED
)
8434 set_wm_state (frame
, 0, fs
, fw
);
8435 if (cur
!= FULLSCREEN_MAXIMIZED
)
8436 set_wm_state (frame
, 1, fh
, NULL
);
8438 case FULLSCREEN_MAXIMIZED
:
8439 if (cur
== FULLSCREEN_BOTH
)
8440 set_wm_state (frame
, 0, fs
, NULL
);
8441 set_wm_state (frame
, 1, fw
, fh
);
8443 case FULLSCREEN_NONE
:
8444 if (cur
== FULLSCREEN_BOTH
)
8445 set_wm_state (frame
, 0, fs
, NULL
);
8447 set_wm_state (frame
, 0, fw
, fh
);
8450 f
->want_fullscreen
= FULLSCREEN_NONE
;
8454 return have_net_atom
;
8458 XTfullscreen_hook (FRAME_PTR f
)
8460 if (f
->async_visible
)
8463 x_check_fullscreen (f
);
8471 x_handle_net_wm_state (struct frame
*f
, XPropertyEvent
*event
)
8473 int value
= FULLSCREEN_NONE
;
8477 get_current_vm_state (f
, event
->window
, &value
, &sticky
);
8481 case FULLSCREEN_WIDTH
:
8484 case FULLSCREEN_HEIGHT
:
8487 case FULLSCREEN_BOTH
:
8490 case FULLSCREEN_MAXIMIZED
:
8495 store_frame_param (f
, Qfullscreen
, lval
);
8496 store_frame_param (f
, Qsticky
, sticky
? Qt
: Qnil
);
8499 /* Check if we need to resize the frame due to a fullscreen request.
8500 If so needed, resize the frame. */
8502 x_check_fullscreen (struct frame
*f
)
8504 if (do_ewmh_fullscreen (f
))
8507 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
8508 return; /* Only fullscreen without WM or with EWM hints (above). */
8510 if (f
->want_fullscreen
!= FULLSCREEN_NONE
)
8512 int width
= FRAME_COLS (f
), height
= FRAME_LINES (f
);
8513 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8515 switch (f
->want_fullscreen
)
8517 /* No difference between these two when there is no WM */
8518 case FULLSCREEN_BOTH
:
8519 case FULLSCREEN_MAXIMIZED
:
8520 width
= x_display_pixel_width (dpyinfo
);
8521 height
= x_display_pixel_height (dpyinfo
);
8523 case FULLSCREEN_WIDTH
:
8524 width
= x_display_pixel_width (dpyinfo
);
8526 case FULLSCREEN_HEIGHT
:
8527 height
= x_display_pixel_height (dpyinfo
);
8530 if (FRAME_COLS (f
) != width
|| FRAME_LINES (f
) != height
)
8532 change_frame_size (f
, height
, width
, 0, 1, 0);
8533 SET_FRAME_GARBAGED (f
);
8534 cancel_mouse_face (f
);
8539 /* This function is called by x_set_offset to determine whether the window
8540 manager interfered with the positioning of the frame. Type A window
8541 managers position the surrounding window manager decorations a small
8542 amount above and left of the user-supplied position. Type B window
8543 managers position the surrounding window manager decorations at the
8544 user-specified position. If we detect a Type A window manager, we
8545 compensate by moving the window right and down by the proper amount. */
8548 x_check_expected_move (struct frame
*f
, int expected_left
, int expected_top
)
8550 int current_left
= 0, current_top
= 0;
8552 /* x_real_positions returns the left and top offsets of the outermost
8553 window manager window around the frame. */
8555 x_real_positions (f
, ¤t_left
, ¤t_top
);
8557 if (current_left
!= expected_left
|| current_top
!= expected_top
)
8559 /* It's a "Type A" window manager. */
8564 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_A
;
8565 FRAME_X_OUTPUT (f
)->move_offset_left
= expected_left
- current_left
;
8566 FRAME_X_OUTPUT (f
)->move_offset_top
= expected_top
- current_top
;
8568 /* Now fix the mispositioned frame's location. */
8570 adjusted_left
= expected_left
+ FRAME_X_OUTPUT (f
)->move_offset_left
;
8571 adjusted_top
= expected_top
+ FRAME_X_OUTPUT (f
)->move_offset_top
;
8573 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8574 adjusted_left
, adjusted_top
);
8576 x_sync_with_move (f
, expected_left
, expected_top
, 0);
8579 /* It's a "Type B" window manager. We don't have to adjust the
8580 frame's position. */
8582 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_B
;
8586 /* Wait for XGetGeometry to return up-to-date position information for a
8587 recently-moved frame. Call this immediately after calling XMoveWindow.
8588 If FUZZY is non-zero, then LEFT and TOP are just estimates of where the
8589 frame has been moved to, so we use a fuzzy position comparison instead
8590 of an exact comparison. */
8593 x_sync_with_move (struct frame
*f
, int left
, int top
, int fuzzy
)
8597 while (count
++ < 50)
8599 int current_left
= 0, current_top
= 0;
8601 /* In theory, this call to XSync only needs to happen once, but in
8602 practice, it doesn't seem to work, hence the need for the surrounding
8605 XSync (FRAME_X_DISPLAY (f
), False
);
8606 x_real_positions (f
, ¤t_left
, ¤t_top
);
8610 /* The left fuzz-factor is 10 pixels. The top fuzz-factor is 40
8613 if (eabs (current_left
- left
) <= 10
8614 && eabs (current_top
- top
) <= 40)
8617 else if (current_left
== left
&& current_top
== top
)
8621 /* As a last resort, just wait 0.5 seconds and hope that XGetGeometry
8622 will then return up-to-date position info. */
8624 wait_reading_process_output (0, 500000, 0, 0, Qnil
, NULL
, 0);
8628 /* Wait for an event on frame F matching EVENTTYPE. */
8630 x_wait_for_event (struct frame
*f
, int eventtype
)
8632 int level
= interrupt_input_blocked
;
8635 EMACS_TIME tmo
, tmo_at
, time_now
;
8636 int fd
= ConnectionNumber (FRAME_X_DISPLAY (f
));
8638 pending_event_wait
.f
= f
;
8639 pending_event_wait
.eventtype
= eventtype
;
8641 /* Set timeout to 0.1 second. Hopefully not noticable.
8642 Maybe it should be configurable. */
8643 EMACS_SET_SECS_USECS (tmo
, 0, 100000);
8644 EMACS_GET_TIME (tmo_at
);
8645 EMACS_ADD_TIME (tmo_at
, tmo_at
, tmo
);
8647 while (pending_event_wait
.eventtype
)
8649 interrupt_input_pending
= 1;
8650 TOTALLY_UNBLOCK_INPUT
;
8651 /* XTread_socket is called after unblock. */
8653 interrupt_input_blocked
= level
;
8658 EMACS_GET_TIME (time_now
);
8659 EMACS_SUB_TIME (tmo
, tmo_at
, time_now
);
8661 if (EMACS_TIME_NEG_P (tmo
) || select (fd
+1, &fds
, NULL
, NULL
, &tmo
) == 0)
8662 break; /* Timeout */
8664 pending_event_wait
.f
= 0;
8665 pending_event_wait
.eventtype
= 0;
8669 /* Change the size of frame F's X window to COLS/ROWS in the case F
8670 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
8671 top-left-corner window gravity for this size change and subsequent
8672 size changes. Otherwise we leave the window gravity unchanged. */
8675 x_set_window_size_1 (struct frame
*f
, int change_gravity
, int cols
, int rows
)
8677 int pixelwidth
, pixelheight
;
8679 check_frame_size (f
, &rows
, &cols
);
8680 f
->scroll_bar_actual_width
8681 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
8683 : FRAME_CONFIG_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
));
8685 compute_fringe_widths (f
, 0);
8687 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
)
8688 + FRAME_TOOLBAR_WIDTH (f
);
8689 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
8690 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
8692 if (change_gravity
) f
->win_gravity
= NorthWestGravity
;
8693 x_wm_set_size_hint (f
, (long) 0, 0);
8694 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8695 pixelwidth
, pixelheight
);
8698 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
8699 receive in the ConfigureNotify event; if we get what we asked
8700 for, then the event won't cause the screen to become garbaged, so
8701 we have to make sure to do it here. */
8702 SET_FRAME_GARBAGED (f
);
8704 /* Now, strictly speaking, we can't be sure that this is accurate,
8705 but the window manager will get around to dealing with the size
8706 change request eventually, and we'll hear how it went when the
8707 ConfigureNotify event gets here.
8709 We could just not bother storing any of this information here,
8710 and let the ConfigureNotify event set everything up, but that
8711 might be kind of confusing to the Lisp code, since size changes
8712 wouldn't be reported in the frame parameters until some random
8713 point in the future when the ConfigureNotify event arrives.
8715 We pass 1 for DELAY since we can't run Lisp code inside of
8718 /* But the ConfigureNotify may in fact never arrive, and then this is
8719 not right if the frame is visible. Instead wait (with timeout)
8720 for the ConfigureNotify. */
8721 if (f
->async_visible
)
8722 x_wait_for_event (f
, ConfigureNotify
);
8725 change_frame_size (f
, rows
, cols
, 0, 1, 0);
8726 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
8727 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
8733 /* Call this to change the size of frame F's x-window.
8734 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
8735 for this size change and subsequent size changes.
8736 Otherwise we leave the window gravity unchanged. */
8739 x_set_window_size (struct frame
*f
, int change_gravity
, int cols
, int rows
)
8743 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
8747 /* When the frame is maximized/fullscreen or running under for
8748 example Xmonad, x_set_window_size_1 will be a no-op.
8749 In that case, the right thing to do is extend rows/cols to
8750 the current frame size. We do that first if x_set_window_size_1
8751 turns out to not be a no-op (there is no way to know).
8752 The size will be adjusted again if the frame gets a
8753 ConfigureNotify event as a result of x_set_window_size. */
8754 int pixelh
= FRAME_PIXEL_HEIGHT (f
);
8755 #ifdef USE_X_TOOLKIT
8756 /* The menu bar is not part of text lines. The tool bar
8758 pixelh
-= FRAME_MENUBAR_HEIGHT (f
);
8760 r
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelh
);
8761 /* Update f->scroll_bar_actual_width because it is used in
8762 FRAME_PIXEL_WIDTH_TO_TEXT_COLS. */
8763 f
->scroll_bar_actual_width
8764 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
8765 c
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, FRAME_PIXEL_WIDTH (f
));
8766 change_frame_size (f
, r
, c
, 0, 1, 0);
8770 if (FRAME_GTK_WIDGET (f
))
8771 xg_frame_set_char_size (f
, cols
, rows
);
8773 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8774 #else /* not USE_GTK */
8776 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8778 #endif /* not USE_GTK */
8780 /* If cursor was outside the new size, mark it as off. */
8781 mark_window_cursors_off (XWINDOW (f
->root_window
));
8783 /* Clear out any recollection of where the mouse highlighting was,
8784 since it might be in a place that's outside the new frame size.
8785 Actually checking whether it is outside is a pain in the neck,
8786 so don't try--just let the highlighting be done afresh with new size. */
8787 cancel_mouse_face (f
);
8792 /* Mouse warping. */
8795 x_set_mouse_position (struct frame
*f
, int x
, int y
)
8799 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
8800 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
8802 if (pix_x
< 0) pix_x
= 0;
8803 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
8805 if (pix_y
< 0) pix_y
= 0;
8806 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
8810 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8811 0, 0, 0, 0, pix_x
, pix_y
);
8815 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
8818 x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
8822 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8823 0, 0, 0, 0, pix_x
, pix_y
);
8827 /* focus shifting, raising and lowering. */
8830 x_focus_on_frame (struct frame
*f
)
8833 /* I don't think that the ICCCM allows programs to do things like this
8834 without the interaction of the window manager. Whatever you end up
8835 doing with this code, do it to x_unfocus_frame too. */
8836 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8837 RevertToPointerRoot
, CurrentTime
);
8842 x_unfocus_frame (struct frame
*f
)
8845 /* Look at the remarks in x_focus_on_frame. */
8846 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
8847 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
8848 RevertToPointerRoot
, CurrentTime
);
8852 /* Raise frame F. */
8855 x_raise_frame (struct frame
*f
)
8858 if (f
->async_visible
)
8859 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8861 XFlush (FRAME_X_DISPLAY (f
));
8865 /* Lower frame F. */
8868 x_lower_frame (struct frame
*f
)
8870 if (f
->async_visible
)
8873 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8874 XFlush (FRAME_X_DISPLAY (f
));
8879 /* Activate frame with Extended Window Manager Hints */
8882 x_ewmh_activate_frame (FRAME_PTR f
)
8884 /* See Window Manager Specification/Extended Window Manager Hints at
8885 http://freedesktop.org/wiki/Specifications/wm-spec */
8887 const char *atom
= "_NET_ACTIVE_WINDOW";
8888 if (f
->async_visible
&& wm_supports (f
, atom
))
8891 XSETFRAME (frame
, f
);
8892 Fx_send_client_event (frame
, make_number (0), frame
,
8893 make_unibyte_string (atom
, strlen (atom
)),
8895 Fcons (make_number (1),
8896 Fcons (make_number (last_user_time
),
8902 XTframe_raise_lower (FRAME_PTR f
, int raise_flag
)
8910 /* XEmbed implementation. */
8913 xembed_set_info (struct frame
*f
, enum xembed_info flags
)
8916 unsigned long data
[2];
8918 atom
= XInternAtom (FRAME_X_DISPLAY (f
), "_XEMBED_INFO", False
);
8920 data
[0] = XEMBED_VERSION
;
8923 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), atom
, atom
,
8924 32, PropModeReplace
, (unsigned char *) data
, 2);
8928 xembed_send_message (struct frame
*f
, Time time
, enum xembed_message message
, long int detail
, long int data1
, long int data2
)
8932 event
.xclient
.type
= ClientMessage
;
8933 event
.xclient
.window
= FRAME_X_OUTPUT (f
)->parent_desc
;
8934 event
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_XEMBED
;
8935 event
.xclient
.format
= 32;
8936 event
.xclient
.data
.l
[0] = time
;
8937 event
.xclient
.data
.l
[1] = message
;
8938 event
.xclient
.data
.l
[2] = detail
;
8939 event
.xclient
.data
.l
[3] = data1
;
8940 event
.xclient
.data
.l
[4] = data2
;
8942 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_OUTPUT (f
)->parent_desc
,
8943 False
, NoEventMask
, &event
);
8944 XSync (FRAME_X_DISPLAY (f
), False
);
8947 /* Change of visibility. */
8949 /* This tries to wait until the frame is really visible.
8950 However, if the window manager asks the user where to position
8951 the frame, this will return before the user finishes doing that.
8952 The frame will not actually be visible at that time,
8953 but it will become visible later when the window manager
8954 finishes with it. */
8957 x_make_frame_visible (struct frame
*f
)
8960 int original_top
, original_left
;
8961 int retry_count
= 2;
8967 type
= x_icon_type (f
);
8969 x_bitmap_icon (f
, type
);
8971 if (! FRAME_VISIBLE_P (f
))
8973 /* We test FRAME_GARBAGED_P here to make sure we don't
8974 call x_set_offset a second time
8975 if we get to x_make_frame_visible a second time
8976 before the window gets really visible. */
8977 if (! FRAME_ICONIFIED_P (f
)
8978 && ! FRAME_X_EMBEDDED_P (f
)
8979 && ! f
->output_data
.x
->asked_for_visible
)
8980 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
8982 f
->output_data
.x
->asked_for_visible
= 1;
8984 if (! EQ (Vx_no_window_manager
, Qt
))
8985 x_wm_set_window_state (f
, NormalState
);
8986 #ifdef USE_X_TOOLKIT
8987 if (FRAME_X_EMBEDDED_P (f
))
8988 xembed_set_info (f
, XEMBED_MAPPED
);
8991 /* This was XtPopup, but that did nothing for an iconified frame. */
8992 XtMapWidget (f
->output_data
.x
->widget
);
8994 #else /* not USE_X_TOOLKIT */
8996 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
8997 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
8999 if (FRAME_X_EMBEDDED_P (f
))
9000 xembed_set_info (f
, XEMBED_MAPPED
);
9002 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9003 #endif /* not USE_GTK */
9004 #endif /* not USE_X_TOOLKIT */
9007 XFlush (FRAME_X_DISPLAY (f
));
9009 /* Synchronize to ensure Emacs knows the frame is visible
9010 before we do anything else. We do this loop with input not blocked
9011 so that incoming events are handled. */
9015 /* This must be before UNBLOCK_INPUT
9016 since events that arrive in response to the actions above
9017 will set it when they are handled. */
9018 int previously_visible
= f
->output_data
.x
->has_been_visible
;
9020 original_left
= f
->left_pos
;
9021 original_top
= f
->top_pos
;
9023 /* This must come after we set COUNT. */
9026 /* We unblock here so that arriving X events are processed. */
9028 /* Now move the window back to where it was "supposed to be".
9029 But don't do it if the gravity is negative.
9030 When the gravity is negative, this uses a position
9031 that is 3 pixels too low. Perhaps that's really the border width.
9033 Don't do this if the window has never been visible before,
9034 because the window manager may choose the position
9035 and we don't want to override it. */
9037 if (! FRAME_VISIBLE_P (f
)
9038 && ! FRAME_ICONIFIED_P (f
)
9039 && ! FRAME_X_EMBEDDED_P (f
)
9040 && f
->win_gravity
== NorthWestGravity
9041 && previously_visible
)
9045 unsigned int width
, height
, border
, depth
;
9049 /* On some window managers (such as FVWM) moving an existing
9050 window, even to the same place, causes the window manager
9051 to introduce an offset. This can cause the window to move
9052 to an unexpected location. Check the geometry (a little
9053 slow here) and then verify that the window is in the right
9054 place. If the window is not in the right place, move it
9055 there, and take the potential window manager hit. */
9056 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9057 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
9059 if (original_left
!= x
|| original_top
!= y
)
9060 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9061 original_left
, original_top
);
9066 XSETFRAME (frame
, f
);
9068 /* Wait until the frame is visible. Process X events until a
9069 MapNotify event has been seen, or until we think we won't get a
9070 MapNotify at all.. */
9071 for (count
= input_signal_count
+ 10;
9072 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
9074 /* Force processing of queued events. */
9077 /* Machines that do polling rather than SIGIO have been
9078 observed to go into a busy-wait here. So we'll fake an
9079 alarm signal to let the handler know that there's something
9080 to be read. We used to raise a real alarm, but it seems
9081 that the handler isn't always enabled here. This is
9083 if (input_polling_used ())
9085 /* It could be confusing if a real alarm arrives while
9086 processing the fake one. Turn it off and let the
9087 handler reset it. */
9088 int old_poll_suppress_count
= poll_suppress_count
;
9089 poll_suppress_count
= 1;
9090 poll_for_input_1 ();
9091 poll_suppress_count
= old_poll_suppress_count
;
9094 /* See if a MapNotify event has been processed. */
9095 FRAME_SAMPLE_VISIBILITY (f
);
9100 (let ((f (selected-frame)))
9104 the frame is not raised with various window managers on
9105 FreeBSD, GNU/Linux and Solaris. It turns out that, for some
9106 unknown reason, the call to XtMapWidget is completely ignored.
9107 Mapping the widget a second time works. */
9109 if (!FRAME_VISIBLE_P (f
) && --retry_count
> 0)
9114 /* Change from mapped state to withdrawn state. */
9116 /* Make the frame visible (mapped and not iconified). */
9119 x_make_frame_invisible (struct frame
*f
)
9123 /* Use the frame's outermost window, not the one we normally draw on. */
9124 window
= FRAME_OUTER_WINDOW (f
);
9126 /* Don't keep the highlight on an invisible frame. */
9127 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9128 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9132 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
9133 that the current position of the window is user-specified, rather than
9134 program-specified, so that when the window is mapped again, it will be
9135 placed at the same location, without forcing the user to position it
9136 by hand again (they have already done that once for this window.) */
9137 x_wm_set_size_hint (f
, (long) 0, 1);
9140 if (FRAME_GTK_OUTER_WIDGET (f
))
9141 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f
));
9144 if (FRAME_X_EMBEDDED_P (f
))
9145 xembed_set_info (f
, 0);
9150 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
9151 DefaultScreen (FRAME_X_DISPLAY (f
))))
9153 UNBLOCK_INPUT_RESIGNAL
;
9154 error ("Can't notify window manager of window withdrawal");
9158 /* We can't distinguish this from iconification
9159 just by the event that we get from the server.
9160 So we can't win using the usual strategy of letting
9161 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
9162 and synchronize with the server to make sure we agree. */
9164 FRAME_ICONIFIED_P (f
) = 0;
9165 f
->async_visible
= 0;
9166 f
->async_iconified
= 0;
9173 /* Change window state from mapped to iconified. */
9176 x_iconify_frame (struct frame
*f
)
9181 /* Don't keep the highlight on an invisible frame. */
9182 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9183 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9185 if (f
->async_iconified
)
9190 FRAME_SAMPLE_VISIBILITY (f
);
9192 type
= x_icon_type (f
);
9194 x_bitmap_icon (f
, type
);
9197 if (FRAME_GTK_OUTER_WIDGET (f
))
9199 if (! FRAME_VISIBLE_P (f
))
9200 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
9202 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
9205 f
->async_iconified
= 1;
9206 f
->async_visible
= 0;
9212 #ifdef USE_X_TOOLKIT
9214 if (! FRAME_VISIBLE_P (f
))
9216 if (! EQ (Vx_no_window_manager
, Qt
))
9217 x_wm_set_window_state (f
, IconicState
);
9218 /* This was XtPopup, but that did nothing for an iconified frame. */
9219 XtMapWidget (f
->output_data
.x
->widget
);
9220 /* The server won't give us any event to indicate
9221 that an invisible frame was changed to an icon,
9222 so we have to record it here. */
9225 f
->async_iconified
= 1;
9226 f
->async_visible
= 0;
9231 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
9232 XtWindow (f
->output_data
.x
->widget
),
9233 DefaultScreen (FRAME_X_DISPLAY (f
)));
9237 error ("Can't notify window manager of iconification");
9239 f
->async_iconified
= 1;
9240 f
->async_visible
= 0;
9244 XFlush (FRAME_X_DISPLAY (f
));
9246 #else /* not USE_X_TOOLKIT */
9248 /* Make sure the X server knows where the window should be positioned,
9249 in case the user deiconifies with the window manager. */
9250 if (! FRAME_VISIBLE_P (f
)
9251 && ! FRAME_ICONIFIED_P (f
)
9252 && ! FRAME_X_EMBEDDED_P (f
))
9253 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
9255 /* Since we don't know which revision of X we're running, we'll use both
9256 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
9258 /* X11R4: send a ClientMessage to the window manager using the
9259 WM_CHANGE_STATE type. */
9263 message
.xclient
.window
= FRAME_X_WINDOW (f
);
9264 message
.xclient
.type
= ClientMessage
;
9265 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
9266 message
.xclient
.format
= 32;
9267 message
.xclient
.data
.l
[0] = IconicState
;
9269 if (! XSendEvent (FRAME_X_DISPLAY (f
),
9270 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
9272 SubstructureRedirectMask
| SubstructureNotifyMask
,
9275 UNBLOCK_INPUT_RESIGNAL
;
9276 error ("Can't notify window manager of iconification");
9280 /* X11R3: set the initial_state field of the window manager hints to
9282 x_wm_set_window_state (f
, IconicState
);
9284 if (!FRAME_VISIBLE_P (f
))
9286 /* If the frame was withdrawn, before, we must map it. */
9287 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9290 f
->async_iconified
= 1;
9291 f
->async_visible
= 0;
9293 XFlush (FRAME_X_DISPLAY (f
));
9295 #endif /* not USE_X_TOOLKIT */
9299 /* Free X resources of frame F. */
9302 x_free_frame_resources (struct frame
*f
)
9304 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9306 struct scroll_bar
*b
;
9310 /* If a display connection is dead, don't try sending more
9311 commands to the X server. */
9312 if (dpyinfo
->display
)
9314 /* We must free faces before destroying windows because some
9315 font-driver (e.g. xft) access a window while finishing a
9317 if (FRAME_FACE_CACHE (f
))
9318 free_frame_faces (f
);
9320 if (f
->output_data
.x
->icon_desc
)
9321 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
9323 #ifdef USE_X_TOOLKIT
9324 /* Explicitly destroy the scroll bars of the frame. Without
9325 this, we get "BadDrawable" errors from the toolkit later on,
9326 presumably from expose events generated for the disappearing
9327 toolkit scroll bars. */
9328 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
9330 b
= XSCROLL_BAR (bar
);
9331 x_scroll_bar_remove (b
);
9340 #ifdef USE_X_TOOLKIT
9341 if (f
->output_data
.x
->widget
)
9343 XtDestroyWidget (f
->output_data
.x
->widget
);
9344 f
->output_data
.x
->widget
= NULL
;
9346 /* Tooltips don't have widgets, only a simple X window, even if
9347 we are using a toolkit. */
9348 else if (FRAME_X_WINDOW (f
))
9349 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9351 free_frame_menubar (f
);
9352 #else /* !USE_X_TOOLKIT */
9355 xg_free_frame_widgets (f
);
9356 #endif /* USE_GTK */
9358 if (FRAME_X_WINDOW (f
))
9359 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9360 #endif /* !USE_X_TOOLKIT */
9362 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
9363 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
9364 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
9365 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
9366 unload_color (f
, f
->output_data
.x
->border_pixel
);
9367 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
9369 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
9370 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
9371 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
9372 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
9373 #ifdef USE_TOOLKIT_SCROLL_BARS
9374 /* Scrollbar shadow colors. */
9375 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
9376 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
9377 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
9378 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
9379 #endif /* USE_TOOLKIT_SCROLL_BARS */
9380 if (f
->output_data
.x
->white_relief
.allocated_p
)
9381 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
9382 if (f
->output_data
.x
->black_relief
.allocated_p
)
9383 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
9386 XFlush (FRAME_X_DISPLAY (f
));
9389 xfree (f
->output_data
.x
->saved_menu_event
);
9390 xfree (f
->output_data
.x
);
9391 f
->output_data
.x
= NULL
;
9393 if (f
== dpyinfo
->x_focus_frame
)
9394 dpyinfo
->x_focus_frame
= 0;
9395 if (f
== dpyinfo
->x_focus_event_frame
)
9396 dpyinfo
->x_focus_event_frame
= 0;
9397 if (f
== dpyinfo
->x_highlight_frame
)
9398 dpyinfo
->x_highlight_frame
= 0;
9400 if (f
== dpyinfo
->mouse_face_mouse_frame
)
9402 dpyinfo
->mouse_face_beg_row
9403 = dpyinfo
->mouse_face_beg_col
= -1;
9404 dpyinfo
->mouse_face_end_row
9405 = dpyinfo
->mouse_face_end_col
= -1;
9406 dpyinfo
->mouse_face_window
= Qnil
;
9407 dpyinfo
->mouse_face_deferred_gc
= 0;
9408 dpyinfo
->mouse_face_mouse_frame
= 0;
9415 /* Destroy the X window of frame F. */
9418 x_destroy_window (struct frame
*f
)
9420 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9422 /* If a display connection is dead, don't try sending more
9423 commands to the X server. */
9424 if (dpyinfo
->display
!= 0)
9425 x_free_frame_resources (f
);
9427 dpyinfo
->reference_count
--;
9431 /* Setting window manager hints. */
9433 /* Set the normal size hints for the window manager, for frame F.
9434 FLAGS is the flags word to use--or 0 meaning preserve the flags
9435 that the window now has.
9436 If USER_POSITION is nonzero, we set the USPosition
9437 flag (this is useful when FLAGS is 0).
9438 The GTK version is in gtkutils.c */
9442 x_wm_set_size_hint (struct frame
*f
, long flags
, int user_position
)
9444 XSizeHints size_hints
;
9445 Window window
= FRAME_OUTER_WINDOW (f
);
9447 /* Setting PMaxSize caused various problems. */
9448 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
9450 size_hints
.x
= f
->left_pos
;
9451 size_hints
.y
= f
->top_pos
;
9453 size_hints
.height
= FRAME_PIXEL_HEIGHT (f
);
9454 size_hints
.width
= FRAME_PIXEL_WIDTH (f
);
9456 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
9457 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
9458 size_hints
.max_width
= x_display_pixel_width (FRAME_X_DISPLAY_INFO (f
))
9459 - FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9460 size_hints
.max_height
= x_display_pixel_height (FRAME_X_DISPLAY_INFO (f
))
9461 - FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9463 /* Calculate the base and minimum sizes. */
9465 int base_width
, base_height
;
9466 int min_rows
= 0, min_cols
= 0;
9468 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9469 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9471 check_frame_size (f
, &min_rows
, &min_cols
);
9473 /* The window manager uses the base width hints to calculate the
9474 current number of rows and columns in the frame while
9475 resizing; min_width and min_height aren't useful for this
9476 purpose, since they might not give the dimensions for a
9477 zero-row, zero-column frame.
9479 We use the base_width and base_height members if we have
9480 them; otherwise, we set the min_width and min_height members
9481 to the size for a zero x zero frame. */
9483 size_hints
.flags
|= PBaseSize
;
9484 size_hints
.base_width
= base_width
;
9485 size_hints
.base_height
= base_height
+ FRAME_MENUBAR_HEIGHT (f
);
9486 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
9487 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
9490 /* If we don't need the old flags, we don't need the old hint at all. */
9493 size_hints
.flags
|= flags
;
9498 XSizeHints hints
; /* Sometimes I hate X Windows... */
9499 long supplied_return
;
9502 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
9506 size_hints
.flags
|= flags
;
9511 if (hints
.flags
& PSize
)
9512 size_hints
.flags
|= PSize
;
9513 if (hints
.flags
& PPosition
)
9514 size_hints
.flags
|= PPosition
;
9515 if (hints
.flags
& USPosition
)
9516 size_hints
.flags
|= USPosition
;
9517 if (hints
.flags
& USSize
)
9518 size_hints
.flags
|= USSize
;
9525 size_hints
.win_gravity
= f
->win_gravity
;
9526 size_hints
.flags
|= PWinGravity
;
9530 size_hints
.flags
&= ~ PPosition
;
9531 size_hints
.flags
|= USPosition
;
9533 #endif /* PWinGravity */
9535 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
9537 #endif /* not USE_GTK */
9539 /* Used for IconicState or NormalState */
9542 x_wm_set_window_state (struct frame
*f
, int state
)
9544 #ifdef USE_X_TOOLKIT
9547 XtSetArg (al
[0], XtNinitialState
, state
);
9548 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9549 #else /* not USE_X_TOOLKIT */
9550 Window window
= FRAME_X_WINDOW (f
);
9552 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
9553 f
->output_data
.x
->wm_hints
.initial_state
= state
;
9555 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9556 #endif /* not USE_X_TOOLKIT */
9560 x_wm_set_icon_pixmap (struct frame
*f
, int pixmap_id
)
9562 Pixmap icon_pixmap
, icon_mask
;
9564 #if !defined USE_X_TOOLKIT && !defined USE_GTK
9565 Window window
= FRAME_OUTER_WINDOW (f
);
9570 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
9571 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
9572 icon_mask
= x_bitmap_mask (f
, pixmap_id
);
9573 f
->output_data
.x
->wm_hints
.icon_mask
= icon_mask
;
9577 /* It seems there is no way to turn off use of an icon
9585 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
);
9589 #elif defined (USE_X_TOOLKIT) /* same as in x_wm_set_window_state. */
9593 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
9594 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9595 XtSetArg (al
[0], XtNiconMask
, icon_mask
);
9596 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9599 #else /* not USE_X_TOOLKIT && not USE_GTK */
9601 f
->output_data
.x
->wm_hints
.flags
|= (IconPixmapHint
| IconMaskHint
);
9602 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9604 #endif /* not USE_X_TOOLKIT && not USE_GTK */
9608 x_wm_set_icon_position (struct frame
*f
, int icon_x
, int icon_y
)
9610 Window window
= FRAME_OUTER_WINDOW (f
);
9612 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
9613 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
9614 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
9616 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9620 /***********************************************************************
9622 ***********************************************************************/
9626 /* Check that FONT is valid on frame F. It is if it can be found in F's
9630 x_check_font (struct frame
*f
, struct font
*font
)
9634 xassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
9635 if (font
->driver
->check
)
9636 xassert (font
->driver
->check (f
, font
) == 0);
9639 #endif /* GLYPH_DEBUG != 0 */
9642 /***********************************************************************
9644 ***********************************************************************/
9646 #ifdef USE_X_TOOLKIT
9647 static XrmOptionDescRec emacs_options
[] = {
9648 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
9649 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
9651 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
9652 XrmoptionSepArg
, NULL
},
9653 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
9655 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9656 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9657 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9658 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
9659 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
9660 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
9661 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
9664 /* Whether atimer for Xt timeouts is activated or not. */
9666 static int x_timeout_atimer_activated_flag
;
9668 #endif /* USE_X_TOOLKIT */
9670 static int x_initialized
;
9673 static int x_session_initialized
;
9676 /* Test whether two display-name strings agree up to the dot that separates
9677 the screen number from the server number. */
9679 same_x_server (const char *name1
, const char *name2
)
9682 const unsigned char *system_name
= SDATA (Vsystem_name
);
9683 int system_name_length
= strlen (system_name
);
9684 int length_until_period
= 0;
9686 while (system_name
[length_until_period
] != 0
9687 && system_name
[length_until_period
] != '.')
9688 length_until_period
++;
9690 /* Treat `unix' like an empty host name. */
9691 if (! strncmp (name1
, "unix:", 5))
9693 if (! strncmp (name2
, "unix:", 5))
9695 /* Treat this host's name like an empty host name. */
9696 if (! strncmp (name1
, system_name
, system_name_length
)
9697 && name1
[system_name_length
] == ':')
9698 name1
+= system_name_length
;
9699 if (! strncmp (name2
, system_name
, system_name_length
)
9700 && name2
[system_name_length
] == ':')
9701 name2
+= system_name_length
;
9702 /* Treat this host's domainless name like an empty host name. */
9703 if (! strncmp (name1
, system_name
, length_until_period
)
9704 && name1
[length_until_period
] == ':')
9705 name1
+= length_until_period
;
9706 if (! strncmp (name2
, system_name
, length_until_period
)
9707 && name2
[length_until_period
] == ':')
9708 name2
+= length_until_period
;
9710 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
9714 if (seen_colon
&& *name1
== '.')
9718 && (*name1
== '.' || *name1
== '\0')
9719 && (*name2
== '.' || *name2
== '\0'));
9722 /* Count number of set bits in mask and number of bits to shift to
9723 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
9726 get_bits_and_offset (long unsigned int mask
, int *bits
, int *offset
)
9747 /* Return 1 if display DISPLAY is available for use, 0 otherwise.
9748 But don't permanently open it, just test its availability. */
9751 x_display_ok (const char *display
)
9756 dpy
= XOpenDisplay (display
);
9758 XCloseDisplay (dpy
);
9766 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
, const gchar
*message
, gpointer user_data
)
9768 if (!strstr (message
, "g_set_prgname"))
9769 fprintf (stderr
, "%s-WARNING **: %s\n", log_domain
, message
);
9773 /* Open a connection to X display DISPLAY_NAME, and return
9774 the structure that describes the open display.
9775 If we cannot contact the display, return null. */
9777 struct x_display_info
*
9778 x_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
9782 struct terminal
*terminal
;
9783 struct x_display_info
*dpyinfo
;
9794 if (! x_display_ok (SDATA (display_name
)))
9795 error ("Display %s can't be opened", SDATA (display_name
));
9801 char *argv
[NUM_ARGV
];
9802 char **argv2
= argv
;
9805 if (x_initialized
++ > 1)
9807 xg_display_open (SDATA (display_name
), &dpy
);
9811 static char display_opt
[] = "--display";
9812 static char name_opt
[] = "--name";
9814 for (argc
= 0; argc
< NUM_ARGV
; ++argc
)
9818 argv
[argc
++] = initial_argv
[0];
9820 if (! NILP (display_name
))
9822 argv
[argc
++] = display_opt
;
9823 argv
[argc
++] = SDATA (display_name
);
9826 argv
[argc
++] = name_opt
;
9827 argv
[argc
++] = resource_name
;
9829 XSetLocaleModifiers ("");
9831 /* Work around GLib bug that outputs a faulty warning. See
9832 https://bugzilla.gnome.org/show_bug.cgi?id=563627. */
9833 id
= g_log_set_handler ("GLib", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
9834 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
9835 gtk_init (&argc
, &argv2
);
9836 g_log_remove_handler ("GLib", id
);
9838 /* gtk_init does set_locale. We must fix locale after calling it. */
9842 dpy
= GDK_DISPLAY ();
9844 /* NULL window -> events for all windows go to our function */
9845 gdk_window_add_filter (NULL
, event_handler_gdk
, NULL
);
9847 /* Load our own gtkrc if it exists. */
9849 const char *file
= "~/.emacs.d/gtkrc";
9850 Lisp_Object s
, abs_file
;
9852 s
= make_string (file
, strlen (file
));
9853 abs_file
= Fexpand_file_name (s
, Qnil
);
9855 if (! NILP (abs_file
) && !NILP (Ffile_readable_p (abs_file
)))
9856 gtk_rc_parse (SDATA (abs_file
));
9859 XSetErrorHandler (x_error_handler
);
9860 XSetIOErrorHandler (x_io_error_quitter
);
9863 #else /* not USE_GTK */
9864 #ifdef USE_X_TOOLKIT
9865 /* weiner@footloose.sps.mot.com reports that this causes
9867 X protocol error: BadAtom (invalid Atom parameter)
9868 on protocol request 18skiloaf.
9869 So let's not use it until R6. */
9871 XtSetLanguageProc (NULL
, NULL
, NULL
);
9882 argv
[argc
++] = "-xrm";
9883 argv
[argc
++] = xrm_option
;
9885 turn_on_atimers (0);
9886 dpy
= XtOpenDisplay (Xt_app_con
, SDATA (display_name
),
9887 resource_name
, EMACS_CLASS
,
9888 emacs_options
, XtNumber (emacs_options
),
9890 turn_on_atimers (1);
9893 /* I think this is to compensate for XtSetLanguageProc. */
9898 #else /* not USE_X_TOOLKIT */
9899 XSetLocaleModifiers ("");
9900 dpy
= XOpenDisplay (SDATA (display_name
));
9901 #endif /* not USE_X_TOOLKIT */
9902 #endif /* not USE_GTK*/
9904 /* Detect failure. */
9911 /* We have definitely succeeded. Record the new connection. */
9913 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
9914 memset (dpyinfo
, 0, sizeof *dpyinfo
);
9916 terminal
= x_create_terminal (dpyinfo
);
9919 struct x_display_info
*share
;
9922 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
9923 share
= share
->next
, tail
= XCDR (tail
))
9924 if (same_x_server (SDATA (XCAR (XCAR (tail
))),
9925 SDATA (display_name
)))
9928 terminal
->kboard
= share
->terminal
->kboard
;
9931 terminal
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
9932 init_kboard (terminal
->kboard
);
9933 terminal
->kboard
->Vwindow_system
= Qx
;
9935 /* Add the keyboard to the list before running Lisp code (via
9936 Qvendor_specific_keysyms below), since these are not traced
9937 via terminals but only through all_kboards. */
9938 terminal
->kboard
->next_kboard
= all_kboards
;
9939 all_kboards
= terminal
->kboard
;
9941 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
9943 char *vendor
= ServerVendor (dpy
);
9945 /* Protect terminal from GC before removing it from the
9946 list of terminals. */
9947 struct gcpro gcpro1
;
9948 Lisp_Object gcpro_term
;
9949 XSETTERMINAL (gcpro_term
, terminal
);
9950 GCPRO1 (gcpro_term
);
9952 /* Temporarily hide the partially initialized terminal. */
9953 terminal_list
= terminal
->next_terminal
;
9955 terminal
->kboard
->Vsystem_key_alist
9956 = call1 (Qvendor_specific_keysyms
,
9957 vendor
? build_string (vendor
) : empty_unibyte_string
);
9959 terminal
->next_terminal
= terminal_list
;
9960 terminal_list
= terminal
;
9964 /* Don't let the initial kboard remain current longer than necessary.
9965 That would cause problems if a file loaded on startup tries to
9966 prompt in the mini-buffer. */
9967 if (current_kboard
== initial_kboard
)
9968 current_kboard
= terminal
->kboard
;
9970 terminal
->kboard
->reference_count
++;
9973 /* Put this display on the chain. */
9974 dpyinfo
->next
= x_display_list
;
9975 x_display_list
= dpyinfo
;
9977 /* Put it on x_display_name_list as well, to keep them parallel. */
9978 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
9979 x_display_name_list
);
9980 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
9982 dpyinfo
->display
= dpy
;
9984 /* Set the name of the terminal. */
9985 terminal
->name
= (char *) xmalloc (SBYTES (display_name
) + 1);
9986 strncpy (terminal
->name
, SDATA (display_name
), SBYTES (display_name
));
9987 terminal
->name
[SBYTES (display_name
)] = 0;
9990 XSetAfterFunction (x_current_display
, x_trace_wire
);
9994 = (char *) xmalloc (SBYTES (Vinvocation_name
)
9995 + SBYTES (Vsystem_name
)
9997 sprintf (dpyinfo
->x_id_name
, "%s@%s",
9998 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
10000 /* Figure out which modifier bits mean what. */
10001 x_find_modifier_meanings (dpyinfo
);
10003 /* Get the scroll bar cursor. */
10005 /* We must create a GTK cursor, it is required for GTK widgets. */
10006 dpyinfo
->xg_cursor
= xg_create_default_cursor (dpyinfo
->display
);
10007 #endif /* USE_GTK */
10009 dpyinfo
->vertical_scroll_bar_cursor
10010 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
10012 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
10013 resource_name
, EMACS_CLASS
);
10014 #ifdef HAVE_XRMSETDATABASE
10015 XrmSetDatabase (dpyinfo
->display
, xrdb
);
10017 dpyinfo
->display
->db
= xrdb
;
10019 /* Put the rdb where we can find it in a way that works on
10021 dpyinfo
->xrdb
= xrdb
;
10023 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
10024 DefaultScreen (dpyinfo
->display
));
10025 select_visual (dpyinfo
);
10026 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
10027 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
10028 dpyinfo
->client_leader_window
= 0;
10029 dpyinfo
->grabbed
= 0;
10030 dpyinfo
->reference_count
= 0;
10031 dpyinfo
->icon_bitmap_id
= -1;
10032 dpyinfo
->n_fonts
= 0;
10033 dpyinfo
->bitmaps
= 0;
10034 dpyinfo
->bitmaps_size
= 0;
10035 dpyinfo
->bitmaps_last
= 0;
10036 dpyinfo
->scratch_cursor_gc
= 0;
10037 dpyinfo
->mouse_face_mouse_frame
= 0;
10038 dpyinfo
->mouse_face_deferred_gc
= 0;
10039 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
10040 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
10041 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
10042 dpyinfo
->mouse_face_window
= Qnil
;
10043 dpyinfo
->mouse_face_overlay
= Qnil
;
10044 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
10045 dpyinfo
->mouse_face_defer
= 0;
10046 dpyinfo
->mouse_face_hidden
= 0;
10047 dpyinfo
->x_focus_frame
= 0;
10048 dpyinfo
->x_focus_event_frame
= 0;
10049 dpyinfo
->x_highlight_frame
= 0;
10050 dpyinfo
->wm_type
= X_WMTYPE_UNKNOWN
;
10052 /* See if we can construct pixel values from RGB values. */
10053 dpyinfo
->red_bits
= dpyinfo
->blue_bits
= dpyinfo
->green_bits
= 0;
10054 dpyinfo
->red_offset
= dpyinfo
->blue_offset
= dpyinfo
->green_offset
= 0;
10056 if (dpyinfo
->visual
->class == TrueColor
)
10058 get_bits_and_offset (dpyinfo
->visual
->red_mask
,
10059 &dpyinfo
->red_bits
, &dpyinfo
->red_offset
);
10060 get_bits_and_offset (dpyinfo
->visual
->blue_mask
,
10061 &dpyinfo
->blue_bits
, &dpyinfo
->blue_offset
);
10062 get_bits_and_offset (dpyinfo
->visual
->green_mask
,
10063 &dpyinfo
->green_bits
, &dpyinfo
->green_offset
);
10066 /* See if a private colormap is requested. */
10067 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
10069 if (dpyinfo
->visual
->class == PseudoColor
)
10072 value
= display_x_get_resource (dpyinfo
,
10073 build_string ("privateColormap"),
10074 build_string ("PrivateColormap"),
10076 if (STRINGP (value
)
10077 && (!strcmp (SDATA (value
), "true")
10078 || !strcmp (SDATA (value
), "on")))
10079 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
10083 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
10084 dpyinfo
->visual
, AllocNone
);
10088 /* If we are using Xft, check dpi value in X resources.
10089 It is better we use it as well, since Xft will use it, as will all
10090 Gnome applications. If our real DPI is smaller or larger than the
10091 one Xft uses, our font will look smaller or larger than other
10092 for other applications, even if it is the same font name (monospace-10
10094 char *v
= XGetDefault (dpyinfo
->display
, "Xft", "dpi");
10096 if (v
!= NULL
&& sscanf (v
, "%lf", &d
) == 1)
10097 dpyinfo
->resy
= dpyinfo
->resx
= d
;
10101 if (dpyinfo
->resy
< 1)
10103 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
10104 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
10105 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
10106 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10107 dpyinfo
->resy
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10108 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
10109 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
10110 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10111 dpyinfo
->resx
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10114 dpyinfo
->Xatom_wm_protocols
10115 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
10116 dpyinfo
->Xatom_wm_take_focus
10117 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
10118 dpyinfo
->Xatom_wm_save_yourself
10119 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
10120 dpyinfo
->Xatom_wm_delete_window
10121 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
10122 dpyinfo
->Xatom_wm_change_state
10123 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
10124 dpyinfo
->Xatom_wm_configure_denied
10125 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
10126 dpyinfo
->Xatom_wm_window_moved
10127 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
10128 dpyinfo
->Xatom_wm_client_leader
10129 = XInternAtom (dpyinfo
->display
, "WM_CLIENT_LEADER", False
);
10130 dpyinfo
->Xatom_editres
10131 = XInternAtom (dpyinfo
->display
, "Editres", False
);
10132 dpyinfo
->Xatom_CLIPBOARD
10133 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
10134 dpyinfo
->Xatom_TIMESTAMP
10135 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
10136 dpyinfo
->Xatom_TEXT
10137 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
10138 dpyinfo
->Xatom_COMPOUND_TEXT
10139 = XInternAtom (dpyinfo
->display
, "COMPOUND_TEXT", False
);
10140 dpyinfo
->Xatom_UTF8_STRING
10141 = XInternAtom (dpyinfo
->display
, "UTF8_STRING", False
);
10142 dpyinfo
->Xatom_DELETE
10143 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
10144 dpyinfo
->Xatom_MULTIPLE
10145 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
10146 dpyinfo
->Xatom_INCR
10147 = XInternAtom (dpyinfo
->display
, "INCR", False
);
10148 dpyinfo
->Xatom_EMACS_TMP
10149 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
10150 dpyinfo
->Xatom_TARGETS
10151 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
10152 dpyinfo
->Xatom_NULL
10153 = XInternAtom (dpyinfo
->display
, "NULL", False
);
10154 dpyinfo
->Xatom_ATOM_PAIR
10155 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
10156 /* For properties of font. */
10157 dpyinfo
->Xatom_PIXEL_SIZE
10158 = XInternAtom (dpyinfo
->display
, "PIXEL_SIZE", False
);
10159 dpyinfo
->Xatom_AVERAGE_WIDTH
10160 = XInternAtom (dpyinfo
->display
, "AVERAGE_WIDTH", False
);
10161 dpyinfo
->Xatom_MULE_BASELINE_OFFSET
10162 = XInternAtom (dpyinfo
->display
, "_MULE_BASELINE_OFFSET", False
);
10163 dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
10164 = XInternAtom (dpyinfo
->display
, "_MULE_RELATIVE_COMPOSE", False
);
10165 dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
10166 = XInternAtom (dpyinfo
->display
, "_MULE_DEFAULT_ASCENT", False
);
10168 /* Ghostscript support. */
10169 dpyinfo
->Xatom_PAGE
= XInternAtom (dpyinfo
->display
, "PAGE", False
);
10170 dpyinfo
->Xatom_DONE
= XInternAtom (dpyinfo
->display
, "DONE", False
);
10172 dpyinfo
->Xatom_Scrollbar
= XInternAtom (dpyinfo
->display
, "SCROLLBAR",
10175 dpyinfo
->Xatom_XEMBED
= XInternAtom (dpyinfo
->display
, "_XEMBED",
10178 dpyinfo
->Xatom_net_wm_state
10179 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE", False
);
10180 dpyinfo
->Xatom_net_wm_state_fullscreen_atom
10181 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE_FULLSCREEN", False
);
10182 dpyinfo
->Xatom_net_wm_state_maximized_horz
10183 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE_MAXIMIZED_HORZ", False
);
10184 dpyinfo
->Xatom_net_wm_state_maximized_vert
10185 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE_MAXIMIZED_VERT", False
);
10186 dpyinfo
->Xatom_net_wm_state_sticky
10187 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE_STICKY", False
);
10188 dpyinfo
->Xatom_net_window_type
10189 = XInternAtom (dpyinfo
->display
, "_NET_WM_WINDOW_TYPE", False
);
10190 dpyinfo
->Xatom_net_window_type_tooltip
10191 = XInternAtom (dpyinfo
->display
, "_NET_WM_WINDOW_TYPE_TOOLTIP", False
);
10192 dpyinfo
->Xatom_net_wm_icon_name
10193 = XInternAtom (dpyinfo
->display
, "_NET_WM_ICON_NAME", False
);
10194 dpyinfo
->Xatom_net_wm_name
10195 = XInternAtom (dpyinfo
->display
, "_NET_WM_NAME", False
);
10197 dpyinfo
->x_dnd_atoms_size
= 8;
10198 dpyinfo
->x_dnd_atoms_length
= 0;
10199 dpyinfo
->x_dnd_atoms
= xmalloc (sizeof (*dpyinfo
->x_dnd_atoms
)
10200 * dpyinfo
->x_dnd_atoms_size
);
10202 dpyinfo
->net_supported_atoms
= NULL
;
10203 dpyinfo
->nr_net_supported_atoms
= 0;
10204 dpyinfo
->net_supported_window
= 0;
10206 connection
= ConnectionNumber (dpyinfo
->display
);
10207 dpyinfo
->connection
= connection
;
10211 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
10213 gray_bitmap_width
, gray_bitmap_height
,
10214 (unsigned long) 1, (unsigned long) 0, 1);
10218 xim_initialize (dpyinfo
, resource_name
);
10221 xsettings_initialize (dpyinfo
);
10223 /* This is only needed for distinguishing keyboard and process input. */
10224 if (connection
!= 0)
10225 add_keyboard_wait_descriptor (connection
);
10228 fcntl (connection
, F_SETOWN
, getpid ());
10229 #endif /* ! defined (F_SETOWN) */
10232 if (interrupt_input
)
10233 init_sigio (connection
);
10234 #endif /* ! defined (SIGIO) */
10238 Display
*dpy
= dpyinfo
->display
;
10239 XrmValue d
, fr
, to
;
10242 d
.addr
= (XPointer
)&dpy
;
10243 d
.size
= sizeof (Display
*);
10244 fr
.addr
= XtDefaultFont
;
10245 fr
.size
= sizeof (XtDefaultFont
);
10246 to
.size
= sizeof (Font
*);
10247 to
.addr
= (XPointer
)&font
;
10248 x_catch_errors (dpy
);
10249 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
10251 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
10252 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
10253 x_uncatch_errors ();
10257 /* See if we should run in synchronous mode. This is useful
10258 for debugging X code. */
10261 value
= display_x_get_resource (dpyinfo
,
10262 build_string ("synchronous"),
10263 build_string ("Synchronous"),
10265 if (STRINGP (value
)
10266 && (!strcmp (SDATA (value
), "true")
10267 || !strcmp (SDATA (value
), "on")))
10268 XSynchronize (dpyinfo
->display
, True
);
10273 value
= display_x_get_resource (dpyinfo
,
10274 build_string ("useXIM"),
10275 build_string ("UseXIM"),
10278 if (STRINGP (value
)
10279 && (!strcmp (SDATA (value
), "false")
10280 || !strcmp (SDATA (value
), "off")))
10283 if (STRINGP (value
)
10284 && (!strcmp (SDATA (value
), "true")
10285 || !strcmp (SDATA (value
), "on")))
10291 /* Only do this for the very first display in the Emacs session.
10292 Ignore X session management when Emacs was first started on a
10294 if (terminal
->id
== 1)
10295 x_session_initialize (dpyinfo
);
10303 /* Get rid of display DPYINFO, deleting all frames on it,
10304 and without sending any more commands to the X server. */
10307 x_delete_display (struct x_display_info
*dpyinfo
)
10309 struct terminal
*t
;
10311 /* Close all frames and delete the generic struct terminal for this
10313 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
10314 if (t
->type
== output_x_window
&& t
->display_info
.x
== dpyinfo
)
10317 /* Close X session management when we close its display. */
10318 if (t
->id
== 1 && x_session_have_connection ())
10319 x_session_close ();
10321 delete_terminal (t
);
10325 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
10327 /* Discard this display from x_display_name_list and x_display_list.
10328 We can't use Fdelq because that can quit. */
10329 if (! NILP (x_display_name_list
)
10330 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
10331 x_display_name_list
= XCDR (x_display_name_list
);
10336 tail
= x_display_name_list
;
10337 while (CONSP (tail
) && CONSP (XCDR (tail
)))
10339 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
10341 XSETCDR (tail
, XCDR (XCDR (tail
)));
10344 tail
= XCDR (tail
);
10348 if (next_noop_dpyinfo
== dpyinfo
)
10349 next_noop_dpyinfo
= dpyinfo
->next
;
10351 if (x_display_list
== dpyinfo
)
10352 x_display_list
= dpyinfo
->next
;
10355 struct x_display_info
*tail
;
10357 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
10358 if (tail
->next
== dpyinfo
)
10359 tail
->next
= tail
->next
->next
;
10362 xfree (dpyinfo
->x_id_name
);
10363 xfree (dpyinfo
->x_dnd_atoms
);
10364 xfree (dpyinfo
->color_cells
);
10368 #ifdef USE_X_TOOLKIT
10370 /* Atimer callback function for TIMER. Called every 0.1s to process
10371 Xt timeouts, if needed. We must avoid calling XtAppPending as
10372 much as possible because that function does an implicit XFlush
10373 that slows us down. */
10376 x_process_timeouts (struct atimer
*timer
)
10379 x_timeout_atimer_activated_flag
= 0;
10380 if (toolkit_scroll_bar_interaction
|| popup_activated ())
10382 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
10383 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
10384 /* Reactivate the atimer for next time. */
10385 x_activate_timeout_atimer ();
10390 /* Install an asynchronous timer that processes Xt timeout events
10391 every 0.1s as long as either `toolkit_scroll_bar_interaction' or
10392 `popup_activated_flag' (in xmenu.c) is set. Make sure to call this
10393 function whenever these variables are set. This is necessary
10394 because some widget sets use timeouts internally, for example the
10395 LessTif menu bar, or the Xaw3d scroll bar. When Xt timeouts aren't
10396 processed, these widgets don't behave normally. */
10399 x_activate_timeout_atimer (void)
10402 if (!x_timeout_atimer_activated_flag
)
10404 EMACS_TIME interval
;
10406 EMACS_SET_SECS_USECS (interval
, 0, 100000);
10407 start_atimer (ATIMER_RELATIVE
, interval
, x_process_timeouts
, 0);
10408 x_timeout_atimer_activated_flag
= 1;
10413 #endif /* USE_X_TOOLKIT */
10416 /* Set up use of X before we make the first connection. */
10418 extern frame_parm_handler x_frame_parm_handlers
[];
10420 static struct redisplay_interface x_redisplay_interface
=
10422 x_frame_parm_handlers
,
10426 x_clear_end_of_line
,
10428 x_after_update_window_line
,
10429 x_update_window_begin
,
10430 x_update_window_end
,
10436 0, /* flush_display_optional */
10438 x_clear_window_mouse_face
,
10439 x_get_glyph_overhangs
,
10440 x_fix_overlapping_area
,
10441 x_draw_fringe_bitmap
,
10442 0, /* define_fringe_bitmap */
10443 0, /* destroy_fringe_bitmap */
10444 x_compute_glyph_string_overhangs
,
10445 x_draw_glyph_string
,
10446 x_define_frame_cursor
,
10447 x_clear_frame_area
,
10448 x_draw_window_cursor
,
10449 x_draw_vertical_window_border
,
10450 x_shift_glyphs_for_insert
10454 /* This function is called when the last frame on a display is deleted. */
10456 x_delete_terminal (struct terminal
*terminal
)
10458 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
10460 /* Protect against recursive calls. delete_frame in
10461 delete_terminal calls us back when it deletes our last frame. */
10462 if (!terminal
->name
)
10467 /* We must close our connection to the XIM server before closing the
10470 xim_close_dpy (dpyinfo
);
10473 /* If called from x_connection_closed, the display may already be closed
10474 and dpyinfo->display was set to 0 to indicate that. */
10475 if (dpyinfo
->display
)
10477 x_destroy_all_bitmaps (dpyinfo
);
10478 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
10480 /* Whether or not XCloseDisplay destroys the associated resource
10481 database depends on the version of libX11. To avoid both
10482 crash and memory leak, we dissociate the database from the
10483 display and then destroy dpyinfo->xrdb ourselves.
10485 Unfortunately, the above strategy does not work in some
10486 situations due to a bug in newer versions of libX11: because
10487 XrmSetDatabase doesn't clear the flag XlibDisplayDfltRMDB if
10488 dpy->db is NULL, XCloseDisplay destroys the associated
10489 database whereas it has not been created by XGetDefault
10490 (Bug#21974 in freedesktop.org Bugzilla). As a workaround, we
10491 don't destroy the database here in order to avoid the crash
10492 in the above situations for now, though that may cause memory
10493 leaks in other situations. */
10495 #ifdef HAVE_XRMSETDATABASE
10496 XrmSetDatabase (dpyinfo
->display
, NULL
);
10498 dpyinfo
->display
->db
= NULL
;
10500 /* We used to call XrmDestroyDatabase from x_delete_display, but
10501 some older versions of libX11 crash if we call it after
10502 closing all the displays. */
10503 XrmDestroyDatabase (dpyinfo
->xrdb
);
10507 xg_display_close (dpyinfo
->display
);
10509 #ifdef USE_X_TOOLKIT
10510 XtCloseDisplay (dpyinfo
->display
);
10512 XCloseDisplay (dpyinfo
->display
);
10514 #endif /* ! USE_GTK */
10517 /* Mark as dead. */
10518 dpyinfo
->display
= NULL
;
10519 x_delete_display (dpyinfo
);
10523 /* Create a struct terminal, initialize it with the X11 specific
10524 functions and make DISPLAY->TERMINAL point to it. */
10526 static struct terminal
*
10527 x_create_terminal (struct x_display_info
*dpyinfo
)
10529 struct terminal
*terminal
;
10531 terminal
= create_terminal ();
10533 terminal
->type
= output_x_window
;
10534 terminal
->display_info
.x
= dpyinfo
;
10535 dpyinfo
->terminal
= terminal
;
10537 /* kboard is initialized in x_term_init. */
10539 terminal
->clear_frame_hook
= x_clear_frame
;
10540 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
10541 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
10542 terminal
->ring_bell_hook
= XTring_bell
;
10543 terminal
->toggle_invisible_pointer_hook
= XTtoggle_invisible_pointer
;
10544 terminal
->reset_terminal_modes_hook
= XTreset_terminal_modes
;
10545 terminal
->set_terminal_modes_hook
= XTset_terminal_modes
;
10546 terminal
->update_begin_hook
= x_update_begin
;
10547 terminal
->update_end_hook
= x_update_end
;
10548 terminal
->set_terminal_window_hook
= XTset_terminal_window
;
10549 terminal
->read_socket_hook
= XTread_socket
;
10550 terminal
->frame_up_to_date_hook
= XTframe_up_to_date
;
10551 terminal
->mouse_position_hook
= XTmouse_position
;
10552 terminal
->frame_rehighlight_hook
= XTframe_rehighlight
;
10553 terminal
->frame_raise_lower_hook
= XTframe_raise_lower
;
10554 terminal
->fullscreen_hook
= XTfullscreen_hook
;
10555 terminal
->set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
10556 terminal
->condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
10557 terminal
->redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
10558 terminal
->judge_scroll_bars_hook
= XTjudge_scroll_bars
;
10560 terminal
->delete_frame_hook
= x_destroy_window
;
10561 terminal
->delete_terminal_hook
= x_delete_terminal
;
10563 terminal
->rif
= &x_redisplay_interface
;
10564 terminal
->scroll_region_ok
= 1; /* We'll scroll partial frames. */
10565 terminal
->char_ins_del_ok
= 1;
10566 terminal
->line_ins_del_ok
= 1; /* We'll just blt 'em. */
10567 terminal
->fast_clear_end_of_line
= 1; /* X does this well. */
10568 terminal
->memory_below_frame
= 0; /* We don't remember what scrolls
10575 x_initialize (void)
10580 last_tool_bar_item
= -1;
10581 any_help_event_p
= 0;
10582 ignore_next_mouse_click_timeout
= 0;
10584 x_session_initialized
= 0;
10588 current_count
= -1;
10591 /* Try to use interrupt input; if we can't, then start polling. */
10592 Fset_input_interrupt_mode (Qt
);
10594 #ifdef USE_X_TOOLKIT
10595 XtToolkitInitialize ();
10597 Xt_app_con
= XtCreateApplicationContext ();
10599 /* Register a converter from strings to pixels, which uses
10600 Emacs' color allocation infrastructure. */
10601 XtAppSetTypeConverter (Xt_app_con
,
10602 XtRString
, XtRPixel
, cvt_string_to_pixel
,
10603 cvt_string_to_pixel_args
,
10604 XtNumber (cvt_string_to_pixel_args
),
10605 XtCacheByDisplay
, cvt_pixel_dtor
);
10607 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
10610 #ifdef USE_TOOLKIT_SCROLL_BARS
10612 xaw3d_arrow_scroll
= False
;
10613 xaw3d_pick_top
= True
;
10617 pending_autoraise_frame
= 0;
10618 pending_event_wait
.f
= 0;
10619 pending_event_wait
.eventtype
= 0;
10621 /* Note that there is no real way portable across R3/R4 to get the
10622 original error handler. */
10623 XSetErrorHandler (x_error_handler
);
10624 XSetIOErrorHandler (x_io_error_quitter
);
10626 signal (SIGPIPE
, x_connection_signal
);
10628 xgselect_initialize ();
10633 syms_of_xterm (void)
10635 x_error_message
= NULL
;
10637 staticpro (&x_display_name_list
);
10638 x_display_name_list
= Qnil
;
10640 staticpro (&last_mouse_scroll_bar
);
10641 last_mouse_scroll_bar
= Qnil
;
10643 staticpro (&Qvendor_specific_keysyms
);
10644 Qvendor_specific_keysyms
= intern_c_string ("vendor-specific-keysyms");
10646 staticpro (&Qlatin_1
);
10647 Qlatin_1
= intern_c_string ("latin-1");
10649 staticpro (&last_mouse_press_frame
);
10650 last_mouse_press_frame
= Qnil
;
10653 xg_default_icon_file
= make_pure_c_string ("icons/hicolor/scalable/apps/emacs.svg");
10654 staticpro (&xg_default_icon_file
);
10656 Qx_gtk_map_stock
= intern_c_string ("x-gtk-map-stock");
10657 staticpro (&Qx_gtk_map_stock
);
10660 DEFVAR_BOOL ("x-use-underline-position-properties",
10661 &x_use_underline_position_properties
,
10662 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
10663 A value of nil means ignore them. If you encounter fonts with bogus
10664 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
10665 to 4.1, set this to nil. You can also use `underline-minimum-offset'
10666 to override the font's UNDERLINE_POSITION for small font display
10668 x_use_underline_position_properties
= 1;
10670 DEFVAR_BOOL ("x-underline-at-descent-line",
10671 &x_underline_at_descent_line
,
10672 doc
: /* *Non-nil means to draw the underline at the same place as the descent line.
10673 A value of nil means to draw the underline according to the value of the
10674 variable `x-use-underline-position-properties', which is usually at the
10675 baseline level. The default value is nil. */);
10676 x_underline_at_descent_line
= 0;
10678 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
10679 &x_mouse_click_focus_ignore_position
,
10680 doc
: /* Non-nil means that a mouse click to focus a frame does not move point.
10681 This variable is only used when the window manager requires that you
10682 click on a frame to select it (give it focus). In that case, a value
10683 of nil, means that the selected window and cursor position changes to
10684 reflect the mouse click position, while a non-nil value means that the
10685 selected window or cursor position is preserved. */);
10686 x_mouse_click_focus_ignore_position
= 0;
10688 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
10689 doc
: /* Which toolkit scroll bars Emacs uses, if any.
10690 A value of nil means Emacs doesn't use toolkit scroll bars.
10691 With the X Window system, the value is a symbol describing the
10692 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
10693 With MS Windows, the value is t. */);
10694 #ifdef USE_TOOLKIT_SCROLL_BARS
10696 Vx_toolkit_scroll_bars
= intern_c_string ("motif");
10697 #elif defined HAVE_XAW3D
10698 Vx_toolkit_scroll_bars
= intern_c_string ("xaw3d");
10700 Vx_toolkit_scroll_bars
= intern_c_string ("gtk");
10702 Vx_toolkit_scroll_bars
= intern_c_string ("xaw");
10705 Vx_toolkit_scroll_bars
= Qnil
;
10708 staticpro (&last_mouse_motion_frame
);
10709 last_mouse_motion_frame
= Qnil
;
10711 Qmodifier_value
= intern_c_string ("modifier-value");
10712 Qalt
= intern_c_string ("alt");
10713 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
10714 Qhyper
= intern_c_string ("hyper");
10715 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
10716 Qmeta
= intern_c_string ("meta");
10717 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
10718 Qsuper
= intern_c_string ("super");
10719 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
10721 DEFVAR_LISP ("x-alt-keysym", &Vx_alt_keysym
,
10722 doc
: /* Which keys Emacs uses for the alt modifier.
10723 This should be one of the symbols `alt', `hyper', `meta', `super'.
10724 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
10725 is nil, which is the same as `alt'. */);
10726 Vx_alt_keysym
= Qnil
;
10728 DEFVAR_LISP ("x-hyper-keysym", &Vx_hyper_keysym
,
10729 doc
: /* Which keys Emacs uses for the hyper modifier.
10730 This should be one of the symbols `alt', `hyper', `meta', `super'.
10731 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
10732 default is nil, which is the same as `hyper'. */);
10733 Vx_hyper_keysym
= Qnil
;
10735 DEFVAR_LISP ("x-meta-keysym", &Vx_meta_keysym
,
10736 doc
: /* Which keys Emacs uses for the meta modifier.
10737 This should be one of the symbols `alt', `hyper', `meta', `super'.
10738 For example, `meta' means use the Meta_L and Meta_R keysyms. The
10739 default is nil, which is the same as `meta'. */);
10740 Vx_meta_keysym
= Qnil
;
10742 DEFVAR_LISP ("x-super-keysym", &Vx_super_keysym
,
10743 doc
: /* Which keys Emacs uses for the super modifier.
10744 This should be one of the symbols `alt', `hyper', `meta', `super'.
10745 For example, `super' means use the Super_L and Super_R keysyms. The
10746 default is nil, which is the same as `super'. */);
10747 Vx_super_keysym
= Qnil
;
10749 DEFVAR_LISP ("x-keysym-table", &Vx_keysym_table
,
10750 doc
: /* Hash table of character codes indexed by X keysym codes. */);
10751 Vx_keysym_table
= make_hash_table (Qeql
, make_number (900),
10752 make_float (DEFAULT_REHASH_SIZE
),
10753 make_float (DEFAULT_REHASH_THRESHOLD
),
10757 #endif /* HAVE_X_WINDOWS */