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
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. */
35 #include "blockinput.h"
37 /* Need syssignal.h for various externs and definitions that may be required
38 by some configurations for calls to signal later in this source file. */
39 #include "syssignal.h"
41 /* This may include sys/types.h, and that somehow loses
42 if this is not done before the other system files. */
44 #include <X11/cursorfont.h>
46 /* Load sys/types.h if not already loaded.
47 In some systems loading it twice is suicidal. */
49 #include <sys/types.h>
53 #include <sys/ioctl.h>
54 #endif /* ! defined (BSD_SYSTEM) */
58 #ifndef INCLUDED_FCNTL
65 /* Caused redefinition of DBL_DIG on Netbsd; seems not to be needed. */
66 /* #include <sys/param.h> */
69 #include "character.h"
72 #include "dispextern.h"
74 #include "termhooks.h"
77 #include "emacs-icon.h"
82 #include "intervals.h"
90 #include <X11/Shell.h>
93 #ifdef HAVE_SYS_TIME_H
105 extern int xlwmenu_window_p
P_ ((Widget w
, Window window
));
106 extern void xlwmenu_redisplay
P_ ((Widget
));
109 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
111 extern void free_frame_menubar
P_ ((struct frame
*));
112 extern struct frame
*x_menubar_window_to_frame
P_ ((struct x_display_info
*,
117 #if (XtSpecificationRelease >= 5) && !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 */
146 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
147 #define x_any_window_to_frame x_window_to_frame
148 #define x_top_window_to_frame x_window_to_frame
153 #ifndef XtNinitialState
154 #define XtNinitialState "initialState"
158 /* Default to using XIM if available. */
162 int use_xim
= 0; /* configure --without-xim */
167 /* Non-nil means Emacs uses toolkit scroll bars. */
169 Lisp_Object Vx_toolkit_scroll_bars
;
171 /* Non-zero means that a HELP_EVENT has been generated since Emacs
174 static int any_help_event_p
;
176 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
177 static Lisp_Object last_window
;
179 /* Non-zero means make use of UNDERLINE_POSITION font properties. */
181 int x_use_underline_position_properties
;
183 /* Non-zero means to draw the underline at the same place as the descent line. */
185 int x_underline_at_descent_line
;
187 /* This is a chain of structures for all the X displays currently in
190 struct x_display_info
*x_display_list
;
192 /* This is a list of cons cells, each of the form (NAME
193 . FONT-LIST-CACHE), one for each element of x_display_list and in
194 the same order. NAME is the name of the frame. FONT-LIST-CACHE
195 records previous values returned by x-list-fonts. */
197 Lisp_Object x_display_name_list
;
199 /* Frame being updated by update_frame. This is declared in term.c.
200 This is set by update_begin and looked at by all the XT functions.
201 It is zero while not inside an update. In that case, the XT
202 functions assume that `selected_frame' is the frame to apply to. */
204 extern struct frame
*updating_frame
;
206 /* This is a frame waiting to be auto-raised, within XTread_socket. */
208 struct frame
*pending_autoraise_frame
;
211 /* The application context for Xt use. */
212 XtAppContext Xt_app_con
;
213 static String Xt_default_resources
[] = {0};
214 #endif /* USE_X_TOOLKIT */
216 /* Non-zero means user is interacting with a toolkit scroll bar. */
218 static int toolkit_scroll_bar_interaction
;
220 /* Non-zero means to not move point as a result of clicking on a
221 frame to focus it (when focus-follows-mouse is nil). */
223 int x_mouse_click_focus_ignore_position
;
225 /* Non-zero timeout value means ignore next mouse click if it arrives
226 before that timeout elapses (i.e. as part of the same sequence of
227 events resulting from clicking on a frame to select it). */
229 static unsigned long ignore_next_mouse_click_timeout
;
233 Formerly, we used PointerMotionHintMask (in standard_event_mask)
234 so that we would have to call XQueryPointer after each MotionNotify
235 event to ask for another such event. However, this made mouse tracking
236 slow, and there was a bug that made it eventually stop.
238 Simply asking for MotionNotify all the time seems to work better.
240 In order to avoid asking for motion events and then throwing most
241 of them away or busy-polling the server for mouse positions, we ask
242 the server for pointer motion hints. This means that we get only
243 one event per group of mouse movements. "Groups" are delimited by
244 other kinds of events (focus changes and button clicks, for
245 example), or by XQueryPointer calls; when one of these happens, we
246 get another MotionNotify event the next time the mouse moves. This
247 is at least as efficient as getting motion events when mouse
248 tracking is on, and I suspect only negligibly worse when tracking
251 /* Where the mouse was last time we reported a mouse event. */
253 static XRectangle last_mouse_glyph
;
254 static FRAME_PTR last_mouse_glyph_frame
;
255 static Lisp_Object last_mouse_press_frame
;
257 /* The scroll bar in which the last X motion event occurred.
259 If the last X motion event occurred in a scroll bar, we set this so
260 XTmouse_position can know whether to report a scroll bar motion or
263 If the last X motion event didn't occur in a scroll bar, we set
264 this to Qnil, to tell XTmouse_position to return an ordinary motion
267 static Lisp_Object last_mouse_scroll_bar
;
269 /* This is a hack. We would really prefer that XTmouse_position would
270 return the time associated with the position it returns, but there
271 doesn't seem to be any way to wrest the time-stamp from the server
272 along with the position query. So, we just keep track of the time
273 of the last movement we received, and return that in hopes that
274 it's somewhat accurate. */
276 static Time last_mouse_movement_time
;
278 /* Time for last user interaction as returned in X events. */
280 static Time last_user_time
;
282 /* Incremented by XTread_socket whenever it really tries to read
286 static int volatile input_signal_count
;
288 static int input_signal_count
;
291 /* Used locally within XTread_socket. */
293 static int x_noop_count
;
295 /* Initial values of argv and argc. */
297 extern char **initial_argv
;
298 extern int initial_argc
;
300 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
302 /* Tells if a window manager is present or not. */
304 extern Lisp_Object Vx_no_window_manager
;
306 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
;
323 /* Used in x_flush. */
325 extern Lisp_Object Vinhibit_redisplay
;
327 extern XrmDatabase x_load_resources
P_ ((Display
*, char *, char *, char *));
328 extern int x_bitmap_mask
P_ ((FRAME_PTR
, int));
330 static int x_alloc_nearest_color_1
P_ ((Display
*, Colormap
, XColor
*));
331 static void x_set_window_size_1
P_ ((struct frame
*, int, int, int));
332 static const XColor
*x_color_cells
P_ ((Display
*, int *));
333 static void x_update_window_end
P_ ((struct window
*, int, int));
335 static int x_io_error_quitter
P_ ((Display
*));
336 static struct terminal
*x_create_terminal
P_ ((struct x_display_info
*));
337 void x_delete_terminal
P_ ((struct terminal
*));
338 static void x_update_end
P_ ((struct frame
*));
339 static void XTframe_up_to_date
P_ ((struct frame
*));
340 static void XTset_terminal_modes
P_ ((struct terminal
*));
341 static void XTreset_terminal_modes
P_ ((struct terminal
*));
342 static void x_clear_frame
P_ ((struct frame
*));
343 static void frame_highlight
P_ ((struct frame
*));
344 static void frame_unhighlight
P_ ((struct frame
*));
345 static void x_new_focus_frame
P_ ((struct x_display_info
*, struct frame
*));
346 static void x_focus_changed
P_ ((int, int, struct x_display_info
*,
347 struct frame
*, struct input_event
*));
348 static void x_detect_focus_change
P_ ((struct x_display_info
*,
349 XEvent
*, struct input_event
*));
350 static void XTframe_rehighlight
P_ ((struct frame
*));
351 static void x_frame_rehighlight
P_ ((struct x_display_info
*));
352 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
353 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int,
354 enum text_cursor_kinds
));
356 static void x_clip_to_row
P_ ((struct window
*, struct glyph_row
*, int, GC
));
357 static void x_flush
P_ ((struct frame
*f
));
358 static void x_update_begin
P_ ((struct frame
*));
359 static void x_update_window_begin
P_ ((struct window
*));
360 static void x_after_update_window_line
P_ ((struct glyph_row
*));
361 static struct scroll_bar
*x_window_to_scroll_bar
P_ ((Display
*, Window
));
362 static void x_scroll_bar_report_motion
P_ ((struct frame
**, Lisp_Object
*,
363 enum scroll_bar_part
*,
364 Lisp_Object
*, Lisp_Object
*,
366 static void x_check_fullscreen
P_ ((struct frame
*));
367 static void x_check_expected_move
P_ ((struct frame
*, int, int));
368 static void x_sync_with_move
P_ ((struct frame
*, int, int, int));
369 static int handle_one_xevent
P_ ((struct x_display_info
*, XEvent
*,
370 int *, struct input_event
*));
371 /* Don't declare this NO_RETURN because we want no
372 interference with debugging failing X calls. */
373 static SIGTYPE x_connection_closed
P_ ((Display
*, char *));
376 /* Flush display of frame F, or of all frames if F is null. */
382 /* Don't call XFlush when it is not safe to redisplay; the X
383 connection may be broken. */
384 if (!NILP (Vinhibit_redisplay
))
390 Lisp_Object rest
, frame
;
391 FOR_EACH_FRAME (rest
, frame
)
392 if (FRAME_X_P (XFRAME (frame
)))
393 x_flush (XFRAME (frame
));
395 else if (FRAME_X_P (f
))
396 XFlush (FRAME_X_DISPLAY (f
));
401 /* Remove calls to XFlush by defining XFlush to an empty replacement.
402 Calls to XFlush should be unnecessary because the X output buffer
403 is flushed automatically as needed by calls to XPending,
404 XNextEvent, or XWindowEvent according to the XFlush man page.
405 XTread_socket calls XPending. Removing XFlush improves
408 #define XFlush(DISPLAY) (void) 0
411 /***********************************************************************
413 ***********************************************************************/
417 /* This is a function useful for recording debugging information about
418 the sequence of occurrences in this file. */
426 struct record event_record
[100];
428 int event_record_index
;
430 record_event (locus
, type
)
434 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
435 event_record_index
= 0;
437 event_record
[event_record_index
].locus
= locus
;
438 event_record
[event_record_index
].type
= type
;
439 event_record_index
++;
446 /* Return the struct x_display_info corresponding to DPY. */
448 struct x_display_info
*
449 x_display_info_for_display (dpy
)
452 struct x_display_info
*dpyinfo
;
454 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
455 if (dpyinfo
->display
== dpy
)
461 #define OPAQUE 0xffffffff
462 #define OPACITY "_NET_WM_WINDOW_OPACITY"
465 x_set_frame_alpha (f
)
468 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
469 Display
*dpy
= FRAME_X_DISPLAY (f
);
470 Window win
= FRAME_OUTER_WINDOW (f
);
472 double alpha_min
= 1.0;
475 if (FRAME_X_DISPLAY_INFO (f
)->root_window
!= FRAME_X_OUTPUT (f
)->parent_desc
)
476 /* Since the WM decoration lies under the FRAME_OUTER_WINDOW,
477 we must treat the former instead of the latter. */
478 win
= FRAME_X_OUTPUT(f
)->parent_desc
;
480 if (dpyinfo
->x_highlight_frame
== f
)
485 if (FLOATP (Vframe_alpha_lower_limit
))
486 alpha_min
= XFLOAT_DATA (Vframe_alpha_lower_limit
);
487 else if (INTEGERP (Vframe_alpha_lower_limit
))
488 alpha_min
= (XINT (Vframe_alpha_lower_limit
)) / 100.0;
490 if (alpha
< 0.0 || 1.0 < alpha
)
492 else if (0.0 <= alpha
&& alpha
< alpha_min
&& alpha_min
<= 1.0)
495 opac
= alpha
* OPAQUE
;
497 /* return unless necessary */
502 unsigned long n
, left
;
504 x_catch_errors (dpy
);
505 rc
= XGetWindowProperty(dpy
, win
, XInternAtom(dpy
, OPACITY
, False
),
506 0L, 1L, False
, XA_CARDINAL
,
507 &actual
, &format
, &n
, &left
,
510 if (rc
== Success
&& actual
!= None
)
511 if (*(unsigned long *)data
== opac
)
513 XFree ((void *) data
);
518 XFree ((void *) data
);
522 x_catch_errors (dpy
);
523 XChangeProperty (dpy
, win
, XInternAtom (dpy
, OPACITY
, False
),
524 XA_CARDINAL
, 32, PropModeReplace
,
525 (unsigned char *) &opac
, 1L);
530 x_display_pixel_height (dpyinfo
)
531 struct x_display_info
*dpyinfo
;
533 return HeightOfScreen (dpyinfo
->screen
);
537 x_display_pixel_width (dpyinfo
)
538 struct x_display_info
*dpyinfo
;
540 return WidthOfScreen (dpyinfo
->screen
);
544 /***********************************************************************
545 Starting and ending an update
546 ***********************************************************************/
548 /* Start an update of frame F. This function is installed as a hook
549 for update_begin, i.e. it is called when update_begin is called.
550 This function is called prior to calls to x_update_window_begin for
551 each window being updated. Currently, there is nothing to do here
552 because all interesting stuff is done on a window basis. */
562 /* Start update of window W. Set the global variable updated_window
563 to the window being updated and set output_cursor to the cursor
567 x_update_window_begin (w
)
570 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
571 struct x_display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
574 set_output_cursor (&w
->cursor
);
578 if (f
== display_info
->mouse_face_mouse_frame
)
580 /* Don't do highlighting for mouse motion during the update. */
581 display_info
->mouse_face_defer
= 1;
583 /* If F needs to be redrawn, simply forget about any prior mouse
585 if (FRAME_GARBAGED_P (f
))
586 display_info
->mouse_face_window
= Qnil
;
588 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
589 their mouse_face_p flag set, which means that they are always
590 unequal to rows in a desired matrix which never have that
591 flag set. So, rows containing mouse-face glyphs are never
592 scrolled, and we don't have to switch the mouse highlight off
593 here to prevent it from being scrolled. */
595 /* Can we tell that this update does not affect the window
596 where the mouse highlight is? If so, no need to turn off.
597 Likewise, don't do anything if the frame is garbaged;
598 in that case, the frame's current matrix that we would use
599 is all wrong, and we will redisplay that line anyway. */
600 if (!NILP (display_info
->mouse_face_window
)
601 && w
== XWINDOW (display_info
->mouse_face_window
))
605 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
606 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
609 if (i
< w
->desired_matrix
->nrows
)
610 clear_mouse_face (display_info
);
619 /* Draw a vertical window border from (x,y0) to (x,y1) */
622 x_draw_vertical_window_border (w
, x
, y0
, y1
)
626 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
629 face
= FACE_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
631 XSetForeground (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
634 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
635 f
->output_data
.x
->normal_gc
, x
, y0
, x
, y1
);
638 /* End update of window W (which is equal to updated_window).
640 Draw vertical borders between horizontally adjacent windows, and
641 display W's cursor if CURSOR_ON_P is non-zero.
643 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
644 glyphs in mouse-face were overwritten. In that case we have to
645 make sure that the mouse-highlight is properly redrawn.
647 W may be a menu bar pseudo-window in case we don't have X toolkit
648 support. Such windows don't have a cursor, so don't display it
652 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
654 int cursor_on_p
, mouse_face_overwritten_p
;
656 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
658 if (!w
->pseudo_window_p
)
663 display_and_set_cursor (w
, 1, output_cursor
.hpos
,
665 output_cursor
.x
, output_cursor
.y
);
667 if (draw_window_fringes (w
, 1))
668 x_draw_vertical_border (w
);
673 /* If a row with mouse-face was overwritten, arrange for
674 XTframe_up_to_date to redisplay the mouse highlight. */
675 if (mouse_face_overwritten_p
)
677 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
678 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
679 dpyinfo
->mouse_face_window
= Qnil
;
682 updated_window
= NULL
;
686 /* End update of frame F. This function is installed as a hook in
693 /* Mouse highlight may be displayed again. */
694 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
698 XFlush (FRAME_X_DISPLAY (f
));
704 /* This function is called from various places in xdisp.c whenever a
705 complete update has been performed. The global variable
706 updated_window is not available here. */
709 XTframe_up_to_date (f
)
714 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
716 if (dpyinfo
->mouse_face_deferred_gc
717 || f
== dpyinfo
->mouse_face_mouse_frame
)
720 if (dpyinfo
->mouse_face_mouse_frame
)
721 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
722 dpyinfo
->mouse_face_mouse_x
,
723 dpyinfo
->mouse_face_mouse_y
);
724 dpyinfo
->mouse_face_deferred_gc
= 0;
731 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
732 arrow bitmaps, or clear the fringes if no bitmaps are required
733 before DESIRED_ROW is made current. The window being updated is
734 found in updated_window. This function It is called from
735 update_window_line only if it is known that there are differences
736 between bitmaps to be drawn between current row and DESIRED_ROW. */
739 x_after_update_window_line (desired_row
)
740 struct glyph_row
*desired_row
;
742 struct window
*w
= updated_window
;
748 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
749 desired_row
->redraw_fringe_bitmaps_p
= 1;
751 /* When a window has disappeared, make sure that no rest of
752 full-width rows stays visible in the internal border. Could
753 check here if updated_window is the leftmost/rightmost window,
754 but I guess it's not worth doing since vertically split windows
755 are almost never used, internal border is rarely set, and the
756 overhead is very small. */
757 if (windows_or_buffers_changed
758 && desired_row
->full_width_p
759 && (f
= XFRAME (w
->frame
),
760 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
762 && (height
= desired_row
->visible_height
,
765 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
767 /* Internal border is drawn below the tool bar. */
768 if (WINDOWP (f
->tool_bar_window
)
769 && w
== XWINDOW (f
->tool_bar_window
))
773 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
774 0, y
, width
, height
, False
);
775 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
776 FRAME_PIXEL_WIDTH (f
) - width
,
777 y
, width
, height
, False
);
783 x_draw_fringe_bitmap (w
, row
, p
)
785 struct glyph_row
*row
;
786 struct draw_fringe_bitmap_params
*p
;
788 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
789 Display
*display
= FRAME_X_DISPLAY (f
);
790 Window window
= FRAME_X_WINDOW (f
);
791 GC gc
= f
->output_data
.x
->normal_gc
;
792 struct face
*face
= p
->face
;
795 /* Must clip because of partially visible lines. */
796 rowY
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
799 /* Adjust position of "bottom aligned" bitmap on partially
802 int oldVH
= row
->visible_height
;
803 row
->visible_height
= p
->h
;
804 row
->y
-= rowY
- p
->y
;
805 x_clip_to_row (w
, row
, -1, gc
);
807 row
->visible_height
= oldVH
;
810 x_clip_to_row (w
, row
, -1, gc
);
814 int bx
= p
->bx
, by
= p
->by
, nx
= p
->nx
, ny
= p
->ny
;
816 /* In case the same realized face is used for fringes and
817 for something displayed in the text (e.g. face `region' on
818 mono-displays, the fill style may have been changed to
819 FillSolid in x_draw_glyph_string_background. */
821 XSetFillStyle (display
, face
->gc
, FillOpaqueStippled
);
823 XSetForeground (display
, face
->gc
, face
->background
);
825 #ifdef USE_TOOLKIT_SCROLL_BARS
826 /* If the fringe is adjacent to the left (right) scroll bar of a
827 leftmost (rightmost, respectively) window, then extend its
828 background to the gap between the fringe and the bar. */
829 if ((WINDOW_LEFTMOST_P (w
)
830 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
831 || (WINDOW_RIGHTMOST_P (w
)
832 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
)))
834 int sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
838 int left
= WINDOW_SCROLL_BAR_AREA_X (w
);
839 int width
= (WINDOW_CONFIG_SCROLL_BAR_COLS (w
)
840 * FRAME_COLUMN_WIDTH (f
));
844 /* Bitmap fills the fringe. */
845 if (left
+ width
== p
->x
)
846 bx
= left
+ sb_width
;
847 else if (p
->x
+ p
->wd
== left
)
851 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
853 nx
= width
- sb_width
;
854 by
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
856 ny
= row
->visible_height
;
861 if (left
+ width
== bx
)
863 bx
= left
+ sb_width
;
864 nx
+= width
- sb_width
;
866 else if (bx
+ nx
== left
)
867 nx
+= width
- sb_width
;
872 if (bx
>= 0 && nx
> 0)
873 XFillRectangle (display
, window
, face
->gc
, bx
, by
, nx
, ny
);
876 XSetForeground (display
, face
->gc
, face
->foreground
);
882 Pixmap pixmap
, clipmask
= (Pixmap
) 0;
883 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
887 bits
= (unsigned char *)(p
->bits
+ p
->dh
);
889 bits
= (unsigned char *)p
->bits
+ p
->dh
;
891 /* Draw the bitmap. I believe these small pixmaps can be cached
893 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, p
->wd
, p
->h
,
895 ? (p
->overlay_p
? face
->background
896 : f
->output_data
.x
->cursor_pixel
)
898 face
->background
, depth
);
902 clipmask
= XCreatePixmapFromBitmapData (display
,
903 FRAME_X_DISPLAY_INFO (f
)->root_window
,
906 gcv
.clip_mask
= clipmask
;
907 gcv
.clip_x_origin
= p
->x
;
908 gcv
.clip_y_origin
= p
->y
;
909 XChangeGC (display
, gc
, GCClipMask
| GCClipXOrigin
| GCClipYOrigin
, &gcv
);
912 XCopyArea (display
, pixmap
, window
, gc
, 0, 0,
913 p
->wd
, p
->h
, p
->x
, p
->y
);
914 XFreePixmap (display
, pixmap
);
918 gcv
.clip_mask
= (Pixmap
) 0;
919 XChangeGC (display
, gc
, GCClipMask
, &gcv
);
920 XFreePixmap (display
, clipmask
);
924 XSetClipMask (display
, gc
, None
);
929 /* This is called when starting Emacs and when restarting after
930 suspend. When starting Emacs, no X window is mapped. And nothing
931 must be done to Emacs's own window if it is suspended (though that
935 XTset_terminal_modes (struct terminal
*terminal
)
939 /* This is called when exiting or suspending Emacs. Exiting will make
940 the X-windows go away, and suspending requires no action. */
943 XTreset_terminal_modes (struct terminal
*terminal
)
948 /***********************************************************************
950 ***********************************************************************/
954 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
955 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
956 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
958 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
959 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
960 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
961 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
962 static void x_compute_glyph_string_overhangs
P_ ((struct glyph_string
*));
963 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
964 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
965 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
966 static int x_alloc_lighter_color
P_ ((struct frame
*, Display
*, Colormap
,
967 unsigned long *, double, int));
968 static void x_setup_relief_color
P_ ((struct frame
*, struct relief
*,
969 double, int, unsigned long));
970 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
971 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
972 static void x_draw_image_relief
P_ ((struct glyph_string
*));
973 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
974 static void x_draw_image_foreground_1
P_ ((struct glyph_string
*, Pixmap
));
975 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
977 static void x_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
978 int, int, int, int, int, int,
980 static void x_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
981 int, int, int, XRectangle
*));
984 static void x_check_font
P_ ((struct frame
*, struct font
*));
988 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
993 struct glyph_string
*s
;
995 if (s
->font
== FRAME_FONT (s
->f
)
996 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
997 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
999 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
1002 /* Cursor on non-default face: must merge. */
1006 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
1007 xgcv
.foreground
= s
->face
->background
;
1009 /* If the glyph would be invisible, try a different foreground. */
1010 if (xgcv
.foreground
== xgcv
.background
)
1011 xgcv
.foreground
= s
->face
->foreground
;
1012 if (xgcv
.foreground
== xgcv
.background
)
1013 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
1014 if (xgcv
.foreground
== xgcv
.background
)
1015 xgcv
.foreground
= s
->face
->foreground
;
1017 /* Make sure the cursor is distinct from text in this face. */
1018 if (xgcv
.background
== s
->face
->background
1019 && xgcv
.foreground
== s
->face
->foreground
)
1021 xgcv
.background
= s
->face
->foreground
;
1022 xgcv
.foreground
= s
->face
->background
;
1025 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1026 xgcv
.graphics_exposures
= False
;
1027 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
1029 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1030 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1033 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1034 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
1036 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1041 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1044 x_set_mouse_face_gc (s
)
1045 struct glyph_string
*s
;
1050 /* What face has to be used last for the mouse face? */
1051 face_id
= FRAME_X_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
1052 face
= FACE_FROM_ID (s
->f
, face_id
);
1054 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1056 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1057 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
1059 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
1060 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1061 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1063 if (s
->font
== s
->face
->font
)
1064 s
->gc
= s
->face
->gc
;
1067 /* Otherwise construct scratch_cursor_gc with values from FACE
1072 xgcv
.background
= s
->face
->background
;
1073 xgcv
.foreground
= s
->face
->foreground
;
1074 xgcv
.graphics_exposures
= False
;
1075 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
1077 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1078 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1081 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1082 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
1084 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1087 xassert (s
->gc
!= 0);
1091 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1092 Faces to use in the mode line have already been computed when the
1093 matrix was built, so there isn't much to do, here. */
1096 x_set_mode_line_face_gc (s
)
1097 struct glyph_string
*s
;
1099 s
->gc
= s
->face
->gc
;
1103 /* Set S->gc of glyph string S for drawing that glyph string. Set
1104 S->stippled_p to a non-zero value if the face of S has a stipple
1108 x_set_glyph_string_gc (s
)
1109 struct glyph_string
*s
;
1111 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1113 if (s
->hl
== DRAW_NORMAL_TEXT
)
1115 s
->gc
= s
->face
->gc
;
1116 s
->stippled_p
= s
->face
->stipple
!= 0;
1118 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1120 x_set_mode_line_face_gc (s
);
1121 s
->stippled_p
= s
->face
->stipple
!= 0;
1123 else if (s
->hl
== DRAW_CURSOR
)
1125 x_set_cursor_gc (s
);
1128 else if (s
->hl
== DRAW_MOUSE_FACE
)
1130 x_set_mouse_face_gc (s
);
1131 s
->stippled_p
= s
->face
->stipple
!= 0;
1133 else if (s
->hl
== DRAW_IMAGE_RAISED
1134 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1136 s
->gc
= s
->face
->gc
;
1137 s
->stippled_p
= s
->face
->stipple
!= 0;
1141 s
->gc
= s
->face
->gc
;
1142 s
->stippled_p
= s
->face
->stipple
!= 0;
1145 /* GC must have been set. */
1146 xassert (s
->gc
!= 0);
1150 /* Set clipping for output of glyph string S. S may be part of a mode
1151 line or menu if we don't have X toolkit support. */
1154 x_set_glyph_string_clipping (s
)
1155 struct glyph_string
*s
;
1157 XRectangle
*r
= s
->clip
;
1158 int n
= get_glyph_string_clip_rects (s
, r
, 2);
1161 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, r
, n
, Unsorted
);
1166 /* Set SRC's clipping for output of glyph string DST. This is called
1167 when we are drawing DST's left_overhang or right_overhang only in
1171 x_set_glyph_string_clipping_exactly (src
, dst
)
1172 struct glyph_string
*src
, *dst
;
1177 r
.width
= src
->width
;
1179 r
.height
= src
->height
;
1182 XSetClipRectangles (dst
->display
, dst
->gc
, 0, 0, &r
, 1, Unsorted
);
1187 Compute left and right overhang of glyph string S. */
1190 x_compute_glyph_string_overhangs (s
)
1191 struct glyph_string
*s
;
1194 && s
->first_glyph
->type
== CHAR_GLYPH
)
1196 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1197 struct font
*font
= s
->font
;
1198 struct font_metrics metrics
;
1201 for (i
= 0; i
< s
->nchars
; i
++)
1202 code
[i
] = (s
->char2b
[i
].byte1
<< 8) | s
->char2b
[i
].byte2
;
1203 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1204 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1205 ? metrics
.rbearing
- metrics
.width
: 0);
1206 s
->left_overhang
= metrics
.lbearing
< 0 ? - metrics
.lbearing
: 0;
1210 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1211 s
->left_overhang
= - s
->cmp
->lbearing
;
1216 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1219 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
1220 struct glyph_string
*s
;
1224 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
1225 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
1226 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
1227 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
1231 /* Draw the background of glyph_string S. If S->background_filled_p
1232 is non-zero don't draw it. FORCE_P non-zero means draw the
1233 background even if it wouldn't be drawn normally. This is used
1234 when a string preceding S draws into the background of S, or S
1235 contains the first component of a composition. */
1238 x_draw_glyph_string_background (s
, force_p
)
1239 struct glyph_string
*s
;
1242 /* Nothing to do if background has already been drawn or if it
1243 shouldn't be drawn in the first place. */
1244 if (!s
->background_filled_p
)
1246 int box_line_width
= max (s
->face
->box_line_width
, 0);
1250 /* Fill background with a stipple pattern. */
1251 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1252 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1253 s
->y
+ box_line_width
,
1254 s
->background_width
,
1255 s
->height
- 2 * box_line_width
);
1256 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1257 s
->background_filled_p
= 1;
1259 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1260 || s
->font_not_found_p
1261 || s
->extends_to_end_of_line_p
1264 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1265 s
->background_width
,
1266 s
->height
- 2 * box_line_width
);
1267 s
->background_filled_p
= 1;
1273 /* Draw the foreground of glyph string S. */
1276 x_draw_glyph_string_foreground (s
)
1277 struct glyph_string
*s
;
1281 /* If first glyph of S has a left box line, start drawing the text
1282 of S to the right of that box line. */
1283 if (s
->face
->box
!= FACE_NO_BOX
1284 && s
->first_glyph
->left_box_line_p
)
1285 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1289 /* Draw characters of S as rectangles if S's font could not be
1291 if (s
->font_not_found_p
)
1293 for (i
= 0; i
< s
->nchars
; ++i
)
1295 struct glyph
*g
= s
->first_glyph
+ i
;
1296 XDrawRectangle (s
->display
, s
->window
,
1297 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1299 x
+= g
->pixel_width
;
1304 struct font
*font
= s
->font
;
1305 int boff
= font
->baseline_offset
;
1308 if (font
->vertical_centering
)
1309 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1311 y
= s
->ybase
- boff
;
1313 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1314 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 0);
1316 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 1);
1317 if (s
->face
->overstrike
)
1318 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, 0);
1322 /* Draw the foreground of composite glyph string S. */
1325 x_draw_composite_glyph_string_foreground (s
)
1326 struct glyph_string
*s
;
1329 struct font
*font
= s
->font
;
1331 /* If first glyph of S has a left box line, start drawing the text
1332 of S to the right of that box line. */
1333 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1334 && s
->first_glyph
->left_box_line_p
)
1335 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1339 /* S is a glyph string for a composition. S->cmp_from is the index
1340 of the first character drawn for glyphs of this composition.
1341 S->cmp_from == 0 means we are drawing the very first character of
1342 this composition. */
1344 /* Draw a rectangle for the composition if the font for the very
1345 first character of the composition could not be loaded. */
1346 if (s
->font_not_found_p
)
1348 if (s
->cmp_from
== 0)
1349 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, s
->y
,
1350 s
->width
- 1, s
->height
- 1);
1352 else if (! s
->first_glyph
->u
.cmp
.automatic
)
1356 for (i
= 0, j
= s
->cmp_from
; i
< s
->nchars
; i
++, j
++)
1357 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1359 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1360 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1362 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, 0);
1363 if (s
->face
->overstrike
)
1364 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, 0);
1369 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1374 for (i
= j
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
1376 glyph
= LGSTRING_GLYPH (gstring
, i
);
1377 if (NILP (LGLYPH_ADJUSTMENT (glyph
)))
1378 width
+= LGLYPH_WIDTH (glyph
);
1381 int xoff
, yoff
, wadjust
;
1385 font
->driver
->draw (s
, j
, i
, x
, y
, 0);
1388 xoff
= LGLYPH_XOFF (glyph
);
1389 yoff
= LGLYPH_YOFF (glyph
);
1390 wadjust
= LGLYPH_WADJUST (glyph
);
1391 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, 0);
1398 font
->driver
->draw (s
, j
, i
, x
, y
, 0);
1403 #ifdef USE_X_TOOLKIT
1405 static struct frame
*x_frame_of_widget
P_ ((Widget
));
1406 static Boolean cvt_string_to_pixel
P_ ((Display
*, XrmValue
*, Cardinal
*,
1407 XrmValue
*, XrmValue
*, XtPointer
*));
1408 static void cvt_pixel_dtor
P_ ((XtAppContext
, XrmValue
*, XtPointer
,
1409 XrmValue
*, Cardinal
*));
1412 /* Return the frame on which widget WIDGET is used.. Abort if frame
1413 cannot be determined. */
1415 static struct frame
*
1416 x_frame_of_widget (widget
)
1419 struct x_display_info
*dpyinfo
;
1423 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
1425 /* Find the top-level shell of the widget. Note that this function
1426 can be called when the widget is not yet realized, so XtWindow
1427 (widget) == 0. That's the reason we can't simply use
1428 x_any_window_to_frame. */
1429 while (!XtIsTopLevelShell (widget
))
1430 widget
= XtParent (widget
);
1432 /* Look for a frame with that top-level widget. Allocate the color
1433 on that frame to get the right gamma correction value. */
1434 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1435 if (FRAMEP (XCAR (tail
))
1436 && (f
= XFRAME (XCAR (tail
)),
1438 && f
->output_data
.nothing
!= 1
1439 && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
))
1440 && f
->output_data
.x
->widget
== widget
)
1447 /* Allocate the color COLOR->pixel on the screen and display of
1448 widget WIDGET in colormap CMAP. If an exact match cannot be
1449 allocated, try the nearest color available. Value is non-zero
1450 if successful. This is called from lwlib. */
1453 x_alloc_nearest_color_for_widget (widget
, cmap
, color
)
1458 struct frame
*f
= x_frame_of_widget (widget
);
1459 return x_alloc_nearest_color (f
, cmap
, color
);
1463 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1464 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1465 If this produces the same color as PIXEL, try a color where all RGB
1466 values have DELTA added. Return the allocated color in *PIXEL.
1467 DISPLAY is the X display, CMAP is the colormap to operate on.
1468 Value is non-zero if successful. */
1471 x_alloc_lighter_color_for_widget (widget
, display
, cmap
, pixel
, factor
, delta
)
1475 unsigned long *pixel
;
1479 struct frame
*f
= x_frame_of_widget (widget
);
1480 return x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
);
1484 /* Structure specifying which arguments should be passed by Xt to
1485 cvt_string_to_pixel. We want the widget's screen and colormap. */
1487 static XtConvertArgRec cvt_string_to_pixel_args
[] =
1489 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.screen
),
1491 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.colormap
),
1496 /* The address of this variable is returned by
1497 cvt_string_to_pixel. */
1499 static Pixel cvt_string_to_pixel_value
;
1502 /* Convert a color name to a pixel color.
1504 DPY is the display we are working on.
1506 ARGS is an array of *NARGS XrmValue structures holding additional
1507 information about the widget for which the conversion takes place.
1508 The contents of this array are determined by the specification
1509 in cvt_string_to_pixel_args.
1511 FROM is a pointer to an XrmValue which points to the color name to
1512 convert. TO is an XrmValue in which to return the pixel color.
1514 CLOSURE_RET is a pointer to user-data, in which we record if
1515 we allocated the color or not.
1517 Value is True if successful, False otherwise. */
1520 cvt_string_to_pixel (dpy
, args
, nargs
, from
, to
, closure_ret
)
1524 XrmValue
*from
, *to
;
1525 XtPointer
*closure_ret
;
1535 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1536 "wrongParameters", "cvt_string_to_pixel",
1538 "Screen and colormap args required", NULL
, NULL
);
1542 screen
= *(Screen
**) args
[0].addr
;
1543 cmap
= *(Colormap
*) args
[1].addr
;
1544 color_name
= (String
) from
->addr
;
1546 if (strcmp (color_name
, XtDefaultBackground
) == 0)
1548 *closure_ret
= (XtPointer
) False
;
1549 pixel
= WhitePixelOfScreen (screen
);
1551 else if (strcmp (color_name
, XtDefaultForeground
) == 0)
1553 *closure_ret
= (XtPointer
) False
;
1554 pixel
= BlackPixelOfScreen (screen
);
1556 else if (XParseColor (dpy
, cmap
, color_name
, &color
)
1557 && x_alloc_nearest_color_1 (dpy
, cmap
, &color
))
1559 pixel
= color
.pixel
;
1560 *closure_ret
= (XtPointer
) True
;
1565 Cardinal nparams
= 1;
1567 params
[0] = color_name
;
1568 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1569 "badValue", "cvt_string_to_pixel",
1570 "XtToolkitError", "Invalid color `%s'",
1575 if (to
->addr
!= NULL
)
1577 if (to
->size
< sizeof (Pixel
))
1579 to
->size
= sizeof (Pixel
);
1583 *(Pixel
*) to
->addr
= pixel
;
1587 cvt_string_to_pixel_value
= pixel
;
1588 to
->addr
= (XtPointer
) &cvt_string_to_pixel_value
;
1591 to
->size
= sizeof (Pixel
);
1596 /* Free a pixel color which was previously allocated via
1597 cvt_string_to_pixel. This is registered as the destructor
1598 for this type of resource via XtSetTypeConverter.
1600 APP is the application context in which we work.
1602 TO is a pointer to an XrmValue holding the color to free.
1603 CLOSURE is the value we stored in CLOSURE_RET for this color
1604 in cvt_string_to_pixel.
1606 ARGS and NARGS are like for cvt_string_to_pixel. */
1609 cvt_pixel_dtor (app
, to
, closure
, args
, nargs
)
1618 XtAppWarningMsg (app
, "wrongParameters", "cvt_pixel_dtor",
1620 "Screen and colormap arguments required",
1623 else if (closure
!= NULL
)
1625 /* We did allocate the pixel, so free it. */
1626 Screen
*screen
= *(Screen
**) args
[0].addr
;
1627 Colormap cmap
= *(Colormap
*) args
[1].addr
;
1628 x_free_dpy_colors (DisplayOfScreen (screen
), screen
, cmap
,
1629 (Pixel
*) to
->addr
, 1);
1634 #endif /* USE_X_TOOLKIT */
1637 /* Value is an array of XColor structures for the contents of the
1638 color map of display DPY. Set *NCELLS to the size of the array.
1639 Note that this probably shouldn't be called for large color maps,
1640 say a 24-bit TrueColor map. */
1642 static const XColor
*
1643 x_color_cells (dpy
, ncells
)
1647 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1649 if (dpyinfo
->color_cells
== NULL
)
1651 Screen
*screen
= dpyinfo
->screen
;
1654 dpyinfo
->ncolor_cells
1655 = XDisplayCells (dpy
, XScreenNumberOfScreen (screen
));
1656 dpyinfo
->color_cells
1657 = (XColor
*) xmalloc (dpyinfo
->ncolor_cells
1658 * sizeof *dpyinfo
->color_cells
);
1660 for (i
= 0; i
< dpyinfo
->ncolor_cells
; ++i
)
1661 dpyinfo
->color_cells
[i
].pixel
= i
;
1663 XQueryColors (dpy
, dpyinfo
->cmap
,
1664 dpyinfo
->color_cells
, dpyinfo
->ncolor_cells
);
1667 *ncells
= dpyinfo
->ncolor_cells
;
1668 return dpyinfo
->color_cells
;
1672 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1673 colors in COLORS. Use cached information, if available. */
1676 x_query_colors (f
, colors
, ncolors
)
1681 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1683 if (dpyinfo
->color_cells
)
1686 for (i
= 0; i
< ncolors
; ++i
)
1688 unsigned long pixel
= colors
[i
].pixel
;
1689 xassert (pixel
< dpyinfo
->ncolor_cells
);
1690 xassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
1691 colors
[i
] = dpyinfo
->color_cells
[pixel
];
1695 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
1699 /* On frame F, translate pixel color to RGB values for the color in
1700 COLOR. Use cached information, if available. */
1703 x_query_color (f
, color
)
1707 x_query_colors (f
, color
, 1);
1711 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
1712 exact match can't be allocated, try the nearest color available.
1713 Value is non-zero if successful. Set *COLOR to the color
1717 x_alloc_nearest_color_1 (dpy
, cmap
, color
)
1724 rc
= XAllocColor (dpy
, cmap
, color
);
1727 /* If we got to this point, the colormap is full, so we're going
1728 to try to get the next closest color. The algorithm used is
1729 a least-squares matching, which is what X uses for closest
1730 color matching with StaticColor visuals. */
1732 unsigned long nearest_delta
= ~0;
1734 const XColor
*cells
= x_color_cells (dpy
, &ncells
);
1736 for (nearest
= i
= 0; i
< ncells
; ++i
)
1738 long dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
1739 long dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
1740 long dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
1741 unsigned long delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
1743 if (delta
< nearest_delta
)
1746 nearest_delta
= delta
;
1750 color
->red
= cells
[nearest
].red
;
1751 color
->green
= cells
[nearest
].green
;
1752 color
->blue
= cells
[nearest
].blue
;
1753 rc
= XAllocColor (dpy
, cmap
, color
);
1757 /* If allocation succeeded, and the allocated pixel color is not
1758 equal to a cached pixel color recorded earlier, there was a
1759 change in the colormap, so clear the color cache. */
1760 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1761 XColor
*cached_color
;
1763 if (dpyinfo
->color_cells
1764 && (cached_color
= &dpyinfo
->color_cells
[color
->pixel
],
1765 (cached_color
->red
!= color
->red
1766 || cached_color
->blue
!= color
->blue
1767 || cached_color
->green
!= color
->green
)))
1769 xfree (dpyinfo
->color_cells
);
1770 dpyinfo
->color_cells
= NULL
;
1771 dpyinfo
->ncolor_cells
= 0;
1775 #ifdef DEBUG_X_COLORS
1777 register_color (color
->pixel
);
1778 #endif /* DEBUG_X_COLORS */
1784 /* Allocate the color COLOR->pixel on frame F, colormap CMAP. If an
1785 exact match can't be allocated, try the nearest color available.
1786 Value is non-zero if successful. Set *COLOR to the color
1790 x_alloc_nearest_color (f
, cmap
, color
)
1795 gamma_correct (f
, color
);
1796 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f
), cmap
, color
);
1800 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
1801 It's necessary to do this instead of just using PIXEL directly to
1802 get color reference counts right. */
1805 x_copy_color (f
, pixel
)
1807 unsigned long pixel
;
1811 color
.pixel
= pixel
;
1813 x_query_color (f
, &color
);
1814 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
1816 #ifdef DEBUG_X_COLORS
1817 register_color (pixel
);
1823 /* Allocate color PIXEL on display DPY. PIXEL must already be allocated.
1824 It's necessary to do this instead of just using PIXEL directly to
1825 get color reference counts right. */
1828 x_copy_dpy_color (dpy
, cmap
, pixel
)
1831 unsigned long pixel
;
1835 color
.pixel
= pixel
;
1837 XQueryColor (dpy
, cmap
, &color
);
1838 XAllocColor (dpy
, cmap
, &color
);
1840 #ifdef DEBUG_X_COLORS
1841 register_color (pixel
);
1847 /* Brightness beyond which a color won't have its highlight brightness
1850 Nominally, highlight colors for `3d' faces are calculated by
1851 brightening an object's color by a constant scale factor, but this
1852 doesn't yield good results for dark colors, so for colors who's
1853 brightness is less than this value (on a scale of 0-65535) have an
1854 use an additional additive factor.
1856 The value here is set so that the default menu-bar/mode-line color
1857 (grey75) will not have its highlights changed at all. */
1858 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
1861 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1862 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1863 If this produces the same color as PIXEL, try a color where all RGB
1864 values have DELTA added. Return the allocated color in *PIXEL.
1865 DISPLAY is the X display, CMAP is the colormap to operate on.
1866 Value is non-zero if successful. */
1869 x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
)
1873 unsigned long *pixel
;
1881 /* Get RGB color values. */
1882 color
.pixel
= *pixel
;
1883 x_query_color (f
, &color
);
1885 /* Change RGB values by specified FACTOR. Avoid overflow! */
1886 xassert (factor
>= 0);
1887 new.red
= min (0xffff, factor
* color
.red
);
1888 new.green
= min (0xffff, factor
* color
.green
);
1889 new.blue
= min (0xffff, factor
* color
.blue
);
1891 /* Calculate brightness of COLOR. */
1892 bright
= (2 * color
.red
+ 3 * color
.green
+ color
.blue
) / 6;
1894 /* We only boost colors that are darker than
1895 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1896 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1897 /* Make an additive adjustment to NEW, because it's dark enough so
1898 that scaling by FACTOR alone isn't enough. */
1900 /* How far below the limit this color is (0 - 1, 1 being darker). */
1901 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1902 /* The additive adjustment. */
1903 int min_delta
= delta
* dimness
* factor
/ 2;
1907 new.red
= max (0, new.red
- min_delta
);
1908 new.green
= max (0, new.green
- min_delta
);
1909 new.blue
= max (0, new.blue
- min_delta
);
1913 new.red
= min (0xffff, min_delta
+ new.red
);
1914 new.green
= min (0xffff, min_delta
+ new.green
);
1915 new.blue
= min (0xffff, min_delta
+ new.blue
);
1919 /* Try to allocate the color. */
1920 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1923 if (new.pixel
== *pixel
)
1925 /* If we end up with the same color as before, try adding
1926 delta to the RGB values. */
1927 x_free_colors (f
, &new.pixel
, 1);
1929 new.red
= min (0xffff, delta
+ color
.red
);
1930 new.green
= min (0xffff, delta
+ color
.green
);
1931 new.blue
= min (0xffff, delta
+ color
.blue
);
1932 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1943 /* Set up the foreground color for drawing relief lines of glyph
1944 string S. RELIEF is a pointer to a struct relief containing the GC
1945 with which lines will be drawn. Use a color that is FACTOR or
1946 DELTA lighter or darker than the relief's background which is found
1947 in S->f->output_data.x->relief_background. If such a color cannot
1948 be allocated, use DEFAULT_PIXEL, instead. */
1951 x_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
1953 struct relief
*relief
;
1956 unsigned long default_pixel
;
1959 struct x_output
*di
= f
->output_data
.x
;
1960 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
1961 unsigned long pixel
;
1962 unsigned long background
= di
->relief_background
;
1963 Colormap cmap
= FRAME_X_COLORMAP (f
);
1964 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1965 Display
*dpy
= FRAME_X_DISPLAY (f
);
1967 xgcv
.graphics_exposures
= False
;
1968 xgcv
.line_width
= 1;
1970 /* Free previously allocated color. The color cell will be reused
1971 when it has been freed as many times as it was allocated, so this
1972 doesn't affect faces using the same colors. */
1974 && relief
->allocated_p
)
1976 x_free_colors (f
, &relief
->pixel
, 1);
1977 relief
->allocated_p
= 0;
1980 /* Allocate new color. */
1981 xgcv
.foreground
= default_pixel
;
1983 if (dpyinfo
->n_planes
!= 1
1984 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
1986 relief
->allocated_p
= 1;
1987 xgcv
.foreground
= relief
->pixel
= pixel
;
1990 if (relief
->gc
== 0)
1992 xgcv
.stipple
= dpyinfo
->gray
;
1994 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
1997 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
2001 /* Set up colors for the relief lines around glyph string S. */
2004 x_setup_relief_colors (s
)
2005 struct glyph_string
*s
;
2007 struct x_output
*di
= s
->f
->output_data
.x
;
2008 unsigned long color
;
2010 if (s
->face
->use_box_color_for_shadows_p
)
2011 color
= s
->face
->box_color
;
2012 else if (s
->first_glyph
->type
== IMAGE_GLYPH
2014 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
2015 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
2020 /* Get the background color of the face. */
2021 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
2022 color
= xgcv
.background
;
2025 if (di
->white_relief
.gc
== 0
2026 || color
!= di
->relief_background
)
2028 di
->relief_background
= color
;
2029 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
2030 WHITE_PIX_DEFAULT (s
->f
));
2031 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
2032 BLACK_PIX_DEFAULT (s
->f
));
2037 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
2038 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
2039 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
2040 relief. LEFT_P non-zero means draw a relief on the left side of
2041 the rectangle. RIGHT_P non-zero means draw a relief on the right
2042 side of the rectangle. CLIP_RECT is the clipping rectangle to use
2046 x_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
2047 raised_p
, top_p
, bot_p
, left_p
, right_p
, clip_rect
)
2049 int left_x
, top_y
, right_x
, bottom_y
, width
;
2050 int top_p
, bot_p
, left_p
, right_p
, raised_p
;
2051 XRectangle
*clip_rect
;
2053 Display
*dpy
= FRAME_X_DISPLAY (f
);
2054 Window window
= FRAME_X_WINDOW (f
);
2059 gc
= f
->output_data
.x
->white_relief
.gc
;
2061 gc
= f
->output_data
.x
->black_relief
.gc
;
2062 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
2066 for (i
= 0; i
< width
; ++i
)
2067 XDrawLine (dpy
, window
, gc
,
2068 left_x
+ i
* left_p
, top_y
+ i
,
2069 right_x
+ 1 - i
* right_p
, top_y
+ i
);
2073 for (i
= 0; i
< width
; ++i
)
2074 XDrawLine (dpy
, window
, gc
,
2075 left_x
+ i
, top_y
+ i
, left_x
+ i
, bottom_y
- i
+ 1);
2077 XSetClipMask (dpy
, gc
, None
);
2079 gc
= f
->output_data
.x
->black_relief
.gc
;
2081 gc
= f
->output_data
.x
->white_relief
.gc
;
2082 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
2086 for (i
= 0; i
< width
; ++i
)
2087 XDrawLine (dpy
, window
, gc
,
2088 left_x
+ i
* left_p
, bottom_y
- i
,
2089 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
2093 for (i
= 0; i
< width
; ++i
)
2094 XDrawLine (dpy
, window
, gc
,
2095 right_x
- i
, top_y
+ i
+ 1, right_x
- i
, bottom_y
- i
);
2097 XSetClipMask (dpy
, gc
, None
);
2101 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
2102 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
2103 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
2104 left side of the rectangle. RIGHT_P non-zero means draw a line
2105 on the right side of the rectangle. CLIP_RECT is the clipping
2106 rectangle to use when drawing. */
2109 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2110 left_p
, right_p
, clip_rect
)
2111 struct glyph_string
*s
;
2112 int left_x
, top_y
, right_x
, bottom_y
, width
, left_p
, right_p
;
2113 XRectangle
*clip_rect
;
2117 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2118 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
2119 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, clip_rect
, 1, Unsorted
);
2122 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2123 left_x
, top_y
, right_x
- left_x
+ 1, width
);
2127 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2128 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
2131 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2132 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
2136 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2137 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
2139 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2140 XSetClipMask (s
->display
, s
->gc
, None
);
2144 /* Draw a box around glyph string S. */
2147 x_draw_glyph_string_box (s
)
2148 struct glyph_string
*s
;
2150 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
2151 int left_p
, right_p
;
2152 struct glyph
*last_glyph
;
2153 XRectangle clip_rect
;
2155 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
2156 ? WINDOW_RIGHT_EDGE_X (s
->w
)
2157 : window_box_right (s
->w
, s
->area
));
2159 /* The glyph that may have a right box line. */
2160 last_glyph
= (s
->cmp
|| s
->img
2162 : s
->first_glyph
+ s
->nchars
- 1);
2164 width
= eabs (s
->face
->box_line_width
);
2165 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
2167 right_x
= (s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
2169 : min (last_x
, s
->x
+ s
->background_width
) - 1);
2171 bottom_y
= top_y
+ s
->height
- 1;
2173 left_p
= (s
->first_glyph
->left_box_line_p
2174 || (s
->hl
== DRAW_MOUSE_FACE
2176 || s
->prev
->hl
!= s
->hl
)));
2177 right_p
= (last_glyph
->right_box_line_p
2178 || (s
->hl
== DRAW_MOUSE_FACE
2180 || s
->next
->hl
!= s
->hl
)));
2182 get_glyph_string_clip_rect (s
, &clip_rect
);
2184 if (s
->face
->box
== FACE_SIMPLE_BOX
)
2185 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2186 left_p
, right_p
, &clip_rect
);
2189 x_setup_relief_colors (s
);
2190 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
2191 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
2196 /* Draw foreground of image glyph string S. */
2199 x_draw_image_foreground (s
)
2200 struct glyph_string
*s
;
2203 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2205 /* If first glyph of S has a left box line, start drawing it to the
2206 right of that line. */
2207 if (s
->face
->box
!= FACE_NO_BOX
2208 && s
->first_glyph
->left_box_line_p
2210 x
+= eabs (s
->face
->box_line_width
);
2212 /* If there is a margin around the image, adjust x- and y-position
2214 if (s
->slice
.x
== 0)
2215 x
+= s
->img
->hmargin
;
2216 if (s
->slice
.y
== 0)
2217 y
+= s
->img
->vmargin
;
2223 /* We can't set both a clip mask and use XSetClipRectangles
2224 because the latter also sets a clip mask. We also can't
2225 trust on the shape extension to be available
2226 (XShapeCombineRegion). So, compute the rectangle to draw
2228 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2231 XRectangle clip_rect
, image_rect
, r
;
2233 xgcv
.clip_mask
= s
->img
->mask
;
2234 xgcv
.clip_x_origin
= x
;
2235 xgcv
.clip_y_origin
= y
;
2236 xgcv
.function
= GXcopy
;
2237 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2239 get_glyph_string_clip_rect (s
, &clip_rect
);
2242 image_rect
.width
= s
->slice
.width
;
2243 image_rect
.height
= s
->slice
.height
;
2244 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2245 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2246 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2247 r
.width
, r
.height
, r
.x
, r
.y
);
2251 XRectangle clip_rect
, image_rect
, r
;
2253 get_glyph_string_clip_rect (s
, &clip_rect
);
2256 image_rect
.width
= s
->slice
.width
;
2257 image_rect
.height
= s
->slice
.height
;
2258 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2259 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2260 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2261 r
.width
, r
.height
, r
.x
, r
.y
);
2263 /* When the image has a mask, we can expect that at
2264 least part of a mouse highlight or a block cursor will
2265 be visible. If the image doesn't have a mask, make
2266 a block cursor visible by drawing a rectangle around
2267 the image. I believe it's looking better if we do
2268 nothing here for mouse-face. */
2269 if (s
->hl
== DRAW_CURSOR
)
2271 int r
= s
->img
->relief
;
2273 XDrawRectangle (s
->display
, s
->window
, s
->gc
,
2275 s
->slice
.width
+ r
*2 - 1,
2276 s
->slice
.height
+ r
*2 - 1);
2281 /* Draw a rectangle if image could not be loaded. */
2282 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
2283 s
->slice
.width
- 1, s
->slice
.height
- 1);
2287 /* Draw a relief around the image glyph string S. */
2290 x_draw_image_relief (s
)
2291 struct glyph_string
*s
;
2293 int x0
, y0
, x1
, y1
, thick
, raised_p
;
2296 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2298 /* If first glyph of S has a left box line, start drawing it to the
2299 right of that line. */
2300 if (s
->face
->box
!= FACE_NO_BOX
2301 && s
->first_glyph
->left_box_line_p
2303 x
+= eabs (s
->face
->box_line_width
);
2305 /* If there is a margin around the image, adjust x- and y-position
2307 if (s
->slice
.x
== 0)
2308 x
+= s
->img
->hmargin
;
2309 if (s
->slice
.y
== 0)
2310 y
+= s
->img
->vmargin
;
2312 if (s
->hl
== DRAW_IMAGE_SUNKEN
2313 || s
->hl
== DRAW_IMAGE_RAISED
)
2315 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
2316 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
2320 thick
= eabs (s
->img
->relief
);
2321 raised_p
= s
->img
->relief
> 0;
2326 x1
= x
+ s
->slice
.width
+ thick
- 1;
2327 y1
= y
+ s
->slice
.height
+ thick
- 1;
2329 x_setup_relief_colors (s
);
2330 get_glyph_string_clip_rect (s
, &r
);
2331 x_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
,
2333 s
->slice
.y
+ s
->slice
.height
== s
->img
->height
,
2335 s
->slice
.x
+ s
->slice
.width
== s
->img
->width
,
2340 /* Draw the foreground of image glyph string S to PIXMAP. */
2343 x_draw_image_foreground_1 (s
, pixmap
)
2344 struct glyph_string
*s
;
2348 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2350 /* If first glyph of S has a left box line, start drawing it to the
2351 right of that line. */
2352 if (s
->face
->box
!= FACE_NO_BOX
2353 && s
->first_glyph
->left_box_line_p
2355 x
+= eabs (s
->face
->box_line_width
);
2357 /* If there is a margin around the image, adjust x- and y-position
2359 if (s
->slice
.x
== 0)
2360 x
+= s
->img
->hmargin
;
2361 if (s
->slice
.y
== 0)
2362 y
+= s
->img
->vmargin
;
2368 /* We can't set both a clip mask and use XSetClipRectangles
2369 because the latter also sets a clip mask. We also can't
2370 trust on the shape extension to be available
2371 (XShapeCombineRegion). So, compute the rectangle to draw
2373 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2377 xgcv
.clip_mask
= s
->img
->mask
;
2378 xgcv
.clip_x_origin
= x
- s
->slice
.x
;
2379 xgcv
.clip_y_origin
= y
- s
->slice
.y
;
2380 xgcv
.function
= GXcopy
;
2381 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2383 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2384 s
->slice
.x
, s
->slice
.y
,
2385 s
->slice
.width
, s
->slice
.height
, x
, y
);
2386 XSetClipMask (s
->display
, s
->gc
, None
);
2390 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2391 s
->slice
.x
, s
->slice
.y
,
2392 s
->slice
.width
, s
->slice
.height
, x
, y
);
2394 /* When the image has a mask, we can expect that at
2395 least part of a mouse highlight or a block cursor will
2396 be visible. If the image doesn't have a mask, make
2397 a block cursor visible by drawing a rectangle around
2398 the image. I believe it's looking better if we do
2399 nothing here for mouse-face. */
2400 if (s
->hl
== DRAW_CURSOR
)
2402 int r
= s
->img
->relief
;
2404 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
- r
, y
- r
,
2405 s
->slice
.width
+ r
*2 - 1,
2406 s
->slice
.height
+ r
*2 - 1);
2411 /* Draw a rectangle if image could not be loaded. */
2412 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
2413 s
->slice
.width
- 1, s
->slice
.height
- 1);
2417 /* Draw part of the background of glyph string S. X, Y, W, and H
2418 give the rectangle to draw. */
2421 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
2422 struct glyph_string
*s
;
2427 /* Fill background with a stipple pattern. */
2428 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2429 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2430 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2433 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2437 /* Draw image glyph string S.
2440 s->x +-------------------------
2443 | +-------------------------
2446 | | +-------------------
2452 x_draw_image_glyph_string (s
)
2453 struct glyph_string
*s
;
2455 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
2456 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2458 Pixmap pixmap
= None
;
2461 if (s
->slice
.y
== 0)
2462 height
-= box_line_vwidth
;
2463 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
2464 height
-= box_line_vwidth
;
2466 /* Fill background with face under the image. Do it only if row is
2467 taller than image or if image has a clip mask to reduce
2469 s
->stippled_p
= s
->face
->stipple
!= 0;
2470 if (height
> s
->slice
.height
2474 || s
->img
->pixmap
== 0
2475 || s
->width
!= s
->background_width
)
2479 /* Create a pixmap as large as the glyph string. Fill it
2480 with the background color. Copy the image to it, using
2481 its mask. Copy the temporary pixmap to the display. */
2482 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2483 int depth
= DefaultDepthOfScreen (screen
);
2485 /* Create a pixmap as large as the glyph string. */
2486 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2487 s
->background_width
,
2490 /* Don't clip in the following because we're working on the
2492 XSetClipMask (s
->display
, s
->gc
, None
);
2494 /* Fill the pixmap with the background color/stipple. */
2497 /* Fill background with a stipple pattern. */
2498 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2499 XSetTSOrigin (s
->display
, s
->gc
, - s
->x
, - s
->y
);
2500 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2501 0, 0, s
->background_width
, s
->height
);
2502 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2503 XSetTSOrigin (s
->display
, s
->gc
, 0, 0);
2508 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2510 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2511 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2512 0, 0, s
->background_width
, s
->height
);
2513 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2521 if (s
->first_glyph
->left_box_line_p
2523 x
+= box_line_hwidth
;
2525 if (s
->slice
.y
== 0)
2526 y
+= box_line_vwidth
;
2528 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
2531 s
->background_filled_p
= 1;
2534 /* Draw the foreground. */
2537 x_draw_image_foreground_1 (s
, pixmap
);
2538 x_set_glyph_string_clipping (s
);
2539 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
2540 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
2541 XFreePixmap (s
->display
, pixmap
);
2544 x_draw_image_foreground (s
);
2546 /* If we must draw a relief around the image, do it. */
2548 || s
->hl
== DRAW_IMAGE_RAISED
2549 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2550 x_draw_image_relief (s
);
2554 /* Draw stretch glyph string S. */
2557 x_draw_stretch_glyph_string (s
)
2558 struct glyph_string
*s
;
2560 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2562 if (s
->hl
== DRAW_CURSOR
2563 && !x_stretch_cursor_p
)
2565 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
2566 as wide as the stretch glyph. */
2567 int width
, background_width
= s
->background_width
;
2568 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2572 background_width
-= left_x
- x
;
2575 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
2578 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
2580 /* Clear rest using the GC of the original non-cursor face. */
2581 if (width
< background_width
)
2584 int w
= background_width
- width
, h
= s
->height
;
2589 if (s
->row
->mouse_face_p
2590 && cursor_in_mouse_face_p (s
->w
))
2592 x_set_mouse_face_gc (s
);
2598 get_glyph_string_clip_rect (s
, &r
);
2599 XSetClipRectangles (s
->display
, gc
, 0, 0, &r
, 1, Unsorted
);
2601 if (s
->face
->stipple
)
2603 /* Fill background with a stipple pattern. */
2604 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2605 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2606 XSetFillStyle (s
->display
, gc
, FillSolid
);
2611 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
2612 XSetForeground (s
->display
, gc
, xgcv
.background
);
2613 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2614 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
2618 else if (!s
->background_filled_p
)
2620 int background_width
= s
->background_width
;
2621 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2623 /* Don't draw into left margin, fringe or scrollbar area
2624 except for header line and mode line. */
2625 if (x
< left_x
&& !s
->row
->mode_line_p
)
2627 background_width
-= left_x
- x
;
2630 if (background_width
> 0)
2631 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2634 s
->background_filled_p
= 1;
2638 /* Draw glyph string S. */
2641 x_draw_glyph_string (s
)
2642 struct glyph_string
*s
;
2644 int relief_drawn_p
= 0;
2646 /* If S draws into the background of its successors, draw the
2647 background of the successors first so that S can draw into it.
2648 This makes S->next use XDrawString instead of XDrawImageString. */
2649 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2652 struct glyph_string
*next
;
2654 for (width
= 0, next
= s
->next
; next
;
2655 width
+= next
->width
, next
= next
->next
)
2656 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
2658 x_set_glyph_string_gc (next
);
2659 x_set_glyph_string_clipping (next
);
2660 x_draw_glyph_string_background (next
, 1);
2661 next
->num_clips
= 0;
2665 /* Set up S->gc, set clipping and draw S. */
2666 x_set_glyph_string_gc (s
);
2668 /* Draw relief (if any) in advance for char/composition so that the
2669 glyph string can be drawn over it. */
2670 if (!s
->for_overlaps
2671 && s
->face
->box
!= FACE_NO_BOX
2672 && (s
->first_glyph
->type
== CHAR_GLYPH
2673 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2676 x_set_glyph_string_clipping (s
);
2677 x_draw_glyph_string_background (s
, 1);
2678 x_draw_glyph_string_box (s
);
2679 x_set_glyph_string_clipping (s
);
2682 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
2684 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2685 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
2686 /* We must clip just this glyph. left_overhang part has already
2687 drawn when s->prev was drawn, and right_overhang part will be
2688 drawn later when s->next is drawn. */
2689 x_set_glyph_string_clipping_exactly (s
, s
);
2691 x_set_glyph_string_clipping (s
);
2693 switch (s
->first_glyph
->type
)
2696 x_draw_image_glyph_string (s
);
2700 x_draw_stretch_glyph_string (s
);
2704 if (s
->for_overlaps
)
2705 s
->background_filled_p
= 1;
2707 x_draw_glyph_string_background (s
, 0);
2708 x_draw_glyph_string_foreground (s
);
2711 case COMPOSITE_GLYPH
:
2712 if (s
->for_overlaps
|| (s
->cmp_from
> 0
2713 && ! s
->first_glyph
->u
.cmp
.automatic
))
2714 s
->background_filled_p
= 1;
2716 x_draw_glyph_string_background (s
, 1);
2717 x_draw_composite_glyph_string_foreground (s
);
2724 if (!s
->for_overlaps
)
2726 /* Draw underline. */
2727 if (s
->face
->underline_p
)
2729 unsigned long thickness
, position
;
2732 if (s
->prev
&& s
->prev
->face
->underline_p
)
2734 /* We use the same underline style as the previous one. */
2735 thickness
= s
->prev
->underline_thickness
;
2736 position
= s
->prev
->underline_position
;
2740 /* Get the underline thickness. Default is 1 pixel. */
2741 if (s
->font
&& s
->font
->underline_thickness
> 0)
2742 thickness
= s
->font
->underline_thickness
;
2745 if (x_underline_at_descent_line
)
2746 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
2749 /* Get the underline position. This is the recommended
2750 vertical offset in pixels from the baseline to the top of
2751 the underline. This is a signed value according to the
2752 specs, and its default is
2754 ROUND ((maximum descent) / 2), with
2755 ROUND(x) = floor (x + 0.5) */
2757 if (x_use_underline_position_properties
2758 && s
->font
&& s
->font
->underline_position
>= 0)
2759 position
= s
->font
->underline_position
;
2761 position
= (s
->font
->descent
+ 1) / 2;
2763 position
= max (position
, underline_minimum_offset
);
2765 /* Check the sanity of thickness and position. We should
2766 avoid drawing underline out of the current line area. */
2767 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
2768 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
2769 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
2770 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
2771 s
->underline_thickness
= thickness
;
2772 s
->underline_position
= position
;
2773 y
= s
->ybase
+ position
;
2774 if (s
->face
->underline_defaulted_p
)
2775 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2776 s
->x
, y
, s
->background_width
, thickness
);
2780 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2781 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
2782 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2783 s
->x
, y
, s
->background_width
, thickness
);
2784 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2788 /* Draw overline. */
2789 if (s
->face
->overline_p
)
2791 unsigned long dy
= 0, h
= 1;
2793 if (s
->face
->overline_color_defaulted_p
)
2794 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2795 s
->background_width
, h
);
2799 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2800 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
2801 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2802 s
->background_width
, h
);
2803 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2807 /* Draw strike-through. */
2808 if (s
->face
->strike_through_p
)
2810 unsigned long h
= 1;
2811 unsigned long dy
= (s
->height
- h
) / 2;
2813 if (s
->face
->strike_through_color_defaulted_p
)
2814 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2819 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2820 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
2821 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2823 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2827 /* Draw relief if not yet drawn. */
2828 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2829 x_draw_glyph_string_box (s
);
2833 struct glyph_string
*prev
;
2835 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2836 if (prev
->hl
!= s
->hl
2837 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2839 /* As prev was drawn while clipped to its own area, we
2840 must draw the right_overhang part using s->hl now. */
2841 enum draw_glyphs_face save
= prev
->hl
;
2844 x_set_glyph_string_gc (prev
);
2845 x_set_glyph_string_clipping_exactly (s
, prev
);
2846 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2847 x_draw_glyph_string_foreground (prev
);
2849 x_draw_composite_glyph_string_foreground (prev
);
2850 XSetClipMask (prev
->display
, prev
->gc
, None
);
2852 prev
->num_clips
= 0;
2858 struct glyph_string
*next
;
2860 for (next
= s
->next
; next
; next
= next
->next
)
2861 if (next
->hl
!= s
->hl
2862 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
2864 /* As next will be drawn while clipped to its own area,
2865 we must draw the left_overhang part using s->hl now. */
2866 enum draw_glyphs_face save
= next
->hl
;
2869 x_set_glyph_string_gc (next
);
2870 x_set_glyph_string_clipping_exactly (s
, next
);
2871 if (next
->first_glyph
->type
== CHAR_GLYPH
)
2872 x_draw_glyph_string_foreground (next
);
2874 x_draw_composite_glyph_string_foreground (next
);
2875 XSetClipMask (next
->display
, next
->gc
, None
);
2877 next
->num_clips
= 0;
2882 /* Reset clipping. */
2883 XSetClipMask (s
->display
, s
->gc
, None
);
2887 /* Shift display to make room for inserted glyphs. */
2890 x_shift_glyphs_for_insert (f
, x
, y
, width
, height
, shift_by
)
2892 int x
, y
, width
, height
, shift_by
;
2894 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
2895 f
->output_data
.x
->normal_gc
,
2896 x
, y
, width
, height
,
2900 /* Delete N glyphs at the nominal cursor position. Not implemented
2904 x_delete_glyphs (f
, n
)
2912 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
2913 If they are <= 0, this is probably an error. */
2916 x_clear_area (dpy
, window
, x
, y
, width
, height
, exposures
)
2923 xassert (width
> 0 && height
> 0);
2924 XClearArea (dpy
, window
, x
, y
, width
, height
, exposures
);
2928 /* Clear an entire frame. */
2931 x_clear_frame (struct frame
*f
)
2933 /* Clearing the frame will erase any cursor, so mark them all as no
2935 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2936 output_cursor
.hpos
= output_cursor
.vpos
= 0;
2937 output_cursor
.x
= -1;
2939 /* We don't set the output cursor here because there will always
2940 follow an explicit cursor_to. */
2942 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
2944 /* We have to clear the scroll bars, too. If we have changed
2945 colors or something like that, then they should be notified. */
2946 x_scroll_bar_clear (f
);
2948 XFlush (FRAME_X_DISPLAY (f
));
2955 /* Invert the middle quarter of the frame for .15 sec. */
2957 /* We use the select system call to do the waiting, so we have to make
2958 sure it's available. If it isn't, we just won't do visual bells. */
2960 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
2963 /* Subtract the `struct timeval' values X and Y, storing the result in
2964 *RESULT. Return 1 if the difference is negative, otherwise 0. */
2967 timeval_subtract (result
, x
, y
)
2968 struct timeval
*result
, x
, y
;
2970 /* Perform the carry for the later subtraction by updating y. This
2971 is safer because on some systems the tv_sec member is unsigned. */
2972 if (x
.tv_usec
< y
.tv_usec
)
2974 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
2975 y
.tv_usec
-= 1000000 * nsec
;
2979 if (x
.tv_usec
- y
.tv_usec
> 1000000)
2981 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
2982 y
.tv_usec
+= 1000000 * nsec
;
2986 /* Compute the time remaining to wait. tv_usec is certainly
2988 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
2989 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
2991 /* Return indication of whether the result should be considered
2993 return x
.tv_sec
< y
.tv_sec
;
3005 /* Create a GC that will use the GXxor function to flip foreground
3006 pixels into background pixels. */
3010 values
.function
= GXxor
;
3011 values
.foreground
= (FRAME_FOREGROUND_PIXEL (f
)
3012 ^ FRAME_BACKGROUND_PIXEL (f
));
3014 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3015 GCFunction
| GCForeground
, &values
);
3019 /* Get the height not including a menu bar widget. */
3020 int height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, FRAME_LINES (f
));
3021 /* Height of each line to flash. */
3022 int flash_height
= FRAME_LINE_HEIGHT (f
);
3023 /* These will be the left and right margins of the rectangles. */
3024 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
3025 int flash_right
= FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
3029 /* Don't flash the area between a scroll bar and the frame
3030 edge it is next to. */
3031 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f
))
3033 case vertical_scroll_bar_left
:
3034 flash_left
+= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
3037 case vertical_scroll_bar_right
:
3038 flash_right
-= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
3045 width
= flash_right
- flash_left
;
3047 /* If window is tall, flash top and bottom line. */
3048 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3050 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3052 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3053 + FRAME_TOOL_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
)),
3054 width
, flash_height
);
3055 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3057 (height
- flash_height
3058 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3059 width
, flash_height
);
3062 /* If it is short, flash it all. */
3063 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3064 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3065 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3070 struct timeval wakeup
;
3072 EMACS_GET_TIME (wakeup
);
3074 /* Compute time to wait until, propagating carry from usecs. */
3075 wakeup
.tv_usec
+= 150000;
3076 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
3077 wakeup
.tv_usec
%= 1000000;
3079 /* Keep waiting until past the time wakeup or any input gets
3081 while (! detect_input_pending ())
3083 struct timeval current
;
3084 struct timeval timeout
;
3086 EMACS_GET_TIME (current
);
3088 /* Break if result would be negative. */
3089 if (timeval_subtract (¤t
, wakeup
, current
))
3092 /* How long `select' should wait. */
3094 timeout
.tv_usec
= 10000;
3096 /* Try to wait that long--but we might wake up sooner. */
3097 select (0, NULL
, NULL
, NULL
, &timeout
);
3101 /* If window is tall, flash top and bottom line. */
3102 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3104 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3106 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3107 + FRAME_TOOL_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
)),
3108 width
, flash_height
);
3109 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3111 (height
- flash_height
3112 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3113 width
, flash_height
);
3116 /* If it is short, flash it all. */
3117 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3118 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3119 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3121 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
3129 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
3132 /* Make audible bell. */
3137 struct frame
*f
= SELECTED_FRAME ();
3139 if (FRAME_X_DISPLAY (f
))
3141 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
3148 XBell (FRAME_X_DISPLAY (f
), 0);
3149 XFlush (FRAME_X_DISPLAY (f
));
3156 /* Specify how many text lines, from the top of the window,
3157 should be affected by insert-lines and delete-lines operations.
3158 This, and those operations, are used only within an update
3159 that is bounded by calls to x_update_begin and x_update_end. */
3162 XTset_terminal_window (n
)
3165 /* This function intentionally left blank. */
3170 /***********************************************************************
3172 ***********************************************************************/
3174 /* Perform an insert-lines or delete-lines operation, inserting N
3175 lines or deleting -N lines at vertical position VPOS. */
3178 x_ins_del_lines (f
, vpos
, n
)
3186 /* Scroll part of the display as described by RUN. */
3189 x_scroll_run (w
, run
)
3193 struct frame
*f
= XFRAME (w
->frame
);
3194 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
3196 /* Get frame-relative bounding box of the text display area of W,
3197 without mode lines. Include in this box the left and right
3199 window_box (w
, -1, &x
, &y
, &width
, &height
);
3201 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
3202 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
3203 bottom_y
= y
+ height
;
3207 /* Scrolling up. Make sure we don't copy part of the mode
3208 line at the bottom. */
3209 if (from_y
+ run
->height
> bottom_y
)
3210 height
= bottom_y
- from_y
;
3212 height
= run
->height
;
3216 /* Scolling down. Make sure we don't copy over the mode line.
3218 if (to_y
+ run
->height
> bottom_y
)
3219 height
= bottom_y
- to_y
;
3221 height
= run
->height
;
3226 /* Cursor off. Will be switched on again in x_update_window_end. */
3230 XCopyArea (FRAME_X_DISPLAY (f
),
3231 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
3232 f
->output_data
.x
->normal_gc
,
3242 /***********************************************************************
3244 ***********************************************************************/
3251 /* We used to only do this if Vx_no_window_manager was non-nil, but
3252 the ICCCM (section 4.1.6) says that the window's border pixmap
3253 and border pixel are window attributes which are "private to the
3254 client", so we can always change it to whatever we want. */
3256 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3257 f
->output_data
.x
->border_pixel
);
3259 x_update_cursor (f
, 1);
3260 x_set_frame_alpha (f
);
3264 frame_unhighlight (f
)
3267 /* We used to only do this if Vx_no_window_manager was non-nil, but
3268 the ICCCM (section 4.1.6) says that the window's border pixmap
3269 and border pixel are window attributes which are "private to the
3270 client", so we can always change it to whatever we want. */
3272 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3273 f
->output_data
.x
->border_tile
);
3275 x_update_cursor (f
, 1);
3276 x_set_frame_alpha (f
);
3279 /* The focus has changed. Update the frames as necessary to reflect
3280 the new situation. Note that we can't change the selected frame
3281 here, because the Lisp code we are interrupting might become confused.
3282 Each event gets marked with the frame in which it occurred, so the
3283 Lisp code can tell when the switch took place by examining the events. */
3286 x_new_focus_frame (dpyinfo
, frame
)
3287 struct x_display_info
*dpyinfo
;
3288 struct frame
*frame
;
3290 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
3292 if (frame
!= dpyinfo
->x_focus_frame
)
3294 /* Set this before calling other routines, so that they see
3295 the correct value of x_focus_frame. */
3296 dpyinfo
->x_focus_frame
= frame
;
3298 if (old_focus
&& old_focus
->auto_lower
)
3299 x_lower_frame (old_focus
);
3302 selected_frame
= frame
;
3303 XSETFRAME (XWINDOW (selected_frame
->selected_window
)->frame
,
3305 Fselect_window (selected_frame
->selected_window
, Qnil
);
3306 choose_minibuf_frame ();
3309 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
3310 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
3312 pending_autoraise_frame
= 0;
3315 x_frame_rehighlight (dpyinfo
);
3318 /* Handle FocusIn and FocusOut state changes for FRAME.
3319 If FRAME has focus and there exists more than one frame, puts
3320 a FOCUS_IN_EVENT into *BUFP. */
3323 x_focus_changed (type
, state
, dpyinfo
, frame
, bufp
)
3326 struct x_display_info
*dpyinfo
;
3327 struct frame
*frame
;
3328 struct input_event
*bufp
;
3330 if (type
== FocusIn
)
3332 if (dpyinfo
->x_focus_event_frame
!= frame
)
3334 x_new_focus_frame (dpyinfo
, frame
);
3335 dpyinfo
->x_focus_event_frame
= frame
;
3337 /* Don't stop displaying the initial startup message
3338 for a switch-frame event we don't need. */
3339 if (NILP (Vterminal_frame
)
3340 && CONSP (Vframe_list
)
3341 && !NILP (XCDR (Vframe_list
)))
3343 bufp
->kind
= FOCUS_IN_EVENT
;
3344 XSETFRAME (bufp
->frame_or_window
, frame
);
3348 frame
->output_data
.x
->focus_state
|= state
;
3351 if (FRAME_XIC (frame
))
3352 XSetICFocus (FRAME_XIC (frame
));
3355 else if (type
== FocusOut
)
3357 frame
->output_data
.x
->focus_state
&= ~state
;
3359 if (dpyinfo
->x_focus_event_frame
== frame
)
3361 dpyinfo
->x_focus_event_frame
= 0;
3362 x_new_focus_frame (dpyinfo
, 0);
3366 if (FRAME_XIC (frame
))
3367 XUnsetICFocus (FRAME_XIC (frame
));
3372 /* The focus may have changed. Figure out if it is a real focus change,
3373 by checking both FocusIn/Out and Enter/LeaveNotify events.
3375 Returns FOCUS_IN_EVENT event in *BUFP. */
3378 x_detect_focus_change (dpyinfo
, event
, bufp
)
3379 struct x_display_info
*dpyinfo
;
3381 struct input_event
*bufp
;
3383 struct frame
*frame
;
3385 frame
= x_any_window_to_frame (dpyinfo
, event
->xany
.window
);
3389 switch (event
->type
)
3394 struct frame
*focus_frame
= dpyinfo
->x_focus_event_frame
;
3396 = focus_frame
? focus_frame
->output_data
.x
->focus_state
: 0;
3398 if (event
->xcrossing
.detail
!= NotifyInferior
3399 && event
->xcrossing
.focus
3400 && ! (focus_state
& FOCUS_EXPLICIT
))
3401 x_focus_changed ((event
->type
== EnterNotify
? FocusIn
: FocusOut
),
3403 dpyinfo
, frame
, bufp
);
3409 x_focus_changed (event
->type
,
3410 (event
->xfocus
.detail
== NotifyPointer
?
3411 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
3412 dpyinfo
, frame
, bufp
);
3416 if (event
->xclient
.message_type
== dpyinfo
->Xatom_XEMBED
)
3418 enum xembed_message msg
= event
->xclient
.data
.l
[1];
3419 x_focus_changed ((msg
== XEMBED_FOCUS_IN
? FocusIn
: FocusOut
),
3420 FOCUS_EXPLICIT
, dpyinfo
, frame
, bufp
);
3427 /* Handle an event saying the mouse has moved out of an Emacs frame. */
3430 x_mouse_leave (dpyinfo
)
3431 struct x_display_info
*dpyinfo
;
3433 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
3436 /* The focus has changed, or we have redirected a frame's focus to
3437 another frame (this happens when a frame uses a surrogate
3438 mini-buffer frame). Shift the highlight as appropriate.
3440 The FRAME argument doesn't necessarily have anything to do with which
3441 frame is being highlighted or un-highlighted; we only use it to find
3442 the appropriate X display info. */
3445 XTframe_rehighlight (frame
)
3446 struct frame
*frame
;
3448 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
3452 x_frame_rehighlight (dpyinfo
)
3453 struct x_display_info
*dpyinfo
;
3455 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
3457 if (dpyinfo
->x_focus_frame
)
3459 dpyinfo
->x_highlight_frame
3460 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
3461 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
3462 : dpyinfo
->x_focus_frame
);
3463 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
3465 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
3466 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
3470 dpyinfo
->x_highlight_frame
= 0;
3472 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
3475 frame_unhighlight (old_highlight
);
3476 if (dpyinfo
->x_highlight_frame
)
3477 frame_highlight (dpyinfo
->x_highlight_frame
);
3483 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
3485 /* Initialize mode_switch_bit and modifier_meaning. */
3487 x_find_modifier_meanings (dpyinfo
)
3488 struct x_display_info
*dpyinfo
;
3490 int min_code
, max_code
;
3493 XModifierKeymap
*mods
;
3495 dpyinfo
->meta_mod_mask
= 0;
3496 dpyinfo
->shift_lock_mask
= 0;
3497 dpyinfo
->alt_mod_mask
= 0;
3498 dpyinfo
->super_mod_mask
= 0;
3499 dpyinfo
->hyper_mod_mask
= 0;
3501 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
3503 syms
= XGetKeyboardMapping (dpyinfo
->display
,
3504 min_code
, max_code
- min_code
+ 1,
3506 mods
= XGetModifierMapping (dpyinfo
->display
);
3508 /* Scan the modifier table to see which modifier bits the Meta and
3509 Alt keysyms are on. */
3511 int row
, col
; /* The row and column in the modifier table. */
3512 int found_alt_or_meta
;
3514 for (row
= 3; row
< 8; row
++)
3516 found_alt_or_meta
= 0;
3517 for (col
= 0; col
< mods
->max_keypermod
; col
++)
3519 KeyCode code
= mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
3521 /* Zeroes are used for filler. Skip them. */
3525 /* Are any of this keycode's keysyms a meta key? */
3529 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
3531 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
3537 found_alt_or_meta
= 1;
3538 dpyinfo
->meta_mod_mask
|= (1 << row
);
3543 found_alt_or_meta
= 1;
3544 dpyinfo
->alt_mod_mask
|= (1 << row
);
3549 if (!found_alt_or_meta
)
3550 dpyinfo
->hyper_mod_mask
|= (1 << row
);
3551 code_col
= syms_per_code
;
3552 col
= mods
->max_keypermod
;
3557 if (!found_alt_or_meta
)
3558 dpyinfo
->super_mod_mask
|= (1 << row
);
3559 code_col
= syms_per_code
;
3560 col
= mods
->max_keypermod
;
3564 /* Ignore this if it's not on the lock modifier. */
3565 if (!found_alt_or_meta
&& ((1 << row
) == LockMask
))
3566 dpyinfo
->shift_lock_mask
= LockMask
;
3567 code_col
= syms_per_code
;
3568 col
= mods
->max_keypermod
;
3577 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
3578 if (! dpyinfo
->meta_mod_mask
)
3580 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
3581 dpyinfo
->alt_mod_mask
= 0;
3584 /* If some keys are both alt and meta,
3585 make them just meta, not alt. */
3586 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
3588 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
3591 XFree ((char *) syms
);
3592 XFreeModifiermap (mods
);
3595 /* Convert between the modifier bits X uses and the modifier bits
3599 x_x_to_emacs_modifiers (dpyinfo
, state
)
3600 struct x_display_info
*dpyinfo
;
3603 EMACS_UINT mod_meta
= meta_modifier
;
3604 EMACS_UINT mod_alt
= alt_modifier
;
3605 EMACS_UINT mod_hyper
= hyper_modifier
;
3606 EMACS_UINT mod_super
= super_modifier
;
3609 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3610 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
3611 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3612 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
3613 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3614 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
3615 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3616 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
3619 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
3620 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
3621 | ((state
& dpyinfo
->meta_mod_mask
) ? mod_meta
: 0)
3622 | ((state
& dpyinfo
->alt_mod_mask
) ? mod_alt
: 0)
3623 | ((state
& dpyinfo
->super_mod_mask
) ? mod_super
: 0)
3624 | ((state
& dpyinfo
->hyper_mod_mask
) ? mod_hyper
: 0));
3628 x_emacs_to_x_modifiers (dpyinfo
, state
)
3629 struct x_display_info
*dpyinfo
;
3632 EMACS_UINT mod_meta
= meta_modifier
;
3633 EMACS_UINT mod_alt
= alt_modifier
;
3634 EMACS_UINT mod_hyper
= hyper_modifier
;
3635 EMACS_UINT mod_super
= super_modifier
;
3639 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3640 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
3641 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3642 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
3643 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3644 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
3645 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3646 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
3649 return ( ((state
& mod_alt
) ? dpyinfo
->alt_mod_mask
: 0)
3650 | ((state
& mod_super
) ? dpyinfo
->super_mod_mask
: 0)
3651 | ((state
& mod_hyper
) ? dpyinfo
->hyper_mod_mask
: 0)
3652 | ((state
& shift_modifier
) ? ShiftMask
: 0)
3653 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
3654 | ((state
& mod_meta
) ? dpyinfo
->meta_mod_mask
: 0));
3657 /* Convert a keysym to its name. */
3660 x_get_keysym_name (keysym
)
3666 value
= XKeysymToString (keysym
);
3674 /* Mouse clicks and mouse movement. Rah. */
3676 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3678 If the event is a button press, then note that we have grabbed
3682 construct_mouse_click (result
, event
, f
)
3683 struct input_event
*result
;
3684 XButtonEvent
*event
;
3687 /* Make the event type NO_EVENT; we'll change that when we decide
3689 result
->kind
= MOUSE_CLICK_EVENT
;
3690 result
->code
= event
->button
- Button1
;
3691 result
->timestamp
= event
->time
;
3692 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
3694 | (event
->type
== ButtonRelease
3698 XSETINT (result
->x
, event
->x
);
3699 XSETINT (result
->y
, event
->y
);
3700 XSETFRAME (result
->frame_or_window
, f
);
3706 /* Function to report a mouse movement to the mainstream Emacs code.
3707 The input handler calls this.
3709 We have received a mouse movement event, which is given in *event.
3710 If the mouse is over a different glyph than it was last time, tell
3711 the mainstream emacs code by setting mouse_moved. If not, ask for
3712 another motion event, so we can check again the next time it moves. */
3714 static XMotionEvent last_mouse_motion_event
;
3715 static Lisp_Object last_mouse_motion_frame
;
3718 note_mouse_movement (frame
, event
)
3720 XMotionEvent
*event
;
3722 last_mouse_movement_time
= event
->time
;
3723 last_mouse_motion_event
= *event
;
3724 XSETFRAME (last_mouse_motion_frame
, frame
);
3726 if (!FRAME_X_OUTPUT (frame
))
3729 if (event
->window
!= FRAME_X_WINDOW (frame
))
3731 frame
->mouse_moved
= 1;
3732 last_mouse_scroll_bar
= Qnil
;
3733 note_mouse_highlight (frame
, -1, -1);
3734 last_mouse_glyph_frame
= 0;
3739 /* Has the mouse moved off the glyph it was on at the last sighting? */
3740 if (frame
!= last_mouse_glyph_frame
3741 || event
->x
< last_mouse_glyph
.x
3742 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
3743 || event
->y
< last_mouse_glyph
.y
3744 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
3746 frame
->mouse_moved
= 1;
3747 last_mouse_scroll_bar
= Qnil
;
3748 note_mouse_highlight (frame
, event
->x
, event
->y
);
3749 /* Remember which glyph we're now on. */
3750 remember_mouse_glyph (frame
, event
->x
, event
->y
, &last_mouse_glyph
);
3751 last_mouse_glyph_frame
= frame
;
3759 /************************************************************************
3761 ************************************************************************/
3764 redo_mouse_highlight ()
3766 if (!NILP (last_mouse_motion_frame
)
3767 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
3768 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
3769 last_mouse_motion_event
.x
,
3770 last_mouse_motion_event
.y
);
3775 /* Return the current position of the mouse.
3776 *FP should be a frame which indicates which display to ask about.
3778 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
3779 and *PART to the frame, window, and scroll bar part that the mouse
3780 is over. Set *X and *Y to the portion and whole of the mouse's
3781 position on the scroll bar.
3783 If the mouse movement started elsewhere, set *FP to the frame the
3784 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
3787 Set *TIME to the server time-stamp for the time at which the mouse
3788 was at this position.
3790 Don't store anything if we don't have a valid set of values to report.
3792 This clears the mouse_moved flag, so we can wait for the next mouse
3796 XTmouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
3799 Lisp_Object
*bar_window
;
3800 enum scroll_bar_part
*part
;
3802 unsigned long *time
;
3808 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
3809 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3815 Window dummy_window
;
3818 Lisp_Object frame
, tail
;
3820 /* Clear the mouse-moved flag for every frame on this display. */
3821 FOR_EACH_FRAME (tail
, frame
)
3822 if (FRAME_X_P (XFRAME (frame
))
3823 && FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
3824 XFRAME (frame
)->mouse_moved
= 0;
3826 last_mouse_scroll_bar
= Qnil
;
3828 /* Figure out which root window we're on. */
3829 XQueryPointer (FRAME_X_DISPLAY (*fp
),
3830 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
3832 /* The root window which contains the pointer. */
3835 /* Trash which we can't trust if the pointer is on
3836 a different screen. */
3839 /* The position on that root window. */
3842 /* More trash we can't trust. */
3845 /* Modifier keys and pointer buttons, about which
3847 (unsigned int *) &dummy
);
3849 /* Now we have a position on the root; find the innermost window
3850 containing the pointer. */
3854 int parent_x
= 0, parent_y
= 0;
3858 /* XTranslateCoordinates can get errors if the window
3859 structure is changing at the same time this function
3860 is running. So at least we must not crash from them. */
3862 x_catch_errors (FRAME_X_DISPLAY (*fp
));
3864 if (FRAME_X_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
3865 && FRAME_LIVE_P (last_mouse_frame
))
3867 /* If mouse was grabbed on a frame, give coords for that frame
3868 even if the mouse is now outside it. */
3869 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3871 /* From-window, to-window. */
3872 root
, FRAME_X_WINDOW (last_mouse_frame
),
3874 /* From-position, to-position. */
3875 root_x
, root_y
, &win_x
, &win_y
,
3879 f1
= last_mouse_frame
;
3885 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3887 /* From-window, to-window. */
3890 /* From-position, to-position. */
3891 root_x
, root_y
, &win_x
, &win_y
,
3896 if (child
== None
|| child
== win
)
3904 /* Now we know that:
3905 win is the innermost window containing the pointer
3906 (XTC says it has no child containing the pointer),
3907 win_x and win_y are the pointer's position in it
3908 (XTC did this the last time through), and
3909 parent_x and parent_y are the pointer's position in win's parent.
3910 (They are what win_x and win_y were when win was child.
3911 If win is the root window, it has no parent, and
3912 parent_{x,y} are invalid, but that's okay, because we'll
3913 never use them in that case.) */
3915 /* Is win one of our frames? */
3916 f1
= x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
3918 #ifdef USE_X_TOOLKIT
3919 /* If we end up with the menu bar window, say it's not
3922 && f1
->output_data
.x
->menubar_widget
3923 && win
== XtWindow (f1
->output_data
.x
->menubar_widget
))
3925 #endif /* USE_X_TOOLKIT */
3928 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
3931 x_uncatch_errors ();
3933 /* If not, is it one of our scroll bars? */
3936 struct scroll_bar
*bar
;
3938 bar
= x_window_to_scroll_bar (FRAME_X_DISPLAY (*fp
), win
);
3942 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3948 if (f1
== 0 && insist
> 0)
3949 f1
= SELECTED_FRAME ();
3953 /* Ok, we found a frame. Store all the values.
3954 last_mouse_glyph is a rectangle used to reduce the
3955 generation of mouse events. To not miss any motion
3956 events, we must divide the frame into rectangles of the
3957 size of the smallest character that could be displayed
3958 on it, i.e. into the same rectangles that matrices on
3959 the frame are divided into. */
3961 remember_mouse_glyph (f1
, win_x
, win_y
, &last_mouse_glyph
);
3962 last_mouse_glyph_frame
= f1
;
3967 XSETINT (*x
, win_x
);
3968 XSETINT (*y
, win_y
);
3969 *time
= last_mouse_movement_time
;
3979 /***********************************************************************
3981 ***********************************************************************/
3983 /* Scroll bar support. */
3985 /* Given an X window ID and a DISPLAY, find the struct scroll_bar which
3987 This can be called in GC, so we have to make sure to strip off mark
3990 static struct scroll_bar
*
3991 x_window_to_scroll_bar (display
, window_id
)
3997 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
3998 window_id
= (Window
) xg_get_scroll_id_for_window (display
, window_id
);
3999 #endif /* USE_GTK && USE_TOOLKIT_SCROLL_BARS */
4001 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
4003 Lisp_Object frame
, bar
, condemned
;
4005 frame
= XCAR (tail
);
4006 /* All elements of Vframe_list should be frames. */
4007 if (! FRAMEP (frame
))
4010 if (! FRAME_X_P (XFRAME (frame
)))
4013 /* Scan this frame's scroll bar list for a scroll bar with the
4015 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
4016 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
4017 /* This trick allows us to search both the ordinary and
4018 condemned scroll bar lists with one loop. */
4019 ! NILP (bar
) || (bar
= condemned
,
4022 bar
= XSCROLL_BAR (bar
)->next
)
4023 if (XSCROLL_BAR (bar
)->x_window
== window_id
&&
4024 FRAME_X_DISPLAY (XFRAME (frame
)) == display
)
4025 return XSCROLL_BAR (bar
);
4032 #if defined USE_LUCID
4034 /* Return the Lucid menu bar WINDOW is part of. Return null
4035 if WINDOW is not part of a menu bar. */
4038 x_window_to_menu_bar (window
)
4043 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
4045 if (FRAME_X_P (XFRAME (XCAR (tail
))))
4047 Lisp_Object frame
= XCAR (tail
);
4048 Widget menu_bar
= XFRAME (frame
)->output_data
.x
->menubar_widget
;
4050 if (menu_bar
&& xlwmenu_window_p (menu_bar
, window
))
4058 #endif /* USE_LUCID */
4061 /************************************************************************
4063 ************************************************************************/
4065 #ifdef USE_TOOLKIT_SCROLL_BARS
4067 static void x_scroll_bar_to_input_event
P_ ((XEvent
*, struct input_event
*));
4068 static void x_send_scroll_bar_event
P_ ((Lisp_Object
, int, int, int));
4069 static void x_create_toolkit_scroll_bar
P_ ((struct frame
*,
4070 struct scroll_bar
*));
4071 static void x_set_toolkit_scroll_bar_thumb
P_ ((struct scroll_bar
*,
4075 /* Lisp window being scrolled. Set when starting to interact with
4076 a toolkit scroll bar, reset to nil when ending the interaction. */
4078 static Lisp_Object window_being_scrolled
;
4080 /* Last scroll bar part sent in xm_scroll_callback. */
4082 static int last_scroll_bar_part
;
4084 /* Whether this is an Xaw with arrow-scrollbars. This should imply
4085 that movements of 1/20 of the screen size are mapped to up/down. */
4088 /* Id of action hook installed for scroll bars. */
4090 static XtActionHookId action_hook_id
;
4092 static Boolean xaw3d_arrow_scroll
;
4094 /* Whether the drag scrolling maintains the mouse at the top of the
4095 thumb. If not, resizing the thumb needs to be done more carefully
4096 to avoid jerkyness. */
4098 static Boolean xaw3d_pick_top
;
4100 /* Action hook installed via XtAppAddActionHook when toolkit scroll
4101 bars are used.. The hook is responsible for detecting when
4102 the user ends an interaction with the scroll bar, and generates
4103 a `end-scroll' SCROLL_BAR_CLICK_EVENT' event if so. */
4106 xt_action_hook (widget
, client_data
, action_name
, event
, params
,
4109 XtPointer client_data
;
4113 Cardinal
*num_params
;
4119 scroll_bar_p
= XmIsScrollBar (widget
);
4120 end_action
= "Release";
4121 #else /* !USE_MOTIF i.e. use Xaw */
4122 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
4123 end_action
= "EndScroll";
4124 #endif /* USE_MOTIF */
4127 && strcmp (action_name
, end_action
) == 0
4128 && WINDOWP (window_being_scrolled
))
4132 x_send_scroll_bar_event (window_being_scrolled
,
4133 scroll_bar_end_scroll
, 0, 0);
4134 w
= XWINDOW (window_being_scrolled
);
4136 if (!NILP (XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
))
4138 XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
= Qnil
;
4139 /* The thumb size is incorrect while dragging: fix it. */
4140 set_vertical_scroll_bar (w
);
4142 window_being_scrolled
= Qnil
;
4143 last_scroll_bar_part
= -1;
4145 /* Xt timeouts no longer needed. */
4146 toolkit_scroll_bar_interaction
= 0;
4149 #endif /* not USE_GTK */
4151 /* A vector of windows used for communication between
4152 x_send_scroll_bar_event and x_scroll_bar_to_input_event. */
4154 static struct window
**scroll_bar_windows
;
4155 static int scroll_bar_windows_size
;
4158 /* Send a client message with message type Xatom_Scrollbar for a
4159 scroll action to the frame of WINDOW. PART is a value identifying
4160 the part of the scroll bar that was clicked on. PORTION is the
4161 amount to scroll of a whole of WHOLE. */
4164 x_send_scroll_bar_event (window
, part
, portion
, whole
)
4166 int part
, portion
, whole
;
4169 XClientMessageEvent
*ev
= (XClientMessageEvent
*) &event
;
4170 struct window
*w
= XWINDOW (window
);
4171 struct frame
*f
= XFRAME (w
->frame
);
4176 /* Construct a ClientMessage event to send to the frame. */
4177 ev
->type
= ClientMessage
;
4178 ev
->message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_Scrollbar
;
4179 ev
->display
= FRAME_X_DISPLAY (f
);
4180 ev
->window
= FRAME_X_WINDOW (f
);
4183 /* We can only transfer 32 bits in the XClientMessageEvent, which is
4184 not enough to store a pointer or Lisp_Object on a 64 bit system.
4185 So, store the window in scroll_bar_windows and pass the index
4186 into that array in the event. */
4187 for (i
= 0; i
< scroll_bar_windows_size
; ++i
)
4188 if (scroll_bar_windows
[i
] == NULL
)
4191 if (i
== scroll_bar_windows_size
)
4193 int new_size
= max (10, 2 * scroll_bar_windows_size
);
4194 size_t nbytes
= new_size
* sizeof *scroll_bar_windows
;
4195 size_t old_nbytes
= scroll_bar_windows_size
* sizeof *scroll_bar_windows
;
4197 scroll_bar_windows
= (struct window
**) xrealloc (scroll_bar_windows
,
4199 bzero (&scroll_bar_windows
[i
], nbytes
- old_nbytes
);
4200 scroll_bar_windows_size
= new_size
;
4203 scroll_bar_windows
[i
] = w
;
4204 ev
->data
.l
[0] = (long) i
;
4205 ev
->data
.l
[1] = (long) part
;
4206 ev
->data
.l
[2] = (long) 0;
4207 ev
->data
.l
[3] = (long) portion
;
4208 ev
->data
.l
[4] = (long) whole
;
4210 /* Make Xt timeouts work while the scroll bar is active. */
4211 toolkit_scroll_bar_interaction
= 1;
4212 #ifdef USE_X_TOOLKIT
4213 x_activate_timeout_atimer ();
4216 /* Setting the event mask to zero means that the message will
4217 be sent to the client that created the window, and if that
4218 window no longer exists, no event will be sent. */
4219 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
4224 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
4228 x_scroll_bar_to_input_event (event
, ievent
)
4230 struct input_event
*ievent
;
4232 XClientMessageEvent
*ev
= (XClientMessageEvent
*) event
;
4237 w
= scroll_bar_windows
[ev
->data
.l
[0]];
4238 scroll_bar_windows
[ev
->data
.l
[0]] = NULL
;
4240 XSETWINDOW (window
, w
);
4241 f
= XFRAME (w
->frame
);
4243 ievent
->kind
= SCROLL_BAR_CLICK_EVENT
;
4244 ievent
->frame_or_window
= window
;
4247 ievent
->timestamp
= CurrentTime
;
4249 ievent
->timestamp
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
4251 ievent
->part
= ev
->data
.l
[1];
4252 ievent
->code
= ev
->data
.l
[2];
4253 ievent
->x
= make_number ((int) ev
->data
.l
[3]);
4254 ievent
->y
= make_number ((int) ev
->data
.l
[4]);
4255 ievent
->modifiers
= 0;
4261 /* Minimum and maximum values used for Motif scroll bars. */
4263 #define XM_SB_MAX 10000000
4266 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
4267 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
4268 CALL_DATA is a pointer to a XmScrollBarCallbackStruct. */
4271 xm_scroll_callback (widget
, client_data
, call_data
)
4273 XtPointer client_data
, call_data
;
4275 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4276 XmScrollBarCallbackStruct
*cs
= (XmScrollBarCallbackStruct
*) call_data
;
4277 int part
= -1, whole
= 0, portion
= 0;
4281 case XmCR_DECREMENT
:
4282 bar
->dragging
= Qnil
;
4283 part
= scroll_bar_up_arrow
;
4286 case XmCR_INCREMENT
:
4287 bar
->dragging
= Qnil
;
4288 part
= scroll_bar_down_arrow
;
4291 case XmCR_PAGE_DECREMENT
:
4292 bar
->dragging
= Qnil
;
4293 part
= scroll_bar_above_handle
;
4296 case XmCR_PAGE_INCREMENT
:
4297 bar
->dragging
= Qnil
;
4298 part
= scroll_bar_below_handle
;
4302 bar
->dragging
= Qnil
;
4303 part
= scroll_bar_to_top
;
4306 case XmCR_TO_BOTTOM
:
4307 bar
->dragging
= Qnil
;
4308 part
= scroll_bar_to_bottom
;
4315 /* Get the slider size. */
4317 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
4320 whole
= XM_SB_MAX
- slider_size
;
4321 portion
= min (cs
->value
, whole
);
4322 part
= scroll_bar_handle
;
4323 bar
->dragging
= make_number (cs
->value
);
4327 case XmCR_VALUE_CHANGED
:
4333 window_being_scrolled
= bar
->window
;
4334 last_scroll_bar_part
= part
;
4335 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4339 #elif defined USE_GTK
4341 /* Scroll bar callback for GTK scroll bars. WIDGET is the scroll
4342 bar widget. DATA is a pointer to the scroll_bar structure. */
4345 xg_scroll_callback (widget
, data
)
4349 struct scroll_bar
*bar
= (struct scroll_bar
*) data
;
4355 int part
= -1, whole
= 0, portion
= 0;
4356 GtkAdjustment
*adj
= GTK_ADJUSTMENT (gtk_range_get_adjustment (widget
));
4358 position
= gtk_adjustment_get_value (adj
);
4360 p
= g_object_get_data (G_OBJECT (widget
), XG_LAST_SB_DATA
);
4363 p
= (gdouble
*) xmalloc (sizeof (gdouble
));
4365 g_object_set_data (G_OBJECT (widget
), XG_LAST_SB_DATA
, p
);
4371 if (xg_ignore_gtk_scrollbar
) return;
4373 diff
= (int) (position
- previous
);
4375 if (diff
== (int) adj
->step_increment
)
4377 part
= scroll_bar_down_arrow
;
4378 bar
->dragging
= Qnil
;
4380 else if (-diff
== (int) adj
->step_increment
)
4382 part
= scroll_bar_up_arrow
;
4383 bar
->dragging
= Qnil
;
4385 else if (diff
== (int) adj
->page_increment
)
4387 part
= scroll_bar_below_handle
;
4388 bar
->dragging
= Qnil
;
4390 else if (-diff
== (int) adj
->page_increment
)
4392 part
= scroll_bar_above_handle
;
4393 bar
->dragging
= Qnil
;
4397 part
= scroll_bar_handle
;
4398 whole
= adj
->upper
- adj
->page_size
;
4399 portion
= min ((int)position
, whole
);
4400 bar
->dragging
= make_number ((int)portion
);
4405 window_being_scrolled
= bar
->window
;
4406 last_scroll_bar_part
= part
;
4407 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4411 #else /* not USE_GTK and not USE_MOTIF */
4413 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
4414 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
4415 scroll bar struct. CALL_DATA is a pointer to a float saying where
4419 xaw_jump_callback (widget
, client_data
, call_data
)
4421 XtPointer client_data
, call_data
;
4423 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4424 float top
= *(float *) call_data
;
4426 int whole
, portion
, height
;
4429 /* Get the size of the thumb, a value between 0 and 1. */
4431 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
4435 portion
= shown
< 1 ? top
* whole
: 0;
4437 if (shown
< 1 && (eabs (top
+ shown
- 1) < 1.0/height
))
4438 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
4439 the bottom, so we force the scrolling whenever we see that we're
4440 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
4441 we try to ensure that we always stay two pixels away from the
4443 part
= scroll_bar_down_arrow
;
4445 part
= scroll_bar_handle
;
4447 window_being_scrolled
= bar
->window
;
4448 bar
->dragging
= make_number (portion
);
4449 last_scroll_bar_part
= part
;
4450 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4454 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
4455 i.e. line or page up or down. WIDGET is the Xaw scroll bar
4456 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
4457 the scroll bar. CALL_DATA is an integer specifying the action that
4458 has taken place. Its magnitude is in the range 0..height of the
4459 scroll bar. Negative values mean scroll towards buffer start.
4460 Values < height of scroll bar mean line-wise movement. */
4463 xaw_scroll_callback (widget
, client_data
, call_data
)
4465 XtPointer client_data
, call_data
;
4467 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4468 /* The position really is stored cast to a pointer. */
4469 int position
= (long) call_data
;
4473 /* Get the height of the scroll bar. */
4475 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
4478 if (eabs (position
) >= height
)
4479 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
4481 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
4482 it maps line-movement to call_data = max(5, height/20). */
4483 else if (xaw3d_arrow_scroll
&& eabs (position
) <= max (5, height
/ 20))
4484 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
4486 part
= scroll_bar_move_ratio
;
4488 window_being_scrolled
= bar
->window
;
4489 bar
->dragging
= Qnil
;
4490 last_scroll_bar_part
= part
;
4491 x_send_scroll_bar_event (bar
->window
, part
, position
, height
);
4494 #endif /* not USE_GTK and not USE_MOTIF */
4496 #define SCROLL_BAR_NAME "verticalScrollBar"
4498 /* Create the widget for scroll bar BAR on frame F. Record the widget
4499 and X window of the scroll bar in BAR. */
4503 x_create_toolkit_scroll_bar (f
, bar
)
4505 struct scroll_bar
*bar
;
4507 char *scroll_bar_name
= SCROLL_BAR_NAME
;
4510 xg_create_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
4515 #else /* not USE_GTK */
4518 x_create_toolkit_scroll_bar (f
, bar
)
4520 struct scroll_bar
*bar
;
4526 char *scroll_bar_name
= SCROLL_BAR_NAME
;
4527 unsigned long pixel
;
4532 /* Set resources. Create the widget. */
4533 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4534 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
4535 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
4536 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
4537 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
4538 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
4539 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
4541 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4544 XtSetArg (av
[ac
], XmNforeground
, pixel
);
4548 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4551 XtSetArg (av
[ac
], XmNbackground
, pixel
);
4555 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
4556 scroll_bar_name
, av
, ac
);
4558 /* Add one callback for everything that can happen. */
4559 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
4561 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
4563 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
4565 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
4567 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
4569 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
4571 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
4574 /* Realize the widget. Only after that is the X window created. */
4575 XtRealizeWidget (widget
);
4577 /* Set the cursor to an arrow. I didn't find a resource to do that.
4578 And I'm wondering why it hasn't an arrow cursor by default. */
4579 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
4580 f
->output_data
.x
->nontext_cursor
);
4582 #else /* !USE_MOTIF i.e. use Xaw */
4584 /* Set resources. Create the widget. The background of the
4585 Xaw3d scroll bar widget is a little bit light for my taste.
4586 We don't alter it here to let users change it according
4587 to their taste with `emacs*verticalScrollBar.background: xxx'. */
4588 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4589 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
4590 /* For smoother scrolling with Xaw3d -sm */
4591 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
4593 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4596 XtSetArg (av
[ac
], XtNforeground
, pixel
);
4600 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4603 XtSetArg (av
[ac
], XtNbackground
, pixel
);
4607 /* Top/bottom shadow colors. */
4609 /* Allocate them, if necessary. */
4610 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
4612 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4613 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
4614 &pixel
, 1.2, 0x8000))
4616 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
4618 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4620 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4621 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
4622 &pixel
, 0.6, 0x4000))
4624 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
4627 #ifdef XtNbeNiceToColormap
4628 /* Tell the toolkit about them. */
4629 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
4630 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4631 /* We tried to allocate a color for the top/bottom shadow, and
4632 failed, so tell Xaw3d to use dithering instead. */
4634 XtSetArg (av
[ac
], XtNbeNiceToColormap
, True
);
4638 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
4639 be more consistent with other emacs 3d colors, and since Xaw3d is
4640 not good at dealing with allocation failure. */
4642 /* This tells Xaw3d to use real colors instead of dithering for
4644 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
4647 /* Specify the colors. */
4648 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
4651 XtSetArg (av
[ac
], XtNtopShadowPixel
, pixel
);
4654 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
4657 XtSetArg (av
[ac
], XtNbottomShadowPixel
, pixel
);
4663 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
4664 f
->output_data
.x
->edit_widget
, av
, ac
);
4668 char *val
= initial
;
4669 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
4670 #ifdef XtNarrowScrollbars
4671 XtNarrowScrollbars
, (XtPointer
) &xaw3d_arrow_scroll
,
4673 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
4674 if (xaw3d_arrow_scroll
|| val
== initial
)
4675 { /* ARROW_SCROLL */
4676 xaw3d_arrow_scroll
= True
;
4677 /* Isn't that just a personal preference ? --Stef */
4678 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
4682 /* Define callbacks. */
4683 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
4684 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
4687 /* Realize the widget. Only after that is the X window created. */
4688 XtRealizeWidget (widget
);
4690 #endif /* !USE_MOTIF */
4692 /* Install an action hook that lets us detect when the user
4693 finishes interacting with a scroll bar. */
4694 if (action_hook_id
== 0)
4695 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
4697 /* Remember X window and widget in the scroll bar vector. */
4698 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
4699 xwindow
= XtWindow (widget
);
4700 bar
->x_window
= xwindow
;
4704 #endif /* not USE_GTK */
4707 /* Set the thumb size and position of scroll bar BAR. We are currently
4708 displaying PORTION out of a whole WHOLE, and our position POSITION. */
4712 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
4713 struct scroll_bar
*bar
;
4714 int portion
, position
, whole
;
4716 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
4719 #else /* not USE_GTK */
4721 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
4722 struct scroll_bar
*bar
;
4723 int portion
, position
, whole
;
4725 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4726 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4733 /* We use an estimate of 30 chars per line rather than the real
4734 `portion' value. This has the disadvantage that the thumb size
4735 is not very representative, but it makes our life a lot easier.
4736 Otherwise, we have to constantly adjust the thumb size, which
4737 we can't always do quickly enough: while dragging, the size of
4738 the thumb might prevent the user from dragging the thumb all the
4739 way to the end. but Motif and some versions of Xaw3d don't allow
4740 updating the thumb size while dragging. Also, even if we can update
4741 its size, the update will often happen too late.
4742 If you don't believe it, check out revision 1.650 of xterm.c to see
4743 what hoops we were going through and the still poor behavior we got. */
4744 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
4745 /* When the thumb is at the bottom, position == whole.
4746 So we need to increase `whole' to make space for the thumb. */
4753 top
= (float) position
/ whole
;
4754 shown
= (float) portion
/ whole
;
4757 if (NILP (bar
->dragging
))
4761 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
4762 is the scroll bar's maximum and MIN is the scroll bar's minimum
4764 size
= shown
* XM_SB_MAX
;
4765 size
= min (size
, XM_SB_MAX
);
4766 size
= max (size
, 1);
4768 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
4769 value
= top
* XM_SB_MAX
;
4770 value
= min (value
, XM_SB_MAX
- size
);
4772 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
4774 #else /* !USE_MOTIF i.e. use Xaw */
4780 top
= (float) position
/ whole
;
4781 shown
= (float) portion
/ whole
;
4785 float old_top
, old_shown
;
4787 XtVaGetValues (widget
,
4788 XtNtopOfThumb
, &old_top
,
4789 XtNshown
, &old_shown
,
4793 /* Massage the top+shown values. */
4794 if (NILP (bar
->dragging
) || last_scroll_bar_part
== scroll_bar_down_arrow
)
4795 top
= max (0, min (1, top
));
4798 /* Keep two pixels available for moving the thumb down. */
4799 shown
= max (0, min (1 - top
- (2.0 / height
), shown
));
4801 /* If the call to XawScrollbarSetThumb below doesn't seem to work,
4802 check that your system's configuration file contains a define
4803 for `NARROWPROTO'. See s/freebsd.h for an example. */
4804 if (top
!= old_top
|| shown
!= old_shown
)
4806 if (NILP (bar
->dragging
))
4807 XawScrollbarSetThumb (widget
, top
, shown
);
4810 /* Try to make the scrolling a tad smoother. */
4811 if (!xaw3d_pick_top
)
4812 shown
= min (shown
, old_shown
);
4814 XawScrollbarSetThumb (widget
, top
, shown
);
4818 #endif /* !USE_MOTIF */
4822 #endif /* not USE_GTK */
4824 #endif /* USE_TOOLKIT_SCROLL_BARS */
4828 /************************************************************************
4829 Scroll bars, general
4830 ************************************************************************/
4832 /* Create a scroll bar and return the scroll bar vector for it. W is
4833 the Emacs window on which to create the scroll bar. TOP, LEFT,
4834 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
4837 static struct scroll_bar
*
4838 x_scroll_bar_create (w
, top
, left
, width
, height
)
4840 int top
, left
, width
, height
;
4842 struct frame
*f
= XFRAME (w
->frame
);
4843 struct scroll_bar
*bar
4844 = ALLOCATE_PSEUDOVECTOR (struct scroll_bar
, x_window
, PVEC_OTHER
);
4848 #ifdef USE_TOOLKIT_SCROLL_BARS
4849 x_create_toolkit_scroll_bar (f
, bar
);
4850 #else /* not USE_TOOLKIT_SCROLL_BARS */
4852 XSetWindowAttributes a
;
4856 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4857 if (a
.background_pixel
== -1)
4858 a
.background_pixel
= FRAME_BACKGROUND_PIXEL (f
);
4860 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
4861 | ButtonMotionMask
| PointerMotionHintMask
4863 a
.cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
4865 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
4867 /* Clear the area of W that will serve as a scroll bar. This is
4868 for the case that a window has been split horizontally. In
4869 this case, no clear_frame is generated to reduce flickering. */
4870 if (width
> 0 && height
> 0)
4871 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4873 window_box_height (w
), False
);
4875 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4876 /* Position and size of scroll bar. */
4877 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4879 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4881 /* Border width, depth, class, and visual. */
4888 bar
->x_window
= window
;
4890 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4892 XSETWINDOW (bar
->window
, w
);
4896 bar
->height
= height
;
4899 bar
->dragging
= Qnil
;
4900 bar
->fringe_extended_p
= 0;
4902 /* Add bar to its frame's list of scroll bars. */
4903 bar
->next
= FRAME_SCROLL_BARS (f
);
4905 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
4906 if (!NILP (bar
->next
))
4907 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4909 /* Map the window/widget. */
4910 #ifdef USE_TOOLKIT_SCROLL_BARS
4913 xg_update_scrollbar_pos (f
,
4916 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4917 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4919 xg_show_scroll_bar (bar
->x_window
);
4920 #else /* not USE_GTK */
4921 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4922 XtConfigureWidget (scroll_bar
,
4923 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4925 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4926 max (height
, 1), 0);
4927 XtMapWidget (scroll_bar
);
4928 #endif /* not USE_GTK */
4930 #else /* not USE_TOOLKIT_SCROLL_BARS */
4931 XMapRaised (FRAME_X_DISPLAY (f
), bar
->x_window
);
4932 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4939 #ifndef USE_TOOLKIT_SCROLL_BARS
4941 /* Draw BAR's handle in the proper position.
4943 If the handle is already drawn from START to END, don't bother
4944 redrawing it, unless REBUILD is non-zero; in that case, always
4945 redraw it. (REBUILD is handy for drawing the handle after expose
4948 Normally, we want to constrain the start and end of the handle to
4949 fit inside its rectangle, but if the user is dragging the scroll
4950 bar handle, we want to let them drag it down all the way, so that
4951 the bar's top is as far down as it goes; otherwise, there's no way
4952 to move to the very end of the buffer. */
4955 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
4956 struct scroll_bar
*bar
;
4960 int dragging
= ! NILP (bar
->dragging
);
4961 Window w
= bar
->x_window
;
4962 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4963 GC gc
= f
->output_data
.x
->normal_gc
;
4965 /* If the display is already accurate, do nothing. */
4967 && start
== bar
->start
4974 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, bar
->width
);
4975 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, bar
->height
);
4976 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
4978 /* Make sure the values are reasonable, and try to preserve
4979 the distance between start and end. */
4981 int length
= end
- start
;
4985 else if (start
> top_range
)
4987 end
= start
+ length
;
4991 else if (end
> top_range
&& ! dragging
)
4995 /* Store the adjusted setting in the scroll bar. */
4999 /* Clip the end position, just for display. */
5000 if (end
> top_range
)
5003 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
5004 below top positions, to make sure the handle is always at least
5005 that many pixels tall. */
5006 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
5008 /* Draw the empty space above the handle. Note that we can't clear
5009 zero-height areas; that means "clear to end of window." */
5011 x_clear_area (FRAME_X_DISPLAY (f
), w
,
5012 /* x, y, width, height, and exposures. */
5013 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
5014 VERTICAL_SCROLL_BAR_TOP_BORDER
,
5015 inside_width
, start
,
5018 /* Change to proper foreground color if one is specified. */
5019 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5020 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5021 f
->output_data
.x
->scroll_bar_foreground_pixel
);
5023 /* Draw the handle itself. */
5024 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
5025 /* x, y, width, height */
5026 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
5027 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
5028 inside_width
, end
- start
);
5030 /* Restore the foreground color of the GC if we changed it above. */
5031 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5032 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5033 FRAME_FOREGROUND_PIXEL (f
));
5035 /* Draw the empty space below the handle. Note that we can't
5036 clear zero-height areas; that means "clear to end of window." */
5037 if (end
< inside_height
)
5038 x_clear_area (FRAME_X_DISPLAY (f
), w
,
5039 /* x, y, width, height, and exposures. */
5040 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
5041 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
5042 inside_width
, inside_height
- end
,
5050 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5052 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
5056 x_scroll_bar_remove (bar
)
5057 struct scroll_bar
*bar
;
5059 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5062 #ifdef USE_TOOLKIT_SCROLL_BARS
5064 xg_remove_scroll_bar (f
, bar
->x_window
);
5065 #else /* not USE_GTK */
5066 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
5067 #endif /* not USE_GTK */
5069 XDestroyWindow (FRAME_X_DISPLAY (f
), bar
->x_window
);
5072 /* Disassociate this scroll bar from its window. */
5073 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
5079 /* Set the handle of the vertical scroll bar for WINDOW to indicate
5080 that we are displaying PORTION characters out of a total of WHOLE
5081 characters, starting at POSITION. If WINDOW has no scroll bar,
5085 XTset_vertical_scroll_bar (w
, portion
, whole
, position
)
5087 int portion
, whole
, position
;
5089 struct frame
*f
= XFRAME (w
->frame
);
5090 struct scroll_bar
*bar
;
5091 int top
, height
, left
, sb_left
, width
, sb_width
;
5092 int window_y
, window_height
;
5093 #ifdef USE_TOOLKIT_SCROLL_BARS
5094 int fringe_extended_p
;
5097 /* Get window dimensions. */
5098 window_box (w
, -1, 0, &window_y
, 0, &window_height
);
5100 width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
5101 height
= window_height
;
5103 /* Compute the left edge of the scroll bar area. */
5104 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
5106 /* Compute the width of the scroll bar which might be less than
5107 the width of the area reserved for the scroll bar. */
5108 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
) > 0)
5109 sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
5113 /* Compute the left edge of the scroll bar. */
5114 #ifdef USE_TOOLKIT_SCROLL_BARS
5115 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
5116 sb_left
= left
+ (WINDOW_RIGHTMOST_P (w
) ? width
- sb_width
: 0);
5118 sb_left
= left
+ (WINDOW_LEFTMOST_P (w
) ? 0 : width
- sb_width
);
5120 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
5121 sb_left
= left
+ width
- sb_width
;
5126 #ifdef USE_TOOLKIT_SCROLL_BARS
5127 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
5128 fringe_extended_p
= (WINDOW_LEFTMOST_P (w
)
5129 && WINDOW_LEFT_FRINGE_WIDTH (w
)
5130 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5131 || WINDOW_LEFT_MARGIN_COLS (w
) == 0));
5133 fringe_extended_p
= (WINDOW_RIGHTMOST_P (w
)
5134 && WINDOW_RIGHT_FRINGE_WIDTH (w
)
5135 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5136 || WINDOW_RIGHT_MARGIN_COLS (w
) == 0));
5139 /* Does the scroll bar exist yet? */
5140 if (NILP (w
->vertical_scroll_bar
))
5142 if (width
> 0 && height
> 0)
5145 #ifdef USE_TOOLKIT_SCROLL_BARS
5146 if (fringe_extended_p
)
5147 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5148 sb_left
, top
, sb_width
, height
, False
);
5151 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5152 left
, top
, width
, height
, False
);
5156 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
5160 /* It may just need to be moved and resized. */
5161 unsigned int mask
= 0;
5163 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5167 if (sb_left
!= bar
->left
)
5169 if (top
!= bar
->top
)
5171 if (sb_width
!= bar
->width
)
5173 if (height
!= bar
->height
)
5176 #ifdef USE_TOOLKIT_SCROLL_BARS
5178 /* Move/size the scroll bar widget. */
5179 if (mask
|| bar
->fringe_extended_p
!= fringe_extended_p
)
5181 /* Since toolkit scroll bars are smaller than the space reserved
5182 for them on the frame, we have to clear "under" them. */
5183 if (width
> 0 && height
> 0)
5185 if (fringe_extended_p
)
5186 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5187 sb_left
, top
, sb_width
, height
, False
);
5189 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5190 left
, top
, width
, height
, False
);
5193 xg_update_scrollbar_pos (f
,
5196 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5197 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
*2,
5199 #else /* not USE_GTK */
5200 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
5201 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5203 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
5204 max (height
, 1), 0);
5205 #endif /* not USE_GTK */
5207 #else /* not USE_TOOLKIT_SCROLL_BARS */
5209 /* Clear areas not covered by the scroll bar because of
5210 VERTICAL_SCROLL_BAR_WIDTH_TRIM. */
5211 if (VERTICAL_SCROLL_BAR_WIDTH_TRIM
)
5213 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5214 left
, top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5216 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5217 left
+ width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5218 top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5222 /* Clear areas not covered by the scroll bar because it's not as
5223 wide as the area reserved for it. This makes sure a
5224 previous mode line display is cleared after C-x 2 C-x 1, for
5227 int area_width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
5228 int rest
= area_width
- sb_width
;
5229 if (rest
> 0 && height
> 0)
5231 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
5232 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5233 left
+ area_width
- rest
, top
,
5234 rest
, height
, False
);
5236 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5237 left
, top
, rest
, height
, False
);
5241 /* Move/size the scroll bar window. */
5246 wc
.x
= sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5248 wc
.width
= sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2;
5250 XConfigureWindow (FRAME_X_DISPLAY (f
), bar
->x_window
,
5254 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5256 /* Remember new settings. */
5257 bar
->left
= sb_left
;
5259 bar
->width
= sb_width
;
5260 bar
->height
= height
;
5265 #ifdef USE_TOOLKIT_SCROLL_BARS
5266 bar
->fringe_extended_p
= fringe_extended_p
;
5268 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
5269 #else /* not USE_TOOLKIT_SCROLL_BARS */
5270 /* Set the scroll bar's current state, unless we're currently being
5272 if (NILP (bar
->dragging
))
5274 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
5277 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
5280 int start
= ((double) position
* top_range
) / whole
;
5281 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
5282 x_scroll_bar_set_handle (bar
, start
, end
, 0);
5285 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5287 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
5291 /* The following three hooks are used when we're doing a thorough
5292 redisplay of the frame. We don't explicitly know which scroll bars
5293 are going to be deleted, because keeping track of when windows go
5294 away is a real pain - "Can you say set-window-configuration, boys
5295 and girls?" Instead, we just assert at the beginning of redisplay
5296 that *all* scroll bars are to be removed, and then save a scroll bar
5297 from the fiery pit when we actually redisplay its window. */
5299 /* Arrange for all scroll bars on FRAME to be removed at the next call
5300 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
5301 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
5304 XTcondemn_scroll_bars (frame
)
5307 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
5308 while (! NILP (FRAME_SCROLL_BARS (frame
)))
5311 bar
= FRAME_SCROLL_BARS (frame
);
5312 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
5313 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
5314 XSCROLL_BAR (bar
)->prev
= Qnil
;
5315 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
5316 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
5317 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
5322 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
5323 Note that WINDOW isn't necessarily condemned at all. */
5326 XTredeem_scroll_bar (window
)
5327 struct window
*window
;
5329 struct scroll_bar
*bar
;
5332 /* We can't redeem this window's scroll bar if it doesn't have one. */
5333 if (NILP (window
->vertical_scroll_bar
))
5336 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
5338 /* Unlink it from the condemned list. */
5339 f
= XFRAME (WINDOW_FRAME (window
));
5340 if (NILP (bar
->prev
))
5342 /* If the prev pointer is nil, it must be the first in one of
5344 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
5345 /* It's not condemned. Everything's fine. */
5347 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
5348 window
->vertical_scroll_bar
))
5349 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
5351 /* If its prev pointer is nil, it must be at the front of
5352 one or the other! */
5356 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
5358 if (! NILP (bar
->next
))
5359 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
5361 bar
->next
= FRAME_SCROLL_BARS (f
);
5363 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
5364 if (! NILP (bar
->next
))
5365 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
5368 /* Remove all scroll bars on FRAME that haven't been saved since the
5369 last call to `*condemn_scroll_bars_hook'. */
5372 XTjudge_scroll_bars (f
)
5375 Lisp_Object bar
, next
;
5377 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
5379 /* Clear out the condemned list now so we won't try to process any
5380 more events on the hapless scroll bars. */
5381 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
5383 for (; ! NILP (bar
); bar
= next
)
5385 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
5387 x_scroll_bar_remove (b
);
5390 b
->next
= b
->prev
= Qnil
;
5393 /* Now there should be no references to the condemned scroll bars,
5394 and they should get garbage-collected. */
5398 #ifndef USE_TOOLKIT_SCROLL_BARS
5399 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
5400 is a no-op when using toolkit scroll bars.
5402 This may be called from a signal handler, so we have to ignore GC
5406 x_scroll_bar_expose (bar
, event
)
5407 struct scroll_bar
*bar
;
5410 Window w
= bar
->x_window
;
5411 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5412 GC gc
= f
->output_data
.x
->normal_gc
;
5413 int width_trim
= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5417 x_scroll_bar_set_handle (bar
, bar
->start
, bar
->end
, 1);
5419 /* Switch to scroll bar foreground color. */
5420 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5421 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5422 f
->output_data
.x
->scroll_bar_foreground_pixel
);
5424 /* Draw a one-pixel border just inside the edges of the scroll bar. */
5425 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
5427 /* x, y, width, height */
5429 bar
->width
- 1 - width_trim
- width_trim
,
5432 /* Restore the foreground color of the GC if we changed it above. */
5433 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5434 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5435 FRAME_FOREGROUND_PIXEL (f
));
5440 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5442 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
5443 is set to something other than NO_EVENT, it is enqueued.
5445 This may be called from a signal handler, so we have to ignore GC
5450 x_scroll_bar_handle_click (bar
, event
, emacs_event
)
5451 struct scroll_bar
*bar
;
5453 struct input_event
*emacs_event
;
5455 if (! WINDOWP (bar
->window
))
5458 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
5459 emacs_event
->code
= event
->xbutton
.button
- Button1
;
5460 emacs_event
->modifiers
5461 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
5462 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
5463 event
->xbutton
.state
)
5464 | (event
->type
== ButtonRelease
5467 emacs_event
->frame_or_window
= bar
->window
;
5468 emacs_event
->arg
= Qnil
;
5469 emacs_event
->timestamp
= event
->xbutton
.time
;
5472 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5474 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, bar
->height
);
5477 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
5478 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
5481 if (y
> top_range
) y
= top_range
;
5484 emacs_event
->part
= scroll_bar_above_handle
;
5485 else if (y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5486 emacs_event
->part
= scroll_bar_handle
;
5488 emacs_event
->part
= scroll_bar_below_handle
;
5490 /* Just because the user has clicked on the handle doesn't mean
5491 they want to drag it. Lisp code needs to be able to decide
5492 whether or not we're dragging. */
5494 /* If the user has just clicked on the handle, record where they're
5496 if (event
->type
== ButtonPress
5497 && emacs_event
->part
== scroll_bar_handle
)
5498 XSETINT (bar
->dragging
, y
- bar
->start
);
5501 #ifndef USE_TOOLKIT_SCROLL_BARS
5502 /* If the user has released the handle, set it to its final position. */
5503 if (event
->type
== ButtonRelease
5504 && ! NILP (bar
->dragging
))
5506 int new_start
= y
- XINT (bar
->dragging
);
5507 int new_end
= new_start
+ bar
->end
- bar
->start
;
5509 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5510 bar
->dragging
= Qnil
;
5514 /* Same deal here as the other #if 0. */
5516 /* Clicks on the handle are always reported as occurring at the top of
5518 if (emacs_event
->part
== scroll_bar_handle
)
5519 emacs_event
->x
= bar
->start
;
5521 XSETINT (emacs_event
->x
, y
);
5523 XSETINT (emacs_event
->x
, y
);
5526 XSETINT (emacs_event
->y
, top_range
);
5530 #ifndef USE_TOOLKIT_SCROLL_BARS
5532 /* Handle some mouse motion while someone is dragging the scroll bar.
5534 This may be called from a signal handler, so we have to ignore GC
5538 x_scroll_bar_note_movement (bar
, event
)
5539 struct scroll_bar
*bar
;
5542 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
5544 last_mouse_movement_time
= event
->xmotion
.time
;
5547 XSETVECTOR (last_mouse_scroll_bar
, bar
);
5549 /* If we're dragging the bar, display it. */
5550 if (! NILP (bar
->dragging
))
5552 /* Where should the handle be now? */
5553 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
5555 if (new_start
!= bar
->start
)
5557 int new_end
= new_start
+ bar
->end
- bar
->start
;
5559 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5564 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5566 /* Return information to the user about the current position of the mouse
5567 on the scroll bar. */
5570 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
5572 Lisp_Object
*bar_window
;
5573 enum scroll_bar_part
*part
;
5575 unsigned long *time
;
5577 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
5578 Window w
= bar
->x_window
;
5579 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5581 Window dummy_window
;
5583 unsigned int dummy_mask
;
5587 /* Get the mouse's position relative to the scroll bar window, and
5589 if (! XQueryPointer (FRAME_X_DISPLAY (f
), w
,
5591 /* Root, child, root x and root y. */
5592 &dummy_window
, &dummy_window
,
5593 &dummy_coord
, &dummy_coord
,
5595 /* Position relative to scroll bar. */
5598 /* Mouse buttons and modifier keys. */
5605 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, bar
->height
);
5608 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
5610 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
5612 if (! NILP (bar
->dragging
))
5613 win_y
-= XINT (bar
->dragging
);
5617 if (win_y
> top_range
)
5621 *bar_window
= bar
->window
;
5623 if (! NILP (bar
->dragging
))
5624 *part
= scroll_bar_handle
;
5625 else if (win_y
< bar
->start
)
5626 *part
= scroll_bar_above_handle
;
5627 else if (win_y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5628 *part
= scroll_bar_handle
;
5630 *part
= scroll_bar_below_handle
;
5632 XSETINT (*x
, win_y
);
5633 XSETINT (*y
, top_range
);
5636 last_mouse_scroll_bar
= Qnil
;
5639 *time
= last_mouse_movement_time
;
5645 /* The screen has been cleared so we may have changed foreground or
5646 background colors, and the scroll bars may need to be redrawn.
5647 Clear out the scroll bars, and ask for expose events, so we can
5651 x_scroll_bar_clear (f
)
5654 #ifndef USE_TOOLKIT_SCROLL_BARS
5657 /* We can have scroll bars even if this is 0,
5658 if we just turned off scroll bar mode.
5659 But in that case we should not clear them. */
5660 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5661 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
5662 bar
= XSCROLL_BAR (bar
)->next
)
5663 XClearArea (FRAME_X_DISPLAY (f
),
5664 XSCROLL_BAR (bar
)->x_window
,
5666 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5670 /* The main X event-reading loop - XTread_socket. */
5673 /* Time stamp of enter window event. This is only used by XTread_socket,
5674 but we have to put it out here, since static variables within functions
5675 sometimes don't work. */
5677 static Time enter_timestamp
;
5680 /* This holds the state XLookupString needs to implement dead keys
5681 and other tricks known as "compose processing". _X Window System_
5682 says that a portable program can't use this, but Stephen Gildea assures
5683 me that letting the compiler initialize it to zeros will work okay.
5685 This must be defined outside of XTread_socket, for the same reasons
5686 given for enter_timestamp, above. */
5688 static XComposeStatus compose_status
;
5690 /* Record the last 100 characters stored
5691 to help debug the loss-of-chars-during-GC problem. */
5693 static int temp_index
;
5694 static short temp_buffer
[100];
5696 #define STORE_KEYSYM_FOR_DEBUG(keysym) \
5697 if (temp_index == sizeof temp_buffer / sizeof (short)) \
5699 temp_buffer[temp_index++] = (keysym)
5701 /* Set this to nonzero to fake an "X I/O error"
5702 on a particular display. */
5704 struct x_display_info
*XTread_socket_fake_io_error
;
5706 /* When we find no input here, we occasionally do a no-op command
5707 to verify that the X server is still running and we can still talk with it.
5708 We try all the open displays, one by one.
5709 This variable is used for cycling thru the displays. */
5711 static struct x_display_info
*next_noop_dpyinfo
;
5713 #define SET_SAVED_MENU_EVENT(size) \
5716 if (f->output_data.x->saved_menu_event == 0) \
5717 f->output_data.x->saved_menu_event \
5718 = (XEvent *) xmalloc (sizeof (XEvent)); \
5719 bcopy (&event, f->output_data.x->saved_menu_event, size); \
5720 inev.ie.kind = MENU_BAR_ACTIVATE_EVENT; \
5721 XSETFRAME (inev.ie.frame_or_window, f); \
5725 #define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
5726 #define SET_SAVED_KEY_EVENT SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
5736 /* Filter events for the current X input method.
5737 DPYINFO is the display this event is for.
5738 EVENT is the X event to filter.
5740 Returns non-zero if the event was filtered, caller shall not process
5742 Returns zero if event is wasn't filtered. */
5746 x_filter_event (dpyinfo
, event
)
5747 struct x_display_info
*dpyinfo
;
5750 /* XFilterEvent returns non-zero if the input method has
5751 consumed the event. We pass the frame's X window to
5752 XFilterEvent because that's the one for which the IC
5755 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
5756 event
->xclient
.window
);
5758 return XFilterEvent (event
, f1
? FRAME_X_WINDOW (f1
) : None
);
5763 static int current_count
;
5764 static int current_finish
;
5765 static struct input_event
*current_hold_quit
;
5767 /* This is the filter function invoked by the GTK event loop.
5768 It is invoked before the XEvent is translated to a GdkEvent,
5769 so we have a chance to act on the event before GTK. */
5770 static GdkFilterReturn
5771 event_handler_gdk (gxev
, ev
, data
)
5776 XEvent
*xev
= (XEvent
*) gxev
;
5778 if (current_count
>= 0)
5780 struct x_display_info
*dpyinfo
;
5782 dpyinfo
= x_display_info_for_display (xev
->xany
.display
);
5785 /* Filter events for the current X input method.
5786 GTK calls XFilterEvent but not for key press and release,
5787 so we do it here. */
5788 if (xev
->type
== KeyPress
|| xev
->type
== KeyRelease
)
5789 if (dpyinfo
&& x_filter_event (dpyinfo
, xev
))
5790 return GDK_FILTER_REMOVE
;
5794 current_finish
= X_EVENT_NORMAL
;
5798 handle_one_xevent (dpyinfo
, xev
, ¤t_finish
,
5803 current_finish
= x_dispatch_event (xev
, xev
->xany
.display
);
5805 if (current_finish
== X_EVENT_GOTO_OUT
|| current_finish
== X_EVENT_DROP
)
5806 return GDK_FILTER_REMOVE
;
5808 return GDK_FILTER_CONTINUE
;
5810 #endif /* USE_GTK */
5813 /* Handles the XEvent EVENT on display DPYINFO.
5815 *FINISH is X_EVENT_GOTO_OUT if caller should stop reading events.
5816 *FINISH is zero if caller should continue reading events.
5817 *FINISH is X_EVENT_DROP if event should not be passed to the toolkit.
5819 We return the number of characters stored into the buffer. */
5822 handle_one_xevent (dpyinfo
, eventp
, finish
, hold_quit
)
5823 struct x_display_info
*dpyinfo
;
5826 struct input_event
*hold_quit
;
5829 struct input_event ie
;
5830 struct selection_input_event sie
;
5835 struct frame
*f
= NULL
;
5836 struct coding_system coding
;
5837 XEvent event
= *eventp
;
5839 *finish
= X_EVENT_NORMAL
;
5841 EVENT_INIT (inev
.ie
);
5842 inev
.ie
.kind
= NO_EVENT
;
5849 if (event
.xclient
.message_type
5850 == dpyinfo
->Xatom_wm_protocols
5851 && event
.xclient
.format
== 32)
5853 if (event
.xclient
.data
.l
[0]
5854 == dpyinfo
->Xatom_wm_take_focus
)
5856 /* Use x_any_window_to_frame because this
5857 could be the shell widget window
5858 if the frame has no title bar. */
5859 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5861 /* Not quite sure this is needed -pd */
5862 if (f
&& FRAME_XIC (f
))
5863 XSetICFocus (FRAME_XIC (f
));
5865 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
5866 instructs the WM to set the input focus automatically for
5867 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
5868 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
5869 it has set the focus. So, XSetInputFocus below is not
5872 The call to XSetInputFocus below has also caused trouble. In
5873 cases where the XSetInputFocus done by the WM and the one
5874 below are temporally close (on a fast machine), the call
5875 below can generate additional FocusIn events which confuse
5878 /* Since we set WM_TAKE_FOCUS, we must call
5879 XSetInputFocus explicitly. But not if f is null,
5880 since that might be an event for a deleted frame. */
5883 Display
*d
= event
.xclient
.display
;
5884 /* Catch and ignore errors, in case window has been
5885 iconified by a window manager such as GWM. */
5887 XSetInputFocus (d
, event
.xclient
.window
,
5888 /* The ICCCM says this is
5889 the only valid choice. */
5891 event
.xclient
.data
.l
[1]);
5892 /* This is needed to detect the error
5893 if there is an error. */
5895 x_uncatch_errors ();
5897 /* Not certain about handling scroll bars here */
5902 if (event
.xclient
.data
.l
[0]
5903 == dpyinfo
->Xatom_wm_save_yourself
)
5905 /* Save state modify the WM_COMMAND property to
5906 something which can reinstate us. This notifies
5907 the session manager, who's looking for such a
5908 PropertyNotify. Can restart processing when
5909 a keyboard or mouse event arrives. */
5910 /* If we have a session manager, don't set this.
5911 KDE will then start two Emacsen, one for the
5912 session manager and one for this. */
5914 if (! x_session_have_connection ())
5917 f
= x_top_window_to_frame (dpyinfo
,
5918 event
.xclient
.window
);
5919 /* This is just so we only give real data once
5920 for a single Emacs process. */
5921 if (f
== SELECTED_FRAME ())
5922 XSetCommand (FRAME_X_DISPLAY (f
),
5923 event
.xclient
.window
,
5924 initial_argv
, initial_argc
);
5926 XSetCommand (FRAME_X_DISPLAY (f
),
5927 event
.xclient
.window
,
5933 if (event
.xclient
.data
.l
[0]
5934 == dpyinfo
->Xatom_wm_delete_window
)
5936 f
= x_any_window_to_frame (dpyinfo
,
5937 event
.xclient
.window
);
5939 goto OTHER
; /* May be a dialog that is to be removed */
5941 inev
.ie
.kind
= DELETE_WINDOW_EVENT
;
5942 XSETFRAME (inev
.ie
.frame_or_window
, f
);
5949 if (event
.xclient
.message_type
5950 == dpyinfo
->Xatom_wm_configure_denied
)
5955 if (event
.xclient
.message_type
5956 == dpyinfo
->Xatom_wm_window_moved
)
5959 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
5961 new_x
= event
.xclient
.data
.s
[0];
5962 new_y
= event
.xclient
.data
.s
[1];
5966 f
->left_pos
= new_x
;
5973 if (event
.xclient
.message_type
5974 == dpyinfo
->Xatom_editres
)
5976 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5978 _XEditResCheckMessages (f
->output_data
.x
->widget
, NULL
,
5982 #endif /* HACK_EDITRES */
5984 if ((event
.xclient
.message_type
5985 == dpyinfo
->Xatom_DONE
)
5986 || (event
.xclient
.message_type
5987 == dpyinfo
->Xatom_PAGE
))
5989 /* Ghostview job completed. Kill it. We could
5990 reply with "Next" if we received "Page", but we
5991 currently never do because we are interested in
5992 images, only, which should have 1 page. */
5993 Pixmap pixmap
= (Pixmap
) event
.xclient
.data
.l
[1];
5994 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
5997 x_kill_gs_process (pixmap
, f
);
5998 expose_frame (f
, 0, 0, 0, 0);
6002 #ifdef USE_TOOLKIT_SCROLL_BARS
6003 /* Scroll bar callbacks send a ClientMessage from which
6004 we construct an input_event. */
6005 if (event
.xclient
.message_type
6006 == dpyinfo
->Xatom_Scrollbar
)
6008 x_scroll_bar_to_input_event (&event
, &inev
.ie
);
6009 *finish
= X_EVENT_GOTO_OUT
;
6012 #endif /* USE_TOOLKIT_SCROLL_BARS */
6014 /* XEmbed messages from the embedder (if any). */
6015 if (event
.xclient
.message_type
6016 == dpyinfo
->Xatom_XEMBED
)
6018 enum xembed_message msg
= event
.xclient
.data
.l
[1];
6019 if (msg
== XEMBED_FOCUS_IN
|| msg
== XEMBED_FOCUS_OUT
)
6020 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6022 *finish
= X_EVENT_GOTO_OUT
;
6026 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
6029 if (x_handle_dnd_message (f
, &event
.xclient
, dpyinfo
, &inev
.ie
))
6030 *finish
= X_EVENT_DROP
;
6034 case SelectionNotify
:
6035 last_user_time
= event
.xselection
.time
;
6036 #ifdef USE_X_TOOLKIT
6037 if (! x_window_to_frame (dpyinfo
, event
.xselection
.requestor
))
6039 #endif /* not USE_X_TOOLKIT */
6040 x_handle_selection_notify (&event
.xselection
);
6043 case SelectionClear
: /* Someone has grabbed ownership. */
6044 last_user_time
= event
.xselectionclear
.time
;
6045 #ifdef USE_X_TOOLKIT
6046 if (! x_window_to_frame (dpyinfo
, event
.xselectionclear
.window
))
6048 #endif /* USE_X_TOOLKIT */
6050 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
6052 inev
.ie
.kind
= SELECTION_CLEAR_EVENT
;
6053 SELECTION_EVENT_DISPLAY (&inev
.sie
) = eventp
->display
;
6054 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
6055 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
6056 inev
.ie
.frame_or_window
= Qnil
;
6060 case SelectionRequest
: /* Someone wants our selection. */
6061 last_user_time
= event
.xselectionrequest
.time
;
6062 #ifdef USE_X_TOOLKIT
6063 if (!x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
))
6065 #endif /* USE_X_TOOLKIT */
6067 XSelectionRequestEvent
*eventp
6068 = (XSelectionRequestEvent
*) &event
;
6070 inev
.ie
.kind
= SELECTION_REQUEST_EVENT
;
6071 SELECTION_EVENT_DISPLAY (&inev
.sie
) = eventp
->display
;
6072 SELECTION_EVENT_REQUESTOR (&inev
.sie
) = eventp
->requestor
;
6073 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
6074 SELECTION_EVENT_TARGET (&inev
.sie
) = eventp
->target
;
6075 SELECTION_EVENT_PROPERTY (&inev
.sie
) = eventp
->property
;
6076 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
6077 inev
.ie
.frame_or_window
= Qnil
;
6081 case PropertyNotify
:
6082 last_user_time
= event
.xproperty
.time
;
6083 #if 0 /* This is plain wrong. In the case that we are waiting for a
6084 PropertyNotify used as an ACK in incremental selection
6085 transfer, the property will be on the receiver's window. */
6086 #if defined USE_X_TOOLKIT
6087 if (!x_any_window_to_frame (dpyinfo
, event
.xproperty
.window
))
6091 x_handle_property_notify (&event
.xproperty
);
6094 case ReparentNotify
:
6095 f
= x_top_window_to_frame (dpyinfo
, event
.xreparent
.window
);
6099 f
->output_data
.x
->parent_desc
= event
.xreparent
.parent
;
6100 x_real_positions (f
, &x
, &y
);
6104 /* Perhaps reparented due to a WM restart. Reset this. */
6105 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_UNKNOWN
;
6106 FRAME_X_DISPLAY_INFO (f
)->net_supported_window
= 0;
6111 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
6114 x_check_fullscreen (f
);
6117 /* This seems to be needed for GTK 2.6. */
6118 x_clear_area (event
.xexpose
.display
,
6119 event
.xexpose
.window
,
6120 event
.xexpose
.x
, event
.xexpose
.y
,
6121 event
.xexpose
.width
, event
.xexpose
.height
,
6124 if (f
->async_visible
== 0)
6126 f
->async_visible
= 1;
6127 f
->async_iconified
= 0;
6128 f
->output_data
.x
->has_been_visible
= 1;
6129 SET_FRAME_GARBAGED (f
);
6133 event
.xexpose
.x
, event
.xexpose
.y
,
6134 event
.xexpose
.width
, event
.xexpose
.height
);
6138 #ifndef USE_TOOLKIT_SCROLL_BARS
6139 struct scroll_bar
*bar
;
6141 #if defined USE_LUCID
6142 /* Submenus of the Lucid menu bar aren't widgets
6143 themselves, so there's no way to dispatch events
6144 to them. Recognize this case separately. */
6147 = x_window_to_menu_bar (event
.xexpose
.window
);
6149 xlwmenu_redisplay (widget
);
6151 #endif /* USE_LUCID */
6153 #ifdef USE_TOOLKIT_SCROLL_BARS
6154 /* Dispatch event to the widget. */
6156 #else /* not USE_TOOLKIT_SCROLL_BARS */
6157 bar
= x_window_to_scroll_bar (event
.xexpose
.display
,
6158 event
.xexpose
.window
);
6161 x_scroll_bar_expose (bar
, &event
);
6162 #ifdef USE_X_TOOLKIT
6165 #endif /* USE_X_TOOLKIT */
6166 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6170 case GraphicsExpose
: /* This occurs when an XCopyArea's
6171 source area was obscured or not
6173 f
= x_window_to_frame (dpyinfo
, event
.xgraphicsexpose
.drawable
);
6177 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
6178 event
.xgraphicsexpose
.width
,
6179 event
.xgraphicsexpose
.height
);
6181 #ifdef USE_X_TOOLKIT
6184 #endif /* USE_X_TOOLKIT */
6187 case NoExpose
: /* This occurs when an XCopyArea's
6188 source area was completely
6193 /* Redo the mouse-highlight after the tooltip has gone. */
6194 if (event
.xmap
.window
== tip_window
)
6197 redo_mouse_highlight ();
6200 f
= x_top_window_to_frame (dpyinfo
, event
.xunmap
.window
);
6201 if (f
) /* F may no longer exist if
6202 the frame was deleted. */
6204 /* While a frame is unmapped, display generation is
6205 disabled; you don't want to spend time updating a
6206 display that won't ever be seen. */
6207 f
->async_visible
= 0;
6208 /* We can't distinguish, from the event, whether the window
6209 has become iconified or invisible. So assume, if it
6210 was previously visible, than now it is iconified.
6211 But x_make_frame_invisible clears both
6212 the visible flag and the iconified flag;
6213 and that way, we know the window is not iconified now. */
6214 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
6216 f
->async_iconified
= 1;
6218 inev
.ie
.kind
= ICONIFY_EVENT
;
6219 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6225 if (event
.xmap
.window
== tip_window
)
6226 /* The tooltip has been drawn already. Avoid
6227 the SET_FRAME_GARBAGED below. */
6230 /* We use x_top_window_to_frame because map events can
6231 come for sub-windows and they don't mean that the
6232 frame is visible. */
6233 f
= x_top_window_to_frame (dpyinfo
, event
.xmap
.window
);
6236 /* wait_reading_process_output will notice this and update
6237 the frame's display structures.
6238 If we where iconified, we should not set garbaged,
6239 because that stops redrawing on Expose events. This looks
6240 bad if we are called from a recursive event loop
6241 (x_dispatch_event), for example when a dialog is up. */
6242 if (! f
->async_iconified
)
6243 SET_FRAME_GARBAGED (f
);
6245 f
->async_visible
= 1;
6246 f
->async_iconified
= 0;
6247 f
->output_data
.x
->has_been_visible
= 1;
6251 inev
.ie
.kind
= DEICONIFY_EVENT
;
6252 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6254 else if (! NILP (Vframe_list
)
6255 && ! NILP (XCDR (Vframe_list
)))
6256 /* Force a redisplay sooner or later
6257 to update the frame titles
6258 in case this is the second frame. */
6259 record_asynch_buffer_change ();
6265 last_user_time
= event
.xkey
.time
;
6266 ignore_next_mouse_click_timeout
= 0;
6268 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6269 /* Dispatch KeyPress events when in menu. */
6270 if (popup_activated ())
6274 f
= x_any_window_to_frame (dpyinfo
, event
.xkey
.window
);
6276 /* If mouse-highlight is an integer, input clears out
6277 mouse highlighting. */
6278 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
6280 || !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
)))
6282 clear_mouse_face (dpyinfo
);
6283 dpyinfo
->mouse_face_hidden
= 1;
6286 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
6289 /* Scroll bars consume key events, but we want
6290 the keys to go to the scroll bar's frame. */
6291 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
6293 if (widget
&& XmIsScrollBar (widget
))
6295 widget
= XtParent (widget
);
6296 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
6299 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
6303 KeySym keysym
, orig_keysym
;
6304 /* al%imercury@uunet.uu.net says that making this 81
6305 instead of 80 fixed a bug whereby meta chars made
6308 It seems that some version of XmbLookupString has
6309 a bug of not returning XBufferOverflow in
6310 status_return even if the input is too long to
6311 fit in 81 bytes. So, we must prepare sufficient
6312 bytes for copy_buffer. 513 bytes (256 chars for
6313 two-byte character set) seems to be a fairly good
6314 approximation. -- 2000.8.10 handa@etl.go.jp */
6315 unsigned char copy_buffer
[513];
6316 unsigned char *copy_bufptr
= copy_buffer
;
6317 int copy_bufsiz
= sizeof (copy_buffer
);
6319 Lisp_Object coding_system
= Qlatin_1
;
6323 /* Don't pass keys to GTK. A Tab will shift focus to the
6324 tool bar in GTK 2.4. Keys will still go to menus and
6325 dialogs because in that case popup_activated is TRUE
6327 *finish
= X_EVENT_DROP
;
6331 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f
),
6332 extra_keyboard_modifiers
);
6333 modifiers
= event
.xkey
.state
;
6335 /* This will have to go some day... */
6337 /* make_lispy_event turns chars into control chars.
6338 Don't do it here because XLookupString is too eager. */
6339 event
.xkey
.state
&= ~ControlMask
;
6340 event
.xkey
.state
&= ~(dpyinfo
->meta_mod_mask
6341 | dpyinfo
->super_mod_mask
6342 | dpyinfo
->hyper_mod_mask
6343 | dpyinfo
->alt_mod_mask
);
6345 /* In case Meta is ComposeCharacter,
6346 clear its status. According to Markus Ehrnsperger
6347 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
6348 this enables ComposeCharacter to work whether or
6349 not it is combined with Meta. */
6350 if (modifiers
& dpyinfo
->meta_mod_mask
)
6351 bzero (&compose_status
, sizeof (compose_status
));
6356 Status status_return
;
6358 coding_system
= Vlocale_coding_system
;
6359 nbytes
= XmbLookupString (FRAME_XIC (f
),
6360 &event
.xkey
, copy_bufptr
,
6361 copy_bufsiz
, &keysym
,
6363 if (status_return
== XBufferOverflow
)
6365 copy_bufsiz
= nbytes
+ 1;
6366 copy_bufptr
= (unsigned char *) alloca (copy_bufsiz
);
6367 nbytes
= XmbLookupString (FRAME_XIC (f
),
6368 &event
.xkey
, copy_bufptr
,
6369 copy_bufsiz
, &keysym
,
6372 /* Xutf8LookupString is a new but already deprecated interface. -stef */
6373 #if 0 && defined X_HAVE_UTF8_STRING
6374 else if (status_return
== XLookupKeySym
)
6375 { /* Try again but with utf-8. */
6376 coding_system
= Qutf_8
;
6377 nbytes
= Xutf8LookupString (FRAME_XIC (f
),
6378 &event
.xkey
, copy_bufptr
,
6379 copy_bufsiz
, &keysym
,
6381 if (status_return
== XBufferOverflow
)
6383 copy_bufsiz
= nbytes
+ 1;
6384 copy_bufptr
= (unsigned char *) alloca (copy_bufsiz
);
6385 nbytes
= Xutf8LookupString (FRAME_XIC (f
),
6388 copy_bufsiz
, &keysym
,
6394 if (status_return
== XLookupNone
)
6396 else if (status_return
== XLookupChars
)
6401 else if (status_return
!= XLookupKeySym
6402 && status_return
!= XLookupBoth
)
6406 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
6407 copy_bufsiz
, &keysym
,
6410 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
6411 copy_bufsiz
, &keysym
,
6415 /* If not using XIM/XIC, and a compose sequence is in progress,
6416 we break here. Otherwise, chars_matched is always 0. */
6417 if (compose_status
.chars_matched
> 0 && nbytes
== 0)
6420 bzero (&compose_status
, sizeof (compose_status
));
6421 orig_keysym
= keysym
;
6423 /* Common for all keysym input events. */
6424 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6426 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), modifiers
);
6427 inev
.ie
.timestamp
= event
.xkey
.time
;
6429 /* First deal with keysyms which have defined
6430 translations to characters. */
6431 if (keysym
>= 32 && keysym
< 128)
6432 /* Avoid explicitly decoding each ASCII character. */
6434 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
6435 inev
.ie
.code
= keysym
;
6439 /* Keysyms directly mapped to Unicode characters. */
6440 if (keysym
>= 0x01000000 && keysym
<= 0x0110FFFF)
6442 if (keysym
< 0x01000080)
6443 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
6445 inev
.ie
.kind
= MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
6446 inev
.ie
.code
= keysym
& 0xFFFFFF;
6450 /* Now non-ASCII. */
6451 if (HASH_TABLE_P (Vx_keysym_table
)
6452 && (NATNUMP (c
= Fgethash (make_number (keysym
),
6456 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (XFASTINT (c
))
6457 ? ASCII_KEYSTROKE_EVENT
6458 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6459 inev
.ie
.code
= XFASTINT (c
);
6463 /* Random non-modifier sorts of keysyms. */
6464 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
6465 || keysym
== XK_Delete
6466 #ifdef XK_ISO_Left_Tab
6467 || (keysym
>= XK_ISO_Left_Tab
6468 && keysym
<= XK_ISO_Enter
)
6470 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
6471 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
6473 /* This recognizes the "extended function
6474 keys". It seems there's no cleaner way.
6475 Test IsModifierKey to avoid handling
6476 mode_switch incorrectly. */
6477 || ((unsigned) (keysym
) >= XK_Select
6478 && (unsigned)(keysym
) < XK_KP_Space
)
6480 #ifdef XK_dead_circumflex
6481 || orig_keysym
== XK_dead_circumflex
6483 #ifdef XK_dead_grave
6484 || orig_keysym
== XK_dead_grave
6486 #ifdef XK_dead_tilde
6487 || orig_keysym
== XK_dead_tilde
6489 #ifdef XK_dead_diaeresis
6490 || orig_keysym
== XK_dead_diaeresis
6492 #ifdef XK_dead_macron
6493 || orig_keysym
== XK_dead_macron
6495 #ifdef XK_dead_degree
6496 || orig_keysym
== XK_dead_degree
6498 #ifdef XK_dead_acute
6499 || orig_keysym
== XK_dead_acute
6501 #ifdef XK_dead_cedilla
6502 || orig_keysym
== XK_dead_cedilla
6504 #ifdef XK_dead_breve
6505 || orig_keysym
== XK_dead_breve
6507 #ifdef XK_dead_ogonek
6508 || orig_keysym
== XK_dead_ogonek
6510 #ifdef XK_dead_caron
6511 || orig_keysym
== XK_dead_caron
6513 #ifdef XK_dead_doubleacute
6514 || orig_keysym
== XK_dead_doubleacute
6516 #ifdef XK_dead_abovedot
6517 || orig_keysym
== XK_dead_abovedot
6519 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
6520 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
6521 /* Any "vendor-specific" key is ok. */
6522 || (orig_keysym
& (1 << 28))
6523 || (keysym
!= NoSymbol
&& nbytes
== 0))
6524 && ! (IsModifierKey (orig_keysym
)
6525 /* The symbols from XK_ISO_Lock
6526 to XK_ISO_Last_Group_Lock
6527 don't have real modifiers but
6528 should be treated similarly to
6529 Mode_switch by Emacs. */
6530 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
6531 || ((unsigned)(orig_keysym
)
6533 && (unsigned)(orig_keysym
)
6534 <= XK_ISO_Last_Group_Lock
)
6538 STORE_KEYSYM_FOR_DEBUG (keysym
);
6539 /* make_lispy_event will convert this to a symbolic
6541 inev
.ie
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
6542 inev
.ie
.code
= keysym
;
6546 { /* Raw bytes, not keysym. */
6551 for (i
= 0, nchars
= 0; i
< nbytes
; i
++)
6553 if (ASCII_BYTE_P (copy_bufptr
[i
]))
6555 STORE_KEYSYM_FOR_DEBUG (copy_bufptr
[i
]);
6558 if (nchars
< nbytes
)
6560 /* Decode the input data. */
6564 /* The input should be decoded with `coding_system'
6565 which depends on which X*LookupString function
6566 we used just above and the locale. */
6567 setup_coding_system (coding_system
, &coding
);
6568 coding
.src_multibyte
= 0;
6569 coding
.dst_multibyte
= 1;
6570 /* The input is converted to events, thus we can't
6571 handle composition. Anyway, there's no XIM that
6572 gives us composition information. */
6573 coding
.common_flags
&= ~CODING_ANNOTATION_MASK
;
6575 require
= MAX_MULTIBYTE_LENGTH
* nbytes
;
6576 coding
.destination
= alloca (require
);
6577 coding
.dst_bytes
= require
;
6578 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
6579 decode_coding_c_string (&coding
, copy_bufptr
, nbytes
, Qnil
);
6580 nbytes
= coding
.produced
;
6581 nchars
= coding
.produced_char
;
6582 copy_bufptr
= coding
.destination
;
6585 /* Convert the input data to a sequence of
6586 character events. */
6587 for (i
= 0; i
< nbytes
; i
+= len
)
6589 if (nchars
== nbytes
)
6590 c
= copy_bufptr
[i
], len
= 1;
6592 c
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
,
6594 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (c
)
6595 ? ASCII_KEYSTROKE_EVENT
6596 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6598 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
6603 inev
.ie
.kind
= NO_EVENT
; /* Already stored above. */
6605 if (keysym
== NoSymbol
)
6611 /* Don't dispatch this event since XtDispatchEvent calls
6612 XFilterEvent, and two calls in a row may freeze the
6620 last_user_time
= event
.xkey
.time
;
6622 /* Don't dispatch this event since XtDispatchEvent calls
6623 XFilterEvent, and two calls in a row may freeze the
6631 last_user_time
= event
.xcrossing
.time
;
6632 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6634 f
= x_any_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
6636 if (f
&& x_mouse_click_focus_ignore_position
)
6637 ignore_next_mouse_click_timeout
= event
.xmotion
.time
+ 200;
6640 if (event
.xcrossing
.focus
)
6642 /* Avoid nasty pop/raise loops. */
6643 if (f
&& (!(f
->auto_raise
)
6645 || (event
.xcrossing
.time
- enter_timestamp
) > 500))
6647 x_new_focus_frame (dpyinfo
, f
);
6648 enter_timestamp
= event
.xcrossing
.time
;
6651 else if (f
== dpyinfo
->x_focus_frame
)
6652 x_new_focus_frame (dpyinfo
, 0);
6655 /* EnterNotify counts as mouse movement,
6656 so update things that depend on mouse position. */
6657 if (f
&& !f
->output_data
.x
->hourglass_p
)
6658 note_mouse_movement (f
, &event
.xmotion
);
6660 /* We may get an EnterNotify on the buttons in the toolbar. In that
6661 case we moved out of any highlighted area and need to note this. */
6662 if (!f
&& last_mouse_glyph_frame
)
6663 note_mouse_movement (last_mouse_glyph_frame
, &event
.xmotion
);
6668 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6672 last_user_time
= event
.xcrossing
.time
;
6673 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6675 f
= x_top_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
6678 if (f
== dpyinfo
->mouse_face_mouse_frame
)
6680 /* If we move outside the frame, then we're
6681 certainly no longer on any text in the frame. */
6682 clear_mouse_face (dpyinfo
);
6683 dpyinfo
->mouse_face_mouse_frame
= 0;
6686 /* Generate a nil HELP_EVENT to cancel a help-echo.
6687 Do it only if there's something to cancel.
6688 Otherwise, the startup message is cleared when
6689 the mouse leaves the frame. */
6690 if (any_help_event_p
)
6694 /* See comment in EnterNotify above */
6695 else if (last_mouse_glyph_frame
)
6696 note_mouse_movement (last_mouse_glyph_frame
, &event
.xmotion
);
6701 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6706 last_user_time
= event
.xmotion
.time
;
6707 previous_help_echo_string
= help_echo_string
;
6708 help_echo_string
= Qnil
;
6710 if (dpyinfo
->grabbed
&& last_mouse_frame
6711 && FRAME_LIVE_P (last_mouse_frame
))
6712 f
= last_mouse_frame
;
6714 f
= x_window_to_frame (dpyinfo
, event
.xmotion
.window
);
6716 if (dpyinfo
->mouse_face_hidden
)
6718 dpyinfo
->mouse_face_hidden
= 0;
6719 clear_mouse_face (dpyinfo
);
6725 /* Generate SELECT_WINDOW_EVENTs when needed. */
6726 if (!NILP (Vmouse_autoselect_window
))
6730 window
= window_from_coordinates (f
,
6731 event
.xmotion
.x
, event
.xmotion
.y
,
6734 /* Window will be selected only when it is not selected now and
6735 last mouse movement event was not in it. Minibuffer window
6736 will be selected only when it is active. */
6737 if (WINDOWP (window
)
6738 && !EQ (window
, last_window
)
6739 && !EQ (window
, selected_window
)
6740 /* For click-to-focus window managers
6741 create event iff we don't leave the
6743 && (focus_follows_mouse
6744 || (EQ (XWINDOW (window
)->frame
,
6745 XWINDOW (selected_window
)->frame
))))
6747 inev
.ie
.kind
= SELECT_WINDOW_EVENT
;
6748 inev
.ie
.frame_or_window
= window
;
6753 if (!note_mouse_movement (f
, &event
.xmotion
))
6754 help_echo_string
= previous_help_echo_string
;
6758 #ifndef USE_TOOLKIT_SCROLL_BARS
6759 struct scroll_bar
*bar
6760 = x_window_to_scroll_bar (event
.xmotion
.display
,
6761 event
.xmotion
.window
);
6764 x_scroll_bar_note_movement (bar
, &event
);
6765 #endif /* USE_TOOLKIT_SCROLL_BARS */
6767 /* If we move outside the frame, then we're
6768 certainly no longer on any text in the frame. */
6769 clear_mouse_face (dpyinfo
);
6772 /* If the contents of the global variable help_echo_string
6773 has changed, generate a HELP_EVENT. */
6774 if (!NILP (help_echo_string
)
6775 || !NILP (previous_help_echo_string
))
6780 case ConfigureNotify
:
6781 f
= x_top_window_to_frame (dpyinfo
, event
.xconfigure
.window
);
6784 && (f
= x_any_window_to_frame (dpyinfo
, event
.xconfigure
.window
))
6785 && event
.xconfigure
.window
== FRAME_X_WINDOW (f
))
6787 xg_frame_resized (f
, event
.xconfigure
.width
,
6788 event
.xconfigure
.height
);
6794 #ifndef USE_X_TOOLKIT
6796 /* If there is a pending resize for fullscreen, don't
6797 do this one, the right one will come later.
6798 The toolkit version doesn't seem to need this, but we
6799 need to reset it below. */
6801 = ((f
->want_fullscreen
& FULLSCREEN_WAIT
)
6802 && f
->new_text_cols
!= 0);
6803 int rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, event
.xconfigure
.height
);
6804 int columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, event
.xconfigure
.width
);
6809 /* In the toolkit version, change_frame_size
6810 is called by the code that handles resizing
6811 of the EmacsFrame widget. */
6813 /* Even if the number of character rows and columns has
6814 not changed, the font size may have changed, so we need
6815 to check the pixel dimensions as well. */
6816 if (columns
!= FRAME_COLS (f
)
6817 || rows
!= FRAME_LINES (f
)
6818 || event
.xconfigure
.width
!= FRAME_PIXEL_WIDTH (f
)
6819 || event
.xconfigure
.height
!= FRAME_PIXEL_HEIGHT (f
))
6821 change_frame_size (f
, rows
, columns
, 0, 1, 0);
6822 SET_FRAME_GARBAGED (f
);
6823 cancel_mouse_face (f
);
6826 FRAME_PIXEL_WIDTH (f
) = event
.xconfigure
.width
;
6827 FRAME_PIXEL_HEIGHT (f
) = event
.xconfigure
.height
;
6828 #endif /* not USE_GTK */
6832 /* GTK creates windows but doesn't map them.
6833 Only get real positions and check fullscreen when mapped. */
6834 if (FRAME_GTK_OUTER_WIDGET (f
)
6835 && GTK_WIDGET_MAPPED (FRAME_GTK_OUTER_WIDGET (f
)))
6838 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
6840 if (f
->want_fullscreen
& FULLSCREEN_WAIT
)
6841 f
->want_fullscreen
&= ~(FULLSCREEN_WAIT
|FULLSCREEN_BOTH
);
6845 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
6846 xic_set_statusarea (f
);
6849 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
6851 /* Since the WM decorations come below top_pos now,
6852 we must put them below top_pos in the future. */
6853 f
->win_gravity
= NorthWestGravity
;
6854 x_wm_set_size_hint (f
, (long) 0, 0);
6862 /* If we decide we want to generate an event to be seen
6863 by the rest of Emacs, we put it here. */
6866 bzero (&compose_status
, sizeof (compose_status
));
6867 last_mouse_glyph_frame
= 0;
6868 last_user_time
= event
.xbutton
.time
;
6870 if (dpyinfo
->grabbed
6872 && FRAME_LIVE_P (last_mouse_frame
))
6873 f
= last_mouse_frame
;
6875 f
= x_window_to_frame (dpyinfo
, event
.xbutton
.window
);
6879 /* Is this in the tool-bar? */
6880 if (WINDOWP (f
->tool_bar_window
)
6881 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
6884 int x
= event
.xbutton
.x
;
6885 int y
= event
.xbutton
.y
;
6887 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 1);
6888 tool_bar_p
= EQ (window
, f
->tool_bar_window
);
6890 if (tool_bar_p
&& event
.xbutton
.button
< 4)
6892 handle_tool_bar_click (f
, x
, y
,
6893 event
.xbutton
.type
== ButtonPress
,
6894 x_x_to_emacs_modifiers (dpyinfo
,
6895 event
.xbutton
.state
));
6900 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6901 if (! popup_activated ())
6904 if (ignore_next_mouse_click_timeout
)
6906 if (event
.type
== ButtonPress
6907 && (int)(event
.xbutton
.time
- ignore_next_mouse_click_timeout
) > 0)
6909 ignore_next_mouse_click_timeout
= 0;
6910 construct_mouse_click (&inev
.ie
, &event
.xbutton
, f
);
6912 if (event
.type
== ButtonRelease
)
6913 ignore_next_mouse_click_timeout
= 0;
6916 construct_mouse_click (&inev
.ie
, &event
.xbutton
, f
);
6918 if (FRAME_X_EMBEDDED_P (f
))
6919 xembed_send_message (f
, event
.xbutton
.time
,
6920 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
6924 struct scroll_bar
*bar
6925 = x_window_to_scroll_bar (event
.xbutton
.display
,
6926 event
.xbutton
.window
);
6928 #ifdef USE_TOOLKIT_SCROLL_BARS
6929 /* Make the "Ctrl-Mouse-2 splits window" work for toolkit
6931 if (bar
&& event
.xbutton
.state
& ControlMask
)
6933 x_scroll_bar_handle_click (bar
, &event
, &inev
.ie
);
6934 *finish
= X_EVENT_DROP
;
6936 #else /* not USE_TOOLKIT_SCROLL_BARS */
6938 x_scroll_bar_handle_click (bar
, &event
, &inev
.ie
);
6939 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6942 if (event
.type
== ButtonPress
)
6944 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
6945 last_mouse_frame
= f
;
6948 last_tool_bar_item
= -1;
6951 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
6953 /* Ignore any mouse motion that happened before this event;
6954 any subsequent mouse-movement Emacs events should reflect
6955 only motion after the ButtonPress/Release. */
6959 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6960 f
= x_menubar_window_to_frame (dpyinfo
, event
.xbutton
.window
);
6961 /* For a down-event in the menu bar,
6962 don't pass it to Xt right now.
6963 Instead, save it away
6964 and we will pass it to Xt from kbd_buffer_get_event.
6965 That way, we can run some Lisp code first. */
6968 ! popup_activated ()
6969 /* Gtk+ menus only react to the first three buttons. */
6970 && event
.xbutton
.button
< 3
6973 f
&& event
.type
== ButtonPress
6974 /* Verify the event is really within the menu bar
6975 and not just sent to it due to grabbing. */
6976 && event
.xbutton
.x
>= 0
6977 && event
.xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
6978 && event
.xbutton
.y
>= 0
6979 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
6980 && event
.xbutton
.same_screen
)
6982 SET_SAVED_BUTTON_EVENT
;
6983 XSETFRAME (last_mouse_press_frame
, f
);
6985 *finish
= X_EVENT_DROP
;
6988 else if (event
.type
== ButtonPress
)
6990 last_mouse_press_frame
= Qnil
;
6994 #ifdef USE_MOTIF /* This should do not harm for Lucid,
6995 but I am trying to be cautious. */
6996 else if (event
.type
== ButtonRelease
)
6998 if (!NILP (last_mouse_press_frame
))
7000 f
= XFRAME (last_mouse_press_frame
);
7001 if (f
->output_data
.x
)
7002 SET_SAVED_BUTTON_EVENT
;
7007 #endif /* USE_MOTIF */
7010 #endif /* USE_X_TOOLKIT || USE_GTK */
7014 case CirculateNotify
:
7017 case CirculateRequest
:
7020 case VisibilityNotify
:
7024 /* Someone has changed the keyboard mapping - update the
7026 switch (event
.xmapping
.request
)
7028 case MappingModifier
:
7029 x_find_modifier_meanings (dpyinfo
);
7030 /* This is meant to fall through. */
7031 case MappingKeyboard
:
7032 XRefreshKeyboardMapping (&event
.xmapping
);
7038 #ifdef USE_X_TOOLKIT
7040 if (*finish
!= X_EVENT_DROP
)
7041 XtDispatchEvent (&event
);
7043 #endif /* USE_X_TOOLKIT */
7048 if (inev
.ie
.kind
!= NO_EVENT
)
7050 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
7055 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
7060 XSETFRAME (frame
, f
);
7066 any_help_event_p
= 1;
7067 gen_help_event (help_echo_string
, frame
, help_echo_window
,
7068 help_echo_object
, help_echo_pos
);
7072 help_echo_string
= Qnil
;
7073 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
7083 /* Handles the XEvent EVENT on display DISPLAY.
7084 This is used for event loops outside the normal event handling,
7085 i.e. looping while a popup menu or a dialog is posted.
7087 Returns the value handle_one_xevent sets in the finish argument. */
7089 x_dispatch_event (event
, display
)
7093 struct x_display_info
*dpyinfo
;
7094 int finish
= X_EVENT_NORMAL
;
7096 dpyinfo
= x_display_info_for_display (display
);
7099 handle_one_xevent (dpyinfo
, event
, &finish
, 0);
7105 /* Read events coming from the X server.
7106 This routine is called by the SIGIO handler.
7107 We return as soon as there are no more events to be read.
7109 We return the number of characters stored into the buffer,
7110 thus pretending to be `read' (except the characters we store
7111 in the keyboard buffer can be multibyte, so are not necessarily
7114 EXPECTED is nonzero if the caller knows input is available. */
7117 XTread_socket (terminal
, expected
, hold_quit
)
7118 struct terminal
*terminal
;
7120 struct input_event
*hold_quit
;
7124 int event_found
= 0;
7126 struct x_display_info
*dpyinfo
;
7129 if (interrupt_input_blocked
)
7131 interrupt_input_pending
= 1;
7135 interrupt_input_pending
= 0;
7138 /* So people can tell when we have read the available input. */
7139 input_signal_count
++;
7144 /* Only check session manager input for the primary display. */
7145 if (terminal
->id
== 1 && x_session_have_connection ())
7147 struct input_event inev
;
7149 /* We don't need to EVENT_INIT (inev) here, as
7150 x_session_check_input copies an entire input_event. */
7151 if (x_session_check_input (&inev
))
7153 kbd_buffer_store_event_hold (&inev
, hold_quit
);
7160 /* For debugging, this gives a way to fake an I/O error. */
7161 if (terminal
->display_info
.x
== XTread_socket_fake_io_error
)
7163 XTread_socket_fake_io_error
= 0;
7164 x_io_error_quitter (terminal
->display_info
.x
->display
);
7167 #if 0 /* This loop is a noop now. */
7168 /* Find the display we are supposed to read input for.
7169 It's the one communicating on descriptor SD. */
7170 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
7172 #if 0 /* This ought to be unnecessary; let's verify it. */
7174 /* If available, Xlib uses FIOSNBIO to make the socket
7175 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
7176 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
7177 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
7178 fcntl (dpyinfo
->connection
, F_SETFL
, 0);
7179 #endif /* ! defined (FIOSNBIO) */
7182 #if 0 /* This code can't be made to work, with multiple displays,
7183 and appears not to be used on any system any more.
7184 Also keyboard.c doesn't turn O_NDELAY on and off
7185 for X connections. */
7188 if (! (fcntl (dpyinfo
->connection
, F_GETFL
, 0) & O_NDELAY
))
7190 extern int read_alarm_should_throw
;
7191 read_alarm_should_throw
= 1;
7192 XPeekEvent (dpyinfo
->display
, &event
);
7193 read_alarm_should_throw
= 0;
7195 #endif /* HAVE_SELECT */
7202 while (XPending (terminal
->display_info
.x
->display
))
7206 XNextEvent (terminal
->display_info
.x
->display
, &event
);
7209 /* Filter events for the current X input method. */
7210 if (x_filter_event (terminal
->display_info
.x
, &event
))
7215 count
+= handle_one_xevent (terminal
->display_info
.x
,
7216 &event
, &finish
, hold_quit
);
7218 if (finish
== X_EVENT_GOTO_OUT
)
7224 /* For GTK we must use the GTK event loop. But XEvents gets passed
7225 to our filter function above, and then to the big event switch.
7226 We use a bunch of globals to communicate with our filter function,
7227 that is kind of ugly, but it works.
7229 There is no way to do one display at the time, GTK just does events
7230 from all displays. */
7232 while (gtk_events_pending ())
7234 current_count
= count
;
7235 current_hold_quit
= hold_quit
;
7237 gtk_main_iteration ();
7239 count
= current_count
;
7241 current_hold_quit
= 0;
7243 if (current_finish
== X_EVENT_GOTO_OUT
)
7246 #endif /* USE_GTK */
7250 /* On some systems, an X bug causes Emacs to get no more events
7251 when the window is destroyed. Detect that. (1994.) */
7254 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
7255 One XNOOP in 100 loops will make Emacs terminate.
7256 B. Bretthauer, 1994 */
7258 if (x_noop_count
>= 100)
7262 if (next_noop_dpyinfo
== 0)
7263 next_noop_dpyinfo
= x_display_list
;
7265 XNoOp (next_noop_dpyinfo
->display
);
7267 /* Each time we get here, cycle through the displays now open. */
7268 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
7272 /* If the focus was just given to an auto-raising frame,
7274 /* ??? This ought to be able to handle more than one such frame. */
7275 if (pending_autoraise_frame
)
7277 x_raise_frame (pending_autoraise_frame
);
7278 pending_autoraise_frame
= 0;
7290 /***********************************************************************
7292 ***********************************************************************/
7294 /* Set clipping for output in glyph row ROW. W is the window in which
7295 we operate. GC is the graphics context to set clipping in.
7297 ROW may be a text row or, e.g., a mode line. Text rows must be
7298 clipped to the interior of the window dedicated to text display,
7299 mode lines must be clipped to the whole window. */
7302 x_clip_to_row (w
, row
, area
, gc
)
7304 struct glyph_row
*row
;
7308 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7309 XRectangle clip_rect
;
7310 int window_x
, window_y
, window_width
;
7312 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
7314 clip_rect
.x
= window_x
;
7315 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, row
->y
));
7316 clip_rect
.y
= max (clip_rect
.y
, window_y
);
7317 clip_rect
.width
= window_width
;
7318 clip_rect
.height
= row
->visible_height
;
7320 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
7324 /* Draw a hollow box cursor on window W in glyph row ROW. */
7327 x_draw_hollow_cursor (w
, row
)
7329 struct glyph_row
*row
;
7331 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7332 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7333 Display
*dpy
= FRAME_X_DISPLAY (f
);
7336 struct glyph
*cursor_glyph
;
7339 /* Get the glyph the cursor is on. If we can't tell because
7340 the current matrix is invalid or such, give up. */
7341 cursor_glyph
= get_phys_cursor_glyph (w
);
7342 if (cursor_glyph
== NULL
)
7345 /* Compute frame-relative coordinates for phys cursor. */
7346 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &x
, &y
, &h
);
7347 wd
= w
->phys_cursor_width
;
7349 /* The foreground of cursor_gc is typically the same as the normal
7350 background color, which can cause the cursor box to be invisible. */
7351 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7352 if (dpyinfo
->scratch_cursor_gc
)
7353 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
7355 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
7356 GCForeground
, &xgcv
);
7357 gc
= dpyinfo
->scratch_cursor_gc
;
7359 /* Set clipping, draw the rectangle, and reset clipping again. */
7360 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7361 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
- 1);
7362 XSetClipMask (dpy
, gc
, None
);
7366 /* Draw a bar cursor on window W in glyph row ROW.
7368 Implementation note: One would like to draw a bar cursor with an
7369 angle equal to the one given by the font property XA_ITALIC_ANGLE.
7370 Unfortunately, I didn't find a font yet that has this property set.
7374 x_draw_bar_cursor (w
, row
, width
, kind
)
7376 struct glyph_row
*row
;
7378 enum text_cursor_kinds kind
;
7380 struct frame
*f
= XFRAME (w
->frame
);
7381 struct glyph
*cursor_glyph
;
7383 /* If cursor is out of bounds, don't draw garbage. This can happen
7384 in mini-buffer windows when switching between echo area glyphs
7386 cursor_glyph
= get_phys_cursor_glyph (w
);
7387 if (cursor_glyph
== NULL
)
7390 /* If on an image, draw like a normal cursor. That's usually better
7391 visible than drawing a bar, esp. if the image is large so that
7392 the bar might not be in the window. */
7393 if (cursor_glyph
->type
== IMAGE_GLYPH
)
7395 struct glyph_row
*row
;
7396 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
7397 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
7401 Display
*dpy
= FRAME_X_DISPLAY (f
);
7402 Window window
= FRAME_X_WINDOW (f
);
7403 GC gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
7404 unsigned long mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
7405 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
7408 /* If the glyph's background equals the color we normally draw
7409 the bar cursor in, the bar cursor in its normal color is
7410 invisible. Use the glyph's foreground color instead in this
7411 case, on the assumption that the glyph's colors are chosen so
7412 that the glyph is legible. */
7413 if (face
->background
== f
->output_data
.x
->cursor_pixel
)
7414 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
7416 xgcv
.background
= xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7417 xgcv
.graphics_exposures
= 0;
7420 XChangeGC (dpy
, gc
, mask
, &xgcv
);
7423 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
7424 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
7428 width
= FRAME_CURSOR_WIDTH (f
);
7429 width
= min (cursor_glyph
->pixel_width
, width
);
7431 w
->phys_cursor_width
= width
;
7432 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7434 if (kind
== BAR_CURSOR
)
7435 XFillRectangle (dpy
, window
, gc
,
7436 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
7437 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
7438 width
, row
->height
);
7440 XFillRectangle (dpy
, window
, gc
,
7441 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
7442 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
7443 row
->height
- width
),
7444 cursor_glyph
->pixel_width
,
7447 XSetClipMask (dpy
, gc
, None
);
7452 /* RIF: Define cursor CURSOR on frame F. */
7455 x_define_frame_cursor (f
, cursor
)
7459 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
7463 /* RIF: Clear area on frame F. */
7466 x_clear_frame_area (f
, x
, y
, width
, height
)
7468 int x
, y
, width
, height
;
7470 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7471 x
, y
, width
, height
, False
);
7475 /* RIF: Draw cursor on window W. */
7478 x_draw_window_cursor (w
, glyph_row
, x
, y
, cursor_type
, cursor_width
, on_p
, active_p
)
7480 struct glyph_row
*glyph_row
;
7482 int cursor_type
, cursor_width
;
7485 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7489 w
->phys_cursor_type
= cursor_type
;
7490 w
->phys_cursor_on_p
= 1;
7492 if (glyph_row
->exact_window_width_line_p
7493 && w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])
7495 glyph_row
->cursor_in_fringe_p
= 1;
7496 draw_fringe_bitmap (w
, glyph_row
, 0);
7499 switch (cursor_type
)
7501 case HOLLOW_BOX_CURSOR
:
7502 x_draw_hollow_cursor (w
, glyph_row
);
7505 case FILLED_BOX_CURSOR
:
7506 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
7510 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
7514 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
7518 w
->phys_cursor_width
= 0;
7526 if (w
== XWINDOW (f
->selected_window
))
7527 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
7528 xic_set_preeditarea (w
, x
, y
);
7533 XFlush (FRAME_X_DISPLAY (f
));
7540 /* Make the x-window of frame F use the gnu icon bitmap. */
7543 x_bitmap_icon (f
, file
)
7549 if (FRAME_X_WINDOW (f
) == 0)
7552 /* Free up our existing icon bitmap and mask if any. */
7553 if (f
->output_data
.x
->icon_bitmap
> 0)
7554 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7555 f
->output_data
.x
->icon_bitmap
= 0;
7560 /* Use gtk_window_set_icon_from_file () if available,
7561 It's not restricted to bitmaps */
7562 if (xg_set_icon (f
, file
))
7564 #endif /* USE_GTK */
7565 bitmap_id
= x_create_bitmap_from_file (f
, file
);
7566 x_create_bitmap_mask (f
, bitmap_id
);
7570 /* Create the GNU bitmap and mask if necessary. */
7571 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
7575 #if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
7577 if (xg_set_icon_from_xpm_data (f
, gnu_xpm_bits
))
7580 rc
= x_create_bitmap_from_xpm_data (f
, gnu_xpm_bits
);
7582 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
7583 #endif /* USE_GTK */
7584 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
7586 /* If all else fails, use the (black and white) xbm image. */
7589 rc
= x_create_bitmap_from_data (f
, gnu_xbm_bits
,
7590 gnu_xbm_width
, gnu_xbm_height
);
7594 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
7595 x_create_bitmap_mask (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
7599 /* The first time we create the GNU bitmap and mask,
7600 this increments the ref-count one extra time.
7601 As a result, the GNU bitmap and mask are never freed.
7602 That way, we don't have to worry about allocating it again. */
7603 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
7605 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
7608 x_wm_set_icon_pixmap (f
, bitmap_id
);
7609 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
7615 /* Make the x-window of frame F use a rectangle with text.
7616 Use ICON_NAME as the text. */
7619 x_text_icon (f
, icon_name
)
7623 if (FRAME_X_WINDOW (f
) == 0)
7628 text
.value
= (unsigned char *) icon_name
;
7629 text
.encoding
= XA_STRING
;
7631 text
.nitems
= strlen (icon_name
);
7632 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
7635 if (f
->output_data
.x
->icon_bitmap
> 0)
7636 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7637 f
->output_data
.x
->icon_bitmap
= 0;
7638 x_wm_set_icon_pixmap (f
, 0);
7643 #define X_ERROR_MESSAGE_SIZE 200
7645 /* If non-nil, this should be a string.
7646 It means catch X errors and store the error message in this string.
7648 The reason we use a stack is that x_catch_error/x_uncatch_error can
7649 be called from a signal handler.
7652 struct x_error_message_stack
{
7653 char string
[X_ERROR_MESSAGE_SIZE
];
7655 struct x_error_message_stack
*prev
;
7657 static struct x_error_message_stack
*x_error_message
;
7659 /* An X error handler which stores the error message in
7660 *x_error_message. This is called from x_error_handler if
7661 x_catch_errors is in effect. */
7664 x_error_catcher (display
, error
)
7668 XGetErrorText (display
, error
->error_code
,
7669 x_error_message
->string
,
7670 X_ERROR_MESSAGE_SIZE
);
7673 /* Begin trapping X errors for display DPY. Actually we trap X errors
7674 for all displays, but DPY should be the display you are actually
7677 After calling this function, X protocol errors no longer cause
7678 Emacs to exit; instead, they are recorded in the string
7679 stored in *x_error_message.
7681 Calling x_check_errors signals an Emacs error if an X error has
7682 occurred since the last call to x_catch_errors or x_check_errors.
7684 Calling x_uncatch_errors resumes the normal error handling. */
7686 void x_check_errors ();
7689 x_catch_errors (dpy
)
7692 struct x_error_message_stack
*data
= xmalloc (sizeof (*data
));
7694 /* Make sure any errors from previous requests have been dealt with. */
7698 data
->string
[0] = 0;
7699 data
->prev
= x_error_message
;
7700 x_error_message
= data
;
7703 /* Undo the last x_catch_errors call.
7704 DPY should be the display that was passed to x_catch_errors. */
7709 struct x_error_message_stack
*tmp
;
7713 /* The display may have been closed before this function is called.
7714 Check if it is still open before calling XSync. */
7715 if (x_display_info_for_display (x_error_message
->dpy
) != 0)
7716 XSync (x_error_message
->dpy
, False
);
7718 tmp
= x_error_message
;
7719 x_error_message
= x_error_message
->prev
;
7724 /* If any X protocol errors have arrived since the last call to
7725 x_catch_errors or x_check_errors, signal an Emacs error using
7726 sprintf (a buffer, FORMAT, the x error message text) as the text. */
7729 x_check_errors (dpy
, format
)
7733 /* Make sure to catch any errors incurred so far. */
7736 if (x_error_message
->string
[0])
7738 char string
[X_ERROR_MESSAGE_SIZE
];
7739 bcopy (x_error_message
->string
, string
, X_ERROR_MESSAGE_SIZE
);
7740 x_uncatch_errors ();
7741 error (format
, string
);
7745 /* Nonzero if we had any X protocol errors
7746 since we did x_catch_errors on DPY. */
7749 x_had_errors_p (dpy
)
7752 /* Make sure to catch any errors incurred so far. */
7755 return x_error_message
->string
[0] != 0;
7758 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
7761 x_clear_errors (dpy
)
7764 x_error_message
->string
[0] = 0;
7767 #if 0 /* See comment in unwind_to_catch why calling this is a bad
7768 * idea. --lorentey */
7769 /* Close off all unclosed x_catch_errors calls. */
7772 x_fully_uncatch_errors ()
7774 while (x_error_message
)
7775 x_uncatch_errors ();
7779 /* Nonzero if x_catch_errors has been done and not yet canceled. */
7782 x_catching_errors ()
7784 return x_error_message
!= 0;
7788 static unsigned int x_wire_count
;
7791 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
7796 /* Handle SIGPIPE, which can happen when the connection to a server
7797 simply goes away. SIGPIPE is handled by x_connection_signal.
7798 Don't need to do anything, because the write which caused the
7799 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
7800 which will do the appropriate cleanup for us. */
7803 x_connection_signal (signalnum
) /* If we don't have an argument, */
7804 int signalnum
; /* some compilers complain in signal calls. */
7807 /* USG systems forget handlers when they are used;
7808 must reestablish each time */
7809 signal (signalnum
, x_connection_signal
);
7814 /************************************************************************
7816 ************************************************************************/
7818 /* Error message passed to x_connection_closed. */
7820 static char *error_msg
;
7822 /* Function installed as fatal_error_signal_hook in
7823 x_connection_closed. Print the X error message, and exit normally,
7824 instead of dumping core when XtCloseDisplay fails. */
7827 x_fatal_error_signal ()
7829 fprintf (stderr
, "%s\n", error_msg
);
7833 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
7834 the text of an error message that lead to the connection loss. */
7837 x_connection_closed (dpy
, error_message
)
7839 char *error_message
;
7841 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
7842 Lisp_Object frame
, tail
;
7843 int index
= SPECPDL_INDEX ();
7845 error_msg
= (char *) alloca (strlen (error_message
) + 1);
7846 strcpy (error_msg
, error_message
);
7847 handling_signal
= 0;
7849 /* Prevent being called recursively because of an error condition
7850 below. Otherwise, we might end up with printing ``can't find per
7851 display information'' in the recursive call instead of printing
7852 the original message here. */
7853 x_catch_errors (dpy
);
7855 /* Inhibit redisplay while frames are being deleted. */
7856 specbind (Qinhibit_redisplay
, Qt
);
7860 /* Protect display from being closed when we delete the last
7862 dpyinfo
->reference_count
++;
7863 dpyinfo
->terminal
->reference_count
++;
7866 /* First delete frames whose mini-buffers are on frames
7867 that are on the dead display. */
7868 FOR_EACH_FRAME (tail
, frame
)
7870 Lisp_Object minibuf_frame
;
7872 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
7873 if (FRAME_X_P (XFRAME (frame
))
7874 && FRAME_X_P (XFRAME (minibuf_frame
))
7875 && ! EQ (frame
, minibuf_frame
)
7876 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
7877 Fdelete_frame (frame
, Qnoelisp
);
7880 /* Now delete all remaining frames on the dead display.
7881 We are now sure none of these is used as the mini-buffer
7882 for another frame that we need to delete. */
7883 FOR_EACH_FRAME (tail
, frame
)
7884 if (FRAME_X_P (XFRAME (frame
))
7885 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
7887 /* Set this to t so that Fdelete_frame won't get confused
7888 trying to find a replacement. */
7889 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
7890 Fdelete_frame (frame
, Qnoelisp
);
7893 /* We have to close the display to inform Xt that it doesn't
7894 exist anymore. If we don't, Xt will continue to wait for
7895 events from the display. As a consequence, a sequence of
7897 M-x make-frame-on-display RET :1 RET
7898 ...kill the new frame, so that we get an IO error...
7899 M-x make-frame-on-display RET :1 RET
7901 will indefinitely wait in Xt for events for display `:1', opened
7902 in the first call to make-frame-on-display.
7904 Closing the display is reported to lead to a bus error on
7905 OpenWindows in certain situations. I suspect that is a bug
7906 in OpenWindows. I don't know how to circumvent it here. */
7910 #ifdef USE_X_TOOLKIT
7911 /* If DPYINFO is null, this means we didn't open the display
7912 in the first place, so don't try to close it. */
7914 extern void (*fatal_error_signal_hook
) P_ ((void));
7915 fatal_error_signal_hook
= x_fatal_error_signal
;
7916 XtCloseDisplay (dpy
);
7917 fatal_error_signal_hook
= NULL
;
7922 /* Due to bugs in some Gtk+ versions, just exit here if this
7923 is the last display/terminal. */
7924 if (terminal_list
->next_terminal
== NULL
)
7926 fprintf (stderr
, "%s\n", error_msg
);
7927 shut_down_emacs (0, 0, Qnil
);
7930 xg_display_close (dpyinfo
->display
);
7933 /* Indicate that this display is dead. */
7934 dpyinfo
->display
= 0;
7936 dpyinfo
->reference_count
--;
7937 dpyinfo
->terminal
->reference_count
--;
7938 if (dpyinfo
->reference_count
!= 0)
7939 /* We have just closed all frames on this display. */
7944 XSETTERMINAL (tmp
, dpyinfo
->terminal
);
7945 Fdelete_terminal (tmp
, Qnoelisp
);
7949 x_uncatch_errors ();
7951 if (terminal_list
== 0)
7953 fprintf (stderr
, "%s\n", error_msg
);
7954 shut_down_emacs (0, 0, Qnil
);
7958 /* Ordinary stack unwind doesn't deal with these. */
7960 sigunblock (sigmask (SIGIO
));
7962 sigunblock (sigmask (SIGALRM
));
7963 TOTALLY_UNBLOCK_INPUT
;
7965 unbind_to (index
, Qnil
);
7966 clear_waiting_for_input ();
7967 /* Here, we absolutely have to use a non-local exit (e.g. signal, throw,
7968 longjmp), because returning from this function would get us back into
7969 Xlib's code which will directly call `exit'. */
7970 error ("%s", error_msg
);
7973 /* We specifically use it before defining it, so that gcc doesn't inline it,
7974 otherwise gdb doesn't know how to properly put a breakpoint on it. */
7975 static void x_error_quitter
P_ ((Display
*, XErrorEvent
*));
7977 /* This is the first-level handler for X protocol errors.
7978 It calls x_error_quitter or x_error_catcher. */
7981 x_error_handler (display
, error
)
7985 if (x_error_message
)
7986 x_error_catcher (display
, error
);
7988 x_error_quitter (display
, error
);
7992 /* This is the usual handler for X protocol errors.
7993 It kills all frames on the display that we got the error for.
7994 If that was the only one, it prints an error message and kills Emacs. */
7996 /* .gdbinit puts a breakpoint here, so make sure it is not inlined. */
7998 #if __GNUC__ >= 3 /* On GCC 3.0 we might get a warning. */
7999 #define NO_INLINE __attribute__((noinline))
8004 /* Some versions of GNU/Linux define noinline in their headers. */
8010 /* On older GCC versions, just putting x_error_quitter
8011 after x_error_handler prevents inlining into the former. */
8013 static void NO_INLINE
8014 x_error_quitter (display
, error
)
8018 char buf
[256], buf1
[356];
8020 /* Ignore BadName errors. They can happen because of fonts
8021 or colors that are not defined. */
8023 if (error
->error_code
== BadName
)
8026 /* Note that there is no real way portable across R3/R4 to get the
8027 original error handler. */
8029 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
8030 sprintf (buf1
, "X protocol error: %s on protocol request %d",
8031 buf
, error
->request_code
);
8032 x_connection_closed (display
, buf1
);
8036 /* This is the handler for X IO errors, always.
8037 It kills all frames on the display that we lost touch with.
8038 If that was the only one, it prints an error message and kills Emacs. */
8041 x_io_error_quitter (display
)
8046 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
8047 x_connection_closed (display
, buf
);
8051 /* Changing the font of the frame. */
8053 /* Give frame F the font FONT-OBJECT as its default font. The return
8054 value is FONT-OBJECT. FONTSET is an ID of the fontset for the
8055 frame. If it is negative, generate a new fontset from
8059 x_new_font (f
, font_object
, fontset
)
8061 Lisp_Object font_object
;
8064 struct font
*font
= XFONT_OBJECT (font_object
);
8067 fontset
= fontset_from_font (font_object
);
8068 FRAME_FONTSET (f
) = fontset
;
8069 if (FRAME_FONT (f
) == font
)
8070 /* This font is already set in frame F. There's nothing more to
8074 FRAME_FONT (f
) = font
;
8075 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
8076 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
8077 FRAME_SPACE_WIDTH (f
) = font
->space_width
;
8078 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (font
);
8080 compute_fringe_widths (f
, 1);
8082 /* Compute the scroll bar width in character columns. */
8083 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
8085 int wid
= FRAME_COLUMN_WIDTH (f
);
8086 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
8087 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
-1) / wid
;
8091 int wid
= FRAME_COLUMN_WIDTH (f
);
8092 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
8095 if (FRAME_X_WINDOW (f
) != 0)
8097 /* Don't change the size of a tip frame; there's no point in
8098 doing it because it's done in Fx_show_tip, and it leads to
8099 problems because the tip frame has no widget. */
8100 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
8101 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
8106 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
8109 xic_set_xfontset (f
, SDATA (fontset_ascii (fontset
)));
8118 /***********************************************************************
8120 ***********************************************************************/
8126 /* XIM destroy callback function, which is called whenever the
8127 connection to input method XIM dies. CLIENT_DATA contains a
8128 pointer to the x_display_info structure corresponding to XIM. */
8131 xim_destroy_callback (xim
, client_data
, call_data
)
8133 XPointer client_data
;
8136 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
8137 Lisp_Object frame
, tail
;
8141 /* No need to call XDestroyIC.. */
8142 FOR_EACH_FRAME (tail
, frame
)
8144 struct frame
*f
= XFRAME (frame
);
8145 if (FRAME_X_P (f
) && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
8147 FRAME_XIC (f
) = NULL
;
8148 xic_free_xfontset (f
);
8152 /* No need to call XCloseIM. */
8153 dpyinfo
->xim
= NULL
;
8154 XFree (dpyinfo
->xim_styles
);
8158 #endif /* HAVE_X11R6 */
8161 /* This isn't prototyped in OSF 5.0 or 5.1a. */
8162 extern char *XSetIMValues
P_ ((XIM
, ...));
8165 /* Open the connection to the XIM server on display DPYINFO.
8166 RESOURCE_NAME is the resource name Emacs uses. */
8169 xim_open_dpy (dpyinfo
, resource_name
)
8170 struct x_display_info
*dpyinfo
;
8171 char *resource_name
;
8178 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
,
8185 XIMCallback destroy
;
8188 /* Get supported styles and XIM values. */
8189 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
8192 destroy
.callback
= xim_destroy_callback
;
8193 destroy
.client_data
= (XPointer
)dpyinfo
;
8194 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
8200 #endif /* HAVE_XIM */
8201 dpyinfo
->xim
= NULL
;
8205 #ifdef HAVE_X11R6_XIM
8209 struct x_display_info
*dpyinfo
;
8210 char *resource_name
;
8213 /* XIM instantiate callback function, which is called whenever an XIM
8214 server is available. DISPLAY is the display of the XIM.
8215 CLIENT_DATA contains a pointer to an xim_inst_t structure created
8216 when the callback was registered. */
8219 xim_instantiate_callback (display
, client_data
, call_data
)
8221 XPointer client_data
;
8224 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
8225 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
8227 /* We don't support multiple XIM connections. */
8231 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
8233 /* Create XIC for the existing frames on the same display, as long
8234 as they have no XIC. */
8235 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
8237 Lisp_Object tail
, frame
;
8240 FOR_EACH_FRAME (tail
, frame
)
8242 struct frame
*f
= XFRAME (frame
);
8245 && FRAME_X_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
8246 if (FRAME_XIC (f
) == NULL
)
8248 create_frame_xic (f
);
8249 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
8250 xic_set_statusarea (f
);
8251 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
8253 struct window
*w
= XWINDOW (f
->selected_window
);
8254 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
8263 #endif /* HAVE_X11R6_XIM */
8266 /* Open a connection to the XIM server on display DPYINFO.
8267 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
8268 connection only at the first time. On X11R6, open the connection
8269 in the XIM instantiate callback function. */
8272 xim_initialize (dpyinfo
, resource_name
)
8273 struct x_display_info
*dpyinfo
;
8274 char *resource_name
;
8279 #ifdef HAVE_X11R6_XIM
8280 struct xim_inst_t
*xim_inst
;
8283 dpyinfo
->xim
= NULL
;
8284 xim_inst
= (struct xim_inst_t
*) xmalloc (sizeof (struct xim_inst_t
));
8285 xim_inst
->dpyinfo
= dpyinfo
;
8286 len
= strlen (resource_name
);
8287 xim_inst
->resource_name
= (char *) xmalloc (len
+ 1);
8288 bcopy (resource_name
, xim_inst
->resource_name
, len
+ 1);
8289 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8290 resource_name
, EMACS_CLASS
,
8291 xim_instantiate_callback
,
8292 /* This is XPointer in XFree86
8293 but (XPointer *) on Tru64, at
8294 least, hence the configure test. */
8295 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
8296 #else /* not HAVE_X11R6_XIM */
8297 dpyinfo
->xim
= NULL
;
8298 xim_open_dpy (dpyinfo
, resource_name
);
8299 #endif /* not HAVE_X11R6_XIM */
8303 #endif /* HAVE_XIM */
8304 dpyinfo
->xim
= NULL
;
8308 /* Close the connection to the XIM server on display DPYINFO. */
8311 xim_close_dpy (dpyinfo
)
8312 struct x_display_info
*dpyinfo
;
8317 #ifdef HAVE_X11R6_XIM
8318 if (dpyinfo
->display
)
8319 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8321 xim_instantiate_callback
, NULL
);
8322 #endif /* not HAVE_X11R6_XIM */
8323 if (dpyinfo
->display
)
8324 XCloseIM (dpyinfo
->xim
);
8325 dpyinfo
->xim
= NULL
;
8326 XFree (dpyinfo
->xim_styles
);
8328 #endif /* HAVE_XIM */
8331 #endif /* not HAVE_X11R6_XIM */
8335 /* Calculate the absolute position in frame F
8336 from its current recorded position values and gravity. */
8339 x_calc_absolute_position (f
)
8342 int flags
= f
->size_hint_flags
;
8344 /* We have nothing to do if the current position
8345 is already for the top-left corner. */
8346 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
8349 /* Treat negative positions as relative to the leftmost bottommost
8350 position that fits on the screen. */
8351 if (flags
& XNegative
)
8352 f
->left_pos
= x_display_pixel_width (FRAME_X_DISPLAY_INFO (f
))
8353 - FRAME_PIXEL_WIDTH (f
) + f
->left_pos
;
8356 int height
= FRAME_PIXEL_HEIGHT (f
);
8358 #if defined USE_X_TOOLKIT && defined USE_MOTIF
8359 /* Something is fishy here. When using Motif, starting Emacs with
8360 `-g -0-0', the frame appears too low by a few pixels.
8362 This seems to be so because initially, while Emacs is starting,
8363 the column widget's height and the frame's pixel height are
8364 different. The column widget's height is the right one. In
8365 later invocations, when Emacs is up, the frame's pixel height
8368 It's not obvious where the initial small difference comes from.
8369 2000-12-01, gerd. */
8371 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
8374 if (flags
& YNegative
)
8375 f
->top_pos
= x_display_pixel_height (FRAME_X_DISPLAY_INFO (f
))
8376 - height
+ f
->top_pos
;
8379 /* The left_pos and top_pos
8380 are now relative to the top and left screen edges,
8381 so the flags should correspond. */
8382 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8385 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
8386 to really change the position, and 0 when calling from
8387 x_make_frame_visible (in that case, XOFF and YOFF are the current
8388 position values). It is -1 when calling from x_set_frame_parameters,
8389 which means, do adjust for borders but don't change the gravity. */
8392 x_set_offset (f
, xoff
, yoff
, change_gravity
)
8394 register int xoff
, yoff
;
8397 int modified_top
, modified_left
;
8399 if (change_gravity
> 0)
8401 FRAME_X_OUTPUT (f
)->left_before_move
= f
->left_pos
;
8402 FRAME_X_OUTPUT (f
)->top_before_move
= f
->top_pos
;
8406 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8408 f
->size_hint_flags
|= XNegative
;
8410 f
->size_hint_flags
|= YNegative
;
8411 f
->win_gravity
= NorthWestGravity
;
8413 x_calc_absolute_position (f
);
8416 x_wm_set_size_hint (f
, (long) 0, 0);
8418 modified_left
= f
->left_pos
;
8419 modified_top
= f
->top_pos
;
8421 if (change_gravity
!= 0 && FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
)
8423 /* Some WMs (twm, wmaker at least) has an offset that is smaller
8424 than the WM decorations. So we use the calculated offset instead
8425 of the WM decoration sizes here (x/y_pixels_outer_diff). */
8426 modified_left
+= FRAME_X_OUTPUT (f
)->move_offset_left
;
8427 modified_top
+= FRAME_X_OUTPUT (f
)->move_offset_top
;
8430 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8431 modified_left
, modified_top
);
8433 x_sync_with_move (f
, f
->left_pos
, f
->top_pos
,
8434 FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8437 /* change_gravity is non-zero when this function is called from Lisp to
8438 programmatically move a frame. In that case, we call
8439 x_check_expected_move to discover if we have a "Type A" or "Type B"
8440 window manager, and, for a "Type A" window manager, adjust the position
8443 We call x_check_expected_move if a programmatic move occurred, and
8444 either the window manager type (A/B) is unknown or it is Type A but we
8445 need to compute the top/left offset adjustment for this frame. */
8447 if (change_gravity
!= 0 &&
8448 (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8449 || (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
8450 && (FRAME_X_OUTPUT (f
)->move_offset_left
== 0
8451 && FRAME_X_OUTPUT (f
)->move_offset_top
== 0))))
8452 x_check_expected_move (f
, modified_left
, modified_top
);
8457 /* Return non-zero if _NET_SUPPORTING_WM_CHECK window exists and _NET_SUPPORTED
8458 on the root window for frame F contains ATOMNAME.
8459 This is how a WM check shall be done according to the Window Manager
8460 Specification/Extended Window Manager Hints at
8461 http://freedesktop.org/wiki/Specifications/wm-spec. */
8464 wm_supports (f
, atomname
)
8466 const char *atomname
;
8469 unsigned long actual_size
, bytes_remaining
;
8470 int i
, rc
, actual_format
;
8472 Window wmcheck_window
;
8473 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8474 Window target_window
= dpyinfo
->root_window
;
8475 long max_len
= 65536;
8476 Display
*dpy
= FRAME_X_DISPLAY (f
);
8477 unsigned char *tmp_data
= NULL
;
8478 Atom target_type
= XA_WINDOW
;
8483 prop_atom
= XInternAtom (dpy
, "_NET_SUPPORTING_WM_CHECK", False
);
8485 x_catch_errors (dpy
);
8486 rc
= XGetWindowProperty (dpy
, target_window
,
8487 prop_atom
, 0, max_len
, False
, target_type
,
8488 &actual_type
, &actual_format
, &actual_size
,
8489 &bytes_remaining
, &tmp_data
);
8491 if (rc
!= Success
|| actual_type
!= XA_WINDOW
|| x_had_errors_p (dpy
))
8493 if (tmp_data
) XFree (tmp_data
);
8494 x_uncatch_errors ();
8499 wmcheck_window
= *(Window
*) tmp_data
;
8502 /* Check if window exists. */
8503 XSelectInput (dpy
, wmcheck_window
, StructureNotifyMask
);
8505 if (x_had_errors_p (dpy
))
8507 x_uncatch_errors ();
8512 if (dpyinfo
->net_supported_window
!= wmcheck_window
)
8514 /* Window changed, reload atoms */
8515 if (dpyinfo
->net_supported_atoms
!= NULL
)
8516 XFree (dpyinfo
->net_supported_atoms
);
8517 dpyinfo
->net_supported_atoms
= NULL
;
8518 dpyinfo
->nr_net_supported_atoms
= 0;
8519 dpyinfo
->net_supported_window
= 0;
8521 target_type
= XA_ATOM
;
8522 prop_atom
= XInternAtom (dpy
, "_NET_SUPPORTED", False
);
8524 rc
= XGetWindowProperty (dpy
, target_window
,
8525 prop_atom
, 0, max_len
, False
, target_type
,
8526 &actual_type
, &actual_format
, &actual_size
,
8527 &bytes_remaining
, &tmp_data
);
8529 if (rc
!= Success
|| actual_type
!= XA_ATOM
|| x_had_errors_p (dpy
))
8531 if (tmp_data
) XFree (tmp_data
);
8532 x_uncatch_errors ();
8537 dpyinfo
->net_supported_atoms
= (Atom
*)tmp_data
;
8538 dpyinfo
->nr_net_supported_atoms
= actual_size
;
8539 dpyinfo
->net_supported_window
= wmcheck_window
;
8543 want_atom
= XInternAtom (dpy
, atomname
, False
);
8545 for (i
= 0; rc
== 0 && i
< dpyinfo
->nr_net_supported_atoms
; ++i
)
8546 rc
= dpyinfo
->net_supported_atoms
[i
] == want_atom
;
8548 x_uncatch_errors ();
8554 /* Do fullscreen as specified in extended window manager hints */
8557 do_ewmh_fullscreen (f
)
8560 int have_net_atom
= wm_supports (f
, "_NET_WM_STATE");
8562 /* Some window managers don't say they support _NET_WM_STATE, but they do say
8563 they support _NET_WM_STATE_FULLSCREEN. Try that also. */
8565 have_net_atom
= wm_supports (f
, "_NET_WM_STATE_FULLSCREEN");
8570 const char *atom
= "_NET_WM_STATE";
8571 const char *fs
= "_NET_WM_STATE_FULLSCREEN";
8572 const char *fw
= "_NET_WM_STATE_MAXIMIZED_HORZ";
8573 const char *fh
= "_NET_WM_STATE_MAXIMIZED_VERT";
8574 const char *what
= NULL
;
8576 XSETFRAME (frame
, f
);
8578 /* If there are _NET_ atoms we assume we have extended window manager
8580 switch (f
->want_fullscreen
)
8582 case FULLSCREEN_BOTH
:
8585 case FULLSCREEN_WIDTH
:
8588 case FULLSCREEN_HEIGHT
:
8593 if (what
!= NULL
&& !wm_supports (f
, what
)) return 0;
8596 Fx_send_client_event (frame
, make_number (0), frame
,
8597 make_unibyte_string (atom
, strlen (atom
)),
8599 Fcons (make_number (0), /* Remove */
8601 (make_unibyte_string (fs
,
8604 Fx_send_client_event (frame
, make_number (0), frame
,
8605 make_unibyte_string (atom
, strlen (atom
)),
8607 Fcons (make_number (0), /* Remove */
8609 (make_unibyte_string (fh
,
8612 Fx_send_client_event (frame
, make_number (0), frame
,
8613 make_unibyte_string (atom
, strlen (atom
)),
8615 Fcons (make_number (0), /* Remove */
8617 (make_unibyte_string (fw
,
8620 f
->want_fullscreen
= FULLSCREEN_NONE
;
8622 Fx_send_client_event (frame
, make_number (0), frame
,
8623 make_unibyte_string (atom
, strlen (atom
)),
8625 Fcons (make_number (1), /* Add */
8627 (make_unibyte_string (what
,
8632 return have_net_atom
;
8636 XTfullscreen_hook (f
)
8639 if (f
->async_visible
)
8642 do_ewmh_fullscreen (f
);
8649 /* Check if we need to resize the frame due to a fullscreen request.
8650 If so needed, resize the frame. */
8652 x_check_fullscreen (f
)
8655 if (f
->want_fullscreen
& FULLSCREEN_BOTH
)
8657 int width
, height
, ign
;
8659 if (do_ewmh_fullscreen (f
))
8662 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
8664 x_fullscreen_adjust (f
, &width
, &height
, &ign
, &ign
);
8666 /* We do not need to move the window, it shall be taken care of
8667 when setting WM manager hints.
8668 If the frame is visible already, the position is checked by
8669 x_check_expected_move. */
8670 if (FRAME_COLS (f
) != width
|| FRAME_LINES (f
) != height
)
8672 change_frame_size (f
, height
, width
, 0, 1, 0);
8673 SET_FRAME_GARBAGED (f
);
8674 cancel_mouse_face (f
);
8676 /* Wait for the change of frame size to occur */
8677 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
8682 /* This function is called by x_set_offset to determine whether the window
8683 manager interfered with the positioning of the frame. Type A window
8684 managers position the surrounding window manager decorations a small
8685 amount above and left of the user-supplied position. Type B window
8686 managers position the surrounding window manager decorations at the
8687 user-specified position. If we detect a Type A window manager, we
8688 compensate by moving the window right and down by the proper amount. */
8691 x_check_expected_move (f
, expected_left
, expected_top
)
8696 int current_left
= 0, current_top
= 0;
8698 /* x_real_positions returns the left and top offsets of the outermost
8699 window manager window around the frame. */
8701 x_real_positions (f
, ¤t_left
, ¤t_top
);
8703 if (current_left
!= expected_left
|| current_top
!= expected_top
)
8705 /* It's a "Type A" window manager. */
8710 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_A
;
8711 FRAME_X_OUTPUT (f
)->move_offset_left
= expected_left
- current_left
;
8712 FRAME_X_OUTPUT (f
)->move_offset_top
= expected_top
- current_top
;
8714 /* Now fix the mispositioned frame's location. */
8716 adjusted_left
= expected_left
+ FRAME_X_OUTPUT (f
)->move_offset_left
;
8717 adjusted_top
= expected_top
+ FRAME_X_OUTPUT (f
)->move_offset_top
;
8719 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8720 adjusted_left
, adjusted_top
);
8722 x_sync_with_move (f
, expected_left
, expected_top
, 0);
8725 /* It's a "Type B" window manager. We don't have to adjust the
8726 frame's position. */
8728 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_B
;
8732 /* Wait for XGetGeometry to return up-to-date position information for a
8733 recently-moved frame. Call this immediately after calling XMoveWindow.
8734 If FUZZY is non-zero, then LEFT and TOP are just estimates of where the
8735 frame has been moved to, so we use a fuzzy position comparison instead
8736 of an exact comparison. */
8739 x_sync_with_move (f
, left
, top
, fuzzy
)
8741 int left
, top
, fuzzy
;
8745 while (count
++ < 50)
8747 int current_left
= 0, current_top
= 0;
8749 /* In theory, this call to XSync only needs to happen once, but in
8750 practice, it doesn't seem to work, hence the need for the surrounding
8753 XSync (FRAME_X_DISPLAY (f
), False
);
8754 x_real_positions (f
, ¤t_left
, ¤t_top
);
8758 /* The left fuzz-factor is 10 pixels. The top fuzz-factor is 40
8761 if (eabs (current_left
- left
) <= 10
8762 && eabs (current_top
- top
) <= 40)
8765 else if (current_left
== left
&& current_top
== top
)
8769 /* As a last resort, just wait 0.5 seconds and hope that XGetGeometry
8770 will then return up-to-date position info. */
8772 wait_reading_process_output (0, 500000, 0, 0, Qnil
, NULL
, 0);
8776 /* Change the size of frame F's X window to COLS/ROWS in the case F
8777 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
8778 top-left-corner window gravity for this size change and subsequent
8779 size changes. Otherwise we leave the window gravity unchanged. */
8782 x_set_window_size_1 (f
, change_gravity
, cols
, rows
)
8787 int pixelwidth
, pixelheight
;
8789 check_frame_size (f
, &rows
, &cols
);
8790 f
->scroll_bar_actual_width
8791 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
8793 : FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0
8794 ? FRAME_CONFIG_SCROLL_BAR_WIDTH (f
)
8795 : (FRAME_CONFIG_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
)));
8797 compute_fringe_widths (f
, 0);
8799 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
8800 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
);
8802 f
->win_gravity
= NorthWestGravity
;
8803 x_wm_set_size_hint (f
, (long) 0, 0);
8805 XSync (FRAME_X_DISPLAY (f
), False
);
8806 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8807 pixelwidth
, pixelheight
);
8809 /* Now, strictly speaking, we can't be sure that this is accurate,
8810 but the window manager will get around to dealing with the size
8811 change request eventually, and we'll hear how it went when the
8812 ConfigureNotify event gets here.
8814 We could just not bother storing any of this information here,
8815 and let the ConfigureNotify event set everything up, but that
8816 might be kind of confusing to the Lisp code, since size changes
8817 wouldn't be reported in the frame parameters until some random
8818 point in the future when the ConfigureNotify event arrives.
8820 We pass 1 for DELAY since we can't run Lisp code inside of
8822 change_frame_size (f
, rows
, cols
, 0, 1, 0);
8823 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
8824 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
8826 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
8827 receive in the ConfigureNotify event; if we get what we asked
8828 for, then the event won't cause the screen to become garbaged, so
8829 we have to make sure to do it here. */
8830 SET_FRAME_GARBAGED (f
);
8832 XFlush (FRAME_X_DISPLAY (f
));
8836 /* Call this to change the size of frame F's x-window.
8837 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
8838 for this size change and subsequent size changes.
8839 Otherwise we leave the window gravity unchanged. */
8842 x_set_window_size (f
, change_gravity
, cols
, rows
)
8850 if (FRAME_GTK_WIDGET (f
))
8851 xg_frame_set_char_size (f
, cols
, rows
);
8853 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8856 if (f
->output_data
.x
->widget
!= NULL
)
8858 /* The x and y position of the widget is clobbered by the
8859 call to XtSetValues within EmacsFrameSetCharSize.
8860 This is a real kludge, but I don't understand Xt so I can't
8861 figure out a correct fix. Can anyone else tell me? -- rms. */
8862 int xpos
= f
->output_data
.x
->widget
->core
.x
;
8863 int ypos
= f
->output_data
.x
->widget
->core
.y
;
8864 EmacsFrameSetCharSize (f
->output_data
.x
->edit_widget
, cols
, rows
);
8865 f
->output_data
.x
->widget
->core
.x
= xpos
;
8866 f
->output_data
.x
->widget
->core
.y
= ypos
;
8869 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8871 #else /* not USE_X_TOOLKIT */
8873 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8875 #endif /* not USE_X_TOOLKIT */
8877 /* If cursor was outside the new size, mark it as off. */
8878 mark_window_cursors_off (XWINDOW (f
->root_window
));
8880 /* Clear out any recollection of where the mouse highlighting was,
8881 since it might be in a place that's outside the new frame size.
8882 Actually checking whether it is outside is a pain in the neck,
8883 so don't try--just let the highlighting be done afresh with new size. */
8884 cancel_mouse_face (f
);
8889 /* Mouse warping. */
8892 x_set_mouse_position (f
, x
, y
)
8898 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
8899 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
8901 if (pix_x
< 0) pix_x
= 0;
8902 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
8904 if (pix_y
< 0) pix_y
= 0;
8905 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
8909 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8910 0, 0, 0, 0, pix_x
, pix_y
);
8914 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
8917 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
8923 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8924 0, 0, 0, 0, pix_x
, pix_y
);
8928 /* focus shifting, raising and lowering. */
8931 x_focus_on_frame (f
)
8934 #if 0 /* This proves to be unpleasant. */
8938 /* I don't think that the ICCCM allows programs to do things like this
8939 without the interaction of the window manager. Whatever you end up
8940 doing with this code, do it to x_unfocus_frame too. */
8941 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8942 RevertToPointerRoot
, CurrentTime
);
8951 /* Look at the remarks in x_focus_on_frame. */
8952 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
8953 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
8954 RevertToPointerRoot
, CurrentTime
);
8958 /* Raise frame F. */
8965 if (f
->async_visible
)
8966 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8968 XFlush (FRAME_X_DISPLAY (f
));
8972 /* Lower frame F. */
8978 if (f
->async_visible
)
8981 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8982 XFlush (FRAME_X_DISPLAY (f
));
8987 /* Activate frame with Extended Window Manager Hints */
8990 x_ewmh_activate_frame (f
)
8993 /* See Window Manager Specification/Extended Window Manager Hints at
8994 http://freedesktop.org/wiki/Specifications/wm-spec */
8996 const char *atom
= "_NET_ACTIVE_WINDOW";
8997 if (f
->async_visible
&& wm_supports (f
, atom
))
9000 XSETFRAME (frame
, f
);
9001 Fx_send_client_event (frame
, make_number (0), frame
,
9002 make_unibyte_string (atom
, strlen (atom
)),
9004 Fcons (make_number (1),
9005 Fcons (make_number (last_user_time
),
9011 XTframe_raise_lower (f
, raise_flag
)
9021 /* XEmbed implementation. */
9024 xembed_set_info (f
, flags
)
9026 enum xembed_info flags
;
9029 unsigned long data
[2];
9031 atom
= XInternAtom (FRAME_X_DISPLAY (f
), "_XEMBED_INFO", False
);
9033 data
[0] = XEMBED_VERSION
;
9036 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), atom
, atom
,
9037 32, PropModeReplace
, (unsigned char *) data
, 2);
9041 xembed_send_message (f
, time
, message
, detail
, data1
, data2
)
9044 enum xembed_message message
;
9051 event
.xclient
.type
= ClientMessage
;
9052 event
.xclient
.window
= FRAME_X_OUTPUT (f
)->parent_desc
;
9053 event
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_XEMBED
;
9054 event
.xclient
.format
= 32;
9055 event
.xclient
.data
.l
[0] = time
;
9056 event
.xclient
.data
.l
[1] = message
;
9057 event
.xclient
.data
.l
[2] = detail
;
9058 event
.xclient
.data
.l
[3] = data1
;
9059 event
.xclient
.data
.l
[4] = data2
;
9061 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_OUTPUT (f
)->parent_desc
,
9062 False
, NoEventMask
, &event
);
9063 XSync (FRAME_X_DISPLAY (f
), False
);
9066 /* Change of visibility. */
9068 /* This tries to wait until the frame is really visible.
9069 However, if the window manager asks the user where to position
9070 the frame, this will return before the user finishes doing that.
9071 The frame will not actually be visible at that time,
9072 but it will become visible later when the window manager
9073 finishes with it. */
9076 x_make_frame_visible (f
)
9080 int original_top
, original_left
;
9081 int retry_count
= 2;
9087 type
= x_icon_type (f
);
9089 x_bitmap_icon (f
, type
);
9091 if (! FRAME_VISIBLE_P (f
))
9093 /* We test FRAME_GARBAGED_P here to make sure we don't
9094 call x_set_offset a second time
9095 if we get to x_make_frame_visible a second time
9096 before the window gets really visible. */
9097 if (! FRAME_ICONIFIED_P (f
)
9098 && ! FRAME_X_EMBEDDED_P (f
)
9099 && ! f
->output_data
.x
->asked_for_visible
)
9100 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
9102 f
->output_data
.x
->asked_for_visible
= 1;
9104 if (! EQ (Vx_no_window_manager
, Qt
))
9105 x_wm_set_window_state (f
, NormalState
);
9106 #ifdef USE_X_TOOLKIT
9107 if (FRAME_X_EMBEDDED_P (f
))
9108 xembed_set_info (f
, XEMBED_MAPPED
);
9111 /* This was XtPopup, but that did nothing for an iconified frame. */
9112 XtMapWidget (f
->output_data
.x
->widget
);
9114 #else /* not USE_X_TOOLKIT */
9116 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
9117 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
9119 if (FRAME_X_EMBEDDED_P (f
))
9120 xembed_set_info (f
, XEMBED_MAPPED
);
9122 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9123 #endif /* not USE_GTK */
9124 #endif /* not USE_X_TOOLKIT */
9125 #if 0 /* This seems to bring back scroll bars in the wrong places
9126 if the window configuration has changed. They seem
9127 to come back ok without this. */
9128 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
9129 XMapSubwindows (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9133 XFlush (FRAME_X_DISPLAY (f
));
9135 /* Synchronize to ensure Emacs knows the frame is visible
9136 before we do anything else. We do this loop with input not blocked
9137 so that incoming events are handled. */
9141 /* This must be before UNBLOCK_INPUT
9142 since events that arrive in response to the actions above
9143 will set it when they are handled. */
9144 int previously_visible
= f
->output_data
.x
->has_been_visible
;
9146 original_left
= f
->left_pos
;
9147 original_top
= f
->top_pos
;
9149 /* This must come after we set COUNT. */
9152 /* We unblock here so that arriving X events are processed. */
9154 /* Now move the window back to where it was "supposed to be".
9155 But don't do it if the gravity is negative.
9156 When the gravity is negative, this uses a position
9157 that is 3 pixels too low. Perhaps that's really the border width.
9159 Don't do this if the window has never been visible before,
9160 because the window manager may choose the position
9161 and we don't want to override it. */
9163 if (! FRAME_VISIBLE_P (f
)
9164 && ! FRAME_ICONIFIED_P (f
)
9165 && ! FRAME_X_EMBEDDED_P (f
)
9166 && f
->win_gravity
== NorthWestGravity
9167 && previously_visible
)
9171 unsigned int width
, height
, border
, depth
;
9175 /* On some window managers (such as FVWM) moving an existing
9176 window, even to the same place, causes the window manager
9177 to introduce an offset. This can cause the window to move
9178 to an unexpected location. Check the geometry (a little
9179 slow here) and then verify that the window is in the right
9180 place. If the window is not in the right place, move it
9181 there, and take the potential window manager hit. */
9182 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9183 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
9185 if (original_left
!= x
|| original_top
!= y
)
9186 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9187 original_left
, original_top
);
9192 XSETFRAME (frame
, f
);
9194 /* Wait until the frame is visible. Process X events until a
9195 MapNotify event has been seen, or until we think we won't get a
9196 MapNotify at all.. */
9197 for (count
= input_signal_count
+ 10;
9198 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
9200 /* Force processing of queued events. */
9203 /* Machines that do polling rather than SIGIO have been
9204 observed to go into a busy-wait here. So we'll fake an
9205 alarm signal to let the handler know that there's something
9206 to be read. We used to raise a real alarm, but it seems
9207 that the handler isn't always enabled here. This is
9209 if (input_polling_used ())
9211 /* It could be confusing if a real alarm arrives while
9212 processing the fake one. Turn it off and let the
9213 handler reset it. */
9214 extern void poll_for_input_1
P_ ((void));
9215 int old_poll_suppress_count
= poll_suppress_count
;
9216 poll_suppress_count
= 1;
9217 poll_for_input_1 ();
9218 poll_suppress_count
= old_poll_suppress_count
;
9221 /* See if a MapNotify event has been processed. */
9222 FRAME_SAMPLE_VISIBILITY (f
);
9227 (let ((f (selected-frame)))
9231 the frame is not raised with various window managers on
9232 FreeBSD, GNU/Linux and Solaris. It turns out that, for some
9233 unknown reason, the call to XtMapWidget is completely ignored.
9234 Mapping the widget a second time works. */
9236 if (!FRAME_VISIBLE_P (f
) && --retry_count
> 0)
9241 /* Change from mapped state to withdrawn state. */
9243 /* Make the frame visible (mapped and not iconified). */
9246 x_make_frame_invisible (f
)
9251 /* Use the frame's outermost window, not the one we normally draw on. */
9252 window
= FRAME_OUTER_WINDOW (f
);
9254 /* Don't keep the highlight on an invisible frame. */
9255 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9256 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9258 #if 0/* This might add unreliability; I don't trust it -- rms. */
9259 if (! f
->async_visible
&& ! f
->async_iconified
)
9265 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
9266 that the current position of the window is user-specified, rather than
9267 program-specified, so that when the window is mapped again, it will be
9268 placed at the same location, without forcing the user to position it
9269 by hand again (they have already done that once for this window.) */
9270 x_wm_set_size_hint (f
, (long) 0, 1);
9273 if (FRAME_GTK_OUTER_WIDGET (f
))
9274 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f
));
9277 if (FRAME_X_EMBEDDED_P (f
))
9278 xembed_set_info (f
, 0);
9283 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
9284 DefaultScreen (FRAME_X_DISPLAY (f
))))
9286 UNBLOCK_INPUT_RESIGNAL
;
9287 error ("Can't notify window manager of window withdrawal");
9291 /* We can't distinguish this from iconification
9292 just by the event that we get from the server.
9293 So we can't win using the usual strategy of letting
9294 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
9295 and synchronize with the server to make sure we agree. */
9297 FRAME_ICONIFIED_P (f
) = 0;
9298 f
->async_visible
= 0;
9299 f
->async_iconified
= 0;
9306 /* Change window state from mapped to iconified. */
9315 /* Don't keep the highlight on an invisible frame. */
9316 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9317 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9319 if (f
->async_iconified
)
9324 FRAME_SAMPLE_VISIBILITY (f
);
9326 type
= x_icon_type (f
);
9328 x_bitmap_icon (f
, type
);
9331 if (FRAME_GTK_OUTER_WIDGET (f
))
9333 if (! FRAME_VISIBLE_P (f
))
9334 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
9336 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
9339 f
->async_iconified
= 1;
9340 f
->async_visible
= 0;
9346 #ifdef USE_X_TOOLKIT
9348 if (! FRAME_VISIBLE_P (f
))
9350 if (! EQ (Vx_no_window_manager
, Qt
))
9351 x_wm_set_window_state (f
, IconicState
);
9352 /* This was XtPopup, but that did nothing for an iconified frame. */
9353 XtMapWidget (f
->output_data
.x
->widget
);
9354 /* The server won't give us any event to indicate
9355 that an invisible frame was changed to an icon,
9356 so we have to record it here. */
9359 f
->async_iconified
= 1;
9360 f
->async_visible
= 0;
9365 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
9366 XtWindow (f
->output_data
.x
->widget
),
9367 DefaultScreen (FRAME_X_DISPLAY (f
)));
9371 error ("Can't notify window manager of iconification");
9373 f
->async_iconified
= 1;
9374 f
->async_visible
= 0;
9378 XFlush (FRAME_X_DISPLAY (f
));
9380 #else /* not USE_X_TOOLKIT */
9382 /* Make sure the X server knows where the window should be positioned,
9383 in case the user deiconifies with the window manager. */
9384 if (! FRAME_VISIBLE_P (f
)
9385 && ! FRAME_ICONIFIED_P (f
)
9386 && ! FRAME_X_EMBEDDED_P (f
))
9387 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
9389 /* Since we don't know which revision of X we're running, we'll use both
9390 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
9392 /* X11R4: send a ClientMessage to the window manager using the
9393 WM_CHANGE_STATE type. */
9397 message
.xclient
.window
= FRAME_X_WINDOW (f
);
9398 message
.xclient
.type
= ClientMessage
;
9399 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
9400 message
.xclient
.format
= 32;
9401 message
.xclient
.data
.l
[0] = IconicState
;
9403 if (! XSendEvent (FRAME_X_DISPLAY (f
),
9404 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
9406 SubstructureRedirectMask
| SubstructureNotifyMask
,
9409 UNBLOCK_INPUT_RESIGNAL
;
9410 error ("Can't notify window manager of iconification");
9414 /* X11R3: set the initial_state field of the window manager hints to
9416 x_wm_set_window_state (f
, IconicState
);
9418 if (!FRAME_VISIBLE_P (f
))
9420 /* If the frame was withdrawn, before, we must map it. */
9421 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9424 f
->async_iconified
= 1;
9425 f
->async_visible
= 0;
9427 XFlush (FRAME_X_DISPLAY (f
));
9429 #endif /* not USE_X_TOOLKIT */
9433 /* Free X resources of frame F. */
9436 x_free_frame_resources (f
)
9439 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9441 struct scroll_bar
*b
;
9445 /* If a display connection is dead, don't try sending more
9446 commands to the X server. */
9447 if (dpyinfo
->display
)
9449 /* We must free faces before destroying windows because some
9450 font-driver (e.g. xft) access a window while finishing a
9452 if (FRAME_FACE_CACHE (f
))
9453 free_frame_faces (f
);
9455 if (f
->output_data
.x
->icon_desc
)
9456 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
9458 #ifdef USE_X_TOOLKIT
9459 /* Explicitly destroy the scroll bars of the frame. Without
9460 this, we get "BadDrawable" errors from the toolkit later on,
9461 presumably from expose events generated for the disappearing
9462 toolkit scroll bars. */
9463 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
9465 b
= XSCROLL_BAR (bar
);
9466 x_scroll_bar_remove (b
);
9475 #ifdef USE_X_TOOLKIT
9476 if (f
->output_data
.x
->widget
)
9478 XtDestroyWidget (f
->output_data
.x
->widget
);
9479 f
->output_data
.x
->widget
= NULL
;
9481 /* Tooltips don't have widgets, only a simple X window, even if
9482 we are using a toolkit. */
9483 else if (FRAME_X_WINDOW (f
))
9484 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9486 free_frame_menubar (f
);
9487 #else /* !USE_X_TOOLKIT */
9490 /* In the GTK version, tooltips are normal X
9491 frames. We must check and free both types. */
9492 if (FRAME_GTK_OUTER_WIDGET (f
))
9494 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
9495 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow below */
9496 FRAME_GTK_OUTER_WIDGET (f
) = 0;
9498 #endif /* USE_GTK */
9500 if (FRAME_X_WINDOW (f
))
9501 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9502 #endif /* !USE_X_TOOLKIT */
9504 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
9505 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
9506 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
9507 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
9508 unload_color (f
, f
->output_data
.x
->border_pixel
);
9509 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
9511 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
9512 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
9513 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
9514 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
9515 #ifdef USE_TOOLKIT_SCROLL_BARS
9516 /* Scrollbar shadow colors. */
9517 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
9518 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
9519 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
9520 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
9521 #endif /* USE_TOOLKIT_SCROLL_BARS */
9522 if (f
->output_data
.x
->white_relief
.allocated_p
)
9523 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
9524 if (f
->output_data
.x
->black_relief
.allocated_p
)
9525 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
9527 if (FRAME_FACE_CACHE (f
))
9528 free_frame_faces (f
);
9531 XFlush (FRAME_X_DISPLAY (f
));
9534 xfree (f
->output_data
.x
->saved_menu_event
);
9535 xfree (f
->output_data
.x
);
9536 f
->output_data
.x
= NULL
;
9538 if (f
== dpyinfo
->x_focus_frame
)
9539 dpyinfo
->x_focus_frame
= 0;
9540 if (f
== dpyinfo
->x_focus_event_frame
)
9541 dpyinfo
->x_focus_event_frame
= 0;
9542 if (f
== dpyinfo
->x_highlight_frame
)
9543 dpyinfo
->x_highlight_frame
= 0;
9545 if (f
== dpyinfo
->mouse_face_mouse_frame
)
9547 dpyinfo
->mouse_face_beg_row
9548 = dpyinfo
->mouse_face_beg_col
= -1;
9549 dpyinfo
->mouse_face_end_row
9550 = dpyinfo
->mouse_face_end_col
= -1;
9551 dpyinfo
->mouse_face_window
= Qnil
;
9552 dpyinfo
->mouse_face_deferred_gc
= 0;
9553 dpyinfo
->mouse_face_mouse_frame
= 0;
9560 /* Destroy the X window of frame F. */
9563 x_destroy_window (f
)
9566 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9568 /* If a display connection is dead, don't try sending more
9569 commands to the X server. */
9570 if (dpyinfo
->display
!= 0)
9571 x_free_frame_resources (f
);
9573 dpyinfo
->reference_count
--;
9577 /* Setting window manager hints. */
9579 /* Set the normal size hints for the window manager, for frame F.
9580 FLAGS is the flags word to use--or 0 meaning preserve the flags
9581 that the window now has.
9582 If USER_POSITION is nonzero, we set the USPosition
9583 flag (this is useful when FLAGS is 0).
9584 The GTK version is in gtkutils.c */
9588 x_wm_set_size_hint (f
, flags
, user_position
)
9593 XSizeHints size_hints
;
9595 #ifdef USE_X_TOOLKIT
9598 Dimension widget_width
, widget_height
;
9601 Window window
= FRAME_OUTER_WINDOW (f
);
9603 /* Setting PMaxSize caused various problems. */
9604 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
9606 size_hints
.x
= f
->left_pos
;
9607 size_hints
.y
= f
->top_pos
;
9609 #ifdef USE_X_TOOLKIT
9610 XtSetArg (al
[ac
], XtNwidth
, &widget_width
); ac
++;
9611 XtSetArg (al
[ac
], XtNheight
, &widget_height
); ac
++;
9612 XtGetValues (f
->output_data
.x
->widget
, al
, ac
);
9613 size_hints
.height
= widget_height
;
9614 size_hints
.width
= widget_width
;
9615 #else /* not USE_X_TOOLKIT */
9616 size_hints
.height
= FRAME_PIXEL_HEIGHT (f
);
9617 size_hints
.width
= FRAME_PIXEL_WIDTH (f
);
9618 #endif /* not USE_X_TOOLKIT */
9620 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
9621 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
9622 size_hints
.max_width
= x_display_pixel_width (FRAME_X_DISPLAY_INFO (f
))
9623 - FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9624 size_hints
.max_height
= x_display_pixel_height (FRAME_X_DISPLAY_INFO (f
))
9625 - FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9627 /* Calculate the base and minimum sizes.
9629 (When we use the X toolkit, we don't do it here.
9630 Instead we copy the values that the widgets are using, below.) */
9631 #ifndef USE_X_TOOLKIT
9633 int base_width
, base_height
;
9634 int min_rows
= 0, min_cols
= 0;
9636 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9637 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9639 check_frame_size (f
, &min_rows
, &min_cols
);
9641 /* The window manager uses the base width hints to calculate the
9642 current number of rows and columns in the frame while
9643 resizing; min_width and min_height aren't useful for this
9644 purpose, since they might not give the dimensions for a
9645 zero-row, zero-column frame.
9647 We use the base_width and base_height members if we have
9648 them; otherwise, we set the min_width and min_height members
9649 to the size for a zero x zero frame. */
9651 size_hints
.flags
|= PBaseSize
;
9652 size_hints
.base_width
= base_width
;
9653 size_hints
.base_height
= base_height
;
9654 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
9655 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
9658 /* If we don't need the old flags, we don't need the old hint at all. */
9661 size_hints
.flags
|= flags
;
9664 #endif /* not USE_X_TOOLKIT */
9667 XSizeHints hints
; /* Sometimes I hate X Windows... */
9668 long supplied_return
;
9671 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
9674 #ifdef USE_X_TOOLKIT
9675 size_hints
.base_height
= hints
.base_height
;
9676 size_hints
.base_width
= hints
.base_width
;
9677 size_hints
.min_height
= hints
.min_height
;
9678 size_hints
.min_width
= hints
.min_width
;
9682 size_hints
.flags
|= flags
;
9687 if (hints
.flags
& PSize
)
9688 size_hints
.flags
|= PSize
;
9689 if (hints
.flags
& PPosition
)
9690 size_hints
.flags
|= PPosition
;
9691 if (hints
.flags
& USPosition
)
9692 size_hints
.flags
|= USPosition
;
9693 if (hints
.flags
& USSize
)
9694 size_hints
.flags
|= USSize
;
9698 #ifndef USE_X_TOOLKIT
9703 size_hints
.win_gravity
= f
->win_gravity
;
9704 size_hints
.flags
|= PWinGravity
;
9708 size_hints
.flags
&= ~ PPosition
;
9709 size_hints
.flags
|= USPosition
;
9711 #endif /* PWinGravity */
9713 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
9715 #endif /* not USE_GTK */
9717 /* Used for IconicState or NormalState */
9720 x_wm_set_window_state (f
, state
)
9724 #ifdef USE_X_TOOLKIT
9727 XtSetArg (al
[0], XtNinitialState
, state
);
9728 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9729 #else /* not USE_X_TOOLKIT */
9730 Window window
= FRAME_X_WINDOW (f
);
9732 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
9733 f
->output_data
.x
->wm_hints
.initial_state
= state
;
9735 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9736 #endif /* not USE_X_TOOLKIT */
9740 x_wm_set_icon_pixmap (f
, pixmap_id
)
9744 Pixmap icon_pixmap
, icon_mask
;
9746 #ifndef USE_X_TOOLKIT
9747 Window window
= FRAME_OUTER_WINDOW (f
);
9752 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
9753 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
9754 icon_mask
= x_bitmap_mask (f
, pixmap_id
);
9755 f
->output_data
.x
->wm_hints
.icon_mask
= icon_mask
;
9759 /* It seems there is no way to turn off use of an icon pixmap.
9760 The following line does it, only if no icon has yet been created,
9761 for some window managers. But with mwm it crashes.
9762 Some people say it should clear the IconPixmapHint bit in this case,
9763 but that doesn't work, and the X consortium said it isn't the
9764 right thing at all. Since there is no way to win,
9765 best to explicitly give up. */
9767 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
9768 f
->output_data
.x
->wm_hints
.icon_mask
= None
;
9777 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
);
9781 #elif defined (USE_X_TOOLKIT) /* same as in x_wm_set_window_state. */
9785 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
9786 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9787 XtSetArg (al
[0], XtNiconMask
, icon_mask
);
9788 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9791 #else /* not USE_X_TOOLKIT && not USE_GTK */
9793 f
->output_data
.x
->wm_hints
.flags
|= (IconPixmapHint
| IconMaskHint
);
9794 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9796 #endif /* not USE_X_TOOLKIT && not USE_GTK */
9800 x_wm_set_icon_position (f
, icon_x
, icon_y
)
9804 Window window
= FRAME_OUTER_WINDOW (f
);
9806 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
9807 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
9808 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
9810 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9814 /***********************************************************************
9816 ***********************************************************************/
9820 /* Check that FONT is valid on frame F. It is if it can be found in F's
9824 x_check_font (f
, font
)
9830 xassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
9831 if (font
->driver
->check
)
9832 xassert (font
->driver
->check (f
, font
) == 0);
9835 #endif /* GLYPH_DEBUG != 0 */
9838 /***********************************************************************
9840 ***********************************************************************/
9842 #ifdef USE_X_TOOLKIT
9843 static XrmOptionDescRec emacs_options
[] = {
9844 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
9845 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
9847 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
9848 XrmoptionSepArg
, NULL
},
9849 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
9851 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9852 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9853 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9854 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
9855 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
9856 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
9857 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
9860 /* Whether atimer for Xt timeouts is activated or not. */
9862 static int x_timeout_atimer_activated_flag
;
9864 #endif /* USE_X_TOOLKIT */
9866 static int x_initialized
;
9869 static int x_session_initialized
;
9872 /* Test whether two display-name strings agree up to the dot that separates
9873 the screen number from the server number. */
9875 same_x_server (name1
, name2
)
9876 const char *name1
, *name2
;
9879 const unsigned char *system_name
= SDATA (Vsystem_name
);
9880 int system_name_length
= strlen (system_name
);
9881 int length_until_period
= 0;
9883 while (system_name
[length_until_period
] != 0
9884 && system_name
[length_until_period
] != '.')
9885 length_until_period
++;
9887 /* Treat `unix' like an empty host name. */
9888 if (! strncmp (name1
, "unix:", 5))
9890 if (! strncmp (name2
, "unix:", 5))
9892 /* Treat this host's name like an empty host name. */
9893 if (! strncmp (name1
, system_name
, system_name_length
)
9894 && name1
[system_name_length
] == ':')
9895 name1
+= system_name_length
;
9896 if (! strncmp (name2
, system_name
, system_name_length
)
9897 && name2
[system_name_length
] == ':')
9898 name2
+= system_name_length
;
9899 /* Treat this host's domainless name like an empty host name. */
9900 if (! strncmp (name1
, system_name
, length_until_period
)
9901 && name1
[length_until_period
] == ':')
9902 name1
+= length_until_period
;
9903 if (! strncmp (name2
, system_name
, length_until_period
)
9904 && name2
[length_until_period
] == ':')
9905 name2
+= length_until_period
;
9907 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
9911 if (seen_colon
&& *name1
== '.')
9915 && (*name1
== '.' || *name1
== '\0')
9916 && (*name2
== '.' || *name2
== '\0'));
9919 /* Count number of set bits in mask and number of bits to shift to
9920 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
9923 get_bits_and_offset (mask
, bits
, offset
)
9947 /* Return 1 if display DISPLAY is available for use, 0 otherwise.
9948 But don't permanently open it, just test its availability. */
9951 x_display_ok (display
)
9952 const char *display
;
9957 dpy
= XOpenDisplay (display
);
9959 XCloseDisplay (dpy
);
9965 /* Open a connection to X display DISPLAY_NAME, and return
9966 the structure that describes the open display.
9967 If we cannot contact the display, return null. */
9969 struct x_display_info
*
9970 x_term_init (display_name
, xrm_option
, resource_name
)
9971 Lisp_Object display_name
;
9973 char *resource_name
;
9977 struct terminal
*terminal
;
9978 struct x_display_info
*dpyinfo
;
9989 if (! x_display_ok (SDATA (display_name
)))
9990 error ("Display %s can't be opened", SDATA (display_name
));
9996 char *argv
[NUM_ARGV
];
9997 char **argv2
= argv
;
10000 #ifndef HAVE_GTK_MULTIDISPLAY
10001 if (!EQ (Vinitial_window_system
, intern ("x")))
10002 error ("Sorry, you cannot connect to X servers with the GTK toolkit");
10005 if (x_initialized
++ > 1)
10007 #ifdef HAVE_GTK_MULTIDISPLAY
10008 /* Opening another display. If xg_display_open returns less
10009 than zero, we are probably on GTK 2.0, which can only handle
10010 one display. GTK 2.2 or later can handle more than one. */
10011 if (xg_display_open (SDATA (display_name
), &dpy
) < 0)
10013 error ("Sorry, this version of GTK can only handle one display");
10017 for (argc
= 0; argc
< NUM_ARGV
; ++argc
)
10021 argv
[argc
++] = initial_argv
[0];
10023 if (! NILP (display_name
))
10025 argv
[argc
++] = "--display";
10026 argv
[argc
++] = SDATA (display_name
);
10029 argv
[argc
++] = "--name";
10030 argv
[argc
++] = resource_name
;
10032 XSetLocaleModifiers ("");
10034 gtk_init (&argc
, &argv2
);
10036 /* gtk_init does set_locale. We must fix locale after calling it. */
10040 dpy
= GDK_DISPLAY ();
10042 /* NULL window -> events for all windows go to our function */
10043 gdk_window_add_filter (NULL
, event_handler_gdk
, NULL
);
10045 /* Load our own gtkrc if it exists. */
10047 char *file
= "~/.emacs.d/gtkrc";
10048 Lisp_Object s
, abs_file
;
10050 s
= make_string (file
, strlen (file
));
10051 abs_file
= Fexpand_file_name (s
, Qnil
);
10053 if (! NILP (abs_file
) && !NILP (Ffile_readable_p (abs_file
)))
10054 gtk_rc_parse (SDATA (abs_file
));
10057 XSetErrorHandler (x_error_handler
);
10058 XSetIOErrorHandler (x_io_error_quitter
);
10061 #else /* not USE_GTK */
10062 #ifdef USE_X_TOOLKIT
10063 /* weiner@footloose.sps.mot.com reports that this causes
10065 X protocol error: BadAtom (invalid Atom parameter)
10066 on protocol request 18skiloaf.
10067 So let's not use it until R6. */
10068 #ifdef HAVE_X11XTR6
10069 XtSetLanguageProc (NULL
, NULL
, NULL
);
10080 argv
[argc
++] = "-xrm";
10081 argv
[argc
++] = xrm_option
;
10083 turn_on_atimers (0);
10084 dpy
= XtOpenDisplay (Xt_app_con
, SDATA (display_name
),
10085 resource_name
, EMACS_CLASS
,
10086 emacs_options
, XtNumber (emacs_options
),
10088 turn_on_atimers (1);
10090 #ifdef HAVE_X11XTR6
10091 /* I think this is to compensate for XtSetLanguageProc. */
10096 #else /* not USE_X_TOOLKIT */
10097 XSetLocaleModifiers ("");
10098 dpy
= XOpenDisplay (SDATA (display_name
));
10099 #endif /* not USE_X_TOOLKIT */
10100 #endif /* not USE_GTK*/
10102 /* Detect failure. */
10109 /* We have definitely succeeded. Record the new connection. */
10111 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
10112 bzero (dpyinfo
, sizeof *dpyinfo
);
10114 terminal
= x_create_terminal (dpyinfo
);
10117 struct x_display_info
*share
;
10120 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
10121 share
= share
->next
, tail
= XCDR (tail
))
10122 if (same_x_server (SDATA (XCAR (XCAR (tail
))),
10123 SDATA (display_name
)))
10126 terminal
->kboard
= share
->terminal
->kboard
;
10129 terminal
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
10130 init_kboard (terminal
->kboard
);
10131 terminal
->kboard
->Vwindow_system
= intern ("x");
10132 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
10134 char *vendor
= ServerVendor (dpy
);
10135 /* Temporarily hide the partially initialized terminal */
10136 terminal_list
= terminal
->next_terminal
;
10138 terminal
->kboard
->Vsystem_key_alist
10139 = call1 (Qvendor_specific_keysyms
,
10140 vendor
? build_string (vendor
) : empty_unibyte_string
);
10142 terminal
->next_terminal
= terminal_list
;
10143 terminal_list
= terminal
;
10146 terminal
->kboard
->next_kboard
= all_kboards
;
10147 all_kboards
= terminal
->kboard
;
10148 /* Don't let the initial kboard remain current longer than necessary.
10149 That would cause problems if a file loaded on startup tries to
10150 prompt in the mini-buffer. */
10151 if (current_kboard
== initial_kboard
)
10152 current_kboard
= terminal
->kboard
;
10154 terminal
->kboard
->reference_count
++;
10157 /* Put this display on the chain. */
10158 dpyinfo
->next
= x_display_list
;
10159 x_display_list
= dpyinfo
;
10161 /* Put it on x_display_name_list as well, to keep them parallel. */
10162 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
10163 x_display_name_list
);
10164 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
10166 dpyinfo
->display
= dpy
;
10168 /* Set the name of the terminal. */
10169 terminal
->name
= (char *) xmalloc (SBYTES (display_name
) + 1);
10170 strncpy (terminal
->name
, SDATA (display_name
), SBYTES (display_name
));
10171 terminal
->name
[SBYTES (display_name
)] = 0;
10174 XSetAfterFunction (x_current_display
, x_trace_wire
);
10178 = (char *) xmalloc (SBYTES (Vinvocation_name
)
10179 + SBYTES (Vsystem_name
)
10181 sprintf (dpyinfo
->x_id_name
, "%s@%s",
10182 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
10184 /* Figure out which modifier bits mean what. */
10185 x_find_modifier_meanings (dpyinfo
);
10187 /* Get the scroll bar cursor. */
10189 /* We must create a GTK cursor, it is required for GTK widgets. */
10190 dpyinfo
->xg_cursor
= xg_create_default_cursor (dpyinfo
->display
);
10191 #endif /* USE_GTK */
10193 dpyinfo
->vertical_scroll_bar_cursor
10194 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
10196 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
10197 resource_name
, EMACS_CLASS
);
10198 #ifdef HAVE_XRMSETDATABASE
10199 XrmSetDatabase (dpyinfo
->display
, xrdb
);
10201 dpyinfo
->display
->db
= xrdb
;
10203 /* Put the rdb where we can find it in a way that works on
10205 dpyinfo
->xrdb
= xrdb
;
10207 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
10208 DefaultScreen (dpyinfo
->display
));
10209 select_visual (dpyinfo
);
10210 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
10211 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
10212 dpyinfo
->client_leader_window
= 0;
10213 dpyinfo
->grabbed
= 0;
10214 dpyinfo
->reference_count
= 0;
10215 dpyinfo
->icon_bitmap_id
= -1;
10216 dpyinfo
->n_fonts
= 0;
10217 dpyinfo
->bitmaps
= 0;
10218 dpyinfo
->bitmaps_size
= 0;
10219 dpyinfo
->bitmaps_last
= 0;
10220 dpyinfo
->scratch_cursor_gc
= 0;
10221 dpyinfo
->mouse_face_mouse_frame
= 0;
10222 dpyinfo
->mouse_face_deferred_gc
= 0;
10223 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
10224 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
10225 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
10226 dpyinfo
->mouse_face_window
= Qnil
;
10227 dpyinfo
->mouse_face_overlay
= Qnil
;
10228 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
10229 dpyinfo
->mouse_face_defer
= 0;
10230 dpyinfo
->mouse_face_hidden
= 0;
10231 dpyinfo
->x_focus_frame
= 0;
10232 dpyinfo
->x_focus_event_frame
= 0;
10233 dpyinfo
->x_highlight_frame
= 0;
10234 dpyinfo
->terminal
->image_cache
= make_image_cache ();
10235 dpyinfo
->wm_type
= X_WMTYPE_UNKNOWN
;
10237 /* See if we can construct pixel values from RGB values. */
10238 dpyinfo
->red_bits
= dpyinfo
->blue_bits
= dpyinfo
->green_bits
= 0;
10239 dpyinfo
->red_offset
= dpyinfo
->blue_offset
= dpyinfo
->green_offset
= 0;
10241 if (dpyinfo
->visual
->class == TrueColor
)
10243 get_bits_and_offset (dpyinfo
->visual
->red_mask
,
10244 &dpyinfo
->red_bits
, &dpyinfo
->red_offset
);
10245 get_bits_and_offset (dpyinfo
->visual
->blue_mask
,
10246 &dpyinfo
->blue_bits
, &dpyinfo
->blue_offset
);
10247 get_bits_and_offset (dpyinfo
->visual
->green_mask
,
10248 &dpyinfo
->green_bits
, &dpyinfo
->green_offset
);
10251 /* See if a private colormap is requested. */
10252 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
10254 if (dpyinfo
->visual
->class == PseudoColor
)
10257 value
= display_x_get_resource (dpyinfo
,
10258 build_string ("privateColormap"),
10259 build_string ("PrivateColormap"),
10261 if (STRINGP (value
)
10262 && (!strcmp (SDATA (value
), "true")
10263 || !strcmp (SDATA (value
), "on")))
10264 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
10268 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
10269 dpyinfo
->visual
, AllocNone
);
10272 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
10273 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
10274 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
10275 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10276 dpyinfo
->resy
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10277 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
10278 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
10279 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10280 dpyinfo
->resx
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10283 dpyinfo
->Xatom_wm_protocols
10284 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
10285 dpyinfo
->Xatom_wm_take_focus
10286 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
10287 dpyinfo
->Xatom_wm_save_yourself
10288 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
10289 dpyinfo
->Xatom_wm_delete_window
10290 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
10291 dpyinfo
->Xatom_wm_change_state
10292 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
10293 dpyinfo
->Xatom_wm_configure_denied
10294 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
10295 dpyinfo
->Xatom_wm_window_moved
10296 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
10297 dpyinfo
->Xatom_wm_client_leader
10298 = XInternAtom (dpyinfo
->display
, "WM_CLIENT_LEADER", False
);
10299 dpyinfo
->Xatom_editres
10300 = XInternAtom (dpyinfo
->display
, "Editres", False
);
10301 dpyinfo
->Xatom_CLIPBOARD
10302 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
10303 dpyinfo
->Xatom_TIMESTAMP
10304 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
10305 dpyinfo
->Xatom_TEXT
10306 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
10307 dpyinfo
->Xatom_COMPOUND_TEXT
10308 = XInternAtom (dpyinfo
->display
, "COMPOUND_TEXT", False
);
10309 dpyinfo
->Xatom_UTF8_STRING
10310 = XInternAtom (dpyinfo
->display
, "UTF8_STRING", False
);
10311 dpyinfo
->Xatom_DELETE
10312 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
10313 dpyinfo
->Xatom_MULTIPLE
10314 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
10315 dpyinfo
->Xatom_INCR
10316 = XInternAtom (dpyinfo
->display
, "INCR", False
);
10317 dpyinfo
->Xatom_EMACS_TMP
10318 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
10319 dpyinfo
->Xatom_TARGETS
10320 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
10321 dpyinfo
->Xatom_NULL
10322 = XInternAtom (dpyinfo
->display
, "NULL", False
);
10323 dpyinfo
->Xatom_ATOM_PAIR
10324 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
10325 /* For properties of font. */
10326 dpyinfo
->Xatom_PIXEL_SIZE
10327 = XInternAtom (dpyinfo
->display
, "PIXEL_SIZE", False
);
10328 dpyinfo
->Xatom_AVERAGE_WIDTH
10329 = XInternAtom (dpyinfo
->display
, "AVERAGE_WIDTH", False
);
10330 dpyinfo
->Xatom_MULE_BASELINE_OFFSET
10331 = XInternAtom (dpyinfo
->display
, "_MULE_BASELINE_OFFSET", False
);
10332 dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
10333 = XInternAtom (dpyinfo
->display
, "_MULE_RELATIVE_COMPOSE", False
);
10334 dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
10335 = XInternAtom (dpyinfo
->display
, "_MULE_DEFAULT_ASCENT", False
);
10337 /* Ghostscript support. */
10338 dpyinfo
->Xatom_PAGE
= XInternAtom (dpyinfo
->display
, "PAGE", False
);
10339 dpyinfo
->Xatom_DONE
= XInternAtom (dpyinfo
->display
, "DONE", False
);
10341 dpyinfo
->Xatom_Scrollbar
= XInternAtom (dpyinfo
->display
, "SCROLLBAR",
10344 dpyinfo
->Xatom_XEMBED
= XInternAtom (dpyinfo
->display
, "_XEMBED",
10347 dpyinfo
->cut_buffers_initialized
= 0;
10349 dpyinfo
->x_dnd_atoms_size
= 8;
10350 dpyinfo
->x_dnd_atoms_length
= 0;
10351 dpyinfo
->x_dnd_atoms
= xmalloc (sizeof (*dpyinfo
->x_dnd_atoms
)
10352 * dpyinfo
->x_dnd_atoms_size
);
10354 dpyinfo
->net_supported_atoms
= NULL
;
10355 dpyinfo
->nr_net_supported_atoms
= 0;
10356 dpyinfo
->net_supported_window
= 0;
10358 connection
= ConnectionNumber (dpyinfo
->display
);
10359 dpyinfo
->connection
= connection
;
10364 null_bits
[0] = 0x00;
10366 dpyinfo
->null_pixel
10367 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
10368 null_bits
, 1, 1, (long) 0, (long) 0,
10373 extern int gray_bitmap_width
, gray_bitmap_height
;
10374 extern char *gray_bitmap_bits
;
10376 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
10378 gray_bitmap_width
, gray_bitmap_height
,
10379 (unsigned long) 1, (unsigned long) 0, 1);
10383 xim_initialize (dpyinfo
, resource_name
);
10386 #ifdef subprocesses
10387 /* This is only needed for distinguishing keyboard and process input. */
10388 if (connection
!= 0)
10389 add_keyboard_wait_descriptor (connection
);
10393 fcntl (connection
, F_SETOWN
, getpid ());
10394 #endif /* ! defined (F_SETOWN) */
10397 if (interrupt_input
)
10398 init_sigio (connection
);
10399 #endif /* ! defined (SIGIO) */
10403 Display
*dpy
= dpyinfo
->display
;
10404 XrmValue d
, fr
, to
;
10407 d
.addr
= (XPointer
)&dpy
;
10408 d
.size
= sizeof (Display
*);
10409 fr
.addr
= XtDefaultFont
;
10410 fr
.size
= sizeof (XtDefaultFont
);
10411 to
.size
= sizeof (Font
*);
10412 to
.addr
= (XPointer
)&font
;
10413 x_catch_errors (dpy
);
10414 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
10416 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
10417 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
10418 x_uncatch_errors ();
10422 /* See if we should run in synchronous mode. This is useful
10423 for debugging X code. */
10426 value
= display_x_get_resource (dpyinfo
,
10427 build_string ("synchronous"),
10428 build_string ("Synchronous"),
10430 if (STRINGP (value
)
10431 && (!strcmp (SDATA (value
), "true")
10432 || !strcmp (SDATA (value
), "on")))
10433 XSynchronize (dpyinfo
->display
, True
);
10438 value
= display_x_get_resource (dpyinfo
,
10439 build_string ("useXIM"),
10440 build_string ("UseXIM"),
10443 if (STRINGP (value
)
10444 && (!strcmp (SDATA (value
), "false")
10445 || !strcmp (SDATA (value
), "off")))
10448 if (STRINGP (value
)
10449 && (!strcmp (SDATA (value
), "true")
10450 || !strcmp (SDATA (value
), "on")))
10456 /* Only do this for the very first display in the Emacs session.
10457 Ignore X session management when Emacs was first started on a
10459 if (terminal
->id
== 1)
10460 x_session_initialize (dpyinfo
);
10468 /* Get rid of display DPYINFO, deleting all frames on it,
10469 and without sending any more commands to the X server. */
10472 x_delete_display (dpyinfo
)
10473 struct x_display_info
*dpyinfo
;
10476 struct terminal
*t
;
10478 /* Close all frames and delete the generic struct terminal for this
10480 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
10481 if (t
->type
== output_x_window
&& t
->display_info
.x
== dpyinfo
)
10484 /* Close X session management when we close its display. */
10485 if (t
->id
== 1 && x_session_have_connection ())
10488 delete_terminal (t
);
10492 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
10494 /* Discard this display from x_display_name_list and x_display_list.
10495 We can't use Fdelq because that can quit. */
10496 if (! NILP (x_display_name_list
)
10497 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
10498 x_display_name_list
= XCDR (x_display_name_list
);
10503 tail
= x_display_name_list
;
10504 while (CONSP (tail
) && CONSP (XCDR (tail
)))
10506 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
10508 XSETCDR (tail
, XCDR (XCDR (tail
)));
10511 tail
= XCDR (tail
);
10515 if (next_noop_dpyinfo
== dpyinfo
)
10516 next_noop_dpyinfo
= dpyinfo
->next
;
10518 if (x_display_list
== dpyinfo
)
10519 x_display_list
= dpyinfo
->next
;
10522 struct x_display_info
*tail
;
10524 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
10525 if (tail
->next
== dpyinfo
)
10526 tail
->next
= tail
->next
->next
;
10529 /* Xt and GTK do this themselves. */
10530 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
10531 #ifndef AIX /* On AIX, XCloseDisplay calls this. */
10532 XrmDestroyDatabase (dpyinfo
->xrdb
);
10537 xim_close_dpy (dpyinfo
);
10540 xfree (dpyinfo
->x_id_name
);
10541 xfree (dpyinfo
->color_cells
);
10545 #ifdef USE_X_TOOLKIT
10547 /* Atimer callback function for TIMER. Called every 0.1s to process
10548 Xt timeouts, if needed. We must avoid calling XtAppPending as
10549 much as possible because that function does an implicit XFlush
10550 that slows us down. */
10553 x_process_timeouts (timer
)
10554 struct atimer
*timer
;
10557 x_timeout_atimer_activated_flag
= 0;
10558 if (toolkit_scroll_bar_interaction
|| popup_activated ())
10560 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
10561 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
10562 /* Reactivate the atimer for next time. */
10563 x_activate_timeout_atimer ();
10568 /* Install an asynchronous timer that processes Xt timeout events
10569 every 0.1s as long as either `toolkit_scroll_bar_interaction' or
10570 `popup_activated_flag' (in xmenu.c) is set. Make sure to call this
10571 function whenever these variables are set. This is necessary
10572 because some widget sets use timeouts internally, for example the
10573 LessTif menu bar, or the Xaw3d scroll bar. When Xt timeouts aren't
10574 processed, these widgets don't behave normally. */
10577 x_activate_timeout_atimer ()
10580 if (!x_timeout_atimer_activated_flag
)
10582 EMACS_TIME interval
;
10584 EMACS_SET_SECS_USECS (interval
, 0, 100000);
10585 start_atimer (ATIMER_RELATIVE
, interval
, x_process_timeouts
, 0);
10586 x_timeout_atimer_activated_flag
= 1;
10591 #endif /* USE_X_TOOLKIT */
10594 /* Set up use of X before we make the first connection. */
10596 extern frame_parm_handler x_frame_parm_handlers
[];
10598 static struct redisplay_interface x_redisplay_interface
=
10600 x_frame_parm_handlers
,
10604 x_clear_end_of_line
,
10606 x_after_update_window_line
,
10607 x_update_window_begin
,
10608 x_update_window_end
,
10614 0, /* flush_display_optional */
10616 x_clear_window_mouse_face
,
10617 x_get_glyph_overhangs
,
10618 x_fix_overlapping_area
,
10619 x_draw_fringe_bitmap
,
10620 0, /* define_fringe_bitmap */
10621 0, /* destroy_fringe_bitmap */
10622 x_compute_glyph_string_overhangs
,
10623 x_draw_glyph_string
,
10624 x_define_frame_cursor
,
10625 x_clear_frame_area
,
10626 x_draw_window_cursor
,
10627 x_draw_vertical_window_border
,
10628 x_shift_glyphs_for_insert
10632 /* This function is called when the last frame on a display is deleted. */
10634 x_delete_terminal (struct terminal
*terminal
)
10636 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
10639 /* Protect against recursive calls. Fdelete_frame in
10640 delete_terminal calls us back when it deletes our last frame. */
10641 if (!terminal
->name
)
10645 /* If called from x_connection_closed, the display may already be closed
10646 and dpyinfo->display was set to 0 to indicate that. */
10647 if (dpyinfo
->display
)
10649 x_destroy_all_bitmaps (dpyinfo
);
10650 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
10653 xg_display_close (dpyinfo
->display
);
10655 #ifdef USE_X_TOOLKIT
10656 XtCloseDisplay (dpyinfo
->display
);
10658 XCloseDisplay (dpyinfo
->display
);
10660 #endif /* ! USE_GTK */
10663 x_delete_display (dpyinfo
);
10667 /* Create a struct terminal, initialize it with the X11 specific
10668 functions and make DISPLAY->TERMINAL point to it. */
10670 static struct terminal
*
10671 x_create_terminal (struct x_display_info
*dpyinfo
)
10673 struct terminal
*terminal
;
10675 terminal
= create_terminal ();
10677 terminal
->type
= output_x_window
;
10678 terminal
->display_info
.x
= dpyinfo
;
10679 dpyinfo
->terminal
= terminal
;
10681 /* kboard is initialized in x_term_init. */
10683 terminal
->clear_frame_hook
= x_clear_frame
;
10684 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
10685 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
10686 terminal
->ring_bell_hook
= XTring_bell
;
10687 terminal
->reset_terminal_modes_hook
= XTreset_terminal_modes
;
10688 terminal
->set_terminal_modes_hook
= XTset_terminal_modes
;
10689 terminal
->update_begin_hook
= x_update_begin
;
10690 terminal
->update_end_hook
= x_update_end
;
10691 terminal
->set_terminal_window_hook
= XTset_terminal_window
;
10692 terminal
->read_socket_hook
= XTread_socket
;
10693 terminal
->frame_up_to_date_hook
= XTframe_up_to_date
;
10694 terminal
->mouse_position_hook
= XTmouse_position
;
10695 terminal
->frame_rehighlight_hook
= XTframe_rehighlight
;
10696 terminal
->frame_raise_lower_hook
= XTframe_raise_lower
;
10697 terminal
->fullscreen_hook
= XTfullscreen_hook
;
10698 terminal
->set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
10699 terminal
->condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
10700 terminal
->redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
10701 terminal
->judge_scroll_bars_hook
= XTjudge_scroll_bars
;
10703 terminal
->delete_frame_hook
= x_destroy_window
;
10704 terminal
->delete_terminal_hook
= x_delete_terminal
;
10706 terminal
->rif
= &x_redisplay_interface
;
10707 terminal
->scroll_region_ok
= 1; /* We'll scroll partial frames. */
10708 terminal
->char_ins_del_ok
= 1;
10709 terminal
->line_ins_del_ok
= 1; /* We'll just blt 'em. */
10710 terminal
->fast_clear_end_of_line
= 1; /* X does this well. */
10711 terminal
->memory_below_frame
= 0; /* We don't remember what scrolls
10723 last_tool_bar_item
= -1;
10724 any_help_event_p
= 0;
10725 ignore_next_mouse_click_timeout
= 0;
10727 x_session_initialized
= 0;
10731 current_count
= -1;
10734 /* Try to use interrupt input; if we can't, then start polling. */
10735 Fset_input_interrupt_mode (Qt
);
10737 #ifdef USE_X_TOOLKIT
10738 XtToolkitInitialize ();
10740 Xt_app_con
= XtCreateApplicationContext ();
10742 /* Register a converter from strings to pixels, which uses
10743 Emacs' color allocation infrastructure. */
10744 XtAppSetTypeConverter (Xt_app_con
,
10745 XtRString
, XtRPixel
, cvt_string_to_pixel
,
10746 cvt_string_to_pixel_args
,
10747 XtNumber (cvt_string_to_pixel_args
),
10748 XtCacheByDisplay
, cvt_pixel_dtor
);
10750 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
10753 #ifdef USE_TOOLKIT_SCROLL_BARS
10755 xaw3d_arrow_scroll
= False
;
10756 xaw3d_pick_top
= True
;
10760 /* Note that there is no real way portable across R3/R4 to get the
10761 original error handler. */
10762 XSetErrorHandler (x_error_handler
);
10763 XSetIOErrorHandler (x_io_error_quitter
);
10765 /* Disable Window Change signals; they are handled by X events. */
10766 #if 0 /* Don't. We may want to open tty frames later. */
10768 signal (SIGWINCH
, SIG_DFL
);
10769 #endif /* SIGWINCH */
10772 signal (SIGPIPE
, x_connection_signal
);
10779 x_error_message
= NULL
;
10781 staticpro (&x_display_name_list
);
10782 x_display_name_list
= Qnil
;
10784 staticpro (&last_mouse_scroll_bar
);
10785 last_mouse_scroll_bar
= Qnil
;
10787 staticpro (&Qvendor_specific_keysyms
);
10788 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
10790 staticpro (&Qlatin_1
);
10791 Qlatin_1
= intern ("latin-1");
10793 staticpro (&last_mouse_press_frame
);
10794 last_mouse_press_frame
= Qnil
;
10796 DEFVAR_BOOL ("x-use-underline-position-properties",
10797 &x_use_underline_position_properties
,
10798 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
10799 A value of nil means ignore them. If you encounter fonts with bogus
10800 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
10801 to 4.1, set this to nil. You can also use `underline-minimum-offset'
10802 to override the font's UNDERLINE_POSITION for small font display
10804 x_use_underline_position_properties
= 1;
10806 DEFVAR_BOOL ("x-underline-at-descent-line",
10807 &x_underline_at_descent_line
,
10808 doc
: /* *Non-nil means to draw the underline at the same place as the descent line.
10809 A value of nil means to draw the underline according to the value of the
10810 variable `x-use-underline-position-properties', which is usually at the
10811 baseline level. The default value is nil. */);
10812 x_underline_at_descent_line
= 0;
10814 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
10815 &x_mouse_click_focus_ignore_position
,
10816 doc
: /* Non-nil means that a mouse click to focus a frame does not move point.
10817 This variable is only used when the window manager requires that you
10818 click on a frame to select it (give it focus). In that case, a value
10819 of nil, means that the selected window and cursor position changes to
10820 reflect the mouse click position, while a non-nil value means that the
10821 selected window or cursor position is preserved. */);
10822 x_mouse_click_focus_ignore_position
= 0;
10824 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
10825 doc
: /* What X toolkit scroll bars Emacs uses.
10826 A value of nil means Emacs doesn't use X toolkit scroll bars.
10827 Otherwise, value is a symbol describing the X toolkit. */);
10828 #ifdef USE_TOOLKIT_SCROLL_BARS
10830 Vx_toolkit_scroll_bars
= intern ("motif");
10831 #elif defined HAVE_XAW3D
10832 Vx_toolkit_scroll_bars
= intern ("xaw3d");
10834 Vx_toolkit_scroll_bars
= intern ("gtk");
10836 Vx_toolkit_scroll_bars
= intern ("xaw");
10839 Vx_toolkit_scroll_bars
= Qnil
;
10842 staticpro (&last_mouse_motion_frame
);
10843 last_mouse_motion_frame
= Qnil
;
10845 Qmodifier_value
= intern ("modifier-value");
10846 Qalt
= intern ("alt");
10847 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
10848 Qhyper
= intern ("hyper");
10849 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
10850 Qmeta
= intern ("meta");
10851 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
10852 Qsuper
= intern ("super");
10853 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
10855 DEFVAR_LISP ("x-alt-keysym", &Vx_alt_keysym
,
10856 doc
: /* Which keys Emacs uses for the alt modifier.
10857 This should be one of the symbols `alt', `hyper', `meta', `super'.
10858 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
10859 is nil, which is the same as `alt'. */);
10860 Vx_alt_keysym
= Qnil
;
10862 DEFVAR_LISP ("x-hyper-keysym", &Vx_hyper_keysym
,
10863 doc
: /* Which keys Emacs uses for the hyper modifier.
10864 This should be one of the symbols `alt', `hyper', `meta', `super'.
10865 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
10866 default is nil, which is the same as `hyper'. */);
10867 Vx_hyper_keysym
= Qnil
;
10869 DEFVAR_LISP ("x-meta-keysym", &Vx_meta_keysym
,
10870 doc
: /* Which keys Emacs uses for the meta modifier.
10871 This should be one of the symbols `alt', `hyper', `meta', `super'.
10872 For example, `meta' means use the Meta_L and Meta_R keysyms. The
10873 default is nil, which is the same as `meta'. */);
10874 Vx_meta_keysym
= Qnil
;
10876 DEFVAR_LISP ("x-super-keysym", &Vx_super_keysym
,
10877 doc
: /* Which keys Emacs uses for the super modifier.
10878 This should be one of the symbols `alt', `hyper', `meta', `super'.
10879 For example, `super' means use the Super_L and Super_R keysyms. The
10880 default is nil, which is the same as `super'. */);
10881 Vx_super_keysym
= Qnil
;
10883 DEFVAR_LISP ("x-keysym-table", &Vx_keysym_table
,
10884 doc
: /* Hash table of character codes indexed by X keysym codes. */);
10885 Vx_keysym_table
= make_hash_table (Qeql
, make_number (900),
10886 make_float (DEFAULT_REHASH_SIZE
),
10887 make_float (DEFAULT_REHASH_THRESHOLD
),
10891 #endif /* HAVE_X_WINDOWS */
10893 /* arch-tag: 6d4e4cb7-abc1-4302-9585-d84dcfb09d0f
10894 (do not change this comment) */