1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 /* New display code by Gerd Moellmann <gerd@gnu.org>. */
22 /* Xt features made by Fred Pierresteguy. */
26 /* On 4.3 these lose if they come after xterm.h. */
27 /* Putting these at the beginning seems to be standard for other .c files. */
36 #include "blockinput.h"
38 /* Need syssignal.h for various externs and definitions that may be required
39 by some configurations for calls to signal later in this source file. */
40 #include "syssignal.h"
42 /* This may include sys/types.h, and that somehow loses
43 if this is not done before the other system files. */
45 #include <X11/cursorfont.h>
47 /* Load sys/types.h if not already loaded.
48 In some systems loading it twice is suicidal. */
50 #include <sys/types.h>
53 #ifdef HAVE_SYS_IOCTL_H
54 #include <sys/ioctl.h>
55 #endif /* ! defined (HAVE_SYS_IOCTL_H) */
64 /* Caused redefinition of DBL_DIG on Netbsd; seems not to be needed. */
65 /* #include <sys/param.h> */
68 #include "character.h"
71 #include "dispextern.h"
73 #include "termhooks.h"
76 #include "emacs-icon.h"
81 #include "intervals.h"
87 #include "xsettings.h"
89 #include "sysselect.h"
92 #include <X11/Shell.h>
95 #ifdef HAVE_SYS_TIME_H
107 extern int xlwmenu_window_p (Widget w
, Window window
);
108 extern void xlwmenu_redisplay (Widget
);
111 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
113 extern void free_frame_menubar (struct frame
*);
117 #if !defined(NO_EDITRES)
119 extern void _XEditResCheckMessages ();
120 #endif /* not NO_EDITRES */
122 /* Include toolkit specific headers for the scroll bar widget. */
124 #ifdef USE_TOOLKIT_SCROLL_BARS
125 #if defined USE_MOTIF
126 #include <Xm/Xm.h> /* for LESSTIF_VERSION */
127 #include <Xm/ScrollBar.h>
128 #else /* !USE_MOTIF i.e. use Xaw */
131 #include <X11/Xaw3d/Simple.h>
132 #include <X11/Xaw3d/Scrollbar.h>
133 #include <X11/Xaw3d/ThreeD.h>
134 #else /* !HAVE_XAW3D */
135 #include <X11/Xaw/Simple.h>
136 #include <X11/Xaw/Scrollbar.h>
137 #endif /* !HAVE_XAW3D */
139 #define XtNpickTop "pickTop"
140 #endif /* !XtNpickTop */
141 #endif /* !USE_MOTIF */
142 #endif /* USE_TOOLKIT_SCROLL_BARS */
144 #endif /* USE_X_TOOLKIT */
148 #ifndef XtNinitialState
149 #define XtNinitialState "initialState"
153 /* Default to using XIM if available. */
157 int use_xim
= 0; /* configure --without-xim */
162 /* Non-nil means Emacs uses toolkit scroll bars. */
164 Lisp_Object Vx_toolkit_scroll_bars
;
166 /* Non-zero means that a HELP_EVENT has been generated since Emacs
169 static int any_help_event_p
;
171 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
172 static Lisp_Object last_window
;
174 /* Non-zero means make use of UNDERLINE_POSITION font properties. */
176 int x_use_underline_position_properties
;
178 /* Non-zero means to draw the underline at the same place as the descent line. */
180 int x_underline_at_descent_line
;
182 /* This is a chain of structures for all the X displays currently in
185 struct x_display_info
*x_display_list
;
187 /* This is a list of cons cells, each of the form (NAME
188 . FONT-LIST-CACHE), one for each element of x_display_list and in
189 the same order. NAME is the name of the frame. FONT-LIST-CACHE
190 records previous values returned by x-list-fonts. */
192 Lisp_Object x_display_name_list
;
194 /* Frame being updated by update_frame. This is declared in term.c.
195 This is set by update_begin and looked at by all the XT functions.
196 It is zero while not inside an update. In that case, the XT
197 functions assume that `selected_frame' is the frame to apply to. */
199 extern struct frame
*updating_frame
;
201 /* This is a frame waiting to be auto-raised, within XTread_socket. */
203 static struct frame
*pending_autoraise_frame
;
205 /* This is a frame waiting for an event matching mask, within XTread_socket. */
210 } pending_event_wait
;
213 /* The application context for Xt use. */
214 XtAppContext Xt_app_con
;
215 static String Xt_default_resources
[] = {0};
216 #endif /* USE_X_TOOLKIT */
218 /* Non-zero means user is interacting with a toolkit scroll bar. */
220 static int toolkit_scroll_bar_interaction
;
222 /* Non-zero means to not move point as a result of clicking on a
223 frame to focus it (when focus-follows-mouse is nil). */
225 int x_mouse_click_focus_ignore_position
;
227 /* Non-zero timeout value means ignore next mouse click if it arrives
228 before that timeout elapses (i.e. as part of the same sequence of
229 events resulting from clicking on a frame to select it). */
231 static unsigned long ignore_next_mouse_click_timeout
;
235 Formerly, we used PointerMotionHintMask (in standard_event_mask)
236 so that we would have to call XQueryPointer after each MotionNotify
237 event to ask for another such event. However, this made mouse tracking
238 slow, and there was a bug that made it eventually stop.
240 Simply asking for MotionNotify all the time seems to work better.
242 In order to avoid asking for motion events and then throwing most
243 of them away or busy-polling the server for mouse positions, we ask
244 the server for pointer motion hints. This means that we get only
245 one event per group of mouse movements. "Groups" are delimited by
246 other kinds of events (focus changes and button clicks, for
247 example), or by XQueryPointer calls; when one of these happens, we
248 get another MotionNotify event the next time the mouse moves. This
249 is at least as efficient as getting motion events when mouse
250 tracking is on, and I suspect only negligibly worse when tracking
253 /* Where the mouse was last time we reported a mouse event. */
255 static XRectangle last_mouse_glyph
;
256 static FRAME_PTR last_mouse_glyph_frame
;
257 static Lisp_Object last_mouse_press_frame
;
259 /* The scroll bar in which the last X motion event occurred.
261 If the last X motion event occurred in a scroll bar, we set this so
262 XTmouse_position can know whether to report a scroll bar motion or
265 If the last X motion event didn't occur in a scroll bar, we set
266 this to Qnil, to tell XTmouse_position to return an ordinary motion
269 static Lisp_Object last_mouse_scroll_bar
;
271 /* This is a hack. We would really prefer that XTmouse_position would
272 return the time associated with the position it returns, but there
273 doesn't seem to be any way to wrest the time-stamp from the server
274 along with the position query. So, we just keep track of the time
275 of the last movement we received, and return that in hopes that
276 it's somewhat accurate. */
278 static Time last_mouse_movement_time
;
280 /* Time for last user interaction as returned in X events. */
282 static Time last_user_time
;
284 /* Incremented by XTread_socket whenever it really tries to read
288 static int volatile input_signal_count
;
290 static int input_signal_count
;
293 /* Used locally within XTread_socket. */
295 static int x_noop_count
;
297 /* Initial values of argv and argc. */
299 extern char **initial_argv
;
300 extern int initial_argc
;
302 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
304 /* Tells if a window manager is present or not. */
306 extern Lisp_Object Vx_no_window_manager
;
308 extern Lisp_Object Qeql
;
310 /* A mask of extra modifier bits to put into every keyboard char. */
312 extern EMACS_INT extra_keyboard_modifiers
;
314 /* The keysyms to use for the various modifiers. */
316 Lisp_Object Vx_alt_keysym
, Vx_hyper_keysym
, Vx_meta_keysym
, Vx_super_keysym
;
317 Lisp_Object Vx_keysym_table
;
318 static Lisp_Object Qalt
, Qhyper
, Qmeta
, Qsuper
, Qmodifier_value
;
320 static Lisp_Object Qvendor_specific_keysyms
;
321 static Lisp_Object Qlatin_1
;
324 /* The name of the Emacs icon file. */
325 static Lisp_Object xg_default_icon_file
;
327 /* Used in gtkutil.c. */
328 Lisp_Object Qx_gtk_map_stock
;
331 /* Used in x_flush. */
333 extern Lisp_Object Vinhibit_redisplay
;
335 extern XrmDatabase
x_load_resources (Display
*, char *, char *, char *);
336 extern int x_bitmap_mask (FRAME_PTR
, int);
338 static int x_alloc_nearest_color_1 (Display
*, Colormap
, XColor
*);
339 static void x_set_window_size_1 (struct frame
*, int, int, int);
340 static const XColor
*x_color_cells (Display
*, int *);
341 static void x_update_window_end (struct window
*, int, int);
343 static int x_io_error_quitter (Display
*);
344 static struct terminal
*x_create_terminal (struct x_display_info
*);
345 void x_delete_terminal (struct terminal
*);
346 static void x_update_end (struct frame
*);
347 static void XTframe_up_to_date (struct frame
*);
348 static void XTset_terminal_modes (struct terminal
*);
349 static void XTreset_terminal_modes (struct terminal
*);
350 static void x_clear_frame (struct frame
*);
351 static void frame_highlight (struct frame
*);
352 static void frame_unhighlight (struct frame
*);
353 static void x_new_focus_frame (struct x_display_info
*, struct frame
*);
354 static void x_focus_changed (int, int, struct x_display_info
*,
355 struct frame
*, struct input_event
*);
356 static void x_detect_focus_change (struct x_display_info
*,
357 XEvent
*, struct input_event
*);
358 static void XTframe_rehighlight (struct frame
*);
359 static void x_frame_rehighlight (struct x_display_info
*);
360 static void x_draw_hollow_cursor (struct window
*, struct glyph_row
*);
361 static void x_draw_bar_cursor (struct window
*, struct glyph_row
*, int,
362 enum text_cursor_kinds
);
364 static void x_clip_to_row (struct window
*, struct glyph_row
*, int, GC
);
365 static void x_flush (struct frame
*f
);
366 static void x_update_begin (struct frame
*);
367 static void x_update_window_begin (struct window
*);
368 static void x_after_update_window_line (struct glyph_row
*);
369 static struct scroll_bar
*x_window_to_scroll_bar (Display
*, Window
);
370 static void x_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
371 enum scroll_bar_part
*,
372 Lisp_Object
*, Lisp_Object
*,
374 static void x_handle_net_wm_state (struct frame
*, XPropertyEvent
*);
375 static void x_check_fullscreen (struct frame
*);
376 static void x_check_expected_move (struct frame
*, int, int);
377 static void x_sync_with_move (struct frame
*, int, int, int);
378 static int handle_one_xevent (struct x_display_info
*, XEvent
*,
379 int *, struct input_event
*);
380 /* Don't declare this NO_RETURN because we want no
381 interference with debugging failing X calls. */
382 static SIGTYPE
x_connection_closed (Display
*, char *);
385 /* Flush display of frame F, or of all frames if F is null. */
388 x_flush (struct frame
*f
)
390 /* Don't call XFlush when it is not safe to redisplay; the X
391 connection may be broken. */
392 if (!NILP (Vinhibit_redisplay
))
398 Lisp_Object rest
, frame
;
399 FOR_EACH_FRAME (rest
, frame
)
400 if (FRAME_X_P (XFRAME (frame
)))
401 x_flush (XFRAME (frame
));
403 else if (FRAME_X_P (f
))
404 XFlush (FRAME_X_DISPLAY (f
));
409 /* Remove calls to XFlush by defining XFlush to an empty replacement.
410 Calls to XFlush should be unnecessary because the X output buffer
411 is flushed automatically as needed by calls to XPending,
412 XNextEvent, or XWindowEvent according to the XFlush man page.
413 XTread_socket calls XPending. Removing XFlush improves
416 #define XFlush(DISPLAY) (void) 0
419 /***********************************************************************
421 ***********************************************************************/
425 /* This is a function useful for recording debugging information about
426 the sequence of occurrences in this file. */
434 struct record event_record
[100];
436 int event_record_index
;
438 record_event (locus
, type
)
442 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
443 event_record_index
= 0;
445 event_record
[event_record_index
].locus
= locus
;
446 event_record
[event_record_index
].type
= type
;
447 event_record_index
++;
454 /* Return the struct x_display_info corresponding to DPY. */
456 struct x_display_info
*
457 x_display_info_for_display (Display
*dpy
)
459 struct x_display_info
*dpyinfo
;
461 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
462 if (dpyinfo
->display
== dpy
)
468 #define OPAQUE 0xffffffff
469 #define OPACITY "_NET_WM_WINDOW_OPACITY"
472 x_set_frame_alpha (struct frame
*f
)
474 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
475 Display
*dpy
= FRAME_X_DISPLAY (f
);
476 Window win
= FRAME_OUTER_WINDOW (f
);
478 double alpha_min
= 1.0;
481 if (FRAME_X_DISPLAY_INFO (f
)->root_window
!= FRAME_X_OUTPUT (f
)->parent_desc
)
482 /* Since the WM decoration lies under the FRAME_OUTER_WINDOW,
483 we must treat the former instead of the latter. */
484 win
= FRAME_X_OUTPUT(f
)->parent_desc
;
486 if (dpyinfo
->x_highlight_frame
== f
)
491 if (FLOATP (Vframe_alpha_lower_limit
))
492 alpha_min
= XFLOAT_DATA (Vframe_alpha_lower_limit
);
493 else if (INTEGERP (Vframe_alpha_lower_limit
))
494 alpha_min
= (XINT (Vframe_alpha_lower_limit
)) / 100.0;
498 else if (alpha
> 1.0)
500 else if (0.0 <= alpha
&& alpha
< alpha_min
&& alpha_min
<= 1.0)
503 opac
= alpha
* OPAQUE
;
505 /* return unless necessary */
510 unsigned long n
, left
;
512 x_catch_errors (dpy
);
513 rc
= XGetWindowProperty(dpy
, win
, XInternAtom(dpy
, OPACITY
, False
),
514 0L, 1L, False
, XA_CARDINAL
,
515 &actual
, &format
, &n
, &left
,
518 if (rc
== Success
&& actual
!= None
)
519 if (*(unsigned long *)data
== opac
)
521 XFree ((void *) data
);
526 XFree ((void *) data
);
530 x_catch_errors (dpy
);
531 XChangeProperty (dpy
, win
, XInternAtom (dpy
, OPACITY
, False
),
532 XA_CARDINAL
, 32, PropModeReplace
,
533 (unsigned char *) &opac
, 1L);
538 x_display_pixel_height (struct x_display_info
*dpyinfo
)
540 return HeightOfScreen (dpyinfo
->screen
);
544 x_display_pixel_width (struct x_display_info
*dpyinfo
)
546 return WidthOfScreen (dpyinfo
->screen
);
550 /***********************************************************************
551 Starting and ending an update
552 ***********************************************************************/
554 /* Start an update of frame F. This function is installed as a hook
555 for update_begin, i.e. it is called when update_begin is called.
556 This function is called prior to calls to x_update_window_begin for
557 each window being updated. Currently, there is nothing to do here
558 because all interesting stuff is done on a window basis. */
561 x_update_begin (struct frame
*f
)
567 /* Start update of window W. Set the global variable updated_window
568 to the window being updated and set output_cursor to the cursor
572 x_update_window_begin (struct window
*w
)
574 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
575 struct x_display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
578 set_output_cursor (&w
->cursor
);
582 if (f
== display_info
->mouse_face_mouse_frame
)
584 /* Don't do highlighting for mouse motion during the update. */
585 display_info
->mouse_face_defer
= 1;
587 /* If F needs to be redrawn, simply forget about any prior mouse
589 if (FRAME_GARBAGED_P (f
))
590 display_info
->mouse_face_window
= Qnil
;
597 /* Draw a vertical window border from (x,y0) to (x,y1) */
600 x_draw_vertical_window_border (struct window
*w
, int x
, int y0
, int y1
)
602 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
605 face
= FACE_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
607 XSetForeground (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
610 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
611 f
->output_data
.x
->normal_gc
, x
, y0
, x
, y1
);
614 /* End update of window W (which is equal to updated_window).
616 Draw vertical borders between horizontally adjacent windows, and
617 display W's cursor if CURSOR_ON_P is non-zero.
619 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
620 glyphs in mouse-face were overwritten. In that case we have to
621 make sure that the mouse-highlight is properly redrawn.
623 W may be a menu bar pseudo-window in case we don't have X toolkit
624 support. Such windows don't have a cursor, so don't display it
628 x_update_window_end (struct window
*w
, int cursor_on_p
, int mouse_face_overwritten_p
)
630 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
632 if (!w
->pseudo_window_p
)
637 display_and_set_cursor (w
, 1, output_cursor
.hpos
,
639 output_cursor
.x
, output_cursor
.y
);
641 if (draw_window_fringes (w
, 1))
642 x_draw_vertical_border (w
);
647 /* If a row with mouse-face was overwritten, arrange for
648 XTframe_up_to_date to redisplay the mouse highlight. */
649 if (mouse_face_overwritten_p
)
651 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
652 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
653 dpyinfo
->mouse_face_window
= Qnil
;
656 updated_window
= NULL
;
660 /* End update of frame F. This function is installed as a hook in
664 x_update_end (struct frame
*f
)
666 /* Mouse highlight may be displayed again. */
667 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
671 XFlush (FRAME_X_DISPLAY (f
));
677 /* This function is called from various places in xdisp.c whenever a
678 complete update has been performed. The global variable
679 updated_window is not available here. */
682 XTframe_up_to_date (struct frame
*f
)
686 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
688 if (dpyinfo
->mouse_face_deferred_gc
689 || f
== dpyinfo
->mouse_face_mouse_frame
)
692 if (dpyinfo
->mouse_face_mouse_frame
)
693 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
694 dpyinfo
->mouse_face_mouse_x
,
695 dpyinfo
->mouse_face_mouse_y
);
696 dpyinfo
->mouse_face_deferred_gc
= 0;
703 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
704 arrow bitmaps, or clear the fringes if no bitmaps are required
705 before DESIRED_ROW is made current. The window being updated is
706 found in updated_window. This function It is called from
707 update_window_line only if it is known that there are differences
708 between bitmaps to be drawn between current row and DESIRED_ROW. */
711 x_after_update_window_line (struct glyph_row
*desired_row
)
713 struct window
*w
= updated_window
;
719 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
720 desired_row
->redraw_fringe_bitmaps_p
= 1;
722 /* When a window has disappeared, make sure that no rest of
723 full-width rows stays visible in the internal border. Could
724 check here if updated_window is the leftmost/rightmost window,
725 but I guess it's not worth doing since vertically split windows
726 are almost never used, internal border is rarely set, and the
727 overhead is very small. */
728 if (windows_or_buffers_changed
729 && desired_row
->full_width_p
730 && (f
= XFRAME (w
->frame
),
731 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
733 && (height
= desired_row
->visible_height
,
736 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
739 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
740 0, y
, width
, height
, False
);
741 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
742 FRAME_PIXEL_WIDTH (f
) - width
,
743 y
, width
, height
, False
);
749 x_draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
, struct draw_fringe_bitmap_params
*p
)
751 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
752 Display
*display
= FRAME_X_DISPLAY (f
);
753 Window window
= FRAME_X_WINDOW (f
);
754 GC gc
= f
->output_data
.x
->normal_gc
;
755 struct face
*face
= p
->face
;
758 /* Must clip because of partially visible lines. */
759 rowY
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
762 /* Adjust position of "bottom aligned" bitmap on partially
765 int oldVH
= row
->visible_height
;
766 row
->visible_height
= p
->h
;
767 row
->y
-= rowY
- p
->y
;
768 x_clip_to_row (w
, row
, -1, gc
);
770 row
->visible_height
= oldVH
;
773 x_clip_to_row (w
, row
, -1, gc
);
777 int bx
= p
->bx
, by
= p
->by
, nx
= p
->nx
, ny
= p
->ny
;
779 /* In case the same realized face is used for fringes and
780 for something displayed in the text (e.g. face `region' on
781 mono-displays, the fill style may have been changed to
782 FillSolid in x_draw_glyph_string_background. */
784 XSetFillStyle (display
, face
->gc
, FillOpaqueStippled
);
786 XSetForeground (display
, face
->gc
, face
->background
);
788 #ifdef USE_TOOLKIT_SCROLL_BARS
789 /* If the fringe is adjacent to the left (right) scroll bar of a
790 leftmost (rightmost, respectively) window, then extend its
791 background to the gap between the fringe and the bar. */
792 if ((WINDOW_LEFTMOST_P (w
)
793 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
794 || (WINDOW_RIGHTMOST_P (w
)
795 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
)))
797 int sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
801 int left
= WINDOW_SCROLL_BAR_AREA_X (w
);
802 int width
= (WINDOW_CONFIG_SCROLL_BAR_COLS (w
)
803 * FRAME_COLUMN_WIDTH (f
));
807 /* Bitmap fills the fringe. */
808 if (left
+ width
== p
->x
)
809 bx
= left
+ sb_width
;
810 else if (p
->x
+ p
->wd
== left
)
814 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
816 nx
= width
- sb_width
;
817 by
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
819 ny
= row
->visible_height
;
824 if (left
+ width
== bx
)
826 bx
= left
+ sb_width
;
827 nx
+= width
- sb_width
;
829 else if (bx
+ nx
== left
)
830 nx
+= width
- sb_width
;
835 if (bx
>= 0 && nx
> 0)
836 XFillRectangle (display
, window
, face
->gc
, bx
, by
, nx
, ny
);
839 XSetForeground (display
, face
->gc
, face
->foreground
);
845 Pixmap pixmap
, clipmask
= (Pixmap
) 0;
846 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
850 bits
= (unsigned char *)(p
->bits
+ p
->dh
);
852 bits
= (unsigned char *)p
->bits
+ p
->dh
;
854 /* Draw the bitmap. I believe these small pixmaps can be cached
856 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, p
->wd
, p
->h
,
858 ? (p
->overlay_p
? face
->background
859 : f
->output_data
.x
->cursor_pixel
)
861 face
->background
, depth
);
865 clipmask
= XCreatePixmapFromBitmapData (display
,
866 FRAME_X_DISPLAY_INFO (f
)->root_window
,
869 gcv
.clip_mask
= clipmask
;
870 gcv
.clip_x_origin
= p
->x
;
871 gcv
.clip_y_origin
= p
->y
;
872 XChangeGC (display
, gc
, GCClipMask
| GCClipXOrigin
| GCClipYOrigin
, &gcv
);
875 XCopyArea (display
, pixmap
, window
, gc
, 0, 0,
876 p
->wd
, p
->h
, p
->x
, p
->y
);
877 XFreePixmap (display
, pixmap
);
881 gcv
.clip_mask
= (Pixmap
) 0;
882 XChangeGC (display
, gc
, GCClipMask
, &gcv
);
883 XFreePixmap (display
, clipmask
);
887 XSetClipMask (display
, gc
, None
);
892 /* This is called when starting Emacs and when restarting after
893 suspend. When starting Emacs, no X window is mapped. And nothing
894 must be done to Emacs's own window if it is suspended (though that
898 XTset_terminal_modes (struct terminal
*terminal
)
902 /* This is called when exiting or suspending Emacs. Exiting will make
903 the X-windows go away, and suspending requires no action. */
906 XTreset_terminal_modes (struct terminal
*terminal
)
911 /***********************************************************************
913 ***********************************************************************/
917 static void x_set_glyph_string_clipping (struct glyph_string
*);
918 static void x_set_glyph_string_gc (struct glyph_string
*);
919 static void x_draw_glyph_string_background (struct glyph_string
*,
921 static void x_draw_glyph_string_foreground (struct glyph_string
*);
922 static void x_draw_composite_glyph_string_foreground (struct glyph_string
*);
923 static void x_draw_glyph_string_box (struct glyph_string
*);
924 static void x_draw_glyph_string (struct glyph_string
*);
925 static void x_compute_glyph_string_overhangs (struct glyph_string
*);
926 static void x_set_cursor_gc (struct glyph_string
*);
927 static void x_set_mode_line_face_gc (struct glyph_string
*);
928 static void x_set_mouse_face_gc (struct glyph_string
*);
929 static int x_alloc_lighter_color (struct frame
*, Display
*, Colormap
,
930 unsigned long *, double, int);
931 static void x_setup_relief_color (struct frame
*, struct relief
*,
932 double, int, unsigned long);
933 static void x_setup_relief_colors (struct glyph_string
*);
934 static void x_draw_image_glyph_string (struct glyph_string
*);
935 static void x_draw_image_relief (struct glyph_string
*);
936 static void x_draw_image_foreground (struct glyph_string
*);
937 static void x_draw_image_foreground_1 (struct glyph_string
*, Pixmap
);
938 static void x_clear_glyph_string_rect (struct glyph_string
*, int,
940 static void x_draw_relief_rect (struct frame
*, int, int, int, int,
941 int, int, int, int, int, int,
943 static void x_draw_box_rect (struct glyph_string
*, int, int, int, int,
944 int, int, int, XRectangle
*);
947 static void x_check_font (struct frame
*, struct font
*);
951 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
955 x_set_cursor_gc (struct glyph_string
*s
)
957 if (s
->font
== FRAME_FONT (s
->f
)
958 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
959 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
961 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
964 /* Cursor on non-default face: must merge. */
968 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
969 xgcv
.foreground
= s
->face
->background
;
971 /* If the glyph would be invisible, try a different foreground. */
972 if (xgcv
.foreground
== xgcv
.background
)
973 xgcv
.foreground
= s
->face
->foreground
;
974 if (xgcv
.foreground
== xgcv
.background
)
975 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
976 if (xgcv
.foreground
== xgcv
.background
)
977 xgcv
.foreground
= s
->face
->foreground
;
979 /* Make sure the cursor is distinct from text in this face. */
980 if (xgcv
.background
== s
->face
->background
981 && xgcv
.foreground
== s
->face
->foreground
)
983 xgcv
.background
= s
->face
->foreground
;
984 xgcv
.foreground
= s
->face
->background
;
987 IF_DEBUG (x_check_font (s
->f
, s
->font
));
988 xgcv
.graphics_exposures
= False
;
989 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
991 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
992 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
995 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
996 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
998 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1003 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1006 x_set_mouse_face_gc (struct glyph_string
*s
)
1011 /* What face has to be used last for the mouse face? */
1012 face_id
= FRAME_X_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
1013 face
= FACE_FROM_ID (s
->f
, face_id
);
1015 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1017 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1018 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
1020 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
1021 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1022 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1024 if (s
->font
== s
->face
->font
)
1025 s
->gc
= s
->face
->gc
;
1028 /* Otherwise construct scratch_cursor_gc with values from FACE
1033 xgcv
.background
= s
->face
->background
;
1034 xgcv
.foreground
= s
->face
->foreground
;
1035 xgcv
.graphics_exposures
= False
;
1036 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
1038 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1039 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1042 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1043 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
1045 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1048 xassert (s
->gc
!= 0);
1052 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1053 Faces to use in the mode line have already been computed when the
1054 matrix was built, so there isn't much to do, here. */
1057 x_set_mode_line_face_gc (struct glyph_string
*s
)
1059 s
->gc
= s
->face
->gc
;
1063 /* Set S->gc of glyph string S for drawing that glyph string. Set
1064 S->stippled_p to a non-zero value if the face of S has a stipple
1068 x_set_glyph_string_gc (struct glyph_string
*s
)
1070 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1072 if (s
->hl
== DRAW_NORMAL_TEXT
)
1074 s
->gc
= s
->face
->gc
;
1075 s
->stippled_p
= s
->face
->stipple
!= 0;
1077 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1079 x_set_mode_line_face_gc (s
);
1080 s
->stippled_p
= s
->face
->stipple
!= 0;
1082 else if (s
->hl
== DRAW_CURSOR
)
1084 x_set_cursor_gc (s
);
1087 else if (s
->hl
== DRAW_MOUSE_FACE
)
1089 x_set_mouse_face_gc (s
);
1090 s
->stippled_p
= s
->face
->stipple
!= 0;
1092 else if (s
->hl
== DRAW_IMAGE_RAISED
1093 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1095 s
->gc
= s
->face
->gc
;
1096 s
->stippled_p
= s
->face
->stipple
!= 0;
1100 s
->gc
= s
->face
->gc
;
1101 s
->stippled_p
= s
->face
->stipple
!= 0;
1104 /* GC must have been set. */
1105 xassert (s
->gc
!= 0);
1109 /* Set clipping for output of glyph string S. S may be part of a mode
1110 line or menu if we don't have X toolkit support. */
1113 x_set_glyph_string_clipping (struct glyph_string
*s
)
1115 XRectangle
*r
= s
->clip
;
1116 int n
= get_glyph_string_clip_rects (s
, r
, 2);
1119 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, r
, n
, Unsorted
);
1124 /* Set SRC's clipping for output of glyph string DST. This is called
1125 when we are drawing DST's left_overhang or right_overhang only in
1129 x_set_glyph_string_clipping_exactly (struct glyph_string
*src
, struct glyph_string
*dst
)
1134 r
.width
= src
->width
;
1136 r
.height
= src
->height
;
1139 XSetClipRectangles (dst
->display
, dst
->gc
, 0, 0, &r
, 1, Unsorted
);
1144 Compute left and right overhang of glyph string S. */
1147 x_compute_glyph_string_overhangs (struct glyph_string
*s
)
1150 && (s
->first_glyph
->type
== CHAR_GLYPH
1151 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
1153 struct font_metrics metrics
;
1155 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1157 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1158 struct font
*font
= s
->font
;
1161 for (i
= 0; i
< s
->nchars
; i
++)
1162 code
[i
] = (s
->char2b
[i
].byte1
<< 8) | s
->char2b
[i
].byte2
;
1163 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1167 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1169 composition_gstring_width (gstring
, s
->cmp_from
, s
->cmp_to
, &metrics
);
1171 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1172 ? metrics
.rbearing
- metrics
.width
: 0);
1173 s
->left_overhang
= metrics
.lbearing
< 0 ? - metrics
.lbearing
: 0;
1177 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1178 s
->left_overhang
= - s
->cmp
->lbearing
;
1183 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1186 x_clear_glyph_string_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
1189 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
1190 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
1191 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
1192 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
1196 /* Draw the background of glyph_string S. If S->background_filled_p
1197 is non-zero don't draw it. FORCE_P non-zero means draw the
1198 background even if it wouldn't be drawn normally. This is used
1199 when a string preceding S draws into the background of S, or S
1200 contains the first component of a composition. */
1203 x_draw_glyph_string_background (struct glyph_string
*s
, int force_p
)
1205 /* Nothing to do if background has already been drawn or if it
1206 shouldn't be drawn in the first place. */
1207 if (!s
->background_filled_p
)
1209 int box_line_width
= max (s
->face
->box_line_width
, 0);
1213 /* Fill background with a stipple pattern. */
1214 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1215 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1216 s
->y
+ box_line_width
,
1217 s
->background_width
,
1218 s
->height
- 2 * box_line_width
);
1219 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1220 s
->background_filled_p
= 1;
1222 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1223 || s
->font_not_found_p
1224 || s
->extends_to_end_of_line_p
1227 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1228 s
->background_width
,
1229 s
->height
- 2 * box_line_width
);
1230 s
->background_filled_p
= 1;
1236 /* Draw the foreground of glyph string S. */
1239 x_draw_glyph_string_foreground (struct glyph_string
*s
)
1243 /* If first glyph of S has a left box line, start drawing the text
1244 of S to the right of that box line. */
1245 if (s
->face
->box
!= FACE_NO_BOX
1246 && s
->first_glyph
->left_box_line_p
)
1247 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1251 /* Draw characters of S as rectangles if S's font could not be
1253 if (s
->font_not_found_p
)
1255 for (i
= 0; i
< s
->nchars
; ++i
)
1257 struct glyph
*g
= s
->first_glyph
+ i
;
1258 XDrawRectangle (s
->display
, s
->window
,
1259 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1261 x
+= g
->pixel_width
;
1266 struct font
*font
= s
->font
;
1267 int boff
= font
->baseline_offset
;
1270 if (font
->vertical_centering
)
1271 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1273 y
= s
->ybase
- boff
;
1275 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1276 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 0);
1278 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 1);
1279 if (s
->face
->overstrike
)
1280 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, 0);
1284 /* Draw the foreground of composite glyph string S. */
1287 x_draw_composite_glyph_string_foreground (struct glyph_string
*s
)
1290 struct font
*font
= s
->font
;
1292 /* If first glyph of S has a left box line, start drawing the text
1293 of S to the right of that box line. */
1294 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1295 && s
->first_glyph
->left_box_line_p
)
1296 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1300 /* S is a glyph string for a composition. S->cmp_from is the index
1301 of the first character drawn for glyphs of this composition.
1302 S->cmp_from == 0 means we are drawing the very first character of
1303 this composition. */
1305 /* Draw a rectangle for the composition if the font for the very
1306 first character of the composition could not be loaded. */
1307 if (s
->font_not_found_p
)
1309 if (s
->cmp_from
== 0)
1310 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, s
->y
,
1311 s
->width
- 1, s
->height
- 1);
1313 else if (! s
->first_glyph
->u
.cmp
.automatic
)
1317 for (i
= 0, j
= s
->cmp_from
; i
< s
->nchars
; i
++, j
++)
1318 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1320 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1321 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1323 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, 0);
1324 if (s
->face
->overstrike
)
1325 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, 0);
1330 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1335 for (i
= j
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
1337 glyph
= LGSTRING_GLYPH (gstring
, i
);
1338 if (NILP (LGLYPH_ADJUSTMENT (glyph
)))
1339 width
+= LGLYPH_WIDTH (glyph
);
1342 int xoff
, yoff
, wadjust
;
1346 font
->driver
->draw (s
, j
, i
, x
, y
, 0);
1347 if (s
->face
->overstrike
)
1348 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, 0);
1351 xoff
= LGLYPH_XOFF (glyph
);
1352 yoff
= LGLYPH_YOFF (glyph
);
1353 wadjust
= LGLYPH_WADJUST (glyph
);
1354 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, 0);
1355 if (s
->face
->overstrike
)
1356 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
+ 1, y
+ yoff
, 0);
1364 font
->driver
->draw (s
, j
, i
, x
, y
, 0);
1365 if (s
->face
->overstrike
)
1366 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, 0);
1372 #ifdef USE_X_TOOLKIT
1374 static struct frame
*x_frame_of_widget (Widget
);
1375 static Boolean
cvt_string_to_pixel (Display
*, XrmValue
*, Cardinal
*,
1376 XrmValue
*, XrmValue
*, XtPointer
*);
1377 static void cvt_pixel_dtor (XtAppContext
, XrmValue
*, XtPointer
,
1378 XrmValue
*, Cardinal
*);
1381 /* Return the frame on which widget WIDGET is used.. Abort if frame
1382 cannot be determined. */
1384 static struct frame
*
1385 x_frame_of_widget (widget
)
1388 struct x_display_info
*dpyinfo
;
1392 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
1394 /* Find the top-level shell of the widget. Note that this function
1395 can be called when the widget is not yet realized, so XtWindow
1396 (widget) == 0. That's the reason we can't simply use
1397 x_any_window_to_frame. */
1398 while (!XtIsTopLevelShell (widget
))
1399 widget
= XtParent (widget
);
1401 /* Look for a frame with that top-level widget. Allocate the color
1402 on that frame to get the right gamma correction value. */
1403 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1404 if (FRAMEP (XCAR (tail
))
1405 && (f
= XFRAME (XCAR (tail
)),
1407 && f
->output_data
.nothing
!= 1
1408 && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
))
1409 && f
->output_data
.x
->widget
== widget
)
1416 /* Allocate the color COLOR->pixel on the screen and display of
1417 widget WIDGET in colormap CMAP. If an exact match cannot be
1418 allocated, try the nearest color available. Value is non-zero
1419 if successful. This is called from lwlib. */
1422 x_alloc_nearest_color_for_widget (widget
, cmap
, color
)
1427 struct frame
*f
= x_frame_of_widget (widget
);
1428 return x_alloc_nearest_color (f
, cmap
, color
);
1432 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1433 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1434 If this produces the same color as PIXEL, try a color where all RGB
1435 values have DELTA added. Return the allocated color in *PIXEL.
1436 DISPLAY is the X display, CMAP is the colormap to operate on.
1437 Value is non-zero if successful. */
1440 x_alloc_lighter_color_for_widget (widget
, display
, cmap
, pixel
, factor
, delta
)
1444 unsigned long *pixel
;
1448 struct frame
*f
= x_frame_of_widget (widget
);
1449 return x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
);
1453 /* Structure specifying which arguments should be passed by Xt to
1454 cvt_string_to_pixel. We want the widget's screen and colormap. */
1456 static XtConvertArgRec cvt_string_to_pixel_args
[] =
1458 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.screen
),
1460 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.colormap
),
1465 /* The address of this variable is returned by
1466 cvt_string_to_pixel. */
1468 static Pixel cvt_string_to_pixel_value
;
1471 /* Convert a color name to a pixel color.
1473 DPY is the display we are working on.
1475 ARGS is an array of *NARGS XrmValue structures holding additional
1476 information about the widget for which the conversion takes place.
1477 The contents of this array are determined by the specification
1478 in cvt_string_to_pixel_args.
1480 FROM is a pointer to an XrmValue which points to the color name to
1481 convert. TO is an XrmValue in which to return the pixel color.
1483 CLOSURE_RET is a pointer to user-data, in which we record if
1484 we allocated the color or not.
1486 Value is True if successful, False otherwise. */
1489 cvt_string_to_pixel (dpy
, args
, nargs
, from
, to
, closure_ret
)
1493 XrmValue
*from
, *to
;
1494 XtPointer
*closure_ret
;
1504 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1505 "wrongParameters", "cvt_string_to_pixel",
1507 "Screen and colormap args required", NULL
, NULL
);
1511 screen
= *(Screen
**) args
[0].addr
;
1512 cmap
= *(Colormap
*) args
[1].addr
;
1513 color_name
= (String
) from
->addr
;
1515 if (strcmp (color_name
, XtDefaultBackground
) == 0)
1517 *closure_ret
= (XtPointer
) False
;
1518 pixel
= WhitePixelOfScreen (screen
);
1520 else if (strcmp (color_name
, XtDefaultForeground
) == 0)
1522 *closure_ret
= (XtPointer
) False
;
1523 pixel
= BlackPixelOfScreen (screen
);
1525 else if (XParseColor (dpy
, cmap
, color_name
, &color
)
1526 && x_alloc_nearest_color_1 (dpy
, cmap
, &color
))
1528 pixel
= color
.pixel
;
1529 *closure_ret
= (XtPointer
) True
;
1534 Cardinal nparams
= 1;
1536 params
[0] = color_name
;
1537 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1538 "badValue", "cvt_string_to_pixel",
1539 "XtToolkitError", "Invalid color `%s'",
1544 if (to
->addr
!= NULL
)
1546 if (to
->size
< sizeof (Pixel
))
1548 to
->size
= sizeof (Pixel
);
1552 *(Pixel
*) to
->addr
= pixel
;
1556 cvt_string_to_pixel_value
= pixel
;
1557 to
->addr
= (XtPointer
) &cvt_string_to_pixel_value
;
1560 to
->size
= sizeof (Pixel
);
1565 /* Free a pixel color which was previously allocated via
1566 cvt_string_to_pixel. This is registered as the destructor
1567 for this type of resource via XtSetTypeConverter.
1569 APP is the application context in which we work.
1571 TO is a pointer to an XrmValue holding the color to free.
1572 CLOSURE is the value we stored in CLOSURE_RET for this color
1573 in cvt_string_to_pixel.
1575 ARGS and NARGS are like for cvt_string_to_pixel. */
1578 cvt_pixel_dtor (app
, to
, closure
, args
, nargs
)
1587 XtAppWarningMsg (app
, "wrongParameters", "cvt_pixel_dtor",
1589 "Screen and colormap arguments required",
1592 else if (closure
!= NULL
)
1594 /* We did allocate the pixel, so free it. */
1595 Screen
*screen
= *(Screen
**) args
[0].addr
;
1596 Colormap cmap
= *(Colormap
*) args
[1].addr
;
1597 x_free_dpy_colors (DisplayOfScreen (screen
), screen
, cmap
,
1598 (Pixel
*) to
->addr
, 1);
1603 #endif /* USE_X_TOOLKIT */
1606 /* Value is an array of XColor structures for the contents of the
1607 color map of display DPY. Set *NCELLS to the size of the array.
1608 Note that this probably shouldn't be called for large color maps,
1609 say a 24-bit TrueColor map. */
1611 static const XColor
*
1612 x_color_cells (Display
*dpy
, int *ncells
)
1614 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1616 if (dpyinfo
->color_cells
== NULL
)
1618 Screen
*screen
= dpyinfo
->screen
;
1621 dpyinfo
->ncolor_cells
1622 = XDisplayCells (dpy
, XScreenNumberOfScreen (screen
));
1623 dpyinfo
->color_cells
1624 = (XColor
*) xmalloc (dpyinfo
->ncolor_cells
1625 * sizeof *dpyinfo
->color_cells
);
1627 for (i
= 0; i
< dpyinfo
->ncolor_cells
; ++i
)
1628 dpyinfo
->color_cells
[i
].pixel
= i
;
1630 XQueryColors (dpy
, dpyinfo
->cmap
,
1631 dpyinfo
->color_cells
, dpyinfo
->ncolor_cells
);
1634 *ncells
= dpyinfo
->ncolor_cells
;
1635 return dpyinfo
->color_cells
;
1639 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1640 colors in COLORS. Use cached information, if available. */
1643 x_query_colors (struct frame
*f
, XColor
*colors
, int ncolors
)
1645 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1647 if (dpyinfo
->color_cells
)
1650 for (i
= 0; i
< ncolors
; ++i
)
1652 unsigned long pixel
= colors
[i
].pixel
;
1653 xassert (pixel
< dpyinfo
->ncolor_cells
);
1654 xassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
1655 colors
[i
] = dpyinfo
->color_cells
[pixel
];
1659 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
1663 /* On frame F, translate pixel color to RGB values for the color in
1664 COLOR. Use cached information, if available. */
1667 x_query_color (struct frame
*f
, XColor
*color
)
1669 x_query_colors (f
, color
, 1);
1673 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
1674 exact match can't be allocated, try the nearest color available.
1675 Value is non-zero if successful. Set *COLOR to the color
1679 x_alloc_nearest_color_1 (Display
*dpy
, Colormap cmap
, XColor
*color
)
1683 rc
= XAllocColor (dpy
, cmap
, color
);
1686 /* If we got to this point, the colormap is full, so we're going
1687 to try to get the next closest color. The algorithm used is
1688 a least-squares matching, which is what X uses for closest
1689 color matching with StaticColor visuals. */
1691 unsigned long nearest_delta
= ~0;
1693 const XColor
*cells
= x_color_cells (dpy
, &ncells
);
1695 for (nearest
= i
= 0; i
< ncells
; ++i
)
1697 long dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
1698 long dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
1699 long dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
1700 unsigned long delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
1702 if (delta
< nearest_delta
)
1705 nearest_delta
= delta
;
1709 color
->red
= cells
[nearest
].red
;
1710 color
->green
= cells
[nearest
].green
;
1711 color
->blue
= cells
[nearest
].blue
;
1712 rc
= XAllocColor (dpy
, cmap
, color
);
1716 /* If allocation succeeded, and the allocated pixel color is not
1717 equal to a cached pixel color recorded earlier, there was a
1718 change in the colormap, so clear the color cache. */
1719 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1720 XColor
*cached_color
;
1722 if (dpyinfo
->color_cells
1723 && (cached_color
= &dpyinfo
->color_cells
[color
->pixel
],
1724 (cached_color
->red
!= color
->red
1725 || cached_color
->blue
!= color
->blue
1726 || cached_color
->green
!= color
->green
)))
1728 xfree (dpyinfo
->color_cells
);
1729 dpyinfo
->color_cells
= NULL
;
1730 dpyinfo
->ncolor_cells
= 0;
1734 #ifdef DEBUG_X_COLORS
1736 register_color (color
->pixel
);
1737 #endif /* DEBUG_X_COLORS */
1743 /* Allocate the color COLOR->pixel on frame F, colormap CMAP. If an
1744 exact match can't be allocated, try the nearest color available.
1745 Value is non-zero if successful. Set *COLOR to the color
1749 x_alloc_nearest_color (struct frame
*f
, Colormap cmap
, XColor
*color
)
1751 gamma_correct (f
, color
);
1752 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f
), cmap
, color
);
1756 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
1757 It's necessary to do this instead of just using PIXEL directly to
1758 get color reference counts right. */
1761 x_copy_color (struct frame
*f
, long unsigned int pixel
)
1765 color
.pixel
= pixel
;
1767 x_query_color (f
, &color
);
1768 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
1770 #ifdef DEBUG_X_COLORS
1771 register_color (pixel
);
1777 /* Allocate color PIXEL on display DPY. PIXEL must already be allocated.
1778 It's necessary to do this instead of just using PIXEL directly to
1779 get color reference counts right. */
1782 x_copy_dpy_color (Display
*dpy
, Colormap cmap
, long unsigned int pixel
)
1786 color
.pixel
= pixel
;
1788 XQueryColor (dpy
, cmap
, &color
);
1789 XAllocColor (dpy
, cmap
, &color
);
1791 #ifdef DEBUG_X_COLORS
1792 register_color (pixel
);
1798 /* Brightness beyond which a color won't have its highlight brightness
1801 Nominally, highlight colors for `3d' faces are calculated by
1802 brightening an object's color by a constant scale factor, but this
1803 doesn't yield good results for dark colors, so for colors who's
1804 brightness is less than this value (on a scale of 0-65535) have an
1805 use an additional additive factor.
1807 The value here is set so that the default menu-bar/mode-line color
1808 (grey75) will not have its highlights changed at all. */
1809 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
1812 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1813 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1814 If this produces the same color as PIXEL, try a color where all RGB
1815 values have DELTA added. Return the allocated color in *PIXEL.
1816 DISPLAY is the X display, CMAP is the colormap to operate on.
1817 Value is non-zero if successful. */
1820 x_alloc_lighter_color (struct frame
*f
, Display
*display
, Colormap cmap
, long unsigned int *pixel
, double factor
, int delta
)
1826 /* Get RGB color values. */
1827 color
.pixel
= *pixel
;
1828 x_query_color (f
, &color
);
1830 /* Change RGB values by specified FACTOR. Avoid overflow! */
1831 xassert (factor
>= 0);
1832 new.red
= min (0xffff, factor
* color
.red
);
1833 new.green
= min (0xffff, factor
* color
.green
);
1834 new.blue
= min (0xffff, factor
* color
.blue
);
1836 /* Calculate brightness of COLOR. */
1837 bright
= (2 * color
.red
+ 3 * color
.green
+ color
.blue
) / 6;
1839 /* We only boost colors that are darker than
1840 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1841 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1842 /* Make an additive adjustment to NEW, because it's dark enough so
1843 that scaling by FACTOR alone isn't enough. */
1845 /* How far below the limit this color is (0 - 1, 1 being darker). */
1846 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1847 /* The additive adjustment. */
1848 int min_delta
= delta
* dimness
* factor
/ 2;
1852 new.red
= max (0, new.red
- min_delta
);
1853 new.green
= max (0, new.green
- min_delta
);
1854 new.blue
= max (0, new.blue
- min_delta
);
1858 new.red
= min (0xffff, min_delta
+ new.red
);
1859 new.green
= min (0xffff, min_delta
+ new.green
);
1860 new.blue
= min (0xffff, min_delta
+ new.blue
);
1864 /* Try to allocate the color. */
1865 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1868 if (new.pixel
== *pixel
)
1870 /* If we end up with the same color as before, try adding
1871 delta to the RGB values. */
1872 x_free_colors (f
, &new.pixel
, 1);
1874 new.red
= min (0xffff, delta
+ color
.red
);
1875 new.green
= min (0xffff, delta
+ color
.green
);
1876 new.blue
= min (0xffff, delta
+ color
.blue
);
1877 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1888 /* Set up the foreground color for drawing relief lines of glyph
1889 string S. RELIEF is a pointer to a struct relief containing the GC
1890 with which lines will be drawn. Use a color that is FACTOR or
1891 DELTA lighter or darker than the relief's background which is found
1892 in S->f->output_data.x->relief_background. If such a color cannot
1893 be allocated, use DEFAULT_PIXEL, instead. */
1896 x_setup_relief_color (struct frame
*f
, struct relief
*relief
, double factor
, int delta
, long unsigned int default_pixel
)
1899 struct x_output
*di
= f
->output_data
.x
;
1900 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
1901 unsigned long pixel
;
1902 unsigned long background
= di
->relief_background
;
1903 Colormap cmap
= FRAME_X_COLORMAP (f
);
1904 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1905 Display
*dpy
= FRAME_X_DISPLAY (f
);
1907 xgcv
.graphics_exposures
= False
;
1908 xgcv
.line_width
= 1;
1910 /* Free previously allocated color. The color cell will be reused
1911 when it has been freed as many times as it was allocated, so this
1912 doesn't affect faces using the same colors. */
1914 && relief
->allocated_p
)
1916 x_free_colors (f
, &relief
->pixel
, 1);
1917 relief
->allocated_p
= 0;
1920 /* Allocate new color. */
1921 xgcv
.foreground
= default_pixel
;
1923 if (dpyinfo
->n_planes
!= 1
1924 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
1926 relief
->allocated_p
= 1;
1927 xgcv
.foreground
= relief
->pixel
= pixel
;
1930 if (relief
->gc
== 0)
1932 xgcv
.stipple
= dpyinfo
->gray
;
1934 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
1937 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
1941 /* Set up colors for the relief lines around glyph string S. */
1944 x_setup_relief_colors (struct glyph_string
*s
)
1946 struct x_output
*di
= s
->f
->output_data
.x
;
1947 unsigned long color
;
1949 if (s
->face
->use_box_color_for_shadows_p
)
1950 color
= s
->face
->box_color
;
1951 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1953 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1954 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1959 /* Get the background color of the face. */
1960 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
1961 color
= xgcv
.background
;
1964 if (di
->white_relief
.gc
== 0
1965 || color
!= di
->relief_background
)
1967 di
->relief_background
= color
;
1968 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
1969 WHITE_PIX_DEFAULT (s
->f
));
1970 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
1971 BLACK_PIX_DEFAULT (s
->f
));
1976 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1977 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1978 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1979 relief. LEFT_P non-zero means draw a relief on the left side of
1980 the rectangle. RIGHT_P non-zero means draw a relief on the right
1981 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1985 x_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
1986 raised_p
, top_p
, bot_p
, left_p
, right_p
, clip_rect
)
1988 int left_x
, top_y
, right_x
, bottom_y
, width
;
1989 int top_p
, bot_p
, left_p
, right_p
, raised_p
;
1990 XRectangle
*clip_rect
;
1992 Display
*dpy
= FRAME_X_DISPLAY (f
);
1993 Window window
= FRAME_X_WINDOW (f
);
1998 gc
= f
->output_data
.x
->white_relief
.gc
;
2000 gc
= f
->output_data
.x
->black_relief
.gc
;
2001 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
2005 for (i
= 0; i
< width
; ++i
)
2006 XDrawLine (dpy
, window
, gc
,
2007 left_x
+ i
* left_p
, top_y
+ i
,
2008 right_x
+ 1 - i
* right_p
, top_y
+ i
);
2012 for (i
= 0; i
< width
; ++i
)
2013 XDrawLine (dpy
, window
, gc
,
2014 left_x
+ i
, top_y
+ i
, left_x
+ i
, bottom_y
- i
+ 1);
2016 XSetClipMask (dpy
, gc
, None
);
2018 gc
= f
->output_data
.x
->black_relief
.gc
;
2020 gc
= f
->output_data
.x
->white_relief
.gc
;
2021 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
2025 for (i
= 0; i
< width
; ++i
)
2026 XDrawLine (dpy
, window
, gc
,
2027 left_x
+ i
* left_p
, bottom_y
- i
,
2028 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
2032 for (i
= 0; i
< width
; ++i
)
2033 XDrawLine (dpy
, window
, gc
,
2034 right_x
- i
, top_y
+ i
+ 1, right_x
- i
, bottom_y
- i
);
2036 XSetClipMask (dpy
, gc
, None
);
2040 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
2041 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
2042 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
2043 left side of the rectangle. RIGHT_P non-zero means draw a line
2044 on the right side of the rectangle. CLIP_RECT is the clipping
2045 rectangle to use when drawing. */
2048 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2049 left_p
, right_p
, clip_rect
)
2050 struct glyph_string
*s
;
2051 int left_x
, top_y
, right_x
, bottom_y
, width
, left_p
, right_p
;
2052 XRectangle
*clip_rect
;
2056 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2057 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
2058 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, clip_rect
, 1, Unsorted
);
2061 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2062 left_x
, top_y
, right_x
- left_x
+ 1, width
);
2066 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2067 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
2070 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2071 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
2075 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2076 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
2078 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2079 XSetClipMask (s
->display
, s
->gc
, None
);
2083 /* Draw a box around glyph string S. */
2086 x_draw_glyph_string_box (struct glyph_string
*s
)
2088 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
2089 int left_p
, right_p
;
2090 struct glyph
*last_glyph
;
2091 XRectangle clip_rect
;
2093 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
2094 ? WINDOW_RIGHT_EDGE_X (s
->w
)
2095 : window_box_right (s
->w
, s
->area
));
2097 /* The glyph that may have a right box line. */
2098 last_glyph
= (s
->cmp
|| s
->img
2100 : s
->first_glyph
+ s
->nchars
- 1);
2102 width
= eabs (s
->face
->box_line_width
);
2103 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
2105 right_x
= (s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
2107 : min (last_x
, s
->x
+ s
->background_width
) - 1);
2109 bottom_y
= top_y
+ s
->height
- 1;
2111 left_p
= (s
->first_glyph
->left_box_line_p
2112 || (s
->hl
== DRAW_MOUSE_FACE
2114 || s
->prev
->hl
!= s
->hl
)));
2115 right_p
= (last_glyph
->right_box_line_p
2116 || (s
->hl
== DRAW_MOUSE_FACE
2118 || s
->next
->hl
!= s
->hl
)));
2120 get_glyph_string_clip_rect (s
, &clip_rect
);
2122 if (s
->face
->box
== FACE_SIMPLE_BOX
)
2123 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2124 left_p
, right_p
, &clip_rect
);
2127 x_setup_relief_colors (s
);
2128 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
2129 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
2134 /* Draw foreground of image glyph string S. */
2137 x_draw_image_foreground (struct glyph_string
*s
)
2140 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2142 /* If first glyph of S has a left box line, start drawing it to the
2143 right of that line. */
2144 if (s
->face
->box
!= FACE_NO_BOX
2145 && s
->first_glyph
->left_box_line_p
2147 x
+= eabs (s
->face
->box_line_width
);
2149 /* If there is a margin around the image, adjust x- and y-position
2151 if (s
->slice
.x
== 0)
2152 x
+= s
->img
->hmargin
;
2153 if (s
->slice
.y
== 0)
2154 y
+= s
->img
->vmargin
;
2160 /* We can't set both a clip mask and use XSetClipRectangles
2161 because the latter also sets a clip mask. We also can't
2162 trust on the shape extension to be available
2163 (XShapeCombineRegion). So, compute the rectangle to draw
2165 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2168 XRectangle clip_rect
, image_rect
, r
;
2170 xgcv
.clip_mask
= s
->img
->mask
;
2171 xgcv
.clip_x_origin
= x
;
2172 xgcv
.clip_y_origin
= y
;
2173 xgcv
.function
= GXcopy
;
2174 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2176 get_glyph_string_clip_rect (s
, &clip_rect
);
2179 image_rect
.width
= s
->slice
.width
;
2180 image_rect
.height
= s
->slice
.height
;
2181 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2182 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2183 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2184 r
.width
, r
.height
, r
.x
, r
.y
);
2188 XRectangle clip_rect
, image_rect
, r
;
2190 get_glyph_string_clip_rect (s
, &clip_rect
);
2193 image_rect
.width
= s
->slice
.width
;
2194 image_rect
.height
= s
->slice
.height
;
2195 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2196 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2197 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2198 r
.width
, r
.height
, r
.x
, r
.y
);
2200 /* When the image has a mask, we can expect that at
2201 least part of a mouse highlight or a block cursor will
2202 be visible. If the image doesn't have a mask, make
2203 a block cursor visible by drawing a rectangle around
2204 the image. I believe it's looking better if we do
2205 nothing here for mouse-face. */
2206 if (s
->hl
== DRAW_CURSOR
)
2208 int r
= s
->img
->relief
;
2210 XDrawRectangle (s
->display
, s
->window
, s
->gc
,
2212 s
->slice
.width
+ r
*2 - 1,
2213 s
->slice
.height
+ r
*2 - 1);
2218 /* Draw a rectangle if image could not be loaded. */
2219 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
2220 s
->slice
.width
- 1, s
->slice
.height
- 1);
2224 /* Draw a relief around the image glyph string S. */
2227 x_draw_image_relief (struct glyph_string
*s
)
2229 int x0
, y0
, x1
, y1
, thick
, raised_p
, extra
;
2232 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2234 /* If first glyph of S has a left box line, start drawing it to the
2235 right of that line. */
2236 if (s
->face
->box
!= FACE_NO_BOX
2237 && s
->first_glyph
->left_box_line_p
2239 x
+= eabs (s
->face
->box_line_width
);
2241 /* If there is a margin around the image, adjust x- and y-position
2243 if (s
->slice
.x
== 0)
2244 x
+= s
->img
->hmargin
;
2245 if (s
->slice
.y
== 0)
2246 y
+= s
->img
->vmargin
;
2248 if (s
->hl
== DRAW_IMAGE_SUNKEN
2249 || s
->hl
== DRAW_IMAGE_RAISED
)
2251 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
2252 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
2256 thick
= eabs (s
->img
->relief
);
2257 raised_p
= s
->img
->relief
> 0;
2260 extra
= s
->face
->id
== TOOL_BAR_FACE_ID
2261 ? XINT (Vtool_bar_button_margin
) : 0;
2263 x0
= x
- thick
- extra
;
2264 y0
= y
- thick
- extra
;
2265 x1
= x
+ s
->slice
.width
+ thick
- 1 + extra
;
2266 y1
= y
+ s
->slice
.height
+ thick
- 1 + extra
;
2268 x_setup_relief_colors (s
);
2269 get_glyph_string_clip_rect (s
, &r
);
2270 x_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
,
2272 s
->slice
.y
+ s
->slice
.height
== s
->img
->height
,
2274 s
->slice
.x
+ s
->slice
.width
== s
->img
->width
,
2279 /* Draw the foreground of image glyph string S to PIXMAP. */
2282 x_draw_image_foreground_1 (struct glyph_string
*s
, Pixmap pixmap
)
2285 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2287 /* If first glyph of S has a left box line, start drawing it to the
2288 right of that line. */
2289 if (s
->face
->box
!= FACE_NO_BOX
2290 && s
->first_glyph
->left_box_line_p
2292 x
+= eabs (s
->face
->box_line_width
);
2294 /* If there is a margin around the image, adjust x- and y-position
2296 if (s
->slice
.x
== 0)
2297 x
+= s
->img
->hmargin
;
2298 if (s
->slice
.y
== 0)
2299 y
+= s
->img
->vmargin
;
2305 /* We can't set both a clip mask and use XSetClipRectangles
2306 because the latter also sets a clip mask. We also can't
2307 trust on the shape extension to be available
2308 (XShapeCombineRegion). So, compute the rectangle to draw
2310 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2314 xgcv
.clip_mask
= s
->img
->mask
;
2315 xgcv
.clip_x_origin
= x
- s
->slice
.x
;
2316 xgcv
.clip_y_origin
= y
- s
->slice
.y
;
2317 xgcv
.function
= GXcopy
;
2318 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2320 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2321 s
->slice
.x
, s
->slice
.y
,
2322 s
->slice
.width
, s
->slice
.height
, x
, y
);
2323 XSetClipMask (s
->display
, s
->gc
, None
);
2327 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2328 s
->slice
.x
, s
->slice
.y
,
2329 s
->slice
.width
, s
->slice
.height
, x
, y
);
2331 /* When the image has a mask, we can expect that at
2332 least part of a mouse highlight or a block cursor will
2333 be visible. If the image doesn't have a mask, make
2334 a block cursor visible by drawing a rectangle around
2335 the image. I believe it's looking better if we do
2336 nothing here for mouse-face. */
2337 if (s
->hl
== DRAW_CURSOR
)
2339 int r
= s
->img
->relief
;
2341 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
- r
, y
- r
,
2342 s
->slice
.width
+ r
*2 - 1,
2343 s
->slice
.height
+ r
*2 - 1);
2348 /* Draw a rectangle if image could not be loaded. */
2349 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
2350 s
->slice
.width
- 1, s
->slice
.height
- 1);
2354 /* Draw part of the background of glyph string S. X, Y, W, and H
2355 give the rectangle to draw. */
2358 x_draw_glyph_string_bg_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
2362 /* Fill background with a stipple pattern. */
2363 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2364 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2365 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2368 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2372 /* Draw image glyph string S.
2375 s->x +-------------------------
2378 | +-------------------------
2381 | | +-------------------
2387 x_draw_image_glyph_string (struct glyph_string
*s
)
2389 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
2390 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2392 Pixmap pixmap
= None
;
2395 if (s
->slice
.y
== 0)
2396 height
-= box_line_vwidth
;
2397 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
2398 height
-= box_line_vwidth
;
2400 /* Fill background with face under the image. Do it only if row is
2401 taller than image or if image has a clip mask to reduce
2403 s
->stippled_p
= s
->face
->stipple
!= 0;
2404 if (height
> s
->slice
.height
2408 || s
->img
->pixmap
== 0
2409 || s
->width
!= s
->background_width
)
2413 /* Create a pixmap as large as the glyph string. Fill it
2414 with the background color. Copy the image to it, using
2415 its mask. Copy the temporary pixmap to the display. */
2416 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2417 int depth
= DefaultDepthOfScreen (screen
);
2419 /* Create a pixmap as large as the glyph string. */
2420 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2421 s
->background_width
,
2424 /* Don't clip in the following because we're working on the
2426 XSetClipMask (s
->display
, s
->gc
, None
);
2428 /* Fill the pixmap with the background color/stipple. */
2431 /* Fill background with a stipple pattern. */
2432 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2433 XSetTSOrigin (s
->display
, s
->gc
, - s
->x
, - s
->y
);
2434 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2435 0, 0, s
->background_width
, s
->height
);
2436 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2437 XSetTSOrigin (s
->display
, s
->gc
, 0, 0);
2442 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2444 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2445 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2446 0, 0, s
->background_width
, s
->height
);
2447 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2455 if (s
->first_glyph
->left_box_line_p
2457 x
+= box_line_hwidth
;
2459 if (s
->slice
.y
== 0)
2460 y
+= box_line_vwidth
;
2462 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
2465 s
->background_filled_p
= 1;
2468 /* Draw the foreground. */
2471 x_draw_image_foreground_1 (s
, pixmap
);
2472 x_set_glyph_string_clipping (s
);
2473 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
2474 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
2475 XFreePixmap (s
->display
, pixmap
);
2478 x_draw_image_foreground (s
);
2480 /* If we must draw a relief around the image, do it. */
2482 || s
->hl
== DRAW_IMAGE_RAISED
2483 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2484 x_draw_image_relief (s
);
2488 /* Draw stretch glyph string S. */
2491 x_draw_stretch_glyph_string (struct glyph_string
*s
)
2493 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2495 if (s
->hl
== DRAW_CURSOR
2496 && !x_stretch_cursor_p
)
2498 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
2499 as wide as the stretch glyph. */
2500 int width
, background_width
= s
->background_width
;
2501 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2505 background_width
-= left_x
- x
;
2508 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
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
;
2522 if (s
->row
->mouse_face_p
2523 && cursor_in_mouse_face_p (s
->w
))
2525 x_set_mouse_face_gc (s
);
2531 get_glyph_string_clip_rect (s
, &r
);
2532 XSetClipRectangles (s
->display
, gc
, 0, 0, &r
, 1, Unsorted
);
2534 if (s
->face
->stipple
)
2536 /* Fill background with a stipple pattern. */
2537 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2538 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2539 XSetFillStyle (s
->display
, gc
, FillSolid
);
2544 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
2545 XSetForeground (s
->display
, gc
, xgcv
.background
);
2546 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2547 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
2551 else if (!s
->background_filled_p
)
2553 int background_width
= s
->background_width
;
2554 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2556 /* Don't draw into left margin, fringe or scrollbar area
2557 except for header line and mode line. */
2558 if (x
< left_x
&& !s
->row
->mode_line_p
)
2560 background_width
-= left_x
- x
;
2563 if (background_width
> 0)
2564 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2567 s
->background_filled_p
= 1;
2571 /* Draw glyph string S. */
2574 x_draw_glyph_string (struct glyph_string
*s
)
2576 int relief_drawn_p
= 0;
2578 /* If S draws into the background of its successors, draw the
2579 background of the successors first so that S can draw into it.
2580 This makes S->next use XDrawString instead of XDrawImageString. */
2581 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2584 struct glyph_string
*next
;
2586 for (width
= 0, next
= s
->next
;
2587 next
&& width
< s
->right_overhang
;
2588 width
+= next
->width
, next
= next
->next
)
2589 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
2591 x_set_glyph_string_gc (next
);
2592 x_set_glyph_string_clipping (next
);
2593 if (next
->first_glyph
->type
== STRETCH_GLYPH
)
2594 x_draw_stretch_glyph_string (next
);
2596 x_draw_glyph_string_background (next
, 1);
2597 next
->num_clips
= 0;
2601 /* Set up S->gc, set clipping and draw S. */
2602 x_set_glyph_string_gc (s
);
2604 /* Draw relief (if any) in advance for char/composition so that the
2605 glyph string can be drawn over it. */
2606 if (!s
->for_overlaps
2607 && s
->face
->box
!= FACE_NO_BOX
2608 && (s
->first_glyph
->type
== CHAR_GLYPH
2609 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2612 x_set_glyph_string_clipping (s
);
2613 x_draw_glyph_string_background (s
, 1);
2614 x_draw_glyph_string_box (s
);
2615 x_set_glyph_string_clipping (s
);
2618 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
2620 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2621 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
2622 /* We must clip just this glyph. left_overhang part has already
2623 drawn when s->prev was drawn, and right_overhang part will be
2624 drawn later when s->next is drawn. */
2625 x_set_glyph_string_clipping_exactly (s
, s
);
2627 x_set_glyph_string_clipping (s
);
2629 switch (s
->first_glyph
->type
)
2632 x_draw_image_glyph_string (s
);
2636 x_draw_stretch_glyph_string (s
);
2640 if (s
->for_overlaps
)
2641 s
->background_filled_p
= 1;
2643 x_draw_glyph_string_background (s
, 0);
2644 x_draw_glyph_string_foreground (s
);
2647 case COMPOSITE_GLYPH
:
2648 if (s
->for_overlaps
|| (s
->cmp_from
> 0
2649 && ! s
->first_glyph
->u
.cmp
.automatic
))
2650 s
->background_filled_p
= 1;
2652 x_draw_glyph_string_background (s
, 1);
2653 x_draw_composite_glyph_string_foreground (s
);
2660 if (!s
->for_overlaps
)
2662 /* Draw underline. */
2663 if (s
->face
->underline_p
)
2665 unsigned long thickness
, position
;
2668 if (s
->prev
&& s
->prev
->face
->underline_p
)
2670 /* We use the same underline style as the previous one. */
2671 thickness
= s
->prev
->underline_thickness
;
2672 position
= s
->prev
->underline_position
;
2676 /* Get the underline thickness. Default is 1 pixel. */
2677 if (s
->font
&& s
->font
->underline_thickness
> 0)
2678 thickness
= s
->font
->underline_thickness
;
2681 if (x_underline_at_descent_line
)
2682 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
2685 /* Get the underline position. This is the recommended
2686 vertical offset in pixels from the baseline to the top of
2687 the underline. This is a signed value according to the
2688 specs, and its default is
2690 ROUND ((maximum descent) / 2), with
2691 ROUND(x) = floor (x + 0.5) */
2693 if (x_use_underline_position_properties
2694 && s
->font
&& s
->font
->underline_position
>= 0)
2695 position
= s
->font
->underline_position
;
2697 position
= (s
->font
->descent
+ 1) / 2;
2699 position
= underline_minimum_offset
;
2701 position
= max (position
, underline_minimum_offset
);
2703 /* Check the sanity of thickness and position. We should
2704 avoid drawing underline out of the current line area. */
2705 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
2706 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
2707 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
2708 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
2709 s
->underline_thickness
= thickness
;
2710 s
->underline_position
= position
;
2711 y
= s
->ybase
+ position
;
2712 if (s
->face
->underline_defaulted_p
)
2713 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2714 s
->x
, y
, s
->width
, thickness
);
2718 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2719 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
2720 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2721 s
->x
, y
, s
->width
, thickness
);
2722 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2726 /* Draw overline. */
2727 if (s
->face
->overline_p
)
2729 unsigned long dy
= 0, h
= 1;
2731 if (s
->face
->overline_color_defaulted_p
)
2732 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2737 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2738 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
2739 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2741 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2745 /* Draw strike-through. */
2746 if (s
->face
->strike_through_p
)
2748 unsigned long h
= 1;
2749 unsigned long dy
= (s
->height
- h
) / 2;
2751 if (s
->face
->strike_through_color_defaulted_p
)
2752 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2757 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2758 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
2759 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2761 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2765 /* Draw relief if not yet drawn. */
2766 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2767 x_draw_glyph_string_box (s
);
2771 struct glyph_string
*prev
;
2773 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2774 if (prev
->hl
!= s
->hl
2775 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2777 /* As prev was drawn while clipped to its own area, we
2778 must draw the right_overhang part using s->hl now. */
2779 enum draw_glyphs_face save
= prev
->hl
;
2782 x_set_glyph_string_gc (prev
);
2783 x_set_glyph_string_clipping_exactly (s
, prev
);
2784 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2785 x_draw_glyph_string_foreground (prev
);
2787 x_draw_composite_glyph_string_foreground (prev
);
2788 XSetClipMask (prev
->display
, prev
->gc
, None
);
2790 prev
->num_clips
= 0;
2796 struct glyph_string
*next
;
2798 for (next
= s
->next
; next
; next
= next
->next
)
2799 if (next
->hl
!= s
->hl
2800 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
2802 /* As next will be drawn while clipped to its own area,
2803 we must draw the left_overhang part using s->hl now. */
2804 enum draw_glyphs_face save
= next
->hl
;
2807 x_set_glyph_string_gc (next
);
2808 x_set_glyph_string_clipping_exactly (s
, next
);
2809 if (next
->first_glyph
->type
== CHAR_GLYPH
)
2810 x_draw_glyph_string_foreground (next
);
2812 x_draw_composite_glyph_string_foreground (next
);
2813 XSetClipMask (next
->display
, next
->gc
, None
);
2815 next
->num_clips
= 0;
2820 /* Reset clipping. */
2821 XSetClipMask (s
->display
, s
->gc
, None
);
2825 /* Shift display to make room for inserted glyphs. */
2828 x_shift_glyphs_for_insert (struct frame
*f
, int x
, int y
, int width
, int height
, int shift_by
)
2830 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
2831 f
->output_data
.x
->normal_gc
,
2832 x
, y
, width
, height
,
2836 /* Delete N glyphs at the nominal cursor position. Not implemented
2840 x_delete_glyphs (struct frame
*f
, register int n
)
2846 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
2847 If they are <= 0, this is probably an error. */
2850 x_clear_area (Display
*dpy
, Window window
, int x
, int y
, int width
, int height
, int exposures
)
2852 xassert (width
> 0 && height
> 0);
2853 XClearArea (dpy
, window
, x
, y
, width
, height
, exposures
);
2857 /* Clear an entire frame. */
2860 x_clear_frame (struct frame
*f
)
2862 /* Clearing the frame will erase any cursor, so mark them all as no
2864 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2865 output_cursor
.hpos
= output_cursor
.vpos
= 0;
2866 output_cursor
.x
= -1;
2868 /* We don't set the output cursor here because there will always
2869 follow an explicit cursor_to. */
2871 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
2873 /* We have to clear the scroll bars, too. If we have changed
2874 colors or something like that, then they should be notified. */
2875 x_scroll_bar_clear (f
);
2877 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
2878 /* Make sure scroll bars are redrawn. As they aren't redrawn by
2879 redisplay, do it here. */
2880 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
2883 XFlush (FRAME_X_DISPLAY (f
));
2890 /* Invert the middle quarter of the frame for .15 sec. */
2892 /* We use the select system call to do the waiting, so we have to make
2893 sure it's available. If it isn't, we just won't do visual bells. */
2895 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
2898 /* Subtract the `struct timeval' values X and Y, storing the result in
2899 *RESULT. Return 1 if the difference is negative, otherwise 0. */
2902 timeval_subtract (struct timeval
*result
, struct timeval x
, struct timeval y
)
2904 /* Perform the carry for the later subtraction by updating y. This
2905 is safer because on some systems the tv_sec member is unsigned. */
2906 if (x
.tv_usec
< y
.tv_usec
)
2908 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
2909 y
.tv_usec
-= 1000000 * nsec
;
2913 if (x
.tv_usec
- y
.tv_usec
> 1000000)
2915 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
2916 y
.tv_usec
+= 1000000 * nsec
;
2920 /* Compute the time remaining to wait. tv_usec is certainly
2922 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
2923 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
2925 /* Return indication of whether the result should be considered
2927 return x
.tv_sec
< y
.tv_sec
;
2931 XTflash (struct frame
*f
)
2937 /* Use Gdk routines to draw. This way, we won't draw over scroll bars
2938 when the scroll bars and the edit widget share the same X window. */
2939 GdkWindow
*window
= gtk_widget_get_window (FRAME_GTK_WIDGET (f
));
2942 vals
.foreground
.pixel
= (FRAME_FOREGROUND_PIXEL (f
)
2943 ^ FRAME_BACKGROUND_PIXEL (f
));
2944 vals
.function
= GDK_XOR
;
2945 gc
= gdk_gc_new_with_values (window
,
2946 &vals
, GDK_GC_FUNCTION
| GDK_GC_FOREGROUND
);
2947 #define XFillRectangle(d, win, gc, x, y, w, h) \
2948 gdk_draw_rectangle (window, gc, TRUE, x, y, w, h)
2952 /* Create a GC that will use the GXxor function to flip foreground
2953 pixels into background pixels. */
2957 values
.function
= GXxor
;
2958 values
.foreground
= (FRAME_FOREGROUND_PIXEL (f
)
2959 ^ FRAME_BACKGROUND_PIXEL (f
));
2961 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2962 GCFunction
| GCForeground
, &values
);
2966 /* Get the height not including a menu bar widget. */
2967 int height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, FRAME_LINES (f
));
2968 /* Height of each line to flash. */
2969 int flash_height
= FRAME_LINE_HEIGHT (f
);
2970 /* These will be the left and right margins of the rectangles. */
2971 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
2972 int flash_right
= FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
2976 /* Don't flash the area between a scroll bar and the frame
2977 edge it is next to. */
2978 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f
))
2980 case vertical_scroll_bar_left
:
2981 flash_left
+= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
2984 case vertical_scroll_bar_right
:
2985 flash_right
-= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
2992 width
= flash_right
- flash_left
;
2994 /* If window is tall, flash top and bottom line. */
2995 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
2997 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2999 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3000 + FRAME_TOP_MARGIN_HEIGHT (f
)),
3001 width
, flash_height
);
3002 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3004 (height
- flash_height
3005 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3006 width
, flash_height
);
3010 /* If it is short, flash it all. */
3011 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3012 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3013 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3018 struct timeval wakeup
;
3020 EMACS_GET_TIME (wakeup
);
3022 /* Compute time to wait until, propagating carry from usecs. */
3023 wakeup
.tv_usec
+= 150000;
3024 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
3025 wakeup
.tv_usec
%= 1000000;
3027 /* Keep waiting until past the time wakeup or any input gets
3029 while (! detect_input_pending ())
3031 struct timeval current
;
3032 struct timeval timeout
;
3034 EMACS_GET_TIME (current
);
3036 /* Break if result would be negative. */
3037 if (timeval_subtract (¤t
, wakeup
, current
))
3040 /* How long `select' should wait. */
3042 timeout
.tv_usec
= 10000;
3044 /* Try to wait that long--but we might wake up sooner. */
3045 select (0, NULL
, NULL
, NULL
, &timeout
);
3049 /* If window is tall, flash top and bottom line. */
3050 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3052 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3054 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3055 + FRAME_TOP_MARGIN_HEIGHT (f
)),
3056 width
, flash_height
);
3057 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3059 (height
- flash_height
3060 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3061 width
, flash_height
);
3064 /* If it is short, flash it all. */
3065 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3066 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3067 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3070 g_object_unref (G_OBJECT (gc
));
3071 #undef XFillRectangle
3073 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
3082 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
3086 XTtoggle_invisible_pointer (FRAME_PTR f
, int invisible
)
3091 if (FRAME_X_DISPLAY_INFO (f
)->invisible_cursor
!= 0)
3092 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3093 FRAME_X_DISPLAY_INFO (f
)->invisible_cursor
);
3096 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3097 f
->output_data
.x
->current_cursor
);
3098 f
->pointer_invisible
= invisible
;
3103 /* Make audible bell. */
3108 struct frame
*f
= SELECTED_FRAME ();
3110 if (FRAME_X_DISPLAY (f
))
3112 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
3119 XBell (FRAME_X_DISPLAY (f
), 0);
3120 XFlush (FRAME_X_DISPLAY (f
));
3127 /* Specify how many text lines, from the top of the window,
3128 should be affected by insert-lines and delete-lines operations.
3129 This, and those operations, are used only within an update
3130 that is bounded by calls to x_update_begin and x_update_end. */
3133 XTset_terminal_window (register int n
)
3135 /* This function intentionally left blank. */
3140 /***********************************************************************
3142 ***********************************************************************/
3144 /* Perform an insert-lines or delete-lines operation, inserting N
3145 lines or deleting -N lines at vertical position VPOS. */
3148 x_ins_del_lines (struct frame
*f
, int vpos
, int n
)
3154 /* Scroll part of the display as described by RUN. */
3157 x_scroll_run (struct window
*w
, struct run
*run
)
3159 struct frame
*f
= XFRAME (w
->frame
);
3160 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
3162 /* Get frame-relative bounding box of the text display area of W,
3163 without mode lines. Include in this box the left and right
3165 window_box (w
, -1, &x
, &y
, &width
, &height
);
3167 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
3168 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
3169 bottom_y
= y
+ height
;
3173 /* Scrolling up. Make sure we don't copy part of the mode
3174 line at the bottom. */
3175 if (from_y
+ run
->height
> bottom_y
)
3176 height
= bottom_y
- from_y
;
3178 height
= run
->height
;
3182 /* Scolling down. Make sure we don't copy over the mode line.
3184 if (to_y
+ run
->height
> bottom_y
)
3185 height
= bottom_y
- to_y
;
3187 height
= run
->height
;
3192 /* Cursor off. Will be switched on again in x_update_window_end. */
3196 XCopyArea (FRAME_X_DISPLAY (f
),
3197 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
3198 f
->output_data
.x
->normal_gc
,
3208 /***********************************************************************
3210 ***********************************************************************/
3214 frame_highlight (struct frame
*f
)
3216 /* We used to only do this if Vx_no_window_manager was non-nil, but
3217 the ICCCM (section 4.1.6) says that the window's border pixmap
3218 and border pixel are window attributes which are "private to the
3219 client", so we can always change it to whatever we want. */
3221 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3222 f
->output_data
.x
->border_pixel
);
3224 x_update_cursor (f
, 1);
3225 x_set_frame_alpha (f
);
3229 frame_unhighlight (struct frame
*f
)
3231 /* We used to only do this if Vx_no_window_manager was non-nil, but
3232 the ICCCM (section 4.1.6) says that the window's border pixmap
3233 and border pixel are window attributes which are "private to the
3234 client", so we can always change it to whatever we want. */
3236 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3237 f
->output_data
.x
->border_tile
);
3239 x_update_cursor (f
, 1);
3240 x_set_frame_alpha (f
);
3243 /* The focus has changed. Update the frames as necessary to reflect
3244 the new situation. Note that we can't change the selected frame
3245 here, because the Lisp code we are interrupting might become confused.
3246 Each event gets marked with the frame in which it occurred, so the
3247 Lisp code can tell when the switch took place by examining the events. */
3250 x_new_focus_frame (struct x_display_info
*dpyinfo
, struct frame
*frame
)
3252 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
3254 if (frame
!= dpyinfo
->x_focus_frame
)
3256 /* Set this before calling other routines, so that they see
3257 the correct value of x_focus_frame. */
3258 dpyinfo
->x_focus_frame
= frame
;
3260 if (old_focus
&& old_focus
->auto_lower
)
3261 x_lower_frame (old_focus
);
3263 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
3264 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
3266 pending_autoraise_frame
= 0;
3269 x_frame_rehighlight (dpyinfo
);
3272 /* Handle FocusIn and FocusOut state changes for FRAME.
3273 If FRAME has focus and there exists more than one frame, puts
3274 a FOCUS_IN_EVENT into *BUFP. */
3277 x_focus_changed (int type
, int state
, struct x_display_info
*dpyinfo
, struct frame
*frame
, struct input_event
*bufp
)
3279 if (type
== FocusIn
)
3281 if (dpyinfo
->x_focus_event_frame
!= frame
)
3283 x_new_focus_frame (dpyinfo
, frame
);
3284 dpyinfo
->x_focus_event_frame
= frame
;
3286 /* Don't stop displaying the initial startup message
3287 for a switch-frame event we don't need. */
3288 if (NILP (Vterminal_frame
)
3289 && CONSP (Vframe_list
)
3290 && !NILP (XCDR (Vframe_list
)))
3292 bufp
->kind
= FOCUS_IN_EVENT
;
3293 XSETFRAME (bufp
->frame_or_window
, frame
);
3297 frame
->output_data
.x
->focus_state
|= state
;
3300 if (FRAME_XIC (frame
))
3301 XSetICFocus (FRAME_XIC (frame
));
3304 else if (type
== FocusOut
)
3306 frame
->output_data
.x
->focus_state
&= ~state
;
3308 if (dpyinfo
->x_focus_event_frame
== frame
)
3310 dpyinfo
->x_focus_event_frame
= 0;
3311 x_new_focus_frame (dpyinfo
, 0);
3315 if (FRAME_XIC (frame
))
3316 XUnsetICFocus (FRAME_XIC (frame
));
3318 if (frame
->pointer_invisible
)
3319 XTtoggle_invisible_pointer (frame
, 0);
3323 /* The focus may have changed. Figure out if it is a real focus change,
3324 by checking both FocusIn/Out and Enter/LeaveNotify events.
3326 Returns FOCUS_IN_EVENT event in *BUFP. */
3329 x_detect_focus_change (struct x_display_info
*dpyinfo
, XEvent
*event
, struct input_event
*bufp
)
3331 struct frame
*frame
;
3333 frame
= x_any_window_to_frame (dpyinfo
, event
->xany
.window
);
3337 switch (event
->type
)
3342 struct frame
*focus_frame
= dpyinfo
->x_focus_event_frame
;
3344 = focus_frame
? focus_frame
->output_data
.x
->focus_state
: 0;
3346 if (event
->xcrossing
.detail
!= NotifyInferior
3347 && event
->xcrossing
.focus
3348 && ! (focus_state
& FOCUS_EXPLICIT
))
3349 x_focus_changed ((event
->type
== EnterNotify
? FocusIn
: FocusOut
),
3351 dpyinfo
, frame
, bufp
);
3357 x_focus_changed (event
->type
,
3358 (event
->xfocus
.detail
== NotifyPointer
?
3359 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
3360 dpyinfo
, frame
, bufp
);
3364 if (event
->xclient
.message_type
== dpyinfo
->Xatom_XEMBED
)
3366 enum xembed_message msg
= event
->xclient
.data
.l
[1];
3367 x_focus_changed ((msg
== XEMBED_FOCUS_IN
? FocusIn
: FocusOut
),
3368 FOCUS_EXPLICIT
, dpyinfo
, frame
, bufp
);
3375 /* Handle an event saying the mouse has moved out of an Emacs frame. */
3378 x_mouse_leave (struct x_display_info
*dpyinfo
)
3380 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
3383 /* The focus has changed, or we have redirected a frame's focus to
3384 another frame (this happens when a frame uses a surrogate
3385 mini-buffer frame). Shift the highlight as appropriate.
3387 The FRAME argument doesn't necessarily have anything to do with which
3388 frame is being highlighted or un-highlighted; we only use it to find
3389 the appropriate X display info. */
3392 XTframe_rehighlight (struct frame
*frame
)
3394 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
3398 x_frame_rehighlight (struct x_display_info
*dpyinfo
)
3400 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
3402 if (dpyinfo
->x_focus_frame
)
3404 dpyinfo
->x_highlight_frame
3405 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
3406 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
3407 : dpyinfo
->x_focus_frame
);
3408 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
3410 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
3411 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
3415 dpyinfo
->x_highlight_frame
= 0;
3417 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
3420 frame_unhighlight (old_highlight
);
3421 if (dpyinfo
->x_highlight_frame
)
3422 frame_highlight (dpyinfo
->x_highlight_frame
);
3428 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
3430 /* Initialize mode_switch_bit and modifier_meaning. */
3432 x_find_modifier_meanings (struct x_display_info
*dpyinfo
)
3434 int min_code
, max_code
;
3437 XModifierKeymap
*mods
;
3439 dpyinfo
->meta_mod_mask
= 0;
3440 dpyinfo
->shift_lock_mask
= 0;
3441 dpyinfo
->alt_mod_mask
= 0;
3442 dpyinfo
->super_mod_mask
= 0;
3443 dpyinfo
->hyper_mod_mask
= 0;
3445 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
3447 syms
= XGetKeyboardMapping (dpyinfo
->display
,
3448 min_code
, max_code
- min_code
+ 1,
3450 mods
= XGetModifierMapping (dpyinfo
->display
);
3452 /* Scan the modifier table to see which modifier bits the Meta and
3453 Alt keysyms are on. */
3455 int row
, col
; /* The row and column in the modifier table. */
3456 int found_alt_or_meta
;
3458 for (row
= 3; row
< 8; row
++)
3460 found_alt_or_meta
= 0;
3461 for (col
= 0; col
< mods
->max_keypermod
; col
++)
3463 KeyCode code
= mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
3465 /* Zeroes are used for filler. Skip them. */
3469 /* Are any of this keycode's keysyms a meta key? */
3473 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
3475 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
3481 found_alt_or_meta
= 1;
3482 dpyinfo
->meta_mod_mask
|= (1 << row
);
3487 found_alt_or_meta
= 1;
3488 dpyinfo
->alt_mod_mask
|= (1 << row
);
3493 if (!found_alt_or_meta
)
3494 dpyinfo
->hyper_mod_mask
|= (1 << row
);
3495 code_col
= syms_per_code
;
3496 col
= mods
->max_keypermod
;
3501 if (!found_alt_or_meta
)
3502 dpyinfo
->super_mod_mask
|= (1 << row
);
3503 code_col
= syms_per_code
;
3504 col
= mods
->max_keypermod
;
3508 /* Ignore this if it's not on the lock modifier. */
3509 if (!found_alt_or_meta
&& ((1 << row
) == LockMask
))
3510 dpyinfo
->shift_lock_mask
= LockMask
;
3511 code_col
= syms_per_code
;
3512 col
= mods
->max_keypermod
;
3521 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
3522 if (! dpyinfo
->meta_mod_mask
)
3524 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
3525 dpyinfo
->alt_mod_mask
= 0;
3528 /* If some keys are both alt and meta,
3529 make them just meta, not alt. */
3530 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
3532 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
3535 XFree ((char *) syms
);
3536 XFreeModifiermap (mods
);
3539 /* Convert between the modifier bits X uses and the modifier bits
3543 x_x_to_emacs_modifiers (struct x_display_info
*dpyinfo
, unsigned int state
)
3545 EMACS_UINT mod_meta
= meta_modifier
;
3546 EMACS_UINT mod_alt
= alt_modifier
;
3547 EMACS_UINT mod_hyper
= hyper_modifier
;
3548 EMACS_UINT mod_super
= super_modifier
;
3551 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3552 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
3553 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3554 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
3555 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3556 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
3557 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3558 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
3561 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
3562 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
3563 | ((state
& dpyinfo
->meta_mod_mask
) ? mod_meta
: 0)
3564 | ((state
& dpyinfo
->alt_mod_mask
) ? mod_alt
: 0)
3565 | ((state
& dpyinfo
->super_mod_mask
) ? mod_super
: 0)
3566 | ((state
& dpyinfo
->hyper_mod_mask
) ? mod_hyper
: 0));
3570 x_emacs_to_x_modifiers (struct x_display_info
*dpyinfo
, unsigned int state
)
3572 EMACS_UINT mod_meta
= meta_modifier
;
3573 EMACS_UINT mod_alt
= alt_modifier
;
3574 EMACS_UINT mod_hyper
= hyper_modifier
;
3575 EMACS_UINT mod_super
= super_modifier
;
3579 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3580 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
3581 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3582 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
3583 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3584 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
3585 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3586 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
3589 return ( ((state
& mod_alt
) ? dpyinfo
->alt_mod_mask
: 0)
3590 | ((state
& mod_super
) ? dpyinfo
->super_mod_mask
: 0)
3591 | ((state
& mod_hyper
) ? dpyinfo
->hyper_mod_mask
: 0)
3592 | ((state
& shift_modifier
) ? ShiftMask
: 0)
3593 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
3594 | ((state
& mod_meta
) ? dpyinfo
->meta_mod_mask
: 0));
3597 /* Convert a keysym to its name. */
3600 x_get_keysym_name (KeySym keysym
)
3605 value
= XKeysymToString (keysym
);
3613 /* Mouse clicks and mouse movement. Rah. */
3615 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3617 If the event is a button press, then note that we have grabbed
3621 construct_mouse_click (struct input_event
*result
, XButtonEvent
*event
, struct frame
*f
)
3623 /* Make the event type NO_EVENT; we'll change that when we decide
3625 result
->kind
= MOUSE_CLICK_EVENT
;
3626 result
->code
= event
->button
- Button1
;
3627 result
->timestamp
= event
->time
;
3628 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
3630 | (event
->type
== ButtonRelease
3634 XSETINT (result
->x
, event
->x
);
3635 XSETINT (result
->y
, event
->y
);
3636 XSETFRAME (result
->frame_or_window
, f
);
3642 /* Function to report a mouse movement to the mainstream Emacs code.
3643 The input handler calls this.
3645 We have received a mouse movement event, which is given in *event.
3646 If the mouse is over a different glyph than it was last time, tell
3647 the mainstream emacs code by setting mouse_moved. If not, ask for
3648 another motion event, so we can check again the next time it moves. */
3650 static XMotionEvent last_mouse_motion_event
;
3651 static Lisp_Object last_mouse_motion_frame
;
3654 note_mouse_movement (FRAME_PTR frame
, XMotionEvent
*event
)
3656 last_mouse_movement_time
= event
->time
;
3657 last_mouse_motion_event
= *event
;
3658 XSETFRAME (last_mouse_motion_frame
, frame
);
3660 if (!FRAME_X_OUTPUT (frame
))
3663 if (event
->window
!= FRAME_X_WINDOW (frame
))
3665 frame
->mouse_moved
= 1;
3666 last_mouse_scroll_bar
= Qnil
;
3667 note_mouse_highlight (frame
, -1, -1);
3668 last_mouse_glyph_frame
= 0;
3673 /* Has the mouse moved off the glyph it was on at the last sighting? */
3674 if (frame
!= last_mouse_glyph_frame
3675 || event
->x
< last_mouse_glyph
.x
3676 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
3677 || event
->y
< last_mouse_glyph
.y
3678 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
3680 frame
->mouse_moved
= 1;
3681 last_mouse_scroll_bar
= Qnil
;
3682 note_mouse_highlight (frame
, event
->x
, event
->y
);
3683 /* Remember which glyph we're now on. */
3684 remember_mouse_glyph (frame
, event
->x
, event
->y
, &last_mouse_glyph
);
3685 last_mouse_glyph_frame
= frame
;
3693 /************************************************************************
3695 ************************************************************************/
3698 redo_mouse_highlight (void)
3700 if (!NILP (last_mouse_motion_frame
)
3701 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
3702 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
3703 last_mouse_motion_event
.x
,
3704 last_mouse_motion_event
.y
);
3709 /* Return the current position of the mouse.
3710 *FP should be a frame which indicates which display to ask about.
3712 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
3713 and *PART to the frame, window, and scroll bar part that the mouse
3714 is over. Set *X and *Y to the portion and whole of the mouse's
3715 position on the scroll bar.
3717 If the mouse movement started elsewhere, set *FP to the frame the
3718 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
3721 Set *TIME to the server time-stamp for the time at which the mouse
3722 was at this position.
3724 Don't store anything if we don't have a valid set of values to report.
3726 This clears the mouse_moved flag, so we can wait for the next mouse
3730 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
)
3736 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
3737 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3743 Window dummy_window
;
3746 Lisp_Object frame
, tail
;
3748 /* Clear the mouse-moved flag for every frame on this display. */
3749 FOR_EACH_FRAME (tail
, frame
)
3750 if (FRAME_X_P (XFRAME (frame
))
3751 && FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
3752 XFRAME (frame
)->mouse_moved
= 0;
3754 last_mouse_scroll_bar
= Qnil
;
3756 /* Figure out which root window we're on. */
3757 XQueryPointer (FRAME_X_DISPLAY (*fp
),
3758 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
3760 /* The root window which contains the pointer. */
3763 /* Trash which we can't trust if the pointer is on
3764 a different screen. */
3767 /* The position on that root window. */
3770 /* More trash we can't trust. */
3773 /* Modifier keys and pointer buttons, about which
3775 (unsigned int *) &dummy
);
3777 /* Now we have a position on the root; find the innermost window
3778 containing the pointer. */
3782 int parent_x
= 0, parent_y
= 0;
3786 /* XTranslateCoordinates can get errors if the window
3787 structure is changing at the same time this function
3788 is running. So at least we must not crash from them. */
3790 x_catch_errors (FRAME_X_DISPLAY (*fp
));
3792 if (FRAME_X_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
3793 && FRAME_LIVE_P (last_mouse_frame
))
3795 /* If mouse was grabbed on a frame, give coords for that frame
3796 even if the mouse is now outside it. */
3797 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3799 /* From-window, to-window. */
3800 root
, FRAME_X_WINDOW (last_mouse_frame
),
3802 /* From-position, to-position. */
3803 root_x
, root_y
, &win_x
, &win_y
,
3807 f1
= last_mouse_frame
;
3813 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3815 /* From-window, to-window. */
3818 /* From-position, to-position. */
3819 root_x
, root_y
, &win_x
, &win_y
,
3824 if (child
== None
|| child
== win
)
3827 /* We don't wan't to know the innermost window. We
3828 want the edit window. For non-Gtk+ the innermost
3829 window is the edit window. For Gtk+ it might not
3830 be. It might be the tool bar for example. */
3831 if (x_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
))
3839 /* Now we know that:
3840 win is the innermost window containing the pointer
3841 (XTC says it has no child containing the pointer),
3842 win_x and win_y are the pointer's position in it
3843 (XTC did this the last time through), and
3844 parent_x and parent_y are the pointer's position in win's parent.
3845 (They are what win_x and win_y were when win was child.
3846 If win is the root window, it has no parent, and
3847 parent_{x,y} are invalid, but that's okay, because we'll
3848 never use them in that case.) */
3851 /* We don't wan't to know the innermost window. We
3852 want the edit window. */
3853 f1
= x_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
3855 /* Is win one of our frames? */
3856 f1
= x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
3859 #ifdef USE_X_TOOLKIT
3860 /* If we end up with the menu bar window, say it's not
3863 && f1
->output_data
.x
->menubar_widget
3864 && win
== XtWindow (f1
->output_data
.x
->menubar_widget
))
3866 #endif /* USE_X_TOOLKIT */
3869 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
3872 x_uncatch_errors ();
3874 /* If not, is it one of our scroll bars? */
3877 struct scroll_bar
*bar
;
3879 bar
= x_window_to_scroll_bar (FRAME_X_DISPLAY (*fp
), win
);
3883 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3889 if (f1
== 0 && insist
> 0)
3890 f1
= SELECTED_FRAME ();
3894 /* Ok, we found a frame. Store all the values.
3895 last_mouse_glyph is a rectangle used to reduce the
3896 generation of mouse events. To not miss any motion
3897 events, we must divide the frame into rectangles of the
3898 size of the smallest character that could be displayed
3899 on it, i.e. into the same rectangles that matrices on
3900 the frame are divided into. */
3902 remember_mouse_glyph (f1
, win_x
, win_y
, &last_mouse_glyph
);
3903 last_mouse_glyph_frame
= f1
;
3908 XSETINT (*x
, win_x
);
3909 XSETINT (*y
, win_y
);
3910 *time
= last_mouse_movement_time
;
3920 /***********************************************************************
3922 ***********************************************************************/
3924 /* Scroll bar support. */
3926 /* Given an X window ID and a DISPLAY, find the struct scroll_bar which
3928 This can be called in GC, so we have to make sure to strip off mark
3931 static struct scroll_bar
*
3932 x_window_to_scroll_bar (Display
*display
, Window window_id
)
3936 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
3937 window_id
= (Window
) xg_get_scroll_id_for_window (display
, window_id
);
3938 #endif /* USE_GTK && USE_TOOLKIT_SCROLL_BARS */
3940 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
3942 Lisp_Object frame
, bar
, condemned
;
3944 frame
= XCAR (tail
);
3945 /* All elements of Vframe_list should be frames. */
3946 if (! FRAMEP (frame
))
3949 if (! FRAME_X_P (XFRAME (frame
)))
3952 /* Scan this frame's scroll bar list for a scroll bar with the
3954 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3955 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3956 /* This trick allows us to search both the ordinary and
3957 condemned scroll bar lists with one loop. */
3958 ! NILP (bar
) || (bar
= condemned
,
3961 bar
= XSCROLL_BAR (bar
)->next
)
3962 if (XSCROLL_BAR (bar
)->x_window
== window_id
&&
3963 FRAME_X_DISPLAY (XFRAME (frame
)) == display
)
3964 return XSCROLL_BAR (bar
);
3971 #if defined USE_LUCID
3973 /* Return the Lucid menu bar WINDOW is part of. Return null
3974 if WINDOW is not part of a menu bar. */
3977 x_window_to_menu_bar (window
)
3982 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
3984 if (FRAME_X_P (XFRAME (XCAR (tail
))))
3986 Lisp_Object frame
= XCAR (tail
);
3987 Widget menu_bar
= XFRAME (frame
)->output_data
.x
->menubar_widget
;
3989 if (menu_bar
&& xlwmenu_window_p (menu_bar
, window
))
3997 #endif /* USE_LUCID */
4000 /************************************************************************
4002 ************************************************************************/
4004 #ifdef USE_TOOLKIT_SCROLL_BARS
4006 static void x_scroll_bar_to_input_event (XEvent
*, struct input_event
*);
4007 static void x_send_scroll_bar_event (Lisp_Object
, int, int, int);
4008 static void x_create_toolkit_scroll_bar (struct frame
*,
4009 struct scroll_bar
*);
4010 static void x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*,
4014 /* Lisp window being scrolled. Set when starting to interact with
4015 a toolkit scroll bar, reset to nil when ending the interaction. */
4017 static Lisp_Object window_being_scrolled
;
4019 /* Last scroll bar part sent in xm_scroll_callback. */
4021 static int last_scroll_bar_part
;
4023 /* Whether this is an Xaw with arrow-scrollbars. This should imply
4024 that movements of 1/20 of the screen size are mapped to up/down. */
4027 /* Id of action hook installed for scroll bars. */
4029 static XtActionHookId action_hook_id
;
4031 static Boolean xaw3d_arrow_scroll
;
4033 /* Whether the drag scrolling maintains the mouse at the top of the
4034 thumb. If not, resizing the thumb needs to be done more carefully
4035 to avoid jerkyness. */
4037 static Boolean xaw3d_pick_top
;
4039 /* Action hook installed via XtAppAddActionHook when toolkit scroll
4040 bars are used.. The hook is responsible for detecting when
4041 the user ends an interaction with the scroll bar, and generates
4042 a `end-scroll' SCROLL_BAR_CLICK_EVENT' event if so. */
4045 xt_action_hook (widget
, client_data
, action_name
, event
, params
,
4048 XtPointer client_data
;
4052 Cardinal
*num_params
;
4058 scroll_bar_p
= XmIsScrollBar (widget
);
4059 end_action
= "Release";
4060 #else /* !USE_MOTIF i.e. use Xaw */
4061 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
4062 end_action
= "EndScroll";
4063 #endif /* USE_MOTIF */
4066 && strcmp (action_name
, end_action
) == 0
4067 && WINDOWP (window_being_scrolled
))
4071 x_send_scroll_bar_event (window_being_scrolled
,
4072 scroll_bar_end_scroll
, 0, 0);
4073 w
= XWINDOW (window_being_scrolled
);
4075 if (!NILP (XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
))
4077 XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
= Qnil
;
4078 /* The thumb size is incorrect while dragging: fix it. */
4079 set_vertical_scroll_bar (w
);
4081 window_being_scrolled
= Qnil
;
4082 last_scroll_bar_part
= -1;
4084 /* Xt timeouts no longer needed. */
4085 toolkit_scroll_bar_interaction
= 0;
4088 #endif /* not USE_GTK */
4090 /* A vector of windows used for communication between
4091 x_send_scroll_bar_event and x_scroll_bar_to_input_event. */
4093 static struct window
**scroll_bar_windows
;
4094 static int scroll_bar_windows_size
;
4097 /* Send a client message with message type Xatom_Scrollbar for a
4098 scroll action to the frame of WINDOW. PART is a value identifying
4099 the part of the scroll bar that was clicked on. PORTION is the
4100 amount to scroll of a whole of WHOLE. */
4103 x_send_scroll_bar_event (Lisp_Object window
, int part
, int portion
, int whole
)
4106 XClientMessageEvent
*ev
= (XClientMessageEvent
*) &event
;
4107 struct window
*w
= XWINDOW (window
);
4108 struct frame
*f
= XFRAME (w
->frame
);
4113 /* Construct a ClientMessage event to send to the frame. */
4114 ev
->type
= ClientMessage
;
4115 ev
->message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_Scrollbar
;
4116 ev
->display
= FRAME_X_DISPLAY (f
);
4117 ev
->window
= FRAME_X_WINDOW (f
);
4120 /* We can only transfer 32 bits in the XClientMessageEvent, which is
4121 not enough to store a pointer or Lisp_Object on a 64 bit system.
4122 So, store the window in scroll_bar_windows and pass the index
4123 into that array in the event. */
4124 for (i
= 0; i
< scroll_bar_windows_size
; ++i
)
4125 if (scroll_bar_windows
[i
] == NULL
)
4128 if (i
== scroll_bar_windows_size
)
4130 int new_size
= max (10, 2 * scroll_bar_windows_size
);
4131 size_t nbytes
= new_size
* sizeof *scroll_bar_windows
;
4132 size_t old_nbytes
= scroll_bar_windows_size
* sizeof *scroll_bar_windows
;
4134 scroll_bar_windows
= (struct window
**) xrealloc (scroll_bar_windows
,
4136 bzero (&scroll_bar_windows
[i
], nbytes
- old_nbytes
);
4137 scroll_bar_windows_size
= new_size
;
4140 scroll_bar_windows
[i
] = w
;
4141 ev
->data
.l
[0] = (long) i
;
4142 ev
->data
.l
[1] = (long) part
;
4143 ev
->data
.l
[2] = (long) 0;
4144 ev
->data
.l
[3] = (long) portion
;
4145 ev
->data
.l
[4] = (long) whole
;
4147 /* Make Xt timeouts work while the scroll bar is active. */
4148 toolkit_scroll_bar_interaction
= 1;
4149 #ifdef USE_X_TOOLKIT
4150 x_activate_timeout_atimer ();
4153 /* Setting the event mask to zero means that the message will
4154 be sent to the client that created the window, and if that
4155 window no longer exists, no event will be sent. */
4156 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
4161 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
4165 x_scroll_bar_to_input_event (XEvent
*event
, struct input_event
*ievent
)
4167 XClientMessageEvent
*ev
= (XClientMessageEvent
*) event
;
4172 w
= scroll_bar_windows
[ev
->data
.l
[0]];
4173 scroll_bar_windows
[ev
->data
.l
[0]] = NULL
;
4175 XSETWINDOW (window
, w
);
4176 f
= XFRAME (w
->frame
);
4178 ievent
->kind
= SCROLL_BAR_CLICK_EVENT
;
4179 ievent
->frame_or_window
= window
;
4182 ievent
->timestamp
= CurrentTime
;
4184 ievent
->timestamp
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
4186 ievent
->part
= ev
->data
.l
[1];
4187 ievent
->code
= ev
->data
.l
[2];
4188 ievent
->x
= make_number ((int) ev
->data
.l
[3]);
4189 ievent
->y
= make_number ((int) ev
->data
.l
[4]);
4190 ievent
->modifiers
= 0;
4196 /* Minimum and maximum values used for Motif scroll bars. */
4198 #define XM_SB_MAX 10000000
4201 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
4202 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
4203 CALL_DATA is a pointer to a XmScrollBarCallbackStruct. */
4206 xm_scroll_callback (widget
, client_data
, call_data
)
4208 XtPointer client_data
, call_data
;
4210 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4211 XmScrollBarCallbackStruct
*cs
= (XmScrollBarCallbackStruct
*) call_data
;
4212 int part
= -1, whole
= 0, portion
= 0;
4216 case XmCR_DECREMENT
:
4217 bar
->dragging
= Qnil
;
4218 part
= scroll_bar_up_arrow
;
4221 case XmCR_INCREMENT
:
4222 bar
->dragging
= Qnil
;
4223 part
= scroll_bar_down_arrow
;
4226 case XmCR_PAGE_DECREMENT
:
4227 bar
->dragging
= Qnil
;
4228 part
= scroll_bar_above_handle
;
4231 case XmCR_PAGE_INCREMENT
:
4232 bar
->dragging
= Qnil
;
4233 part
= scroll_bar_below_handle
;
4237 bar
->dragging
= Qnil
;
4238 part
= scroll_bar_to_top
;
4241 case XmCR_TO_BOTTOM
:
4242 bar
->dragging
= Qnil
;
4243 part
= scroll_bar_to_bottom
;
4250 /* Get the slider size. */
4252 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
4255 whole
= XM_SB_MAX
- slider_size
;
4256 portion
= min (cs
->value
, whole
);
4257 part
= scroll_bar_handle
;
4258 bar
->dragging
= make_number (cs
->value
);
4262 case XmCR_VALUE_CHANGED
:
4268 window_being_scrolled
= bar
->window
;
4269 last_scroll_bar_part
= part
;
4270 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4274 #elif defined USE_GTK
4276 /* Scroll bar callback for GTK scroll bars. WIDGET is the scroll
4277 bar widget. DATA is a pointer to the scroll_bar structure. */
4280 xg_scroll_callback (GtkRange
*range
,
4281 GtkScrollType scroll
,
4285 struct scroll_bar
*bar
= (struct scroll_bar
*) user_data
;
4287 int part
= -1, whole
= 0, portion
= 0;
4288 GtkAdjustment
*adj
= GTK_ADJUSTMENT (gtk_range_get_adjustment (range
));
4289 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (range
), XG_FRAME_DATA
);
4291 if (xg_ignore_gtk_scrollbar
) return FALSE
;
4292 position
= gtk_adjustment_get_value (adj
);
4297 case GTK_SCROLL_JUMP
:
4298 /* Buttons 1 2 or 3 must be grabbed. */
4299 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
!= 0
4300 && FRAME_X_DISPLAY_INFO (f
)->grabbed
< (1 << 4))
4302 part
= scroll_bar_handle
;
4303 whole
= gtk_adjustment_get_upper (adj
) -
4304 gtk_adjustment_get_page_size (adj
);
4305 portion
= min ((int)position
, whole
);
4306 bar
->dragging
= make_number ((int)portion
);
4309 case GTK_SCROLL_STEP_BACKWARD
:
4310 part
= scroll_bar_up_arrow
;
4311 bar
->dragging
= Qnil
;
4313 case GTK_SCROLL_STEP_FORWARD
:
4314 part
= scroll_bar_down_arrow
;
4315 bar
->dragging
= Qnil
;
4317 case GTK_SCROLL_PAGE_BACKWARD
:
4318 part
= scroll_bar_above_handle
;
4319 bar
->dragging
= Qnil
;
4321 case GTK_SCROLL_PAGE_FORWARD
:
4322 part
= scroll_bar_below_handle
;
4323 bar
->dragging
= Qnil
;
4329 window_being_scrolled
= bar
->window
;
4330 last_scroll_bar_part
= part
;
4331 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4337 /* Callback for button release. Sets dragging to Qnil when dragging is done. */
4340 xg_end_scroll_callback (GtkWidget
*widget
,
4341 GdkEventButton
*event
,
4344 struct scroll_bar
*bar
= (struct scroll_bar
*) user_data
;
4345 bar
->dragging
= Qnil
;
4346 if (WINDOWP (window_being_scrolled
))
4348 x_send_scroll_bar_event (window_being_scrolled
,
4349 scroll_bar_end_scroll
, 0, 0);
4350 window_being_scrolled
= Qnil
;
4357 #else /* not USE_GTK and not USE_MOTIF */
4359 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
4360 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
4361 scroll bar struct. CALL_DATA is a pointer to a float saying where
4365 xaw_jump_callback (widget
, client_data
, call_data
)
4367 XtPointer client_data
, call_data
;
4369 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4370 float top
= *(float *) call_data
;
4372 int whole
, portion
, height
;
4375 /* Get the size of the thumb, a value between 0 and 1. */
4377 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
4381 portion
= shown
< 1 ? top
* whole
: 0;
4383 if (shown
< 1 && (eabs (top
+ shown
- 1) < 1.0/height
))
4384 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
4385 the bottom, so we force the scrolling whenever we see that we're
4386 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
4387 we try to ensure that we always stay two pixels away from the
4389 part
= scroll_bar_down_arrow
;
4391 part
= scroll_bar_handle
;
4393 window_being_scrolled
= bar
->window
;
4394 bar
->dragging
= make_number (portion
);
4395 last_scroll_bar_part
= part
;
4396 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4400 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
4401 i.e. line or page up or down. WIDGET is the Xaw scroll bar
4402 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
4403 the scroll bar. CALL_DATA is an integer specifying the action that
4404 has taken place. Its magnitude is in the range 0..height of the
4405 scroll bar. Negative values mean scroll towards buffer start.
4406 Values < height of scroll bar mean line-wise movement. */
4409 xaw_scroll_callback (widget
, client_data
, call_data
)
4411 XtPointer client_data
, call_data
;
4413 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4414 /* The position really is stored cast to a pointer. */
4415 int position
= (long) call_data
;
4419 /* Get the height of the scroll bar. */
4421 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
4424 if (eabs (position
) >= height
)
4425 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
4427 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
4428 it maps line-movement to call_data = max(5, height/20). */
4429 else if (xaw3d_arrow_scroll
&& eabs (position
) <= max (5, height
/ 20))
4430 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
4432 part
= scroll_bar_move_ratio
;
4434 window_being_scrolled
= bar
->window
;
4435 bar
->dragging
= Qnil
;
4436 last_scroll_bar_part
= part
;
4437 x_send_scroll_bar_event (bar
->window
, part
, position
, height
);
4440 #endif /* not USE_GTK and not USE_MOTIF */
4442 #define SCROLL_BAR_NAME "verticalScrollBar"
4444 /* Create the widget for scroll bar BAR on frame F. Record the widget
4445 and X window of the scroll bar in BAR. */
4449 x_create_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
4451 char *scroll_bar_name
= SCROLL_BAR_NAME
;
4454 xg_create_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
4455 G_CALLBACK (xg_end_scroll_callback
),
4460 #else /* not USE_GTK */
4463 x_create_toolkit_scroll_bar (f
, bar
)
4465 struct scroll_bar
*bar
;
4471 char *scroll_bar_name
= SCROLL_BAR_NAME
;
4472 unsigned long pixel
;
4477 /* Set resources. Create the widget. */
4478 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4479 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
4480 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
4481 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
4482 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
4483 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
4484 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
4486 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4489 XtSetArg (av
[ac
], XmNforeground
, pixel
);
4493 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4496 XtSetArg (av
[ac
], XmNbackground
, pixel
);
4500 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
4501 scroll_bar_name
, av
, ac
);
4503 /* Add one callback for everything that can happen. */
4504 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
4506 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
4508 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
4510 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
4512 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
4514 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
4516 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
4519 /* Realize the widget. Only after that is the X window created. */
4520 XtRealizeWidget (widget
);
4522 /* Set the cursor to an arrow. I didn't find a resource to do that.
4523 And I'm wondering why it hasn't an arrow cursor by default. */
4524 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
4525 f
->output_data
.x
->nontext_cursor
);
4527 #else /* !USE_MOTIF i.e. use Xaw */
4529 /* Set resources. Create the widget. The background of the
4530 Xaw3d scroll bar widget is a little bit light for my taste.
4531 We don't alter it here to let users change it according
4532 to their taste with `emacs*verticalScrollBar.background: xxx'. */
4533 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4534 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
4535 /* For smoother scrolling with Xaw3d -sm */
4536 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
4538 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4541 XtSetArg (av
[ac
], XtNforeground
, pixel
);
4545 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4548 XtSetArg (av
[ac
], XtNbackground
, pixel
);
4552 /* Top/bottom shadow colors. */
4554 /* Allocate them, if necessary. */
4555 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
4557 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4560 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
4561 FRAME_X_COLORMAP (f
),
4562 &pixel
, 1.2, 0x8000))
4564 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
4567 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4569 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4572 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
4573 FRAME_X_COLORMAP (f
),
4574 &pixel
, 0.6, 0x4000))
4576 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
4580 #ifdef XtNbeNiceToColormap
4581 /* Tell the toolkit about them. */
4582 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
4583 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4584 /* We tried to allocate a color for the top/bottom shadow, and
4585 failed, so tell Xaw3d to use dithering instead. */
4587 XtSetArg (av
[ac
], XtNbeNiceToColormap
, True
);
4591 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
4592 be more consistent with other emacs 3d colors, and since Xaw3d is
4593 not good at dealing with allocation failure. */
4595 /* This tells Xaw3d to use real colors instead of dithering for
4597 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
4600 /* Specify the colors. */
4601 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
4604 XtSetArg (av
[ac
], XtNtopShadowPixel
, pixel
);
4607 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
4610 XtSetArg (av
[ac
], XtNbottomShadowPixel
, pixel
);
4616 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
4617 f
->output_data
.x
->edit_widget
, av
, ac
);
4621 char *val
= initial
;
4622 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
4623 #ifdef XtNarrowScrollbars
4624 XtNarrowScrollbars
, (XtPointer
) &xaw3d_arrow_scroll
,
4626 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
4627 if (xaw3d_arrow_scroll
|| val
== initial
)
4628 { /* ARROW_SCROLL */
4629 xaw3d_arrow_scroll
= True
;
4630 /* Isn't that just a personal preference ? --Stef */
4631 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
4635 /* Define callbacks. */
4636 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
4637 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
4640 /* Realize the widget. Only after that is the X window created. */
4641 XtRealizeWidget (widget
);
4643 #endif /* !USE_MOTIF */
4645 /* Install an action hook that lets us detect when the user
4646 finishes interacting with a scroll bar. */
4647 if (action_hook_id
== 0)
4648 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
4650 /* Remember X window and widget in the scroll bar vector. */
4651 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
4652 xwindow
= XtWindow (widget
);
4653 bar
->x_window
= xwindow
;
4657 #endif /* not USE_GTK */
4660 /* Set the thumb size and position of scroll bar BAR. We are currently
4661 displaying PORTION out of a whole WHOLE, and our position POSITION. */
4665 x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
, int whole
)
4667 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
4670 #else /* not USE_GTK */
4672 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
4673 struct scroll_bar
*bar
;
4674 int portion
, position
, whole
;
4676 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4677 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4684 /* We use an estimate of 30 chars per line rather than the real
4685 `portion' value. This has the disadvantage that the thumb size
4686 is not very representative, but it makes our life a lot easier.
4687 Otherwise, we have to constantly adjust the thumb size, which
4688 we can't always do quickly enough: while dragging, the size of
4689 the thumb might prevent the user from dragging the thumb all the
4690 way to the end. but Motif and some versions of Xaw3d don't allow
4691 updating the thumb size while dragging. Also, even if we can update
4692 its size, the update will often happen too late.
4693 If you don't believe it, check out revision 1.650 of xterm.c to see
4694 what hoops we were going through and the still poor behavior we got. */
4695 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
4696 /* When the thumb is at the bottom, position == whole.
4697 So we need to increase `whole' to make space for the thumb. */
4704 top
= (float) position
/ whole
;
4705 shown
= (float) portion
/ whole
;
4708 if (NILP (bar
->dragging
))
4712 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
4713 is the scroll bar's maximum and MIN is the scroll bar's minimum
4715 size
= shown
* XM_SB_MAX
;
4716 size
= min (size
, XM_SB_MAX
);
4717 size
= max (size
, 1);
4719 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
4720 value
= top
* XM_SB_MAX
;
4721 value
= min (value
, XM_SB_MAX
- size
);
4723 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
4725 #else /* !USE_MOTIF i.e. use Xaw */
4731 top
= (float) position
/ whole
;
4732 shown
= (float) portion
/ whole
;
4736 float old_top
, old_shown
;
4738 XtVaGetValues (widget
,
4739 XtNtopOfThumb
, &old_top
,
4740 XtNshown
, &old_shown
,
4744 /* Massage the top+shown values. */
4745 if (NILP (bar
->dragging
) || last_scroll_bar_part
== scroll_bar_down_arrow
)
4746 top
= max (0, min (1, top
));
4749 /* Keep two pixels available for moving the thumb down. */
4750 shown
= max (0, min (1 - top
- (2.0 / height
), shown
));
4752 /* If the call to XawScrollbarSetThumb below doesn't seem to work,
4753 check that your system's configuration file contains a define
4754 for `NARROWPROTO'. See s/freebsd.h for an example. */
4755 if (top
!= old_top
|| shown
!= old_shown
)
4757 if (NILP (bar
->dragging
))
4758 XawScrollbarSetThumb (widget
, top
, shown
);
4761 /* Try to make the scrolling a tad smoother. */
4762 if (!xaw3d_pick_top
)
4763 shown
= min (shown
, old_shown
);
4765 XawScrollbarSetThumb (widget
, top
, shown
);
4769 #endif /* !USE_MOTIF */
4773 #endif /* not USE_GTK */
4775 #endif /* USE_TOOLKIT_SCROLL_BARS */
4779 /************************************************************************
4780 Scroll bars, general
4781 ************************************************************************/
4783 /* Create a scroll bar and return the scroll bar vector for it. W is
4784 the Emacs window on which to create the scroll bar. TOP, LEFT,
4785 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
4788 static struct scroll_bar
*
4789 x_scroll_bar_create (struct window
*w
, int top
, int left
, int width
, int height
)
4791 struct frame
*f
= XFRAME (w
->frame
);
4792 struct scroll_bar
*bar
4793 = ALLOCATE_PSEUDOVECTOR (struct scroll_bar
, x_window
, PVEC_OTHER
);
4797 #ifdef USE_TOOLKIT_SCROLL_BARS
4798 x_create_toolkit_scroll_bar (f
, bar
);
4799 #else /* not USE_TOOLKIT_SCROLL_BARS */
4801 XSetWindowAttributes a
;
4805 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4806 if (a
.background_pixel
== -1)
4807 a
.background_pixel
= FRAME_BACKGROUND_PIXEL (f
);
4809 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
4810 | ButtonMotionMask
| PointerMotionHintMask
4812 a
.cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
4814 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
4816 /* Clear the area of W that will serve as a scroll bar. This is
4817 for the case that a window has been split horizontally. In
4818 this case, no clear_frame is generated to reduce flickering. */
4819 if (width
> 0 && height
> 0)
4820 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4822 window_box_height (w
), False
);
4824 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4825 /* Position and size of scroll bar. */
4826 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4828 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4830 /* Border width, depth, class, and visual. */
4837 bar
->x_window
= window
;
4839 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4841 XSETWINDOW (bar
->window
, w
);
4845 bar
->height
= height
;
4848 bar
->dragging
= Qnil
;
4849 bar
->fringe_extended_p
= 0;
4851 /* Add bar to its frame's list of scroll bars. */
4852 bar
->next
= FRAME_SCROLL_BARS (f
);
4854 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
4855 if (!NILP (bar
->next
))
4856 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4858 /* Map the window/widget. */
4859 #ifdef USE_TOOLKIT_SCROLL_BARS
4862 xg_update_scrollbar_pos (f
,
4865 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4866 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4868 #else /* not USE_GTK */
4869 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4870 XtConfigureWidget (scroll_bar
,
4871 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4873 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4874 max (height
, 1), 0);
4875 XtMapWidget (scroll_bar
);
4876 #endif /* not USE_GTK */
4878 #else /* not USE_TOOLKIT_SCROLL_BARS */
4879 XMapRaised (FRAME_X_DISPLAY (f
), bar
->x_window
);
4880 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4887 #ifndef USE_TOOLKIT_SCROLL_BARS
4889 /* Draw BAR's handle in the proper position.
4891 If the handle is already drawn from START to END, don't bother
4892 redrawing it, unless REBUILD is non-zero; in that case, always
4893 redraw it. (REBUILD is handy for drawing the handle after expose
4896 Normally, we want to constrain the start and end of the handle to
4897 fit inside its rectangle, but if the user is dragging the scroll
4898 bar handle, we want to let them drag it down all the way, so that
4899 the bar's top is as far down as it goes; otherwise, there's no way
4900 to move to the very end of the buffer. */
4903 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
4904 struct scroll_bar
*bar
;
4908 int dragging
= ! NILP (bar
->dragging
);
4909 Window w
= bar
->x_window
;
4910 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4911 GC gc
= f
->output_data
.x
->normal_gc
;
4913 /* If the display is already accurate, do nothing. */
4915 && start
== bar
->start
4922 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, bar
->width
);
4923 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, bar
->height
);
4924 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
4926 /* Make sure the values are reasonable, and try to preserve
4927 the distance between start and end. */
4929 int length
= end
- start
;
4933 else if (start
> top_range
)
4935 end
= start
+ length
;
4939 else if (end
> top_range
&& ! dragging
)
4943 /* Store the adjusted setting in the scroll bar. */
4947 /* Clip the end position, just for display. */
4948 if (end
> top_range
)
4951 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
4952 below top positions, to make sure the handle is always at least
4953 that many pixels tall. */
4954 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4956 /* Draw the empty space above the handle. Note that we can't clear
4957 zero-height areas; that means "clear to end of window." */
4959 x_clear_area (FRAME_X_DISPLAY (f
), w
,
4960 /* x, y, width, height, and exposures. */
4961 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4962 VERTICAL_SCROLL_BAR_TOP_BORDER
,
4963 inside_width
, start
,
4966 /* Change to proper foreground color if one is specified. */
4967 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
4968 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
4969 f
->output_data
.x
->scroll_bar_foreground_pixel
);
4971 /* Draw the handle itself. */
4972 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
4973 /* x, y, width, height */
4974 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4975 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
4976 inside_width
, end
- start
);
4978 /* Restore the foreground color of the GC if we changed it above. */
4979 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
4980 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
4981 FRAME_FOREGROUND_PIXEL (f
));
4983 /* Draw the empty space below the handle. Note that we can't
4984 clear zero-height areas; that means "clear to end of window." */
4985 if (end
< inside_height
)
4986 x_clear_area (FRAME_X_DISPLAY (f
), w
,
4987 /* x, y, width, height, and exposures. */
4988 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4989 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
4990 inside_width
, inside_height
- end
,
4998 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5000 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
5004 x_scroll_bar_remove (struct scroll_bar
*bar
)
5006 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5009 #ifdef USE_TOOLKIT_SCROLL_BARS
5011 xg_remove_scroll_bar (f
, bar
->x_window
);
5012 #else /* not USE_GTK */
5013 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
5014 #endif /* not USE_GTK */
5016 XDestroyWindow (FRAME_X_DISPLAY (f
), bar
->x_window
);
5019 /* Disassociate this scroll bar from its window. */
5020 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
5026 /* Set the handle of the vertical scroll bar for WINDOW to indicate
5027 that we are displaying PORTION characters out of a total of WHOLE
5028 characters, starting at POSITION. If WINDOW has no scroll bar,
5032 XTset_vertical_scroll_bar (struct window
*w
, int portion
, int whole
, int position
)
5034 struct frame
*f
= XFRAME (w
->frame
);
5035 struct scroll_bar
*bar
;
5036 int top
, height
, left
, sb_left
, width
, sb_width
;
5037 int window_y
, window_height
;
5038 #ifdef USE_TOOLKIT_SCROLL_BARS
5039 int fringe_extended_p
;
5042 /* Get window dimensions. */
5043 window_box (w
, -1, 0, &window_y
, 0, &window_height
);
5045 width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
5046 height
= window_height
;
5048 /* Compute the left edge of the scroll bar area. */
5049 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
5051 /* Compute the width of the scroll bar which might be less than
5052 the width of the area reserved for the scroll bar. */
5053 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
) > 0)
5054 sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
5058 /* Compute the left edge of the scroll bar. */
5059 #ifdef USE_TOOLKIT_SCROLL_BARS
5060 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
5061 sb_left
= left
+ (WINDOW_RIGHTMOST_P (w
) ? width
- sb_width
: 0);
5063 sb_left
= left
+ (WINDOW_LEFTMOST_P (w
) ? 0 : width
- sb_width
);
5065 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
5066 sb_left
= left
+ width
- sb_width
;
5071 #ifdef USE_TOOLKIT_SCROLL_BARS
5072 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
5073 fringe_extended_p
= (WINDOW_LEFTMOST_P (w
)
5074 && WINDOW_LEFT_FRINGE_WIDTH (w
)
5075 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5076 || WINDOW_LEFT_MARGIN_COLS (w
) == 0));
5078 fringe_extended_p
= (WINDOW_RIGHTMOST_P (w
)
5079 && WINDOW_RIGHT_FRINGE_WIDTH (w
)
5080 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5081 || WINDOW_RIGHT_MARGIN_COLS (w
) == 0));
5084 /* Does the scroll bar exist yet? */
5085 if (NILP (w
->vertical_scroll_bar
))
5087 if (width
> 0 && height
> 0)
5090 #ifdef USE_TOOLKIT_SCROLL_BARS
5091 if (fringe_extended_p
)
5092 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5093 sb_left
, top
, sb_width
, height
, False
);
5096 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5097 left
, top
, width
, height
, False
);
5101 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
5105 /* It may just need to be moved and resized. */
5106 unsigned int mask
= 0;
5108 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5112 if (sb_left
!= bar
->left
)
5114 if (top
!= bar
->top
)
5116 if (sb_width
!= bar
->width
)
5118 if (height
!= bar
->height
)
5121 #ifdef USE_TOOLKIT_SCROLL_BARS
5123 /* Move/size the scroll bar widget. */
5124 if (mask
|| bar
->fringe_extended_p
!= fringe_extended_p
)
5126 /* Since toolkit scroll bars are smaller than the space reserved
5127 for them on the frame, we have to clear "under" them. */
5128 if (width
> 0 && height
> 0)
5130 if (fringe_extended_p
)
5131 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5132 sb_left
, top
, sb_width
, height
, False
);
5134 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5135 left
, top
, width
, height
, False
);
5138 xg_update_scrollbar_pos (f
,
5141 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5142 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
*2,
5144 #else /* not USE_GTK */
5145 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
5146 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5148 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
5149 max (height
, 1), 0);
5150 #endif /* not USE_GTK */
5152 #else /* not USE_TOOLKIT_SCROLL_BARS */
5154 /* Clear areas not covered by the scroll bar because of
5155 VERTICAL_SCROLL_BAR_WIDTH_TRIM. */
5156 if (VERTICAL_SCROLL_BAR_WIDTH_TRIM
)
5158 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5159 left
, top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5161 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5162 left
+ width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5163 top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5167 /* Clear areas not covered by the scroll bar because it's not as
5168 wide as the area reserved for it. This makes sure a
5169 previous mode line display is cleared after C-x 2 C-x 1, for
5172 int area_width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
5173 int rest
= area_width
- sb_width
;
5174 if (rest
> 0 && height
> 0)
5176 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
5177 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5178 left
+ area_width
- rest
, top
,
5179 rest
, height
, False
);
5181 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5182 left
, top
, rest
, height
, False
);
5186 /* Move/size the scroll bar window. */
5191 wc
.x
= sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5193 wc
.width
= sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2;
5195 XConfigureWindow (FRAME_X_DISPLAY (f
), bar
->x_window
,
5199 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5201 /* Remember new settings. */
5202 bar
->left
= sb_left
;
5204 bar
->width
= sb_width
;
5205 bar
->height
= height
;
5210 #ifdef USE_TOOLKIT_SCROLL_BARS
5211 bar
->fringe_extended_p
= fringe_extended_p
;
5213 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
5214 #else /* not USE_TOOLKIT_SCROLL_BARS */
5215 /* Set the scroll bar's current state, unless we're currently being
5217 if (NILP (bar
->dragging
))
5219 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
5222 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
5225 int start
= ((double) position
* top_range
) / whole
;
5226 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
5227 x_scroll_bar_set_handle (bar
, start
, end
, 0);
5230 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5232 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
5236 /* The following three hooks are used when we're doing a thorough
5237 redisplay of the frame. We don't explicitly know which scroll bars
5238 are going to be deleted, because keeping track of when windows go
5239 away is a real pain - "Can you say set-window-configuration, boys
5240 and girls?" Instead, we just assert at the beginning of redisplay
5241 that *all* scroll bars are to be removed, and then save a scroll bar
5242 from the fiery pit when we actually redisplay its window. */
5244 /* Arrange for all scroll bars on FRAME to be removed at the next call
5245 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
5246 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
5249 XTcondemn_scroll_bars (FRAME_PTR frame
)
5251 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
5252 while (! NILP (FRAME_SCROLL_BARS (frame
)))
5255 bar
= FRAME_SCROLL_BARS (frame
);
5256 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
5257 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
5258 XSCROLL_BAR (bar
)->prev
= Qnil
;
5259 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
5260 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
5261 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
5266 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
5267 Note that WINDOW isn't necessarily condemned at all. */
5270 XTredeem_scroll_bar (struct window
*window
)
5272 struct scroll_bar
*bar
;
5275 /* We can't redeem this window's scroll bar if it doesn't have one. */
5276 if (NILP (window
->vertical_scroll_bar
))
5279 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
5281 /* Unlink it from the condemned list. */
5282 f
= XFRAME (WINDOW_FRAME (window
));
5283 if (NILP (bar
->prev
))
5285 /* If the prev pointer is nil, it must be the first in one of
5287 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
5288 /* It's not condemned. Everything's fine. */
5290 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
5291 window
->vertical_scroll_bar
))
5292 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
5294 /* If its prev pointer is nil, it must be at the front of
5295 one or the other! */
5299 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
5301 if (! NILP (bar
->next
))
5302 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
5304 bar
->next
= FRAME_SCROLL_BARS (f
);
5306 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
5307 if (! NILP (bar
->next
))
5308 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
5311 /* Remove all scroll bars on FRAME that haven't been saved since the
5312 last call to `*condemn_scroll_bars_hook'. */
5315 XTjudge_scroll_bars (FRAME_PTR f
)
5317 Lisp_Object bar
, next
;
5319 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
5321 /* Clear out the condemned list now so we won't try to process any
5322 more events on the hapless scroll bars. */
5323 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
5325 for (; ! NILP (bar
); bar
= next
)
5327 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
5329 x_scroll_bar_remove (b
);
5332 b
->next
= b
->prev
= Qnil
;
5335 /* Now there should be no references to the condemned scroll bars,
5336 and they should get garbage-collected. */
5340 #ifndef USE_TOOLKIT_SCROLL_BARS
5341 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
5342 is a no-op when using toolkit scroll bars.
5344 This may be called from a signal handler, so we have to ignore GC
5348 x_scroll_bar_expose (bar
, event
)
5349 struct scroll_bar
*bar
;
5352 Window w
= bar
->x_window
;
5353 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5354 GC gc
= f
->output_data
.x
->normal_gc
;
5355 int width_trim
= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5359 x_scroll_bar_set_handle (bar
, bar
->start
, bar
->end
, 1);
5361 /* Switch to scroll bar foreground color. */
5362 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5363 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5364 f
->output_data
.x
->scroll_bar_foreground_pixel
);
5366 /* Draw a one-pixel border just inside the edges of the scroll bar. */
5367 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
5369 /* x, y, width, height */
5371 bar
->width
- 1 - width_trim
- width_trim
,
5374 /* Restore the foreground color of the GC if we changed it above. */
5375 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5376 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5377 FRAME_FOREGROUND_PIXEL (f
));
5382 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5384 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
5385 is set to something other than NO_EVENT, it is enqueued.
5387 This may be called from a signal handler, so we have to ignore GC
5392 x_scroll_bar_handle_click (struct scroll_bar
*bar
, XEvent
*event
, struct input_event
*emacs_event
)
5394 if (! WINDOWP (bar
->window
))
5397 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
5398 emacs_event
->code
= event
->xbutton
.button
- Button1
;
5399 emacs_event
->modifiers
5400 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
5401 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
5402 event
->xbutton
.state
)
5403 | (event
->type
== ButtonRelease
5406 emacs_event
->frame_or_window
= bar
->window
;
5407 emacs_event
->arg
= Qnil
;
5408 emacs_event
->timestamp
= event
->xbutton
.time
;
5411 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
5412 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
5415 if (y
> top_range
) y
= top_range
;
5418 emacs_event
->part
= scroll_bar_above_handle
;
5419 else if (y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5420 emacs_event
->part
= scroll_bar_handle
;
5422 emacs_event
->part
= scroll_bar_below_handle
;
5424 #ifndef USE_TOOLKIT_SCROLL_BARS
5425 /* If the user has released the handle, set it to its final position. */
5426 if (event
->type
== ButtonRelease
5427 && ! NILP (bar
->dragging
))
5429 int new_start
= y
- XINT (bar
->dragging
);
5430 int new_end
= new_start
+ bar
->end
- bar
->start
;
5432 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5433 bar
->dragging
= Qnil
;
5437 XSETINT (emacs_event
->x
, y
);
5438 XSETINT (emacs_event
->y
, top_range
);
5442 #ifndef USE_TOOLKIT_SCROLL_BARS
5444 /* Handle some mouse motion while someone is dragging the scroll bar.
5446 This may be called from a signal handler, so we have to ignore GC
5450 x_scroll_bar_note_movement (bar
, event
)
5451 struct scroll_bar
*bar
;
5454 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
5456 last_mouse_movement_time
= event
->xmotion
.time
;
5459 XSETVECTOR (last_mouse_scroll_bar
, bar
);
5461 /* If we're dragging the bar, display it. */
5462 if (! NILP (bar
->dragging
))
5464 /* Where should the handle be now? */
5465 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
5467 if (new_start
!= bar
->start
)
5469 int new_end
= new_start
+ bar
->end
- bar
->start
;
5471 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5476 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5478 /* Return information to the user about the current position of the mouse
5479 on the scroll bar. */
5482 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
)
5484 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
5485 Window w
= bar
->x_window
;
5486 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5488 Window dummy_window
;
5490 unsigned int dummy_mask
;
5494 /* Get the mouse's position relative to the scroll bar window, and
5496 if (! XQueryPointer (FRAME_X_DISPLAY (f
), w
,
5498 /* Root, child, root x and root y. */
5499 &dummy_window
, &dummy_window
,
5500 &dummy_coord
, &dummy_coord
,
5502 /* Position relative to scroll bar. */
5505 /* Mouse buttons and modifier keys. */
5511 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
5513 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
5515 if (! NILP (bar
->dragging
))
5516 win_y
-= XINT (bar
->dragging
);
5520 if (win_y
> top_range
)
5524 *bar_window
= bar
->window
;
5526 if (! NILP (bar
->dragging
))
5527 *part
= scroll_bar_handle
;
5528 else if (win_y
< bar
->start
)
5529 *part
= scroll_bar_above_handle
;
5530 else if (win_y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5531 *part
= scroll_bar_handle
;
5533 *part
= scroll_bar_below_handle
;
5535 XSETINT (*x
, win_y
);
5536 XSETINT (*y
, top_range
);
5539 last_mouse_scroll_bar
= Qnil
;
5542 *time
= last_mouse_movement_time
;
5548 /* The screen has been cleared so we may have changed foreground or
5549 background colors, and the scroll bars may need to be redrawn.
5550 Clear out the scroll bars, and ask for expose events, so we can
5554 x_scroll_bar_clear (FRAME_PTR f
)
5556 #ifndef USE_TOOLKIT_SCROLL_BARS
5559 /* We can have scroll bars even if this is 0,
5560 if we just turned off scroll bar mode.
5561 But in that case we should not clear them. */
5562 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5563 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
5564 bar
= XSCROLL_BAR (bar
)->next
)
5565 XClearArea (FRAME_X_DISPLAY (f
),
5566 XSCROLL_BAR (bar
)->x_window
,
5568 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5572 /* The main X event-reading loop - XTread_socket. */
5574 /* This holds the state XLookupString needs to implement dead keys
5575 and other tricks known as "compose processing". _X Window System_
5576 says that a portable program can't use this, but Stephen Gildea assures
5577 me that letting the compiler initialize it to zeros will work okay.
5579 This must be defined outside of XTread_socket, for the same reasons
5580 given for enter_timestamp, above. */
5582 static XComposeStatus compose_status
;
5584 /* Record the last 100 characters stored
5585 to help debug the loss-of-chars-during-GC problem. */
5587 static int temp_index
;
5588 static short temp_buffer
[100];
5590 #define STORE_KEYSYM_FOR_DEBUG(keysym) \
5591 if (temp_index == sizeof temp_buffer / sizeof (short)) \
5593 temp_buffer[temp_index++] = (keysym)
5595 /* Set this to nonzero to fake an "X I/O error"
5596 on a particular display. */
5598 struct x_display_info
*XTread_socket_fake_io_error
;
5600 /* When we find no input here, we occasionally do a no-op command
5601 to verify that the X server is still running and we can still talk with it.
5602 We try all the open displays, one by one.
5603 This variable is used for cycling thru the displays. */
5605 static struct x_display_info
*next_noop_dpyinfo
;
5607 #define SET_SAVED_MENU_EVENT(size) \
5610 if (f->output_data.x->saved_menu_event == 0) \
5611 f->output_data.x->saved_menu_event \
5612 = (XEvent *) xmalloc (sizeof (XEvent)); \
5613 bcopy (&event, f->output_data.x->saved_menu_event, size); \
5614 inev.ie.kind = MENU_BAR_ACTIVATE_EVENT; \
5615 XSETFRAME (inev.ie.frame_or_window, f); \
5619 #define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
5620 #define SET_SAVED_KEY_EVENT SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
5630 /* Filter events for the current X input method.
5631 DPYINFO is the display this event is for.
5632 EVENT is the X event to filter.
5634 Returns non-zero if the event was filtered, caller shall not process
5636 Returns zero if event is wasn't filtered. */
5640 x_filter_event (struct x_display_info
*dpyinfo
, XEvent
*event
)
5642 /* XFilterEvent returns non-zero if the input method has
5643 consumed the event. We pass the frame's X window to
5644 XFilterEvent because that's the one for which the IC
5647 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
5648 event
->xclient
.window
);
5650 return XFilterEvent (event
, f1
? FRAME_X_WINDOW (f1
) : None
);
5655 static int current_count
;
5656 static int current_finish
;
5657 static struct input_event
*current_hold_quit
;
5659 /* This is the filter function invoked by the GTK event loop.
5660 It is invoked before the XEvent is translated to a GdkEvent,
5661 so we have a chance to act on the event before GTK. */
5662 static GdkFilterReturn
5663 event_handler_gdk (GdkXEvent
*gxev
, GdkEvent
*ev
, gpointer data
)
5665 XEvent
*xev
= (XEvent
*) gxev
;
5668 if (current_count
>= 0)
5670 struct x_display_info
*dpyinfo
;
5672 dpyinfo
= x_display_info_for_display (xev
->xany
.display
);
5675 /* Filter events for the current X input method.
5676 GTK calls XFilterEvent but not for key press and release,
5677 so we do it here. */
5678 if ((xev
->type
== KeyPress
|| xev
->type
== KeyRelease
)
5680 && x_filter_event (dpyinfo
, xev
))
5683 return GDK_FILTER_REMOVE
;
5688 current_finish
= X_EVENT_NORMAL
;
5691 handle_one_xevent (dpyinfo
, xev
, ¤t_finish
,
5695 current_finish
= x_dispatch_event (xev
, xev
->xany
.display
);
5699 if (current_finish
== X_EVENT_GOTO_OUT
|| current_finish
== X_EVENT_DROP
)
5700 return GDK_FILTER_REMOVE
;
5702 return GDK_FILTER_CONTINUE
;
5704 #endif /* USE_GTK */
5707 /* Handles the XEvent EVENT on display DPYINFO.
5709 *FINISH is X_EVENT_GOTO_OUT if caller should stop reading events.
5710 *FINISH is zero if caller should continue reading events.
5711 *FINISH is X_EVENT_DROP if event should not be passed to the toolkit.
5713 We return the number of characters stored into the buffer. */
5716 handle_one_xevent (struct x_display_info
*dpyinfo
, XEvent
*eventp
, int *finish
, struct input_event
*hold_quit
)
5719 struct input_event ie
;
5720 struct selection_input_event sie
;
5725 struct frame
*f
= NULL
;
5726 struct coding_system coding
;
5727 XEvent event
= *eventp
;
5729 *finish
= X_EVENT_NORMAL
;
5731 EVENT_INIT (inev
.ie
);
5732 inev
.ie
.kind
= NO_EVENT
;
5735 if (pending_event_wait
.eventtype
== event
.type
)
5736 pending_event_wait
.eventtype
= 0; /* Indicates we got it. */
5742 if (event
.xclient
.message_type
5743 == dpyinfo
->Xatom_wm_protocols
5744 && event
.xclient
.format
== 32)
5746 if (event
.xclient
.data
.l
[0]
5747 == dpyinfo
->Xatom_wm_take_focus
)
5749 /* Use x_any_window_to_frame because this
5750 could be the shell widget window
5751 if the frame has no title bar. */
5752 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5754 /* Not quite sure this is needed -pd */
5755 if (f
&& FRAME_XIC (f
))
5756 XSetICFocus (FRAME_XIC (f
));
5758 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
5759 instructs the WM to set the input focus automatically for
5760 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
5761 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
5762 it has set the focus. So, XSetInputFocus below is not
5765 The call to XSetInputFocus below has also caused trouble. In
5766 cases where the XSetInputFocus done by the WM and the one
5767 below are temporally close (on a fast machine), the call
5768 below can generate additional FocusIn events which confuse
5771 /* Since we set WM_TAKE_FOCUS, we must call
5772 XSetInputFocus explicitly. But not if f is null,
5773 since that might be an event for a deleted frame. */
5776 Display
*d
= event
.xclient
.display
;
5777 /* Catch and ignore errors, in case window has been
5778 iconified by a window manager such as GWM. */
5780 XSetInputFocus (d
, event
.xclient
.window
,
5781 /* The ICCCM says this is
5782 the only valid choice. */
5784 event
.xclient
.data
.l
[1]);
5785 /* This is needed to detect the error
5786 if there is an error. */
5788 x_uncatch_errors ();
5790 /* Not certain about handling scroll bars here */
5795 if (event
.xclient
.data
.l
[0]
5796 == dpyinfo
->Xatom_wm_save_yourself
)
5798 /* Save state modify the WM_COMMAND property to
5799 something which can reinstate us. This notifies
5800 the session manager, who's looking for such a
5801 PropertyNotify. Can restart processing when
5802 a keyboard or mouse event arrives. */
5803 /* If we have a session manager, don't set this.
5804 KDE will then start two Emacsen, one for the
5805 session manager and one for this. */
5807 if (! x_session_have_connection ())
5810 f
= x_top_window_to_frame (dpyinfo
,
5811 event
.xclient
.window
);
5812 /* This is just so we only give real data once
5813 for a single Emacs process. */
5814 if (f
== SELECTED_FRAME ())
5815 XSetCommand (FRAME_X_DISPLAY (f
),
5816 event
.xclient
.window
,
5817 initial_argv
, initial_argc
);
5819 XSetCommand (FRAME_X_DISPLAY (f
),
5820 event
.xclient
.window
,
5826 if (event
.xclient
.data
.l
[0]
5827 == dpyinfo
->Xatom_wm_delete_window
)
5829 f
= x_any_window_to_frame (dpyinfo
,
5830 event
.xclient
.window
);
5832 goto OTHER
; /* May be a dialog that is to be removed */
5834 inev
.ie
.kind
= DELETE_WINDOW_EVENT
;
5835 XSETFRAME (inev
.ie
.frame_or_window
, f
);
5842 if (event
.xclient
.message_type
5843 == dpyinfo
->Xatom_wm_configure_denied
)
5848 if (event
.xclient
.message_type
5849 == dpyinfo
->Xatom_wm_window_moved
)
5852 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
5854 new_x
= event
.xclient
.data
.s
[0];
5855 new_y
= event
.xclient
.data
.s
[1];
5859 f
->left_pos
= new_x
;
5866 if (event
.xclient
.message_type
5867 == dpyinfo
->Xatom_editres
)
5869 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5871 _XEditResCheckMessages (f
->output_data
.x
->widget
, NULL
,
5875 #endif /* HACK_EDITRES */
5877 if ((event
.xclient
.message_type
5878 == dpyinfo
->Xatom_DONE
)
5879 || (event
.xclient
.message_type
5880 == dpyinfo
->Xatom_PAGE
))
5882 /* Ghostview job completed. Kill it. We could
5883 reply with "Next" if we received "Page", but we
5884 currently never do because we are interested in
5885 images, only, which should have 1 page. */
5886 Pixmap pixmap
= (Pixmap
) event
.xclient
.data
.l
[1];
5887 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
5890 x_kill_gs_process (pixmap
, f
);
5891 expose_frame (f
, 0, 0, 0, 0);
5895 #ifdef USE_TOOLKIT_SCROLL_BARS
5896 /* Scroll bar callbacks send a ClientMessage from which
5897 we construct an input_event. */
5898 if (event
.xclient
.message_type
5899 == dpyinfo
->Xatom_Scrollbar
)
5901 x_scroll_bar_to_input_event (&event
, &inev
.ie
);
5902 *finish
= X_EVENT_GOTO_OUT
;
5905 #endif /* USE_TOOLKIT_SCROLL_BARS */
5907 /* XEmbed messages from the embedder (if any). */
5908 if (event
.xclient
.message_type
5909 == dpyinfo
->Xatom_XEMBED
)
5911 enum xembed_message msg
= event
.xclient
.data
.l
[1];
5912 if (msg
== XEMBED_FOCUS_IN
|| msg
== XEMBED_FOCUS_OUT
)
5913 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
5915 *finish
= X_EVENT_GOTO_OUT
;
5919 xft_settings_event (dpyinfo
, &event
);
5921 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5924 if (x_handle_dnd_message (f
, &event
.xclient
, dpyinfo
, &inev
.ie
))
5925 *finish
= X_EVENT_DROP
;
5929 case SelectionNotify
:
5930 last_user_time
= event
.xselection
.time
;
5931 #ifdef USE_X_TOOLKIT
5932 if (! x_window_to_frame (dpyinfo
, event
.xselection
.requestor
))
5934 #endif /* not USE_X_TOOLKIT */
5935 x_handle_selection_notify (&event
.xselection
);
5938 case SelectionClear
: /* Someone has grabbed ownership. */
5939 last_user_time
= event
.xselectionclear
.time
;
5940 #ifdef USE_X_TOOLKIT
5941 if (! x_window_to_frame (dpyinfo
, event
.xselectionclear
.window
))
5943 #endif /* USE_X_TOOLKIT */
5945 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
5947 inev
.ie
.kind
= SELECTION_CLEAR_EVENT
;
5948 SELECTION_EVENT_DISPLAY (&inev
.sie
) = eventp
->display
;
5949 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
5950 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
5951 inev
.ie
.frame_or_window
= Qnil
;
5955 case SelectionRequest
: /* Someone wants our selection. */
5956 last_user_time
= event
.xselectionrequest
.time
;
5957 #ifdef USE_X_TOOLKIT
5958 if (!x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
))
5960 #endif /* USE_X_TOOLKIT */
5962 XSelectionRequestEvent
*eventp
5963 = (XSelectionRequestEvent
*) &event
;
5965 inev
.ie
.kind
= SELECTION_REQUEST_EVENT
;
5966 SELECTION_EVENT_DISPLAY (&inev
.sie
) = eventp
->display
;
5967 SELECTION_EVENT_REQUESTOR (&inev
.sie
) = eventp
->requestor
;
5968 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
5969 SELECTION_EVENT_TARGET (&inev
.sie
) = eventp
->target
;
5970 SELECTION_EVENT_PROPERTY (&inev
.sie
) = eventp
->property
;
5971 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
5972 inev
.ie
.frame_or_window
= Qnil
;
5976 case PropertyNotify
:
5977 last_user_time
= event
.xproperty
.time
;
5978 f
= x_top_window_to_frame (dpyinfo
, event
.xproperty
.window
);
5979 if (f
&& event
.xproperty
.atom
== dpyinfo
->Xatom_net_wm_state
)
5980 x_handle_net_wm_state (f
, &event
.xproperty
);
5982 x_handle_property_notify (&event
.xproperty
);
5983 xft_settings_event (dpyinfo
, &event
);
5986 case ReparentNotify
:
5987 f
= x_top_window_to_frame (dpyinfo
, event
.xreparent
.window
);
5991 f
->output_data
.x
->parent_desc
= event
.xreparent
.parent
;
5992 x_real_positions (f
, &x
, &y
);
5996 /* Perhaps reparented due to a WM restart. Reset this. */
5997 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_UNKNOWN
;
5998 FRAME_X_DISPLAY_INFO (f
)->net_supported_window
= 0;
6003 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
6007 /* This seems to be needed for GTK 2.6. */
6008 x_clear_area (event
.xexpose
.display
,
6009 event
.xexpose
.window
,
6010 event
.xexpose
.x
, event
.xexpose
.y
,
6011 event
.xexpose
.width
, event
.xexpose
.height
,
6014 if (f
->async_visible
== 0)
6016 f
->async_visible
= 1;
6017 f
->async_iconified
= 0;
6018 f
->output_data
.x
->has_been_visible
= 1;
6019 SET_FRAME_GARBAGED (f
);
6023 event
.xexpose
.x
, event
.xexpose
.y
,
6024 event
.xexpose
.width
, event
.xexpose
.height
);
6028 #ifndef USE_TOOLKIT_SCROLL_BARS
6029 struct scroll_bar
*bar
;
6031 #if defined USE_LUCID
6032 /* Submenus of the Lucid menu bar aren't widgets
6033 themselves, so there's no way to dispatch events
6034 to them. Recognize this case separately. */
6037 = x_window_to_menu_bar (event
.xexpose
.window
);
6039 xlwmenu_redisplay (widget
);
6041 #endif /* USE_LUCID */
6043 #ifdef USE_TOOLKIT_SCROLL_BARS
6044 /* Dispatch event to the widget. */
6046 #else /* not USE_TOOLKIT_SCROLL_BARS */
6047 bar
= x_window_to_scroll_bar (event
.xexpose
.display
,
6048 event
.xexpose
.window
);
6051 x_scroll_bar_expose (bar
, &event
);
6052 #ifdef USE_X_TOOLKIT
6055 #endif /* USE_X_TOOLKIT */
6056 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6060 case GraphicsExpose
: /* This occurs when an XCopyArea's
6061 source area was obscured or not
6063 f
= x_window_to_frame (dpyinfo
, event
.xgraphicsexpose
.drawable
);
6067 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
6068 event
.xgraphicsexpose
.width
,
6069 event
.xgraphicsexpose
.height
);
6071 #ifdef USE_X_TOOLKIT
6074 #endif /* USE_X_TOOLKIT */
6077 case NoExpose
: /* This occurs when an XCopyArea's
6078 source area was completely
6083 /* Redo the mouse-highlight after the tooltip has gone. */
6084 if (event
.xmap
.window
== tip_window
)
6087 redo_mouse_highlight ();
6090 f
= x_top_window_to_frame (dpyinfo
, event
.xunmap
.window
);
6091 if (f
) /* F may no longer exist if
6092 the frame was deleted. */
6094 /* While a frame is unmapped, display generation is
6095 disabled; you don't want to spend time updating a
6096 display that won't ever be seen. */
6097 f
->async_visible
= 0;
6098 /* We can't distinguish, from the event, whether the window
6099 has become iconified or invisible. So assume, if it
6100 was previously visible, than now it is iconified.
6101 But x_make_frame_invisible clears both
6102 the visible flag and the iconified flag;
6103 and that way, we know the window is not iconified now. */
6104 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
6106 f
->async_iconified
= 1;
6108 inev
.ie
.kind
= ICONIFY_EVENT
;
6109 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6115 if (event
.xmap
.window
== tip_window
)
6116 /* The tooltip has been drawn already. Avoid
6117 the SET_FRAME_GARBAGED below. */
6120 /* We use x_top_window_to_frame because map events can
6121 come for sub-windows and they don't mean that the
6122 frame is visible. */
6123 f
= x_top_window_to_frame (dpyinfo
, event
.xmap
.window
);
6126 /* wait_reading_process_output will notice this and update
6127 the frame's display structures.
6128 If we where iconified, we should not set garbaged,
6129 because that stops redrawing on Expose events. This looks
6130 bad if we are called from a recursive event loop
6131 (x_dispatch_event), for example when a dialog is up. */
6132 if (! f
->async_iconified
)
6133 SET_FRAME_GARBAGED (f
);
6135 /* Check if fullscreen was specified before we where mapped the
6136 first time, i.e. from the command line. */
6137 if (!f
->output_data
.x
->has_been_visible
)
6138 x_check_fullscreen (f
);
6140 f
->async_visible
= 1;
6141 f
->async_iconified
= 0;
6142 f
->output_data
.x
->has_been_visible
= 1;
6146 inev
.ie
.kind
= DEICONIFY_EVENT
;
6147 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6149 else if (! NILP (Vframe_list
)
6150 && ! NILP (XCDR (Vframe_list
)))
6151 /* Force a redisplay sooner or later
6152 to update the frame titles
6153 in case this is the second frame. */
6154 record_asynch_buffer_change ();
6157 xg_frame_resized (f
, -1, -1);
6164 last_user_time
= event
.xkey
.time
;
6165 ignore_next_mouse_click_timeout
= 0;
6167 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6168 /* Dispatch KeyPress events when in menu. */
6169 if (popup_activated ())
6173 f
= x_any_window_to_frame (dpyinfo
, event
.xkey
.window
);
6175 /* If mouse-highlight is an integer, input clears out
6176 mouse highlighting. */
6177 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
6179 || !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
)))
6181 clear_mouse_face (dpyinfo
);
6182 dpyinfo
->mouse_face_hidden
= 1;
6185 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
6188 /* Scroll bars consume key events, but we want
6189 the keys to go to the scroll bar's frame. */
6190 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
6192 if (widget
&& XmIsScrollBar (widget
))
6194 widget
= XtParent (widget
);
6195 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
6198 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
6202 KeySym keysym
, orig_keysym
;
6203 /* al%imercury@uunet.uu.net says that making this 81
6204 instead of 80 fixed a bug whereby meta chars made
6207 It seems that some version of XmbLookupString has
6208 a bug of not returning XBufferOverflow in
6209 status_return even if the input is too long to
6210 fit in 81 bytes. So, we must prepare sufficient
6211 bytes for copy_buffer. 513 bytes (256 chars for
6212 two-byte character set) seems to be a fairly good
6213 approximation. -- 2000.8.10 handa@etl.go.jp */
6214 unsigned char copy_buffer
[513];
6215 unsigned char *copy_bufptr
= copy_buffer
;
6216 int copy_bufsiz
= sizeof (copy_buffer
);
6218 Lisp_Object coding_system
= Qlatin_1
;
6222 /* Don't pass keys to GTK. A Tab will shift focus to the
6223 tool bar in GTK 2.4. Keys will still go to menus and
6224 dialogs because in that case popup_activated is TRUE
6226 *finish
= X_EVENT_DROP
;
6230 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f
),
6231 extra_keyboard_modifiers
);
6232 modifiers
= event
.xkey
.state
;
6234 /* This will have to go some day... */
6236 /* make_lispy_event turns chars into control chars.
6237 Don't do it here because XLookupString is too eager. */
6238 event
.xkey
.state
&= ~ControlMask
;
6239 event
.xkey
.state
&= ~(dpyinfo
->meta_mod_mask
6240 | dpyinfo
->super_mod_mask
6241 | dpyinfo
->hyper_mod_mask
6242 | dpyinfo
->alt_mod_mask
);
6244 /* In case Meta is ComposeCharacter,
6245 clear its status. According to Markus Ehrnsperger
6246 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
6247 this enables ComposeCharacter to work whether or
6248 not it is combined with Meta. */
6249 if (modifiers
& dpyinfo
->meta_mod_mask
)
6250 bzero (&compose_status
, sizeof (compose_status
));
6255 Status status_return
;
6257 coding_system
= Vlocale_coding_system
;
6258 nbytes
= XmbLookupString (FRAME_XIC (f
),
6259 &event
.xkey
, copy_bufptr
,
6260 copy_bufsiz
, &keysym
,
6262 if (status_return
== XBufferOverflow
)
6264 copy_bufsiz
= nbytes
+ 1;
6265 copy_bufptr
= (unsigned char *) alloca (copy_bufsiz
);
6266 nbytes
= XmbLookupString (FRAME_XIC (f
),
6267 &event
.xkey
, copy_bufptr
,
6268 copy_bufsiz
, &keysym
,
6271 /* Xutf8LookupString is a new but already deprecated interface. -stef */
6272 if (status_return
== XLookupNone
)
6274 else if (status_return
== XLookupChars
)
6279 else if (status_return
!= XLookupKeySym
6280 && status_return
!= XLookupBoth
)
6284 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
6285 copy_bufsiz
, &keysym
,
6288 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
6289 copy_bufsiz
, &keysym
,
6293 /* If not using XIM/XIC, and a compose sequence is in progress,
6294 we break here. Otherwise, chars_matched is always 0. */
6295 if (compose_status
.chars_matched
> 0 && nbytes
== 0)
6298 bzero (&compose_status
, sizeof (compose_status
));
6299 orig_keysym
= keysym
;
6301 /* Common for all keysym input events. */
6302 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6304 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), modifiers
);
6305 inev
.ie
.timestamp
= event
.xkey
.time
;
6307 /* First deal with keysyms which have defined
6308 translations to characters. */
6309 if (keysym
>= 32 && keysym
< 128)
6310 /* Avoid explicitly decoding each ASCII character. */
6312 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
6313 inev
.ie
.code
= keysym
;
6317 /* Keysyms directly mapped to Unicode characters. */
6318 if (keysym
>= 0x01000000 && keysym
<= 0x0110FFFF)
6320 if (keysym
< 0x01000080)
6321 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
6323 inev
.ie
.kind
= MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
6324 inev
.ie
.code
= keysym
& 0xFFFFFF;
6328 /* Now non-ASCII. */
6329 if (HASH_TABLE_P (Vx_keysym_table
)
6330 && (NATNUMP (c
= Fgethash (make_number (keysym
),
6334 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (XFASTINT (c
))
6335 ? ASCII_KEYSTROKE_EVENT
6336 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6337 inev
.ie
.code
= XFASTINT (c
);
6341 /* Random non-modifier sorts of keysyms. */
6342 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
6343 || keysym
== XK_Delete
6344 #ifdef XK_ISO_Left_Tab
6345 || (keysym
>= XK_ISO_Left_Tab
6346 && keysym
<= XK_ISO_Enter
)
6348 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
6349 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
6351 /* This recognizes the "extended function
6352 keys". It seems there's no cleaner way.
6353 Test IsModifierKey to avoid handling
6354 mode_switch incorrectly. */
6355 || ((unsigned) (keysym
) >= XK_Select
6356 && (unsigned)(keysym
) < XK_KP_Space
)
6358 #ifdef XK_dead_circumflex
6359 || orig_keysym
== XK_dead_circumflex
6361 #ifdef XK_dead_grave
6362 || orig_keysym
== XK_dead_grave
6364 #ifdef XK_dead_tilde
6365 || orig_keysym
== XK_dead_tilde
6367 #ifdef XK_dead_diaeresis
6368 || orig_keysym
== XK_dead_diaeresis
6370 #ifdef XK_dead_macron
6371 || orig_keysym
== XK_dead_macron
6373 #ifdef XK_dead_degree
6374 || orig_keysym
== XK_dead_degree
6376 #ifdef XK_dead_acute
6377 || orig_keysym
== XK_dead_acute
6379 #ifdef XK_dead_cedilla
6380 || orig_keysym
== XK_dead_cedilla
6382 #ifdef XK_dead_breve
6383 || orig_keysym
== XK_dead_breve
6385 #ifdef XK_dead_ogonek
6386 || orig_keysym
== XK_dead_ogonek
6388 #ifdef XK_dead_caron
6389 || orig_keysym
== XK_dead_caron
6391 #ifdef XK_dead_doubleacute
6392 || orig_keysym
== XK_dead_doubleacute
6394 #ifdef XK_dead_abovedot
6395 || orig_keysym
== XK_dead_abovedot
6397 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
6398 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
6399 /* Any "vendor-specific" key is ok. */
6400 || (orig_keysym
& (1 << 28))
6401 || (keysym
!= NoSymbol
&& nbytes
== 0))
6402 && ! (IsModifierKey (orig_keysym
)
6403 /* The symbols from XK_ISO_Lock
6404 to XK_ISO_Last_Group_Lock
6405 don't have real modifiers but
6406 should be treated similarly to
6407 Mode_switch by Emacs. */
6408 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
6409 || ((unsigned)(orig_keysym
)
6411 && (unsigned)(orig_keysym
)
6412 <= XK_ISO_Last_Group_Lock
)
6416 STORE_KEYSYM_FOR_DEBUG (keysym
);
6417 /* make_lispy_event will convert this to a symbolic
6419 inev
.ie
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
6420 inev
.ie
.code
= keysym
;
6424 { /* Raw bytes, not keysym. */
6429 for (i
= 0, nchars
= 0; i
< nbytes
; i
++)
6431 if (ASCII_BYTE_P (copy_bufptr
[i
]))
6433 STORE_KEYSYM_FOR_DEBUG (copy_bufptr
[i
]);
6436 if (nchars
< nbytes
)
6438 /* Decode the input data. */
6442 /* The input should be decoded with `coding_system'
6443 which depends on which X*LookupString function
6444 we used just above and the locale. */
6445 setup_coding_system (coding_system
, &coding
);
6446 coding
.src_multibyte
= 0;
6447 coding
.dst_multibyte
= 1;
6448 /* The input is converted to events, thus we can't
6449 handle composition. Anyway, there's no XIM that
6450 gives us composition information. */
6451 coding
.common_flags
&= ~CODING_ANNOTATION_MASK
;
6453 require
= MAX_MULTIBYTE_LENGTH
* nbytes
;
6454 coding
.destination
= alloca (require
);
6455 coding
.dst_bytes
= require
;
6456 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
6457 decode_coding_c_string (&coding
, copy_bufptr
, nbytes
, Qnil
);
6458 nbytes
= coding
.produced
;
6459 nchars
= coding
.produced_char
;
6460 copy_bufptr
= coding
.destination
;
6463 /* Convert the input data to a sequence of
6464 character events. */
6465 for (i
= 0; i
< nbytes
; i
+= len
)
6467 if (nchars
== nbytes
)
6468 c
= copy_bufptr
[i
], len
= 1;
6470 c
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
, len
);
6471 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (c
)
6472 ? ASCII_KEYSTROKE_EVENT
6473 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6475 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
6480 inev
.ie
.kind
= NO_EVENT
; /* Already stored above. */
6482 if (keysym
== NoSymbol
)
6488 /* Don't dispatch this event since XtDispatchEvent calls
6489 XFilterEvent, and two calls in a row may freeze the
6497 last_user_time
= event
.xkey
.time
;
6499 /* Don't dispatch this event since XtDispatchEvent calls
6500 XFilterEvent, and two calls in a row may freeze the
6508 last_user_time
= event
.xcrossing
.time
;
6509 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6511 f
= x_any_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
6513 if (f
&& x_mouse_click_focus_ignore_position
)
6514 ignore_next_mouse_click_timeout
= event
.xmotion
.time
+ 200;
6516 /* EnterNotify counts as mouse movement,
6517 so update things that depend on mouse position. */
6518 if (f
&& !f
->output_data
.x
->hourglass_p
)
6519 note_mouse_movement (f
, &event
.xmotion
);
6521 /* We may get an EnterNotify on the buttons in the toolbar. In that
6522 case we moved out of any highlighted area and need to note this. */
6523 if (!f
&& last_mouse_glyph_frame
)
6524 note_mouse_movement (last_mouse_glyph_frame
, &event
.xmotion
);
6529 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6533 last_user_time
= event
.xcrossing
.time
;
6534 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6536 f
= x_top_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
6539 if (f
== dpyinfo
->mouse_face_mouse_frame
)
6541 /* If we move outside the frame, then we're
6542 certainly no longer on any text in the frame. */
6543 clear_mouse_face (dpyinfo
);
6544 dpyinfo
->mouse_face_mouse_frame
= 0;
6547 /* Generate a nil HELP_EVENT to cancel a help-echo.
6548 Do it only if there's something to cancel.
6549 Otherwise, the startup message is cleared when
6550 the mouse leaves the frame. */
6551 if (any_help_event_p
)
6555 /* See comment in EnterNotify above */
6556 else if (last_mouse_glyph_frame
)
6557 note_mouse_movement (last_mouse_glyph_frame
, &event
.xmotion
);
6562 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6567 last_user_time
= event
.xmotion
.time
;
6568 previous_help_echo_string
= help_echo_string
;
6569 help_echo_string
= Qnil
;
6571 if (dpyinfo
->grabbed
&& last_mouse_frame
6572 && FRAME_LIVE_P (last_mouse_frame
))
6573 f
= last_mouse_frame
;
6575 f
= x_window_to_frame (dpyinfo
, event
.xmotion
.window
);
6577 if (dpyinfo
->mouse_face_hidden
)
6579 dpyinfo
->mouse_face_hidden
= 0;
6580 clear_mouse_face (dpyinfo
);
6584 if (f
&& xg_event_is_for_scrollbar (f
, &event
))
6590 /* Generate SELECT_WINDOW_EVENTs when needed.
6591 Don't let popup menus influence things (bug#1261). */
6592 if (!NILP (Vmouse_autoselect_window
) && !popup_activated ())
6596 window
= window_from_coordinates (f
,
6597 event
.xmotion
.x
, event
.xmotion
.y
,
6600 /* Window will be selected only when it is not selected now and
6601 last mouse movement event was not in it. Minibuffer window
6602 will be selected only when it is active. */
6603 if (WINDOWP (window
)
6604 && !EQ (window
, last_window
)
6605 && !EQ (window
, selected_window
)
6606 /* For click-to-focus window managers
6607 create event iff we don't leave the
6609 && (focus_follows_mouse
6610 || (EQ (XWINDOW (window
)->frame
,
6611 XWINDOW (selected_window
)->frame
))))
6613 inev
.ie
.kind
= SELECT_WINDOW_EVENT
;
6614 inev
.ie
.frame_or_window
= window
;
6619 if (!note_mouse_movement (f
, &event
.xmotion
))
6620 help_echo_string
= previous_help_echo_string
;
6624 #ifndef USE_TOOLKIT_SCROLL_BARS
6625 struct scroll_bar
*bar
6626 = x_window_to_scroll_bar (event
.xmotion
.display
,
6627 event
.xmotion
.window
);
6630 x_scroll_bar_note_movement (bar
, &event
);
6631 #endif /* USE_TOOLKIT_SCROLL_BARS */
6633 /* If we move outside the frame, then we're
6634 certainly no longer on any text in the frame. */
6635 clear_mouse_face (dpyinfo
);
6638 /* If the contents of the global variable help_echo_string
6639 has changed, generate a HELP_EVENT. */
6640 if (!NILP (help_echo_string
)
6641 || !NILP (previous_help_echo_string
))
6646 case ConfigureNotify
:
6647 f
= x_top_window_to_frame (dpyinfo
, event
.xconfigure
.window
);
6650 && (f
= x_any_window_to_frame (dpyinfo
, event
.xconfigure
.window
))
6651 && event
.xconfigure
.window
== FRAME_X_WINDOW (f
))
6653 xg_frame_resized (f
, event
.xconfigure
.width
,
6654 event
.xconfigure
.height
);
6660 #ifndef USE_X_TOOLKIT
6662 int rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, event
.xconfigure
.height
);
6663 int columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, event
.xconfigure
.width
);
6665 /* In the toolkit version, change_frame_size
6666 is called by the code that handles resizing
6667 of the EmacsFrame widget. */
6669 /* Even if the number of character rows and columns has
6670 not changed, the font size may have changed, so we need
6671 to check the pixel dimensions as well. */
6672 if (columns
!= FRAME_COLS (f
)
6673 || rows
!= FRAME_LINES (f
)
6674 || event
.xconfigure
.width
!= FRAME_PIXEL_WIDTH (f
)
6675 || event
.xconfigure
.height
!= FRAME_PIXEL_HEIGHT (f
))
6677 change_frame_size (f
, rows
, columns
, 0, 1, 0);
6678 SET_FRAME_GARBAGED (f
);
6679 cancel_mouse_face (f
);
6682 FRAME_PIXEL_WIDTH (f
) = event
.xconfigure
.width
;
6683 FRAME_PIXEL_HEIGHT (f
) = event
.xconfigure
.height
;
6684 #endif /* not USE_GTK */
6688 /* GTK creates windows but doesn't map them.
6689 Only get real positions when mapped. */
6690 if (FRAME_GTK_OUTER_WIDGET (f
)
6691 && gtk_widget_get_mapped (FRAME_GTK_OUTER_WIDGET (f
)))
6694 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
6698 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
6699 xic_set_statusarea (f
);
6708 /* If we decide we want to generate an event to be seen
6709 by the rest of Emacs, we put it here. */
6712 bzero (&compose_status
, sizeof (compose_status
));
6713 last_mouse_glyph_frame
= 0;
6714 last_user_time
= event
.xbutton
.time
;
6716 if (dpyinfo
->grabbed
6718 && FRAME_LIVE_P (last_mouse_frame
))
6719 f
= last_mouse_frame
;
6721 f
= x_window_to_frame (dpyinfo
, event
.xbutton
.window
);
6724 if (f
&& xg_event_is_for_scrollbar (f
, &event
))
6729 /* Is this in the tool-bar? */
6730 if (WINDOWP (f
->tool_bar_window
)
6731 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
6734 int x
= event
.xbutton
.x
;
6735 int y
= event
.xbutton
.y
;
6737 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 1);
6738 tool_bar_p
= EQ (window
, f
->tool_bar_window
);
6740 if (tool_bar_p
&& event
.xbutton
.button
< 4)
6742 handle_tool_bar_click (f
, x
, y
,
6743 event
.xbutton
.type
== ButtonPress
,
6744 x_x_to_emacs_modifiers (dpyinfo
,
6745 event
.xbutton
.state
));
6750 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6751 if (! popup_activated ())
6754 if (ignore_next_mouse_click_timeout
)
6756 if (event
.type
== ButtonPress
6757 && (int)(event
.xbutton
.time
- ignore_next_mouse_click_timeout
) > 0)
6759 ignore_next_mouse_click_timeout
= 0;
6760 construct_mouse_click (&inev
.ie
, &event
.xbutton
, f
);
6762 if (event
.type
== ButtonRelease
)
6763 ignore_next_mouse_click_timeout
= 0;
6766 construct_mouse_click (&inev
.ie
, &event
.xbutton
, f
);
6768 if (FRAME_X_EMBEDDED_P (f
))
6769 xembed_send_message (f
, event
.xbutton
.time
,
6770 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
6774 struct scroll_bar
*bar
6775 = x_window_to_scroll_bar (event
.xbutton
.display
,
6776 event
.xbutton
.window
);
6778 #ifdef USE_TOOLKIT_SCROLL_BARS
6779 /* Make the "Ctrl-Mouse-2 splits window" work for toolkit
6781 if (bar
&& event
.xbutton
.state
& ControlMask
)
6783 x_scroll_bar_handle_click (bar
, &event
, &inev
.ie
);
6784 *finish
= X_EVENT_DROP
;
6786 #else /* not USE_TOOLKIT_SCROLL_BARS */
6788 x_scroll_bar_handle_click (bar
, &event
, &inev
.ie
);
6789 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6792 if (event
.type
== ButtonPress
)
6794 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
6795 last_mouse_frame
= f
;
6798 last_tool_bar_item
= -1;
6801 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
6803 /* Ignore any mouse motion that happened before this event;
6804 any subsequent mouse-movement Emacs events should reflect
6805 only motion after the ButtonPress/Release. */
6809 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6810 f
= x_menubar_window_to_frame (dpyinfo
, event
.xbutton
.window
);
6811 /* For a down-event in the menu bar,
6812 don't pass it to Xt right now.
6813 Instead, save it away
6814 and we will pass it to Xt from kbd_buffer_get_event.
6815 That way, we can run some Lisp code first. */
6818 ! popup_activated ()
6819 /* Gtk+ menus only react to the first three buttons. */
6820 && event
.xbutton
.button
< 3
6823 f
&& event
.type
== ButtonPress
6824 /* Verify the event is really within the menu bar
6825 and not just sent to it due to grabbing. */
6826 && event
.xbutton
.x
>= 0
6827 && event
.xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
6828 && event
.xbutton
.y
>= 0
6829 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
6830 && event
.xbutton
.same_screen
)
6832 SET_SAVED_BUTTON_EVENT
;
6833 XSETFRAME (last_mouse_press_frame
, f
);
6835 *finish
= X_EVENT_DROP
;
6838 else if (event
.type
== ButtonPress
)
6840 last_mouse_press_frame
= Qnil
;
6844 #ifdef USE_MOTIF /* This should do not harm for Lucid,
6845 but I am trying to be cautious. */
6846 else if (event
.type
== ButtonRelease
)
6848 if (!NILP (last_mouse_press_frame
))
6850 f
= XFRAME (last_mouse_press_frame
);
6851 if (f
->output_data
.x
)
6852 SET_SAVED_BUTTON_EVENT
;
6857 #endif /* USE_MOTIF */
6860 #endif /* USE_X_TOOLKIT || USE_GTK */
6864 case CirculateNotify
:
6867 case CirculateRequest
:
6870 case VisibilityNotify
:
6874 /* Someone has changed the keyboard mapping - update the
6876 switch (event
.xmapping
.request
)
6878 case MappingModifier
:
6879 x_find_modifier_meanings (dpyinfo
);
6880 /* This is meant to fall through. */
6881 case MappingKeyboard
:
6882 XRefreshKeyboardMapping (&event
.xmapping
);
6887 xft_settings_event (dpyinfo
, &event
);
6892 #ifdef USE_X_TOOLKIT
6894 if (*finish
!= X_EVENT_DROP
)
6895 XtDispatchEvent (&event
);
6897 #endif /* USE_X_TOOLKIT */
6902 if (inev
.ie
.kind
!= NO_EVENT
)
6904 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
6909 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
6914 XSETFRAME (frame
, f
);
6920 any_help_event_p
= 1;
6921 gen_help_event (help_echo_string
, frame
, help_echo_window
,
6922 help_echo_object
, help_echo_pos
);
6926 help_echo_string
= Qnil
;
6927 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
6937 /* Handles the XEvent EVENT on display DISPLAY.
6938 This is used for event loops outside the normal event handling,
6939 i.e. looping while a popup menu or a dialog is posted.
6941 Returns the value handle_one_xevent sets in the finish argument. */
6943 x_dispatch_event (XEvent
*event
, Display
*display
)
6945 struct x_display_info
*dpyinfo
;
6946 int finish
= X_EVENT_NORMAL
;
6948 dpyinfo
= x_display_info_for_display (display
);
6951 handle_one_xevent (dpyinfo
, event
, &finish
, 0);
6957 /* Read events coming from the X server.
6958 This routine is called by the SIGIO handler.
6959 We return as soon as there are no more events to be read.
6961 We return the number of characters stored into the buffer,
6962 thus pretending to be `read' (except the characters we store
6963 in the keyboard buffer can be multibyte, so are not necessarily
6966 EXPECTED is nonzero if the caller knows input is available. */
6969 XTread_socket (struct terminal
*terminal
, int expected
, struct input_event
*hold_quit
)
6973 int event_found
= 0;
6975 if (interrupt_input_blocked
)
6977 interrupt_input_pending
= 1;
6979 pending_signals
= 1;
6984 interrupt_input_pending
= 0;
6986 pending_signals
= pending_atimers
;
6990 /* So people can tell when we have read the available input. */
6991 input_signal_count
++;
6996 /* Only check session manager input for the primary display. */
6997 if (terminal
->id
== 1 && x_session_have_connection ())
6999 struct input_event inev
;
7001 /* We don't need to EVENT_INIT (inev) here, as
7002 x_session_check_input copies an entire input_event. */
7003 if (x_session_check_input (&inev
))
7005 kbd_buffer_store_event_hold (&inev
, hold_quit
);
7012 /* For debugging, this gives a way to fake an I/O error. */
7013 if (terminal
->display_info
.x
== XTread_socket_fake_io_error
)
7015 XTread_socket_fake_io_error
= 0;
7016 x_io_error_quitter (terminal
->display_info
.x
->display
);
7020 while (XPending (terminal
->display_info
.x
->display
))
7024 XNextEvent (terminal
->display_info
.x
->display
, &event
);
7027 /* Filter events for the current X input method. */
7028 if (x_filter_event (terminal
->display_info
.x
, &event
))
7033 count
+= handle_one_xevent (terminal
->display_info
.x
,
7034 &event
, &finish
, hold_quit
);
7036 if (finish
== X_EVENT_GOTO_OUT
)
7042 /* For GTK we must use the GTK event loop. But XEvents gets passed
7043 to our filter function above, and then to the big event switch.
7044 We use a bunch of globals to communicate with our filter function,
7045 that is kind of ugly, but it works.
7047 There is no way to do one display at the time, GTK just does events
7048 from all displays. */
7050 while (gtk_events_pending ())
7052 current_count
= count
;
7053 current_hold_quit
= hold_quit
;
7055 gtk_main_iteration ();
7057 count
= current_count
;
7059 current_hold_quit
= 0;
7061 if (current_finish
== X_EVENT_GOTO_OUT
)
7064 #endif /* USE_GTK */
7068 /* On some systems, an X bug causes Emacs to get no more events
7069 when the window is destroyed. Detect that. (1994.) */
7072 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
7073 One XNOOP in 100 loops will make Emacs terminate.
7074 B. Bretthauer, 1994 */
7076 if (x_noop_count
>= 100)
7080 if (next_noop_dpyinfo
== 0)
7081 next_noop_dpyinfo
= x_display_list
;
7083 XNoOp (next_noop_dpyinfo
->display
);
7085 /* Each time we get here, cycle through the displays now open. */
7086 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
7090 /* If the focus was just given to an auto-raising frame,
7092 /* ??? This ought to be able to handle more than one such frame. */
7093 if (pending_autoraise_frame
)
7095 x_raise_frame (pending_autoraise_frame
);
7096 pending_autoraise_frame
= 0;
7108 /***********************************************************************
7110 ***********************************************************************/
7112 /* Set clipping for output in glyph row ROW. W is the window in which
7113 we operate. GC is the graphics context to set clipping in.
7115 ROW may be a text row or, e.g., a mode line. Text rows must be
7116 clipped to the interior of the window dedicated to text display,
7117 mode lines must be clipped to the whole window. */
7120 x_clip_to_row (struct window
*w
, struct glyph_row
*row
, int area
, GC gc
)
7122 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7123 XRectangle clip_rect
;
7124 int window_x
, window_y
, window_width
;
7126 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
7128 clip_rect
.x
= window_x
;
7129 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, row
->y
));
7130 clip_rect
.y
= max (clip_rect
.y
, window_y
);
7131 clip_rect
.width
= window_width
;
7132 clip_rect
.height
= row
->visible_height
;
7134 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
7138 /* Draw a hollow box cursor on window W in glyph row ROW. */
7141 x_draw_hollow_cursor (struct window
*w
, struct glyph_row
*row
)
7143 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7144 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7145 Display
*dpy
= FRAME_X_DISPLAY (f
);
7148 struct glyph
*cursor_glyph
;
7151 /* Get the glyph the cursor is on. If we can't tell because
7152 the current matrix is invalid or such, give up. */
7153 cursor_glyph
= get_phys_cursor_glyph (w
);
7154 if (cursor_glyph
== NULL
)
7157 /* Compute frame-relative coordinates for phys cursor. */
7158 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &x
, &y
, &h
);
7159 wd
= w
->phys_cursor_width
;
7161 /* The foreground of cursor_gc is typically the same as the normal
7162 background color, which can cause the cursor box to be invisible. */
7163 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7164 if (dpyinfo
->scratch_cursor_gc
)
7165 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
7167 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
7168 GCForeground
, &xgcv
);
7169 gc
= dpyinfo
->scratch_cursor_gc
;
7171 /* Set clipping, draw the rectangle, and reset clipping again. */
7172 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7173 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
- 1);
7174 XSetClipMask (dpy
, gc
, None
);
7178 /* Draw a bar cursor on window W in glyph row ROW.
7180 Implementation note: One would like to draw a bar cursor with an
7181 angle equal to the one given by the font property XA_ITALIC_ANGLE.
7182 Unfortunately, I didn't find a font yet that has this property set.
7186 x_draw_bar_cursor (struct window
*w
, struct glyph_row
*row
, int width
, enum text_cursor_kinds kind
)
7188 struct frame
*f
= XFRAME (w
->frame
);
7189 struct glyph
*cursor_glyph
;
7191 /* If cursor is out of bounds, don't draw garbage. This can happen
7192 in mini-buffer windows when switching between echo area glyphs
7194 cursor_glyph
= get_phys_cursor_glyph (w
);
7195 if (cursor_glyph
== NULL
)
7198 /* If on an image, draw like a normal cursor. That's usually better
7199 visible than drawing a bar, esp. if the image is large so that
7200 the bar might not be in the window. */
7201 if (cursor_glyph
->type
== IMAGE_GLYPH
)
7203 struct glyph_row
*row
;
7204 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
7205 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
7209 Display
*dpy
= FRAME_X_DISPLAY (f
);
7210 Window window
= FRAME_X_WINDOW (f
);
7211 GC gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
7212 unsigned long mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
7213 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
7216 /* If the glyph's background equals the color we normally draw
7217 the bars cursor in, the bar cursor in its normal color is
7218 invisible. Use the glyph's foreground color instead in this
7219 case, on the assumption that the glyph's colors are chosen so
7220 that the glyph is legible. */
7221 if (face
->background
== f
->output_data
.x
->cursor_pixel
)
7222 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
7224 xgcv
.background
= xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7225 xgcv
.graphics_exposures
= 0;
7228 XChangeGC (dpy
, gc
, mask
, &xgcv
);
7231 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
7232 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
7235 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7237 if (kind
== BAR_CURSOR
)
7240 width
= FRAME_CURSOR_WIDTH (f
);
7241 width
= min (cursor_glyph
->pixel_width
, width
);
7243 w
->phys_cursor_width
= width
;
7245 XFillRectangle (dpy
, window
, gc
,
7246 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
7247 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
7248 width
, row
->height
);
7252 int dummy_x
, dummy_y
, dummy_h
;
7255 width
= row
->height
;
7257 width
= min (row
->height
, width
);
7259 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &dummy_x
,
7260 &dummy_y
, &dummy_h
);
7262 XFillRectangle (dpy
, window
, gc
,
7263 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
7264 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
7265 row
->height
- width
),
7266 w
->phys_cursor_width
, width
);
7269 XSetClipMask (dpy
, gc
, None
);
7274 /* RIF: Define cursor CURSOR on frame F. */
7277 x_define_frame_cursor (struct frame
*f
, Cursor cursor
)
7279 if (!f
->pointer_invisible
7280 && f
->output_data
.x
->current_cursor
!= cursor
)
7281 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
7282 f
->output_data
.x
->current_cursor
= cursor
;
7286 /* RIF: Clear area on frame F. */
7289 x_clear_frame_area (struct frame
*f
, int x
, int y
, int width
, int height
)
7291 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7292 x
, y
, width
, height
, False
);
7294 /* Must queue a redraw, because scroll bars might have been cleared. */
7295 if (FRAME_GTK_WIDGET (f
))
7296 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
7301 /* RIF: Draw cursor on window W. */
7304 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
)
7306 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7310 w
->phys_cursor_type
= cursor_type
;
7311 w
->phys_cursor_on_p
= 1;
7313 if (glyph_row
->exact_window_width_line_p
7314 && (glyph_row
->reversed_p
7315 ? (w
->phys_cursor
.hpos
< 0)
7316 : (w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])))
7318 glyph_row
->cursor_in_fringe_p
= 1;
7319 draw_fringe_bitmap (w
, glyph_row
, glyph_row
->reversed_p
);
7323 switch (cursor_type
)
7325 case HOLLOW_BOX_CURSOR
:
7326 x_draw_hollow_cursor (w
, glyph_row
);
7329 case FILLED_BOX_CURSOR
:
7330 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
7334 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
7338 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
7342 w
->phys_cursor_width
= 0;
7351 if (w
== XWINDOW (f
->selected_window
))
7352 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
7353 xic_set_preeditarea (w
, x
, y
);
7358 XFlush (FRAME_X_DISPLAY (f
));
7365 /* Make the x-window of frame F use the gnu icon bitmap. */
7368 x_bitmap_icon (struct frame
*f
, Lisp_Object file
)
7372 if (FRAME_X_WINDOW (f
) == 0)
7375 /* Free up our existing icon bitmap and mask if any. */
7376 if (f
->output_data
.x
->icon_bitmap
> 0)
7377 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7378 f
->output_data
.x
->icon_bitmap
= 0;
7383 /* Use gtk_window_set_icon_from_file () if available,
7384 It's not restricted to bitmaps */
7385 if (xg_set_icon (f
, file
))
7387 #endif /* USE_GTK */
7388 bitmap_id
= x_create_bitmap_from_file (f
, file
);
7389 x_create_bitmap_mask (f
, bitmap_id
);
7393 /* Create the GNU bitmap and mask if necessary. */
7394 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
7400 if (xg_set_icon (f
, xg_default_icon_file
)
7401 || xg_set_icon_from_xpm_data (f
, gnu_xpm_bits
))
7404 #elif defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
7406 rc
= x_create_bitmap_from_xpm_data (f
, gnu_xpm_bits
);
7408 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
7412 /* If all else fails, use the (black and white) xbm image. */
7415 rc
= x_create_bitmap_from_data (f
, gnu_xbm_bits
,
7416 gnu_xbm_width
, gnu_xbm_height
);
7420 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
7421 x_create_bitmap_mask (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
7425 /* The first time we create the GNU bitmap and mask,
7426 this increments the ref-count one extra time.
7427 As a result, the GNU bitmap and mask are never freed.
7428 That way, we don't have to worry about allocating it again. */
7429 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
7431 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
7434 x_wm_set_icon_pixmap (f
, bitmap_id
);
7435 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
7441 /* Make the x-window of frame F use a rectangle with text.
7442 Use ICON_NAME as the text. */
7445 x_text_icon (struct frame
*f
, char *icon_name
)
7447 if (FRAME_X_WINDOW (f
) == 0)
7452 text
.value
= (unsigned char *) icon_name
;
7453 text
.encoding
= XA_STRING
;
7455 text
.nitems
= strlen (icon_name
);
7456 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
7459 if (f
->output_data
.x
->icon_bitmap
> 0)
7460 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7461 f
->output_data
.x
->icon_bitmap
= 0;
7462 x_wm_set_icon_pixmap (f
, 0);
7467 #define X_ERROR_MESSAGE_SIZE 200
7469 /* If non-nil, this should be a string.
7470 It means catch X errors and store the error message in this string.
7472 The reason we use a stack is that x_catch_error/x_uncatch_error can
7473 be called from a signal handler.
7476 struct x_error_message_stack
{
7477 char string
[X_ERROR_MESSAGE_SIZE
];
7479 struct x_error_message_stack
*prev
;
7481 static struct x_error_message_stack
*x_error_message
;
7483 /* An X error handler which stores the error message in
7484 *x_error_message. This is called from x_error_handler if
7485 x_catch_errors is in effect. */
7488 x_error_catcher (Display
*display
, XErrorEvent
*error
)
7490 XGetErrorText (display
, error
->error_code
,
7491 x_error_message
->string
,
7492 X_ERROR_MESSAGE_SIZE
);
7495 /* Begin trapping X errors for display DPY. Actually we trap X errors
7496 for all displays, but DPY should be the display you are actually
7499 After calling this function, X protocol errors no longer cause
7500 Emacs to exit; instead, they are recorded in the string
7501 stored in *x_error_message.
7503 Calling x_check_errors signals an Emacs error if an X error has
7504 occurred since the last call to x_catch_errors or x_check_errors.
7506 Calling x_uncatch_errors resumes the normal error handling. */
7508 void x_check_errors (Display
*dpy
, char *format
);
7511 x_catch_errors (Display
*dpy
)
7513 struct x_error_message_stack
*data
= xmalloc (sizeof (*data
));
7515 /* Make sure any errors from previous requests have been dealt with. */
7519 data
->string
[0] = 0;
7520 data
->prev
= x_error_message
;
7521 x_error_message
= data
;
7524 /* Undo the last x_catch_errors call.
7525 DPY should be the display that was passed to x_catch_errors. */
7528 x_uncatch_errors (void)
7530 struct x_error_message_stack
*tmp
;
7534 /* The display may have been closed before this function is called.
7535 Check if it is still open before calling XSync. */
7536 if (x_display_info_for_display (x_error_message
->dpy
) != 0)
7537 XSync (x_error_message
->dpy
, False
);
7539 tmp
= x_error_message
;
7540 x_error_message
= x_error_message
->prev
;
7545 /* If any X protocol errors have arrived since the last call to
7546 x_catch_errors or x_check_errors, signal an Emacs error using
7547 sprintf (a buffer, FORMAT, the x error message text) as the text. */
7550 x_check_errors (Display
*dpy
, char *format
)
7552 /* Make sure to catch any errors incurred so far. */
7555 if (x_error_message
->string
[0])
7557 char string
[X_ERROR_MESSAGE_SIZE
];
7558 bcopy (x_error_message
->string
, string
, X_ERROR_MESSAGE_SIZE
);
7559 x_uncatch_errors ();
7560 error (format
, string
);
7564 /* Nonzero if we had any X protocol errors
7565 since we did x_catch_errors on DPY. */
7568 x_had_errors_p (Display
*dpy
)
7570 /* Make sure to catch any errors incurred so far. */
7573 return x_error_message
->string
[0] != 0;
7576 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
7579 x_clear_errors (Display
*dpy
)
7581 x_error_message
->string
[0] = 0;
7584 #if 0 /* See comment in unwind_to_catch why calling this is a bad
7585 * idea. --lorentey */
7586 /* Close off all unclosed x_catch_errors calls. */
7589 x_fully_uncatch_errors ()
7591 while (x_error_message
)
7592 x_uncatch_errors ();
7596 /* Nonzero if x_catch_errors has been done and not yet canceled. */
7599 x_catching_errors (void)
7601 return x_error_message
!= 0;
7605 static unsigned int x_wire_count
;
7608 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
7613 /* Handle SIGPIPE, which can happen when the connection to a server
7614 simply goes away. SIGPIPE is handled by x_connection_signal.
7615 Don't need to do anything, because the write which caused the
7616 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
7617 which will do the appropriate cleanup for us. */
7620 x_connection_signal (int signalnum
) /* If we don't have an argument, */
7621 /* some compilers complain in signal calls. */
7624 /* USG systems forget handlers when they are used;
7625 must reestablish each time */
7626 signal (signalnum
, x_connection_signal
);
7631 /************************************************************************
7633 ************************************************************************/
7635 /* Error message passed to x_connection_closed. */
7637 static char *error_msg
;
7639 /* Function installed as fatal_error_signal_hook in
7640 x_connection_closed. Print the X error message, and exit normally,
7641 instead of dumping core when XtCloseDisplay fails. */
7644 x_fatal_error_signal (void)
7646 fprintf (stderr
, "%s\n", error_msg
);
7650 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
7651 the text of an error message that lead to the connection loss. */
7654 x_connection_closed (Display
*dpy
, char *error_message
)
7656 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
7657 Lisp_Object frame
, tail
;
7658 int index
= SPECPDL_INDEX ();
7660 error_msg
= (char *) alloca (strlen (error_message
) + 1);
7661 strcpy (error_msg
, error_message
);
7662 handling_signal
= 0;
7664 /* Prevent being called recursively because of an error condition
7665 below. Otherwise, we might end up with printing ``can't find per
7666 display information'' in the recursive call instead of printing
7667 the original message here. */
7668 x_catch_errors (dpy
);
7670 /* Inhibit redisplay while frames are being deleted. */
7671 specbind (Qinhibit_redisplay
, Qt
);
7675 /* Protect display from being closed when we delete the last
7677 dpyinfo
->reference_count
++;
7678 dpyinfo
->terminal
->reference_count
++;
7681 /* First delete frames whose mini-buffers are on frames
7682 that are on the dead display. */
7683 FOR_EACH_FRAME (tail
, frame
)
7685 Lisp_Object minibuf_frame
;
7687 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
7688 if (FRAME_X_P (XFRAME (frame
))
7689 && FRAME_X_P (XFRAME (minibuf_frame
))
7690 && ! EQ (frame
, minibuf_frame
)
7691 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
7692 delete_frame (frame
, Qnoelisp
);
7695 /* Now delete all remaining frames on the dead display.
7696 We are now sure none of these is used as the mini-buffer
7697 for another frame that we need to delete. */
7698 FOR_EACH_FRAME (tail
, frame
)
7699 if (FRAME_X_P (XFRAME (frame
))
7700 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
7702 /* Set this to t so that delete_frame won't get confused
7703 trying to find a replacement. */
7704 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
7705 delete_frame (frame
, Qnoelisp
);
7708 /* We have to close the display to inform Xt that it doesn't
7709 exist anymore. If we don't, Xt will continue to wait for
7710 events from the display. As a consequence, a sequence of
7712 M-x make-frame-on-display RET :1 RET
7713 ...kill the new frame, so that we get an IO error...
7714 M-x make-frame-on-display RET :1 RET
7716 will indefinitely wait in Xt for events for display `:1', opened
7717 in the first call to make-frame-on-display.
7719 Closing the display is reported to lead to a bus error on
7720 OpenWindows in certain situations. I suspect that is a bug
7721 in OpenWindows. I don't know how to circumvent it here. */
7725 #ifdef USE_X_TOOLKIT
7726 /* If DPYINFO is null, this means we didn't open the display
7727 in the first place, so don't try to close it. */
7729 extern void (*fatal_error_signal_hook
) (void);
7730 fatal_error_signal_hook
= x_fatal_error_signal
;
7731 XtCloseDisplay (dpy
);
7732 fatal_error_signal_hook
= NULL
;
7737 /* Due to bugs in some Gtk+ versions, just exit here if this
7738 is the last display/terminal. */
7739 if (terminal_list
->next_terminal
== NULL
)
7741 fprintf (stderr
, "%s\n", error_msg
);
7742 Fkill_emacs (make_number (70));
7745 xg_display_close (dpyinfo
->display
);
7748 /* Indicate that this display is dead. */
7749 dpyinfo
->display
= 0;
7751 dpyinfo
->reference_count
--;
7752 dpyinfo
->terminal
->reference_count
--;
7753 if (dpyinfo
->reference_count
!= 0)
7754 /* We have just closed all frames on this display. */
7759 XSETTERMINAL (tmp
, dpyinfo
->terminal
);
7760 Fdelete_terminal (tmp
, Qnoelisp
);
7764 x_uncatch_errors ();
7766 if (terminal_list
== 0)
7768 fprintf (stderr
, "%s\n", error_msg
);
7769 Fkill_emacs (make_number (70));
7773 /* Ordinary stack unwind doesn't deal with these. */
7775 sigunblock (sigmask (SIGIO
));
7777 sigunblock (sigmask (SIGALRM
));
7778 TOTALLY_UNBLOCK_INPUT
;
7780 unbind_to (index
, Qnil
);
7781 clear_waiting_for_input ();
7782 /* Here, we absolutely have to use a non-local exit (e.g. signal, throw,
7783 longjmp), because returning from this function would get us back into
7784 Xlib's code which will directly call `exit'. */
7785 error ("%s", error_msg
);
7788 /* We specifically use it before defining it, so that gcc doesn't inline it,
7789 otherwise gdb doesn't know how to properly put a breakpoint on it. */
7790 static void x_error_quitter (Display
*, XErrorEvent
*);
7792 /* This is the first-level handler for X protocol errors.
7793 It calls x_error_quitter or x_error_catcher. */
7796 x_error_handler (Display
*display
, XErrorEvent
*error
)
7798 if (x_error_message
)
7799 x_error_catcher (display
, error
);
7801 x_error_quitter (display
, error
);
7805 /* This is the usual handler for X protocol errors.
7806 It kills all frames on the display that we got the error for.
7807 If that was the only one, it prints an error message and kills Emacs. */
7809 /* .gdbinit puts a breakpoint here, so make sure it is not inlined. */
7811 #if __GNUC__ >= 3 /* On GCC 3.0 we might get a warning. */
7812 #define NO_INLINE __attribute__((noinline))
7817 /* Some versions of GNU/Linux define noinline in their headers. */
7823 /* On older GCC versions, just putting x_error_quitter
7824 after x_error_handler prevents inlining into the former. */
7826 static void NO_INLINE
7827 x_error_quitter (Display
*display
, XErrorEvent
*error
)
7829 char buf
[256], buf1
[356];
7831 /* Ignore BadName errors. They can happen because of fonts
7832 or colors that are not defined. */
7834 if (error
->error_code
== BadName
)
7837 /* Note that there is no real way portable across R3/R4 to get the
7838 original error handler. */
7840 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
7841 sprintf (buf1
, "X protocol error: %s on protocol request %d",
7842 buf
, error
->request_code
);
7843 x_connection_closed (display
, buf1
);
7847 /* This is the handler for X IO errors, always.
7848 It kills all frames on the display that we lost touch with.
7849 If that was the only one, it prints an error message and kills Emacs. */
7852 x_io_error_quitter (Display
*display
)
7856 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
7857 x_connection_closed (display
, buf
);
7861 /* Changing the font of the frame. */
7863 /* Give frame F the font FONT-OBJECT as its default font. The return
7864 value is FONT-OBJECT. FONTSET is an ID of the fontset for the
7865 frame. If it is negative, generate a new fontset from
7869 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
7871 struct font
*font
= XFONT_OBJECT (font_object
);
7874 fontset
= fontset_from_font (font_object
);
7875 FRAME_FONTSET (f
) = fontset
;
7876 if (FRAME_FONT (f
) == font
)
7877 /* This font is already set in frame F. There's nothing more to
7881 FRAME_FONT (f
) = font
;
7882 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
7883 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
7884 FRAME_SPACE_WIDTH (f
) = font
->space_width
;
7885 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (font
);
7887 compute_fringe_widths (f
, 1);
7889 /* Compute the scroll bar width in character columns. */
7890 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
7892 int wid
= FRAME_COLUMN_WIDTH (f
);
7893 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
7894 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
-1) / wid
;
7898 int wid
= FRAME_COLUMN_WIDTH (f
);
7899 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
7902 if (FRAME_X_WINDOW (f
) != 0)
7904 /* Don't change the size of a tip frame; there's no point in
7905 doing it because it's done in Fx_show_tip, and it leads to
7906 problems because the tip frame has no widget. */
7907 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
7908 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
7913 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
7916 xic_set_xfontset (f
, SDATA (fontset_ascii (fontset
)));
7925 /***********************************************************************
7927 ***********************************************************************/
7933 /* XIM destroy callback function, which is called whenever the
7934 connection to input method XIM dies. CLIENT_DATA contains a
7935 pointer to the x_display_info structure corresponding to XIM. */
7938 xim_destroy_callback (XIM xim
, XPointer client_data
, XPointer call_data
)
7940 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
7941 Lisp_Object frame
, tail
;
7945 /* No need to call XDestroyIC.. */
7946 FOR_EACH_FRAME (tail
, frame
)
7948 struct frame
*f
= XFRAME (frame
);
7949 if (FRAME_X_P (f
) && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
7951 FRAME_XIC (f
) = NULL
;
7952 xic_free_xfontset (f
);
7956 /* No need to call XCloseIM. */
7957 dpyinfo
->xim
= NULL
;
7958 XFree (dpyinfo
->xim_styles
);
7962 #endif /* HAVE_X11R6 */
7965 /* This isn't prototyped in OSF 5.0 or 5.1a. */
7966 extern char *XSetIMValues (XIM
, ...);
7969 /* Open the connection to the XIM server on display DPYINFO.
7970 RESOURCE_NAME is the resource name Emacs uses. */
7973 xim_open_dpy (struct x_display_info
*dpyinfo
, char *resource_name
)
7981 XCloseIM (dpyinfo
->xim
);
7982 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
,
7989 XIMCallback destroy
;
7992 /* Get supported styles and XIM values. */
7993 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
7996 destroy
.callback
= xim_destroy_callback
;
7997 destroy
.client_data
= (XPointer
)dpyinfo
;
7998 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
8004 #endif /* HAVE_XIM */
8005 dpyinfo
->xim
= NULL
;
8009 #ifdef HAVE_X11R6_XIM
8011 /* XIM instantiate callback function, which is called whenever an XIM
8012 server is available. DISPLAY is the display of the XIM.
8013 CLIENT_DATA contains a pointer to an xim_inst_t structure created
8014 when the callback was registered. */
8017 xim_instantiate_callback (Display
*display
, XPointer client_data
, XPointer call_data
)
8019 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
8020 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
8022 /* We don't support multiple XIM connections. */
8026 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
8028 /* Create XIC for the existing frames on the same display, as long
8029 as they have no XIC. */
8030 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
8032 Lisp_Object tail
, frame
;
8035 FOR_EACH_FRAME (tail
, frame
)
8037 struct frame
*f
= XFRAME (frame
);
8040 && FRAME_X_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
8041 if (FRAME_XIC (f
) == NULL
)
8043 create_frame_xic (f
);
8044 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
8045 xic_set_statusarea (f
);
8046 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
8048 struct window
*w
= XWINDOW (f
->selected_window
);
8049 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
8058 #endif /* HAVE_X11R6_XIM */
8061 /* Open a connection to the XIM server on display DPYINFO.
8062 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
8063 connection only at the first time. On X11R6, open the connection
8064 in the XIM instantiate callback function. */
8067 xim_initialize (struct x_display_info
*dpyinfo
, char *resource_name
)
8069 dpyinfo
->xim
= NULL
;
8073 #ifdef HAVE_X11R6_XIM
8074 struct xim_inst_t
*xim_inst
;
8077 xim_inst
= (struct xim_inst_t
*) xmalloc (sizeof (struct xim_inst_t
));
8078 dpyinfo
->xim_callback_data
= xim_inst
;
8079 xim_inst
->dpyinfo
= dpyinfo
;
8080 len
= strlen (resource_name
);
8081 xim_inst
->resource_name
= (char *) xmalloc (len
+ 1);
8082 bcopy (resource_name
, xim_inst
->resource_name
, len
+ 1);
8083 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8084 resource_name
, EMACS_CLASS
,
8085 xim_instantiate_callback
,
8086 /* This is XPointer in XFree86
8087 but (XPointer *) on Tru64, at
8088 least, hence the configure test. */
8089 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
8090 #else /* not HAVE_X11R6_XIM */
8091 xim_open_dpy (dpyinfo
, resource_name
);
8092 #endif /* not HAVE_X11R6_XIM */
8094 #endif /* HAVE_XIM */
8098 /* Close the connection to the XIM server on display DPYINFO. */
8101 xim_close_dpy (struct x_display_info
*dpyinfo
)
8106 #ifdef HAVE_X11R6_XIM
8107 if (dpyinfo
->display
)
8108 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8110 xim_instantiate_callback
, NULL
);
8111 xfree (dpyinfo
->xim_callback_data
->resource_name
);
8112 xfree (dpyinfo
->xim_callback_data
);
8113 #endif /* HAVE_X11R6_XIM */
8114 if (dpyinfo
->display
)
8115 XCloseIM (dpyinfo
->xim
);
8116 dpyinfo
->xim
= NULL
;
8117 XFree (dpyinfo
->xim_styles
);
8119 #endif /* HAVE_XIM */
8122 #endif /* not HAVE_X11R6_XIM */
8126 /* Calculate the absolute position in frame F
8127 from its current recorded position values and gravity. */
8130 x_calc_absolute_position (struct frame
*f
)
8132 int flags
= f
->size_hint_flags
;
8134 /* We have nothing to do if the current position
8135 is already for the top-left corner. */
8136 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
8139 /* Treat negative positions as relative to the leftmost bottommost
8140 position that fits on the screen. */
8141 if (flags
& XNegative
)
8142 f
->left_pos
= x_display_pixel_width (FRAME_X_DISPLAY_INFO (f
))
8143 - FRAME_PIXEL_WIDTH (f
) + f
->left_pos
;
8146 int height
= FRAME_PIXEL_HEIGHT (f
);
8148 #if defined USE_X_TOOLKIT && defined USE_MOTIF
8149 /* Something is fishy here. When using Motif, starting Emacs with
8150 `-g -0-0', the frame appears too low by a few pixels.
8152 This seems to be so because initially, while Emacs is starting,
8153 the column widget's height and the frame's pixel height are
8154 different. The column widget's height is the right one. In
8155 later invocations, when Emacs is up, the frame's pixel height
8158 It's not obvious where the initial small difference comes from.
8159 2000-12-01, gerd. */
8161 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
8164 if (flags
& YNegative
)
8165 f
->top_pos
= x_display_pixel_height (FRAME_X_DISPLAY_INFO (f
))
8166 - height
+ f
->top_pos
;
8169 /* The left_pos and top_pos
8170 are now relative to the top and left screen edges,
8171 so the flags should correspond. */
8172 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8175 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
8176 to really change the position, and 0 when calling from
8177 x_make_frame_visible (in that case, XOFF and YOFF are the current
8178 position values). It is -1 when calling from x_set_frame_parameters,
8179 which means, do adjust for borders but don't change the gravity. */
8182 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
, int change_gravity
)
8184 int modified_top
, modified_left
;
8186 if (change_gravity
> 0)
8188 FRAME_X_OUTPUT (f
)->left_before_move
= f
->left_pos
;
8189 FRAME_X_OUTPUT (f
)->top_before_move
= f
->top_pos
;
8193 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8195 f
->size_hint_flags
|= XNegative
;
8197 f
->size_hint_flags
|= YNegative
;
8198 f
->win_gravity
= NorthWestGravity
;
8200 x_calc_absolute_position (f
);
8203 x_wm_set_size_hint (f
, (long) 0, 0);
8205 modified_left
= f
->left_pos
;
8206 modified_top
= f
->top_pos
;
8208 if (change_gravity
!= 0 && FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
)
8210 /* Some WMs (twm, wmaker at least) has an offset that is smaller
8211 than the WM decorations. So we use the calculated offset instead
8212 of the WM decoration sizes here (x/y_pixels_outer_diff). */
8213 modified_left
+= FRAME_X_OUTPUT (f
)->move_offset_left
;
8214 modified_top
+= FRAME_X_OUTPUT (f
)->move_offset_top
;
8217 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8218 modified_left
, modified_top
);
8220 x_sync_with_move (f
, f
->left_pos
, f
->top_pos
,
8221 FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8224 /* change_gravity is non-zero when this function is called from Lisp to
8225 programmatically move a frame. In that case, we call
8226 x_check_expected_move to discover if we have a "Type A" or "Type B"
8227 window manager, and, for a "Type A" window manager, adjust the position
8230 We call x_check_expected_move if a programmatic move occurred, and
8231 either the window manager type (A/B) is unknown or it is Type A but we
8232 need to compute the top/left offset adjustment for this frame. */
8234 if (change_gravity
!= 0 &&
8235 (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8236 || (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
8237 && (FRAME_X_OUTPUT (f
)->move_offset_left
== 0
8238 && FRAME_X_OUTPUT (f
)->move_offset_top
== 0))))
8239 x_check_expected_move (f
, modified_left
, modified_top
);
8244 /* Return non-zero if _NET_SUPPORTING_WM_CHECK window exists and _NET_SUPPORTED
8245 on the root window for frame F contains ATOMNAME.
8246 This is how a WM check shall be done according to the Window Manager
8247 Specification/Extended Window Manager Hints at
8248 http://freedesktop.org/wiki/Specifications/wm-spec. */
8251 wm_supports (struct frame
*f
, const char *atomname
)
8254 unsigned long actual_size
, bytes_remaining
;
8255 int i
, rc
, actual_format
;
8257 Window wmcheck_window
;
8258 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8259 Window target_window
= dpyinfo
->root_window
;
8260 long max_len
= 65536;
8261 Display
*dpy
= FRAME_X_DISPLAY (f
);
8262 unsigned char *tmp_data
= NULL
;
8263 Atom target_type
= XA_WINDOW
;
8268 prop_atom
= XInternAtom (dpy
, "_NET_SUPPORTING_WM_CHECK", False
);
8270 x_catch_errors (dpy
);
8271 rc
= XGetWindowProperty (dpy
, target_window
,
8272 prop_atom
, 0, max_len
, False
, target_type
,
8273 &actual_type
, &actual_format
, &actual_size
,
8274 &bytes_remaining
, &tmp_data
);
8276 if (rc
!= Success
|| actual_type
!= XA_WINDOW
|| x_had_errors_p (dpy
))
8278 if (tmp_data
) XFree (tmp_data
);
8279 x_uncatch_errors ();
8284 wmcheck_window
= *(Window
*) tmp_data
;
8287 /* Check if window exists. */
8288 XSelectInput (dpy
, wmcheck_window
, StructureNotifyMask
);
8290 if (x_had_errors_p (dpy
))
8292 x_uncatch_errors ();
8297 if (dpyinfo
->net_supported_window
!= wmcheck_window
)
8299 /* Window changed, reload atoms */
8300 if (dpyinfo
->net_supported_atoms
!= NULL
)
8301 XFree (dpyinfo
->net_supported_atoms
);
8302 dpyinfo
->net_supported_atoms
= NULL
;
8303 dpyinfo
->nr_net_supported_atoms
= 0;
8304 dpyinfo
->net_supported_window
= 0;
8306 target_type
= XA_ATOM
;
8307 prop_atom
= XInternAtom (dpy
, "_NET_SUPPORTED", False
);
8309 rc
= XGetWindowProperty (dpy
, target_window
,
8310 prop_atom
, 0, max_len
, False
, target_type
,
8311 &actual_type
, &actual_format
, &actual_size
,
8312 &bytes_remaining
, &tmp_data
);
8314 if (rc
!= Success
|| actual_type
!= XA_ATOM
|| x_had_errors_p (dpy
))
8316 if (tmp_data
) XFree (tmp_data
);
8317 x_uncatch_errors ();
8322 dpyinfo
->net_supported_atoms
= (Atom
*)tmp_data
;
8323 dpyinfo
->nr_net_supported_atoms
= actual_size
;
8324 dpyinfo
->net_supported_window
= wmcheck_window
;
8328 want_atom
= XInternAtom (dpy
, atomname
, False
);
8330 for (i
= 0; rc
== 0 && i
< dpyinfo
->nr_net_supported_atoms
; ++i
)
8331 rc
= dpyinfo
->net_supported_atoms
[i
] == want_atom
;
8333 x_uncatch_errors ();
8340 set_wm_state (Lisp_Object frame
, int add
, const char *what
, const char *what2
)
8342 const char *atom
= "_NET_WM_STATE";
8343 Fx_send_client_event (frame
, make_number (0), frame
,
8344 make_unibyte_string (atom
, strlen (atom
)),
8346 /* 1 = add, 0 = remove */
8348 (make_number (add
? 1 : 0),
8350 (make_unibyte_string (what
, strlen (what
)),
8352 ? Fcons (make_unibyte_string (what2
, strlen (what2
)),
8358 x_set_sticky (struct frame
*f
, Lisp_Object new_value
, Lisp_Object old_value
)
8362 XSETFRAME (frame
, f
);
8363 set_wm_state (frame
, NILP (new_value
) ? 0 : 1,
8364 "_NET_WM_STATE_STICKY", NULL
);
8367 /* Do fullscreen as specified in extended window manager hints */
8370 do_ewmh_fullscreen (struct frame
*f
)
8372 int have_net_atom
= wm_supports (f
, "_NET_WM_STATE");
8374 /* Some window managers don't say they support _NET_WM_STATE, but they do say
8375 they support _NET_WM_STATE_FULLSCREEN. Try that also. */
8377 have_net_atom
= wm_supports (f
, "_NET_WM_STATE_FULLSCREEN");
8382 const char *fs
= "_NET_WM_STATE_FULLSCREEN";
8383 const char *fw
= "_NET_WM_STATE_MAXIMIZED_HORZ";
8384 const char *fh
= "_NET_WM_STATE_MAXIMIZED_VERT";
8386 XSETFRAME (frame
, f
);
8388 set_wm_state (frame
, 0, fs
, NULL
);
8389 set_wm_state (frame
, 0, fh
, NULL
);
8390 set_wm_state (frame
, 0, fw
, NULL
);
8392 /* If there are _NET_ atoms we assume we have extended window manager
8394 switch (f
->want_fullscreen
)
8396 case FULLSCREEN_BOTH
:
8397 set_wm_state (frame
, 1, fs
, NULL
);
8399 case FULLSCREEN_WIDTH
:
8400 set_wm_state (frame
, 1, fw
, NULL
);
8402 case FULLSCREEN_HEIGHT
:
8403 set_wm_state (frame
, 1, fh
, NULL
);
8405 case FULLSCREEN_MAXIMIZED
:
8406 set_wm_state (frame
, 1, fw
, fh
);
8410 f
->want_fullscreen
= FULLSCREEN_NONE
;
8414 return have_net_atom
;
8418 XTfullscreen_hook (FRAME_PTR f
)
8420 if (f
->async_visible
)
8423 x_check_fullscreen (f
);
8431 x_handle_net_wm_state (struct frame
*f
, XPropertyEvent
*event
)
8434 unsigned long actual_size
, bytes_remaining
;
8435 int i
, rc
, actual_format
, value
= FULLSCREEN_NONE
;
8436 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8437 long max_len
= 65536;
8438 Display
*dpy
= FRAME_X_DISPLAY (f
);
8439 unsigned char *tmp_data
= NULL
;
8440 Atom target_type
= XA_ATOM
;
8445 x_catch_errors (dpy
);
8446 rc
= XGetWindowProperty (dpy
, event
->window
,
8447 event
->atom
, 0, max_len
, False
, target_type
,
8448 &actual_type
, &actual_format
, &actual_size
,
8449 &bytes_remaining
, &tmp_data
);
8451 if (rc
!= Success
|| actual_type
!= target_type
|| x_had_errors_p (dpy
))
8453 if (tmp_data
) XFree (tmp_data
);
8454 x_uncatch_errors ();
8459 x_uncatch_errors ();
8461 for (i
= 0; i
< actual_size
; ++i
)
8463 Atom a
= ((Atom
*)tmp_data
)[i
];
8464 if (a
== dpyinfo
->Xatom_net_wm_state_maximized_horz
)
8466 if (value
== FULLSCREEN_HEIGHT
)
8467 value
= FULLSCREEN_MAXIMIZED
;
8469 value
= FULLSCREEN_WIDTH
;
8471 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_vert
)
8473 if (value
== FULLSCREEN_WIDTH
)
8474 value
= FULLSCREEN_MAXIMIZED
;
8476 value
= FULLSCREEN_HEIGHT
;
8478 else if (a
== dpyinfo
->Xatom_net_wm_state_fullscreen_atom
)
8479 value
= FULLSCREEN_BOTH
;
8480 else if (a
== dpyinfo
->Xatom_net_wm_state_sticky
)
8487 case FULLSCREEN_WIDTH
:
8490 case FULLSCREEN_HEIGHT
:
8493 case FULLSCREEN_BOTH
:
8496 case FULLSCREEN_MAXIMIZED
:
8501 store_frame_param (f
, Qfullscreen
, lval
);
8502 store_frame_param (f
, Qsticky
, sticky
? Qt
: Qnil
);
8504 if (tmp_data
) XFree (tmp_data
);
8508 /* Check if we need to resize the frame due to a fullscreen request.
8509 If so needed, resize the frame. */
8511 x_check_fullscreen (struct frame
*f
)
8513 if (do_ewmh_fullscreen (f
))
8516 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
8517 return; /* Only fullscreen without WM or with EWM hints (above). */
8519 if (f
->want_fullscreen
!= FULLSCREEN_NONE
)
8521 int width
= FRAME_COLS (f
), height
= FRAME_LINES (f
);
8522 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8524 switch (f
->want_fullscreen
)
8526 /* No difference between these two when there is no WM */
8527 case FULLSCREEN_BOTH
:
8528 case FULLSCREEN_MAXIMIZED
:
8529 width
= x_display_pixel_width (dpyinfo
);
8530 height
= x_display_pixel_height (dpyinfo
);
8532 case FULLSCREEN_WIDTH
:
8533 width
= x_display_pixel_width (dpyinfo
);
8535 case FULLSCREEN_HEIGHT
:
8536 height
= x_display_pixel_height (dpyinfo
);
8539 if (FRAME_COLS (f
) != width
|| FRAME_LINES (f
) != height
)
8541 change_frame_size (f
, height
, width
, 0, 1, 0);
8542 SET_FRAME_GARBAGED (f
);
8543 cancel_mouse_face (f
);
8548 /* This function is called by x_set_offset to determine whether the window
8549 manager interfered with the positioning of the frame. Type A window
8550 managers position the surrounding window manager decorations a small
8551 amount above and left of the user-supplied position. Type B window
8552 managers position the surrounding window manager decorations at the
8553 user-specified position. If we detect a Type A window manager, we
8554 compensate by moving the window right and down by the proper amount. */
8557 x_check_expected_move (struct frame
*f
, int expected_left
, int expected_top
)
8559 int current_left
= 0, current_top
= 0;
8561 /* x_real_positions returns the left and top offsets of the outermost
8562 window manager window around the frame. */
8564 x_real_positions (f
, ¤t_left
, ¤t_top
);
8566 if (current_left
!= expected_left
|| current_top
!= expected_top
)
8568 /* It's a "Type A" window manager. */
8573 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_A
;
8574 FRAME_X_OUTPUT (f
)->move_offset_left
= expected_left
- current_left
;
8575 FRAME_X_OUTPUT (f
)->move_offset_top
= expected_top
- current_top
;
8577 /* Now fix the mispositioned frame's location. */
8579 adjusted_left
= expected_left
+ FRAME_X_OUTPUT (f
)->move_offset_left
;
8580 adjusted_top
= expected_top
+ FRAME_X_OUTPUT (f
)->move_offset_top
;
8582 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8583 adjusted_left
, adjusted_top
);
8585 x_sync_with_move (f
, expected_left
, expected_top
, 0);
8588 /* It's a "Type B" window manager. We don't have to adjust the
8589 frame's position. */
8591 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_B
;
8595 /* Wait for XGetGeometry to return up-to-date position information for a
8596 recently-moved frame. Call this immediately after calling XMoveWindow.
8597 If FUZZY is non-zero, then LEFT and TOP are just estimates of where the
8598 frame has been moved to, so we use a fuzzy position comparison instead
8599 of an exact comparison. */
8602 x_sync_with_move (struct frame
*f
, int left
, int top
, int fuzzy
)
8606 while (count
++ < 50)
8608 int current_left
= 0, current_top
= 0;
8610 /* In theory, this call to XSync only needs to happen once, but in
8611 practice, it doesn't seem to work, hence the need for the surrounding
8614 XSync (FRAME_X_DISPLAY (f
), False
);
8615 x_real_positions (f
, ¤t_left
, ¤t_top
);
8619 /* The left fuzz-factor is 10 pixels. The top fuzz-factor is 40
8622 if (eabs (current_left
- left
) <= 10
8623 && eabs (current_top
- top
) <= 40)
8626 else if (current_left
== left
&& current_top
== top
)
8630 /* As a last resort, just wait 0.5 seconds and hope that XGetGeometry
8631 will then return up-to-date position info. */
8633 wait_reading_process_output (0, 500000, 0, 0, Qnil
, NULL
, 0);
8637 /* Wait for an event on frame F matching EVENTTYPE. */
8639 x_wait_for_event (struct frame
*f
, int eventtype
)
8641 int level
= interrupt_input_blocked
;
8644 EMACS_TIME tmo
, tmo_at
, time_now
;
8645 int fd
= ConnectionNumber (FRAME_X_DISPLAY (f
));
8647 pending_event_wait
.f
= f
;
8648 pending_event_wait
.eventtype
= eventtype
;
8650 /* Set timeout to 0.1 second. Hopefully not noticable.
8651 Maybe it should be configurable. */
8652 EMACS_SET_SECS_USECS (tmo
, 0, 100000);
8653 EMACS_GET_TIME (tmo_at
);
8654 EMACS_ADD_TIME (tmo_at
, tmo_at
, tmo
);
8656 while (pending_event_wait
.eventtype
)
8658 interrupt_input_pending
= 1;
8659 TOTALLY_UNBLOCK_INPUT
;
8660 /* XTread_socket is called after unblock. */
8662 interrupt_input_blocked
= level
;
8667 EMACS_GET_TIME (time_now
);
8668 EMACS_SUB_TIME (tmo
, tmo_at
, time_now
);
8670 if (EMACS_TIME_NEG_P (tmo
) || select (fd
+1, &fds
, NULL
, NULL
, &tmo
) == 0)
8671 break; /* Timeout */
8673 pending_event_wait
.f
= 0;
8674 pending_event_wait
.eventtype
= 0;
8678 /* Change the size of frame F's X window to COLS/ROWS in the case F
8679 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
8680 top-left-corner window gravity for this size change and subsequent
8681 size changes. Otherwise we leave the window gravity unchanged. */
8684 x_set_window_size_1 (struct frame
*f
, int change_gravity
, int cols
, int rows
)
8686 int pixelwidth
, pixelheight
;
8688 check_frame_size (f
, &rows
, &cols
);
8689 f
->scroll_bar_actual_width
8690 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
8692 : FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0
8693 ? FRAME_CONFIG_SCROLL_BAR_WIDTH (f
)
8694 : (FRAME_CONFIG_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
)));
8696 compute_fringe_widths (f
, 0);
8698 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
8699 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
8700 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
8702 if (change_gravity
) f
->win_gravity
= NorthWestGravity
;
8703 x_wm_set_size_hint (f
, (long) 0, 0);
8704 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8705 pixelwidth
, pixelheight
);
8708 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
8709 receive in the ConfigureNotify event; if we get what we asked
8710 for, then the event won't cause the screen to become garbaged, so
8711 we have to make sure to do it here. */
8712 SET_FRAME_GARBAGED (f
);
8714 /* Now, strictly speaking, we can't be sure that this is accurate,
8715 but the window manager will get around to dealing with the size
8716 change request eventually, and we'll hear how it went when the
8717 ConfigureNotify event gets here.
8719 We could just not bother storing any of this information here,
8720 and let the ConfigureNotify event set everything up, but that
8721 might be kind of confusing to the Lisp code, since size changes
8722 wouldn't be reported in the frame parameters until some random
8723 point in the future when the ConfigureNotify event arrives.
8725 We pass 1 for DELAY since we can't run Lisp code inside of
8728 /* But the ConfigureNotify may in fact never arrive, and then this is
8729 not right if the frame is visible. Instead wait (with timeout)
8730 for the ConfigureNotify. */
8731 if (f
->async_visible
)
8732 x_wait_for_event (f
, ConfigureNotify
);
8735 change_frame_size (f
, rows
, cols
, 0, 1, 0);
8736 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
8737 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
8743 /* Call this to change the size of frame F's x-window.
8744 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
8745 for this size change and subsequent size changes.
8746 Otherwise we leave the window gravity unchanged. */
8749 x_set_window_size (struct frame
*f
, int change_gravity
, int cols
, int rows
)
8753 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
8757 /* When the frame is maximized/fullscreen or running under for
8758 example Xmonad, x_set_window_size_1 will be a no-op.
8759 In that case, the right thing to do is extend rows/cols to
8760 the current frame size. We do that first if x_set_window_size_1
8761 turns out to not be a no-op (there is no way to know).
8762 The size will be adjusted again if the frame gets a
8763 ConfigureNotify event as a result of x_set_window_size. */
8764 int pixelh
= FRAME_PIXEL_HEIGHT (f
);
8765 #ifdef USE_X_TOOLKIT
8766 /* The menu bar is not part of text lines. The tool bar
8768 pixelh
-= FRAME_MENUBAR_HEIGHT (f
);
8770 r
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelh
);
8771 /* Update f->scroll_bar_actual_width because it is used in
8772 FRAME_PIXEL_WIDTH_TO_TEXT_COLS. */
8773 f
->scroll_bar_actual_width
8774 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
8775 c
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, FRAME_PIXEL_WIDTH (f
));
8776 change_frame_size (f
, r
, c
, 0, 1, 0);
8780 if (FRAME_GTK_WIDGET (f
))
8781 xg_frame_set_char_size (f
, cols
, rows
);
8783 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8784 #else /* not USE_GTK */
8786 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8788 #endif /* not USE_GTK */
8790 /* If cursor was outside the new size, mark it as off. */
8791 mark_window_cursors_off (XWINDOW (f
->root_window
));
8793 /* Clear out any recollection of where the mouse highlighting was,
8794 since it might be in a place that's outside the new frame size.
8795 Actually checking whether it is outside is a pain in the neck,
8796 so don't try--just let the highlighting be done afresh with new size. */
8797 cancel_mouse_face (f
);
8802 /* Mouse warping. */
8805 x_set_mouse_position (struct frame
*f
, int x
, int y
)
8809 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
8810 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
8812 if (pix_x
< 0) pix_x
= 0;
8813 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
8815 if (pix_y
< 0) pix_y
= 0;
8816 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
8820 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8821 0, 0, 0, 0, pix_x
, pix_y
);
8825 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
8828 x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
8832 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8833 0, 0, 0, 0, pix_x
, pix_y
);
8837 /* focus shifting, raising and lowering. */
8840 x_focus_on_frame (struct frame
*f
)
8843 /* I don't think that the ICCCM allows programs to do things like this
8844 without the interaction of the window manager. Whatever you end up
8845 doing with this code, do it to x_unfocus_frame too. */
8846 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8847 RevertToPointerRoot
, CurrentTime
);
8852 x_unfocus_frame (struct frame
*f
)
8855 /* Look at the remarks in x_focus_on_frame. */
8856 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
8857 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
8858 RevertToPointerRoot
, CurrentTime
);
8862 /* Raise frame F. */
8865 x_raise_frame (struct frame
*f
)
8868 if (f
->async_visible
)
8869 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8871 XFlush (FRAME_X_DISPLAY (f
));
8875 /* Lower frame F. */
8878 x_lower_frame (struct frame
*f
)
8880 if (f
->async_visible
)
8883 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8884 XFlush (FRAME_X_DISPLAY (f
));
8889 /* Activate frame with Extended Window Manager Hints */
8892 x_ewmh_activate_frame (FRAME_PTR f
)
8894 /* See Window Manager Specification/Extended Window Manager Hints at
8895 http://freedesktop.org/wiki/Specifications/wm-spec */
8897 const char *atom
= "_NET_ACTIVE_WINDOW";
8898 if (f
->async_visible
&& wm_supports (f
, atom
))
8901 XSETFRAME (frame
, f
);
8902 Fx_send_client_event (frame
, make_number (0), frame
,
8903 make_unibyte_string (atom
, strlen (atom
)),
8905 Fcons (make_number (1),
8906 Fcons (make_number (last_user_time
),
8912 XTframe_raise_lower (FRAME_PTR f
, int raise_flag
)
8920 /* XEmbed implementation. */
8923 xembed_set_info (struct frame
*f
, enum xembed_info flags
)
8926 unsigned long data
[2];
8928 atom
= XInternAtom (FRAME_X_DISPLAY (f
), "_XEMBED_INFO", False
);
8930 data
[0] = XEMBED_VERSION
;
8933 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), atom
, atom
,
8934 32, PropModeReplace
, (unsigned char *) data
, 2);
8938 xembed_send_message (struct frame
*f
, Time time
, enum xembed_message message
, long int detail
, long int data1
, long int data2
)
8942 event
.xclient
.type
= ClientMessage
;
8943 event
.xclient
.window
= FRAME_X_OUTPUT (f
)->parent_desc
;
8944 event
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_XEMBED
;
8945 event
.xclient
.format
= 32;
8946 event
.xclient
.data
.l
[0] = time
;
8947 event
.xclient
.data
.l
[1] = message
;
8948 event
.xclient
.data
.l
[2] = detail
;
8949 event
.xclient
.data
.l
[3] = data1
;
8950 event
.xclient
.data
.l
[4] = data2
;
8952 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_OUTPUT (f
)->parent_desc
,
8953 False
, NoEventMask
, &event
);
8954 XSync (FRAME_X_DISPLAY (f
), False
);
8957 /* Change of visibility. */
8959 /* This tries to wait until the frame is really visible.
8960 However, if the window manager asks the user where to position
8961 the frame, this will return before the user finishes doing that.
8962 The frame will not actually be visible at that time,
8963 but it will become visible later when the window manager
8964 finishes with it. */
8967 x_make_frame_visible (struct frame
*f
)
8970 int original_top
, original_left
;
8971 int retry_count
= 2;
8977 type
= x_icon_type (f
);
8979 x_bitmap_icon (f
, type
);
8981 if (! FRAME_VISIBLE_P (f
))
8983 /* We test FRAME_GARBAGED_P here to make sure we don't
8984 call x_set_offset a second time
8985 if we get to x_make_frame_visible a second time
8986 before the window gets really visible. */
8987 if (! FRAME_ICONIFIED_P (f
)
8988 && ! FRAME_X_EMBEDDED_P (f
)
8989 && ! f
->output_data
.x
->asked_for_visible
)
8990 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
8992 f
->output_data
.x
->asked_for_visible
= 1;
8994 if (! EQ (Vx_no_window_manager
, Qt
))
8995 x_wm_set_window_state (f
, NormalState
);
8996 #ifdef USE_X_TOOLKIT
8997 if (FRAME_X_EMBEDDED_P (f
))
8998 xembed_set_info (f
, XEMBED_MAPPED
);
9001 /* This was XtPopup, but that did nothing for an iconified frame. */
9002 XtMapWidget (f
->output_data
.x
->widget
);
9004 #else /* not USE_X_TOOLKIT */
9006 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
9007 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
9009 if (FRAME_X_EMBEDDED_P (f
))
9010 xembed_set_info (f
, XEMBED_MAPPED
);
9012 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9013 #endif /* not USE_GTK */
9014 #endif /* not USE_X_TOOLKIT */
9017 XFlush (FRAME_X_DISPLAY (f
));
9019 /* Synchronize to ensure Emacs knows the frame is visible
9020 before we do anything else. We do this loop with input not blocked
9021 so that incoming events are handled. */
9025 /* This must be before UNBLOCK_INPUT
9026 since events that arrive in response to the actions above
9027 will set it when they are handled. */
9028 int previously_visible
= f
->output_data
.x
->has_been_visible
;
9030 original_left
= f
->left_pos
;
9031 original_top
= f
->top_pos
;
9033 /* This must come after we set COUNT. */
9036 /* We unblock here so that arriving X events are processed. */
9038 /* Now move the window back to where it was "supposed to be".
9039 But don't do it if the gravity is negative.
9040 When the gravity is negative, this uses a position
9041 that is 3 pixels too low. Perhaps that's really the border width.
9043 Don't do this if the window has never been visible before,
9044 because the window manager may choose the position
9045 and we don't want to override it. */
9047 if (! FRAME_VISIBLE_P (f
)
9048 && ! FRAME_ICONIFIED_P (f
)
9049 && ! FRAME_X_EMBEDDED_P (f
)
9050 && f
->win_gravity
== NorthWestGravity
9051 && previously_visible
)
9055 unsigned int width
, height
, border
, depth
;
9059 /* On some window managers (such as FVWM) moving an existing
9060 window, even to the same place, causes the window manager
9061 to introduce an offset. This can cause the window to move
9062 to an unexpected location. Check the geometry (a little
9063 slow here) and then verify that the window is in the right
9064 place. If the window is not in the right place, move it
9065 there, and take the potential window manager hit. */
9066 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9067 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
9069 if (original_left
!= x
|| original_top
!= y
)
9070 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9071 original_left
, original_top
);
9076 XSETFRAME (frame
, f
);
9078 /* Wait until the frame is visible. Process X events until a
9079 MapNotify event has been seen, or until we think we won't get a
9080 MapNotify at all.. */
9081 for (count
= input_signal_count
+ 10;
9082 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
9084 /* Force processing of queued events. */
9087 /* Machines that do polling rather than SIGIO have been
9088 observed to go into a busy-wait here. So we'll fake an
9089 alarm signal to let the handler know that there's something
9090 to be read. We used to raise a real alarm, but it seems
9091 that the handler isn't always enabled here. This is
9093 if (input_polling_used ())
9095 /* It could be confusing if a real alarm arrives while
9096 processing the fake one. Turn it off and let the
9097 handler reset it. */
9098 extern void poll_for_input_1 (void);
9099 int old_poll_suppress_count
= poll_suppress_count
;
9100 poll_suppress_count
= 1;
9101 poll_for_input_1 ();
9102 poll_suppress_count
= old_poll_suppress_count
;
9105 /* See if a MapNotify event has been processed. */
9106 FRAME_SAMPLE_VISIBILITY (f
);
9111 (let ((f (selected-frame)))
9115 the frame is not raised with various window managers on
9116 FreeBSD, GNU/Linux and Solaris. It turns out that, for some
9117 unknown reason, the call to XtMapWidget is completely ignored.
9118 Mapping the widget a second time works. */
9120 if (!FRAME_VISIBLE_P (f
) && --retry_count
> 0)
9125 /* Change from mapped state to withdrawn state. */
9127 /* Make the frame visible (mapped and not iconified). */
9130 x_make_frame_invisible (struct frame
*f
)
9134 /* Use the frame's outermost window, not the one we normally draw on. */
9135 window
= FRAME_OUTER_WINDOW (f
);
9137 /* Don't keep the highlight on an invisible frame. */
9138 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9139 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9143 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
9144 that the current position of the window is user-specified, rather than
9145 program-specified, so that when the window is mapped again, it will be
9146 placed at the same location, without forcing the user to position it
9147 by hand again (they have already done that once for this window.) */
9148 x_wm_set_size_hint (f
, (long) 0, 1);
9151 if (FRAME_GTK_OUTER_WIDGET (f
))
9152 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f
));
9155 if (FRAME_X_EMBEDDED_P (f
))
9156 xembed_set_info (f
, 0);
9161 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
9162 DefaultScreen (FRAME_X_DISPLAY (f
))))
9164 UNBLOCK_INPUT_RESIGNAL
;
9165 error ("Can't notify window manager of window withdrawal");
9169 /* We can't distinguish this from iconification
9170 just by the event that we get from the server.
9171 So we can't win using the usual strategy of letting
9172 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
9173 and synchronize with the server to make sure we agree. */
9175 FRAME_ICONIFIED_P (f
) = 0;
9176 f
->async_visible
= 0;
9177 f
->async_iconified
= 0;
9184 /* Change window state from mapped to iconified. */
9187 x_iconify_frame (struct frame
*f
)
9192 /* Don't keep the highlight on an invisible frame. */
9193 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9194 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9196 if (f
->async_iconified
)
9201 FRAME_SAMPLE_VISIBILITY (f
);
9203 type
= x_icon_type (f
);
9205 x_bitmap_icon (f
, type
);
9208 if (FRAME_GTK_OUTER_WIDGET (f
))
9210 if (! FRAME_VISIBLE_P (f
))
9211 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
9213 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
9216 f
->async_iconified
= 1;
9217 f
->async_visible
= 0;
9223 #ifdef USE_X_TOOLKIT
9225 if (! FRAME_VISIBLE_P (f
))
9227 if (! EQ (Vx_no_window_manager
, Qt
))
9228 x_wm_set_window_state (f
, IconicState
);
9229 /* This was XtPopup, but that did nothing for an iconified frame. */
9230 XtMapWidget (f
->output_data
.x
->widget
);
9231 /* The server won't give us any event to indicate
9232 that an invisible frame was changed to an icon,
9233 so we have to record it here. */
9236 f
->async_iconified
= 1;
9237 f
->async_visible
= 0;
9242 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
9243 XtWindow (f
->output_data
.x
->widget
),
9244 DefaultScreen (FRAME_X_DISPLAY (f
)));
9248 error ("Can't notify window manager of iconification");
9250 f
->async_iconified
= 1;
9251 f
->async_visible
= 0;
9255 XFlush (FRAME_X_DISPLAY (f
));
9257 #else /* not USE_X_TOOLKIT */
9259 /* Make sure the X server knows where the window should be positioned,
9260 in case the user deiconifies with the window manager. */
9261 if (! FRAME_VISIBLE_P (f
)
9262 && ! FRAME_ICONIFIED_P (f
)
9263 && ! FRAME_X_EMBEDDED_P (f
))
9264 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
9266 /* Since we don't know which revision of X we're running, we'll use both
9267 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
9269 /* X11R4: send a ClientMessage to the window manager using the
9270 WM_CHANGE_STATE type. */
9274 message
.xclient
.window
= FRAME_X_WINDOW (f
);
9275 message
.xclient
.type
= ClientMessage
;
9276 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
9277 message
.xclient
.format
= 32;
9278 message
.xclient
.data
.l
[0] = IconicState
;
9280 if (! XSendEvent (FRAME_X_DISPLAY (f
),
9281 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
9283 SubstructureRedirectMask
| SubstructureNotifyMask
,
9286 UNBLOCK_INPUT_RESIGNAL
;
9287 error ("Can't notify window manager of iconification");
9291 /* X11R3: set the initial_state field of the window manager hints to
9293 x_wm_set_window_state (f
, IconicState
);
9295 if (!FRAME_VISIBLE_P (f
))
9297 /* If the frame was withdrawn, before, we must map it. */
9298 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9301 f
->async_iconified
= 1;
9302 f
->async_visible
= 0;
9304 XFlush (FRAME_X_DISPLAY (f
));
9306 #endif /* not USE_X_TOOLKIT */
9310 /* Free X resources of frame F. */
9313 x_free_frame_resources (struct frame
*f
)
9315 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9317 struct scroll_bar
*b
;
9321 /* If a display connection is dead, don't try sending more
9322 commands to the X server. */
9323 if (dpyinfo
->display
)
9325 /* We must free faces before destroying windows because some
9326 font-driver (e.g. xft) access a window while finishing a
9328 if (FRAME_FACE_CACHE (f
))
9329 free_frame_faces (f
);
9331 if (f
->output_data
.x
->icon_desc
)
9332 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
9334 #ifdef USE_X_TOOLKIT
9335 /* Explicitly destroy the scroll bars of the frame. Without
9336 this, we get "BadDrawable" errors from the toolkit later on,
9337 presumably from expose events generated for the disappearing
9338 toolkit scroll bars. */
9339 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
9341 b
= XSCROLL_BAR (bar
);
9342 x_scroll_bar_remove (b
);
9351 #ifdef USE_X_TOOLKIT
9352 if (f
->output_data
.x
->widget
)
9354 XtDestroyWidget (f
->output_data
.x
->widget
);
9355 f
->output_data
.x
->widget
= NULL
;
9357 /* Tooltips don't have widgets, only a simple X window, even if
9358 we are using a toolkit. */
9359 else if (FRAME_X_WINDOW (f
))
9360 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9362 free_frame_menubar (f
);
9363 #else /* !USE_X_TOOLKIT */
9366 /* In the GTK version, tooltips are normal X
9367 frames. We must check and free both types. */
9368 if (FRAME_GTK_OUTER_WIDGET (f
))
9370 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
9371 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow below */
9372 FRAME_GTK_OUTER_WIDGET (f
) = 0;
9374 #endif /* USE_GTK */
9376 if (FRAME_X_WINDOW (f
))
9377 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9378 #endif /* !USE_X_TOOLKIT */
9380 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
9381 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
9382 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
9383 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
9384 unload_color (f
, f
->output_data
.x
->border_pixel
);
9385 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
9387 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
9388 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
9389 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
9390 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
9391 #ifdef USE_TOOLKIT_SCROLL_BARS
9392 /* Scrollbar shadow colors. */
9393 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
9394 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
9395 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
9396 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
9397 #endif /* USE_TOOLKIT_SCROLL_BARS */
9398 if (f
->output_data
.x
->white_relief
.allocated_p
)
9399 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
9400 if (f
->output_data
.x
->black_relief
.allocated_p
)
9401 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
9404 XFlush (FRAME_X_DISPLAY (f
));
9407 xfree (f
->output_data
.x
->saved_menu_event
);
9408 xfree (f
->output_data
.x
);
9409 f
->output_data
.x
= NULL
;
9411 if (f
== dpyinfo
->x_focus_frame
)
9412 dpyinfo
->x_focus_frame
= 0;
9413 if (f
== dpyinfo
->x_focus_event_frame
)
9414 dpyinfo
->x_focus_event_frame
= 0;
9415 if (f
== dpyinfo
->x_highlight_frame
)
9416 dpyinfo
->x_highlight_frame
= 0;
9418 if (f
== dpyinfo
->mouse_face_mouse_frame
)
9420 dpyinfo
->mouse_face_beg_row
9421 = dpyinfo
->mouse_face_beg_col
= -1;
9422 dpyinfo
->mouse_face_end_row
9423 = dpyinfo
->mouse_face_end_col
= -1;
9424 dpyinfo
->mouse_face_window
= Qnil
;
9425 dpyinfo
->mouse_face_deferred_gc
= 0;
9426 dpyinfo
->mouse_face_mouse_frame
= 0;
9433 /* Destroy the X window of frame F. */
9436 x_destroy_window (struct frame
*f
)
9438 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9440 /* If a display connection is dead, don't try sending more
9441 commands to the X server. */
9442 if (dpyinfo
->display
!= 0)
9443 x_free_frame_resources (f
);
9445 dpyinfo
->reference_count
--;
9449 /* Setting window manager hints. */
9451 /* Set the normal size hints for the window manager, for frame F.
9452 FLAGS is the flags word to use--or 0 meaning preserve the flags
9453 that the window now has.
9454 If USER_POSITION is nonzero, we set the USPosition
9455 flag (this is useful when FLAGS is 0).
9456 The GTK version is in gtkutils.c */
9460 x_wm_set_size_hint (f
, flags
, user_position
)
9465 XSizeHints size_hints
;
9466 Window window
= FRAME_OUTER_WINDOW (f
);
9468 /* Setting PMaxSize caused various problems. */
9469 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
9471 size_hints
.x
= f
->left_pos
;
9472 size_hints
.y
= f
->top_pos
;
9474 size_hints
.height
= FRAME_PIXEL_HEIGHT (f
);
9475 size_hints
.width
= FRAME_PIXEL_WIDTH (f
);
9477 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
9478 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
9479 size_hints
.max_width
= x_display_pixel_width (FRAME_X_DISPLAY_INFO (f
))
9480 - FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9481 size_hints
.max_height
= x_display_pixel_height (FRAME_X_DISPLAY_INFO (f
))
9482 - FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9484 /* Calculate the base and minimum sizes. */
9486 int base_width
, base_height
;
9487 int min_rows
= 0, min_cols
= 0;
9489 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9490 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9492 check_frame_size (f
, &min_rows
, &min_cols
);
9494 /* The window manager uses the base width hints to calculate the
9495 current number of rows and columns in the frame while
9496 resizing; min_width and min_height aren't useful for this
9497 purpose, since they might not give the dimensions for a
9498 zero-row, zero-column frame.
9500 We use the base_width and base_height members if we have
9501 them; otherwise, we set the min_width and min_height members
9502 to the size for a zero x zero frame. */
9504 size_hints
.flags
|= PBaseSize
;
9505 size_hints
.base_width
= base_width
;
9506 size_hints
.base_height
= base_height
+ FRAME_MENUBAR_HEIGHT (f
);
9507 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
9508 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
9511 /* If we don't need the old flags, we don't need the old hint at all. */
9514 size_hints
.flags
|= flags
;
9519 XSizeHints hints
; /* Sometimes I hate X Windows... */
9520 long supplied_return
;
9523 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
9527 size_hints
.flags
|= flags
;
9532 if (hints
.flags
& PSize
)
9533 size_hints
.flags
|= PSize
;
9534 if (hints
.flags
& PPosition
)
9535 size_hints
.flags
|= PPosition
;
9536 if (hints
.flags
& USPosition
)
9537 size_hints
.flags
|= USPosition
;
9538 if (hints
.flags
& USSize
)
9539 size_hints
.flags
|= USSize
;
9546 size_hints
.win_gravity
= f
->win_gravity
;
9547 size_hints
.flags
|= PWinGravity
;
9551 size_hints
.flags
&= ~ PPosition
;
9552 size_hints
.flags
|= USPosition
;
9554 #endif /* PWinGravity */
9556 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
9558 #endif /* not USE_GTK */
9560 /* Used for IconicState or NormalState */
9563 x_wm_set_window_state (struct frame
*f
, int state
)
9565 #ifdef USE_X_TOOLKIT
9568 XtSetArg (al
[0], XtNinitialState
, state
);
9569 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9570 #else /* not USE_X_TOOLKIT */
9571 Window window
= FRAME_X_WINDOW (f
);
9573 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
9574 f
->output_data
.x
->wm_hints
.initial_state
= state
;
9576 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9577 #endif /* not USE_X_TOOLKIT */
9581 x_wm_set_icon_pixmap (struct frame
*f
, int pixmap_id
)
9583 Pixmap icon_pixmap
, icon_mask
;
9585 #if !defined USE_X_TOOLKIT && !defined USE_GTK
9586 Window window
= FRAME_OUTER_WINDOW (f
);
9591 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
9592 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
9593 icon_mask
= x_bitmap_mask (f
, pixmap_id
);
9594 f
->output_data
.x
->wm_hints
.icon_mask
= icon_mask
;
9598 /* It seems there is no way to turn off use of an icon
9606 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
);
9610 #elif defined (USE_X_TOOLKIT) /* same as in x_wm_set_window_state. */
9614 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
9615 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9616 XtSetArg (al
[0], XtNiconMask
, icon_mask
);
9617 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9620 #else /* not USE_X_TOOLKIT && not USE_GTK */
9622 f
->output_data
.x
->wm_hints
.flags
|= (IconPixmapHint
| IconMaskHint
);
9623 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9625 #endif /* not USE_X_TOOLKIT && not USE_GTK */
9629 x_wm_set_icon_position (struct frame
*f
, int icon_x
, int icon_y
)
9631 Window window
= FRAME_OUTER_WINDOW (f
);
9633 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
9634 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
9635 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
9637 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9641 /***********************************************************************
9643 ***********************************************************************/
9647 /* Check that FONT is valid on frame F. It is if it can be found in F's
9651 x_check_font (f
, font
)
9657 xassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
9658 if (font
->driver
->check
)
9659 xassert (font
->driver
->check (f
, font
) == 0);
9662 #endif /* GLYPH_DEBUG != 0 */
9665 /***********************************************************************
9667 ***********************************************************************/
9669 #ifdef USE_X_TOOLKIT
9670 static XrmOptionDescRec emacs_options
[] = {
9671 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
9672 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
9674 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
9675 XrmoptionSepArg
, NULL
},
9676 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
9678 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9679 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9680 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9681 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
9682 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
9683 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
9684 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
9687 /* Whether atimer for Xt timeouts is activated or not. */
9689 static int x_timeout_atimer_activated_flag
;
9691 #endif /* USE_X_TOOLKIT */
9693 static int x_initialized
;
9696 static int x_session_initialized
;
9699 /* Test whether two display-name strings agree up to the dot that separates
9700 the screen number from the server number. */
9702 same_x_server (const char *name1
, const char *name2
)
9705 const unsigned char *system_name
= SDATA (Vsystem_name
);
9706 int system_name_length
= strlen (system_name
);
9707 int length_until_period
= 0;
9709 while (system_name
[length_until_period
] != 0
9710 && system_name
[length_until_period
] != '.')
9711 length_until_period
++;
9713 /* Treat `unix' like an empty host name. */
9714 if (! strncmp (name1
, "unix:", 5))
9716 if (! strncmp (name2
, "unix:", 5))
9718 /* Treat this host's name like an empty host name. */
9719 if (! strncmp (name1
, system_name
, system_name_length
)
9720 && name1
[system_name_length
] == ':')
9721 name1
+= system_name_length
;
9722 if (! strncmp (name2
, system_name
, system_name_length
)
9723 && name2
[system_name_length
] == ':')
9724 name2
+= system_name_length
;
9725 /* Treat this host's domainless name like an empty host name. */
9726 if (! strncmp (name1
, system_name
, length_until_period
)
9727 && name1
[length_until_period
] == ':')
9728 name1
+= length_until_period
;
9729 if (! strncmp (name2
, system_name
, length_until_period
)
9730 && name2
[length_until_period
] == ':')
9731 name2
+= length_until_period
;
9733 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
9737 if (seen_colon
&& *name1
== '.')
9741 && (*name1
== '.' || *name1
== '\0')
9742 && (*name2
== '.' || *name2
== '\0'));
9745 /* Count number of set bits in mask and number of bits to shift to
9746 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
9749 get_bits_and_offset (long unsigned int mask
, int *bits
, int *offset
)
9770 /* Return 1 if display DISPLAY is available for use, 0 otherwise.
9771 But don't permanently open it, just test its availability. */
9774 x_display_ok (const char *display
)
9779 dpy
= XOpenDisplay (display
);
9781 XCloseDisplay (dpy
);
9789 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
, const gchar
*message
, gpointer user_data
)
9791 if (!strstr (message
, "g_set_prgname"))
9792 fprintf (stderr
, "%s-WARNING **: %s\n", log_domain
, message
);
9796 /* Open a connection to X display DISPLAY_NAME, and return
9797 the structure that describes the open display.
9798 If we cannot contact the display, return null. */
9800 struct x_display_info
*
9801 x_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
9805 struct terminal
*terminal
;
9806 struct x_display_info
*dpyinfo
;
9817 if (! x_display_ok (SDATA (display_name
)))
9818 error ("Display %s can't be opened", SDATA (display_name
));
9824 char *argv
[NUM_ARGV
];
9825 char **argv2
= argv
;
9828 if (x_initialized
++ > 1)
9830 xg_display_open (SDATA (display_name
), &dpy
);
9834 for (argc
= 0; argc
< NUM_ARGV
; ++argc
)
9838 argv
[argc
++] = initial_argv
[0];
9840 if (! NILP (display_name
))
9842 argv
[argc
++] = "--display";
9843 argv
[argc
++] = SDATA (display_name
);
9846 argv
[argc
++] = "--name";
9847 argv
[argc
++] = resource_name
;
9849 XSetLocaleModifiers ("");
9851 /* Work around GLib bug that outputs a faulty warning. See
9852 https://bugzilla.gnome.org/show_bug.cgi?id=563627. */
9853 id
= g_log_set_handler ("GLib", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
9854 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
9855 gtk_init (&argc
, &argv2
);
9856 g_log_remove_handler ("GLib", id
);
9858 /* gtk_init does set_locale. We must fix locale after calling it. */
9862 dpy
= GDK_DISPLAY ();
9864 /* NULL window -> events for all windows go to our function */
9865 gdk_window_add_filter (NULL
, event_handler_gdk
, NULL
);
9867 /* Load our own gtkrc if it exists. */
9869 char *file
= "~/.emacs.d/gtkrc";
9870 Lisp_Object s
, abs_file
;
9872 s
= make_string (file
, strlen (file
));
9873 abs_file
= Fexpand_file_name (s
, Qnil
);
9875 if (! NILP (abs_file
) && !NILP (Ffile_readable_p (abs_file
)))
9876 gtk_rc_parse (SDATA (abs_file
));
9879 XSetErrorHandler (x_error_handler
);
9880 XSetIOErrorHandler (x_io_error_quitter
);
9883 #else /* not USE_GTK */
9884 #ifdef USE_X_TOOLKIT
9885 /* weiner@footloose.sps.mot.com reports that this causes
9887 X protocol error: BadAtom (invalid Atom parameter)
9888 on protocol request 18skiloaf.
9889 So let's not use it until R6. */
9891 XtSetLanguageProc (NULL
, NULL
, NULL
);
9902 argv
[argc
++] = "-xrm";
9903 argv
[argc
++] = xrm_option
;
9905 turn_on_atimers (0);
9906 dpy
= XtOpenDisplay (Xt_app_con
, SDATA (display_name
),
9907 resource_name
, EMACS_CLASS
,
9908 emacs_options
, XtNumber (emacs_options
),
9910 turn_on_atimers (1);
9913 /* I think this is to compensate for XtSetLanguageProc. */
9918 #else /* not USE_X_TOOLKIT */
9919 XSetLocaleModifiers ("");
9920 dpy
= XOpenDisplay (SDATA (display_name
));
9921 #endif /* not USE_X_TOOLKIT */
9922 #endif /* not USE_GTK*/
9924 /* Detect failure. */
9931 /* We have definitely succeeded. Record the new connection. */
9933 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
9934 bzero (dpyinfo
, sizeof *dpyinfo
);
9936 terminal
= x_create_terminal (dpyinfo
);
9939 struct x_display_info
*share
;
9942 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
9943 share
= share
->next
, tail
= XCDR (tail
))
9944 if (same_x_server (SDATA (XCAR (XCAR (tail
))),
9945 SDATA (display_name
)))
9948 terminal
->kboard
= share
->terminal
->kboard
;
9951 terminal
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
9952 init_kboard (terminal
->kboard
);
9953 terminal
->kboard
->Vwindow_system
= Qx
;
9955 /* Add the keyboard to the list before running Lisp code (via
9956 Qvendor_specific_keysyms below), since these are not traced
9957 via terminals but only through all_kboards. */
9958 terminal
->kboard
->next_kboard
= all_kboards
;
9959 all_kboards
= terminal
->kboard
;
9961 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
9963 char *vendor
= ServerVendor (dpy
);
9965 /* Protect terminal from GC before removing it from the
9966 list of terminals. */
9967 struct gcpro gcpro1
;
9968 Lisp_Object gcpro_term
;
9969 XSETTERMINAL (gcpro_term
, terminal
);
9970 GCPRO1 (gcpro_term
);
9972 /* Temporarily hide the partially initialized terminal. */
9973 terminal_list
= terminal
->next_terminal
;
9975 terminal
->kboard
->Vsystem_key_alist
9976 = call1 (Qvendor_specific_keysyms
,
9977 vendor
? build_string (vendor
) : empty_unibyte_string
);
9979 terminal
->next_terminal
= terminal_list
;
9980 terminal_list
= terminal
;
9984 /* Don't let the initial kboard remain current longer than necessary.
9985 That would cause problems if a file loaded on startup tries to
9986 prompt in the mini-buffer. */
9987 if (current_kboard
== initial_kboard
)
9988 current_kboard
= terminal
->kboard
;
9990 terminal
->kboard
->reference_count
++;
9993 /* Put this display on the chain. */
9994 dpyinfo
->next
= x_display_list
;
9995 x_display_list
= dpyinfo
;
9997 /* Put it on x_display_name_list as well, to keep them parallel. */
9998 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
9999 x_display_name_list
);
10000 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
10002 dpyinfo
->display
= dpy
;
10004 /* Set the name of the terminal. */
10005 terminal
->name
= (char *) xmalloc (SBYTES (display_name
) + 1);
10006 strncpy (terminal
->name
, SDATA (display_name
), SBYTES (display_name
));
10007 terminal
->name
[SBYTES (display_name
)] = 0;
10010 XSetAfterFunction (x_current_display
, x_trace_wire
);
10014 = (char *) xmalloc (SBYTES (Vinvocation_name
)
10015 + SBYTES (Vsystem_name
)
10017 sprintf (dpyinfo
->x_id_name
, "%s@%s",
10018 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
10020 /* Figure out which modifier bits mean what. */
10021 x_find_modifier_meanings (dpyinfo
);
10023 /* Get the scroll bar cursor. */
10025 /* We must create a GTK cursor, it is required for GTK widgets. */
10026 dpyinfo
->xg_cursor
= xg_create_default_cursor (dpyinfo
->display
);
10027 #endif /* USE_GTK */
10029 dpyinfo
->vertical_scroll_bar_cursor
10030 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
10032 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
10033 resource_name
, EMACS_CLASS
);
10034 #ifdef HAVE_XRMSETDATABASE
10035 XrmSetDatabase (dpyinfo
->display
, xrdb
);
10037 dpyinfo
->display
->db
= xrdb
;
10039 /* Put the rdb where we can find it in a way that works on
10041 dpyinfo
->xrdb
= xrdb
;
10043 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
10044 DefaultScreen (dpyinfo
->display
));
10045 select_visual (dpyinfo
);
10046 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
10047 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
10048 dpyinfo
->client_leader_window
= 0;
10049 dpyinfo
->grabbed
= 0;
10050 dpyinfo
->reference_count
= 0;
10051 dpyinfo
->icon_bitmap_id
= -1;
10052 dpyinfo
->n_fonts
= 0;
10053 dpyinfo
->bitmaps
= 0;
10054 dpyinfo
->bitmaps_size
= 0;
10055 dpyinfo
->bitmaps_last
= 0;
10056 dpyinfo
->scratch_cursor_gc
= 0;
10057 dpyinfo
->mouse_face_mouse_frame
= 0;
10058 dpyinfo
->mouse_face_deferred_gc
= 0;
10059 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
10060 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
10061 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
10062 dpyinfo
->mouse_face_window
= Qnil
;
10063 dpyinfo
->mouse_face_overlay
= Qnil
;
10064 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
10065 dpyinfo
->mouse_face_defer
= 0;
10066 dpyinfo
->mouse_face_hidden
= 0;
10067 dpyinfo
->x_focus_frame
= 0;
10068 dpyinfo
->x_focus_event_frame
= 0;
10069 dpyinfo
->x_highlight_frame
= 0;
10070 dpyinfo
->wm_type
= X_WMTYPE_UNKNOWN
;
10072 /* See if we can construct pixel values from RGB values. */
10073 dpyinfo
->red_bits
= dpyinfo
->blue_bits
= dpyinfo
->green_bits
= 0;
10074 dpyinfo
->red_offset
= dpyinfo
->blue_offset
= dpyinfo
->green_offset
= 0;
10076 if (dpyinfo
->visual
->class == TrueColor
)
10078 get_bits_and_offset (dpyinfo
->visual
->red_mask
,
10079 &dpyinfo
->red_bits
, &dpyinfo
->red_offset
);
10080 get_bits_and_offset (dpyinfo
->visual
->blue_mask
,
10081 &dpyinfo
->blue_bits
, &dpyinfo
->blue_offset
);
10082 get_bits_and_offset (dpyinfo
->visual
->green_mask
,
10083 &dpyinfo
->green_bits
, &dpyinfo
->green_offset
);
10086 /* See if a private colormap is requested. */
10087 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
10089 if (dpyinfo
->visual
->class == PseudoColor
)
10092 value
= display_x_get_resource (dpyinfo
,
10093 build_string ("privateColormap"),
10094 build_string ("PrivateColormap"),
10096 if (STRINGP (value
)
10097 && (!strcmp (SDATA (value
), "true")
10098 || !strcmp (SDATA (value
), "on")))
10099 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
10103 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
10104 dpyinfo
->visual
, AllocNone
);
10108 /* If we are using Xft, check dpi value in X resources.
10109 It is better we use it as well, since Xft will use it, as will all
10110 Gnome applications. If our real DPI is smaller or larger than the
10111 one Xft uses, our font will look smaller or larger than other
10112 for other applications, even if it is the same font name (monospace-10
10114 char *v
= XGetDefault (dpyinfo
->display
, "Xft", "dpi");
10116 if (v
!= NULL
&& sscanf (v
, "%lf", &d
) == 1)
10117 dpyinfo
->resy
= dpyinfo
->resx
= d
;
10121 if (dpyinfo
->resy
< 1)
10123 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
10124 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
10125 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
10126 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10127 dpyinfo
->resy
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10128 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
10129 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
10130 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10131 dpyinfo
->resx
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10134 dpyinfo
->Xatom_wm_protocols
10135 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
10136 dpyinfo
->Xatom_wm_take_focus
10137 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
10138 dpyinfo
->Xatom_wm_save_yourself
10139 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
10140 dpyinfo
->Xatom_wm_delete_window
10141 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
10142 dpyinfo
->Xatom_wm_change_state
10143 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
10144 dpyinfo
->Xatom_wm_configure_denied
10145 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
10146 dpyinfo
->Xatom_wm_window_moved
10147 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
10148 dpyinfo
->Xatom_wm_client_leader
10149 = XInternAtom (dpyinfo
->display
, "WM_CLIENT_LEADER", False
);
10150 dpyinfo
->Xatom_editres
10151 = XInternAtom (dpyinfo
->display
, "Editres", False
);
10152 dpyinfo
->Xatom_CLIPBOARD
10153 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
10154 dpyinfo
->Xatom_TIMESTAMP
10155 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
10156 dpyinfo
->Xatom_TEXT
10157 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
10158 dpyinfo
->Xatom_COMPOUND_TEXT
10159 = XInternAtom (dpyinfo
->display
, "COMPOUND_TEXT", False
);
10160 dpyinfo
->Xatom_UTF8_STRING
10161 = XInternAtom (dpyinfo
->display
, "UTF8_STRING", False
);
10162 dpyinfo
->Xatom_DELETE
10163 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
10164 dpyinfo
->Xatom_MULTIPLE
10165 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
10166 dpyinfo
->Xatom_INCR
10167 = XInternAtom (dpyinfo
->display
, "INCR", False
);
10168 dpyinfo
->Xatom_EMACS_TMP
10169 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
10170 dpyinfo
->Xatom_TARGETS
10171 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
10172 dpyinfo
->Xatom_NULL
10173 = XInternAtom (dpyinfo
->display
, "NULL", False
);
10174 dpyinfo
->Xatom_ATOM_PAIR
10175 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
10176 /* For properties of font. */
10177 dpyinfo
->Xatom_PIXEL_SIZE
10178 = XInternAtom (dpyinfo
->display
, "PIXEL_SIZE", False
);
10179 dpyinfo
->Xatom_AVERAGE_WIDTH
10180 = XInternAtom (dpyinfo
->display
, "AVERAGE_WIDTH", False
);
10181 dpyinfo
->Xatom_MULE_BASELINE_OFFSET
10182 = XInternAtom (dpyinfo
->display
, "_MULE_BASELINE_OFFSET", False
);
10183 dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
10184 = XInternAtom (dpyinfo
->display
, "_MULE_RELATIVE_COMPOSE", False
);
10185 dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
10186 = XInternAtom (dpyinfo
->display
, "_MULE_DEFAULT_ASCENT", False
);
10188 /* Ghostscript support. */
10189 dpyinfo
->Xatom_PAGE
= XInternAtom (dpyinfo
->display
, "PAGE", False
);
10190 dpyinfo
->Xatom_DONE
= XInternAtom (dpyinfo
->display
, "DONE", False
);
10192 dpyinfo
->Xatom_Scrollbar
= XInternAtom (dpyinfo
->display
, "SCROLLBAR",
10195 dpyinfo
->Xatom_XEMBED
= XInternAtom (dpyinfo
->display
, "_XEMBED",
10198 dpyinfo
->Xatom_net_wm_state
10199 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE", False
);
10200 dpyinfo
->Xatom_net_wm_state_fullscreen_atom
10201 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE_FULLSCREEN", False
);
10202 dpyinfo
->Xatom_net_wm_state_maximized_horz
10203 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE_MAXIMIZED_HORZ", False
);
10204 dpyinfo
->Xatom_net_wm_state_maximized_vert
10205 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE_MAXIMIZED_VERT", False
);
10206 dpyinfo
->Xatom_net_wm_state_sticky
10207 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE_STICKY", False
);
10208 dpyinfo
->Xatom_net_window_type
10209 = XInternAtom (dpyinfo
->display
, "_NET_WM_WINDOW_TYPE", False
);
10210 dpyinfo
->Xatom_net_window_type_tooltip
10211 = XInternAtom (dpyinfo
->display
, "_NET_WM_WINDOW_TYPE_TOOLTIP", False
);
10213 dpyinfo
->cut_buffers_initialized
= 0;
10215 dpyinfo
->x_dnd_atoms_size
= 8;
10216 dpyinfo
->x_dnd_atoms_length
= 0;
10217 dpyinfo
->x_dnd_atoms
= xmalloc (sizeof (*dpyinfo
->x_dnd_atoms
)
10218 * dpyinfo
->x_dnd_atoms_size
);
10220 dpyinfo
->net_supported_atoms
= NULL
;
10221 dpyinfo
->nr_net_supported_atoms
= 0;
10222 dpyinfo
->net_supported_window
= 0;
10224 connection
= ConnectionNumber (dpyinfo
->display
);
10225 dpyinfo
->connection
= connection
;
10228 extern int gray_bitmap_width
, gray_bitmap_height
;
10229 extern char *gray_bitmap_bits
;
10231 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
10233 gray_bitmap_width
, gray_bitmap_height
,
10234 (unsigned long) 1, (unsigned long) 0, 1);
10238 xim_initialize (dpyinfo
, resource_name
);
10241 xsettings_initialize (dpyinfo
);
10243 #ifdef subprocesses
10244 /* This is only needed for distinguishing keyboard and process input. */
10245 if (connection
!= 0)
10246 add_keyboard_wait_descriptor (connection
);
10250 fcntl (connection
, F_SETOWN
, getpid ());
10251 #endif /* ! defined (F_SETOWN) */
10254 if (interrupt_input
)
10255 init_sigio (connection
);
10256 #endif /* ! defined (SIGIO) */
10260 Display
*dpy
= dpyinfo
->display
;
10261 XrmValue d
, fr
, to
;
10264 d
.addr
= (XPointer
)&dpy
;
10265 d
.size
= sizeof (Display
*);
10266 fr
.addr
= XtDefaultFont
;
10267 fr
.size
= sizeof (XtDefaultFont
);
10268 to
.size
= sizeof (Font
*);
10269 to
.addr
= (XPointer
)&font
;
10270 x_catch_errors (dpy
);
10271 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
10273 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
10274 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
10275 x_uncatch_errors ();
10279 /* See if we should run in synchronous mode. This is useful
10280 for debugging X code. */
10283 value
= display_x_get_resource (dpyinfo
,
10284 build_string ("synchronous"),
10285 build_string ("Synchronous"),
10287 if (STRINGP (value
)
10288 && (!strcmp (SDATA (value
), "true")
10289 || !strcmp (SDATA (value
), "on")))
10290 XSynchronize (dpyinfo
->display
, True
);
10295 value
= display_x_get_resource (dpyinfo
,
10296 build_string ("useXIM"),
10297 build_string ("UseXIM"),
10300 if (STRINGP (value
)
10301 && (!strcmp (SDATA (value
), "false")
10302 || !strcmp (SDATA (value
), "off")))
10305 if (STRINGP (value
)
10306 && (!strcmp (SDATA (value
), "true")
10307 || !strcmp (SDATA (value
), "on")))
10313 /* Only do this for the very first display in the Emacs session.
10314 Ignore X session management when Emacs was first started on a
10316 if (terminal
->id
== 1)
10317 x_session_initialize (dpyinfo
);
10325 /* Get rid of display DPYINFO, deleting all frames on it,
10326 and without sending any more commands to the X server. */
10329 x_delete_display (struct x_display_info
*dpyinfo
)
10331 struct terminal
*t
;
10333 /* Close all frames and delete the generic struct terminal for this
10335 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
10336 if (t
->type
== output_x_window
&& t
->display_info
.x
== dpyinfo
)
10339 /* Close X session management when we close its display. */
10340 if (t
->id
== 1 && x_session_have_connection ())
10343 delete_terminal (t
);
10347 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
10349 /* Discard this display from x_display_name_list and x_display_list.
10350 We can't use Fdelq because that can quit. */
10351 if (! NILP (x_display_name_list
)
10352 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
10353 x_display_name_list
= XCDR (x_display_name_list
);
10358 tail
= x_display_name_list
;
10359 while (CONSP (tail
) && CONSP (XCDR (tail
)))
10361 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
10363 XSETCDR (tail
, XCDR (XCDR (tail
)));
10366 tail
= XCDR (tail
);
10370 if (next_noop_dpyinfo
== dpyinfo
)
10371 next_noop_dpyinfo
= dpyinfo
->next
;
10373 if (x_display_list
== dpyinfo
)
10374 x_display_list
= dpyinfo
->next
;
10377 struct x_display_info
*tail
;
10379 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
10380 if (tail
->next
== dpyinfo
)
10381 tail
->next
= tail
->next
->next
;
10384 xfree (dpyinfo
->x_id_name
);
10385 xfree (dpyinfo
->x_dnd_atoms
);
10386 xfree (dpyinfo
->color_cells
);
10390 #ifdef USE_X_TOOLKIT
10392 /* Atimer callback function for TIMER. Called every 0.1s to process
10393 Xt timeouts, if needed. We must avoid calling XtAppPending as
10394 much as possible because that function does an implicit XFlush
10395 that slows us down. */
10398 x_process_timeouts (timer
)
10399 struct atimer
*timer
;
10402 x_timeout_atimer_activated_flag
= 0;
10403 if (toolkit_scroll_bar_interaction
|| popup_activated ())
10405 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
10406 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
10407 /* Reactivate the atimer for next time. */
10408 x_activate_timeout_atimer ();
10413 /* Install an asynchronous timer that processes Xt timeout events
10414 every 0.1s as long as either `toolkit_scroll_bar_interaction' or
10415 `popup_activated_flag' (in xmenu.c) is set. Make sure to call this
10416 function whenever these variables are set. This is necessary
10417 because some widget sets use timeouts internally, for example the
10418 LessTif menu bar, or the Xaw3d scroll bar. When Xt timeouts aren't
10419 processed, these widgets don't behave normally. */
10422 x_activate_timeout_atimer ()
10425 if (!x_timeout_atimer_activated_flag
)
10427 EMACS_TIME interval
;
10429 EMACS_SET_SECS_USECS (interval
, 0, 100000);
10430 start_atimer (ATIMER_RELATIVE
, interval
, x_process_timeouts
, 0);
10431 x_timeout_atimer_activated_flag
= 1;
10436 #endif /* USE_X_TOOLKIT */
10439 /* Set up use of X before we make the first connection. */
10441 extern frame_parm_handler x_frame_parm_handlers
[];
10443 static struct redisplay_interface x_redisplay_interface
=
10445 x_frame_parm_handlers
,
10449 x_clear_end_of_line
,
10451 x_after_update_window_line
,
10452 x_update_window_begin
,
10453 x_update_window_end
,
10459 0, /* flush_display_optional */
10461 x_clear_window_mouse_face
,
10462 x_get_glyph_overhangs
,
10463 x_fix_overlapping_area
,
10464 x_draw_fringe_bitmap
,
10465 0, /* define_fringe_bitmap */
10466 0, /* destroy_fringe_bitmap */
10467 x_compute_glyph_string_overhangs
,
10468 x_draw_glyph_string
,
10469 x_define_frame_cursor
,
10470 x_clear_frame_area
,
10471 x_draw_window_cursor
,
10472 x_draw_vertical_window_border
,
10473 x_shift_glyphs_for_insert
10477 /* This function is called when the last frame on a display is deleted. */
10479 x_delete_terminal (struct terminal
*terminal
)
10481 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
10483 /* Protect against recursive calls. delete_frame in
10484 delete_terminal calls us back when it deletes our last frame. */
10485 if (!terminal
->name
)
10490 /* We must close our connection to the XIM server before closing the
10493 xim_close_dpy (dpyinfo
);
10496 /* If called from x_connection_closed, the display may already be closed
10497 and dpyinfo->display was set to 0 to indicate that. */
10498 if (dpyinfo
->display
)
10500 x_destroy_all_bitmaps (dpyinfo
);
10501 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
10503 /* Whether or not XCloseDisplay destroys the associated resource
10504 database depends on the version of libX11. To avoid both
10505 crash and memory leak, we dissociate the database from the
10506 display and then destroy dpyinfo->xrdb ourselves.
10508 Unfortunately, the above strategy does not work in some
10509 situations due to a bug in newer versions of libX11: because
10510 XrmSetDatabase doesn't clear the flag XlibDisplayDfltRMDB if
10511 dpy->db is NULL, XCloseDisplay destroys the associated
10512 database whereas it has not been created by XGetDefault
10513 (Bug#21974 in freedesktop.org Bugzilla). As a workaround, we
10514 don't destroy the database here in order to avoid the crash
10515 in the above situations for now, though that may cause memory
10516 leaks in other situations. */
10518 #ifdef HAVE_XRMSETDATABASE
10519 XrmSetDatabase (dpyinfo
->display
, NULL
);
10521 dpyinfo
->display
->db
= NULL
;
10523 /* We used to call XrmDestroyDatabase from x_delete_display, but
10524 some older versions of libX11 crash if we call it after
10525 closing all the displays. */
10526 XrmDestroyDatabase (dpyinfo
->xrdb
);
10530 xg_display_close (dpyinfo
->display
);
10532 #ifdef USE_X_TOOLKIT
10533 XtCloseDisplay (dpyinfo
->display
);
10535 XCloseDisplay (dpyinfo
->display
);
10537 #endif /* ! USE_GTK */
10540 /* Mark as dead. */
10541 dpyinfo
->display
= NULL
;
10542 x_delete_display (dpyinfo
);
10546 /* Create a struct terminal, initialize it with the X11 specific
10547 functions and make DISPLAY->TERMINAL point to it. */
10549 static struct terminal
*
10550 x_create_terminal (struct x_display_info
*dpyinfo
)
10552 struct terminal
*terminal
;
10554 terminal
= create_terminal ();
10556 terminal
->type
= output_x_window
;
10557 terminal
->display_info
.x
= dpyinfo
;
10558 dpyinfo
->terminal
= terminal
;
10560 /* kboard is initialized in x_term_init. */
10562 terminal
->clear_frame_hook
= x_clear_frame
;
10563 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
10564 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
10565 terminal
->ring_bell_hook
= XTring_bell
;
10566 terminal
->toggle_invisible_pointer_hook
= XTtoggle_invisible_pointer
;
10567 terminal
->reset_terminal_modes_hook
= XTreset_terminal_modes
;
10568 terminal
->set_terminal_modes_hook
= XTset_terminal_modes
;
10569 terminal
->update_begin_hook
= x_update_begin
;
10570 terminal
->update_end_hook
= x_update_end
;
10571 terminal
->set_terminal_window_hook
= XTset_terminal_window
;
10572 terminal
->read_socket_hook
= XTread_socket
;
10573 terminal
->frame_up_to_date_hook
= XTframe_up_to_date
;
10574 terminal
->mouse_position_hook
= XTmouse_position
;
10575 terminal
->frame_rehighlight_hook
= XTframe_rehighlight
;
10576 terminal
->frame_raise_lower_hook
= XTframe_raise_lower
;
10577 terminal
->fullscreen_hook
= XTfullscreen_hook
;
10578 terminal
->set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
10579 terminal
->condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
10580 terminal
->redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
10581 terminal
->judge_scroll_bars_hook
= XTjudge_scroll_bars
;
10583 terminal
->delete_frame_hook
= x_destroy_window
;
10584 terminal
->delete_terminal_hook
= x_delete_terminal
;
10586 terminal
->rif
= &x_redisplay_interface
;
10587 terminal
->scroll_region_ok
= 1; /* We'll scroll partial frames. */
10588 terminal
->char_ins_del_ok
= 1;
10589 terminal
->line_ins_del_ok
= 1; /* We'll just blt 'em. */
10590 terminal
->fast_clear_end_of_line
= 1; /* X does this well. */
10591 terminal
->memory_below_frame
= 0; /* We don't remember what scrolls
10598 x_initialize (void)
10603 last_tool_bar_item
= -1;
10604 any_help_event_p
= 0;
10605 ignore_next_mouse_click_timeout
= 0;
10607 x_session_initialized
= 0;
10611 current_count
= -1;
10614 /* Try to use interrupt input; if we can't, then start polling. */
10615 Fset_input_interrupt_mode (Qt
);
10617 #ifdef USE_X_TOOLKIT
10618 XtToolkitInitialize ();
10620 Xt_app_con
= XtCreateApplicationContext ();
10622 /* Register a converter from strings to pixels, which uses
10623 Emacs' color allocation infrastructure. */
10624 XtAppSetTypeConverter (Xt_app_con
,
10625 XtRString
, XtRPixel
, cvt_string_to_pixel
,
10626 cvt_string_to_pixel_args
,
10627 XtNumber (cvt_string_to_pixel_args
),
10628 XtCacheByDisplay
, cvt_pixel_dtor
);
10630 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
10633 #ifdef USE_TOOLKIT_SCROLL_BARS
10635 xaw3d_arrow_scroll
= False
;
10636 xaw3d_pick_top
= True
;
10640 pending_autoraise_frame
= 0;
10641 pending_event_wait
.f
= 0;
10642 pending_event_wait
.eventtype
= 0;
10644 /* Note that there is no real way portable across R3/R4 to get the
10645 original error handler. */
10646 XSetErrorHandler (x_error_handler
);
10647 XSetIOErrorHandler (x_io_error_quitter
);
10649 signal (SIGPIPE
, x_connection_signal
);
10651 xgselect_initialize ();
10656 syms_of_xterm (void)
10658 x_error_message
= NULL
;
10660 staticpro (&x_display_name_list
);
10661 x_display_name_list
= Qnil
;
10663 staticpro (&last_mouse_scroll_bar
);
10664 last_mouse_scroll_bar
= Qnil
;
10666 staticpro (&Qvendor_specific_keysyms
);
10667 Qvendor_specific_keysyms
= intern_c_string ("vendor-specific-keysyms");
10669 staticpro (&Qlatin_1
);
10670 Qlatin_1
= intern_c_string ("latin-1");
10672 staticpro (&last_mouse_press_frame
);
10673 last_mouse_press_frame
= Qnil
;
10676 xg_default_icon_file
= make_pure_c_string ("icons/hicolor/scalable/apps/emacs.svg");
10677 staticpro (&xg_default_icon_file
);
10679 Qx_gtk_map_stock
= intern_c_string ("x-gtk-map-stock");
10680 staticpro (&Qx_gtk_map_stock
);
10683 DEFVAR_BOOL ("x-use-underline-position-properties",
10684 &x_use_underline_position_properties
,
10685 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
10686 A value of nil means ignore them. If you encounter fonts with bogus
10687 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
10688 to 4.1, set this to nil. You can also use `underline-minimum-offset'
10689 to override the font's UNDERLINE_POSITION for small font display
10691 x_use_underline_position_properties
= 1;
10693 DEFVAR_BOOL ("x-underline-at-descent-line",
10694 &x_underline_at_descent_line
,
10695 doc
: /* *Non-nil means to draw the underline at the same place as the descent line.
10696 A value of nil means to draw the underline according to the value of the
10697 variable `x-use-underline-position-properties', which is usually at the
10698 baseline level. The default value is nil. */);
10699 x_underline_at_descent_line
= 0;
10701 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
10702 &x_mouse_click_focus_ignore_position
,
10703 doc
: /* Non-nil means that a mouse click to focus a frame does not move point.
10704 This variable is only used when the window manager requires that you
10705 click on a frame to select it (give it focus). In that case, a value
10706 of nil, means that the selected window and cursor position changes to
10707 reflect the mouse click position, while a non-nil value means that the
10708 selected window or cursor position is preserved. */);
10709 x_mouse_click_focus_ignore_position
= 0;
10711 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
10712 doc
: /* What X toolkit scroll bars Emacs uses.
10713 A value of nil means Emacs doesn't use X toolkit scroll bars.
10714 Otherwise, value is a symbol describing the X toolkit. */);
10715 #ifdef USE_TOOLKIT_SCROLL_BARS
10717 Vx_toolkit_scroll_bars
= intern_c_string ("motif");
10718 #elif defined HAVE_XAW3D
10719 Vx_toolkit_scroll_bars
= intern_c_string ("xaw3d");
10721 Vx_toolkit_scroll_bars
= intern_c_string ("gtk");
10723 Vx_toolkit_scroll_bars
= intern_c_string ("xaw");
10726 Vx_toolkit_scroll_bars
= Qnil
;
10729 staticpro (&last_mouse_motion_frame
);
10730 last_mouse_motion_frame
= Qnil
;
10732 Qmodifier_value
= intern_c_string ("modifier-value");
10733 Qalt
= intern_c_string ("alt");
10734 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
10735 Qhyper
= intern_c_string ("hyper");
10736 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
10737 Qmeta
= intern_c_string ("meta");
10738 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
10739 Qsuper
= intern_c_string ("super");
10740 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
10742 DEFVAR_LISP ("x-alt-keysym", &Vx_alt_keysym
,
10743 doc
: /* Which keys Emacs uses for the alt modifier.
10744 This should be one of the symbols `alt', `hyper', `meta', `super'.
10745 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
10746 is nil, which is the same as `alt'. */);
10747 Vx_alt_keysym
= Qnil
;
10749 DEFVAR_LISP ("x-hyper-keysym", &Vx_hyper_keysym
,
10750 doc
: /* Which keys Emacs uses for the hyper modifier.
10751 This should be one of the symbols `alt', `hyper', `meta', `super'.
10752 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
10753 default is nil, which is the same as `hyper'. */);
10754 Vx_hyper_keysym
= Qnil
;
10756 DEFVAR_LISP ("x-meta-keysym", &Vx_meta_keysym
,
10757 doc
: /* Which keys Emacs uses for the meta modifier.
10758 This should be one of the symbols `alt', `hyper', `meta', `super'.
10759 For example, `meta' means use the Meta_L and Meta_R keysyms. The
10760 default is nil, which is the same as `meta'. */);
10761 Vx_meta_keysym
= Qnil
;
10763 DEFVAR_LISP ("x-super-keysym", &Vx_super_keysym
,
10764 doc
: /* Which keys Emacs uses for the super modifier.
10765 This should be one of the symbols `alt', `hyper', `meta', `super'.
10766 For example, `super' means use the Super_L and Super_R keysyms. The
10767 default is nil, which is the same as `super'. */);
10768 Vx_super_keysym
= Qnil
;
10770 DEFVAR_LISP ("x-keysym-table", &Vx_keysym_table
,
10771 doc
: /* Hash table of character codes indexed by X keysym codes. */);
10772 Vx_keysym_table
= make_hash_table (Qeql
, make_number (900),
10773 make_float (DEFAULT_REHASH_SIZE
),
10774 make_float (DEFAULT_REHASH_THRESHOLD
),
10778 #endif /* HAVE_X_WINDOWS */
10780 /* arch-tag: 6d4e4cb7-abc1-4302-9585-d84dcfb09d0f
10781 (do not change this comment) */