1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
4 Free Software Foundation, Inc.
6 This file is part of GNU Emacs.
8 GNU Emacs is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 GNU Emacs is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 /* New display code by Gerd Moellmann <gerd@gnu.org>. */
22 /* Xt features made by Fred Pierresteguy. */
26 /* On 4.3 these lose if they come after xterm.h. */
27 /* Putting these at the beginning seems to be standard for other .c files. */
36 #include "blockinput.h"
38 /* Need syssignal.h for various externs and definitions that may be required
39 by some configurations for calls to signal later in this source file. */
40 #include "syssignal.h"
42 /* This may include sys/types.h, and that somehow loses
43 if this is not done before the other system files. */
45 #include <X11/cursorfont.h>
47 /* Load sys/types.h if not already loaded.
48 In some systems loading it twice is suicidal. */
50 #include <sys/types.h>
53 #ifdef HAVE_SYS_IOCTL_H
54 #include <sys/ioctl.h>
55 #endif /* ! defined (HAVE_SYS_IOCTL_H) */
64 /* Caused redefinition of DBL_DIG on Netbsd; seems not to be needed. */
65 /* #include <sys/param.h> */
68 #include "character.h"
71 #include "dispextern.h"
73 #include "termhooks.h"
76 #include "emacs-icon.h"
81 #include "intervals.h"
87 #include "xsettings.h"
89 #include "sysselect.h"
92 #include <X11/Shell.h>
95 #ifdef HAVE_SYS_TIME_H
107 extern int xlwmenu_window_p (Widget w
, Window window
);
108 extern void xlwmenu_redisplay (Widget
);
111 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
113 extern void free_frame_menubar (struct frame
*);
117 #if !defined(NO_EDITRES)
119 extern void _XEditResCheckMessages ();
120 #endif /* not NO_EDITRES */
122 /* Include toolkit specific headers for the scroll bar widget. */
124 #ifdef USE_TOOLKIT_SCROLL_BARS
125 #if defined USE_MOTIF
126 #include <Xm/Xm.h> /* for LESSTIF_VERSION */
127 #include <Xm/ScrollBar.h>
128 #else /* !USE_MOTIF i.e. use Xaw */
131 #include <X11/Xaw3d/Simple.h>
132 #include <X11/Xaw3d/Scrollbar.h>
133 #include <X11/Xaw3d/ThreeD.h>
134 #else /* !HAVE_XAW3D */
135 #include <X11/Xaw/Simple.h>
136 #include <X11/Xaw/Scrollbar.h>
137 #endif /* !HAVE_XAW3D */
139 #define XtNpickTop "pickTop"
140 #endif /* !XtNpickTop */
141 #endif /* !USE_MOTIF */
142 #endif /* USE_TOOLKIT_SCROLL_BARS */
144 #endif /* USE_X_TOOLKIT */
148 #ifndef XtNinitialState
149 #define XtNinitialState "initialState"
153 /* Default to using XIM if available. */
157 int use_xim
= 0; /* configure --without-xim */
162 /* Non-nil means Emacs uses toolkit scroll bars. */
164 Lisp_Object Vx_toolkit_scroll_bars
;
166 /* Non-zero means that a HELP_EVENT has been generated since Emacs
169 static int any_help_event_p
;
171 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
172 static Lisp_Object last_window
;
174 /* Non-zero means make use of UNDERLINE_POSITION font properties. */
176 int x_use_underline_position_properties
;
178 /* Non-zero means to draw the underline at the same place as the descent line. */
180 int x_underline_at_descent_line
;
182 /* This is a chain of structures for all the X displays currently in
185 struct x_display_info
*x_display_list
;
187 /* This is a list of cons cells, each of the form (NAME
188 . FONT-LIST-CACHE), one for each element of x_display_list and in
189 the same order. NAME is the name of the frame. FONT-LIST-CACHE
190 records previous values returned by x-list-fonts. */
192 Lisp_Object x_display_name_list
;
194 /* Frame being updated by update_frame. This is declared in term.c.
195 This is set by update_begin and looked at by all the XT functions.
196 It is zero while not inside an update. In that case, the XT
197 functions assume that `selected_frame' is the frame to apply to. */
199 extern struct frame
*updating_frame
;
201 /* This is a frame waiting to be auto-raised, within XTread_socket. */
203 static struct frame
*pending_autoraise_frame
;
205 /* This is a frame waiting for an event matching mask, within XTread_socket. */
210 } pending_event_wait
;
213 /* The application context for Xt use. */
214 XtAppContext Xt_app_con
;
215 static String Xt_default_resources
[] = {0};
216 #endif /* USE_X_TOOLKIT */
218 /* Non-zero means user is interacting with a toolkit scroll bar. */
220 static int toolkit_scroll_bar_interaction
;
222 /* Non-zero means to not move point as a result of clicking on a
223 frame to focus it (when focus-follows-mouse is nil). */
225 int x_mouse_click_focus_ignore_position
;
227 /* Non-zero timeout value means ignore next mouse click if it arrives
228 before that timeout elapses (i.e. as part of the same sequence of
229 events resulting from clicking on a frame to select it). */
231 static unsigned long ignore_next_mouse_click_timeout
;
235 Formerly, we used PointerMotionHintMask (in standard_event_mask)
236 so that we would have to call XQueryPointer after each MotionNotify
237 event to ask for another such event. However, this made mouse tracking
238 slow, and there was a bug that made it eventually stop.
240 Simply asking for MotionNotify all the time seems to work better.
242 In order to avoid asking for motion events and then throwing most
243 of them away or busy-polling the server for mouse positions, we ask
244 the server for pointer motion hints. This means that we get only
245 one event per group of mouse movements. "Groups" are delimited by
246 other kinds of events (focus changes and button clicks, for
247 example), or by XQueryPointer calls; when one of these happens, we
248 get another MotionNotify event the next time the mouse moves. This
249 is at least as efficient as getting motion events when mouse
250 tracking is on, and I suspect only negligibly worse when tracking
253 /* Where the mouse was last time we reported a mouse event. */
255 static XRectangle last_mouse_glyph
;
256 static FRAME_PTR last_mouse_glyph_frame
;
257 static Lisp_Object last_mouse_press_frame
;
259 /* The scroll bar in which the last X motion event occurred.
261 If the last X motion event occurred in a scroll bar, we set this so
262 XTmouse_position can know whether to report a scroll bar motion or
265 If the last X motion event didn't occur in a scroll bar, we set
266 this to Qnil, to tell XTmouse_position to return an ordinary motion
269 static Lisp_Object last_mouse_scroll_bar
;
271 /* This is a hack. We would really prefer that XTmouse_position would
272 return the time associated with the position it returns, but there
273 doesn't seem to be any way to wrest the time-stamp from the server
274 along with the position query. So, we just keep track of the time
275 of the last movement we received, and return that in hopes that
276 it's somewhat accurate. */
278 static Time last_mouse_movement_time
;
280 /* Time for last user interaction as returned in X events. */
282 static Time last_user_time
;
284 /* Incremented by XTread_socket whenever it really tries to read
288 static int volatile input_signal_count
;
290 static int input_signal_count
;
293 /* Used locally within XTread_socket. */
295 static int x_noop_count
;
297 /* Initial values of argv and argc. */
299 extern char **initial_argv
;
300 extern int initial_argc
;
302 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
304 /* Tells if a window manager is present or not. */
306 extern Lisp_Object Vx_no_window_manager
;
308 extern Lisp_Object Qeql
;
310 /* A mask of extra modifier bits to put into every keyboard char. */
312 extern EMACS_INT extra_keyboard_modifiers
;
314 /* The keysyms to use for the various modifiers. */
316 Lisp_Object Vx_alt_keysym
, Vx_hyper_keysym
, Vx_meta_keysym
, Vx_super_keysym
;
317 Lisp_Object Vx_keysym_table
;
318 static Lisp_Object Qalt
, Qhyper
, Qmeta
, Qsuper
, Qmodifier_value
;
320 static Lisp_Object Qvendor_specific_keysyms
;
321 static Lisp_Object Qlatin_1
;
324 /* The name of the Emacs icon file. */
325 static Lisp_Object xg_default_icon_file
;
327 /* Used in gtkutil.c. */
328 Lisp_Object Qx_gtk_map_stock
;
331 /* Used in x_flush. */
333 extern Lisp_Object Vinhibit_redisplay
;
335 extern XrmDatabase
x_load_resources (Display
*, char *, char *, char *);
336 extern int x_bitmap_mask (FRAME_PTR
, int);
338 static int x_alloc_nearest_color_1 (Display
*, Colormap
, XColor
*);
339 static void x_set_window_size_1 (struct frame
*, int, int, int);
340 static const XColor
*x_color_cells (Display
*, int *);
341 static void x_update_window_end (struct window
*, int, int);
343 static int x_io_error_quitter (Display
*);
344 static struct terminal
*x_create_terminal (struct x_display_info
*);
345 void x_delete_terminal (struct terminal
*);
346 static void x_update_end (struct frame
*);
347 static void XTframe_up_to_date (struct frame
*);
348 static void XTset_terminal_modes (struct terminal
*);
349 static void XTreset_terminal_modes (struct terminal
*);
350 static void x_clear_frame (struct frame
*);
351 static void frame_highlight (struct frame
*);
352 static void frame_unhighlight (struct frame
*);
353 static void x_new_focus_frame (struct x_display_info
*, struct frame
*);
354 static void x_focus_changed (int, int, struct x_display_info
*,
355 struct frame
*, struct input_event
*);
356 static void x_detect_focus_change (struct x_display_info
*,
357 XEvent
*, struct input_event
*);
358 static void XTframe_rehighlight (struct frame
*);
359 static void x_frame_rehighlight (struct x_display_info
*);
360 static void x_draw_hollow_cursor (struct window
*, struct glyph_row
*);
361 static void x_draw_bar_cursor (struct window
*, struct glyph_row
*, int,
362 enum text_cursor_kinds
);
364 static void x_clip_to_row (struct window
*, struct glyph_row
*, int, GC
);
365 static void x_flush (struct frame
*f
);
366 static void x_update_begin (struct frame
*);
367 static void x_update_window_begin (struct window
*);
368 static void x_after_update_window_line (struct glyph_row
*);
369 static struct scroll_bar
*x_window_to_scroll_bar (Display
*, Window
);
370 static void x_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
371 enum scroll_bar_part
*,
372 Lisp_Object
*, Lisp_Object
*,
374 static void x_handle_net_wm_state (struct frame
*, XPropertyEvent
*);
375 static void x_check_fullscreen (struct frame
*);
376 static void x_check_expected_move (struct frame
*, int, int);
377 static void x_sync_with_move (struct frame
*, int, int, int);
378 static int handle_one_xevent (struct x_display_info
*, XEvent
*,
379 int *, struct input_event
*);
380 /* Don't declare this NO_RETURN because we want no
381 interference with debugging failing X calls. */
382 static SIGTYPE
x_connection_closed (Display
*, char *);
385 /* Flush display of frame F, or of all frames if F is null. */
388 x_flush (struct frame
*f
)
390 /* Don't call XFlush when it is not safe to redisplay; the X
391 connection may be broken. */
392 if (!NILP (Vinhibit_redisplay
))
398 Lisp_Object rest
, frame
;
399 FOR_EACH_FRAME (rest
, frame
)
400 if (FRAME_X_P (XFRAME (frame
)))
401 x_flush (XFRAME (frame
));
403 else if (FRAME_X_P (f
))
404 XFlush (FRAME_X_DISPLAY (f
));
409 /* Remove calls to XFlush by defining XFlush to an empty replacement.
410 Calls to XFlush should be unnecessary because the X output buffer
411 is flushed automatically as needed by calls to XPending,
412 XNextEvent, or XWindowEvent according to the XFlush man page.
413 XTread_socket calls XPending. Removing XFlush improves
416 #define XFlush(DISPLAY) (void) 0
419 /***********************************************************************
421 ***********************************************************************/
425 /* This is a function useful for recording debugging information about
426 the sequence of occurrences in this file. */
434 struct record event_record
[100];
436 int event_record_index
;
438 record_event (locus
, type
)
442 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
443 event_record_index
= 0;
445 event_record
[event_record_index
].locus
= locus
;
446 event_record
[event_record_index
].type
= type
;
447 event_record_index
++;
454 /* Return the struct x_display_info corresponding to DPY. */
456 struct x_display_info
*
457 x_display_info_for_display (Display
*dpy
)
459 struct x_display_info
*dpyinfo
;
461 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
462 if (dpyinfo
->display
== dpy
)
468 #define OPAQUE 0xffffffff
469 #define OPACITY "_NET_WM_WINDOW_OPACITY"
472 x_set_frame_alpha (struct frame
*f
)
474 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
475 Display
*dpy
= FRAME_X_DISPLAY (f
);
476 Window win
= FRAME_OUTER_WINDOW (f
);
478 double alpha_min
= 1.0;
481 if (FRAME_X_DISPLAY_INFO (f
)->root_window
!= FRAME_X_OUTPUT (f
)->parent_desc
)
482 /* Since the WM decoration lies under the FRAME_OUTER_WINDOW,
483 we must treat the former instead of the latter. */
484 win
= FRAME_X_OUTPUT (f
)->parent_desc
;
486 if (dpyinfo
->x_highlight_frame
== f
)
491 if (FLOATP (Vframe_alpha_lower_limit
))
492 alpha_min
= XFLOAT_DATA (Vframe_alpha_lower_limit
);
493 else if (INTEGERP (Vframe_alpha_lower_limit
))
494 alpha_min
= (XINT (Vframe_alpha_lower_limit
)) / 100.0;
498 else if (alpha
> 1.0)
500 else if (0.0 <= alpha
&& alpha
< alpha_min
&& alpha_min
<= 1.0)
503 opac
= alpha
* OPAQUE
;
505 /* return unless necessary */
510 unsigned long n
, left
;
512 x_catch_errors (dpy
);
513 rc
= XGetWindowProperty (dpy
, win
, XInternAtom(dpy
, OPACITY
, False
),
514 0L, 1L, False
, XA_CARDINAL
,
515 &actual
, &format
, &n
, &left
,
518 if (rc
== Success
&& actual
!= None
)
519 if (*(unsigned long *)data
== opac
)
521 XFree ((void *) data
);
526 XFree ((void *) data
);
530 x_catch_errors (dpy
);
531 XChangeProperty (dpy
, win
, XInternAtom (dpy
, OPACITY
, False
),
532 XA_CARDINAL
, 32, PropModeReplace
,
533 (unsigned char *) &opac
, 1L);
538 x_display_pixel_height (struct x_display_info
*dpyinfo
)
540 return HeightOfScreen (dpyinfo
->screen
);
544 x_display_pixel_width (struct x_display_info
*dpyinfo
)
546 return WidthOfScreen (dpyinfo
->screen
);
550 /***********************************************************************
551 Starting and ending an update
552 ***********************************************************************/
554 /* Start an update of frame F. This function is installed as a hook
555 for update_begin, i.e. it is called when update_begin is called.
556 This function is called prior to calls to x_update_window_begin for
557 each window being updated. Currently, there is nothing to do here
558 because all interesting stuff is done on a window basis. */
561 x_update_begin (struct frame
*f
)
567 /* Start update of window W. Set the global variable updated_window
568 to the window being updated and set output_cursor to the cursor
572 x_update_window_begin (struct window
*w
)
574 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
575 struct x_display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
578 set_output_cursor (&w
->cursor
);
582 if (f
== display_info
->mouse_face_mouse_frame
)
584 /* Don't do highlighting for mouse motion during the update. */
585 display_info
->mouse_face_defer
= 1;
587 /* If F needs to be redrawn, simply forget about any prior mouse
589 if (FRAME_GARBAGED_P (f
))
590 display_info
->mouse_face_window
= Qnil
;
597 /* Draw a vertical window border from (x,y0) to (x,y1) */
600 x_draw_vertical_window_border (struct window
*w
, int x
, int y0
, int y1
)
602 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
605 face
= FACE_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
607 XSetForeground (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
610 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
611 f
->output_data
.x
->normal_gc
, x
, y0
, x
, y1
);
614 /* End update of window W (which is equal to updated_window).
616 Draw vertical borders between horizontally adjacent windows, and
617 display W's cursor if CURSOR_ON_P is non-zero.
619 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
620 glyphs in mouse-face were overwritten. In that case we have to
621 make sure that the mouse-highlight is properly redrawn.
623 W may be a menu bar pseudo-window in case we don't have X toolkit
624 support. Such windows don't have a cursor, so don't display it
628 x_update_window_end (struct window
*w
, int cursor_on_p
, int mouse_face_overwritten_p
)
630 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
632 if (!w
->pseudo_window_p
)
637 display_and_set_cursor (w
, 1, output_cursor
.hpos
,
639 output_cursor
.x
, output_cursor
.y
);
641 if (draw_window_fringes (w
, 1))
642 x_draw_vertical_border (w
);
647 /* If a row with mouse-face was overwritten, arrange for
648 XTframe_up_to_date to redisplay the mouse highlight. */
649 if (mouse_face_overwritten_p
)
651 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
652 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
653 dpyinfo
->mouse_face_window
= Qnil
;
656 updated_window
= NULL
;
660 /* End update of frame F. This function is installed as a hook in
664 x_update_end (struct frame
*f
)
666 /* Mouse highlight may be displayed again. */
667 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
671 XFlush (FRAME_X_DISPLAY (f
));
677 /* This function is called from various places in xdisp.c whenever a
678 complete update has been performed. The global variable
679 updated_window is not available here. */
682 XTframe_up_to_date (struct frame
*f
)
686 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
688 if (dpyinfo
->mouse_face_deferred_gc
689 || f
== dpyinfo
->mouse_face_mouse_frame
)
692 if (dpyinfo
->mouse_face_mouse_frame
)
693 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
694 dpyinfo
->mouse_face_mouse_x
,
695 dpyinfo
->mouse_face_mouse_y
);
696 dpyinfo
->mouse_face_deferred_gc
= 0;
703 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
704 arrow bitmaps, or clear the fringes if no bitmaps are required
705 before DESIRED_ROW is made current. The window being updated is
706 found in updated_window. This function It is called from
707 update_window_line only if it is known that there are differences
708 between bitmaps to be drawn between current row and DESIRED_ROW. */
711 x_after_update_window_line (struct glyph_row
*desired_row
)
713 struct window
*w
= updated_window
;
719 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
720 desired_row
->redraw_fringe_bitmaps_p
= 1;
722 /* When a window has disappeared, make sure that no rest of
723 full-width rows stays visible in the internal border. Could
724 check here if updated_window is the leftmost/rightmost window,
725 but I guess it's not worth doing since vertically split windows
726 are almost never used, internal border is rarely set, and the
727 overhead is very small. */
728 if (windows_or_buffers_changed
729 && desired_row
->full_width_p
730 && (f
= XFRAME (w
->frame
),
731 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
733 && (height
= desired_row
->visible_height
,
736 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
739 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
740 0, y
, width
, height
, False
);
741 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
742 FRAME_PIXEL_WIDTH (f
) - width
,
743 y
, width
, height
, False
);
749 x_draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
, struct draw_fringe_bitmap_params
*p
)
751 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
752 Display
*display
= FRAME_X_DISPLAY (f
);
753 Window window
= FRAME_X_WINDOW (f
);
754 GC gc
= f
->output_data
.x
->normal_gc
;
755 struct face
*face
= p
->face
;
757 /* Must clip because of partially visible lines. */
758 x_clip_to_row (w
, row
, -1, gc
);
762 int bx
= p
->bx
, by
= p
->by
, nx
= p
->nx
, ny
= p
->ny
;
764 /* In case the same realized face is used for fringes and
765 for something displayed in the text (e.g. face `region' on
766 mono-displays, the fill style may have been changed to
767 FillSolid in x_draw_glyph_string_background. */
769 XSetFillStyle (display
, face
->gc
, FillOpaqueStippled
);
771 XSetForeground (display
, face
->gc
, face
->background
);
773 #ifdef USE_TOOLKIT_SCROLL_BARS
774 /* If the fringe is adjacent to the left (right) scroll bar of a
775 leftmost (rightmost, respectively) window, then extend its
776 background to the gap between the fringe and the bar. */
777 if ((WINDOW_LEFTMOST_P (w
)
778 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
779 || (WINDOW_RIGHTMOST_P (w
)
780 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
)))
782 int sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
786 int left
= WINDOW_SCROLL_BAR_AREA_X (w
);
787 int width
= (WINDOW_CONFIG_SCROLL_BAR_COLS (w
)
788 * FRAME_COLUMN_WIDTH (f
));
792 /* Bitmap fills the fringe. */
793 if (left
+ width
== p
->x
)
794 bx
= left
+ sb_width
;
795 else if (p
->x
+ p
->wd
== left
)
799 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
801 nx
= width
- sb_width
;
802 by
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
804 ny
= row
->visible_height
;
809 if (left
+ width
== bx
)
811 bx
= left
+ sb_width
;
812 nx
+= width
- sb_width
;
814 else if (bx
+ nx
== left
)
815 nx
+= width
- sb_width
;
820 if (bx
>= 0 && nx
> 0)
821 XFillRectangle (display
, window
, face
->gc
, bx
, by
, nx
, ny
);
824 XSetForeground (display
, face
->gc
, face
->foreground
);
830 Pixmap pixmap
, clipmask
= (Pixmap
) 0;
831 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
835 bits
= (unsigned char *)(p
->bits
+ p
->dh
);
837 bits
= (unsigned char *)p
->bits
+ p
->dh
;
839 /* Draw the bitmap. I believe these small pixmaps can be cached
841 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, p
->wd
, p
->h
,
843 ? (p
->overlay_p
? face
->background
844 : f
->output_data
.x
->cursor_pixel
)
846 face
->background
, depth
);
850 clipmask
= XCreatePixmapFromBitmapData (display
,
851 FRAME_X_DISPLAY_INFO (f
)->root_window
,
854 gcv
.clip_mask
= clipmask
;
855 gcv
.clip_x_origin
= p
->x
;
856 gcv
.clip_y_origin
= p
->y
;
857 XChangeGC (display
, gc
, GCClipMask
| GCClipXOrigin
| GCClipYOrigin
, &gcv
);
860 XCopyArea (display
, pixmap
, window
, gc
, 0, 0,
861 p
->wd
, p
->h
, p
->x
, p
->y
);
862 XFreePixmap (display
, pixmap
);
866 gcv
.clip_mask
= (Pixmap
) 0;
867 XChangeGC (display
, gc
, GCClipMask
, &gcv
);
868 XFreePixmap (display
, clipmask
);
872 XSetClipMask (display
, gc
, None
);
877 /* This is called when starting Emacs and when restarting after
878 suspend. When starting Emacs, no X window is mapped. And nothing
879 must be done to Emacs's own window if it is suspended (though that
883 XTset_terminal_modes (struct terminal
*terminal
)
887 /* This is called when exiting or suspending Emacs. Exiting will make
888 the X-windows go away, and suspending requires no action. */
891 XTreset_terminal_modes (struct terminal
*terminal
)
896 /***********************************************************************
898 ***********************************************************************/
902 static void x_set_glyph_string_clipping (struct glyph_string
*);
903 static void x_set_glyph_string_gc (struct glyph_string
*);
904 static void x_draw_glyph_string_background (struct glyph_string
*,
906 static void x_draw_glyph_string_foreground (struct glyph_string
*);
907 static void x_draw_composite_glyph_string_foreground (struct glyph_string
*);
908 static void x_draw_glyph_string_box (struct glyph_string
*);
909 static void x_draw_glyph_string (struct glyph_string
*);
910 static void x_compute_glyph_string_overhangs (struct glyph_string
*);
911 static void x_set_cursor_gc (struct glyph_string
*);
912 static void x_set_mode_line_face_gc (struct glyph_string
*);
913 static void x_set_mouse_face_gc (struct glyph_string
*);
914 static int x_alloc_lighter_color (struct frame
*, Display
*, Colormap
,
915 unsigned long *, double, int);
916 static void x_setup_relief_color (struct frame
*, struct relief
*,
917 double, int, unsigned long);
918 static void x_setup_relief_colors (struct glyph_string
*);
919 static void x_draw_image_glyph_string (struct glyph_string
*);
920 static void x_draw_image_relief (struct glyph_string
*);
921 static void x_draw_image_foreground (struct glyph_string
*);
922 static void x_draw_image_foreground_1 (struct glyph_string
*, Pixmap
);
923 static void x_clear_glyph_string_rect (struct glyph_string
*, int,
925 static void x_draw_relief_rect (struct frame
*, int, int, int, int,
926 int, int, int, int, int, int,
928 static void x_draw_box_rect (struct glyph_string
*, int, int, int, int,
929 int, int, int, XRectangle
*);
932 static void x_check_font (struct frame
*, struct font
*);
936 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
940 x_set_cursor_gc (struct glyph_string
*s
)
942 if (s
->font
== FRAME_FONT (s
->f
)
943 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
944 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
946 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
949 /* Cursor on non-default face: must merge. */
953 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
954 xgcv
.foreground
= s
->face
->background
;
956 /* If the glyph would be invisible, try a different foreground. */
957 if (xgcv
.foreground
== xgcv
.background
)
958 xgcv
.foreground
= s
->face
->foreground
;
959 if (xgcv
.foreground
== xgcv
.background
)
960 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
961 if (xgcv
.foreground
== xgcv
.background
)
962 xgcv
.foreground
= s
->face
->foreground
;
964 /* Make sure the cursor is distinct from text in this face. */
965 if (xgcv
.background
== s
->face
->background
966 && xgcv
.foreground
== s
->face
->foreground
)
968 xgcv
.background
= s
->face
->foreground
;
969 xgcv
.foreground
= s
->face
->background
;
972 IF_DEBUG (x_check_font (s
->f
, s
->font
));
973 xgcv
.graphics_exposures
= False
;
974 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
976 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
977 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
980 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
981 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
983 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
988 /* Set up S->gc of glyph string S for drawing text in mouse face. */
991 x_set_mouse_face_gc (struct glyph_string
*s
)
996 /* What face has to be used last for the mouse face? */
997 face_id
= FRAME_X_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
998 face
= FACE_FROM_ID (s
->f
, face_id
);
1000 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1002 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1003 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
1005 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
1006 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1007 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1009 if (s
->font
== s
->face
->font
)
1010 s
->gc
= s
->face
->gc
;
1013 /* Otherwise construct scratch_cursor_gc with values from FACE
1018 xgcv
.background
= s
->face
->background
;
1019 xgcv
.foreground
= s
->face
->foreground
;
1020 xgcv
.graphics_exposures
= False
;
1021 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
1023 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1024 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1027 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1028 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
1030 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1033 xassert (s
->gc
!= 0);
1037 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1038 Faces to use in the mode line have already been computed when the
1039 matrix was built, so there isn't much to do, here. */
1042 x_set_mode_line_face_gc (struct glyph_string
*s
)
1044 s
->gc
= s
->face
->gc
;
1048 /* Set S->gc of glyph string S for drawing that glyph string. Set
1049 S->stippled_p to a non-zero value if the face of S has a stipple
1053 x_set_glyph_string_gc (struct glyph_string
*s
)
1055 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1057 if (s
->hl
== DRAW_NORMAL_TEXT
)
1059 s
->gc
= s
->face
->gc
;
1060 s
->stippled_p
= s
->face
->stipple
!= 0;
1062 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1064 x_set_mode_line_face_gc (s
);
1065 s
->stippled_p
= s
->face
->stipple
!= 0;
1067 else if (s
->hl
== DRAW_CURSOR
)
1069 x_set_cursor_gc (s
);
1072 else if (s
->hl
== DRAW_MOUSE_FACE
)
1074 x_set_mouse_face_gc (s
);
1075 s
->stippled_p
= s
->face
->stipple
!= 0;
1077 else if (s
->hl
== DRAW_IMAGE_RAISED
1078 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1080 s
->gc
= s
->face
->gc
;
1081 s
->stippled_p
= s
->face
->stipple
!= 0;
1085 s
->gc
= s
->face
->gc
;
1086 s
->stippled_p
= s
->face
->stipple
!= 0;
1089 /* GC must have been set. */
1090 xassert (s
->gc
!= 0);
1094 /* Set clipping for output of glyph string S. S may be part of a mode
1095 line or menu if we don't have X toolkit support. */
1098 x_set_glyph_string_clipping (struct glyph_string
*s
)
1100 XRectangle
*r
= s
->clip
;
1101 int n
= get_glyph_string_clip_rects (s
, r
, 2);
1104 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, r
, n
, Unsorted
);
1109 /* Set SRC's clipping for output of glyph string DST. This is called
1110 when we are drawing DST's left_overhang or right_overhang only in
1114 x_set_glyph_string_clipping_exactly (struct glyph_string
*src
, struct glyph_string
*dst
)
1119 r
.width
= src
->width
;
1121 r
.height
= src
->height
;
1124 XSetClipRectangles (dst
->display
, dst
->gc
, 0, 0, &r
, 1, Unsorted
);
1129 Compute left and right overhang of glyph string S. */
1132 x_compute_glyph_string_overhangs (struct glyph_string
*s
)
1135 && (s
->first_glyph
->type
== CHAR_GLYPH
1136 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
1138 struct font_metrics metrics
;
1140 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1142 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1143 struct font
*font
= s
->font
;
1146 for (i
= 0; i
< s
->nchars
; i
++)
1147 code
[i
] = (s
->char2b
[i
].byte1
<< 8) | s
->char2b
[i
].byte2
;
1148 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1152 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1154 composition_gstring_width (gstring
, s
->cmp_from
, s
->cmp_to
, &metrics
);
1156 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1157 ? metrics
.rbearing
- metrics
.width
: 0);
1158 s
->left_overhang
= metrics
.lbearing
< 0 ? - metrics
.lbearing
: 0;
1162 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1163 s
->left_overhang
= - s
->cmp
->lbearing
;
1168 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1171 x_clear_glyph_string_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
1174 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
1175 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
1176 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
1177 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
1181 /* Draw the background of glyph_string S. If S->background_filled_p
1182 is non-zero don't draw it. FORCE_P non-zero means draw the
1183 background even if it wouldn't be drawn normally. This is used
1184 when a string preceding S draws into the background of S, or S
1185 contains the first component of a composition. */
1188 x_draw_glyph_string_background (struct glyph_string
*s
, int force_p
)
1190 /* Nothing to do if background has already been drawn or if it
1191 shouldn't be drawn in the first place. */
1192 if (!s
->background_filled_p
)
1194 int box_line_width
= max (s
->face
->box_line_width
, 0);
1198 /* Fill background with a stipple pattern. */
1199 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1200 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1201 s
->y
+ box_line_width
,
1202 s
->background_width
,
1203 s
->height
- 2 * box_line_width
);
1204 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1205 s
->background_filled_p
= 1;
1207 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1208 || s
->font_not_found_p
1209 || s
->extends_to_end_of_line_p
1212 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1213 s
->background_width
,
1214 s
->height
- 2 * box_line_width
);
1215 s
->background_filled_p
= 1;
1221 /* Draw the foreground of glyph string S. */
1224 x_draw_glyph_string_foreground (struct glyph_string
*s
)
1228 /* If first glyph of S has a left box line, start drawing the text
1229 of S to the right of that box line. */
1230 if (s
->face
->box
!= FACE_NO_BOX
1231 && s
->first_glyph
->left_box_line_p
)
1232 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1236 /* Draw characters of S as rectangles if S's font could not be
1238 if (s
->font_not_found_p
)
1240 for (i
= 0; i
< s
->nchars
; ++i
)
1242 struct glyph
*g
= s
->first_glyph
+ i
;
1243 XDrawRectangle (s
->display
, s
->window
,
1244 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1246 x
+= g
->pixel_width
;
1251 struct font
*font
= s
->font
;
1252 int boff
= font
->baseline_offset
;
1255 if (font
->vertical_centering
)
1256 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1258 y
= s
->ybase
- boff
;
1260 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1261 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 0);
1263 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 1);
1264 if (s
->face
->overstrike
)
1265 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, 0);
1269 /* Draw the foreground of composite glyph string S. */
1272 x_draw_composite_glyph_string_foreground (struct glyph_string
*s
)
1275 struct font
*font
= s
->font
;
1277 /* If first glyph of S has a left box line, start drawing the text
1278 of S to the right of that box line. */
1279 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1280 && s
->first_glyph
->left_box_line_p
)
1281 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1285 /* S is a glyph string for a composition. S->cmp_from is the index
1286 of the first character drawn for glyphs of this composition.
1287 S->cmp_from == 0 means we are drawing the very first character of
1288 this composition. */
1290 /* Draw a rectangle for the composition if the font for the very
1291 first character of the composition could not be loaded. */
1292 if (s
->font_not_found_p
)
1294 if (s
->cmp_from
== 0)
1295 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, s
->y
,
1296 s
->width
- 1, s
->height
- 1);
1298 else if (! s
->first_glyph
->u
.cmp
.automatic
)
1302 for (i
= 0, j
= s
->cmp_from
; i
< s
->nchars
; i
++, j
++)
1303 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1305 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1306 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1308 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, 0);
1309 if (s
->face
->overstrike
)
1310 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, 0);
1315 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1320 for (i
= j
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
1322 glyph
= LGSTRING_GLYPH (gstring
, i
);
1323 if (NILP (LGLYPH_ADJUSTMENT (glyph
)))
1324 width
+= LGLYPH_WIDTH (glyph
);
1327 int xoff
, yoff
, wadjust
;
1331 font
->driver
->draw (s
, j
, i
, x
, y
, 0);
1332 if (s
->face
->overstrike
)
1333 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, 0);
1336 xoff
= LGLYPH_XOFF (glyph
);
1337 yoff
= LGLYPH_YOFF (glyph
);
1338 wadjust
= LGLYPH_WADJUST (glyph
);
1339 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, 0);
1340 if (s
->face
->overstrike
)
1341 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
+ 1, y
+ yoff
, 0);
1349 font
->driver
->draw (s
, j
, i
, x
, y
, 0);
1350 if (s
->face
->overstrike
)
1351 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, 0);
1357 #ifdef USE_X_TOOLKIT
1359 static struct frame
*x_frame_of_widget (Widget
);
1360 static Boolean
cvt_string_to_pixel (Display
*, XrmValue
*, Cardinal
*,
1361 XrmValue
*, XrmValue
*, XtPointer
*);
1362 static void cvt_pixel_dtor (XtAppContext
, XrmValue
*, XtPointer
,
1363 XrmValue
*, Cardinal
*);
1366 /* Return the frame on which widget WIDGET is used.. Abort if frame
1367 cannot be determined. */
1369 static struct frame
*
1370 x_frame_of_widget (widget
)
1373 struct x_display_info
*dpyinfo
;
1377 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
1379 /* Find the top-level shell of the widget. Note that this function
1380 can be called when the widget is not yet realized, so XtWindow
1381 (widget) == 0. That's the reason we can't simply use
1382 x_any_window_to_frame. */
1383 while (!XtIsTopLevelShell (widget
))
1384 widget
= XtParent (widget
);
1386 /* Look for a frame with that top-level widget. Allocate the color
1387 on that frame to get the right gamma correction value. */
1388 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1389 if (FRAMEP (XCAR (tail
))
1390 && (f
= XFRAME (XCAR (tail
)),
1392 && f
->output_data
.nothing
!= 1
1393 && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
))
1394 && f
->output_data
.x
->widget
== widget
)
1401 /* Allocate the color COLOR->pixel on the screen and display of
1402 widget WIDGET in colormap CMAP. If an exact match cannot be
1403 allocated, try the nearest color available. Value is non-zero
1404 if successful. This is called from lwlib. */
1407 x_alloc_nearest_color_for_widget (widget
, cmap
, color
)
1412 struct frame
*f
= x_frame_of_widget (widget
);
1413 return x_alloc_nearest_color (f
, cmap
, color
);
1417 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1418 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1419 If this produces the same color as PIXEL, try a color where all RGB
1420 values have DELTA added. Return the allocated color in *PIXEL.
1421 DISPLAY is the X display, CMAP is the colormap to operate on.
1422 Value is non-zero if successful. */
1425 x_alloc_lighter_color_for_widget (widget
, display
, cmap
, pixel
, factor
, delta
)
1429 unsigned long *pixel
;
1433 struct frame
*f
= x_frame_of_widget (widget
);
1434 return x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
);
1438 /* Structure specifying which arguments should be passed by Xt to
1439 cvt_string_to_pixel. We want the widget's screen and colormap. */
1441 static XtConvertArgRec cvt_string_to_pixel_args
[] =
1443 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.screen
),
1445 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.colormap
),
1450 /* The address of this variable is returned by
1451 cvt_string_to_pixel. */
1453 static Pixel cvt_string_to_pixel_value
;
1456 /* Convert a color name to a pixel color.
1458 DPY is the display we are working on.
1460 ARGS is an array of *NARGS XrmValue structures holding additional
1461 information about the widget for which the conversion takes place.
1462 The contents of this array are determined by the specification
1463 in cvt_string_to_pixel_args.
1465 FROM is a pointer to an XrmValue which points to the color name to
1466 convert. TO is an XrmValue in which to return the pixel color.
1468 CLOSURE_RET is a pointer to user-data, in which we record if
1469 we allocated the color or not.
1471 Value is True if successful, False otherwise. */
1474 cvt_string_to_pixel (dpy
, args
, nargs
, from
, to
, closure_ret
)
1478 XrmValue
*from
, *to
;
1479 XtPointer
*closure_ret
;
1489 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1490 "wrongParameters", "cvt_string_to_pixel",
1492 "Screen and colormap args required", NULL
, NULL
);
1496 screen
= *(Screen
**) args
[0].addr
;
1497 cmap
= *(Colormap
*) args
[1].addr
;
1498 color_name
= (String
) from
->addr
;
1500 if (strcmp (color_name
, XtDefaultBackground
) == 0)
1502 *closure_ret
= (XtPointer
) False
;
1503 pixel
= WhitePixelOfScreen (screen
);
1505 else if (strcmp (color_name
, XtDefaultForeground
) == 0)
1507 *closure_ret
= (XtPointer
) False
;
1508 pixel
= BlackPixelOfScreen (screen
);
1510 else if (XParseColor (dpy
, cmap
, color_name
, &color
)
1511 && x_alloc_nearest_color_1 (dpy
, cmap
, &color
))
1513 pixel
= color
.pixel
;
1514 *closure_ret
= (XtPointer
) True
;
1519 Cardinal nparams
= 1;
1521 params
[0] = color_name
;
1522 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1523 "badValue", "cvt_string_to_pixel",
1524 "XtToolkitError", "Invalid color `%s'",
1529 if (to
->addr
!= NULL
)
1531 if (to
->size
< sizeof (Pixel
))
1533 to
->size
= sizeof (Pixel
);
1537 *(Pixel
*) to
->addr
= pixel
;
1541 cvt_string_to_pixel_value
= pixel
;
1542 to
->addr
= (XtPointer
) &cvt_string_to_pixel_value
;
1545 to
->size
= sizeof (Pixel
);
1550 /* Free a pixel color which was previously allocated via
1551 cvt_string_to_pixel. This is registered as the destructor
1552 for this type of resource via XtSetTypeConverter.
1554 APP is the application context in which we work.
1556 TO is a pointer to an XrmValue holding the color to free.
1557 CLOSURE is the value we stored in CLOSURE_RET for this color
1558 in cvt_string_to_pixel.
1560 ARGS and NARGS are like for cvt_string_to_pixel. */
1563 cvt_pixel_dtor (app
, to
, closure
, args
, nargs
)
1572 XtAppWarningMsg (app
, "wrongParameters", "cvt_pixel_dtor",
1574 "Screen and colormap arguments required",
1577 else if (closure
!= NULL
)
1579 /* We did allocate the pixel, so free it. */
1580 Screen
*screen
= *(Screen
**) args
[0].addr
;
1581 Colormap cmap
= *(Colormap
*) args
[1].addr
;
1582 x_free_dpy_colors (DisplayOfScreen (screen
), screen
, cmap
,
1583 (Pixel
*) to
->addr
, 1);
1588 #endif /* USE_X_TOOLKIT */
1591 /* Value is an array of XColor structures for the contents of the
1592 color map of display DPY. Set *NCELLS to the size of the array.
1593 Note that this probably shouldn't be called for large color maps,
1594 say a 24-bit TrueColor map. */
1596 static const XColor
*
1597 x_color_cells (Display
*dpy
, int *ncells
)
1599 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1601 if (dpyinfo
->color_cells
== NULL
)
1603 Screen
*screen
= dpyinfo
->screen
;
1606 dpyinfo
->ncolor_cells
1607 = XDisplayCells (dpy
, XScreenNumberOfScreen (screen
));
1608 dpyinfo
->color_cells
1609 = (XColor
*) xmalloc (dpyinfo
->ncolor_cells
1610 * sizeof *dpyinfo
->color_cells
);
1612 for (i
= 0; i
< dpyinfo
->ncolor_cells
; ++i
)
1613 dpyinfo
->color_cells
[i
].pixel
= i
;
1615 XQueryColors (dpy
, dpyinfo
->cmap
,
1616 dpyinfo
->color_cells
, dpyinfo
->ncolor_cells
);
1619 *ncells
= dpyinfo
->ncolor_cells
;
1620 return dpyinfo
->color_cells
;
1624 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1625 colors in COLORS. Use cached information, if available. */
1628 x_query_colors (struct frame
*f
, XColor
*colors
, int ncolors
)
1630 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1632 if (dpyinfo
->color_cells
)
1635 for (i
= 0; i
< ncolors
; ++i
)
1637 unsigned long pixel
= colors
[i
].pixel
;
1638 xassert (pixel
< dpyinfo
->ncolor_cells
);
1639 xassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
1640 colors
[i
] = dpyinfo
->color_cells
[pixel
];
1644 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
1648 /* On frame F, translate pixel color to RGB values for the color in
1649 COLOR. Use cached information, if available. */
1652 x_query_color (struct frame
*f
, XColor
*color
)
1654 x_query_colors (f
, color
, 1);
1658 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
1659 exact match can't be allocated, try the nearest color available.
1660 Value is non-zero if successful. Set *COLOR to the color
1664 x_alloc_nearest_color_1 (Display
*dpy
, Colormap cmap
, XColor
*color
)
1668 rc
= XAllocColor (dpy
, cmap
, color
);
1671 /* If we got to this point, the colormap is full, so we're going
1672 to try to get the next closest color. The algorithm used is
1673 a least-squares matching, which is what X uses for closest
1674 color matching with StaticColor visuals. */
1676 unsigned long nearest_delta
= ~0;
1678 const XColor
*cells
= x_color_cells (dpy
, &ncells
);
1680 for (nearest
= i
= 0; i
< ncells
; ++i
)
1682 long dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
1683 long dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
1684 long dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
1685 unsigned long delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
1687 if (delta
< nearest_delta
)
1690 nearest_delta
= delta
;
1694 color
->red
= cells
[nearest
].red
;
1695 color
->green
= cells
[nearest
].green
;
1696 color
->blue
= cells
[nearest
].blue
;
1697 rc
= XAllocColor (dpy
, cmap
, color
);
1701 /* If allocation succeeded, and the allocated pixel color is not
1702 equal to a cached pixel color recorded earlier, there was a
1703 change in the colormap, so clear the color cache. */
1704 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1705 XColor
*cached_color
;
1707 if (dpyinfo
->color_cells
1708 && (cached_color
= &dpyinfo
->color_cells
[color
->pixel
],
1709 (cached_color
->red
!= color
->red
1710 || cached_color
->blue
!= color
->blue
1711 || cached_color
->green
!= color
->green
)))
1713 xfree (dpyinfo
->color_cells
);
1714 dpyinfo
->color_cells
= NULL
;
1715 dpyinfo
->ncolor_cells
= 0;
1719 #ifdef DEBUG_X_COLORS
1721 register_color (color
->pixel
);
1722 #endif /* DEBUG_X_COLORS */
1728 /* Allocate the color COLOR->pixel on frame F, colormap CMAP. If an
1729 exact match can't be allocated, try the nearest color available.
1730 Value is non-zero if successful. Set *COLOR to the color
1734 x_alloc_nearest_color (struct frame
*f
, Colormap cmap
, XColor
*color
)
1736 gamma_correct (f
, color
);
1737 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f
), cmap
, color
);
1741 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
1742 It's necessary to do this instead of just using PIXEL directly to
1743 get color reference counts right. */
1746 x_copy_color (struct frame
*f
, long unsigned int pixel
)
1750 color
.pixel
= pixel
;
1752 x_query_color (f
, &color
);
1753 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
1755 #ifdef DEBUG_X_COLORS
1756 register_color (pixel
);
1762 /* Allocate color PIXEL on display DPY. PIXEL must already be allocated.
1763 It's necessary to do this instead of just using PIXEL directly to
1764 get color reference counts right. */
1767 x_copy_dpy_color (Display
*dpy
, Colormap cmap
, long unsigned int pixel
)
1771 color
.pixel
= pixel
;
1773 XQueryColor (dpy
, cmap
, &color
);
1774 XAllocColor (dpy
, cmap
, &color
);
1776 #ifdef DEBUG_X_COLORS
1777 register_color (pixel
);
1783 /* Brightness beyond which a color won't have its highlight brightness
1786 Nominally, highlight colors for `3d' faces are calculated by
1787 brightening an object's color by a constant scale factor, but this
1788 doesn't yield good results for dark colors, so for colors who's
1789 brightness is less than this value (on a scale of 0-65535) have an
1790 use an additional additive factor.
1792 The value here is set so that the default menu-bar/mode-line color
1793 (grey75) will not have its highlights changed at all. */
1794 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
1797 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1798 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1799 If this produces the same color as PIXEL, try a color where all RGB
1800 values have DELTA added. Return the allocated color in *PIXEL.
1801 DISPLAY is the X display, CMAP is the colormap to operate on.
1802 Value is non-zero if successful. */
1805 x_alloc_lighter_color (struct frame
*f
, Display
*display
, Colormap cmap
, long unsigned int *pixel
, double factor
, int delta
)
1811 /* Get RGB color values. */
1812 color
.pixel
= *pixel
;
1813 x_query_color (f
, &color
);
1815 /* Change RGB values by specified FACTOR. Avoid overflow! */
1816 xassert (factor
>= 0);
1817 new.red
= min (0xffff, factor
* color
.red
);
1818 new.green
= min (0xffff, factor
* color
.green
);
1819 new.blue
= min (0xffff, factor
* color
.blue
);
1821 /* Calculate brightness of COLOR. */
1822 bright
= (2 * color
.red
+ 3 * color
.green
+ color
.blue
) / 6;
1824 /* We only boost colors that are darker than
1825 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1826 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1827 /* Make an additive adjustment to NEW, because it's dark enough so
1828 that scaling by FACTOR alone isn't enough. */
1830 /* How far below the limit this color is (0 - 1, 1 being darker). */
1831 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1832 /* The additive adjustment. */
1833 int min_delta
= delta
* dimness
* factor
/ 2;
1837 new.red
= max (0, new.red
- min_delta
);
1838 new.green
= max (0, new.green
- min_delta
);
1839 new.blue
= max (0, new.blue
- min_delta
);
1843 new.red
= min (0xffff, min_delta
+ new.red
);
1844 new.green
= min (0xffff, min_delta
+ new.green
);
1845 new.blue
= min (0xffff, min_delta
+ new.blue
);
1849 /* Try to allocate the color. */
1850 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1853 if (new.pixel
== *pixel
)
1855 /* If we end up with the same color as before, try adding
1856 delta to the RGB values. */
1857 x_free_colors (f
, &new.pixel
, 1);
1859 new.red
= min (0xffff, delta
+ color
.red
);
1860 new.green
= min (0xffff, delta
+ color
.green
);
1861 new.blue
= min (0xffff, delta
+ color
.blue
);
1862 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1873 /* Set up the foreground color for drawing relief lines of glyph
1874 string S. RELIEF is a pointer to a struct relief containing the GC
1875 with which lines will be drawn. Use a color that is FACTOR or
1876 DELTA lighter or darker than the relief's background which is found
1877 in S->f->output_data.x->relief_background. If such a color cannot
1878 be allocated, use DEFAULT_PIXEL, instead. */
1881 x_setup_relief_color (struct frame
*f
, struct relief
*relief
, double factor
, int delta
, long unsigned int default_pixel
)
1884 struct x_output
*di
= f
->output_data
.x
;
1885 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
1886 unsigned long pixel
;
1887 unsigned long background
= di
->relief_background
;
1888 Colormap cmap
= FRAME_X_COLORMAP (f
);
1889 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1890 Display
*dpy
= FRAME_X_DISPLAY (f
);
1892 xgcv
.graphics_exposures
= False
;
1893 xgcv
.line_width
= 1;
1895 /* Free previously allocated color. The color cell will be reused
1896 when it has been freed as many times as it was allocated, so this
1897 doesn't affect faces using the same colors. */
1899 && relief
->allocated_p
)
1901 x_free_colors (f
, &relief
->pixel
, 1);
1902 relief
->allocated_p
= 0;
1905 /* Allocate new color. */
1906 xgcv
.foreground
= default_pixel
;
1908 if (dpyinfo
->n_planes
!= 1
1909 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
1911 relief
->allocated_p
= 1;
1912 xgcv
.foreground
= relief
->pixel
= pixel
;
1915 if (relief
->gc
== 0)
1917 xgcv
.stipple
= dpyinfo
->gray
;
1919 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
1922 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
1926 /* Set up colors for the relief lines around glyph string S. */
1929 x_setup_relief_colors (struct glyph_string
*s
)
1931 struct x_output
*di
= s
->f
->output_data
.x
;
1932 unsigned long color
;
1934 if (s
->face
->use_box_color_for_shadows_p
)
1935 color
= s
->face
->box_color
;
1936 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1938 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1939 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1944 /* Get the background color of the face. */
1945 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
1946 color
= xgcv
.background
;
1949 if (di
->white_relief
.gc
== 0
1950 || color
!= di
->relief_background
)
1952 di
->relief_background
= color
;
1953 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
1954 WHITE_PIX_DEFAULT (s
->f
));
1955 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
1956 BLACK_PIX_DEFAULT (s
->f
));
1961 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1962 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1963 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1964 relief. LEFT_P non-zero means draw a relief on the left side of
1965 the rectangle. RIGHT_P non-zero means draw a relief on the right
1966 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1970 x_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
1971 raised_p
, top_p
, bot_p
, left_p
, right_p
, clip_rect
)
1973 int left_x
, top_y
, right_x
, bottom_y
, width
;
1974 int top_p
, bot_p
, left_p
, right_p
, raised_p
;
1975 XRectangle
*clip_rect
;
1977 Display
*dpy
= FRAME_X_DISPLAY (f
);
1978 Window window
= FRAME_X_WINDOW (f
);
1983 gc
= f
->output_data
.x
->white_relief
.gc
;
1985 gc
= f
->output_data
.x
->black_relief
.gc
;
1986 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
1990 for (i
= 0; i
< width
; ++i
)
1991 XDrawLine (dpy
, window
, gc
,
1992 left_x
+ i
* left_p
, top_y
+ i
,
1993 right_x
+ 1 - i
* right_p
, top_y
+ i
);
1997 for (i
= 0; i
< width
; ++i
)
1998 XDrawLine (dpy
, window
, gc
,
1999 left_x
+ i
, top_y
+ i
, left_x
+ i
, bottom_y
- i
+ 1);
2001 XSetClipMask (dpy
, gc
, None
);
2003 gc
= f
->output_data
.x
->black_relief
.gc
;
2005 gc
= f
->output_data
.x
->white_relief
.gc
;
2006 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
2010 for (i
= 0; i
< width
; ++i
)
2011 XDrawLine (dpy
, window
, gc
,
2012 left_x
+ i
* left_p
, bottom_y
- i
,
2013 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
2017 for (i
= 0; i
< width
; ++i
)
2018 XDrawLine (dpy
, window
, gc
,
2019 right_x
- i
, top_y
+ i
+ 1, right_x
- i
, bottom_y
- i
);
2021 XSetClipMask (dpy
, gc
, None
);
2025 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
2026 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
2027 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
2028 left side of the rectangle. RIGHT_P non-zero means draw a line
2029 on the right side of the rectangle. CLIP_RECT is the clipping
2030 rectangle to use when drawing. */
2033 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2034 left_p
, right_p
, clip_rect
)
2035 struct glyph_string
*s
;
2036 int left_x
, top_y
, right_x
, bottom_y
, width
, left_p
, right_p
;
2037 XRectangle
*clip_rect
;
2041 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2042 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
2043 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, clip_rect
, 1, Unsorted
);
2046 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2047 left_x
, top_y
, right_x
- left_x
+ 1, width
);
2051 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2052 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
2055 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2056 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
2060 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2061 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
2063 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2064 XSetClipMask (s
->display
, s
->gc
, None
);
2068 /* Draw a box around glyph string S. */
2071 x_draw_glyph_string_box (struct glyph_string
*s
)
2073 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
2074 int left_p
, right_p
;
2075 struct glyph
*last_glyph
;
2076 XRectangle clip_rect
;
2078 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
2079 ? WINDOW_RIGHT_EDGE_X (s
->w
)
2080 : window_box_right (s
->w
, s
->area
));
2082 /* The glyph that may have a right box line. */
2083 last_glyph
= (s
->cmp
|| s
->img
2085 : s
->first_glyph
+ s
->nchars
- 1);
2087 width
= eabs (s
->face
->box_line_width
);
2088 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
2090 right_x
= (s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
2092 : min (last_x
, s
->x
+ s
->background_width
) - 1);
2094 bottom_y
= top_y
+ s
->height
- 1;
2096 left_p
= (s
->first_glyph
->left_box_line_p
2097 || (s
->hl
== DRAW_MOUSE_FACE
2099 || s
->prev
->hl
!= s
->hl
)));
2100 right_p
= (last_glyph
->right_box_line_p
2101 || (s
->hl
== DRAW_MOUSE_FACE
2103 || s
->next
->hl
!= s
->hl
)));
2105 get_glyph_string_clip_rect (s
, &clip_rect
);
2107 if (s
->face
->box
== FACE_SIMPLE_BOX
)
2108 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2109 left_p
, right_p
, &clip_rect
);
2112 x_setup_relief_colors (s
);
2113 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
2114 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
2119 /* Draw foreground of image glyph string S. */
2122 x_draw_image_foreground (struct glyph_string
*s
)
2125 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2127 /* If first glyph of S has a left box line, start drawing it to the
2128 right of that line. */
2129 if (s
->face
->box
!= FACE_NO_BOX
2130 && s
->first_glyph
->left_box_line_p
2132 x
+= eabs (s
->face
->box_line_width
);
2134 /* If there is a margin around the image, adjust x- and y-position
2136 if (s
->slice
.x
== 0)
2137 x
+= s
->img
->hmargin
;
2138 if (s
->slice
.y
== 0)
2139 y
+= s
->img
->vmargin
;
2145 /* We can't set both a clip mask and use XSetClipRectangles
2146 because the latter also sets a clip mask. We also can't
2147 trust on the shape extension to be available
2148 (XShapeCombineRegion). So, compute the rectangle to draw
2150 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2153 XRectangle clip_rect
, image_rect
, r
;
2155 xgcv
.clip_mask
= s
->img
->mask
;
2156 xgcv
.clip_x_origin
= x
;
2157 xgcv
.clip_y_origin
= y
;
2158 xgcv
.function
= GXcopy
;
2159 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2161 get_glyph_string_clip_rect (s
, &clip_rect
);
2164 image_rect
.width
= s
->slice
.width
;
2165 image_rect
.height
= s
->slice
.height
;
2166 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2167 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2168 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2169 r
.width
, r
.height
, r
.x
, r
.y
);
2173 XRectangle clip_rect
, image_rect
, r
;
2175 get_glyph_string_clip_rect (s
, &clip_rect
);
2178 image_rect
.width
= s
->slice
.width
;
2179 image_rect
.height
= s
->slice
.height
;
2180 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2181 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2182 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2183 r
.width
, r
.height
, r
.x
, r
.y
);
2185 /* When the image has a mask, we can expect that at
2186 least part of a mouse highlight or a block cursor will
2187 be visible. If the image doesn't have a mask, make
2188 a block cursor visible by drawing a rectangle around
2189 the image. I believe it's looking better if we do
2190 nothing here for mouse-face. */
2191 if (s
->hl
== DRAW_CURSOR
)
2193 int r
= s
->img
->relief
;
2195 XDrawRectangle (s
->display
, s
->window
, s
->gc
,
2197 s
->slice
.width
+ r
*2 - 1,
2198 s
->slice
.height
+ r
*2 - 1);
2203 /* Draw a rectangle if image could not be loaded. */
2204 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
2205 s
->slice
.width
- 1, s
->slice
.height
- 1);
2209 /* Draw a relief around the image glyph string S. */
2212 x_draw_image_relief (struct glyph_string
*s
)
2214 int x0
, y0
, x1
, y1
, thick
, raised_p
, extra
;
2217 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2219 /* If first glyph of S has a left box line, start drawing it to the
2220 right of that line. */
2221 if (s
->face
->box
!= FACE_NO_BOX
2222 && s
->first_glyph
->left_box_line_p
2224 x
+= eabs (s
->face
->box_line_width
);
2226 /* If there is a margin around the image, adjust x- and y-position
2228 if (s
->slice
.x
== 0)
2229 x
+= s
->img
->hmargin
;
2230 if (s
->slice
.y
== 0)
2231 y
+= s
->img
->vmargin
;
2233 if (s
->hl
== DRAW_IMAGE_SUNKEN
2234 || s
->hl
== DRAW_IMAGE_RAISED
)
2236 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
2237 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
2241 thick
= eabs (s
->img
->relief
);
2242 raised_p
= s
->img
->relief
> 0;
2245 extra
= s
->face
->id
== TOOL_BAR_FACE_ID
2246 ? XINT (Vtool_bar_button_margin
) : 0;
2248 x0
= x
- thick
- extra
;
2249 y0
= y
- thick
- extra
;
2250 x1
= x
+ s
->slice
.width
+ thick
- 1 + extra
;
2251 y1
= y
+ s
->slice
.height
+ thick
- 1 + extra
;
2253 x_setup_relief_colors (s
);
2254 get_glyph_string_clip_rect (s
, &r
);
2255 x_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
,
2257 s
->slice
.y
+ s
->slice
.height
== s
->img
->height
,
2259 s
->slice
.x
+ s
->slice
.width
== s
->img
->width
,
2264 /* Draw the foreground of image glyph string S to PIXMAP. */
2267 x_draw_image_foreground_1 (struct glyph_string
*s
, Pixmap pixmap
)
2270 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2272 /* If first glyph of S has a left box line, start drawing it to the
2273 right of that line. */
2274 if (s
->face
->box
!= FACE_NO_BOX
2275 && s
->first_glyph
->left_box_line_p
2277 x
+= eabs (s
->face
->box_line_width
);
2279 /* If there is a margin around the image, adjust x- and y-position
2281 if (s
->slice
.x
== 0)
2282 x
+= s
->img
->hmargin
;
2283 if (s
->slice
.y
== 0)
2284 y
+= s
->img
->vmargin
;
2290 /* We can't set both a clip mask and use XSetClipRectangles
2291 because the latter also sets a clip mask. We also can't
2292 trust on the shape extension to be available
2293 (XShapeCombineRegion). So, compute the rectangle to draw
2295 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2299 xgcv
.clip_mask
= s
->img
->mask
;
2300 xgcv
.clip_x_origin
= x
- s
->slice
.x
;
2301 xgcv
.clip_y_origin
= y
- s
->slice
.y
;
2302 xgcv
.function
= GXcopy
;
2303 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2305 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2306 s
->slice
.x
, s
->slice
.y
,
2307 s
->slice
.width
, s
->slice
.height
, x
, y
);
2308 XSetClipMask (s
->display
, s
->gc
, None
);
2312 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2313 s
->slice
.x
, s
->slice
.y
,
2314 s
->slice
.width
, s
->slice
.height
, x
, y
);
2316 /* When the image has a mask, we can expect that at
2317 least part of a mouse highlight or a block cursor will
2318 be visible. If the image doesn't have a mask, make
2319 a block cursor visible by drawing a rectangle around
2320 the image. I believe it's looking better if we do
2321 nothing here for mouse-face. */
2322 if (s
->hl
== DRAW_CURSOR
)
2324 int r
= s
->img
->relief
;
2326 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
- r
, y
- r
,
2327 s
->slice
.width
+ r
*2 - 1,
2328 s
->slice
.height
+ r
*2 - 1);
2333 /* Draw a rectangle if image could not be loaded. */
2334 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
2335 s
->slice
.width
- 1, s
->slice
.height
- 1);
2339 /* Draw part of the background of glyph string S. X, Y, W, and H
2340 give the rectangle to draw. */
2343 x_draw_glyph_string_bg_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
2347 /* Fill background with a stipple pattern. */
2348 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2349 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2350 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2353 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2357 /* Draw image glyph string S.
2360 s->x +-------------------------
2363 | +-------------------------
2366 | | +-------------------
2372 x_draw_image_glyph_string (struct glyph_string
*s
)
2374 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
2375 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2377 Pixmap pixmap
= None
;
2380 if (s
->slice
.y
== 0)
2381 height
-= box_line_vwidth
;
2382 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
2383 height
-= box_line_vwidth
;
2385 /* Fill background with face under the image. Do it only if row is
2386 taller than image or if image has a clip mask to reduce
2388 s
->stippled_p
= s
->face
->stipple
!= 0;
2389 if (height
> s
->slice
.height
2393 || s
->img
->pixmap
== 0
2394 || s
->width
!= s
->background_width
)
2398 /* Create a pixmap as large as the glyph string. Fill it
2399 with the background color. Copy the image to it, using
2400 its mask. Copy the temporary pixmap to the display. */
2401 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2402 int depth
= DefaultDepthOfScreen (screen
);
2404 /* Create a pixmap as large as the glyph string. */
2405 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2406 s
->background_width
,
2409 /* Don't clip in the following because we're working on the
2411 XSetClipMask (s
->display
, s
->gc
, None
);
2413 /* Fill the pixmap with the background color/stipple. */
2416 /* Fill background with a stipple pattern. */
2417 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2418 XSetTSOrigin (s
->display
, s
->gc
, - s
->x
, - s
->y
);
2419 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2420 0, 0, s
->background_width
, s
->height
);
2421 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2422 XSetTSOrigin (s
->display
, s
->gc
, 0, 0);
2427 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2429 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2430 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2431 0, 0, s
->background_width
, s
->height
);
2432 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2440 if (s
->first_glyph
->left_box_line_p
2442 x
+= box_line_hwidth
;
2444 if (s
->slice
.y
== 0)
2445 y
+= box_line_vwidth
;
2447 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
2450 s
->background_filled_p
= 1;
2453 /* Draw the foreground. */
2456 x_draw_image_foreground_1 (s
, pixmap
);
2457 x_set_glyph_string_clipping (s
);
2458 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
2459 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
2460 XFreePixmap (s
->display
, pixmap
);
2463 x_draw_image_foreground (s
);
2465 /* If we must draw a relief around the image, do it. */
2467 || s
->hl
== DRAW_IMAGE_RAISED
2468 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2469 x_draw_image_relief (s
);
2473 /* Draw stretch glyph string S. */
2476 x_draw_stretch_glyph_string (struct glyph_string
*s
)
2478 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2480 if (s
->hl
== DRAW_CURSOR
2481 && !x_stretch_cursor_p
)
2483 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
2484 as wide as the stretch glyph. */
2485 int width
, background_width
= s
->background_width
;
2486 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2490 background_width
-= left_x
- x
;
2493 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
2496 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
2498 /* Clear rest using the GC of the original non-cursor face. */
2499 if (width
< background_width
)
2502 int w
= background_width
- width
, h
= s
->height
;
2507 if (s
->row
->mouse_face_p
2508 && cursor_in_mouse_face_p (s
->w
))
2510 x_set_mouse_face_gc (s
);
2516 get_glyph_string_clip_rect (s
, &r
);
2517 XSetClipRectangles (s
->display
, gc
, 0, 0, &r
, 1, Unsorted
);
2519 if (s
->face
->stipple
)
2521 /* Fill background with a stipple pattern. */
2522 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2523 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2524 XSetFillStyle (s
->display
, gc
, FillSolid
);
2529 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
2530 XSetForeground (s
->display
, gc
, xgcv
.background
);
2531 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2532 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
2536 else if (!s
->background_filled_p
)
2538 int background_width
= s
->background_width
;
2539 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2541 /* Don't draw into left margin, fringe or scrollbar area
2542 except for header line and mode line. */
2543 if (x
< left_x
&& !s
->row
->mode_line_p
)
2545 background_width
-= left_x
- x
;
2548 if (background_width
> 0)
2549 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2552 s
->background_filled_p
= 1;
2556 /* Draw glyph string S. */
2559 x_draw_glyph_string (struct glyph_string
*s
)
2561 int relief_drawn_p
= 0;
2563 /* If S draws into the background of its successors, draw the
2564 background of the successors first so that S can draw into it.
2565 This makes S->next use XDrawString instead of XDrawImageString. */
2566 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2569 struct glyph_string
*next
;
2571 for (width
= 0, next
= s
->next
;
2572 next
&& width
< s
->right_overhang
;
2573 width
+= next
->width
, next
= next
->next
)
2574 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
2576 x_set_glyph_string_gc (next
);
2577 x_set_glyph_string_clipping (next
);
2578 if (next
->first_glyph
->type
== STRETCH_GLYPH
)
2579 x_draw_stretch_glyph_string (next
);
2581 x_draw_glyph_string_background (next
, 1);
2582 next
->num_clips
= 0;
2586 /* Set up S->gc, set clipping and draw S. */
2587 x_set_glyph_string_gc (s
);
2589 /* Draw relief (if any) in advance for char/composition so that the
2590 glyph string can be drawn over it. */
2591 if (!s
->for_overlaps
2592 && s
->face
->box
!= FACE_NO_BOX
2593 && (s
->first_glyph
->type
== CHAR_GLYPH
2594 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2597 x_set_glyph_string_clipping (s
);
2598 x_draw_glyph_string_background (s
, 1);
2599 x_draw_glyph_string_box (s
);
2600 x_set_glyph_string_clipping (s
);
2603 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
2605 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2606 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
2607 /* We must clip just this glyph. left_overhang part has already
2608 drawn when s->prev was drawn, and right_overhang part will be
2609 drawn later when s->next is drawn. */
2610 x_set_glyph_string_clipping_exactly (s
, s
);
2612 x_set_glyph_string_clipping (s
);
2614 switch (s
->first_glyph
->type
)
2617 x_draw_image_glyph_string (s
);
2621 x_draw_stretch_glyph_string (s
);
2625 if (s
->for_overlaps
)
2626 s
->background_filled_p
= 1;
2628 x_draw_glyph_string_background (s
, 0);
2629 x_draw_glyph_string_foreground (s
);
2632 case COMPOSITE_GLYPH
:
2633 if (s
->for_overlaps
|| (s
->cmp_from
> 0
2634 && ! s
->first_glyph
->u
.cmp
.automatic
))
2635 s
->background_filled_p
= 1;
2637 x_draw_glyph_string_background (s
, 1);
2638 x_draw_composite_glyph_string_foreground (s
);
2645 if (!s
->for_overlaps
)
2647 /* Draw underline. */
2648 if (s
->face
->underline_p
)
2650 unsigned long thickness
, position
;
2653 if (s
->prev
&& s
->prev
->face
->underline_p
)
2655 /* We use the same underline style as the previous one. */
2656 thickness
= s
->prev
->underline_thickness
;
2657 position
= s
->prev
->underline_position
;
2661 /* Get the underline thickness. Default is 1 pixel. */
2662 if (s
->font
&& s
->font
->underline_thickness
> 0)
2663 thickness
= s
->font
->underline_thickness
;
2666 if (x_underline_at_descent_line
)
2667 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
2670 /* Get the underline position. This is the recommended
2671 vertical offset in pixels from the baseline to the top of
2672 the underline. This is a signed value according to the
2673 specs, and its default is
2675 ROUND ((maximum descent) / 2), with
2676 ROUND(x) = floor (x + 0.5) */
2678 if (x_use_underline_position_properties
2679 && s
->font
&& s
->font
->underline_position
>= 0)
2680 position
= s
->font
->underline_position
;
2682 position
= (s
->font
->descent
+ 1) / 2;
2684 position
= underline_minimum_offset
;
2686 position
= max (position
, underline_minimum_offset
);
2688 /* Check the sanity of thickness and position. We should
2689 avoid drawing underline out of the current line area. */
2690 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
2691 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
2692 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
2693 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
2694 s
->underline_thickness
= thickness
;
2695 s
->underline_position
= position
;
2696 y
= s
->ybase
+ position
;
2697 if (s
->face
->underline_defaulted_p
)
2698 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2699 s
->x
, y
, s
->width
, thickness
);
2703 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2704 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
2705 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2706 s
->x
, y
, s
->width
, thickness
);
2707 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2711 /* Draw overline. */
2712 if (s
->face
->overline_p
)
2714 unsigned long dy
= 0, h
= 1;
2716 if (s
->face
->overline_color_defaulted_p
)
2717 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2722 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2723 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
2724 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2726 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2730 /* Draw strike-through. */
2731 if (s
->face
->strike_through_p
)
2733 unsigned long h
= 1;
2734 unsigned long dy
= (s
->height
- h
) / 2;
2736 if (s
->face
->strike_through_color_defaulted_p
)
2737 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2742 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2743 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
2744 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2746 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2750 /* Draw relief if not yet drawn. */
2751 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2752 x_draw_glyph_string_box (s
);
2756 struct glyph_string
*prev
;
2758 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2759 if (prev
->hl
!= s
->hl
2760 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2762 /* As prev was drawn while clipped to its own area, we
2763 must draw the right_overhang part using s->hl now. */
2764 enum draw_glyphs_face save
= prev
->hl
;
2767 x_set_glyph_string_gc (prev
);
2768 x_set_glyph_string_clipping_exactly (s
, prev
);
2769 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2770 x_draw_glyph_string_foreground (prev
);
2772 x_draw_composite_glyph_string_foreground (prev
);
2773 XSetClipMask (prev
->display
, prev
->gc
, None
);
2775 prev
->num_clips
= 0;
2781 struct glyph_string
*next
;
2783 for (next
= s
->next
; next
; next
= next
->next
)
2784 if (next
->hl
!= s
->hl
2785 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
2787 /* As next will be drawn while clipped to its own area,
2788 we must draw the left_overhang part using s->hl now. */
2789 enum draw_glyphs_face save
= next
->hl
;
2792 x_set_glyph_string_gc (next
);
2793 x_set_glyph_string_clipping_exactly (s
, next
);
2794 if (next
->first_glyph
->type
== CHAR_GLYPH
)
2795 x_draw_glyph_string_foreground (next
);
2797 x_draw_composite_glyph_string_foreground (next
);
2798 XSetClipMask (next
->display
, next
->gc
, None
);
2800 next
->num_clips
= 0;
2805 /* Reset clipping. */
2806 XSetClipMask (s
->display
, s
->gc
, None
);
2810 /* Shift display to make room for inserted glyphs. */
2813 x_shift_glyphs_for_insert (struct frame
*f
, int x
, int y
, int width
, int height
, int shift_by
)
2815 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
2816 f
->output_data
.x
->normal_gc
,
2817 x
, y
, width
, height
,
2821 /* Delete N glyphs at the nominal cursor position. Not implemented
2825 x_delete_glyphs (struct frame
*f
, register int n
)
2831 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
2832 If they are <= 0, this is probably an error. */
2835 x_clear_area (Display
*dpy
, Window window
, int x
, int y
, int width
, int height
, int exposures
)
2837 xassert (width
> 0 && height
> 0);
2838 XClearArea (dpy
, window
, x
, y
, width
, height
, exposures
);
2842 /* Clear an entire frame. */
2845 x_clear_frame (struct frame
*f
)
2847 /* Clearing the frame will erase any cursor, so mark them all as no
2849 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2850 output_cursor
.hpos
= output_cursor
.vpos
= 0;
2851 output_cursor
.x
= -1;
2853 /* We don't set the output cursor here because there will always
2854 follow an explicit cursor_to. */
2856 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
2858 /* We have to clear the scroll bars, too. If we have changed
2859 colors or something like that, then they should be notified. */
2860 x_scroll_bar_clear (f
);
2862 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
2863 /* Make sure scroll bars are redrawn. As they aren't redrawn by
2864 redisplay, do it here. */
2865 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
2868 XFlush (FRAME_X_DISPLAY (f
));
2875 /* Invert the middle quarter of the frame for .15 sec. */
2877 /* We use the select system call to do the waiting, so we have to make
2878 sure it's available. If it isn't, we just won't do visual bells. */
2880 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
2883 /* Subtract the `struct timeval' values X and Y, storing the result in
2884 *RESULT. Return 1 if the difference is negative, otherwise 0. */
2887 timeval_subtract (struct timeval
*result
, struct timeval x
, struct timeval y
)
2889 /* Perform the carry for the later subtraction by updating y. This
2890 is safer because on some systems the tv_sec member is unsigned. */
2891 if (x
.tv_usec
< y
.tv_usec
)
2893 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
2894 y
.tv_usec
-= 1000000 * nsec
;
2898 if (x
.tv_usec
- y
.tv_usec
> 1000000)
2900 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
2901 y
.tv_usec
+= 1000000 * nsec
;
2905 /* Compute the time remaining to wait. tv_usec is certainly
2907 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
2908 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
2910 /* Return indication of whether the result should be considered
2912 return x
.tv_sec
< y
.tv_sec
;
2916 XTflash (struct frame
*f
)
2922 /* Use Gdk routines to draw. This way, we won't draw over scroll bars
2923 when the scroll bars and the edit widget share the same X window. */
2924 GdkWindow
*window
= gtk_widget_get_window (FRAME_GTK_WIDGET (f
));
2927 vals
.foreground
.pixel
= (FRAME_FOREGROUND_PIXEL (f
)
2928 ^ FRAME_BACKGROUND_PIXEL (f
));
2929 vals
.function
= GDK_XOR
;
2930 gc
= gdk_gc_new_with_values (window
,
2931 &vals
, GDK_GC_FUNCTION
| GDK_GC_FOREGROUND
);
2932 #define XFillRectangle(d, win, gc, x, y, w, h) \
2933 gdk_draw_rectangle (window, gc, TRUE, x, y, w, h)
2937 /* Create a GC that will use the GXxor function to flip foreground
2938 pixels into background pixels. */
2942 values
.function
= GXxor
;
2943 values
.foreground
= (FRAME_FOREGROUND_PIXEL (f
)
2944 ^ FRAME_BACKGROUND_PIXEL (f
));
2946 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2947 GCFunction
| GCForeground
, &values
);
2951 /* Get the height not including a menu bar widget. */
2952 int height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, FRAME_LINES (f
));
2953 /* Height of each line to flash. */
2954 int flash_height
= FRAME_LINE_HEIGHT (f
);
2955 /* These will be the left and right margins of the rectangles. */
2956 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
2957 int flash_right
= FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
2961 /* Don't flash the area between a scroll bar and the frame
2962 edge it is next to. */
2963 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f
))
2965 case vertical_scroll_bar_left
:
2966 flash_left
+= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
2969 case vertical_scroll_bar_right
:
2970 flash_right
-= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
2977 width
= flash_right
- flash_left
;
2979 /* If window is tall, flash top and bottom line. */
2980 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
2982 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2984 (FRAME_INTERNAL_BORDER_WIDTH (f
)
2985 + FRAME_TOP_MARGIN_HEIGHT (f
)),
2986 width
, flash_height
);
2987 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2989 (height
- flash_height
2990 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
2991 width
, flash_height
);
2995 /* If it is short, flash it all. */
2996 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2997 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
2998 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3003 struct timeval wakeup
;
3005 EMACS_GET_TIME (wakeup
);
3007 /* Compute time to wait until, propagating carry from usecs. */
3008 wakeup
.tv_usec
+= 150000;
3009 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
3010 wakeup
.tv_usec
%= 1000000;
3012 /* Keep waiting until past the time wakeup or any input gets
3014 while (! detect_input_pending ())
3016 struct timeval current
;
3017 struct timeval timeout
;
3019 EMACS_GET_TIME (current
);
3021 /* Break if result would be negative. */
3022 if (timeval_subtract (¤t
, wakeup
, current
))
3025 /* How long `select' should wait. */
3027 timeout
.tv_usec
= 10000;
3029 /* Try to wait that long--but we might wake up sooner. */
3030 select (0, NULL
, NULL
, NULL
, &timeout
);
3034 /* If window is tall, flash top and bottom line. */
3035 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3037 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3039 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3040 + FRAME_TOP_MARGIN_HEIGHT (f
)),
3041 width
, flash_height
);
3042 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3044 (height
- flash_height
3045 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3046 width
, flash_height
);
3049 /* If it is short, flash it all. */
3050 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3051 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3052 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3055 g_object_unref (G_OBJECT (gc
));
3056 #undef XFillRectangle
3058 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
3067 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
3071 XTtoggle_invisible_pointer (FRAME_PTR f
, int invisible
)
3076 if (FRAME_X_DISPLAY_INFO (f
)->invisible_cursor
!= 0)
3077 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3078 FRAME_X_DISPLAY_INFO (f
)->invisible_cursor
);
3081 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3082 f
->output_data
.x
->current_cursor
);
3083 f
->pointer_invisible
= invisible
;
3088 /* Make audible bell. */
3091 XTring_bell (struct frame
*f
)
3093 if (FRAME_X_DISPLAY (f
))
3095 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
3102 XBell (FRAME_X_DISPLAY (f
), 0);
3103 XFlush (FRAME_X_DISPLAY (f
));
3110 /* Specify how many text lines, from the top of the window,
3111 should be affected by insert-lines and delete-lines operations.
3112 This, and those operations, are used only within an update
3113 that is bounded by calls to x_update_begin and x_update_end. */
3116 XTset_terminal_window (struct frame
*f
, int n
)
3118 /* This function intentionally left blank. */
3123 /***********************************************************************
3125 ***********************************************************************/
3127 /* Perform an insert-lines or delete-lines operation, inserting N
3128 lines or deleting -N lines at vertical position VPOS. */
3131 x_ins_del_lines (struct frame
*f
, int vpos
, int n
)
3137 /* Scroll part of the display as described by RUN. */
3140 x_scroll_run (struct window
*w
, struct run
*run
)
3142 struct frame
*f
= XFRAME (w
->frame
);
3143 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
3145 /* Get frame-relative bounding box of the text display area of W,
3146 without mode lines. Include in this box the left and right
3148 window_box (w
, -1, &x
, &y
, &width
, &height
);
3150 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
3151 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
3152 bottom_y
= y
+ height
;
3156 /* Scrolling up. Make sure we don't copy part of the mode
3157 line at the bottom. */
3158 if (from_y
+ run
->height
> bottom_y
)
3159 height
= bottom_y
- from_y
;
3161 height
= run
->height
;
3165 /* Scolling down. Make sure we don't copy over the mode line.
3167 if (to_y
+ run
->height
> bottom_y
)
3168 height
= bottom_y
- to_y
;
3170 height
= run
->height
;
3175 /* Cursor off. Will be switched on again in x_update_window_end. */
3179 XCopyArea (FRAME_X_DISPLAY (f
),
3180 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
3181 f
->output_data
.x
->normal_gc
,
3191 /***********************************************************************
3193 ***********************************************************************/
3197 frame_highlight (struct frame
*f
)
3199 /* We used to only do this if Vx_no_window_manager was non-nil, but
3200 the ICCCM (section 4.1.6) says that the window's border pixmap
3201 and border pixel are window attributes which are "private to the
3202 client", so we can always change it to whatever we want. */
3204 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3205 f
->output_data
.x
->border_pixel
);
3207 x_update_cursor (f
, 1);
3208 x_set_frame_alpha (f
);
3212 frame_unhighlight (struct frame
*f
)
3214 /* We used to only do this if Vx_no_window_manager was non-nil, but
3215 the ICCCM (section 4.1.6) says that the window's border pixmap
3216 and border pixel are window attributes which are "private to the
3217 client", so we can always change it to whatever we want. */
3219 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3220 f
->output_data
.x
->border_tile
);
3222 x_update_cursor (f
, 1);
3223 x_set_frame_alpha (f
);
3226 /* The focus has changed. Update the frames as necessary to reflect
3227 the new situation. Note that we can't change the selected frame
3228 here, because the Lisp code we are interrupting might become confused.
3229 Each event gets marked with the frame in which it occurred, so the
3230 Lisp code can tell when the switch took place by examining the events. */
3233 x_new_focus_frame (struct x_display_info
*dpyinfo
, struct frame
*frame
)
3235 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
3237 if (frame
!= dpyinfo
->x_focus_frame
)
3239 /* Set this before calling other routines, so that they see
3240 the correct value of x_focus_frame. */
3241 dpyinfo
->x_focus_frame
= frame
;
3243 if (old_focus
&& old_focus
->auto_lower
)
3244 x_lower_frame (old_focus
);
3246 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
3247 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
3249 pending_autoraise_frame
= 0;
3252 x_frame_rehighlight (dpyinfo
);
3255 /* Handle FocusIn and FocusOut state changes for FRAME.
3256 If FRAME has focus and there exists more than one frame, puts
3257 a FOCUS_IN_EVENT into *BUFP. */
3260 x_focus_changed (int type
, int state
, struct x_display_info
*dpyinfo
, struct frame
*frame
, struct input_event
*bufp
)
3262 if (type
== FocusIn
)
3264 if (dpyinfo
->x_focus_event_frame
!= frame
)
3266 x_new_focus_frame (dpyinfo
, frame
);
3267 dpyinfo
->x_focus_event_frame
= frame
;
3269 /* Don't stop displaying the initial startup message
3270 for a switch-frame event we don't need. */
3271 if (NILP (Vterminal_frame
)
3272 && CONSP (Vframe_list
)
3273 && !NILP (XCDR (Vframe_list
)))
3275 bufp
->kind
= FOCUS_IN_EVENT
;
3276 XSETFRAME (bufp
->frame_or_window
, frame
);
3280 frame
->output_data
.x
->focus_state
|= state
;
3283 if (FRAME_XIC (frame
))
3284 XSetICFocus (FRAME_XIC (frame
));
3287 else if (type
== FocusOut
)
3289 frame
->output_data
.x
->focus_state
&= ~state
;
3291 if (dpyinfo
->x_focus_event_frame
== frame
)
3293 dpyinfo
->x_focus_event_frame
= 0;
3294 x_new_focus_frame (dpyinfo
, 0);
3298 if (FRAME_XIC (frame
))
3299 XUnsetICFocus (FRAME_XIC (frame
));
3301 if (frame
->pointer_invisible
)
3302 XTtoggle_invisible_pointer (frame
, 0);
3306 /* The focus may have changed. Figure out if it is a real focus change,
3307 by checking both FocusIn/Out and Enter/LeaveNotify events.
3309 Returns FOCUS_IN_EVENT event in *BUFP. */
3312 x_detect_focus_change (struct x_display_info
*dpyinfo
, XEvent
*event
, struct input_event
*bufp
)
3314 struct frame
*frame
;
3316 frame
= x_any_window_to_frame (dpyinfo
, event
->xany
.window
);
3320 switch (event
->type
)
3325 struct frame
*focus_frame
= dpyinfo
->x_focus_event_frame
;
3327 = focus_frame
? focus_frame
->output_data
.x
->focus_state
: 0;
3329 if (event
->xcrossing
.detail
!= NotifyInferior
3330 && event
->xcrossing
.focus
3331 && ! (focus_state
& FOCUS_EXPLICIT
))
3332 x_focus_changed ((event
->type
== EnterNotify
? FocusIn
: FocusOut
),
3334 dpyinfo
, frame
, bufp
);
3340 x_focus_changed (event
->type
,
3341 (event
->xfocus
.detail
== NotifyPointer
?
3342 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
3343 dpyinfo
, frame
, bufp
);
3347 if (event
->xclient
.message_type
== dpyinfo
->Xatom_XEMBED
)
3349 enum xembed_message msg
= event
->xclient
.data
.l
[1];
3350 x_focus_changed ((msg
== XEMBED_FOCUS_IN
? FocusIn
: FocusOut
),
3351 FOCUS_EXPLICIT
, dpyinfo
, frame
, bufp
);
3358 /* Handle an event saying the mouse has moved out of an Emacs frame. */
3361 x_mouse_leave (struct x_display_info
*dpyinfo
)
3363 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
3366 /* The focus has changed, or we have redirected a frame's focus to
3367 another frame (this happens when a frame uses a surrogate
3368 mini-buffer frame). Shift the highlight as appropriate.
3370 The FRAME argument doesn't necessarily have anything to do with which
3371 frame is being highlighted or un-highlighted; we only use it to find
3372 the appropriate X display info. */
3375 XTframe_rehighlight (struct frame
*frame
)
3377 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
3381 x_frame_rehighlight (struct x_display_info
*dpyinfo
)
3383 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
3385 if (dpyinfo
->x_focus_frame
)
3387 dpyinfo
->x_highlight_frame
3388 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
3389 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
3390 : dpyinfo
->x_focus_frame
);
3391 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
3393 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
3394 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
3398 dpyinfo
->x_highlight_frame
= 0;
3400 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
3403 frame_unhighlight (old_highlight
);
3404 if (dpyinfo
->x_highlight_frame
)
3405 frame_highlight (dpyinfo
->x_highlight_frame
);
3411 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
3413 /* Initialize mode_switch_bit and modifier_meaning. */
3415 x_find_modifier_meanings (struct x_display_info
*dpyinfo
)
3417 int min_code
, max_code
;
3420 XModifierKeymap
*mods
;
3422 dpyinfo
->meta_mod_mask
= 0;
3423 dpyinfo
->shift_lock_mask
= 0;
3424 dpyinfo
->alt_mod_mask
= 0;
3425 dpyinfo
->super_mod_mask
= 0;
3426 dpyinfo
->hyper_mod_mask
= 0;
3428 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
3430 syms
= XGetKeyboardMapping (dpyinfo
->display
,
3431 min_code
, max_code
- min_code
+ 1,
3433 mods
= XGetModifierMapping (dpyinfo
->display
);
3435 /* Scan the modifier table to see which modifier bits the Meta and
3436 Alt keysyms are on. */
3438 int row
, col
; /* The row and column in the modifier table. */
3439 int found_alt_or_meta
;
3441 for (row
= 3; row
< 8; row
++)
3443 found_alt_or_meta
= 0;
3444 for (col
= 0; col
< mods
->max_keypermod
; col
++)
3446 KeyCode code
= mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
3448 /* Zeroes are used for filler. Skip them. */
3452 /* Are any of this keycode's keysyms a meta key? */
3456 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
3458 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
3464 found_alt_or_meta
= 1;
3465 dpyinfo
->meta_mod_mask
|= (1 << row
);
3470 found_alt_or_meta
= 1;
3471 dpyinfo
->alt_mod_mask
|= (1 << row
);
3476 if (!found_alt_or_meta
)
3477 dpyinfo
->hyper_mod_mask
|= (1 << row
);
3478 code_col
= syms_per_code
;
3479 col
= mods
->max_keypermod
;
3484 if (!found_alt_or_meta
)
3485 dpyinfo
->super_mod_mask
|= (1 << row
);
3486 code_col
= syms_per_code
;
3487 col
= mods
->max_keypermod
;
3491 /* Ignore this if it's not on the lock modifier. */
3492 if (!found_alt_or_meta
&& ((1 << row
) == LockMask
))
3493 dpyinfo
->shift_lock_mask
= LockMask
;
3494 code_col
= syms_per_code
;
3495 col
= mods
->max_keypermod
;
3504 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
3505 if (! dpyinfo
->meta_mod_mask
)
3507 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
3508 dpyinfo
->alt_mod_mask
= 0;
3511 /* If some keys are both alt and meta,
3512 make them just meta, not alt. */
3513 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
3515 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
3518 XFree ((char *) syms
);
3519 XFreeModifiermap (mods
);
3522 /* Convert between the modifier bits X uses and the modifier bits
3526 x_x_to_emacs_modifiers (struct x_display_info
*dpyinfo
, unsigned int state
)
3528 EMACS_UINT mod_meta
= meta_modifier
;
3529 EMACS_UINT mod_alt
= alt_modifier
;
3530 EMACS_UINT mod_hyper
= hyper_modifier
;
3531 EMACS_UINT mod_super
= super_modifier
;
3534 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3535 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
3536 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3537 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
3538 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3539 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
3540 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3541 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
3544 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
3545 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
3546 | ((state
& dpyinfo
->meta_mod_mask
) ? mod_meta
: 0)
3547 | ((state
& dpyinfo
->alt_mod_mask
) ? mod_alt
: 0)
3548 | ((state
& dpyinfo
->super_mod_mask
) ? mod_super
: 0)
3549 | ((state
& dpyinfo
->hyper_mod_mask
) ? mod_hyper
: 0));
3553 x_emacs_to_x_modifiers (struct x_display_info
*dpyinfo
, unsigned int state
)
3555 EMACS_UINT mod_meta
= meta_modifier
;
3556 EMACS_UINT mod_alt
= alt_modifier
;
3557 EMACS_UINT mod_hyper
= hyper_modifier
;
3558 EMACS_UINT mod_super
= super_modifier
;
3562 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3563 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
3564 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3565 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
3566 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3567 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
3568 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3569 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
3572 return ( ((state
& mod_alt
) ? dpyinfo
->alt_mod_mask
: 0)
3573 | ((state
& mod_super
) ? dpyinfo
->super_mod_mask
: 0)
3574 | ((state
& mod_hyper
) ? dpyinfo
->hyper_mod_mask
: 0)
3575 | ((state
& shift_modifier
) ? ShiftMask
: 0)
3576 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
3577 | ((state
& mod_meta
) ? dpyinfo
->meta_mod_mask
: 0));
3580 /* Convert a keysym to its name. */
3583 x_get_keysym_name (int keysym
)
3588 value
= XKeysymToString (keysym
);
3596 /* Mouse clicks and mouse movement. Rah. */
3598 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3600 If the event is a button press, then note that we have grabbed
3604 construct_mouse_click (struct input_event
*result
, XButtonEvent
*event
, struct frame
*f
)
3606 /* Make the event type NO_EVENT; we'll change that when we decide
3608 result
->kind
= MOUSE_CLICK_EVENT
;
3609 result
->code
= event
->button
- Button1
;
3610 result
->timestamp
= event
->time
;
3611 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
3613 | (event
->type
== ButtonRelease
3617 XSETINT (result
->x
, event
->x
);
3618 XSETINT (result
->y
, event
->y
);
3619 XSETFRAME (result
->frame_or_window
, f
);
3625 /* Function to report a mouse movement to the mainstream Emacs code.
3626 The input handler calls this.
3628 We have received a mouse movement event, which is given in *event.
3629 If the mouse is over a different glyph than it was last time, tell
3630 the mainstream emacs code by setting mouse_moved. If not, ask for
3631 another motion event, so we can check again the next time it moves. */
3633 static XMotionEvent last_mouse_motion_event
;
3634 static Lisp_Object last_mouse_motion_frame
;
3637 note_mouse_movement (FRAME_PTR frame
, XMotionEvent
*event
)
3639 last_mouse_movement_time
= event
->time
;
3640 last_mouse_motion_event
= *event
;
3641 XSETFRAME (last_mouse_motion_frame
, frame
);
3643 if (!FRAME_X_OUTPUT (frame
))
3646 if (event
->window
!= FRAME_X_WINDOW (frame
))
3648 frame
->mouse_moved
= 1;
3649 last_mouse_scroll_bar
= Qnil
;
3650 note_mouse_highlight (frame
, -1, -1);
3651 last_mouse_glyph_frame
= 0;
3656 /* Has the mouse moved off the glyph it was on at the last sighting? */
3657 if (frame
!= last_mouse_glyph_frame
3658 || event
->x
< last_mouse_glyph
.x
3659 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
3660 || event
->y
< last_mouse_glyph
.y
3661 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
3663 frame
->mouse_moved
= 1;
3664 last_mouse_scroll_bar
= Qnil
;
3665 note_mouse_highlight (frame
, event
->x
, event
->y
);
3666 /* Remember which glyph we're now on. */
3667 remember_mouse_glyph (frame
, event
->x
, event
->y
, &last_mouse_glyph
);
3668 last_mouse_glyph_frame
= frame
;
3676 /************************************************************************
3678 ************************************************************************/
3681 redo_mouse_highlight (void)
3683 if (!NILP (last_mouse_motion_frame
)
3684 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
3685 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
3686 last_mouse_motion_event
.x
,
3687 last_mouse_motion_event
.y
);
3692 /* Return the current position of the mouse.
3693 *FP should be a frame which indicates which display to ask about.
3695 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
3696 and *PART to the frame, window, and scroll bar part that the mouse
3697 is over. Set *X and *Y to the portion and whole of the mouse's
3698 position on the scroll bar.
3700 If the mouse movement started elsewhere, set *FP to the frame the
3701 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
3704 Set *TIME to the server time-stamp for the time at which the mouse
3705 was at this position.
3707 Don't store anything if we don't have a valid set of values to report.
3709 This clears the mouse_moved flag, so we can wait for the next mouse
3713 XTmouse_position (FRAME_PTR
*fp
, int insist
, Lisp_Object
*bar_window
, enum scroll_bar_part
*part
, Lisp_Object
*x
, Lisp_Object
*y
, long unsigned int *time
)
3719 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
3720 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3726 Window dummy_window
;
3729 Lisp_Object frame
, tail
;
3731 /* Clear the mouse-moved flag for every frame on this display. */
3732 FOR_EACH_FRAME (tail
, frame
)
3733 if (FRAME_X_P (XFRAME (frame
))
3734 && FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
3735 XFRAME (frame
)->mouse_moved
= 0;
3737 last_mouse_scroll_bar
= Qnil
;
3739 /* Figure out which root window we're on. */
3740 XQueryPointer (FRAME_X_DISPLAY (*fp
),
3741 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
3743 /* The root window which contains the pointer. */
3746 /* Trash which we can't trust if the pointer is on
3747 a different screen. */
3750 /* The position on that root window. */
3753 /* More trash we can't trust. */
3756 /* Modifier keys and pointer buttons, about which
3758 (unsigned int *) &dummy
);
3760 /* Now we have a position on the root; find the innermost window
3761 containing the pointer. */
3765 int parent_x
= 0, parent_y
= 0;
3769 /* XTranslateCoordinates can get errors if the window
3770 structure is changing at the same time this function
3771 is running. So at least we must not crash from them. */
3773 x_catch_errors (FRAME_X_DISPLAY (*fp
));
3775 if (FRAME_X_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
3776 && FRAME_LIVE_P (last_mouse_frame
))
3778 /* If mouse was grabbed on a frame, give coords for that frame
3779 even if the mouse is now outside it. */
3780 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3782 /* From-window, to-window. */
3783 root
, FRAME_X_WINDOW (last_mouse_frame
),
3785 /* From-position, to-position. */
3786 root_x
, root_y
, &win_x
, &win_y
,
3790 f1
= last_mouse_frame
;
3796 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3798 /* From-window, to-window. */
3801 /* From-position, to-position. */
3802 root_x
, root_y
, &win_x
, &win_y
,
3807 if (child
== None
|| child
== win
)
3810 /* We don't wan't to know the innermost window. We
3811 want the edit window. For non-Gtk+ the innermost
3812 window is the edit window. For Gtk+ it might not
3813 be. It might be the tool bar for example. */
3814 if (x_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
))
3822 /* Now we know that:
3823 win is the innermost window containing the pointer
3824 (XTC says it has no child containing the pointer),
3825 win_x and win_y are the pointer's position in it
3826 (XTC did this the last time through), and
3827 parent_x and parent_y are the pointer's position in win's parent.
3828 (They are what win_x and win_y were when win was child.
3829 If win is the root window, it has no parent, and
3830 parent_{x,y} are invalid, but that's okay, because we'll
3831 never use them in that case.) */
3834 /* We don't wan't to know the innermost window. We
3835 want the edit window. */
3836 f1
= x_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
3838 /* Is win one of our frames? */
3839 f1
= x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
3842 #ifdef USE_X_TOOLKIT
3843 /* If we end up with the menu bar window, say it's not
3846 && f1
->output_data
.x
->menubar_widget
3847 && win
== XtWindow (f1
->output_data
.x
->menubar_widget
))
3849 #endif /* USE_X_TOOLKIT */
3852 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
3855 x_uncatch_errors ();
3857 /* If not, is it one of our scroll bars? */
3860 struct scroll_bar
*bar
;
3862 bar
= x_window_to_scroll_bar (FRAME_X_DISPLAY (*fp
), win
);
3866 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3872 if (f1
== 0 && insist
> 0)
3873 f1
= SELECTED_FRAME ();
3877 /* Ok, we found a frame. Store all the values.
3878 last_mouse_glyph is a rectangle used to reduce the
3879 generation of mouse events. To not miss any motion
3880 events, we must divide the frame into rectangles of the
3881 size of the smallest character that could be displayed
3882 on it, i.e. into the same rectangles that matrices on
3883 the frame are divided into. */
3885 remember_mouse_glyph (f1
, win_x
, win_y
, &last_mouse_glyph
);
3886 last_mouse_glyph_frame
= f1
;
3891 XSETINT (*x
, win_x
);
3892 XSETINT (*y
, win_y
);
3893 *time
= last_mouse_movement_time
;
3903 /***********************************************************************
3905 ***********************************************************************/
3907 /* Scroll bar support. */
3909 /* Given an X window ID and a DISPLAY, find the struct scroll_bar which
3911 This can be called in GC, so we have to make sure to strip off mark
3914 static struct scroll_bar
*
3915 x_window_to_scroll_bar (Display
*display
, Window window_id
)
3919 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
3920 window_id
= (Window
) xg_get_scroll_id_for_window (display
, window_id
);
3921 #endif /* USE_GTK && USE_TOOLKIT_SCROLL_BARS */
3923 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
3925 Lisp_Object frame
, bar
, condemned
;
3927 frame
= XCAR (tail
);
3928 /* All elements of Vframe_list should be frames. */
3929 if (! FRAMEP (frame
))
3932 if (! FRAME_X_P (XFRAME (frame
)))
3935 /* Scan this frame's scroll bar list for a scroll bar with the
3937 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3938 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3939 /* This trick allows us to search both the ordinary and
3940 condemned scroll bar lists with one loop. */
3941 ! NILP (bar
) || (bar
= condemned
,
3944 bar
= XSCROLL_BAR (bar
)->next
)
3945 if (XSCROLL_BAR (bar
)->x_window
== window_id
&&
3946 FRAME_X_DISPLAY (XFRAME (frame
)) == display
)
3947 return XSCROLL_BAR (bar
);
3954 #if defined USE_LUCID
3956 /* Return the Lucid menu bar WINDOW is part of. Return null
3957 if WINDOW is not part of a menu bar. */
3960 x_window_to_menu_bar (window
)
3965 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
3967 if (FRAME_X_P (XFRAME (XCAR (tail
))))
3969 Lisp_Object frame
= XCAR (tail
);
3970 Widget menu_bar
= XFRAME (frame
)->output_data
.x
->menubar_widget
;
3972 if (menu_bar
&& xlwmenu_window_p (menu_bar
, window
))
3980 #endif /* USE_LUCID */
3983 /************************************************************************
3985 ************************************************************************/
3987 #ifdef USE_TOOLKIT_SCROLL_BARS
3989 static void x_scroll_bar_to_input_event (XEvent
*, struct input_event
*);
3990 static void x_send_scroll_bar_event (Lisp_Object
, int, int, int);
3991 static void x_create_toolkit_scroll_bar (struct frame
*,
3992 struct scroll_bar
*);
3993 static void x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*,
3997 /* Lisp window being scrolled. Set when starting to interact with
3998 a toolkit scroll bar, reset to nil when ending the interaction. */
4000 static Lisp_Object window_being_scrolled
;
4002 /* Last scroll bar part sent in xm_scroll_callback. */
4004 static int last_scroll_bar_part
;
4006 /* Whether this is an Xaw with arrow-scrollbars. This should imply
4007 that movements of 1/20 of the screen size are mapped to up/down. */
4010 /* Id of action hook installed for scroll bars. */
4012 static XtActionHookId action_hook_id
;
4014 static Boolean xaw3d_arrow_scroll
;
4016 /* Whether the drag scrolling maintains the mouse at the top of the
4017 thumb. If not, resizing the thumb needs to be done more carefully
4018 to avoid jerkyness. */
4020 static Boolean xaw3d_pick_top
;
4022 /* Action hook installed via XtAppAddActionHook when toolkit scroll
4023 bars are used.. The hook is responsible for detecting when
4024 the user ends an interaction with the scroll bar, and generates
4025 a `end-scroll' SCROLL_BAR_CLICK_EVENT' event if so. */
4028 xt_action_hook (widget
, client_data
, action_name
, event
, params
,
4031 XtPointer client_data
;
4035 Cardinal
*num_params
;
4041 scroll_bar_p
= XmIsScrollBar (widget
);
4042 end_action
= "Release";
4043 #else /* !USE_MOTIF i.e. use Xaw */
4044 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
4045 end_action
= "EndScroll";
4046 #endif /* USE_MOTIF */
4049 && strcmp (action_name
, end_action
) == 0
4050 && WINDOWP (window_being_scrolled
))
4054 x_send_scroll_bar_event (window_being_scrolled
,
4055 scroll_bar_end_scroll
, 0, 0);
4056 w
= XWINDOW (window_being_scrolled
);
4058 if (!NILP (XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
))
4060 XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
= Qnil
;
4061 /* The thumb size is incorrect while dragging: fix it. */
4062 set_vertical_scroll_bar (w
);
4064 window_being_scrolled
= Qnil
;
4065 last_scroll_bar_part
= -1;
4067 /* Xt timeouts no longer needed. */
4068 toolkit_scroll_bar_interaction
= 0;
4071 #endif /* not USE_GTK */
4073 /* A vector of windows used for communication between
4074 x_send_scroll_bar_event and x_scroll_bar_to_input_event. */
4076 static struct window
**scroll_bar_windows
;
4077 static int scroll_bar_windows_size
;
4080 /* Send a client message with message type Xatom_Scrollbar for a
4081 scroll action to the frame of WINDOW. PART is a value identifying
4082 the part of the scroll bar that was clicked on. PORTION is the
4083 amount to scroll of a whole of WHOLE. */
4086 x_send_scroll_bar_event (Lisp_Object window
, int part
, int portion
, int whole
)
4089 XClientMessageEvent
*ev
= (XClientMessageEvent
*) &event
;
4090 struct window
*w
= XWINDOW (window
);
4091 struct frame
*f
= XFRAME (w
->frame
);
4096 /* Construct a ClientMessage event to send to the frame. */
4097 ev
->type
= ClientMessage
;
4098 ev
->message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_Scrollbar
;
4099 ev
->display
= FRAME_X_DISPLAY (f
);
4100 ev
->window
= FRAME_X_WINDOW (f
);
4103 /* We can only transfer 32 bits in the XClientMessageEvent, which is
4104 not enough to store a pointer or Lisp_Object on a 64 bit system.
4105 So, store the window in scroll_bar_windows and pass the index
4106 into that array in the event. */
4107 for (i
= 0; i
< scroll_bar_windows_size
; ++i
)
4108 if (scroll_bar_windows
[i
] == NULL
)
4111 if (i
== scroll_bar_windows_size
)
4113 int new_size
= max (10, 2 * scroll_bar_windows_size
);
4114 size_t nbytes
= new_size
* sizeof *scroll_bar_windows
;
4115 size_t old_nbytes
= scroll_bar_windows_size
* sizeof *scroll_bar_windows
;
4117 scroll_bar_windows
= (struct window
**) xrealloc (scroll_bar_windows
,
4119 memset (&scroll_bar_windows
[i
], 0, nbytes
- old_nbytes
);
4120 scroll_bar_windows_size
= new_size
;
4123 scroll_bar_windows
[i
] = w
;
4124 ev
->data
.l
[0] = (long) i
;
4125 ev
->data
.l
[1] = (long) part
;
4126 ev
->data
.l
[2] = (long) 0;
4127 ev
->data
.l
[3] = (long) portion
;
4128 ev
->data
.l
[4] = (long) whole
;
4130 /* Make Xt timeouts work while the scroll bar is active. */
4131 toolkit_scroll_bar_interaction
= 1;
4132 #ifdef USE_X_TOOLKIT
4133 x_activate_timeout_atimer ();
4136 /* Setting the event mask to zero means that the message will
4137 be sent to the client that created the window, and if that
4138 window no longer exists, no event will be sent. */
4139 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
4144 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
4148 x_scroll_bar_to_input_event (XEvent
*event
, struct input_event
*ievent
)
4150 XClientMessageEvent
*ev
= (XClientMessageEvent
*) event
;
4155 w
= scroll_bar_windows
[ev
->data
.l
[0]];
4156 scroll_bar_windows
[ev
->data
.l
[0]] = NULL
;
4158 XSETWINDOW (window
, w
);
4159 f
= XFRAME (w
->frame
);
4161 ievent
->kind
= SCROLL_BAR_CLICK_EVENT
;
4162 ievent
->frame_or_window
= window
;
4165 ievent
->timestamp
= CurrentTime
;
4167 ievent
->timestamp
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
4169 ievent
->part
= ev
->data
.l
[1];
4170 ievent
->code
= ev
->data
.l
[2];
4171 ievent
->x
= make_number ((int) ev
->data
.l
[3]);
4172 ievent
->y
= make_number ((int) ev
->data
.l
[4]);
4173 ievent
->modifiers
= 0;
4179 /* Minimum and maximum values used for Motif scroll bars. */
4181 #define XM_SB_MAX 10000000
4184 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
4185 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
4186 CALL_DATA is a pointer to a XmScrollBarCallbackStruct. */
4189 xm_scroll_callback (widget
, client_data
, call_data
)
4191 XtPointer client_data
, call_data
;
4193 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4194 XmScrollBarCallbackStruct
*cs
= (XmScrollBarCallbackStruct
*) call_data
;
4195 int part
= -1, whole
= 0, portion
= 0;
4199 case XmCR_DECREMENT
:
4200 bar
->dragging
= Qnil
;
4201 part
= scroll_bar_up_arrow
;
4204 case XmCR_INCREMENT
:
4205 bar
->dragging
= Qnil
;
4206 part
= scroll_bar_down_arrow
;
4209 case XmCR_PAGE_DECREMENT
:
4210 bar
->dragging
= Qnil
;
4211 part
= scroll_bar_above_handle
;
4214 case XmCR_PAGE_INCREMENT
:
4215 bar
->dragging
= Qnil
;
4216 part
= scroll_bar_below_handle
;
4220 bar
->dragging
= Qnil
;
4221 part
= scroll_bar_to_top
;
4224 case XmCR_TO_BOTTOM
:
4225 bar
->dragging
= Qnil
;
4226 part
= scroll_bar_to_bottom
;
4233 /* Get the slider size. */
4235 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
4238 whole
= XM_SB_MAX
- slider_size
;
4239 portion
= min (cs
->value
, whole
);
4240 part
= scroll_bar_handle
;
4241 bar
->dragging
= make_number (cs
->value
);
4245 case XmCR_VALUE_CHANGED
:
4251 window_being_scrolled
= bar
->window
;
4252 last_scroll_bar_part
= part
;
4253 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4257 #elif defined USE_GTK
4259 /* Scroll bar callback for GTK scroll bars. WIDGET is the scroll
4260 bar widget. DATA is a pointer to the scroll_bar structure. */
4263 xg_scroll_callback (GtkRange
*range
,
4264 GtkScrollType scroll
,
4268 struct scroll_bar
*bar
= (struct scroll_bar
*) user_data
;
4270 int part
= -1, whole
= 0, portion
= 0;
4271 GtkAdjustment
*adj
= GTK_ADJUSTMENT (gtk_range_get_adjustment (range
));
4272 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (range
), XG_FRAME_DATA
);
4274 if (xg_ignore_gtk_scrollbar
) return FALSE
;
4275 position
= gtk_adjustment_get_value (adj
);
4280 case GTK_SCROLL_JUMP
:
4281 /* Buttons 1 2 or 3 must be grabbed. */
4282 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
!= 0
4283 && FRAME_X_DISPLAY_INFO (f
)->grabbed
< (1 << 4))
4285 part
= scroll_bar_handle
;
4286 whole
= gtk_adjustment_get_upper (adj
) -
4287 gtk_adjustment_get_page_size (adj
);
4288 portion
= min ((int)position
, whole
);
4289 bar
->dragging
= make_number ((int)portion
);
4292 case GTK_SCROLL_STEP_BACKWARD
:
4293 part
= scroll_bar_up_arrow
;
4294 bar
->dragging
= Qnil
;
4296 case GTK_SCROLL_STEP_FORWARD
:
4297 part
= scroll_bar_down_arrow
;
4298 bar
->dragging
= Qnil
;
4300 case GTK_SCROLL_PAGE_BACKWARD
:
4301 part
= scroll_bar_above_handle
;
4302 bar
->dragging
= Qnil
;
4304 case GTK_SCROLL_PAGE_FORWARD
:
4305 part
= scroll_bar_below_handle
;
4306 bar
->dragging
= Qnil
;
4312 window_being_scrolled
= bar
->window
;
4313 last_scroll_bar_part
= part
;
4314 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4320 /* Callback for button release. Sets dragging to Qnil when dragging is done. */
4323 xg_end_scroll_callback (GtkWidget
*widget
,
4324 GdkEventButton
*event
,
4327 struct scroll_bar
*bar
= (struct scroll_bar
*) user_data
;
4328 bar
->dragging
= Qnil
;
4329 if (WINDOWP (window_being_scrolled
))
4331 x_send_scroll_bar_event (window_being_scrolled
,
4332 scroll_bar_end_scroll
, 0, 0);
4333 window_being_scrolled
= Qnil
;
4340 #else /* not USE_GTK and not USE_MOTIF */
4342 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
4343 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
4344 scroll bar struct. CALL_DATA is a pointer to a float saying where
4348 xaw_jump_callback (widget
, client_data
, call_data
)
4350 XtPointer client_data
, call_data
;
4352 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4353 float top
= *(float *) call_data
;
4355 int whole
, portion
, height
;
4358 /* Get the size of the thumb, a value between 0 and 1. */
4360 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
4364 portion
= shown
< 1 ? top
* whole
: 0;
4366 if (shown
< 1 && (eabs (top
+ shown
- 1) < 1.0/height
))
4367 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
4368 the bottom, so we force the scrolling whenever we see that we're
4369 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
4370 we try to ensure that we always stay two pixels away from the
4372 part
= scroll_bar_down_arrow
;
4374 part
= scroll_bar_handle
;
4376 window_being_scrolled
= bar
->window
;
4377 bar
->dragging
= make_number (portion
);
4378 last_scroll_bar_part
= part
;
4379 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4383 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
4384 i.e. line or page up or down. WIDGET is the Xaw scroll bar
4385 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
4386 the scroll bar. CALL_DATA is an integer specifying the action that
4387 has taken place. Its magnitude is in the range 0..height of the
4388 scroll bar. Negative values mean scroll towards buffer start.
4389 Values < height of scroll bar mean line-wise movement. */
4392 xaw_scroll_callback (widget
, client_data
, call_data
)
4394 XtPointer client_data
, call_data
;
4396 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4397 /* The position really is stored cast to a pointer. */
4398 int position
= (long) call_data
;
4402 /* Get the height of the scroll bar. */
4404 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
4407 if (eabs (position
) >= height
)
4408 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
4410 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
4411 it maps line-movement to call_data = max(5, height/20). */
4412 else if (xaw3d_arrow_scroll
&& eabs (position
) <= max (5, height
/ 20))
4413 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
4415 part
= scroll_bar_move_ratio
;
4417 window_being_scrolled
= bar
->window
;
4418 bar
->dragging
= Qnil
;
4419 last_scroll_bar_part
= part
;
4420 x_send_scroll_bar_event (bar
->window
, part
, position
, height
);
4423 #endif /* not USE_GTK and not USE_MOTIF */
4425 #define SCROLL_BAR_NAME "verticalScrollBar"
4427 /* Create the widget for scroll bar BAR on frame F. Record the widget
4428 and X window of the scroll bar in BAR. */
4432 x_create_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
4434 char *scroll_bar_name
= SCROLL_BAR_NAME
;
4437 xg_create_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
4438 G_CALLBACK (xg_end_scroll_callback
),
4443 #else /* not USE_GTK */
4446 x_create_toolkit_scroll_bar (f
, bar
)
4448 struct scroll_bar
*bar
;
4454 char *scroll_bar_name
= SCROLL_BAR_NAME
;
4455 unsigned long pixel
;
4460 /* Set resources. Create the widget. */
4461 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4462 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
4463 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
4464 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
4465 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
4466 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
4467 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
4469 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4472 XtSetArg (av
[ac
], XmNforeground
, pixel
);
4476 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4479 XtSetArg (av
[ac
], XmNbackground
, pixel
);
4483 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
4484 scroll_bar_name
, av
, ac
);
4486 /* Add one callback for everything that can happen. */
4487 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
4489 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
4491 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
4493 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
4495 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
4497 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
4499 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
4502 /* Realize the widget. Only after that is the X window created. */
4503 XtRealizeWidget (widget
);
4505 /* Set the cursor to an arrow. I didn't find a resource to do that.
4506 And I'm wondering why it hasn't an arrow cursor by default. */
4507 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
4508 f
->output_data
.x
->nontext_cursor
);
4510 #else /* !USE_MOTIF i.e. use Xaw */
4512 /* Set resources. Create the widget. The background of the
4513 Xaw3d scroll bar widget is a little bit light for my taste.
4514 We don't alter it here to let users change it according
4515 to their taste with `emacs*verticalScrollBar.background: xxx'. */
4516 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4517 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
4518 /* For smoother scrolling with Xaw3d -sm */
4519 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
4521 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4524 XtSetArg (av
[ac
], XtNforeground
, pixel
);
4528 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4531 XtSetArg (av
[ac
], XtNbackground
, pixel
);
4535 /* Top/bottom shadow colors. */
4537 /* Allocate them, if necessary. */
4538 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
4540 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4543 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
4544 FRAME_X_COLORMAP (f
),
4545 &pixel
, 1.2, 0x8000))
4547 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
4550 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4552 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4555 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
4556 FRAME_X_COLORMAP (f
),
4557 &pixel
, 0.6, 0x4000))
4559 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
4563 #ifdef XtNbeNiceToColormap
4564 /* Tell the toolkit about them. */
4565 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
4566 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4567 /* We tried to allocate a color for the top/bottom shadow, and
4568 failed, so tell Xaw3d to use dithering instead. */
4570 XtSetArg (av
[ac
], XtNbeNiceToColormap
, True
);
4574 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
4575 be more consistent with other emacs 3d colors, and since Xaw3d is
4576 not good at dealing with allocation failure. */
4578 /* This tells Xaw3d to use real colors instead of dithering for
4580 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
4583 /* Specify the colors. */
4584 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
4587 XtSetArg (av
[ac
], XtNtopShadowPixel
, pixel
);
4590 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
4593 XtSetArg (av
[ac
], XtNbottomShadowPixel
, pixel
);
4599 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
4600 f
->output_data
.x
->edit_widget
, av
, ac
);
4604 char *val
= initial
;
4605 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
4606 #ifdef XtNarrowScrollbars
4607 XtNarrowScrollbars
, (XtPointer
) &xaw3d_arrow_scroll
,
4609 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
4610 if (xaw3d_arrow_scroll
|| val
== initial
)
4611 { /* ARROW_SCROLL */
4612 xaw3d_arrow_scroll
= True
;
4613 /* Isn't that just a personal preference ? --Stef */
4614 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
4618 /* Define callbacks. */
4619 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
4620 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
4623 /* Realize the widget. Only after that is the X window created. */
4624 XtRealizeWidget (widget
);
4626 #endif /* !USE_MOTIF */
4628 /* Install an action hook that lets us detect when the user
4629 finishes interacting with a scroll bar. */
4630 if (action_hook_id
== 0)
4631 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
4633 /* Remember X window and widget in the scroll bar vector. */
4634 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
4635 xwindow
= XtWindow (widget
);
4636 bar
->x_window
= xwindow
;
4640 #endif /* not USE_GTK */
4643 /* Set the thumb size and position of scroll bar BAR. We are currently
4644 displaying PORTION out of a whole WHOLE, and our position POSITION. */
4648 x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
, int whole
)
4650 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
4653 #else /* not USE_GTK */
4655 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
4656 struct scroll_bar
*bar
;
4657 int portion
, position
, whole
;
4659 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4660 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4667 /* We use an estimate of 30 chars per line rather than the real
4668 `portion' value. This has the disadvantage that the thumb size
4669 is not very representative, but it makes our life a lot easier.
4670 Otherwise, we have to constantly adjust the thumb size, which
4671 we can't always do quickly enough: while dragging, the size of
4672 the thumb might prevent the user from dragging the thumb all the
4673 way to the end. but Motif and some versions of Xaw3d don't allow
4674 updating the thumb size while dragging. Also, even if we can update
4675 its size, the update will often happen too late.
4676 If you don't believe it, check out revision 1.650 of xterm.c to see
4677 what hoops we were going through and the still poor behavior we got. */
4678 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
4679 /* When the thumb is at the bottom, position == whole.
4680 So we need to increase `whole' to make space for the thumb. */
4687 top
= (float) position
/ whole
;
4688 shown
= (float) portion
/ whole
;
4691 if (NILP (bar
->dragging
))
4695 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
4696 is the scroll bar's maximum and MIN is the scroll bar's minimum
4698 size
= shown
* XM_SB_MAX
;
4699 size
= min (size
, XM_SB_MAX
);
4700 size
= max (size
, 1);
4702 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
4703 value
= top
* XM_SB_MAX
;
4704 value
= min (value
, XM_SB_MAX
- size
);
4706 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
4708 #else /* !USE_MOTIF i.e. use Xaw */
4714 top
= (float) position
/ whole
;
4715 shown
= (float) portion
/ whole
;
4719 float old_top
, old_shown
;
4721 XtVaGetValues (widget
,
4722 XtNtopOfThumb
, &old_top
,
4723 XtNshown
, &old_shown
,
4727 /* Massage the top+shown values. */
4728 if (NILP (bar
->dragging
) || last_scroll_bar_part
== scroll_bar_down_arrow
)
4729 top
= max (0, min (1, top
));
4732 /* Keep two pixels available for moving the thumb down. */
4733 shown
= max (0, min (1 - top
- (2.0 / height
), shown
));
4735 /* If the call to XawScrollbarSetThumb below doesn't seem to work,
4736 check that your system's configuration file contains a define
4737 for `NARROWPROTO'. See s/freebsd.h for an example. */
4738 if (top
!= old_top
|| shown
!= old_shown
)
4740 if (NILP (bar
->dragging
))
4741 XawScrollbarSetThumb (widget
, top
, shown
);
4744 /* Try to make the scrolling a tad smoother. */
4745 if (!xaw3d_pick_top
)
4746 shown
= min (shown
, old_shown
);
4748 XawScrollbarSetThumb (widget
, top
, shown
);
4752 #endif /* !USE_MOTIF */
4756 #endif /* not USE_GTK */
4758 #endif /* USE_TOOLKIT_SCROLL_BARS */
4762 /************************************************************************
4763 Scroll bars, general
4764 ************************************************************************/
4766 /* Create a scroll bar and return the scroll bar vector for it. W is
4767 the Emacs window on which to create the scroll bar. TOP, LEFT,
4768 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
4771 static struct scroll_bar
*
4772 x_scroll_bar_create (struct window
*w
, int top
, int left
, int width
, int height
)
4774 struct frame
*f
= XFRAME (w
->frame
);
4775 struct scroll_bar
*bar
4776 = ALLOCATE_PSEUDOVECTOR (struct scroll_bar
, x_window
, PVEC_OTHER
);
4780 #ifdef USE_TOOLKIT_SCROLL_BARS
4781 x_create_toolkit_scroll_bar (f
, bar
);
4782 #else /* not USE_TOOLKIT_SCROLL_BARS */
4784 XSetWindowAttributes a
;
4788 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4789 if (a
.background_pixel
== -1)
4790 a
.background_pixel
= FRAME_BACKGROUND_PIXEL (f
);
4792 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
4793 | ButtonMotionMask
| PointerMotionHintMask
4795 a
.cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
4797 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
4799 /* Clear the area of W that will serve as a scroll bar. This is
4800 for the case that a window has been split horizontally. In
4801 this case, no clear_frame is generated to reduce flickering. */
4802 if (width
> 0 && height
> 0)
4803 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4805 window_box_height (w
), False
);
4807 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4808 /* Position and size of scroll bar. */
4809 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4811 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4813 /* Border width, depth, class, and visual. */
4820 bar
->x_window
= window
;
4822 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4824 XSETWINDOW (bar
->window
, w
);
4828 bar
->height
= height
;
4831 bar
->dragging
= Qnil
;
4832 bar
->fringe_extended_p
= 0;
4834 /* Add bar to its frame's list of scroll bars. */
4835 bar
->next
= FRAME_SCROLL_BARS (f
);
4837 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
4838 if (!NILP (bar
->next
))
4839 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4841 /* Map the window/widget. */
4842 #ifdef USE_TOOLKIT_SCROLL_BARS
4845 xg_update_scrollbar_pos (f
,
4848 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4849 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4851 #else /* not USE_GTK */
4852 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4853 XtConfigureWidget (scroll_bar
,
4854 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4856 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4857 max (height
, 1), 0);
4858 XtMapWidget (scroll_bar
);
4859 #endif /* not USE_GTK */
4861 #else /* not USE_TOOLKIT_SCROLL_BARS */
4862 XMapRaised (FRAME_X_DISPLAY (f
), bar
->x_window
);
4863 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4870 #ifndef USE_TOOLKIT_SCROLL_BARS
4872 /* Draw BAR's handle in the proper position.
4874 If the handle is already drawn from START to END, don't bother
4875 redrawing it, unless REBUILD is non-zero; in that case, always
4876 redraw it. (REBUILD is handy for drawing the handle after expose
4879 Normally, we want to constrain the start and end of the handle to
4880 fit inside its rectangle, but if the user is dragging the scroll
4881 bar handle, we want to let them drag it down all the way, so that
4882 the bar's top is as far down as it goes; otherwise, there's no way
4883 to move to the very end of the buffer. */
4886 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
4887 struct scroll_bar
*bar
;
4891 int dragging
= ! NILP (bar
->dragging
);
4892 Window w
= bar
->x_window
;
4893 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4894 GC gc
= f
->output_data
.x
->normal_gc
;
4896 /* If the display is already accurate, do nothing. */
4898 && start
== bar
->start
4905 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, bar
->width
);
4906 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, bar
->height
);
4907 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
4909 /* Make sure the values are reasonable, and try to preserve
4910 the distance between start and end. */
4912 int length
= end
- start
;
4916 else if (start
> top_range
)
4918 end
= start
+ length
;
4922 else if (end
> top_range
&& ! dragging
)
4926 /* Store the adjusted setting in the scroll bar. */
4930 /* Clip the end position, just for display. */
4931 if (end
> top_range
)
4934 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
4935 below top positions, to make sure the handle is always at least
4936 that many pixels tall. */
4937 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4939 /* Draw the empty space above the handle. Note that we can't clear
4940 zero-height areas; that means "clear to end of window." */
4942 x_clear_area (FRAME_X_DISPLAY (f
), w
,
4943 /* x, y, width, height, and exposures. */
4944 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4945 VERTICAL_SCROLL_BAR_TOP_BORDER
,
4946 inside_width
, start
,
4949 /* Change to proper foreground color if one is specified. */
4950 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
4951 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
4952 f
->output_data
.x
->scroll_bar_foreground_pixel
);
4954 /* Draw the handle itself. */
4955 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
4956 /* x, y, width, height */
4957 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4958 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
4959 inside_width
, end
- start
);
4961 /* Restore the foreground color of the GC if we changed it above. */
4962 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
4963 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
4964 FRAME_FOREGROUND_PIXEL (f
));
4966 /* Draw the empty space below the handle. Note that we can't
4967 clear zero-height areas; that means "clear to end of window." */
4968 if (end
< inside_height
)
4969 x_clear_area (FRAME_X_DISPLAY (f
), w
,
4970 /* x, y, width, height, and exposures. */
4971 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4972 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
4973 inside_width
, inside_height
- end
,
4981 #endif /* !USE_TOOLKIT_SCROLL_BARS */
4983 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
4987 x_scroll_bar_remove (struct scroll_bar
*bar
)
4989 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4992 #ifdef USE_TOOLKIT_SCROLL_BARS
4994 xg_remove_scroll_bar (f
, bar
->x_window
);
4995 #else /* not USE_GTK */
4996 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
4997 #endif /* not USE_GTK */
4999 XDestroyWindow (FRAME_X_DISPLAY (f
), bar
->x_window
);
5002 /* Disassociate this scroll bar from its window. */
5003 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
5009 /* Set the handle of the vertical scroll bar for WINDOW to indicate
5010 that we are displaying PORTION characters out of a total of WHOLE
5011 characters, starting at POSITION. If WINDOW has no scroll bar,
5015 XTset_vertical_scroll_bar (struct window
*w
, int portion
, int whole
, int position
)
5017 struct frame
*f
= XFRAME (w
->frame
);
5018 struct scroll_bar
*bar
;
5019 int top
, height
, left
, sb_left
, width
, sb_width
;
5020 int window_y
, window_height
;
5021 #ifdef USE_TOOLKIT_SCROLL_BARS
5022 int fringe_extended_p
;
5025 /* Get window dimensions. */
5026 window_box (w
, -1, 0, &window_y
, 0, &window_height
);
5028 width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
5029 height
= window_height
;
5031 /* Compute the left edge of the scroll bar area. */
5032 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
5034 /* Compute the width of the scroll bar which might be less than
5035 the width of the area reserved for the scroll bar. */
5036 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
) > 0)
5037 sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
5041 /* Compute the left edge of the scroll bar. */
5042 #ifdef USE_TOOLKIT_SCROLL_BARS
5043 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
5044 sb_left
= left
+ (WINDOW_RIGHTMOST_P (w
) ? width
- sb_width
: 0);
5046 sb_left
= left
+ (WINDOW_LEFTMOST_P (w
) ? 0 : width
- sb_width
);
5048 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
5049 sb_left
= left
+ width
- sb_width
;
5054 #ifdef USE_TOOLKIT_SCROLL_BARS
5055 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
5056 fringe_extended_p
= (WINDOW_LEFTMOST_P (w
)
5057 && WINDOW_LEFT_FRINGE_WIDTH (w
)
5058 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5059 || WINDOW_LEFT_MARGIN_COLS (w
) == 0));
5061 fringe_extended_p
= (WINDOW_RIGHTMOST_P (w
)
5062 && WINDOW_RIGHT_FRINGE_WIDTH (w
)
5063 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5064 || WINDOW_RIGHT_MARGIN_COLS (w
) == 0));
5067 /* Does the scroll bar exist yet? */
5068 if (NILP (w
->vertical_scroll_bar
))
5070 if (width
> 0 && height
> 0)
5073 #ifdef USE_TOOLKIT_SCROLL_BARS
5074 if (fringe_extended_p
)
5075 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5076 sb_left
, top
, sb_width
, height
, False
);
5079 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5080 left
, top
, width
, height
, False
);
5084 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
5088 /* It may just need to be moved and resized. */
5089 unsigned int mask
= 0;
5091 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5095 if (sb_left
!= bar
->left
)
5097 if (top
!= bar
->top
)
5099 if (sb_width
!= bar
->width
)
5101 if (height
!= bar
->height
)
5104 #ifdef USE_TOOLKIT_SCROLL_BARS
5106 /* Move/size the scroll bar widget. */
5107 if (mask
|| bar
->fringe_extended_p
!= fringe_extended_p
)
5109 /* Since toolkit scroll bars are smaller than the space reserved
5110 for them on the frame, we have to clear "under" them. */
5111 if (width
> 0 && height
> 0)
5113 if (fringe_extended_p
)
5114 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5115 sb_left
, top
, sb_width
, height
, False
);
5117 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5118 left
, top
, width
, height
, False
);
5121 xg_update_scrollbar_pos (f
,
5124 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5125 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
*2,
5127 #else /* not USE_GTK */
5128 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
5129 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5131 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
5132 max (height
, 1), 0);
5133 #endif /* not USE_GTK */
5135 #else /* not USE_TOOLKIT_SCROLL_BARS */
5137 /* Clear areas not covered by the scroll bar because of
5138 VERTICAL_SCROLL_BAR_WIDTH_TRIM. */
5139 if (VERTICAL_SCROLL_BAR_WIDTH_TRIM
)
5141 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5142 left
, top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5144 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5145 left
+ width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5146 top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5150 /* Clear areas not covered by the scroll bar because it's not as
5151 wide as the area reserved for it. This makes sure a
5152 previous mode line display is cleared after C-x 2 C-x 1, for
5155 int area_width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
5156 int rest
= area_width
- sb_width
;
5157 if (rest
> 0 && height
> 0)
5159 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
5160 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5161 left
+ area_width
- rest
, top
,
5162 rest
, height
, False
);
5164 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5165 left
, top
, rest
, height
, False
);
5169 /* Move/size the scroll bar window. */
5174 wc
.x
= sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5176 wc
.width
= sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2;
5178 XConfigureWindow (FRAME_X_DISPLAY (f
), bar
->x_window
,
5182 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5184 /* Remember new settings. */
5185 bar
->left
= sb_left
;
5187 bar
->width
= sb_width
;
5188 bar
->height
= height
;
5193 #ifdef USE_TOOLKIT_SCROLL_BARS
5194 bar
->fringe_extended_p
= fringe_extended_p
;
5196 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
5197 #else /* not USE_TOOLKIT_SCROLL_BARS */
5198 /* Set the scroll bar's current state, unless we're currently being
5200 if (NILP (bar
->dragging
))
5202 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
5205 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
5208 int start
= ((double) position
* top_range
) / whole
;
5209 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
5210 x_scroll_bar_set_handle (bar
, start
, end
, 0);
5213 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5215 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
5219 /* The following three hooks are used when we're doing a thorough
5220 redisplay of the frame. We don't explicitly know which scroll bars
5221 are going to be deleted, because keeping track of when windows go
5222 away is a real pain - "Can you say set-window-configuration, boys
5223 and girls?" Instead, we just assert at the beginning of redisplay
5224 that *all* scroll bars are to be removed, and then save a scroll bar
5225 from the fiery pit when we actually redisplay its window. */
5227 /* Arrange for all scroll bars on FRAME to be removed at the next call
5228 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
5229 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
5232 XTcondemn_scroll_bars (FRAME_PTR frame
)
5234 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
5235 while (! NILP (FRAME_SCROLL_BARS (frame
)))
5238 bar
= FRAME_SCROLL_BARS (frame
);
5239 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
5240 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
5241 XSCROLL_BAR (bar
)->prev
= Qnil
;
5242 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
5243 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
5244 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
5249 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
5250 Note that WINDOW isn't necessarily condemned at all. */
5253 XTredeem_scroll_bar (struct window
*window
)
5255 struct scroll_bar
*bar
;
5258 /* We can't redeem this window's scroll bar if it doesn't have one. */
5259 if (NILP (window
->vertical_scroll_bar
))
5262 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
5264 /* Unlink it from the condemned list. */
5265 f
= XFRAME (WINDOW_FRAME (window
));
5266 if (NILP (bar
->prev
))
5268 /* If the prev pointer is nil, it must be the first in one of
5270 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
5271 /* It's not condemned. Everything's fine. */
5273 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
5274 window
->vertical_scroll_bar
))
5275 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
5277 /* If its prev pointer is nil, it must be at the front of
5278 one or the other! */
5282 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
5284 if (! NILP (bar
->next
))
5285 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
5287 bar
->next
= FRAME_SCROLL_BARS (f
);
5289 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
5290 if (! NILP (bar
->next
))
5291 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
5294 /* Remove all scroll bars on FRAME that haven't been saved since the
5295 last call to `*condemn_scroll_bars_hook'. */
5298 XTjudge_scroll_bars (FRAME_PTR f
)
5300 Lisp_Object bar
, next
;
5302 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
5304 /* Clear out the condemned list now so we won't try to process any
5305 more events on the hapless scroll bars. */
5306 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
5308 for (; ! NILP (bar
); bar
= next
)
5310 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
5312 x_scroll_bar_remove (b
);
5315 b
->next
= b
->prev
= Qnil
;
5318 /* Now there should be no references to the condemned scroll bars,
5319 and they should get garbage-collected. */
5323 #ifndef USE_TOOLKIT_SCROLL_BARS
5324 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
5325 is a no-op when using toolkit scroll bars.
5327 This may be called from a signal handler, so we have to ignore GC
5331 x_scroll_bar_expose (bar
, event
)
5332 struct scroll_bar
*bar
;
5335 Window w
= bar
->x_window
;
5336 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5337 GC gc
= f
->output_data
.x
->normal_gc
;
5338 int width_trim
= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5342 x_scroll_bar_set_handle (bar
, bar
->start
, bar
->end
, 1);
5344 /* Switch to scroll bar foreground color. */
5345 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5346 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5347 f
->output_data
.x
->scroll_bar_foreground_pixel
);
5349 /* Draw a one-pixel border just inside the edges of the scroll bar. */
5350 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
5352 /* x, y, width, height */
5354 bar
->width
- 1 - width_trim
- width_trim
,
5357 /* Restore the foreground color of the GC if we changed it above. */
5358 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5359 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5360 FRAME_FOREGROUND_PIXEL (f
));
5365 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5367 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
5368 is set to something other than NO_EVENT, it is enqueued.
5370 This may be called from a signal handler, so we have to ignore GC
5375 x_scroll_bar_handle_click (struct scroll_bar
*bar
, XEvent
*event
, struct input_event
*emacs_event
)
5377 if (! WINDOWP (bar
->window
))
5380 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
5381 emacs_event
->code
= event
->xbutton
.button
- Button1
;
5382 emacs_event
->modifiers
5383 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
5384 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
5385 event
->xbutton
.state
)
5386 | (event
->type
== ButtonRelease
5389 emacs_event
->frame_or_window
= bar
->window
;
5390 emacs_event
->arg
= Qnil
;
5391 emacs_event
->timestamp
= event
->xbutton
.time
;
5394 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
5395 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
5398 if (y
> top_range
) y
= top_range
;
5401 emacs_event
->part
= scroll_bar_above_handle
;
5402 else if (y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5403 emacs_event
->part
= scroll_bar_handle
;
5405 emacs_event
->part
= scroll_bar_below_handle
;
5407 #ifndef USE_TOOLKIT_SCROLL_BARS
5408 /* If the user has released the handle, set it to its final position. */
5409 if (event
->type
== ButtonRelease
5410 && ! NILP (bar
->dragging
))
5412 int new_start
= y
- XINT (bar
->dragging
);
5413 int new_end
= new_start
+ bar
->end
- bar
->start
;
5415 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5416 bar
->dragging
= Qnil
;
5420 XSETINT (emacs_event
->x
, y
);
5421 XSETINT (emacs_event
->y
, top_range
);
5425 #ifndef USE_TOOLKIT_SCROLL_BARS
5427 /* Handle some mouse motion while someone is dragging the scroll bar.
5429 This may be called from a signal handler, so we have to ignore GC
5433 x_scroll_bar_note_movement (bar
, event
)
5434 struct scroll_bar
*bar
;
5437 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
5439 last_mouse_movement_time
= event
->xmotion
.time
;
5442 XSETVECTOR (last_mouse_scroll_bar
, bar
);
5444 /* If we're dragging the bar, display it. */
5445 if (! NILP (bar
->dragging
))
5447 /* Where should the handle be now? */
5448 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
5450 if (new_start
!= bar
->start
)
5452 int new_end
= new_start
+ bar
->end
- bar
->start
;
5454 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5459 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5461 /* Return information to the user about the current position of the mouse
5462 on the scroll bar. */
5465 x_scroll_bar_report_motion (FRAME_PTR
*fp
, Lisp_Object
*bar_window
, enum scroll_bar_part
*part
, Lisp_Object
*x
, Lisp_Object
*y
, long unsigned int *time
)
5467 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
5468 Window w
= bar
->x_window
;
5469 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5471 Window dummy_window
;
5473 unsigned int dummy_mask
;
5477 /* Get the mouse's position relative to the scroll bar window, and
5479 if (! XQueryPointer (FRAME_X_DISPLAY (f
), w
,
5481 /* Root, child, root x and root y. */
5482 &dummy_window
, &dummy_window
,
5483 &dummy_coord
, &dummy_coord
,
5485 /* Position relative to scroll bar. */
5488 /* Mouse buttons and modifier keys. */
5494 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
5496 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
5498 if (! NILP (bar
->dragging
))
5499 win_y
-= XINT (bar
->dragging
);
5503 if (win_y
> top_range
)
5507 *bar_window
= bar
->window
;
5509 if (! NILP (bar
->dragging
))
5510 *part
= scroll_bar_handle
;
5511 else if (win_y
< bar
->start
)
5512 *part
= scroll_bar_above_handle
;
5513 else if (win_y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5514 *part
= scroll_bar_handle
;
5516 *part
= scroll_bar_below_handle
;
5518 XSETINT (*x
, win_y
);
5519 XSETINT (*y
, top_range
);
5522 last_mouse_scroll_bar
= Qnil
;
5525 *time
= last_mouse_movement_time
;
5531 /* The screen has been cleared so we may have changed foreground or
5532 background colors, and the scroll bars may need to be redrawn.
5533 Clear out the scroll bars, and ask for expose events, so we can
5537 x_scroll_bar_clear (FRAME_PTR f
)
5539 #ifndef USE_TOOLKIT_SCROLL_BARS
5542 /* We can have scroll bars even if this is 0,
5543 if we just turned off scroll bar mode.
5544 But in that case we should not clear them. */
5545 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5546 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
5547 bar
= XSCROLL_BAR (bar
)->next
)
5548 XClearArea (FRAME_X_DISPLAY (f
),
5549 XSCROLL_BAR (bar
)->x_window
,
5551 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5555 /* The main X event-reading loop - XTread_socket. */
5557 /* This holds the state XLookupString needs to implement dead keys
5558 and other tricks known as "compose processing". _X Window System_
5559 says that a portable program can't use this, but Stephen Gildea assures
5560 me that letting the compiler initialize it to zeros will work okay.
5562 This must be defined outside of XTread_socket, for the same reasons
5563 given for enter_timestamp, above. */
5565 static XComposeStatus compose_status
;
5567 /* Record the last 100 characters stored
5568 to help debug the loss-of-chars-during-GC problem. */
5570 static int temp_index
;
5571 static short temp_buffer
[100];
5573 #define STORE_KEYSYM_FOR_DEBUG(keysym) \
5574 if (temp_index == sizeof temp_buffer / sizeof (short)) \
5576 temp_buffer[temp_index++] = (keysym)
5578 /* Set this to nonzero to fake an "X I/O error"
5579 on a particular display. */
5581 struct x_display_info
*XTread_socket_fake_io_error
;
5583 /* When we find no input here, we occasionally do a no-op command
5584 to verify that the X server is still running and we can still talk with it.
5585 We try all the open displays, one by one.
5586 This variable is used for cycling thru the displays. */
5588 static struct x_display_info
*next_noop_dpyinfo
;
5590 #define SET_SAVED_MENU_EVENT(size) \
5593 if (f->output_data.x->saved_menu_event == 0) \
5594 f->output_data.x->saved_menu_event \
5595 = (XEvent *) xmalloc (sizeof (XEvent)); \
5596 memcpy (f->output_data.x->saved_menu_event, &event, size); \
5597 inev.ie.kind = MENU_BAR_ACTIVATE_EVENT; \
5598 XSETFRAME (inev.ie.frame_or_window, f); \
5602 #define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
5603 #define SET_SAVED_KEY_EVENT SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
5613 /* Filter events for the current X input method.
5614 DPYINFO is the display this event is for.
5615 EVENT is the X event to filter.
5617 Returns non-zero if the event was filtered, caller shall not process
5619 Returns zero if event is wasn't filtered. */
5623 x_filter_event (struct x_display_info
*dpyinfo
, XEvent
*event
)
5625 /* XFilterEvent returns non-zero if the input method has
5626 consumed the event. We pass the frame's X window to
5627 XFilterEvent because that's the one for which the IC
5630 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
5631 event
->xclient
.window
);
5633 return XFilterEvent (event
, f1
? FRAME_X_WINDOW (f1
) : None
);
5638 static int current_count
;
5639 static int current_finish
;
5640 static struct input_event
*current_hold_quit
;
5642 /* This is the filter function invoked by the GTK event loop.
5643 It is invoked before the XEvent is translated to a GdkEvent,
5644 so we have a chance to act on the event before GTK. */
5645 static GdkFilterReturn
5646 event_handler_gdk (GdkXEvent
*gxev
, GdkEvent
*ev
, gpointer data
)
5648 XEvent
*xev
= (XEvent
*) gxev
;
5651 if (current_count
>= 0)
5653 struct x_display_info
*dpyinfo
;
5655 dpyinfo
= x_display_info_for_display (xev
->xany
.display
);
5658 /* Filter events for the current X input method.
5659 GTK calls XFilterEvent but not for key press and release,
5660 so we do it here. */
5661 if ((xev
->type
== KeyPress
|| xev
->type
== KeyRelease
)
5663 && x_filter_event (dpyinfo
, xev
))
5666 return GDK_FILTER_REMOVE
;
5671 current_finish
= X_EVENT_NORMAL
;
5674 handle_one_xevent (dpyinfo
, xev
, ¤t_finish
,
5678 current_finish
= x_dispatch_event (xev
, xev
->xany
.display
);
5682 if (current_finish
== X_EVENT_GOTO_OUT
|| current_finish
== X_EVENT_DROP
)
5683 return GDK_FILTER_REMOVE
;
5685 return GDK_FILTER_CONTINUE
;
5687 #endif /* USE_GTK */
5690 /* Handles the XEvent EVENT on display DPYINFO.
5692 *FINISH is X_EVENT_GOTO_OUT if caller should stop reading events.
5693 *FINISH is zero if caller should continue reading events.
5694 *FINISH is X_EVENT_DROP if event should not be passed to the toolkit.
5696 We return the number of characters stored into the buffer. */
5699 handle_one_xevent (struct x_display_info
*dpyinfo
, XEvent
*eventp
, int *finish
, struct input_event
*hold_quit
)
5702 struct input_event ie
;
5703 struct selection_input_event sie
;
5708 struct frame
*f
= NULL
;
5709 struct coding_system coding
;
5710 XEvent event
= *eventp
;
5712 *finish
= X_EVENT_NORMAL
;
5714 EVENT_INIT (inev
.ie
);
5715 inev
.ie
.kind
= NO_EVENT
;
5718 if (pending_event_wait
.eventtype
== event
.type
)
5719 pending_event_wait
.eventtype
= 0; /* Indicates we got it. */
5725 if (event
.xclient
.message_type
5726 == dpyinfo
->Xatom_wm_protocols
5727 && event
.xclient
.format
== 32)
5729 if (event
.xclient
.data
.l
[0]
5730 == dpyinfo
->Xatom_wm_take_focus
)
5732 /* Use x_any_window_to_frame because this
5733 could be the shell widget window
5734 if the frame has no title bar. */
5735 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5737 /* Not quite sure this is needed -pd */
5738 if (f
&& FRAME_XIC (f
))
5739 XSetICFocus (FRAME_XIC (f
));
5741 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
5742 instructs the WM to set the input focus automatically for
5743 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
5744 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
5745 it has set the focus. So, XSetInputFocus below is not
5748 The call to XSetInputFocus below has also caused trouble. In
5749 cases where the XSetInputFocus done by the WM and the one
5750 below are temporally close (on a fast machine), the call
5751 below can generate additional FocusIn events which confuse
5754 /* Since we set WM_TAKE_FOCUS, we must call
5755 XSetInputFocus explicitly. But not if f is null,
5756 since that might be an event for a deleted frame. */
5759 Display
*d
= event
.xclient
.display
;
5760 /* Catch and ignore errors, in case window has been
5761 iconified by a window manager such as GWM. */
5763 XSetInputFocus (d
, event
.xclient
.window
,
5764 /* The ICCCM says this is
5765 the only valid choice. */
5767 event
.xclient
.data
.l
[1]);
5768 /* This is needed to detect the error
5769 if there is an error. */
5771 x_uncatch_errors ();
5773 /* Not certain about handling scroll bars here */
5778 if (event
.xclient
.data
.l
[0]
5779 == dpyinfo
->Xatom_wm_save_yourself
)
5781 /* Save state modify the WM_COMMAND property to
5782 something which can reinstate us. This notifies
5783 the session manager, who's looking for such a
5784 PropertyNotify. Can restart processing when
5785 a keyboard or mouse event arrives. */
5786 /* If we have a session manager, don't set this.
5787 KDE will then start two Emacsen, one for the
5788 session manager and one for this. */
5790 if (! x_session_have_connection ())
5793 f
= x_top_window_to_frame (dpyinfo
,
5794 event
.xclient
.window
);
5795 /* This is just so we only give real data once
5796 for a single Emacs process. */
5797 if (f
== SELECTED_FRAME ())
5798 XSetCommand (FRAME_X_DISPLAY (f
),
5799 event
.xclient
.window
,
5800 initial_argv
, initial_argc
);
5802 XSetCommand (FRAME_X_DISPLAY (f
),
5803 event
.xclient
.window
,
5809 if (event
.xclient
.data
.l
[0]
5810 == dpyinfo
->Xatom_wm_delete_window
)
5812 f
= x_any_window_to_frame (dpyinfo
,
5813 event
.xclient
.window
);
5815 goto OTHER
; /* May be a dialog that is to be removed */
5817 inev
.ie
.kind
= DELETE_WINDOW_EVENT
;
5818 XSETFRAME (inev
.ie
.frame_or_window
, f
);
5825 if (event
.xclient
.message_type
5826 == dpyinfo
->Xatom_wm_configure_denied
)
5831 if (event
.xclient
.message_type
5832 == dpyinfo
->Xatom_wm_window_moved
)
5835 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
5837 new_x
= event
.xclient
.data
.s
[0];
5838 new_y
= event
.xclient
.data
.s
[1];
5842 f
->left_pos
= new_x
;
5849 if (event
.xclient
.message_type
5850 == dpyinfo
->Xatom_editres
)
5852 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5854 _XEditResCheckMessages (f
->output_data
.x
->widget
, NULL
,
5858 #endif /* HACK_EDITRES */
5860 if ((event
.xclient
.message_type
5861 == dpyinfo
->Xatom_DONE
)
5862 || (event
.xclient
.message_type
5863 == dpyinfo
->Xatom_PAGE
))
5865 /* Ghostview job completed. Kill it. We could
5866 reply with "Next" if we received "Page", but we
5867 currently never do because we are interested in
5868 images, only, which should have 1 page. */
5869 Pixmap pixmap
= (Pixmap
) event
.xclient
.data
.l
[1];
5870 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
5873 x_kill_gs_process (pixmap
, f
);
5874 expose_frame (f
, 0, 0, 0, 0);
5878 #ifdef USE_TOOLKIT_SCROLL_BARS
5879 /* Scroll bar callbacks send a ClientMessage from which
5880 we construct an input_event. */
5881 if (event
.xclient
.message_type
5882 == dpyinfo
->Xatom_Scrollbar
)
5884 x_scroll_bar_to_input_event (&event
, &inev
.ie
);
5885 *finish
= X_EVENT_GOTO_OUT
;
5888 #endif /* USE_TOOLKIT_SCROLL_BARS */
5890 /* XEmbed messages from the embedder (if any). */
5891 if (event
.xclient
.message_type
5892 == dpyinfo
->Xatom_XEMBED
)
5894 enum xembed_message msg
= event
.xclient
.data
.l
[1];
5895 if (msg
== XEMBED_FOCUS_IN
|| msg
== XEMBED_FOCUS_OUT
)
5896 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
5898 *finish
= X_EVENT_GOTO_OUT
;
5902 xft_settings_event (dpyinfo
, &event
);
5904 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5907 if (x_handle_dnd_message (f
, &event
.xclient
, dpyinfo
, &inev
.ie
))
5908 *finish
= X_EVENT_DROP
;
5912 case SelectionNotify
:
5913 last_user_time
= event
.xselection
.time
;
5914 #ifdef USE_X_TOOLKIT
5915 if (! x_window_to_frame (dpyinfo
, event
.xselection
.requestor
))
5917 #endif /* not USE_X_TOOLKIT */
5918 x_handle_selection_notify (&event
.xselection
);
5921 case SelectionClear
: /* Someone has grabbed ownership. */
5922 last_user_time
= event
.xselectionclear
.time
;
5923 #ifdef USE_X_TOOLKIT
5924 if (! x_window_to_frame (dpyinfo
, event
.xselectionclear
.window
))
5926 #endif /* USE_X_TOOLKIT */
5928 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
5930 inev
.ie
.kind
= SELECTION_CLEAR_EVENT
;
5931 SELECTION_EVENT_DISPLAY (&inev
.sie
) = eventp
->display
;
5932 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
5933 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
5934 inev
.ie
.frame_or_window
= Qnil
;
5938 case SelectionRequest
: /* Someone wants our selection. */
5939 last_user_time
= event
.xselectionrequest
.time
;
5940 #ifdef USE_X_TOOLKIT
5941 if (!x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
))
5943 #endif /* USE_X_TOOLKIT */
5945 XSelectionRequestEvent
*eventp
5946 = (XSelectionRequestEvent
*) &event
;
5948 inev
.ie
.kind
= SELECTION_REQUEST_EVENT
;
5949 SELECTION_EVENT_DISPLAY (&inev
.sie
) = eventp
->display
;
5950 SELECTION_EVENT_REQUESTOR (&inev
.sie
) = eventp
->requestor
;
5951 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
5952 SELECTION_EVENT_TARGET (&inev
.sie
) = eventp
->target
;
5953 SELECTION_EVENT_PROPERTY (&inev
.sie
) = eventp
->property
;
5954 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
5955 inev
.ie
.frame_or_window
= Qnil
;
5959 case PropertyNotify
:
5960 last_user_time
= event
.xproperty
.time
;
5961 f
= x_top_window_to_frame (dpyinfo
, event
.xproperty
.window
);
5962 if (f
&& event
.xproperty
.atom
== dpyinfo
->Xatom_net_wm_state
)
5963 x_handle_net_wm_state (f
, &event
.xproperty
);
5965 x_handle_property_notify (&event
.xproperty
);
5966 xft_settings_event (dpyinfo
, &event
);
5969 case ReparentNotify
:
5970 f
= x_top_window_to_frame (dpyinfo
, event
.xreparent
.window
);
5974 f
->output_data
.x
->parent_desc
= event
.xreparent
.parent
;
5975 x_real_positions (f
, &x
, &y
);
5979 /* Perhaps reparented due to a WM restart. Reset this. */
5980 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_UNKNOWN
;
5981 FRAME_X_DISPLAY_INFO (f
)->net_supported_window
= 0;
5986 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
5990 /* This seems to be needed for GTK 2.6. */
5991 x_clear_area (event
.xexpose
.display
,
5992 event
.xexpose
.window
,
5993 event
.xexpose
.x
, event
.xexpose
.y
,
5994 event
.xexpose
.width
, event
.xexpose
.height
,
5997 if (f
->async_visible
== 0)
5999 f
->async_visible
= 1;
6000 f
->async_iconified
= 0;
6001 f
->output_data
.x
->has_been_visible
= 1;
6002 SET_FRAME_GARBAGED (f
);
6006 event
.xexpose
.x
, event
.xexpose
.y
,
6007 event
.xexpose
.width
, event
.xexpose
.height
);
6011 #ifndef USE_TOOLKIT_SCROLL_BARS
6012 struct scroll_bar
*bar
;
6014 #if defined USE_LUCID
6015 /* Submenus of the Lucid menu bar aren't widgets
6016 themselves, so there's no way to dispatch events
6017 to them. Recognize this case separately. */
6020 = x_window_to_menu_bar (event
.xexpose
.window
);
6022 xlwmenu_redisplay (widget
);
6024 #endif /* USE_LUCID */
6026 #ifdef USE_TOOLKIT_SCROLL_BARS
6027 /* Dispatch event to the widget. */
6029 #else /* not USE_TOOLKIT_SCROLL_BARS */
6030 bar
= x_window_to_scroll_bar (event
.xexpose
.display
,
6031 event
.xexpose
.window
);
6034 x_scroll_bar_expose (bar
, &event
);
6035 #ifdef USE_X_TOOLKIT
6038 #endif /* USE_X_TOOLKIT */
6039 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6043 case GraphicsExpose
: /* This occurs when an XCopyArea's
6044 source area was obscured or not
6046 f
= x_window_to_frame (dpyinfo
, event
.xgraphicsexpose
.drawable
);
6050 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
6051 event
.xgraphicsexpose
.width
,
6052 event
.xgraphicsexpose
.height
);
6054 #ifdef USE_X_TOOLKIT
6057 #endif /* USE_X_TOOLKIT */
6060 case NoExpose
: /* This occurs when an XCopyArea's
6061 source area was completely
6066 /* Redo the mouse-highlight after the tooltip has gone. */
6067 if (event
.xmap
.window
== tip_window
)
6070 redo_mouse_highlight ();
6073 f
= x_top_window_to_frame (dpyinfo
, event
.xunmap
.window
);
6074 if (f
) /* F may no longer exist if
6075 the frame was deleted. */
6077 /* While a frame is unmapped, display generation is
6078 disabled; you don't want to spend time updating a
6079 display that won't ever be seen. */
6080 f
->async_visible
= 0;
6081 /* We can't distinguish, from the event, whether the window
6082 has become iconified or invisible. So assume, if it
6083 was previously visible, than now it is iconified.
6084 But x_make_frame_invisible clears both
6085 the visible flag and the iconified flag;
6086 and that way, we know the window is not iconified now. */
6087 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
6089 f
->async_iconified
= 1;
6091 inev
.ie
.kind
= ICONIFY_EVENT
;
6092 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6098 if (event
.xmap
.window
== tip_window
)
6099 /* The tooltip has been drawn already. Avoid
6100 the SET_FRAME_GARBAGED below. */
6103 /* We use x_top_window_to_frame because map events can
6104 come for sub-windows and they don't mean that the
6105 frame is visible. */
6106 f
= x_top_window_to_frame (dpyinfo
, event
.xmap
.window
);
6109 /* wait_reading_process_output will notice this and update
6110 the frame's display structures.
6111 If we where iconified, we should not set garbaged,
6112 because that stops redrawing on Expose events. This looks
6113 bad if we are called from a recursive event loop
6114 (x_dispatch_event), for example when a dialog is up. */
6115 if (! f
->async_iconified
)
6116 SET_FRAME_GARBAGED (f
);
6118 /* Check if fullscreen was specified before we where mapped the
6119 first time, i.e. from the command line. */
6120 if (!f
->output_data
.x
->has_been_visible
)
6121 x_check_fullscreen (f
);
6123 f
->async_visible
= 1;
6124 f
->async_iconified
= 0;
6125 f
->output_data
.x
->has_been_visible
= 1;
6129 inev
.ie
.kind
= DEICONIFY_EVENT
;
6130 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6132 else if (! NILP (Vframe_list
)
6133 && ! NILP (XCDR (Vframe_list
)))
6134 /* Force a redisplay sooner or later
6135 to update the frame titles
6136 in case this is the second frame. */
6137 record_asynch_buffer_change ();
6140 xg_frame_resized (f
, -1, -1);
6147 last_user_time
= event
.xkey
.time
;
6148 ignore_next_mouse_click_timeout
= 0;
6150 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6151 /* Dispatch KeyPress events when in menu. */
6152 if (popup_activated ())
6156 f
= x_any_window_to_frame (dpyinfo
, event
.xkey
.window
);
6158 /* If mouse-highlight is an integer, input clears out
6159 mouse highlighting. */
6160 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
6162 || !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
)))
6164 clear_mouse_face (dpyinfo
);
6165 dpyinfo
->mouse_face_hidden
= 1;
6168 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
6171 /* Scroll bars consume key events, but we want
6172 the keys to go to the scroll bar's frame. */
6173 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
6175 if (widget
&& XmIsScrollBar (widget
))
6177 widget
= XtParent (widget
);
6178 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
6181 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
6185 KeySym keysym
, orig_keysym
;
6186 /* al%imercury@uunet.uu.net says that making this 81
6187 instead of 80 fixed a bug whereby meta chars made
6190 It seems that some version of XmbLookupString has
6191 a bug of not returning XBufferOverflow in
6192 status_return even if the input is too long to
6193 fit in 81 bytes. So, we must prepare sufficient
6194 bytes for copy_buffer. 513 bytes (256 chars for
6195 two-byte character set) seems to be a fairly good
6196 approximation. -- 2000.8.10 handa@etl.go.jp */
6197 unsigned char copy_buffer
[513];
6198 unsigned char *copy_bufptr
= copy_buffer
;
6199 int copy_bufsiz
= sizeof (copy_buffer
);
6201 Lisp_Object coding_system
= Qlatin_1
;
6205 /* Don't pass keys to GTK. A Tab will shift focus to the
6206 tool bar in GTK 2.4. Keys will still go to menus and
6207 dialogs because in that case popup_activated is TRUE
6209 *finish
= X_EVENT_DROP
;
6213 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f
),
6214 extra_keyboard_modifiers
);
6215 modifiers
= event
.xkey
.state
;
6217 /* This will have to go some day... */
6219 /* make_lispy_event turns chars into control chars.
6220 Don't do it here because XLookupString is too eager. */
6221 event
.xkey
.state
&= ~ControlMask
;
6222 event
.xkey
.state
&= ~(dpyinfo
->meta_mod_mask
6223 | dpyinfo
->super_mod_mask
6224 | dpyinfo
->hyper_mod_mask
6225 | dpyinfo
->alt_mod_mask
);
6227 /* In case Meta is ComposeCharacter,
6228 clear its status. According to Markus Ehrnsperger
6229 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
6230 this enables ComposeCharacter to work whether or
6231 not it is combined with Meta. */
6232 if (modifiers
& dpyinfo
->meta_mod_mask
)
6233 memset (&compose_status
, 0, sizeof (compose_status
));
6238 Status status_return
;
6240 coding_system
= Vlocale_coding_system
;
6241 nbytes
= XmbLookupString (FRAME_XIC (f
),
6242 &event
.xkey
, copy_bufptr
,
6243 copy_bufsiz
, &keysym
,
6245 if (status_return
== XBufferOverflow
)
6247 copy_bufsiz
= nbytes
+ 1;
6248 copy_bufptr
= (unsigned char *) alloca (copy_bufsiz
);
6249 nbytes
= XmbLookupString (FRAME_XIC (f
),
6250 &event
.xkey
, copy_bufptr
,
6251 copy_bufsiz
, &keysym
,
6254 /* Xutf8LookupString is a new but already deprecated interface. -stef */
6255 if (status_return
== XLookupNone
)
6257 else if (status_return
== XLookupChars
)
6262 else if (status_return
!= XLookupKeySym
6263 && status_return
!= XLookupBoth
)
6267 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
6268 copy_bufsiz
, &keysym
,
6271 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
6272 copy_bufsiz
, &keysym
,
6276 /* If not using XIM/XIC, and a compose sequence is in progress,
6277 we break here. Otherwise, chars_matched is always 0. */
6278 if (compose_status
.chars_matched
> 0 && nbytes
== 0)
6281 memset (&compose_status
, 0, sizeof (compose_status
));
6282 orig_keysym
= keysym
;
6284 /* Common for all keysym input events. */
6285 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6287 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), modifiers
);
6288 inev
.ie
.timestamp
= event
.xkey
.time
;
6290 /* First deal with keysyms which have defined
6291 translations to characters. */
6292 if (keysym
>= 32 && keysym
< 128)
6293 /* Avoid explicitly decoding each ASCII character. */
6295 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
6296 inev
.ie
.code
= keysym
;
6300 /* Keysyms directly mapped to Unicode characters. */
6301 if (keysym
>= 0x01000000 && keysym
<= 0x0110FFFF)
6303 if (keysym
< 0x01000080)
6304 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
6306 inev
.ie
.kind
= MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
6307 inev
.ie
.code
= keysym
& 0xFFFFFF;
6311 /* Now non-ASCII. */
6312 if (HASH_TABLE_P (Vx_keysym_table
)
6313 && (NATNUMP (c
= Fgethash (make_number (keysym
),
6317 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (XFASTINT (c
))
6318 ? ASCII_KEYSTROKE_EVENT
6319 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6320 inev
.ie
.code
= XFASTINT (c
);
6324 /* Random non-modifier sorts of keysyms. */
6325 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
6326 || keysym
== XK_Delete
6327 #ifdef XK_ISO_Left_Tab
6328 || (keysym
>= XK_ISO_Left_Tab
6329 && keysym
<= XK_ISO_Enter
)
6331 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
6332 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
6334 /* This recognizes the "extended function
6335 keys". It seems there's no cleaner way.
6336 Test IsModifierKey to avoid handling
6337 mode_switch incorrectly. */
6338 || ((unsigned) (keysym
) >= XK_Select
6339 && (unsigned)(keysym
) < XK_KP_Space
)
6341 #ifdef XK_dead_circumflex
6342 || orig_keysym
== XK_dead_circumflex
6344 #ifdef XK_dead_grave
6345 || orig_keysym
== XK_dead_grave
6347 #ifdef XK_dead_tilde
6348 || orig_keysym
== XK_dead_tilde
6350 #ifdef XK_dead_diaeresis
6351 || orig_keysym
== XK_dead_diaeresis
6353 #ifdef XK_dead_macron
6354 || orig_keysym
== XK_dead_macron
6356 #ifdef XK_dead_degree
6357 || orig_keysym
== XK_dead_degree
6359 #ifdef XK_dead_acute
6360 || orig_keysym
== XK_dead_acute
6362 #ifdef XK_dead_cedilla
6363 || orig_keysym
== XK_dead_cedilla
6365 #ifdef XK_dead_breve
6366 || orig_keysym
== XK_dead_breve
6368 #ifdef XK_dead_ogonek
6369 || orig_keysym
== XK_dead_ogonek
6371 #ifdef XK_dead_caron
6372 || orig_keysym
== XK_dead_caron
6374 #ifdef XK_dead_doubleacute
6375 || orig_keysym
== XK_dead_doubleacute
6377 #ifdef XK_dead_abovedot
6378 || orig_keysym
== XK_dead_abovedot
6380 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
6381 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
6382 /* Any "vendor-specific" key is ok. */
6383 || (orig_keysym
& (1 << 28))
6384 || (keysym
!= NoSymbol
&& nbytes
== 0))
6385 && ! (IsModifierKey (orig_keysym
)
6386 /* The symbols from XK_ISO_Lock
6387 to XK_ISO_Last_Group_Lock
6388 don't have real modifiers but
6389 should be treated similarly to
6390 Mode_switch by Emacs. */
6391 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
6392 || ((unsigned)(orig_keysym
)
6394 && (unsigned)(orig_keysym
)
6395 <= XK_ISO_Last_Group_Lock
)
6399 STORE_KEYSYM_FOR_DEBUG (keysym
);
6400 /* make_lispy_event will convert this to a symbolic
6402 inev
.ie
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
6403 inev
.ie
.code
= keysym
;
6407 { /* Raw bytes, not keysym. */
6412 for (i
= 0, nchars
= 0; i
< nbytes
; i
++)
6414 if (ASCII_BYTE_P (copy_bufptr
[i
]))
6416 STORE_KEYSYM_FOR_DEBUG (copy_bufptr
[i
]);
6419 if (nchars
< nbytes
)
6421 /* Decode the input data. */
6425 /* The input should be decoded with `coding_system'
6426 which depends on which X*LookupString function
6427 we used just above and the locale. */
6428 setup_coding_system (coding_system
, &coding
);
6429 coding
.src_multibyte
= 0;
6430 coding
.dst_multibyte
= 1;
6431 /* The input is converted to events, thus we can't
6432 handle composition. Anyway, there's no XIM that
6433 gives us composition information. */
6434 coding
.common_flags
&= ~CODING_ANNOTATION_MASK
;
6436 require
= MAX_MULTIBYTE_LENGTH
* nbytes
;
6437 coding
.destination
= alloca (require
);
6438 coding
.dst_bytes
= require
;
6439 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
6440 decode_coding_c_string (&coding
, copy_bufptr
, nbytes
, Qnil
);
6441 nbytes
= coding
.produced
;
6442 nchars
= coding
.produced_char
;
6443 copy_bufptr
= coding
.destination
;
6446 /* Convert the input data to a sequence of
6447 character events. */
6448 for (i
= 0; i
< nbytes
; i
+= len
)
6450 if (nchars
== nbytes
)
6451 c
= copy_bufptr
[i
], len
= 1;
6453 c
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
, len
);
6454 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (c
)
6455 ? ASCII_KEYSTROKE_EVENT
6456 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6458 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
6463 inev
.ie
.kind
= NO_EVENT
; /* Already stored above. */
6465 if (keysym
== NoSymbol
)
6471 /* Don't dispatch this event since XtDispatchEvent calls
6472 XFilterEvent, and two calls in a row may freeze the
6480 last_user_time
= event
.xkey
.time
;
6482 /* Don't dispatch this event since XtDispatchEvent calls
6483 XFilterEvent, and two calls in a row may freeze the
6491 last_user_time
= event
.xcrossing
.time
;
6492 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6494 f
= x_any_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
6496 if (f
&& x_mouse_click_focus_ignore_position
)
6497 ignore_next_mouse_click_timeout
= event
.xmotion
.time
+ 200;
6499 /* EnterNotify counts as mouse movement,
6500 so update things that depend on mouse position. */
6501 if (f
&& !f
->output_data
.x
->hourglass_p
)
6502 note_mouse_movement (f
, &event
.xmotion
);
6504 /* We may get an EnterNotify on the buttons in the toolbar. In that
6505 case we moved out of any highlighted area and need to note this. */
6506 if (!f
&& last_mouse_glyph_frame
)
6507 note_mouse_movement (last_mouse_glyph_frame
, &event
.xmotion
);
6512 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6516 last_user_time
= event
.xcrossing
.time
;
6517 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6519 f
= x_top_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
6522 if (f
== dpyinfo
->mouse_face_mouse_frame
)
6524 /* If we move outside the frame, then we're
6525 certainly no longer on any text in the frame. */
6526 clear_mouse_face (dpyinfo
);
6527 dpyinfo
->mouse_face_mouse_frame
= 0;
6530 /* Generate a nil HELP_EVENT to cancel a help-echo.
6531 Do it only if there's something to cancel.
6532 Otherwise, the startup message is cleared when
6533 the mouse leaves the frame. */
6534 if (any_help_event_p
)
6538 /* See comment in EnterNotify above */
6539 else if (last_mouse_glyph_frame
)
6540 note_mouse_movement (last_mouse_glyph_frame
, &event
.xmotion
);
6545 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6550 last_user_time
= event
.xmotion
.time
;
6551 previous_help_echo_string
= help_echo_string
;
6552 help_echo_string
= Qnil
;
6554 if (dpyinfo
->grabbed
&& last_mouse_frame
6555 && FRAME_LIVE_P (last_mouse_frame
))
6556 f
= last_mouse_frame
;
6558 f
= x_window_to_frame (dpyinfo
, event
.xmotion
.window
);
6560 if (dpyinfo
->mouse_face_hidden
)
6562 dpyinfo
->mouse_face_hidden
= 0;
6563 clear_mouse_face (dpyinfo
);
6567 if (f
&& xg_event_is_for_scrollbar (f
, &event
))
6573 /* Generate SELECT_WINDOW_EVENTs when needed.
6574 Don't let popup menus influence things (bug#1261). */
6575 if (!NILP (Vmouse_autoselect_window
) && !popup_activated ())
6579 window
= window_from_coordinates (f
,
6580 event
.xmotion
.x
, event
.xmotion
.y
,
6583 /* Window will be selected only when it is not selected now and
6584 last mouse movement event was not in it. Minibuffer window
6585 will be selected only when it is active. */
6586 if (WINDOWP (window
)
6587 && !EQ (window
, last_window
)
6588 && !EQ (window
, selected_window
)
6589 /* For click-to-focus window managers
6590 create event iff we don't leave the
6592 && (focus_follows_mouse
6593 || (EQ (XWINDOW (window
)->frame
,
6594 XWINDOW (selected_window
)->frame
))))
6596 inev
.ie
.kind
= SELECT_WINDOW_EVENT
;
6597 inev
.ie
.frame_or_window
= window
;
6602 if (!note_mouse_movement (f
, &event
.xmotion
))
6603 help_echo_string
= previous_help_echo_string
;
6607 #ifndef USE_TOOLKIT_SCROLL_BARS
6608 struct scroll_bar
*bar
6609 = x_window_to_scroll_bar (event
.xmotion
.display
,
6610 event
.xmotion
.window
);
6613 x_scroll_bar_note_movement (bar
, &event
);
6614 #endif /* USE_TOOLKIT_SCROLL_BARS */
6616 /* If we move outside the frame, then we're
6617 certainly no longer on any text in the frame. */
6618 clear_mouse_face (dpyinfo
);
6621 /* If the contents of the global variable help_echo_string
6622 has changed, generate a HELP_EVENT. */
6623 if (!NILP (help_echo_string
)
6624 || !NILP (previous_help_echo_string
))
6629 case ConfigureNotify
:
6630 f
= x_top_window_to_frame (dpyinfo
, event
.xconfigure
.window
);
6633 && (f
= x_any_window_to_frame (dpyinfo
, event
.xconfigure
.window
))
6634 && event
.xconfigure
.window
== FRAME_X_WINDOW (f
))
6636 xg_frame_resized (f
, event
.xconfigure
.width
,
6637 event
.xconfigure
.height
);
6643 #ifndef USE_X_TOOLKIT
6645 int rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, event
.xconfigure
.height
);
6646 int columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, event
.xconfigure
.width
);
6648 /* In the toolkit version, change_frame_size
6649 is called by the code that handles resizing
6650 of the EmacsFrame widget. */
6652 /* Even if the number of character rows and columns has
6653 not changed, the font size may have changed, so we need
6654 to check the pixel dimensions as well. */
6655 if (columns
!= FRAME_COLS (f
)
6656 || rows
!= FRAME_LINES (f
)
6657 || event
.xconfigure
.width
!= FRAME_PIXEL_WIDTH (f
)
6658 || event
.xconfigure
.height
!= FRAME_PIXEL_HEIGHT (f
))
6660 change_frame_size (f
, rows
, columns
, 0, 1, 0);
6661 SET_FRAME_GARBAGED (f
);
6662 cancel_mouse_face (f
);
6665 FRAME_PIXEL_WIDTH (f
) = event
.xconfigure
.width
;
6666 FRAME_PIXEL_HEIGHT (f
) = event
.xconfigure
.height
;
6667 #endif /* not USE_GTK */
6671 /* GTK creates windows but doesn't map them.
6672 Only get real positions when mapped. */
6673 if (FRAME_GTK_OUTER_WIDGET (f
)
6674 && gtk_widget_get_mapped (FRAME_GTK_OUTER_WIDGET (f
)))
6677 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
6681 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
6682 xic_set_statusarea (f
);
6691 /* If we decide we want to generate an event to be seen
6692 by the rest of Emacs, we put it here. */
6695 memset (&compose_status
, 0, sizeof (compose_status
));
6696 last_mouse_glyph_frame
= 0;
6697 last_user_time
= event
.xbutton
.time
;
6699 if (dpyinfo
->grabbed
6701 && FRAME_LIVE_P (last_mouse_frame
))
6702 f
= last_mouse_frame
;
6704 f
= x_window_to_frame (dpyinfo
, event
.xbutton
.window
);
6707 if (f
&& xg_event_is_for_scrollbar (f
, &event
))
6712 /* Is this in the tool-bar? */
6713 if (WINDOWP (f
->tool_bar_window
)
6714 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
6717 int x
= event
.xbutton
.x
;
6718 int y
= event
.xbutton
.y
;
6720 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 1);
6721 tool_bar_p
= EQ (window
, f
->tool_bar_window
);
6723 if (tool_bar_p
&& event
.xbutton
.button
< 4)
6725 handle_tool_bar_click (f
, x
, y
,
6726 event
.xbutton
.type
== ButtonPress
,
6727 x_x_to_emacs_modifiers (dpyinfo
,
6728 event
.xbutton
.state
));
6733 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6734 if (! popup_activated ())
6737 if (ignore_next_mouse_click_timeout
)
6739 if (event
.type
== ButtonPress
6740 && (int)(event
.xbutton
.time
- ignore_next_mouse_click_timeout
) > 0)
6742 ignore_next_mouse_click_timeout
= 0;
6743 construct_mouse_click (&inev
.ie
, &event
.xbutton
, f
);
6745 if (event
.type
== ButtonRelease
)
6746 ignore_next_mouse_click_timeout
= 0;
6749 construct_mouse_click (&inev
.ie
, &event
.xbutton
, f
);
6751 if (FRAME_X_EMBEDDED_P (f
))
6752 xembed_send_message (f
, event
.xbutton
.time
,
6753 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
6757 struct scroll_bar
*bar
6758 = x_window_to_scroll_bar (event
.xbutton
.display
,
6759 event
.xbutton
.window
);
6761 #ifdef USE_TOOLKIT_SCROLL_BARS
6762 /* Make the "Ctrl-Mouse-2 splits window" work for toolkit
6764 if (bar
&& event
.xbutton
.state
& ControlMask
)
6766 x_scroll_bar_handle_click (bar
, &event
, &inev
.ie
);
6767 *finish
= X_EVENT_DROP
;
6769 #else /* not USE_TOOLKIT_SCROLL_BARS */
6771 x_scroll_bar_handle_click (bar
, &event
, &inev
.ie
);
6772 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6775 if (event
.type
== ButtonPress
)
6777 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
6778 last_mouse_frame
= f
;
6781 last_tool_bar_item
= -1;
6784 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
6786 /* Ignore any mouse motion that happened before this event;
6787 any subsequent mouse-movement Emacs events should reflect
6788 only motion after the ButtonPress/Release. */
6792 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6793 f
= x_menubar_window_to_frame (dpyinfo
, event
.xbutton
.window
);
6794 /* For a down-event in the menu bar,
6795 don't pass it to Xt right now.
6796 Instead, save it away
6797 and we will pass it to Xt from kbd_buffer_get_event.
6798 That way, we can run some Lisp code first. */
6801 ! popup_activated ()
6802 /* Gtk+ menus only react to the first three buttons. */
6803 && event
.xbutton
.button
< 3
6806 f
&& event
.type
== ButtonPress
6807 /* Verify the event is really within the menu bar
6808 and not just sent to it due to grabbing. */
6809 && event
.xbutton
.x
>= 0
6810 && event
.xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
6811 && event
.xbutton
.y
>= 0
6812 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
6813 && event
.xbutton
.same_screen
)
6815 SET_SAVED_BUTTON_EVENT
;
6816 XSETFRAME (last_mouse_press_frame
, f
);
6818 *finish
= X_EVENT_DROP
;
6821 else if (event
.type
== ButtonPress
)
6823 last_mouse_press_frame
= Qnil
;
6827 #ifdef USE_MOTIF /* This should do not harm for Lucid,
6828 but I am trying to be cautious. */
6829 else if (event
.type
== ButtonRelease
)
6831 if (!NILP (last_mouse_press_frame
))
6833 f
= XFRAME (last_mouse_press_frame
);
6834 if (f
->output_data
.x
)
6835 SET_SAVED_BUTTON_EVENT
;
6840 #endif /* USE_MOTIF */
6843 #endif /* USE_X_TOOLKIT || USE_GTK */
6847 case CirculateNotify
:
6850 case CirculateRequest
:
6853 case VisibilityNotify
:
6857 /* Someone has changed the keyboard mapping - update the
6859 switch (event
.xmapping
.request
)
6861 case MappingModifier
:
6862 x_find_modifier_meanings (dpyinfo
);
6863 /* This is meant to fall through. */
6864 case MappingKeyboard
:
6865 XRefreshKeyboardMapping (&event
.xmapping
);
6870 xft_settings_event (dpyinfo
, &event
);
6875 #ifdef USE_X_TOOLKIT
6877 if (*finish
!= X_EVENT_DROP
)
6878 XtDispatchEvent (&event
);
6880 #endif /* USE_X_TOOLKIT */
6885 if (inev
.ie
.kind
!= NO_EVENT
)
6887 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
6892 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
6897 XSETFRAME (frame
, f
);
6903 any_help_event_p
= 1;
6904 gen_help_event (help_echo_string
, frame
, help_echo_window
,
6905 help_echo_object
, help_echo_pos
);
6909 help_echo_string
= Qnil
;
6910 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
6920 /* Handles the XEvent EVENT on display DISPLAY.
6921 This is used for event loops outside the normal event handling,
6922 i.e. looping while a popup menu or a dialog is posted.
6924 Returns the value handle_one_xevent sets in the finish argument. */
6926 x_dispatch_event (XEvent
*event
, Display
*display
)
6928 struct x_display_info
*dpyinfo
;
6929 int finish
= X_EVENT_NORMAL
;
6931 dpyinfo
= x_display_info_for_display (display
);
6934 handle_one_xevent (dpyinfo
, event
, &finish
, 0);
6940 /* Read events coming from the X server.
6941 This routine is called by the SIGIO handler.
6942 We return as soon as there are no more events to be read.
6944 We return the number of characters stored into the buffer,
6945 thus pretending to be `read' (except the characters we store
6946 in the keyboard buffer can be multibyte, so are not necessarily
6949 EXPECTED is nonzero if the caller knows input is available. */
6952 XTread_socket (struct terminal
*terminal
, int expected
, struct input_event
*hold_quit
)
6956 int event_found
= 0;
6958 if (interrupt_input_blocked
)
6960 interrupt_input_pending
= 1;
6962 pending_signals
= 1;
6967 interrupt_input_pending
= 0;
6969 pending_signals
= pending_atimers
;
6973 /* So people can tell when we have read the available input. */
6974 input_signal_count
++;
6979 /* Only check session manager input for the primary display. */
6980 if (terminal
->id
== 1 && x_session_have_connection ())
6982 struct input_event inev
;
6984 /* We don't need to EVENT_INIT (inev) here, as
6985 x_session_check_input copies an entire input_event. */
6986 if (x_session_check_input (&inev
))
6988 kbd_buffer_store_event_hold (&inev
, hold_quit
);
6995 /* For debugging, this gives a way to fake an I/O error. */
6996 if (terminal
->display_info
.x
== XTread_socket_fake_io_error
)
6998 XTread_socket_fake_io_error
= 0;
6999 x_io_error_quitter (terminal
->display_info
.x
->display
);
7003 while (XPending (terminal
->display_info
.x
->display
))
7007 XNextEvent (terminal
->display_info
.x
->display
, &event
);
7010 /* Filter events for the current X input method. */
7011 if (x_filter_event (terminal
->display_info
.x
, &event
))
7016 count
+= handle_one_xevent (terminal
->display_info
.x
,
7017 &event
, &finish
, hold_quit
);
7019 if (finish
== X_EVENT_GOTO_OUT
)
7025 /* For GTK we must use the GTK event loop. But XEvents gets passed
7026 to our filter function above, and then to the big event switch.
7027 We use a bunch of globals to communicate with our filter function,
7028 that is kind of ugly, but it works.
7030 There is no way to do one display at the time, GTK just does events
7031 from all displays. */
7033 while (gtk_events_pending ())
7035 current_count
= count
;
7036 current_hold_quit
= hold_quit
;
7038 gtk_main_iteration ();
7040 count
= current_count
;
7042 current_hold_quit
= 0;
7044 if (current_finish
== X_EVENT_GOTO_OUT
)
7047 #endif /* USE_GTK */
7051 /* On some systems, an X bug causes Emacs to get no more events
7052 when the window is destroyed. Detect that. (1994.) */
7055 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
7056 One XNOOP in 100 loops will make Emacs terminate.
7057 B. Bretthauer, 1994 */
7059 if (x_noop_count
>= 100)
7063 if (next_noop_dpyinfo
== 0)
7064 next_noop_dpyinfo
= x_display_list
;
7066 XNoOp (next_noop_dpyinfo
->display
);
7068 /* Each time we get here, cycle through the displays now open. */
7069 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
7073 /* If the focus was just given to an auto-raising frame,
7075 /* ??? This ought to be able to handle more than one such frame. */
7076 if (pending_autoraise_frame
)
7078 x_raise_frame (pending_autoraise_frame
);
7079 pending_autoraise_frame
= 0;
7091 /***********************************************************************
7093 ***********************************************************************/
7095 /* Set clipping for output in glyph row ROW. W is the window in which
7096 we operate. GC is the graphics context to set clipping in.
7098 ROW may be a text row or, e.g., a mode line. Text rows must be
7099 clipped to the interior of the window dedicated to text display,
7100 mode lines must be clipped to the whole window. */
7103 x_clip_to_row (struct window
*w
, struct glyph_row
*row
, int area
, GC gc
)
7105 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7106 XRectangle clip_rect
;
7107 int window_x
, window_y
, window_width
;
7109 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
7111 clip_rect
.x
= window_x
;
7112 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, row
->y
));
7113 clip_rect
.y
= max (clip_rect
.y
, window_y
);
7114 clip_rect
.width
= window_width
;
7115 clip_rect
.height
= row
->visible_height
;
7117 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
7121 /* Draw a hollow box cursor on window W in glyph row ROW. */
7124 x_draw_hollow_cursor (struct window
*w
, struct glyph_row
*row
)
7126 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7127 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7128 Display
*dpy
= FRAME_X_DISPLAY (f
);
7131 struct glyph
*cursor_glyph
;
7134 /* Get the glyph the cursor is on. If we can't tell because
7135 the current matrix is invalid or such, give up. */
7136 cursor_glyph
= get_phys_cursor_glyph (w
);
7137 if (cursor_glyph
== NULL
)
7140 /* Compute frame-relative coordinates for phys cursor. */
7141 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &x
, &y
, &h
);
7142 wd
= w
->phys_cursor_width
;
7144 /* The foreground of cursor_gc is typically the same as the normal
7145 background color, which can cause the cursor box to be invisible. */
7146 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7147 if (dpyinfo
->scratch_cursor_gc
)
7148 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
7150 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
7151 GCForeground
, &xgcv
);
7152 gc
= dpyinfo
->scratch_cursor_gc
;
7154 /* Set clipping, draw the rectangle, and reset clipping again. */
7155 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7156 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
- 1);
7157 XSetClipMask (dpy
, gc
, None
);
7161 /* Draw a bar cursor on window W in glyph row ROW.
7163 Implementation note: One would like to draw a bar cursor with an
7164 angle equal to the one given by the font property XA_ITALIC_ANGLE.
7165 Unfortunately, I didn't find a font yet that has this property set.
7169 x_draw_bar_cursor (struct window
*w
, struct glyph_row
*row
, int width
, enum text_cursor_kinds kind
)
7171 struct frame
*f
= XFRAME (w
->frame
);
7172 struct glyph
*cursor_glyph
;
7174 /* If cursor is out of bounds, don't draw garbage. This can happen
7175 in mini-buffer windows when switching between echo area glyphs
7177 cursor_glyph
= get_phys_cursor_glyph (w
);
7178 if (cursor_glyph
== NULL
)
7181 /* If on an image, draw like a normal cursor. That's usually better
7182 visible than drawing a bar, esp. if the image is large so that
7183 the bar might not be in the window. */
7184 if (cursor_glyph
->type
== IMAGE_GLYPH
)
7186 struct glyph_row
*row
;
7187 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
7188 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
7192 Display
*dpy
= FRAME_X_DISPLAY (f
);
7193 Window window
= FRAME_X_WINDOW (f
);
7194 GC gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
7195 unsigned long mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
7196 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
7199 /* If the glyph's background equals the color we normally draw
7200 the bars cursor in, the bar cursor in its normal color is
7201 invisible. Use the glyph's foreground color instead in this
7202 case, on the assumption that the glyph's colors are chosen so
7203 that the glyph is legible. */
7204 if (face
->background
== f
->output_data
.x
->cursor_pixel
)
7205 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
7207 xgcv
.background
= xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7208 xgcv
.graphics_exposures
= 0;
7211 XChangeGC (dpy
, gc
, mask
, &xgcv
);
7214 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
7215 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
7218 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7220 if (kind
== BAR_CURSOR
)
7223 width
= FRAME_CURSOR_WIDTH (f
);
7224 width
= min (cursor_glyph
->pixel_width
, width
);
7226 w
->phys_cursor_width
= width
;
7228 XFillRectangle (dpy
, window
, gc
,
7229 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
7230 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
7231 width
, row
->height
);
7235 int dummy_x
, dummy_y
, dummy_h
;
7238 width
= row
->height
;
7240 width
= min (row
->height
, width
);
7242 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &dummy_x
,
7243 &dummy_y
, &dummy_h
);
7245 XFillRectangle (dpy
, window
, gc
,
7246 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
7247 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
7248 row
->height
- width
),
7249 w
->phys_cursor_width
, width
);
7252 XSetClipMask (dpy
, gc
, None
);
7257 /* RIF: Define cursor CURSOR on frame F. */
7260 x_define_frame_cursor (struct frame
*f
, Cursor cursor
)
7262 if (!f
->pointer_invisible
7263 && f
->output_data
.x
->current_cursor
!= cursor
)
7264 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
7265 f
->output_data
.x
->current_cursor
= cursor
;
7269 /* RIF: Clear area on frame F. */
7272 x_clear_frame_area (struct frame
*f
, int x
, int y
, int width
, int height
)
7274 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7275 x
, y
, width
, height
, False
);
7277 /* Must queue a redraw, because scroll bars might have been cleared. */
7278 if (FRAME_GTK_WIDGET (f
))
7279 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
7284 /* RIF: Draw cursor on window W. */
7287 x_draw_window_cursor (struct window
*w
, struct glyph_row
*glyph_row
, int x
, int y
, int cursor_type
, int cursor_width
, int on_p
, int active_p
)
7289 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7293 w
->phys_cursor_type
= cursor_type
;
7294 w
->phys_cursor_on_p
= 1;
7296 if (glyph_row
->exact_window_width_line_p
7297 && (glyph_row
->reversed_p
7298 ? (w
->phys_cursor
.hpos
< 0)
7299 : (w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])))
7301 glyph_row
->cursor_in_fringe_p
= 1;
7302 draw_fringe_bitmap (w
, glyph_row
, glyph_row
->reversed_p
);
7306 switch (cursor_type
)
7308 case HOLLOW_BOX_CURSOR
:
7309 x_draw_hollow_cursor (w
, glyph_row
);
7312 case FILLED_BOX_CURSOR
:
7313 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
7317 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
7321 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
7325 w
->phys_cursor_width
= 0;
7334 if (w
== XWINDOW (f
->selected_window
))
7335 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
7336 xic_set_preeditarea (w
, x
, y
);
7341 XFlush (FRAME_X_DISPLAY (f
));
7348 /* Make the x-window of frame F use the gnu icon bitmap. */
7351 x_bitmap_icon (struct frame
*f
, Lisp_Object file
)
7355 if (FRAME_X_WINDOW (f
) == 0)
7358 /* Free up our existing icon bitmap and mask if any. */
7359 if (f
->output_data
.x
->icon_bitmap
> 0)
7360 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7361 f
->output_data
.x
->icon_bitmap
= 0;
7366 /* Use gtk_window_set_icon_from_file () if available,
7367 It's not restricted to bitmaps */
7368 if (xg_set_icon (f
, file
))
7370 #endif /* USE_GTK */
7371 bitmap_id
= x_create_bitmap_from_file (f
, file
);
7372 x_create_bitmap_mask (f
, bitmap_id
);
7376 /* Create the GNU bitmap and mask if necessary. */
7377 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
7383 if (xg_set_icon (f
, xg_default_icon_file
)
7384 || xg_set_icon_from_xpm_data (f
, gnu_xpm_bits
))
7387 #elif defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
7389 rc
= x_create_bitmap_from_xpm_data (f
, gnu_xpm_bits
);
7391 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
7395 /* If all else fails, use the (black and white) xbm image. */
7398 rc
= x_create_bitmap_from_data (f
, gnu_xbm_bits
,
7399 gnu_xbm_width
, gnu_xbm_height
);
7403 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
7404 x_create_bitmap_mask (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
7408 /* The first time we create the GNU bitmap and mask,
7409 this increments the ref-count one extra time.
7410 As a result, the GNU bitmap and mask are never freed.
7411 That way, we don't have to worry about allocating it again. */
7412 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
7414 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
7417 x_wm_set_icon_pixmap (f
, bitmap_id
);
7418 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
7424 /* Make the x-window of frame F use a rectangle with text.
7425 Use ICON_NAME as the text. */
7428 x_text_icon (struct frame
*f
, char *icon_name
)
7430 if (FRAME_X_WINDOW (f
) == 0)
7435 text
.value
= (unsigned char *) icon_name
;
7436 text
.encoding
= XA_STRING
;
7438 text
.nitems
= strlen (icon_name
);
7439 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
7442 if (f
->output_data
.x
->icon_bitmap
> 0)
7443 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7444 f
->output_data
.x
->icon_bitmap
= 0;
7445 x_wm_set_icon_pixmap (f
, 0);
7450 #define X_ERROR_MESSAGE_SIZE 200
7452 /* If non-nil, this should be a string.
7453 It means catch X errors and store the error message in this string.
7455 The reason we use a stack is that x_catch_error/x_uncatch_error can
7456 be called from a signal handler.
7459 struct x_error_message_stack
{
7460 char string
[X_ERROR_MESSAGE_SIZE
];
7462 struct x_error_message_stack
*prev
;
7464 static struct x_error_message_stack
*x_error_message
;
7466 /* An X error handler which stores the error message in
7467 *x_error_message. This is called from x_error_handler if
7468 x_catch_errors is in effect. */
7471 x_error_catcher (Display
*display
, XErrorEvent
*error
)
7473 XGetErrorText (display
, error
->error_code
,
7474 x_error_message
->string
,
7475 X_ERROR_MESSAGE_SIZE
);
7478 /* Begin trapping X errors for display DPY. Actually we trap X errors
7479 for all displays, but DPY should be the display you are actually
7482 After calling this function, X protocol errors no longer cause
7483 Emacs to exit; instead, they are recorded in the string
7484 stored in *x_error_message.
7486 Calling x_check_errors signals an Emacs error if an X error has
7487 occurred since the last call to x_catch_errors or x_check_errors.
7489 Calling x_uncatch_errors resumes the normal error handling. */
7491 void x_check_errors (Display
*dpy
, char *format
);
7494 x_catch_errors (Display
*dpy
)
7496 struct x_error_message_stack
*data
= xmalloc (sizeof (*data
));
7498 /* Make sure any errors from previous requests have been dealt with. */
7502 data
->string
[0] = 0;
7503 data
->prev
= x_error_message
;
7504 x_error_message
= data
;
7507 /* Undo the last x_catch_errors call.
7508 DPY should be the display that was passed to x_catch_errors. */
7511 x_uncatch_errors (void)
7513 struct x_error_message_stack
*tmp
;
7517 /* The display may have been closed before this function is called.
7518 Check if it is still open before calling XSync. */
7519 if (x_display_info_for_display (x_error_message
->dpy
) != 0)
7520 XSync (x_error_message
->dpy
, False
);
7522 tmp
= x_error_message
;
7523 x_error_message
= x_error_message
->prev
;
7528 /* If any X protocol errors have arrived since the last call to
7529 x_catch_errors or x_check_errors, signal an Emacs error using
7530 sprintf (a buffer, FORMAT, the x error message text) as the text. */
7533 x_check_errors (Display
*dpy
, char *format
)
7535 /* Make sure to catch any errors incurred so far. */
7538 if (x_error_message
->string
[0])
7540 char string
[X_ERROR_MESSAGE_SIZE
];
7541 memcpy (string
, x_error_message
->string
, X_ERROR_MESSAGE_SIZE
);
7542 x_uncatch_errors ();
7543 error (format
, string
);
7547 /* Nonzero if we had any X protocol errors
7548 since we did x_catch_errors on DPY. */
7551 x_had_errors_p (Display
*dpy
)
7553 /* Make sure to catch any errors incurred so far. */
7556 return x_error_message
->string
[0] != 0;
7559 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
7562 x_clear_errors (Display
*dpy
)
7564 x_error_message
->string
[0] = 0;
7567 #if 0 /* See comment in unwind_to_catch why calling this is a bad
7568 * idea. --lorentey */
7569 /* Close off all unclosed x_catch_errors calls. */
7572 x_fully_uncatch_errors ()
7574 while (x_error_message
)
7575 x_uncatch_errors ();
7579 /* Nonzero if x_catch_errors has been done and not yet canceled. */
7582 x_catching_errors (void)
7584 return x_error_message
!= 0;
7588 static unsigned int x_wire_count
;
7591 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
7596 /* Handle SIGPIPE, which can happen when the connection to a server
7597 simply goes away. SIGPIPE is handled by x_connection_signal.
7598 Don't need to do anything, because the write which caused the
7599 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
7600 which will do the appropriate cleanup for us. */
7603 x_connection_signal (int signalnum
) /* If we don't have an argument, */
7604 /* some compilers complain in signal calls. */
7607 /* USG systems forget handlers when they are used;
7608 must reestablish each time */
7609 signal (signalnum
, x_connection_signal
);
7614 /************************************************************************
7616 ************************************************************************/
7618 /* Error message passed to x_connection_closed. */
7620 static char *error_msg
;
7622 /* Function installed as fatal_error_signal_hook in
7623 x_connection_closed. Print the X error message, and exit normally,
7624 instead of dumping core when XtCloseDisplay fails. */
7627 x_fatal_error_signal (void)
7629 fprintf (stderr
, "%s\n", error_msg
);
7633 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
7634 the text of an error message that lead to the connection loss. */
7637 x_connection_closed (Display
*dpy
, char *error_message
)
7639 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
7640 Lisp_Object frame
, tail
;
7641 int index
= SPECPDL_INDEX ();
7643 error_msg
= (char *) alloca (strlen (error_message
) + 1);
7644 strcpy (error_msg
, error_message
);
7645 handling_signal
= 0;
7647 /* Prevent being called recursively because of an error condition
7648 below. Otherwise, we might end up with printing ``can't find per
7649 display information'' in the recursive call instead of printing
7650 the original message here. */
7651 x_catch_errors (dpy
);
7653 /* Inhibit redisplay while frames are being deleted. */
7654 specbind (Qinhibit_redisplay
, Qt
);
7658 /* Protect display from being closed when we delete the last
7660 dpyinfo
->reference_count
++;
7661 dpyinfo
->terminal
->reference_count
++;
7664 /* First delete frames whose mini-buffers are on frames
7665 that are on the dead display. */
7666 FOR_EACH_FRAME (tail
, frame
)
7668 Lisp_Object minibuf_frame
;
7670 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
7671 if (FRAME_X_P (XFRAME (frame
))
7672 && FRAME_X_P (XFRAME (minibuf_frame
))
7673 && ! EQ (frame
, minibuf_frame
)
7674 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
7675 delete_frame (frame
, Qnoelisp
);
7678 /* Now delete all remaining frames on the dead display.
7679 We are now sure none of these is used as the mini-buffer
7680 for another frame that we need to delete. */
7681 FOR_EACH_FRAME (tail
, frame
)
7682 if (FRAME_X_P (XFRAME (frame
))
7683 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
7685 /* Set this to t so that delete_frame won't get confused
7686 trying to find a replacement. */
7687 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
7688 delete_frame (frame
, Qnoelisp
);
7691 /* We have to close the display to inform Xt that it doesn't
7692 exist anymore. If we don't, Xt will continue to wait for
7693 events from the display. As a consequence, a sequence of
7695 M-x make-frame-on-display RET :1 RET
7696 ...kill the new frame, so that we get an IO error...
7697 M-x make-frame-on-display RET :1 RET
7699 will indefinitely wait in Xt for events for display `:1', opened
7700 in the first call to make-frame-on-display.
7702 Closing the display is reported to lead to a bus error on
7703 OpenWindows in certain situations. I suspect that is a bug
7704 in OpenWindows. I don't know how to circumvent it here. */
7708 #ifdef USE_X_TOOLKIT
7709 /* If DPYINFO is null, this means we didn't open the display
7710 in the first place, so don't try to close it. */
7712 extern void (*fatal_error_signal_hook
) (void);
7713 fatal_error_signal_hook
= x_fatal_error_signal
;
7714 XtCloseDisplay (dpy
);
7715 fatal_error_signal_hook
= NULL
;
7720 /* Due to bugs in some Gtk+ versions, just exit here if this
7721 is the last display/terminal. */
7722 if (terminal_list
->next_terminal
== NULL
)
7724 fprintf (stderr
, "%s\n", error_msg
);
7725 Fkill_emacs (make_number (70));
7728 xg_display_close (dpyinfo
->display
);
7731 /* Indicate that this display is dead. */
7732 dpyinfo
->display
= 0;
7734 dpyinfo
->reference_count
--;
7735 dpyinfo
->terminal
->reference_count
--;
7736 if (dpyinfo
->reference_count
!= 0)
7737 /* We have just closed all frames on this display. */
7742 XSETTERMINAL (tmp
, dpyinfo
->terminal
);
7743 Fdelete_terminal (tmp
, Qnoelisp
);
7747 x_uncatch_errors ();
7749 if (terminal_list
== 0)
7751 fprintf (stderr
, "%s\n", error_msg
);
7752 Fkill_emacs (make_number (70));
7756 /* Ordinary stack unwind doesn't deal with these. */
7758 sigunblock (sigmask (SIGIO
));
7760 sigunblock (sigmask (SIGALRM
));
7761 TOTALLY_UNBLOCK_INPUT
;
7763 unbind_to (index
, Qnil
);
7764 clear_waiting_for_input ();
7765 /* Here, we absolutely have to use a non-local exit (e.g. signal, throw,
7766 longjmp), because returning from this function would get us back into
7767 Xlib's code which will directly call `exit'. */
7768 error ("%s", error_msg
);
7771 /* We specifically use it before defining it, so that gcc doesn't inline it,
7772 otherwise gdb doesn't know how to properly put a breakpoint on it. */
7773 static void x_error_quitter (Display
*, XErrorEvent
*);
7775 /* This is the first-level handler for X protocol errors.
7776 It calls x_error_quitter or x_error_catcher. */
7779 x_error_handler (Display
*display
, XErrorEvent
*error
)
7781 if (x_error_message
)
7782 x_error_catcher (display
, error
);
7784 x_error_quitter (display
, error
);
7788 /* This is the usual handler for X protocol errors.
7789 It kills all frames on the display that we got the error for.
7790 If that was the only one, it prints an error message and kills Emacs. */
7792 /* .gdbinit puts a breakpoint here, so make sure it is not inlined. */
7794 #if __GNUC__ >= 3 /* On GCC 3.0 we might get a warning. */
7795 #define NO_INLINE __attribute__((noinline))
7800 /* Some versions of GNU/Linux define noinline in their headers. */
7806 /* On older GCC versions, just putting x_error_quitter
7807 after x_error_handler prevents inlining into the former. */
7809 static void NO_INLINE
7810 x_error_quitter (Display
*display
, XErrorEvent
*error
)
7812 char buf
[256], buf1
[356];
7814 /* Ignore BadName errors. They can happen because of fonts
7815 or colors that are not defined. */
7817 if (error
->error_code
== BadName
)
7820 /* Note that there is no real way portable across R3/R4 to get the
7821 original error handler. */
7823 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
7824 sprintf (buf1
, "X protocol error: %s on protocol request %d",
7825 buf
, error
->request_code
);
7826 x_connection_closed (display
, buf1
);
7830 /* This is the handler for X IO errors, always.
7831 It kills all frames on the display that we lost touch with.
7832 If that was the only one, it prints an error message and kills Emacs. */
7835 x_io_error_quitter (Display
*display
)
7839 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
7840 x_connection_closed (display
, buf
);
7844 /* Changing the font of the frame. */
7846 /* Give frame F the font FONT-OBJECT as its default font. The return
7847 value is FONT-OBJECT. FONTSET is an ID of the fontset for the
7848 frame. If it is negative, generate a new fontset from
7852 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
7854 struct font
*font
= XFONT_OBJECT (font_object
);
7857 fontset
= fontset_from_font (font_object
);
7858 FRAME_FONTSET (f
) = fontset
;
7859 if (FRAME_FONT (f
) == font
)
7860 /* This font is already set in frame F. There's nothing more to
7864 FRAME_FONT (f
) = font
;
7865 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
7866 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
7867 FRAME_SPACE_WIDTH (f
) = font
->space_width
;
7868 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (font
);
7870 compute_fringe_widths (f
, 1);
7872 /* Compute the scroll bar width in character columns. */
7873 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
7875 int wid
= FRAME_COLUMN_WIDTH (f
);
7876 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
7877 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
-1) / wid
;
7881 int wid
= FRAME_COLUMN_WIDTH (f
);
7882 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
7885 if (FRAME_X_WINDOW (f
) != 0)
7887 /* Don't change the size of a tip frame; there's no point in
7888 doing it because it's done in Fx_show_tip, and it leads to
7889 problems because the tip frame has no widget. */
7890 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
7891 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
7896 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
7899 xic_set_xfontset (f
, SDATA (fontset_ascii (fontset
)));
7908 /***********************************************************************
7910 ***********************************************************************/
7916 /* XIM destroy callback function, which is called whenever the
7917 connection to input method XIM dies. CLIENT_DATA contains a
7918 pointer to the x_display_info structure corresponding to XIM. */
7921 xim_destroy_callback (XIM xim
, XPointer client_data
, XPointer call_data
)
7923 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
7924 Lisp_Object frame
, tail
;
7928 /* No need to call XDestroyIC.. */
7929 FOR_EACH_FRAME (tail
, frame
)
7931 struct frame
*f
= XFRAME (frame
);
7932 if (FRAME_X_P (f
) && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
7934 FRAME_XIC (f
) = NULL
;
7935 xic_free_xfontset (f
);
7939 /* No need to call XCloseIM. */
7940 dpyinfo
->xim
= NULL
;
7941 XFree (dpyinfo
->xim_styles
);
7945 #endif /* HAVE_X11R6 */
7948 /* This isn't prototyped in OSF 5.0 or 5.1a. */
7949 extern char *XSetIMValues (XIM
, ...);
7952 /* Open the connection to the XIM server on display DPYINFO.
7953 RESOURCE_NAME is the resource name Emacs uses. */
7956 xim_open_dpy (struct x_display_info
*dpyinfo
, char *resource_name
)
7964 XCloseIM (dpyinfo
->xim
);
7965 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
,
7972 XIMCallback destroy
;
7975 /* Get supported styles and XIM values. */
7976 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
7979 destroy
.callback
= xim_destroy_callback
;
7980 destroy
.client_data
= (XPointer
)dpyinfo
;
7981 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
7987 #endif /* HAVE_XIM */
7988 dpyinfo
->xim
= NULL
;
7992 #ifdef HAVE_X11R6_XIM
7994 /* XIM instantiate callback function, which is called whenever an XIM
7995 server is available. DISPLAY is the display of the XIM.
7996 CLIENT_DATA contains a pointer to an xim_inst_t structure created
7997 when the callback was registered. */
8000 xim_instantiate_callback (Display
*display
, XPointer client_data
, XPointer call_data
)
8002 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
8003 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
8005 /* We don't support multiple XIM connections. */
8009 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
8011 /* Create XIC for the existing frames on the same display, as long
8012 as they have no XIC. */
8013 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
8015 Lisp_Object tail
, frame
;
8018 FOR_EACH_FRAME (tail
, frame
)
8020 struct frame
*f
= XFRAME (frame
);
8023 && FRAME_X_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
8024 if (FRAME_XIC (f
) == NULL
)
8026 create_frame_xic (f
);
8027 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
8028 xic_set_statusarea (f
);
8029 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
8031 struct window
*w
= XWINDOW (f
->selected_window
);
8032 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
8041 #endif /* HAVE_X11R6_XIM */
8044 /* Open a connection to the XIM server on display DPYINFO.
8045 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
8046 connection only at the first time. On X11R6, open the connection
8047 in the XIM instantiate callback function. */
8050 xim_initialize (struct x_display_info
*dpyinfo
, char *resource_name
)
8052 dpyinfo
->xim
= NULL
;
8056 #ifdef HAVE_X11R6_XIM
8057 struct xim_inst_t
*xim_inst
;
8060 xim_inst
= (struct xim_inst_t
*) xmalloc (sizeof (struct xim_inst_t
));
8061 dpyinfo
->xim_callback_data
= xim_inst
;
8062 xim_inst
->dpyinfo
= dpyinfo
;
8063 len
= strlen (resource_name
);
8064 xim_inst
->resource_name
= (char *) xmalloc (len
+ 1);
8065 memcpy (xim_inst
->resource_name
, resource_name
, len
+ 1);
8066 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8067 resource_name
, EMACS_CLASS
,
8068 xim_instantiate_callback
,
8069 /* This is XPointer in XFree86
8070 but (XPointer *) on Tru64, at
8071 least, hence the configure test. */
8072 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
8073 #else /* not HAVE_X11R6_XIM */
8074 xim_open_dpy (dpyinfo
, resource_name
);
8075 #endif /* not HAVE_X11R6_XIM */
8077 #endif /* HAVE_XIM */
8081 /* Close the connection to the XIM server on display DPYINFO. */
8084 xim_close_dpy (struct x_display_info
*dpyinfo
)
8089 #ifdef HAVE_X11R6_XIM
8090 if (dpyinfo
->display
)
8091 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8093 xim_instantiate_callback
, NULL
);
8094 xfree (dpyinfo
->xim_callback_data
->resource_name
);
8095 xfree (dpyinfo
->xim_callback_data
);
8096 #endif /* HAVE_X11R6_XIM */
8097 if (dpyinfo
->display
)
8098 XCloseIM (dpyinfo
->xim
);
8099 dpyinfo
->xim
= NULL
;
8100 XFree (dpyinfo
->xim_styles
);
8102 #endif /* HAVE_XIM */
8105 #endif /* not HAVE_X11R6_XIM */
8109 /* Calculate the absolute position in frame F
8110 from its current recorded position values and gravity. */
8113 x_calc_absolute_position (struct frame
*f
)
8115 int flags
= f
->size_hint_flags
;
8117 /* We have nothing to do if the current position
8118 is already for the top-left corner. */
8119 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
8122 /* Treat negative positions as relative to the leftmost bottommost
8123 position that fits on the screen. */
8124 if (flags
& XNegative
)
8125 f
->left_pos
= x_display_pixel_width (FRAME_X_DISPLAY_INFO (f
))
8126 - FRAME_PIXEL_WIDTH (f
) + f
->left_pos
;
8129 int height
= FRAME_PIXEL_HEIGHT (f
);
8131 #if defined USE_X_TOOLKIT && defined USE_MOTIF
8132 /* Something is fishy here. When using Motif, starting Emacs with
8133 `-g -0-0', the frame appears too low by a few pixels.
8135 This seems to be so because initially, while Emacs is starting,
8136 the column widget's height and the frame's pixel height are
8137 different. The column widget's height is the right one. In
8138 later invocations, when Emacs is up, the frame's pixel height
8141 It's not obvious where the initial small difference comes from.
8142 2000-12-01, gerd. */
8144 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
8147 if (flags
& YNegative
)
8148 f
->top_pos
= x_display_pixel_height (FRAME_X_DISPLAY_INFO (f
))
8149 - height
+ f
->top_pos
;
8152 /* The left_pos and top_pos
8153 are now relative to the top and left screen edges,
8154 so the flags should correspond. */
8155 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8158 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
8159 to really change the position, and 0 when calling from
8160 x_make_frame_visible (in that case, XOFF and YOFF are the current
8161 position values). It is -1 when calling from x_set_frame_parameters,
8162 which means, do adjust for borders but don't change the gravity. */
8165 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
, int change_gravity
)
8167 int modified_top
, modified_left
;
8169 if (change_gravity
> 0)
8171 FRAME_X_OUTPUT (f
)->left_before_move
= f
->left_pos
;
8172 FRAME_X_OUTPUT (f
)->top_before_move
= f
->top_pos
;
8176 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8178 f
->size_hint_flags
|= XNegative
;
8180 f
->size_hint_flags
|= YNegative
;
8181 f
->win_gravity
= NorthWestGravity
;
8183 x_calc_absolute_position (f
);
8186 x_wm_set_size_hint (f
, (long) 0, 0);
8188 modified_left
= f
->left_pos
;
8189 modified_top
= f
->top_pos
;
8191 if (change_gravity
!= 0 && FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
)
8193 /* Some WMs (twm, wmaker at least) has an offset that is smaller
8194 than the WM decorations. So we use the calculated offset instead
8195 of the WM decoration sizes here (x/y_pixels_outer_diff). */
8196 modified_left
+= FRAME_X_OUTPUT (f
)->move_offset_left
;
8197 modified_top
+= FRAME_X_OUTPUT (f
)->move_offset_top
;
8200 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8201 modified_left
, modified_top
);
8203 x_sync_with_move (f
, f
->left_pos
, f
->top_pos
,
8204 FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8207 /* change_gravity is non-zero when this function is called from Lisp to
8208 programmatically move a frame. In that case, we call
8209 x_check_expected_move to discover if we have a "Type A" or "Type B"
8210 window manager, and, for a "Type A" window manager, adjust the position
8213 We call x_check_expected_move if a programmatic move occurred, and
8214 either the window manager type (A/B) is unknown or it is Type A but we
8215 need to compute the top/left offset adjustment for this frame. */
8217 if (change_gravity
!= 0 &&
8218 (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8219 || (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
8220 && (FRAME_X_OUTPUT (f
)->move_offset_left
== 0
8221 && FRAME_X_OUTPUT (f
)->move_offset_top
== 0))))
8222 x_check_expected_move (f
, modified_left
, modified_top
);
8227 /* Return non-zero if _NET_SUPPORTING_WM_CHECK window exists and _NET_SUPPORTED
8228 on the root window for frame F contains ATOMNAME.
8229 This is how a WM check shall be done according to the Window Manager
8230 Specification/Extended Window Manager Hints at
8231 http://freedesktop.org/wiki/Specifications/wm-spec. */
8234 wm_supports (struct frame
*f
, const char *atomname
)
8237 unsigned long actual_size
, bytes_remaining
;
8238 int i
, rc
, actual_format
;
8240 Window wmcheck_window
;
8241 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8242 Window target_window
= dpyinfo
->root_window
;
8243 long max_len
= 65536;
8244 Display
*dpy
= FRAME_X_DISPLAY (f
);
8245 unsigned char *tmp_data
= NULL
;
8246 Atom target_type
= XA_WINDOW
;
8251 prop_atom
= XInternAtom (dpy
, "_NET_SUPPORTING_WM_CHECK", False
);
8253 x_catch_errors (dpy
);
8254 rc
= XGetWindowProperty (dpy
, target_window
,
8255 prop_atom
, 0, max_len
, False
, target_type
,
8256 &actual_type
, &actual_format
, &actual_size
,
8257 &bytes_remaining
, &tmp_data
);
8259 if (rc
!= Success
|| actual_type
!= XA_WINDOW
|| x_had_errors_p (dpy
))
8261 if (tmp_data
) XFree (tmp_data
);
8262 x_uncatch_errors ();
8267 wmcheck_window
= *(Window
*) tmp_data
;
8270 /* Check if window exists. */
8271 XSelectInput (dpy
, wmcheck_window
, StructureNotifyMask
);
8273 if (x_had_errors_p (dpy
))
8275 x_uncatch_errors ();
8280 if (dpyinfo
->net_supported_window
!= wmcheck_window
)
8282 /* Window changed, reload atoms */
8283 if (dpyinfo
->net_supported_atoms
!= NULL
)
8284 XFree (dpyinfo
->net_supported_atoms
);
8285 dpyinfo
->net_supported_atoms
= NULL
;
8286 dpyinfo
->nr_net_supported_atoms
= 0;
8287 dpyinfo
->net_supported_window
= 0;
8289 target_type
= XA_ATOM
;
8290 prop_atom
= XInternAtom (dpy
, "_NET_SUPPORTED", False
);
8292 rc
= XGetWindowProperty (dpy
, target_window
,
8293 prop_atom
, 0, max_len
, False
, target_type
,
8294 &actual_type
, &actual_format
, &actual_size
,
8295 &bytes_remaining
, &tmp_data
);
8297 if (rc
!= Success
|| actual_type
!= XA_ATOM
|| x_had_errors_p (dpy
))
8299 if (tmp_data
) XFree (tmp_data
);
8300 x_uncatch_errors ();
8305 dpyinfo
->net_supported_atoms
= (Atom
*)tmp_data
;
8306 dpyinfo
->nr_net_supported_atoms
= actual_size
;
8307 dpyinfo
->net_supported_window
= wmcheck_window
;
8311 want_atom
= XInternAtom (dpy
, atomname
, False
);
8313 for (i
= 0; rc
== 0 && i
< dpyinfo
->nr_net_supported_atoms
; ++i
)
8314 rc
= dpyinfo
->net_supported_atoms
[i
] == want_atom
;
8316 x_uncatch_errors ();
8323 set_wm_state (Lisp_Object frame
, int add
, const char *what
, const char *what2
)
8325 const char *atom
= "_NET_WM_STATE";
8326 Fx_send_client_event (frame
, make_number (0), frame
,
8327 make_unibyte_string (atom
, strlen (atom
)),
8329 /* 1 = add, 0 = remove */
8331 (make_number (add
? 1 : 0),
8333 (make_unibyte_string (what
, strlen (what
)),
8335 ? Fcons (make_unibyte_string (what2
, strlen (what2
)),
8341 x_set_sticky (struct frame
*f
, Lisp_Object new_value
, Lisp_Object old_value
)
8345 XSETFRAME (frame
, f
);
8346 set_wm_state (frame
, NILP (new_value
) ? 0 : 1,
8347 "_NET_WM_STATE_STICKY", NULL
);
8350 /* Do fullscreen as specified in extended window manager hints */
8353 do_ewmh_fullscreen (struct frame
*f
)
8355 int have_net_atom
= wm_supports (f
, "_NET_WM_STATE");
8357 /* Some window managers don't say they support _NET_WM_STATE, but they do say
8358 they support _NET_WM_STATE_FULLSCREEN. Try that also. */
8360 have_net_atom
= wm_supports (f
, "_NET_WM_STATE_FULLSCREEN");
8365 const char *fs
= "_NET_WM_STATE_FULLSCREEN";
8366 const char *fw
= "_NET_WM_STATE_MAXIMIZED_HORZ";
8367 const char *fh
= "_NET_WM_STATE_MAXIMIZED_VERT";
8369 XSETFRAME (frame
, f
);
8371 set_wm_state (frame
, 0, fs
, NULL
);
8372 set_wm_state (frame
, 0, fh
, NULL
);
8373 set_wm_state (frame
, 0, fw
, NULL
);
8375 /* If there are _NET_ atoms we assume we have extended window manager
8377 switch (f
->want_fullscreen
)
8379 case FULLSCREEN_BOTH
:
8380 set_wm_state (frame
, 1, fs
, NULL
);
8382 case FULLSCREEN_WIDTH
:
8383 set_wm_state (frame
, 1, fw
, NULL
);
8385 case FULLSCREEN_HEIGHT
:
8386 set_wm_state (frame
, 1, fh
, NULL
);
8388 case FULLSCREEN_MAXIMIZED
:
8389 set_wm_state (frame
, 1, fw
, fh
);
8393 f
->want_fullscreen
= FULLSCREEN_NONE
;
8397 return have_net_atom
;
8401 XTfullscreen_hook (FRAME_PTR f
)
8403 if (f
->async_visible
)
8406 x_check_fullscreen (f
);
8414 x_handle_net_wm_state (struct frame
*f
, XPropertyEvent
*event
)
8417 unsigned long actual_size
, bytes_remaining
;
8418 int i
, rc
, actual_format
, value
= FULLSCREEN_NONE
;
8419 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8420 long max_len
= 65536;
8421 Display
*dpy
= FRAME_X_DISPLAY (f
);
8422 unsigned char *tmp_data
= NULL
;
8423 Atom target_type
= XA_ATOM
;
8428 x_catch_errors (dpy
);
8429 rc
= XGetWindowProperty (dpy
, event
->window
,
8430 event
->atom
, 0, max_len
, False
, target_type
,
8431 &actual_type
, &actual_format
, &actual_size
,
8432 &bytes_remaining
, &tmp_data
);
8434 if (rc
!= Success
|| actual_type
!= target_type
|| x_had_errors_p (dpy
))
8436 if (tmp_data
) XFree (tmp_data
);
8437 x_uncatch_errors ();
8442 x_uncatch_errors ();
8444 for (i
= 0; i
< actual_size
; ++i
)
8446 Atom a
= ((Atom
*)tmp_data
)[i
];
8447 if (a
== dpyinfo
->Xatom_net_wm_state_maximized_horz
)
8449 if (value
== FULLSCREEN_HEIGHT
)
8450 value
= FULLSCREEN_MAXIMIZED
;
8452 value
= FULLSCREEN_WIDTH
;
8454 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_vert
)
8456 if (value
== FULLSCREEN_WIDTH
)
8457 value
= FULLSCREEN_MAXIMIZED
;
8459 value
= FULLSCREEN_HEIGHT
;
8461 else if (a
== dpyinfo
->Xatom_net_wm_state_fullscreen_atom
)
8462 value
= FULLSCREEN_BOTH
;
8463 else if (a
== dpyinfo
->Xatom_net_wm_state_sticky
)
8470 case FULLSCREEN_WIDTH
:
8473 case FULLSCREEN_HEIGHT
:
8476 case FULLSCREEN_BOTH
:
8479 case FULLSCREEN_MAXIMIZED
:
8484 store_frame_param (f
, Qfullscreen
, lval
);
8485 store_frame_param (f
, Qsticky
, sticky
? Qt
: Qnil
);
8487 if (tmp_data
) XFree (tmp_data
);
8491 /* Check if we need to resize the frame due to a fullscreen request.
8492 If so needed, resize the frame. */
8494 x_check_fullscreen (struct frame
*f
)
8496 if (do_ewmh_fullscreen (f
))
8499 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
8500 return; /* Only fullscreen without WM or with EWM hints (above). */
8502 if (f
->want_fullscreen
!= FULLSCREEN_NONE
)
8504 int width
= FRAME_COLS (f
), height
= FRAME_LINES (f
);
8505 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8507 switch (f
->want_fullscreen
)
8509 /* No difference between these two when there is no WM */
8510 case FULLSCREEN_BOTH
:
8511 case FULLSCREEN_MAXIMIZED
:
8512 width
= x_display_pixel_width (dpyinfo
);
8513 height
= x_display_pixel_height (dpyinfo
);
8515 case FULLSCREEN_WIDTH
:
8516 width
= x_display_pixel_width (dpyinfo
);
8518 case FULLSCREEN_HEIGHT
:
8519 height
= x_display_pixel_height (dpyinfo
);
8522 if (FRAME_COLS (f
) != width
|| FRAME_LINES (f
) != height
)
8524 change_frame_size (f
, height
, width
, 0, 1, 0);
8525 SET_FRAME_GARBAGED (f
);
8526 cancel_mouse_face (f
);
8531 /* This function is called by x_set_offset to determine whether the window
8532 manager interfered with the positioning of the frame. Type A window
8533 managers position the surrounding window manager decorations a small
8534 amount above and left of the user-supplied position. Type B window
8535 managers position the surrounding window manager decorations at the
8536 user-specified position. If we detect a Type A window manager, we
8537 compensate by moving the window right and down by the proper amount. */
8540 x_check_expected_move (struct frame
*f
, int expected_left
, int expected_top
)
8542 int current_left
= 0, current_top
= 0;
8544 /* x_real_positions returns the left and top offsets of the outermost
8545 window manager window around the frame. */
8547 x_real_positions (f
, ¤t_left
, ¤t_top
);
8549 if (current_left
!= expected_left
|| current_top
!= expected_top
)
8551 /* It's a "Type A" window manager. */
8556 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_A
;
8557 FRAME_X_OUTPUT (f
)->move_offset_left
= expected_left
- current_left
;
8558 FRAME_X_OUTPUT (f
)->move_offset_top
= expected_top
- current_top
;
8560 /* Now fix the mispositioned frame's location. */
8562 adjusted_left
= expected_left
+ FRAME_X_OUTPUT (f
)->move_offset_left
;
8563 adjusted_top
= expected_top
+ FRAME_X_OUTPUT (f
)->move_offset_top
;
8565 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8566 adjusted_left
, adjusted_top
);
8568 x_sync_with_move (f
, expected_left
, expected_top
, 0);
8571 /* It's a "Type B" window manager. We don't have to adjust the
8572 frame's position. */
8574 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_B
;
8578 /* Wait for XGetGeometry to return up-to-date position information for a
8579 recently-moved frame. Call this immediately after calling XMoveWindow.
8580 If FUZZY is non-zero, then LEFT and TOP are just estimates of where the
8581 frame has been moved to, so we use a fuzzy position comparison instead
8582 of an exact comparison. */
8585 x_sync_with_move (struct frame
*f
, int left
, int top
, int fuzzy
)
8589 while (count
++ < 50)
8591 int current_left
= 0, current_top
= 0;
8593 /* In theory, this call to XSync only needs to happen once, but in
8594 practice, it doesn't seem to work, hence the need for the surrounding
8597 XSync (FRAME_X_DISPLAY (f
), False
);
8598 x_real_positions (f
, ¤t_left
, ¤t_top
);
8602 /* The left fuzz-factor is 10 pixels. The top fuzz-factor is 40
8605 if (eabs (current_left
- left
) <= 10
8606 && eabs (current_top
- top
) <= 40)
8609 else if (current_left
== left
&& current_top
== top
)
8613 /* As a last resort, just wait 0.5 seconds and hope that XGetGeometry
8614 will then return up-to-date position info. */
8616 wait_reading_process_output (0, 500000, 0, 0, Qnil
, NULL
, 0);
8620 /* Wait for an event on frame F matching EVENTTYPE. */
8622 x_wait_for_event (struct frame
*f
, int eventtype
)
8624 int level
= interrupt_input_blocked
;
8627 EMACS_TIME tmo
, tmo_at
, time_now
;
8628 int fd
= ConnectionNumber (FRAME_X_DISPLAY (f
));
8630 pending_event_wait
.f
= f
;
8631 pending_event_wait
.eventtype
= eventtype
;
8633 /* Set timeout to 0.1 second. Hopefully not noticable.
8634 Maybe it should be configurable. */
8635 EMACS_SET_SECS_USECS (tmo
, 0, 100000);
8636 EMACS_GET_TIME (tmo_at
);
8637 EMACS_ADD_TIME (tmo_at
, tmo_at
, tmo
);
8639 while (pending_event_wait
.eventtype
)
8641 interrupt_input_pending
= 1;
8642 TOTALLY_UNBLOCK_INPUT
;
8643 /* XTread_socket is called after unblock. */
8645 interrupt_input_blocked
= level
;
8650 EMACS_GET_TIME (time_now
);
8651 EMACS_SUB_TIME (tmo
, tmo_at
, time_now
);
8653 if (EMACS_TIME_NEG_P (tmo
) || select (fd
+1, &fds
, NULL
, NULL
, &tmo
) == 0)
8654 break; /* Timeout */
8656 pending_event_wait
.f
= 0;
8657 pending_event_wait
.eventtype
= 0;
8661 /* Change the size of frame F's X window to COLS/ROWS in the case F
8662 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
8663 top-left-corner window gravity for this size change and subsequent
8664 size changes. Otherwise we leave the window gravity unchanged. */
8667 x_set_window_size_1 (struct frame
*f
, int change_gravity
, int cols
, int rows
)
8669 int pixelwidth
, pixelheight
;
8671 check_frame_size (f
, &rows
, &cols
);
8672 f
->scroll_bar_actual_width
8673 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
8675 : FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0
8676 ? FRAME_CONFIG_SCROLL_BAR_WIDTH (f
)
8677 : (FRAME_CONFIG_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
)));
8679 compute_fringe_widths (f
, 0);
8681 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
8682 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
8683 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
8685 if (change_gravity
) f
->win_gravity
= NorthWestGravity
;
8686 x_wm_set_size_hint (f
, (long) 0, 0);
8687 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8688 pixelwidth
, pixelheight
);
8691 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
8692 receive in the ConfigureNotify event; if we get what we asked
8693 for, then the event won't cause the screen to become garbaged, so
8694 we have to make sure to do it here. */
8695 SET_FRAME_GARBAGED (f
);
8697 /* Now, strictly speaking, we can't be sure that this is accurate,
8698 but the window manager will get around to dealing with the size
8699 change request eventually, and we'll hear how it went when the
8700 ConfigureNotify event gets here.
8702 We could just not bother storing any of this information here,
8703 and let the ConfigureNotify event set everything up, but that
8704 might be kind of confusing to the Lisp code, since size changes
8705 wouldn't be reported in the frame parameters until some random
8706 point in the future when the ConfigureNotify event arrives.
8708 We pass 1 for DELAY since we can't run Lisp code inside of
8711 /* But the ConfigureNotify may in fact never arrive, and then this is
8712 not right if the frame is visible. Instead wait (with timeout)
8713 for the ConfigureNotify. */
8714 if (f
->async_visible
)
8715 x_wait_for_event (f
, ConfigureNotify
);
8718 change_frame_size (f
, rows
, cols
, 0, 1, 0);
8719 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
8720 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
8726 /* Call this to change the size of frame F's x-window.
8727 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
8728 for this size change and subsequent size changes.
8729 Otherwise we leave the window gravity unchanged. */
8732 x_set_window_size (struct frame
*f
, int change_gravity
, int cols
, int rows
)
8736 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
8740 /* When the frame is maximized/fullscreen or running under for
8741 example Xmonad, x_set_window_size_1 will be a no-op.
8742 In that case, the right thing to do is extend rows/cols to
8743 the current frame size. We do that first if x_set_window_size_1
8744 turns out to not be a no-op (there is no way to know).
8745 The size will be adjusted again if the frame gets a
8746 ConfigureNotify event as a result of x_set_window_size. */
8747 int pixelh
= FRAME_PIXEL_HEIGHT (f
);
8748 #ifdef USE_X_TOOLKIT
8749 /* The menu bar is not part of text lines. The tool bar
8751 pixelh
-= FRAME_MENUBAR_HEIGHT (f
);
8753 r
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelh
);
8754 /* Update f->scroll_bar_actual_width because it is used in
8755 FRAME_PIXEL_WIDTH_TO_TEXT_COLS. */
8756 f
->scroll_bar_actual_width
8757 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
8758 c
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, FRAME_PIXEL_WIDTH (f
));
8759 change_frame_size (f
, r
, c
, 0, 1, 0);
8763 if (FRAME_GTK_WIDGET (f
))
8764 xg_frame_set_char_size (f
, cols
, rows
);
8766 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8767 #else /* not USE_GTK */
8769 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8771 #endif /* not USE_GTK */
8773 /* If cursor was outside the new size, mark it as off. */
8774 mark_window_cursors_off (XWINDOW (f
->root_window
));
8776 /* Clear out any recollection of where the mouse highlighting was,
8777 since it might be in a place that's outside the new frame size.
8778 Actually checking whether it is outside is a pain in the neck,
8779 so don't try--just let the highlighting be done afresh with new size. */
8780 cancel_mouse_face (f
);
8785 /* Mouse warping. */
8788 x_set_mouse_position (struct frame
*f
, int x
, int y
)
8792 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
8793 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
8795 if (pix_x
< 0) pix_x
= 0;
8796 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
8798 if (pix_y
< 0) pix_y
= 0;
8799 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
8803 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8804 0, 0, 0, 0, pix_x
, pix_y
);
8808 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
8811 x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
8815 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8816 0, 0, 0, 0, pix_x
, pix_y
);
8820 /* focus shifting, raising and lowering. */
8823 x_focus_on_frame (struct frame
*f
)
8826 /* I don't think that the ICCCM allows programs to do things like this
8827 without the interaction of the window manager. Whatever you end up
8828 doing with this code, do it to x_unfocus_frame too. */
8829 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8830 RevertToPointerRoot
, CurrentTime
);
8835 x_unfocus_frame (struct frame
*f
)
8838 /* Look at the remarks in x_focus_on_frame. */
8839 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
8840 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
8841 RevertToPointerRoot
, CurrentTime
);
8845 /* Raise frame F. */
8848 x_raise_frame (struct frame
*f
)
8851 if (f
->async_visible
)
8852 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8854 XFlush (FRAME_X_DISPLAY (f
));
8858 /* Lower frame F. */
8861 x_lower_frame (struct frame
*f
)
8863 if (f
->async_visible
)
8866 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8867 XFlush (FRAME_X_DISPLAY (f
));
8872 /* Activate frame with Extended Window Manager Hints */
8875 x_ewmh_activate_frame (FRAME_PTR f
)
8877 /* See Window Manager Specification/Extended Window Manager Hints at
8878 http://freedesktop.org/wiki/Specifications/wm-spec */
8880 const char *atom
= "_NET_ACTIVE_WINDOW";
8881 if (f
->async_visible
&& wm_supports (f
, atom
))
8884 XSETFRAME (frame
, f
);
8885 Fx_send_client_event (frame
, make_number (0), frame
,
8886 make_unibyte_string (atom
, strlen (atom
)),
8888 Fcons (make_number (1),
8889 Fcons (make_number (last_user_time
),
8895 XTframe_raise_lower (FRAME_PTR f
, int raise_flag
)
8903 /* XEmbed implementation. */
8906 xembed_set_info (struct frame
*f
, enum xembed_info flags
)
8909 unsigned long data
[2];
8911 atom
= XInternAtom (FRAME_X_DISPLAY (f
), "_XEMBED_INFO", False
);
8913 data
[0] = XEMBED_VERSION
;
8916 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), atom
, atom
,
8917 32, PropModeReplace
, (unsigned char *) data
, 2);
8921 xembed_send_message (struct frame
*f
, Time time
, enum xembed_message message
, long int detail
, long int data1
, long int data2
)
8925 event
.xclient
.type
= ClientMessage
;
8926 event
.xclient
.window
= FRAME_X_OUTPUT (f
)->parent_desc
;
8927 event
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_XEMBED
;
8928 event
.xclient
.format
= 32;
8929 event
.xclient
.data
.l
[0] = time
;
8930 event
.xclient
.data
.l
[1] = message
;
8931 event
.xclient
.data
.l
[2] = detail
;
8932 event
.xclient
.data
.l
[3] = data1
;
8933 event
.xclient
.data
.l
[4] = data2
;
8935 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_OUTPUT (f
)->parent_desc
,
8936 False
, NoEventMask
, &event
);
8937 XSync (FRAME_X_DISPLAY (f
), False
);
8940 /* Change of visibility. */
8942 /* This tries to wait until the frame is really visible.
8943 However, if the window manager asks the user where to position
8944 the frame, this will return before the user finishes doing that.
8945 The frame will not actually be visible at that time,
8946 but it will become visible later when the window manager
8947 finishes with it. */
8950 x_make_frame_visible (struct frame
*f
)
8953 int original_top
, original_left
;
8954 int retry_count
= 2;
8960 type
= x_icon_type (f
);
8962 x_bitmap_icon (f
, type
);
8964 if (! FRAME_VISIBLE_P (f
))
8966 /* We test FRAME_GARBAGED_P here to make sure we don't
8967 call x_set_offset a second time
8968 if we get to x_make_frame_visible a second time
8969 before the window gets really visible. */
8970 if (! FRAME_ICONIFIED_P (f
)
8971 && ! FRAME_X_EMBEDDED_P (f
)
8972 && ! f
->output_data
.x
->asked_for_visible
)
8973 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
8975 f
->output_data
.x
->asked_for_visible
= 1;
8977 if (! EQ (Vx_no_window_manager
, Qt
))
8978 x_wm_set_window_state (f
, NormalState
);
8979 #ifdef USE_X_TOOLKIT
8980 if (FRAME_X_EMBEDDED_P (f
))
8981 xembed_set_info (f
, XEMBED_MAPPED
);
8984 /* This was XtPopup, but that did nothing for an iconified frame. */
8985 XtMapWidget (f
->output_data
.x
->widget
);
8987 #else /* not USE_X_TOOLKIT */
8989 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
8990 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
8992 if (FRAME_X_EMBEDDED_P (f
))
8993 xembed_set_info (f
, XEMBED_MAPPED
);
8995 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8996 #endif /* not USE_GTK */
8997 #endif /* not USE_X_TOOLKIT */
9000 XFlush (FRAME_X_DISPLAY (f
));
9002 /* Synchronize to ensure Emacs knows the frame is visible
9003 before we do anything else. We do this loop with input not blocked
9004 so that incoming events are handled. */
9008 /* This must be before UNBLOCK_INPUT
9009 since events that arrive in response to the actions above
9010 will set it when they are handled. */
9011 int previously_visible
= f
->output_data
.x
->has_been_visible
;
9013 original_left
= f
->left_pos
;
9014 original_top
= f
->top_pos
;
9016 /* This must come after we set COUNT. */
9019 /* We unblock here so that arriving X events are processed. */
9021 /* Now move the window back to where it was "supposed to be".
9022 But don't do it if the gravity is negative.
9023 When the gravity is negative, this uses a position
9024 that is 3 pixels too low. Perhaps that's really the border width.
9026 Don't do this if the window has never been visible before,
9027 because the window manager may choose the position
9028 and we don't want to override it. */
9030 if (! FRAME_VISIBLE_P (f
)
9031 && ! FRAME_ICONIFIED_P (f
)
9032 && ! FRAME_X_EMBEDDED_P (f
)
9033 && f
->win_gravity
== NorthWestGravity
9034 && previously_visible
)
9038 unsigned int width
, height
, border
, depth
;
9042 /* On some window managers (such as FVWM) moving an existing
9043 window, even to the same place, causes the window manager
9044 to introduce an offset. This can cause the window to move
9045 to an unexpected location. Check the geometry (a little
9046 slow here) and then verify that the window is in the right
9047 place. If the window is not in the right place, move it
9048 there, and take the potential window manager hit. */
9049 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9050 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
9052 if (original_left
!= x
|| original_top
!= y
)
9053 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9054 original_left
, original_top
);
9059 XSETFRAME (frame
, f
);
9061 /* Wait until the frame is visible. Process X events until a
9062 MapNotify event has been seen, or until we think we won't get a
9063 MapNotify at all.. */
9064 for (count
= input_signal_count
+ 10;
9065 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
9067 /* Force processing of queued events. */
9070 /* Machines that do polling rather than SIGIO have been
9071 observed to go into a busy-wait here. So we'll fake an
9072 alarm signal to let the handler know that there's something
9073 to be read. We used to raise a real alarm, but it seems
9074 that the handler isn't always enabled here. This is
9076 if (input_polling_used ())
9078 /* It could be confusing if a real alarm arrives while
9079 processing the fake one. Turn it off and let the
9080 handler reset it. */
9081 extern void poll_for_input_1 (void);
9082 int old_poll_suppress_count
= poll_suppress_count
;
9083 poll_suppress_count
= 1;
9084 poll_for_input_1 ();
9085 poll_suppress_count
= old_poll_suppress_count
;
9088 /* See if a MapNotify event has been processed. */
9089 FRAME_SAMPLE_VISIBILITY (f
);
9094 (let ((f (selected-frame)))
9098 the frame is not raised with various window managers on
9099 FreeBSD, GNU/Linux and Solaris. It turns out that, for some
9100 unknown reason, the call to XtMapWidget is completely ignored.
9101 Mapping the widget a second time works. */
9103 if (!FRAME_VISIBLE_P (f
) && --retry_count
> 0)
9108 /* Change from mapped state to withdrawn state. */
9110 /* Make the frame visible (mapped and not iconified). */
9113 x_make_frame_invisible (struct frame
*f
)
9117 /* Use the frame's outermost window, not the one we normally draw on. */
9118 window
= FRAME_OUTER_WINDOW (f
);
9120 /* Don't keep the highlight on an invisible frame. */
9121 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9122 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9126 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
9127 that the current position of the window is user-specified, rather than
9128 program-specified, so that when the window is mapped again, it will be
9129 placed at the same location, without forcing the user to position it
9130 by hand again (they have already done that once for this window.) */
9131 x_wm_set_size_hint (f
, (long) 0, 1);
9134 if (FRAME_GTK_OUTER_WIDGET (f
))
9135 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f
));
9138 if (FRAME_X_EMBEDDED_P (f
))
9139 xembed_set_info (f
, 0);
9144 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
9145 DefaultScreen (FRAME_X_DISPLAY (f
))))
9147 UNBLOCK_INPUT_RESIGNAL
;
9148 error ("Can't notify window manager of window withdrawal");
9152 /* We can't distinguish this from iconification
9153 just by the event that we get from the server.
9154 So we can't win using the usual strategy of letting
9155 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
9156 and synchronize with the server to make sure we agree. */
9158 FRAME_ICONIFIED_P (f
) = 0;
9159 f
->async_visible
= 0;
9160 f
->async_iconified
= 0;
9167 /* Change window state from mapped to iconified. */
9170 x_iconify_frame (struct frame
*f
)
9175 /* Don't keep the highlight on an invisible frame. */
9176 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9177 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9179 if (f
->async_iconified
)
9184 FRAME_SAMPLE_VISIBILITY (f
);
9186 type
= x_icon_type (f
);
9188 x_bitmap_icon (f
, type
);
9191 if (FRAME_GTK_OUTER_WIDGET (f
))
9193 if (! FRAME_VISIBLE_P (f
))
9194 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
9196 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
9199 f
->async_iconified
= 1;
9200 f
->async_visible
= 0;
9206 #ifdef USE_X_TOOLKIT
9208 if (! FRAME_VISIBLE_P (f
))
9210 if (! EQ (Vx_no_window_manager
, Qt
))
9211 x_wm_set_window_state (f
, IconicState
);
9212 /* This was XtPopup, but that did nothing for an iconified frame. */
9213 XtMapWidget (f
->output_data
.x
->widget
);
9214 /* The server won't give us any event to indicate
9215 that an invisible frame was changed to an icon,
9216 so we have to record it here. */
9219 f
->async_iconified
= 1;
9220 f
->async_visible
= 0;
9225 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
9226 XtWindow (f
->output_data
.x
->widget
),
9227 DefaultScreen (FRAME_X_DISPLAY (f
)));
9231 error ("Can't notify window manager of iconification");
9233 f
->async_iconified
= 1;
9234 f
->async_visible
= 0;
9238 XFlush (FRAME_X_DISPLAY (f
));
9240 #else /* not USE_X_TOOLKIT */
9242 /* Make sure the X server knows where the window should be positioned,
9243 in case the user deiconifies with the window manager. */
9244 if (! FRAME_VISIBLE_P (f
)
9245 && ! FRAME_ICONIFIED_P (f
)
9246 && ! FRAME_X_EMBEDDED_P (f
))
9247 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
9249 /* Since we don't know which revision of X we're running, we'll use both
9250 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
9252 /* X11R4: send a ClientMessage to the window manager using the
9253 WM_CHANGE_STATE type. */
9257 message
.xclient
.window
= FRAME_X_WINDOW (f
);
9258 message
.xclient
.type
= ClientMessage
;
9259 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
9260 message
.xclient
.format
= 32;
9261 message
.xclient
.data
.l
[0] = IconicState
;
9263 if (! XSendEvent (FRAME_X_DISPLAY (f
),
9264 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
9266 SubstructureRedirectMask
| SubstructureNotifyMask
,
9269 UNBLOCK_INPUT_RESIGNAL
;
9270 error ("Can't notify window manager of iconification");
9274 /* X11R3: set the initial_state field of the window manager hints to
9276 x_wm_set_window_state (f
, IconicState
);
9278 if (!FRAME_VISIBLE_P (f
))
9280 /* If the frame was withdrawn, before, we must map it. */
9281 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9284 f
->async_iconified
= 1;
9285 f
->async_visible
= 0;
9287 XFlush (FRAME_X_DISPLAY (f
));
9289 #endif /* not USE_X_TOOLKIT */
9293 /* Free X resources of frame F. */
9296 x_free_frame_resources (struct frame
*f
)
9298 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9300 struct scroll_bar
*b
;
9304 /* If a display connection is dead, don't try sending more
9305 commands to the X server. */
9306 if (dpyinfo
->display
)
9308 /* We must free faces before destroying windows because some
9309 font-driver (e.g. xft) access a window while finishing a
9311 if (FRAME_FACE_CACHE (f
))
9312 free_frame_faces (f
);
9314 if (f
->output_data
.x
->icon_desc
)
9315 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
9317 #ifdef USE_X_TOOLKIT
9318 /* Explicitly destroy the scroll bars of the frame. Without
9319 this, we get "BadDrawable" errors from the toolkit later on,
9320 presumably from expose events generated for the disappearing
9321 toolkit scroll bars. */
9322 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
9324 b
= XSCROLL_BAR (bar
);
9325 x_scroll_bar_remove (b
);
9334 #ifdef USE_X_TOOLKIT
9335 if (f
->output_data
.x
->widget
)
9337 XtDestroyWidget (f
->output_data
.x
->widget
);
9338 f
->output_data
.x
->widget
= NULL
;
9340 /* Tooltips don't have widgets, only a simple X window, even if
9341 we are using a toolkit. */
9342 else if (FRAME_X_WINDOW (f
))
9343 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9345 free_frame_menubar (f
);
9346 #else /* !USE_X_TOOLKIT */
9349 /* In the GTK version, tooltips are normal X
9350 frames. We must check and free both types. */
9351 if (FRAME_GTK_OUTER_WIDGET (f
))
9353 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
9354 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow below */
9355 FRAME_GTK_OUTER_WIDGET (f
) = 0;
9357 #endif /* USE_GTK */
9359 if (FRAME_X_WINDOW (f
))
9360 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9361 #endif /* !USE_X_TOOLKIT */
9363 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
9364 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
9365 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
9366 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
9367 unload_color (f
, f
->output_data
.x
->border_pixel
);
9368 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
9370 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
9371 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
9372 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
9373 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
9374 #ifdef USE_TOOLKIT_SCROLL_BARS
9375 /* Scrollbar shadow colors. */
9376 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
9377 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
9378 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
9379 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
9380 #endif /* USE_TOOLKIT_SCROLL_BARS */
9381 if (f
->output_data
.x
->white_relief
.allocated_p
)
9382 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
9383 if (f
->output_data
.x
->black_relief
.allocated_p
)
9384 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
9387 XFlush (FRAME_X_DISPLAY (f
));
9390 xfree (f
->output_data
.x
->saved_menu_event
);
9391 xfree (f
->output_data
.x
);
9392 f
->output_data
.x
= NULL
;
9394 if (f
== dpyinfo
->x_focus_frame
)
9395 dpyinfo
->x_focus_frame
= 0;
9396 if (f
== dpyinfo
->x_focus_event_frame
)
9397 dpyinfo
->x_focus_event_frame
= 0;
9398 if (f
== dpyinfo
->x_highlight_frame
)
9399 dpyinfo
->x_highlight_frame
= 0;
9401 if (f
== dpyinfo
->mouse_face_mouse_frame
)
9403 dpyinfo
->mouse_face_beg_row
9404 = dpyinfo
->mouse_face_beg_col
= -1;
9405 dpyinfo
->mouse_face_end_row
9406 = dpyinfo
->mouse_face_end_col
= -1;
9407 dpyinfo
->mouse_face_window
= Qnil
;
9408 dpyinfo
->mouse_face_deferred_gc
= 0;
9409 dpyinfo
->mouse_face_mouse_frame
= 0;
9416 /* Destroy the X window of frame F. */
9419 x_destroy_window (struct frame
*f
)
9421 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9423 /* If a display connection is dead, don't try sending more
9424 commands to the X server. */
9425 if (dpyinfo
->display
!= 0)
9426 x_free_frame_resources (f
);
9428 dpyinfo
->reference_count
--;
9432 /* Setting window manager hints. */
9434 /* Set the normal size hints for the window manager, for frame F.
9435 FLAGS is the flags word to use--or 0 meaning preserve the flags
9436 that the window now has.
9437 If USER_POSITION is nonzero, we set the USPosition
9438 flag (this is useful when FLAGS is 0).
9439 The GTK version is in gtkutils.c */
9443 x_wm_set_size_hint (f
, flags
, user_position
)
9448 XSizeHints size_hints
;
9449 Window window
= FRAME_OUTER_WINDOW (f
);
9451 /* Setting PMaxSize caused various problems. */
9452 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
9454 size_hints
.x
= f
->left_pos
;
9455 size_hints
.y
= f
->top_pos
;
9457 size_hints
.height
= FRAME_PIXEL_HEIGHT (f
);
9458 size_hints
.width
= FRAME_PIXEL_WIDTH (f
);
9460 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
9461 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
9462 size_hints
.max_width
= x_display_pixel_width (FRAME_X_DISPLAY_INFO (f
))
9463 - FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9464 size_hints
.max_height
= x_display_pixel_height (FRAME_X_DISPLAY_INFO (f
))
9465 - FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9467 /* Calculate the base and minimum sizes. */
9469 int base_width
, base_height
;
9470 int min_rows
= 0, min_cols
= 0;
9472 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9473 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9475 check_frame_size (f
, &min_rows
, &min_cols
);
9477 /* The window manager uses the base width hints to calculate the
9478 current number of rows and columns in the frame while
9479 resizing; min_width and min_height aren't useful for this
9480 purpose, since they might not give the dimensions for a
9481 zero-row, zero-column frame.
9483 We use the base_width and base_height members if we have
9484 them; otherwise, we set the min_width and min_height members
9485 to the size for a zero x zero frame. */
9487 size_hints
.flags
|= PBaseSize
;
9488 size_hints
.base_width
= base_width
;
9489 size_hints
.base_height
= base_height
+ FRAME_MENUBAR_HEIGHT (f
);
9490 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
9491 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
9494 /* If we don't need the old flags, we don't need the old hint at all. */
9497 size_hints
.flags
|= flags
;
9502 XSizeHints hints
; /* Sometimes I hate X Windows... */
9503 long supplied_return
;
9506 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
9510 size_hints
.flags
|= flags
;
9515 if (hints
.flags
& PSize
)
9516 size_hints
.flags
|= PSize
;
9517 if (hints
.flags
& PPosition
)
9518 size_hints
.flags
|= PPosition
;
9519 if (hints
.flags
& USPosition
)
9520 size_hints
.flags
|= USPosition
;
9521 if (hints
.flags
& USSize
)
9522 size_hints
.flags
|= USSize
;
9529 size_hints
.win_gravity
= f
->win_gravity
;
9530 size_hints
.flags
|= PWinGravity
;
9534 size_hints
.flags
&= ~ PPosition
;
9535 size_hints
.flags
|= USPosition
;
9537 #endif /* PWinGravity */
9539 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
9541 #endif /* not USE_GTK */
9543 /* Used for IconicState or NormalState */
9546 x_wm_set_window_state (struct frame
*f
, int state
)
9548 #ifdef USE_X_TOOLKIT
9551 XtSetArg (al
[0], XtNinitialState
, state
);
9552 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9553 #else /* not USE_X_TOOLKIT */
9554 Window window
= FRAME_X_WINDOW (f
);
9556 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
9557 f
->output_data
.x
->wm_hints
.initial_state
= state
;
9559 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9560 #endif /* not USE_X_TOOLKIT */
9564 x_wm_set_icon_pixmap (struct frame
*f
, int pixmap_id
)
9566 Pixmap icon_pixmap
, icon_mask
;
9568 #if !defined USE_X_TOOLKIT && !defined USE_GTK
9569 Window window
= FRAME_OUTER_WINDOW (f
);
9574 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
9575 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
9576 icon_mask
= x_bitmap_mask (f
, pixmap_id
);
9577 f
->output_data
.x
->wm_hints
.icon_mask
= icon_mask
;
9581 /* It seems there is no way to turn off use of an icon
9589 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
);
9593 #elif defined (USE_X_TOOLKIT) /* same as in x_wm_set_window_state. */
9597 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
9598 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9599 XtSetArg (al
[0], XtNiconMask
, icon_mask
);
9600 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9603 #else /* not USE_X_TOOLKIT && not USE_GTK */
9605 f
->output_data
.x
->wm_hints
.flags
|= (IconPixmapHint
| IconMaskHint
);
9606 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9608 #endif /* not USE_X_TOOLKIT && not USE_GTK */
9612 x_wm_set_icon_position (struct frame
*f
, int icon_x
, int icon_y
)
9614 Window window
= FRAME_OUTER_WINDOW (f
);
9616 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
9617 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
9618 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
9620 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9624 /***********************************************************************
9626 ***********************************************************************/
9630 /* Check that FONT is valid on frame F. It is if it can be found in F's
9634 x_check_font (f
, font
)
9640 xassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
9641 if (font
->driver
->check
)
9642 xassert (font
->driver
->check (f
, font
) == 0);
9645 #endif /* GLYPH_DEBUG != 0 */
9648 /***********************************************************************
9650 ***********************************************************************/
9652 #ifdef USE_X_TOOLKIT
9653 static XrmOptionDescRec emacs_options
[] = {
9654 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
9655 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
9657 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
9658 XrmoptionSepArg
, NULL
},
9659 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
9661 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9662 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9663 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9664 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
9665 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
9666 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
9667 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
9670 /* Whether atimer for Xt timeouts is activated or not. */
9672 static int x_timeout_atimer_activated_flag
;
9674 #endif /* USE_X_TOOLKIT */
9676 static int x_initialized
;
9679 static int x_session_initialized
;
9682 /* Test whether two display-name strings agree up to the dot that separates
9683 the screen number from the server number. */
9685 same_x_server (const char *name1
, const char *name2
)
9688 const unsigned char *system_name
= SDATA (Vsystem_name
);
9689 int system_name_length
= strlen (system_name
);
9690 int length_until_period
= 0;
9692 while (system_name
[length_until_period
] != 0
9693 && system_name
[length_until_period
] != '.')
9694 length_until_period
++;
9696 /* Treat `unix' like an empty host name. */
9697 if (! strncmp (name1
, "unix:", 5))
9699 if (! strncmp (name2
, "unix:", 5))
9701 /* Treat this host's name like an empty host name. */
9702 if (! strncmp (name1
, system_name
, system_name_length
)
9703 && name1
[system_name_length
] == ':')
9704 name1
+= system_name_length
;
9705 if (! strncmp (name2
, system_name
, system_name_length
)
9706 && name2
[system_name_length
] == ':')
9707 name2
+= system_name_length
;
9708 /* Treat this host's domainless name like an empty host name. */
9709 if (! strncmp (name1
, system_name
, length_until_period
)
9710 && name1
[length_until_period
] == ':')
9711 name1
+= length_until_period
;
9712 if (! strncmp (name2
, system_name
, length_until_period
)
9713 && name2
[length_until_period
] == ':')
9714 name2
+= length_until_period
;
9716 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
9720 if (seen_colon
&& *name1
== '.')
9724 && (*name1
== '.' || *name1
== '\0')
9725 && (*name2
== '.' || *name2
== '\0'));
9728 /* Count number of set bits in mask and number of bits to shift to
9729 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
9732 get_bits_and_offset (long unsigned int mask
, int *bits
, int *offset
)
9753 /* Return 1 if display DISPLAY is available for use, 0 otherwise.
9754 But don't permanently open it, just test its availability. */
9757 x_display_ok (const char *display
)
9762 dpy
= XOpenDisplay (display
);
9764 XCloseDisplay (dpy
);
9772 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
, const gchar
*message
, gpointer user_data
)
9774 if (!strstr (message
, "g_set_prgname"))
9775 fprintf (stderr
, "%s-WARNING **: %s\n", log_domain
, message
);
9779 /* Open a connection to X display DISPLAY_NAME, and return
9780 the structure that describes the open display.
9781 If we cannot contact the display, return null. */
9783 struct x_display_info
*
9784 x_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
9788 struct terminal
*terminal
;
9789 struct x_display_info
*dpyinfo
;
9800 if (! x_display_ok (SDATA (display_name
)))
9801 error ("Display %s can't be opened", SDATA (display_name
));
9807 char *argv
[NUM_ARGV
];
9808 char **argv2
= argv
;
9811 if (x_initialized
++ > 1)
9813 xg_display_open (SDATA (display_name
), &dpy
);
9817 for (argc
= 0; argc
< NUM_ARGV
; ++argc
)
9821 argv
[argc
++] = initial_argv
[0];
9823 if (! NILP (display_name
))
9825 argv
[argc
++] = "--display";
9826 argv
[argc
++] = SDATA (display_name
);
9829 argv
[argc
++] = "--name";
9830 argv
[argc
++] = resource_name
;
9832 XSetLocaleModifiers ("");
9834 /* Work around GLib bug that outputs a faulty warning. See
9835 https://bugzilla.gnome.org/show_bug.cgi?id=563627. */
9836 id
= g_log_set_handler ("GLib", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
9837 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
9838 gtk_init (&argc
, &argv2
);
9839 g_log_remove_handler ("GLib", id
);
9841 /* gtk_init does set_locale. We must fix locale after calling it. */
9845 dpy
= GDK_DISPLAY ();
9847 /* NULL window -> events for all windows go to our function */
9848 gdk_window_add_filter (NULL
, event_handler_gdk
, NULL
);
9850 /* Load our own gtkrc if it exists. */
9852 char *file
= "~/.emacs.d/gtkrc";
9853 Lisp_Object s
, abs_file
;
9855 s
= make_string (file
, strlen (file
));
9856 abs_file
= Fexpand_file_name (s
, Qnil
);
9858 if (! NILP (abs_file
) && !NILP (Ffile_readable_p (abs_file
)))
9859 gtk_rc_parse (SDATA (abs_file
));
9862 XSetErrorHandler (x_error_handler
);
9863 XSetIOErrorHandler (x_io_error_quitter
);
9866 #else /* not USE_GTK */
9867 #ifdef USE_X_TOOLKIT
9868 /* weiner@footloose.sps.mot.com reports that this causes
9870 X protocol error: BadAtom (invalid Atom parameter)
9871 on protocol request 18skiloaf.
9872 So let's not use it until R6. */
9874 XtSetLanguageProc (NULL
, NULL
, NULL
);
9885 argv
[argc
++] = "-xrm";
9886 argv
[argc
++] = xrm_option
;
9888 turn_on_atimers (0);
9889 dpy
= XtOpenDisplay (Xt_app_con
, SDATA (display_name
),
9890 resource_name
, EMACS_CLASS
,
9891 emacs_options
, XtNumber (emacs_options
),
9893 turn_on_atimers (1);
9896 /* I think this is to compensate for XtSetLanguageProc. */
9901 #else /* not USE_X_TOOLKIT */
9902 XSetLocaleModifiers ("");
9903 dpy
= XOpenDisplay (SDATA (display_name
));
9904 #endif /* not USE_X_TOOLKIT */
9905 #endif /* not USE_GTK*/
9907 /* Detect failure. */
9914 /* We have definitely succeeded. Record the new connection. */
9916 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
9917 memset (dpyinfo
, 0, sizeof *dpyinfo
);
9919 terminal
= x_create_terminal (dpyinfo
);
9922 struct x_display_info
*share
;
9925 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
9926 share
= share
->next
, tail
= XCDR (tail
))
9927 if (same_x_server (SDATA (XCAR (XCAR (tail
))),
9928 SDATA (display_name
)))
9931 terminal
->kboard
= share
->terminal
->kboard
;
9934 terminal
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
9935 init_kboard (terminal
->kboard
);
9936 terminal
->kboard
->Vwindow_system
= Qx
;
9938 /* Add the keyboard to the list before running Lisp code (via
9939 Qvendor_specific_keysyms below), since these are not traced
9940 via terminals but only through all_kboards. */
9941 terminal
->kboard
->next_kboard
= all_kboards
;
9942 all_kboards
= terminal
->kboard
;
9944 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
9946 char *vendor
= ServerVendor (dpy
);
9948 /* Protect terminal from GC before removing it from the
9949 list of terminals. */
9950 struct gcpro gcpro1
;
9951 Lisp_Object gcpro_term
;
9952 XSETTERMINAL (gcpro_term
, terminal
);
9953 GCPRO1 (gcpro_term
);
9955 /* Temporarily hide the partially initialized terminal. */
9956 terminal_list
= terminal
->next_terminal
;
9958 terminal
->kboard
->Vsystem_key_alist
9959 = call1 (Qvendor_specific_keysyms
,
9960 vendor
? build_string (vendor
) : empty_unibyte_string
);
9962 terminal
->next_terminal
= terminal_list
;
9963 terminal_list
= terminal
;
9967 /* Don't let the initial kboard remain current longer than necessary.
9968 That would cause problems if a file loaded on startup tries to
9969 prompt in the mini-buffer. */
9970 if (current_kboard
== initial_kboard
)
9971 current_kboard
= terminal
->kboard
;
9973 terminal
->kboard
->reference_count
++;
9976 /* Put this display on the chain. */
9977 dpyinfo
->next
= x_display_list
;
9978 x_display_list
= dpyinfo
;
9980 /* Put it on x_display_name_list as well, to keep them parallel. */
9981 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
9982 x_display_name_list
);
9983 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
9985 dpyinfo
->display
= dpy
;
9987 /* Set the name of the terminal. */
9988 terminal
->name
= (char *) xmalloc (SBYTES (display_name
) + 1);
9989 strncpy (terminal
->name
, SDATA (display_name
), SBYTES (display_name
));
9990 terminal
->name
[SBYTES (display_name
)] = 0;
9993 XSetAfterFunction (x_current_display
, x_trace_wire
);
9997 = (char *) xmalloc (SBYTES (Vinvocation_name
)
9998 + SBYTES (Vsystem_name
)
10000 sprintf (dpyinfo
->x_id_name
, "%s@%s",
10001 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
10003 /* Figure out which modifier bits mean what. */
10004 x_find_modifier_meanings (dpyinfo
);
10006 /* Get the scroll bar cursor. */
10008 /* We must create a GTK cursor, it is required for GTK widgets. */
10009 dpyinfo
->xg_cursor
= xg_create_default_cursor (dpyinfo
->display
);
10010 #endif /* USE_GTK */
10012 dpyinfo
->vertical_scroll_bar_cursor
10013 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
10015 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
10016 resource_name
, EMACS_CLASS
);
10017 #ifdef HAVE_XRMSETDATABASE
10018 XrmSetDatabase (dpyinfo
->display
, xrdb
);
10020 dpyinfo
->display
->db
= xrdb
;
10022 /* Put the rdb where we can find it in a way that works on
10024 dpyinfo
->xrdb
= xrdb
;
10026 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
10027 DefaultScreen (dpyinfo
->display
));
10028 select_visual (dpyinfo
);
10029 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
10030 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
10031 dpyinfo
->client_leader_window
= 0;
10032 dpyinfo
->grabbed
= 0;
10033 dpyinfo
->reference_count
= 0;
10034 dpyinfo
->icon_bitmap_id
= -1;
10035 dpyinfo
->n_fonts
= 0;
10036 dpyinfo
->bitmaps
= 0;
10037 dpyinfo
->bitmaps_size
= 0;
10038 dpyinfo
->bitmaps_last
= 0;
10039 dpyinfo
->scratch_cursor_gc
= 0;
10040 dpyinfo
->mouse_face_mouse_frame
= 0;
10041 dpyinfo
->mouse_face_deferred_gc
= 0;
10042 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
10043 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
10044 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
10045 dpyinfo
->mouse_face_window
= Qnil
;
10046 dpyinfo
->mouse_face_overlay
= Qnil
;
10047 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
10048 dpyinfo
->mouse_face_defer
= 0;
10049 dpyinfo
->mouse_face_hidden
= 0;
10050 dpyinfo
->x_focus_frame
= 0;
10051 dpyinfo
->x_focus_event_frame
= 0;
10052 dpyinfo
->x_highlight_frame
= 0;
10053 dpyinfo
->wm_type
= X_WMTYPE_UNKNOWN
;
10055 /* See if we can construct pixel values from RGB values. */
10056 dpyinfo
->red_bits
= dpyinfo
->blue_bits
= dpyinfo
->green_bits
= 0;
10057 dpyinfo
->red_offset
= dpyinfo
->blue_offset
= dpyinfo
->green_offset
= 0;
10059 if (dpyinfo
->visual
->class == TrueColor
)
10061 get_bits_and_offset (dpyinfo
->visual
->red_mask
,
10062 &dpyinfo
->red_bits
, &dpyinfo
->red_offset
);
10063 get_bits_and_offset (dpyinfo
->visual
->blue_mask
,
10064 &dpyinfo
->blue_bits
, &dpyinfo
->blue_offset
);
10065 get_bits_and_offset (dpyinfo
->visual
->green_mask
,
10066 &dpyinfo
->green_bits
, &dpyinfo
->green_offset
);
10069 /* See if a private colormap is requested. */
10070 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
10072 if (dpyinfo
->visual
->class == PseudoColor
)
10075 value
= display_x_get_resource (dpyinfo
,
10076 build_string ("privateColormap"),
10077 build_string ("PrivateColormap"),
10079 if (STRINGP (value
)
10080 && (!strcmp (SDATA (value
), "true")
10081 || !strcmp (SDATA (value
), "on")))
10082 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
10086 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
10087 dpyinfo
->visual
, AllocNone
);
10091 /* If we are using Xft, check dpi value in X resources.
10092 It is better we use it as well, since Xft will use it, as will all
10093 Gnome applications. If our real DPI is smaller or larger than the
10094 one Xft uses, our font will look smaller or larger than other
10095 for other applications, even if it is the same font name (monospace-10
10097 char *v
= XGetDefault (dpyinfo
->display
, "Xft", "dpi");
10099 if (v
!= NULL
&& sscanf (v
, "%lf", &d
) == 1)
10100 dpyinfo
->resy
= dpyinfo
->resx
= d
;
10104 if (dpyinfo
->resy
< 1)
10106 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
10107 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
10108 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
10109 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10110 dpyinfo
->resy
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10111 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
10112 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
10113 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10114 dpyinfo
->resx
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10117 dpyinfo
->Xatom_wm_protocols
10118 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
10119 dpyinfo
->Xatom_wm_take_focus
10120 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
10121 dpyinfo
->Xatom_wm_save_yourself
10122 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
10123 dpyinfo
->Xatom_wm_delete_window
10124 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
10125 dpyinfo
->Xatom_wm_change_state
10126 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
10127 dpyinfo
->Xatom_wm_configure_denied
10128 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
10129 dpyinfo
->Xatom_wm_window_moved
10130 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
10131 dpyinfo
->Xatom_wm_client_leader
10132 = XInternAtom (dpyinfo
->display
, "WM_CLIENT_LEADER", False
);
10133 dpyinfo
->Xatom_editres
10134 = XInternAtom (dpyinfo
->display
, "Editres", False
);
10135 dpyinfo
->Xatom_CLIPBOARD
10136 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
10137 dpyinfo
->Xatom_TIMESTAMP
10138 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
10139 dpyinfo
->Xatom_TEXT
10140 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
10141 dpyinfo
->Xatom_COMPOUND_TEXT
10142 = XInternAtom (dpyinfo
->display
, "COMPOUND_TEXT", False
);
10143 dpyinfo
->Xatom_UTF8_STRING
10144 = XInternAtom (dpyinfo
->display
, "UTF8_STRING", False
);
10145 dpyinfo
->Xatom_DELETE
10146 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
10147 dpyinfo
->Xatom_MULTIPLE
10148 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
10149 dpyinfo
->Xatom_INCR
10150 = XInternAtom (dpyinfo
->display
, "INCR", False
);
10151 dpyinfo
->Xatom_EMACS_TMP
10152 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
10153 dpyinfo
->Xatom_TARGETS
10154 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
10155 dpyinfo
->Xatom_NULL
10156 = XInternAtom (dpyinfo
->display
, "NULL", False
);
10157 dpyinfo
->Xatom_ATOM_PAIR
10158 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
10159 /* For properties of font. */
10160 dpyinfo
->Xatom_PIXEL_SIZE
10161 = XInternAtom (dpyinfo
->display
, "PIXEL_SIZE", False
);
10162 dpyinfo
->Xatom_AVERAGE_WIDTH
10163 = XInternAtom (dpyinfo
->display
, "AVERAGE_WIDTH", False
);
10164 dpyinfo
->Xatom_MULE_BASELINE_OFFSET
10165 = XInternAtom (dpyinfo
->display
, "_MULE_BASELINE_OFFSET", False
);
10166 dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
10167 = XInternAtom (dpyinfo
->display
, "_MULE_RELATIVE_COMPOSE", False
);
10168 dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
10169 = XInternAtom (dpyinfo
->display
, "_MULE_DEFAULT_ASCENT", False
);
10171 /* Ghostscript support. */
10172 dpyinfo
->Xatom_PAGE
= XInternAtom (dpyinfo
->display
, "PAGE", False
);
10173 dpyinfo
->Xatom_DONE
= XInternAtom (dpyinfo
->display
, "DONE", False
);
10175 dpyinfo
->Xatom_Scrollbar
= XInternAtom (dpyinfo
->display
, "SCROLLBAR",
10178 dpyinfo
->Xatom_XEMBED
= XInternAtom (dpyinfo
->display
, "_XEMBED",
10181 dpyinfo
->Xatom_net_wm_state
10182 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE", False
);
10183 dpyinfo
->Xatom_net_wm_state_fullscreen_atom
10184 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE_FULLSCREEN", False
);
10185 dpyinfo
->Xatom_net_wm_state_maximized_horz
10186 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE_MAXIMIZED_HORZ", False
);
10187 dpyinfo
->Xatom_net_wm_state_maximized_vert
10188 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE_MAXIMIZED_VERT", False
);
10189 dpyinfo
->Xatom_net_wm_state_sticky
10190 = XInternAtom (dpyinfo
->display
, "_NET_WM_STATE_STICKY", False
);
10191 dpyinfo
->Xatom_net_window_type
10192 = XInternAtom (dpyinfo
->display
, "_NET_WM_WINDOW_TYPE", False
);
10193 dpyinfo
->Xatom_net_window_type_tooltip
10194 = XInternAtom (dpyinfo
->display
, "_NET_WM_WINDOW_TYPE_TOOLTIP", False
);
10195 dpyinfo
->Xatom_net_wm_icon_name
10196 = XInternAtom (dpyinfo
->display
, "_NET_WM_ICON_NAME", False
);
10197 dpyinfo
->Xatom_net_wm_name
10198 = XInternAtom (dpyinfo
->display
, "_NET_WM_NAME", False
);
10200 dpyinfo
->cut_buffers_initialized
= 0;
10202 dpyinfo
->x_dnd_atoms_size
= 8;
10203 dpyinfo
->x_dnd_atoms_length
= 0;
10204 dpyinfo
->x_dnd_atoms
= xmalloc (sizeof (*dpyinfo
->x_dnd_atoms
)
10205 * dpyinfo
->x_dnd_atoms_size
);
10207 dpyinfo
->net_supported_atoms
= NULL
;
10208 dpyinfo
->nr_net_supported_atoms
= 0;
10209 dpyinfo
->net_supported_window
= 0;
10211 connection
= ConnectionNumber (dpyinfo
->display
);
10212 dpyinfo
->connection
= connection
;
10215 extern int gray_bitmap_width
, gray_bitmap_height
;
10216 extern char *gray_bitmap_bits
;
10218 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
10220 gray_bitmap_width
, gray_bitmap_height
,
10221 (unsigned long) 1, (unsigned long) 0, 1);
10225 xim_initialize (dpyinfo
, resource_name
);
10228 xsettings_initialize (dpyinfo
);
10230 #ifdef subprocesses
10231 /* This is only needed for distinguishing keyboard and process input. */
10232 if (connection
!= 0)
10233 add_keyboard_wait_descriptor (connection
);
10237 fcntl (connection
, F_SETOWN
, getpid ());
10238 #endif /* ! defined (F_SETOWN) */
10241 if (interrupt_input
)
10242 init_sigio (connection
);
10243 #endif /* ! defined (SIGIO) */
10247 Display
*dpy
= dpyinfo
->display
;
10248 XrmValue d
, fr
, to
;
10251 d
.addr
= (XPointer
)&dpy
;
10252 d
.size
= sizeof (Display
*);
10253 fr
.addr
= XtDefaultFont
;
10254 fr
.size
= sizeof (XtDefaultFont
);
10255 to
.size
= sizeof (Font
*);
10256 to
.addr
= (XPointer
)&font
;
10257 x_catch_errors (dpy
);
10258 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
10260 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
10261 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
10262 x_uncatch_errors ();
10266 /* See if we should run in synchronous mode. This is useful
10267 for debugging X code. */
10270 value
= display_x_get_resource (dpyinfo
,
10271 build_string ("synchronous"),
10272 build_string ("Synchronous"),
10274 if (STRINGP (value
)
10275 && (!strcmp (SDATA (value
), "true")
10276 || !strcmp (SDATA (value
), "on")))
10277 XSynchronize (dpyinfo
->display
, True
);
10282 value
= display_x_get_resource (dpyinfo
,
10283 build_string ("useXIM"),
10284 build_string ("UseXIM"),
10287 if (STRINGP (value
)
10288 && (!strcmp (SDATA (value
), "false")
10289 || !strcmp (SDATA (value
), "off")))
10292 if (STRINGP (value
)
10293 && (!strcmp (SDATA (value
), "true")
10294 || !strcmp (SDATA (value
), "on")))
10300 /* Only do this for the very first display in the Emacs session.
10301 Ignore X session management when Emacs was first started on a
10303 if (terminal
->id
== 1)
10304 x_session_initialize (dpyinfo
);
10312 /* Get rid of display DPYINFO, deleting all frames on it,
10313 and without sending any more commands to the X server. */
10316 x_delete_display (struct x_display_info
*dpyinfo
)
10318 struct terminal
*t
;
10320 /* Close all frames and delete the generic struct terminal for this
10322 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
10323 if (t
->type
== output_x_window
&& t
->display_info
.x
== dpyinfo
)
10326 /* Close X session management when we close its display. */
10327 if (t
->id
== 1 && x_session_have_connection ())
10328 x_session_close ();
10330 delete_terminal (t
);
10334 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
10336 /* Discard this display from x_display_name_list and x_display_list.
10337 We can't use Fdelq because that can quit. */
10338 if (! NILP (x_display_name_list
)
10339 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
10340 x_display_name_list
= XCDR (x_display_name_list
);
10345 tail
= x_display_name_list
;
10346 while (CONSP (tail
) && CONSP (XCDR (tail
)))
10348 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
10350 XSETCDR (tail
, XCDR (XCDR (tail
)));
10353 tail
= XCDR (tail
);
10357 if (next_noop_dpyinfo
== dpyinfo
)
10358 next_noop_dpyinfo
= dpyinfo
->next
;
10360 if (x_display_list
== dpyinfo
)
10361 x_display_list
= dpyinfo
->next
;
10364 struct x_display_info
*tail
;
10366 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
10367 if (tail
->next
== dpyinfo
)
10368 tail
->next
= tail
->next
->next
;
10371 xfree (dpyinfo
->x_id_name
);
10372 xfree (dpyinfo
->x_dnd_atoms
);
10373 xfree (dpyinfo
->color_cells
);
10377 #ifdef USE_X_TOOLKIT
10379 /* Atimer callback function for TIMER. Called every 0.1s to process
10380 Xt timeouts, if needed. We must avoid calling XtAppPending as
10381 much as possible because that function does an implicit XFlush
10382 that slows us down. */
10385 x_process_timeouts (timer
)
10386 struct atimer
*timer
;
10389 x_timeout_atimer_activated_flag
= 0;
10390 if (toolkit_scroll_bar_interaction
|| popup_activated ())
10392 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
10393 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
10394 /* Reactivate the atimer for next time. */
10395 x_activate_timeout_atimer ();
10400 /* Install an asynchronous timer that processes Xt timeout events
10401 every 0.1s as long as either `toolkit_scroll_bar_interaction' or
10402 `popup_activated_flag' (in xmenu.c) is set. Make sure to call this
10403 function whenever these variables are set. This is necessary
10404 because some widget sets use timeouts internally, for example the
10405 LessTif menu bar, or the Xaw3d scroll bar. When Xt timeouts aren't
10406 processed, these widgets don't behave normally. */
10409 x_activate_timeout_atimer ()
10412 if (!x_timeout_atimer_activated_flag
)
10414 EMACS_TIME interval
;
10416 EMACS_SET_SECS_USECS (interval
, 0, 100000);
10417 start_atimer (ATIMER_RELATIVE
, interval
, x_process_timeouts
, 0);
10418 x_timeout_atimer_activated_flag
= 1;
10423 #endif /* USE_X_TOOLKIT */
10426 /* Set up use of X before we make the first connection. */
10428 extern frame_parm_handler x_frame_parm_handlers
[];
10430 static struct redisplay_interface x_redisplay_interface
=
10432 x_frame_parm_handlers
,
10436 x_clear_end_of_line
,
10438 x_after_update_window_line
,
10439 x_update_window_begin
,
10440 x_update_window_end
,
10446 0, /* flush_display_optional */
10448 x_clear_window_mouse_face
,
10449 x_get_glyph_overhangs
,
10450 x_fix_overlapping_area
,
10451 x_draw_fringe_bitmap
,
10452 0, /* define_fringe_bitmap */
10453 0, /* destroy_fringe_bitmap */
10454 x_compute_glyph_string_overhangs
,
10455 x_draw_glyph_string
,
10456 x_define_frame_cursor
,
10457 x_clear_frame_area
,
10458 x_draw_window_cursor
,
10459 x_draw_vertical_window_border
,
10460 x_shift_glyphs_for_insert
10464 /* This function is called when the last frame on a display is deleted. */
10466 x_delete_terminal (struct terminal
*terminal
)
10468 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
10470 /* Protect against recursive calls. delete_frame in
10471 delete_terminal calls us back when it deletes our last frame. */
10472 if (!terminal
->name
)
10477 /* We must close our connection to the XIM server before closing the
10480 xim_close_dpy (dpyinfo
);
10483 /* If called from x_connection_closed, the display may already be closed
10484 and dpyinfo->display was set to 0 to indicate that. */
10485 if (dpyinfo
->display
)
10487 x_destroy_all_bitmaps (dpyinfo
);
10488 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
10490 /* Whether or not XCloseDisplay destroys the associated resource
10491 database depends on the version of libX11. To avoid both
10492 crash and memory leak, we dissociate the database from the
10493 display and then destroy dpyinfo->xrdb ourselves.
10495 Unfortunately, the above strategy does not work in some
10496 situations due to a bug in newer versions of libX11: because
10497 XrmSetDatabase doesn't clear the flag XlibDisplayDfltRMDB if
10498 dpy->db is NULL, XCloseDisplay destroys the associated
10499 database whereas it has not been created by XGetDefault
10500 (Bug#21974 in freedesktop.org Bugzilla). As a workaround, we
10501 don't destroy the database here in order to avoid the crash
10502 in the above situations for now, though that may cause memory
10503 leaks in other situations. */
10505 #ifdef HAVE_XRMSETDATABASE
10506 XrmSetDatabase (dpyinfo
->display
, NULL
);
10508 dpyinfo
->display
->db
= NULL
;
10510 /* We used to call XrmDestroyDatabase from x_delete_display, but
10511 some older versions of libX11 crash if we call it after
10512 closing all the displays. */
10513 XrmDestroyDatabase (dpyinfo
->xrdb
);
10517 xg_display_close (dpyinfo
->display
);
10519 #ifdef USE_X_TOOLKIT
10520 XtCloseDisplay (dpyinfo
->display
);
10522 XCloseDisplay (dpyinfo
->display
);
10524 #endif /* ! USE_GTK */
10527 /* Mark as dead. */
10528 dpyinfo
->display
= NULL
;
10529 x_delete_display (dpyinfo
);
10533 /* Create a struct terminal, initialize it with the X11 specific
10534 functions and make DISPLAY->TERMINAL point to it. */
10536 static struct terminal
*
10537 x_create_terminal (struct x_display_info
*dpyinfo
)
10539 struct terminal
*terminal
;
10541 terminal
= create_terminal ();
10543 terminal
->type
= output_x_window
;
10544 terminal
->display_info
.x
= dpyinfo
;
10545 dpyinfo
->terminal
= terminal
;
10547 /* kboard is initialized in x_term_init. */
10549 terminal
->clear_frame_hook
= x_clear_frame
;
10550 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
10551 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
10552 terminal
->ring_bell_hook
= XTring_bell
;
10553 terminal
->toggle_invisible_pointer_hook
= XTtoggle_invisible_pointer
;
10554 terminal
->reset_terminal_modes_hook
= XTreset_terminal_modes
;
10555 terminal
->set_terminal_modes_hook
= XTset_terminal_modes
;
10556 terminal
->update_begin_hook
= x_update_begin
;
10557 terminal
->update_end_hook
= x_update_end
;
10558 terminal
->set_terminal_window_hook
= XTset_terminal_window
;
10559 terminal
->read_socket_hook
= XTread_socket
;
10560 terminal
->frame_up_to_date_hook
= XTframe_up_to_date
;
10561 terminal
->mouse_position_hook
= XTmouse_position
;
10562 terminal
->frame_rehighlight_hook
= XTframe_rehighlight
;
10563 terminal
->frame_raise_lower_hook
= XTframe_raise_lower
;
10564 terminal
->fullscreen_hook
= XTfullscreen_hook
;
10565 terminal
->set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
10566 terminal
->condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
10567 terminal
->redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
10568 terminal
->judge_scroll_bars_hook
= XTjudge_scroll_bars
;
10570 terminal
->delete_frame_hook
= x_destroy_window
;
10571 terminal
->delete_terminal_hook
= x_delete_terminal
;
10573 terminal
->rif
= &x_redisplay_interface
;
10574 terminal
->scroll_region_ok
= 1; /* We'll scroll partial frames. */
10575 terminal
->char_ins_del_ok
= 1;
10576 terminal
->line_ins_del_ok
= 1; /* We'll just blt 'em. */
10577 terminal
->fast_clear_end_of_line
= 1; /* X does this well. */
10578 terminal
->memory_below_frame
= 0; /* We don't remember what scrolls
10585 x_initialize (void)
10590 last_tool_bar_item
= -1;
10591 any_help_event_p
= 0;
10592 ignore_next_mouse_click_timeout
= 0;
10594 x_session_initialized
= 0;
10598 current_count
= -1;
10601 /* Try to use interrupt input; if we can't, then start polling. */
10602 Fset_input_interrupt_mode (Qt
);
10604 #ifdef USE_X_TOOLKIT
10605 XtToolkitInitialize ();
10607 Xt_app_con
= XtCreateApplicationContext ();
10609 /* Register a converter from strings to pixels, which uses
10610 Emacs' color allocation infrastructure. */
10611 XtAppSetTypeConverter (Xt_app_con
,
10612 XtRString
, XtRPixel
, cvt_string_to_pixel
,
10613 cvt_string_to_pixel_args
,
10614 XtNumber (cvt_string_to_pixel_args
),
10615 XtCacheByDisplay
, cvt_pixel_dtor
);
10617 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
10620 #ifdef USE_TOOLKIT_SCROLL_BARS
10622 xaw3d_arrow_scroll
= False
;
10623 xaw3d_pick_top
= True
;
10627 pending_autoraise_frame
= 0;
10628 pending_event_wait
.f
= 0;
10629 pending_event_wait
.eventtype
= 0;
10631 /* Note that there is no real way portable across R3/R4 to get the
10632 original error handler. */
10633 XSetErrorHandler (x_error_handler
);
10634 XSetIOErrorHandler (x_io_error_quitter
);
10636 signal (SIGPIPE
, x_connection_signal
);
10638 xgselect_initialize ();
10643 syms_of_xterm (void)
10645 x_error_message
= NULL
;
10647 staticpro (&x_display_name_list
);
10648 x_display_name_list
= Qnil
;
10650 staticpro (&last_mouse_scroll_bar
);
10651 last_mouse_scroll_bar
= Qnil
;
10653 staticpro (&Qvendor_specific_keysyms
);
10654 Qvendor_specific_keysyms
= intern_c_string ("vendor-specific-keysyms");
10656 staticpro (&Qlatin_1
);
10657 Qlatin_1
= intern_c_string ("latin-1");
10659 staticpro (&last_mouse_press_frame
);
10660 last_mouse_press_frame
= Qnil
;
10663 xg_default_icon_file
= make_pure_c_string ("icons/hicolor/scalable/apps/emacs.svg");
10664 staticpro (&xg_default_icon_file
);
10666 Qx_gtk_map_stock
= intern_c_string ("x-gtk-map-stock");
10667 staticpro (&Qx_gtk_map_stock
);
10670 DEFVAR_BOOL ("x-use-underline-position-properties",
10671 &x_use_underline_position_properties
,
10672 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
10673 A value of nil means ignore them. If you encounter fonts with bogus
10674 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
10675 to 4.1, set this to nil. You can also use `underline-minimum-offset'
10676 to override the font's UNDERLINE_POSITION for small font display
10678 x_use_underline_position_properties
= 1;
10680 DEFVAR_BOOL ("x-underline-at-descent-line",
10681 &x_underline_at_descent_line
,
10682 doc
: /* *Non-nil means to draw the underline at the same place as the descent line.
10683 A value of nil means to draw the underline according to the value of the
10684 variable `x-use-underline-position-properties', which is usually at the
10685 baseline level. The default value is nil. */);
10686 x_underline_at_descent_line
= 0;
10688 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
10689 &x_mouse_click_focus_ignore_position
,
10690 doc
: /* Non-nil means that a mouse click to focus a frame does not move point.
10691 This variable is only used when the window manager requires that you
10692 click on a frame to select it (give it focus). In that case, a value
10693 of nil, means that the selected window and cursor position changes to
10694 reflect the mouse click position, while a non-nil value means that the
10695 selected window or cursor position is preserved. */);
10696 x_mouse_click_focus_ignore_position
= 0;
10698 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
10699 doc
: /* What X toolkit scroll bars Emacs uses.
10700 A value of nil means Emacs doesn't use X toolkit scroll bars.
10701 Otherwise, value is a symbol describing the X toolkit. */);
10702 #ifdef USE_TOOLKIT_SCROLL_BARS
10704 Vx_toolkit_scroll_bars
= intern_c_string ("motif");
10705 #elif defined HAVE_XAW3D
10706 Vx_toolkit_scroll_bars
= intern_c_string ("xaw3d");
10708 Vx_toolkit_scroll_bars
= intern_c_string ("gtk");
10710 Vx_toolkit_scroll_bars
= intern_c_string ("xaw");
10713 Vx_toolkit_scroll_bars
= Qnil
;
10716 staticpro (&last_mouse_motion_frame
);
10717 last_mouse_motion_frame
= Qnil
;
10719 Qmodifier_value
= intern_c_string ("modifier-value");
10720 Qalt
= intern_c_string ("alt");
10721 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
10722 Qhyper
= intern_c_string ("hyper");
10723 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
10724 Qmeta
= intern_c_string ("meta");
10725 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
10726 Qsuper
= intern_c_string ("super");
10727 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
10729 DEFVAR_LISP ("x-alt-keysym", &Vx_alt_keysym
,
10730 doc
: /* Which keys Emacs uses for the alt modifier.
10731 This should be one of the symbols `alt', `hyper', `meta', `super'.
10732 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
10733 is nil, which is the same as `alt'. */);
10734 Vx_alt_keysym
= Qnil
;
10736 DEFVAR_LISP ("x-hyper-keysym", &Vx_hyper_keysym
,
10737 doc
: /* Which keys Emacs uses for the hyper modifier.
10738 This should be one of the symbols `alt', `hyper', `meta', `super'.
10739 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
10740 default is nil, which is the same as `hyper'. */);
10741 Vx_hyper_keysym
= Qnil
;
10743 DEFVAR_LISP ("x-meta-keysym", &Vx_meta_keysym
,
10744 doc
: /* Which keys Emacs uses for the meta modifier.
10745 This should be one of the symbols `alt', `hyper', `meta', `super'.
10746 For example, `meta' means use the Meta_L and Meta_R keysyms. The
10747 default is nil, which is the same as `meta'. */);
10748 Vx_meta_keysym
= Qnil
;
10750 DEFVAR_LISP ("x-super-keysym", &Vx_super_keysym
,
10751 doc
: /* Which keys Emacs uses for the super modifier.
10752 This should be one of the symbols `alt', `hyper', `meta', `super'.
10753 For example, `super' means use the Super_L and Super_R keysyms. The
10754 default is nil, which is the same as `super'. */);
10755 Vx_super_keysym
= Qnil
;
10757 DEFVAR_LISP ("x-keysym-table", &Vx_keysym_table
,
10758 doc
: /* Hash table of character codes indexed by X keysym codes. */);
10759 Vx_keysym_table
= make_hash_table (Qeql
, make_number (900),
10760 make_float (DEFAULT_REHASH_SIZE
),
10761 make_float (DEFAULT_REHASH_THRESHOLD
),
10765 #endif /* HAVE_X_WINDOWS */
10767 /* arch-tag: 6d4e4cb7-abc1-4302-9585-d84dcfb09d0f
10768 (do not change this comment) */