1 /* X Communication module for terminals which understand the X protocol.
3 Copyright (C) 1989, 1993-2011 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 /* New display code by Gerd Moellmann <gerd@gnu.org>. */
21 /* Xt features made by Fred Pierresteguy. */
31 #include "blockinput.h"
33 /* Need syssignal.h for various externs and definitions that may be required
34 by some configurations for calls to signal later in this source file. */
35 #include "syssignal.h"
37 /* This may include sys/types.h, and that somehow loses
38 if this is not done before the other system files. */
40 #include <X11/cursorfont.h>
42 /* Load sys/types.h if not already loaded.
43 In some systems loading it twice is suicidal. */
45 #include <sys/types.h>
48 #include <sys/ioctl.h>
57 /* Caused redefinition of DBL_DIG on Netbsd; seems not to be needed. */
58 /* #include <sys/param.h> */
61 #include "character.h"
64 #include "dispextern.h"
66 #include "termhooks.h"
69 #include "emacs-icon.h"
74 #include "intervals.h"
80 #include "xsettings.h"
82 #include "sysselect.h"
85 #include <X11/Shell.h>
88 #ifdef HAVE_SYS_TIME_H
99 #include "../lwlib/xlwmenu.h"
103 #if !defined(NO_EDITRES)
105 extern void _XEditResCheckMessages ();
106 #endif /* not NO_EDITRES */
108 /* Include toolkit specific headers for the scroll bar widget. */
110 #ifdef USE_TOOLKIT_SCROLL_BARS
111 #if defined USE_MOTIF
112 #include <Xm/Xm.h> /* for LESSTIF_VERSION */
113 #include <Xm/ScrollBar.h>
114 #else /* !USE_MOTIF i.e. use Xaw */
117 #include <X11/Xaw3d/Simple.h>
118 #include <X11/Xaw3d/Scrollbar.h>
119 #include <X11/Xaw3d/ThreeD.h>
120 #else /* !HAVE_XAW3D */
121 #include <X11/Xaw/Simple.h>
122 #include <X11/Xaw/Scrollbar.h>
123 #endif /* !HAVE_XAW3D */
125 #define XtNpickTop "pickTop"
126 #endif /* !XtNpickTop */
127 #endif /* !USE_MOTIF */
128 #endif /* USE_TOOLKIT_SCROLL_BARS */
130 #endif /* USE_X_TOOLKIT */
134 #ifndef XtNinitialState
135 #define XtNinitialState "initialState"
139 /* Default to using XIM if available. */
143 int use_xim
= 0; /* configure --without-xim */
148 /* Non-zero means that a HELP_EVENT has been generated since Emacs
151 static int any_help_event_p
;
153 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
154 static Lisp_Object last_window
;
156 /* This is a chain of structures for all the X displays currently in
159 struct x_display_info
*x_display_list
;
161 /* This is a list of cons cells, each of the form (NAME
162 . FONT-LIST-CACHE), one for each element of x_display_list and in
163 the same order. NAME is the name of the frame. FONT-LIST-CACHE
164 records previous values returned by x-list-fonts. */
166 Lisp_Object x_display_name_list
;
168 /* Frame being updated by update_frame. This is declared in term.c.
169 This is set by update_begin and looked at by all the XT functions.
170 It is zero while not inside an update. In that case, the XT
171 functions assume that `selected_frame' is the frame to apply to. */
173 extern struct frame
*updating_frame
;
175 /* This is a frame waiting to be auto-raised, within XTread_socket. */
177 static struct frame
*pending_autoraise_frame
;
179 /* This is a frame waiting for an event matching mask, within XTread_socket. */
184 } pending_event_wait
;
187 /* The application context for Xt use. */
188 XtAppContext Xt_app_con
;
189 static String Xt_default_resources
[] = {0};
190 #endif /* USE_X_TOOLKIT */
192 /* Non-zero means user is interacting with a toolkit scroll bar. */
194 static int toolkit_scroll_bar_interaction
;
196 /* Non-zero timeout value means ignore next mouse click if it arrives
197 before that timeout elapses (i.e. as part of the same sequence of
198 events resulting from clicking on a frame to select it). */
200 static unsigned long ignore_next_mouse_click_timeout
;
204 Formerly, we used PointerMotionHintMask (in standard_event_mask)
205 so that we would have to call XQueryPointer after each MotionNotify
206 event to ask for another such event. However, this made mouse tracking
207 slow, and there was a bug that made it eventually stop.
209 Simply asking for MotionNotify all the time seems to work better.
211 In order to avoid asking for motion events and then throwing most
212 of them away or busy-polling the server for mouse positions, we ask
213 the server for pointer motion hints. This means that we get only
214 one event per group of mouse movements. "Groups" are delimited by
215 other kinds of events (focus changes and button clicks, for
216 example), or by XQueryPointer calls; when one of these happens, we
217 get another MotionNotify event the next time the mouse moves. This
218 is at least as efficient as getting motion events when mouse
219 tracking is on, and I suspect only negligibly worse when tracking
222 /* Where the mouse was last time we reported a mouse event. */
224 static XRectangle last_mouse_glyph
;
225 static FRAME_PTR last_mouse_glyph_frame
;
226 static Lisp_Object last_mouse_press_frame
;
228 /* The scroll bar in which the last X motion event occurred.
230 If the last X motion event occurred in a scroll bar, we set this so
231 XTmouse_position can know whether to report a scroll bar motion or
234 If the last X motion event didn't occur in a scroll bar, we set
235 this to Qnil, to tell XTmouse_position to return an ordinary motion
238 static Lisp_Object last_mouse_scroll_bar
;
240 /* This is a hack. We would really prefer that XTmouse_position would
241 return the time associated with the position it returns, but there
242 doesn't seem to be any way to wrest the time-stamp from the server
243 along with the position query. So, we just keep track of the time
244 of the last movement we received, and return that in hopes that
245 it's somewhat accurate. */
247 static Time last_mouse_movement_time
;
249 /* Time for last user interaction as returned in X events. */
251 static Time last_user_time
;
253 /* Incremented by XTread_socket whenever it really tries to read
257 static int volatile input_signal_count
;
259 static int input_signal_count
;
262 /* Used locally within XTread_socket. */
264 static int x_noop_count
;
266 static Lisp_Object Qalt
, Qhyper
, Qmeta
, Qsuper
, Qmodifier_value
;
268 static Lisp_Object Qvendor_specific_keysyms
;
269 static Lisp_Object Qlatin_1
;
272 /* The name of the Emacs icon file. */
273 static Lisp_Object xg_default_icon_file
;
275 /* Used in gtkutil.c. */
276 Lisp_Object Qx_gtk_map_stock
;
279 /* Some functions take this as char *, not const char *. */
280 static char emacs_class
[] = EMACS_CLASS
;
282 /* XEmbed implementation. */
284 #define XEMBED_VERSION 0
288 XEMBED_MAPPED
= 1 << 0
293 XEMBED_EMBEDDED_NOTIFY
= 0,
294 XEMBED_WINDOW_ACTIVATE
= 1,
295 XEMBED_WINDOW_DEACTIVATE
= 2,
296 XEMBED_REQUEST_FOCUS
= 3,
298 XEMBED_FOCUS_OUT
= 5,
299 XEMBED_FOCUS_NEXT
= 6,
300 XEMBED_FOCUS_PREV
= 7,
302 XEMBED_MODALITY_ON
= 10,
303 XEMBED_MODALITY_OFF
= 11,
304 XEMBED_REGISTER_ACCELERATOR
= 12,
305 XEMBED_UNREGISTER_ACCELERATOR
= 13,
306 XEMBED_ACTIVATE_ACCELERATOR
= 14
309 /* Used in x_flush. */
311 static int x_alloc_nearest_color_1 (Display
*, Colormap
, XColor
*);
312 static void x_set_window_size_1 (struct frame
*, int, int, int);
313 static const XColor
*x_color_cells (Display
*, int *);
314 static void x_update_window_end (struct window
*, int, int);
316 static int x_io_error_quitter (Display
*);
317 static struct terminal
*x_create_terminal (struct x_display_info
*);
318 void x_delete_terminal (struct terminal
*);
319 static void x_update_end (struct frame
*);
320 static void XTframe_up_to_date (struct frame
*);
321 static void XTset_terminal_modes (struct terminal
*);
322 static void XTreset_terminal_modes (struct terminal
*);
323 static void x_clear_frame (struct frame
*);
324 static void frame_highlight (struct frame
*);
325 static void frame_unhighlight (struct frame
*);
326 static void x_new_focus_frame (struct x_display_info
*, struct frame
*);
327 static void x_focus_changed (int, int, struct x_display_info
*,
328 struct frame
*, struct input_event
*);
329 static void x_detect_focus_change (struct x_display_info
*,
330 XEvent
*, struct input_event
*);
331 static void XTframe_rehighlight (struct frame
*);
332 static void x_frame_rehighlight (struct x_display_info
*);
333 static void x_draw_hollow_cursor (struct window
*, struct glyph_row
*);
334 static void x_draw_bar_cursor (struct window
*, struct glyph_row
*, int,
335 enum text_cursor_kinds
);
337 static void x_clip_to_row (struct window
*, struct glyph_row
*, int, GC
);
338 static void x_flush (struct frame
*f
);
339 static void x_update_begin (struct frame
*);
340 static void x_update_window_begin (struct window
*);
341 static void x_after_update_window_line (struct glyph_row
*);
342 static struct scroll_bar
*x_window_to_scroll_bar (Display
*, Window
);
343 static void x_scroll_bar_report_motion (struct frame
**, Lisp_Object
*,
344 enum scroll_bar_part
*,
345 Lisp_Object
*, Lisp_Object
*,
347 static void x_handle_net_wm_state (struct frame
*, XPropertyEvent
*);
348 static void x_check_fullscreen (struct frame
*);
349 static void x_check_expected_move (struct frame
*, int, int);
350 static void x_sync_with_move (struct frame
*, int, int, int);
351 static int handle_one_xevent (struct x_display_info
*, XEvent
*,
352 int *, struct input_event
*);
353 /* Don't declare this NO_RETURN because we want no
354 interference with debugging failing X calls. */
355 static SIGTYPE
x_connection_closed (Display
*, const char *);
358 /* Flush display of frame F, or of all frames if F is null. */
361 x_flush (struct frame
*f
)
363 /* Don't call XFlush when it is not safe to redisplay; the X
364 connection may be broken. */
365 if (!NILP (Vinhibit_redisplay
))
371 Lisp_Object rest
, frame
;
372 FOR_EACH_FRAME (rest
, frame
)
373 if (FRAME_X_P (XFRAME (frame
)))
374 x_flush (XFRAME (frame
));
376 else if (FRAME_X_P (f
))
377 XFlush (FRAME_X_DISPLAY (f
));
382 /* Remove calls to XFlush by defining XFlush to an empty replacement.
383 Calls to XFlush should be unnecessary because the X output buffer
384 is flushed automatically as needed by calls to XPending,
385 XNextEvent, or XWindowEvent according to the XFlush man page.
386 XTread_socket calls XPending. Removing XFlush improves
389 #define XFlush(DISPLAY) (void) 0
392 /***********************************************************************
394 ***********************************************************************/
398 /* This is a function useful for recording debugging information about
399 the sequence of occurrences in this file. */
407 struct record event_record
[100];
409 int event_record_index
;
412 record_event (char *locus
, int type
)
414 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
415 event_record_index
= 0;
417 event_record
[event_record_index
].locus
= locus
;
418 event_record
[event_record_index
].type
= type
;
419 event_record_index
++;
426 /* Return the struct x_display_info corresponding to DPY. */
428 struct x_display_info
*
429 x_display_info_for_display (Display
*dpy
)
431 struct x_display_info
*dpyinfo
;
433 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
434 if (dpyinfo
->display
== dpy
)
440 #define OPAQUE 0xffffffff
443 x_set_frame_alpha (struct frame
*f
)
445 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
446 Display
*dpy
= FRAME_X_DISPLAY (f
);
447 Window win
= FRAME_OUTER_WINDOW (f
);
449 double alpha_min
= 1.0;
452 if (FRAME_X_DISPLAY_INFO (f
)->root_window
!= FRAME_X_OUTPUT (f
)->parent_desc
)
453 /* Since the WM decoration lies under the FRAME_OUTER_WINDOW,
454 we must treat the former instead of the latter. */
455 win
= FRAME_X_OUTPUT (f
)->parent_desc
;
457 if (dpyinfo
->x_highlight_frame
== f
)
462 if (FLOATP (Vframe_alpha_lower_limit
))
463 alpha_min
= XFLOAT_DATA (Vframe_alpha_lower_limit
);
464 else if (INTEGERP (Vframe_alpha_lower_limit
))
465 alpha_min
= (XINT (Vframe_alpha_lower_limit
)) / 100.0;
469 else if (alpha
> 1.0)
471 else if (0.0 <= alpha
&& alpha
< alpha_min
&& alpha_min
<= 1.0)
474 opac
= alpha
* OPAQUE
;
476 /* return unless necessary */
481 unsigned long n
, left
;
483 x_catch_errors (dpy
);
484 rc
= XGetWindowProperty (dpy
, win
, dpyinfo
->Xatom_net_wm_window_opacity
,
485 0L, 1L, False
, XA_CARDINAL
,
486 &actual
, &format
, &n
, &left
,
489 if (rc
== Success
&& actual
!= None
)
491 unsigned long value
= *(unsigned long *)data
;
492 XFree ((void *) data
);
501 XChangeProperty (dpy
, win
, dpyinfo
->Xatom_net_wm_window_opacity
,
502 XA_CARDINAL
, 32, PropModeReplace
,
503 (unsigned char *) &opac
, 1L);
508 x_display_pixel_height (struct x_display_info
*dpyinfo
)
510 return HeightOfScreen (dpyinfo
->screen
);
514 x_display_pixel_width (struct x_display_info
*dpyinfo
)
516 return WidthOfScreen (dpyinfo
->screen
);
520 /***********************************************************************
521 Starting and ending an update
522 ***********************************************************************/
524 /* Start an update of frame F. This function is installed as a hook
525 for update_begin, i.e. it is called when update_begin is called.
526 This function is called prior to calls to x_update_window_begin for
527 each window being updated. Currently, there is nothing to do here
528 because all interesting stuff is done on a window basis. */
531 x_update_begin (struct frame
*f
)
537 /* Start update of window W. Set the global variable updated_window
538 to the window being updated and set output_cursor to the cursor
542 x_update_window_begin (struct window
*w
)
544 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
545 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
548 set_output_cursor (&w
->cursor
);
552 if (f
== hlinfo
->mouse_face_mouse_frame
)
554 /* Don't do highlighting for mouse motion during the update. */
555 hlinfo
->mouse_face_defer
= 1;
557 /* If F needs to be redrawn, simply forget about any prior mouse
559 if (FRAME_GARBAGED_P (f
))
560 hlinfo
->mouse_face_window
= Qnil
;
567 /* Draw a vertical window border from (x,y0) to (x,y1) */
570 x_draw_vertical_window_border (struct window
*w
, int x
, int y0
, int y1
)
572 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
575 face
= FACE_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
577 XSetForeground (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
580 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
581 f
->output_data
.x
->normal_gc
, x
, y0
, x
, y1
);
584 /* End update of window W (which is equal to updated_window).
586 Draw vertical borders between horizontally adjacent windows, and
587 display W's cursor if CURSOR_ON_P is non-zero.
589 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
590 glyphs in mouse-face were overwritten. In that case we have to
591 make sure that the mouse-highlight is properly redrawn.
593 W may be a menu bar pseudo-window in case we don't have X toolkit
594 support. Such windows don't have a cursor, so don't display it
598 x_update_window_end (struct window
*w
, int cursor_on_p
, int mouse_face_overwritten_p
)
600 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (XFRAME (w
->frame
));
602 if (!w
->pseudo_window_p
)
607 display_and_set_cursor (w
, 1, output_cursor
.hpos
,
609 output_cursor
.x
, output_cursor
.y
);
611 if (draw_window_fringes (w
, 1))
612 x_draw_vertical_border (w
);
617 /* If a row with mouse-face was overwritten, arrange for
618 XTframe_up_to_date to redisplay the mouse highlight. */
619 if (mouse_face_overwritten_p
)
621 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
622 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
623 hlinfo
->mouse_face_window
= Qnil
;
626 updated_window
= NULL
;
630 /* End update of frame F. This function is installed as a hook in
634 x_update_end (struct frame
*f
)
636 /* Mouse highlight may be displayed again. */
637 MOUSE_HL_INFO (f
)->mouse_face_defer
= 0;
641 XFlush (FRAME_X_DISPLAY (f
));
647 /* This function is called from various places in xdisp.c whenever a
648 complete update has been performed. The global variable
649 updated_window is not available here. */
652 XTframe_up_to_date (struct frame
*f
)
656 Mouse_HLInfo
*hlinfo
= MOUSE_HL_INFO (f
);
658 if (hlinfo
->mouse_face_deferred_gc
659 || f
== hlinfo
->mouse_face_mouse_frame
)
662 if (hlinfo
->mouse_face_mouse_frame
)
663 note_mouse_highlight (hlinfo
->mouse_face_mouse_frame
,
664 hlinfo
->mouse_face_mouse_x
,
665 hlinfo
->mouse_face_mouse_y
);
666 hlinfo
->mouse_face_deferred_gc
= 0;
673 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
674 arrow bitmaps, or clear the fringes if no bitmaps are required
675 before DESIRED_ROW is made current. The window being updated is
676 found in updated_window. This function It is called from
677 update_window_line only if it is known that there are differences
678 between bitmaps to be drawn between current row and DESIRED_ROW. */
681 x_after_update_window_line (struct glyph_row
*desired_row
)
683 struct window
*w
= updated_window
;
689 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
690 desired_row
->redraw_fringe_bitmaps_p
= 1;
692 /* When a window has disappeared, make sure that no rest of
693 full-width rows stays visible in the internal border. Could
694 check here if updated_window is the leftmost/rightmost window,
695 but I guess it's not worth doing since vertically split windows
696 are almost never used, internal border is rarely set, and the
697 overhead is very small. */
698 if (windows_or_buffers_changed
699 && desired_row
->full_width_p
700 && (f
= XFRAME (w
->frame
),
701 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
703 && (height
= desired_row
->visible_height
,
706 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
709 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
710 0, y
, width
, height
, False
);
711 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
712 FRAME_PIXEL_WIDTH (f
) - width
,
713 y
, width
, height
, False
);
719 x_draw_fringe_bitmap (struct window
*w
, struct glyph_row
*row
, struct draw_fringe_bitmap_params
*p
)
721 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
722 Display
*display
= FRAME_X_DISPLAY (f
);
723 Window window
= FRAME_X_WINDOW (f
);
724 GC gc
= f
->output_data
.x
->normal_gc
;
725 struct face
*face
= p
->face
;
727 /* Must clip because of partially visible lines. */
728 x_clip_to_row (w
, row
, -1, gc
);
732 int bx
= p
->bx
, by
= p
->by
, nx
= p
->nx
, ny
= p
->ny
;
734 /* In case the same realized face is used for fringes and
735 for something displayed in the text (e.g. face `region' on
736 mono-displays, the fill style may have been changed to
737 FillSolid in x_draw_glyph_string_background. */
739 XSetFillStyle (display
, face
->gc
, FillOpaqueStippled
);
741 XSetForeground (display
, face
->gc
, face
->background
);
743 #ifdef USE_TOOLKIT_SCROLL_BARS
744 /* If the fringe is adjacent to the left (right) scroll bar of a
745 leftmost (rightmost, respectively) window, then extend its
746 background to the gap between the fringe and the bar. */
747 if ((WINDOW_LEFTMOST_P (w
)
748 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
749 || (WINDOW_RIGHTMOST_P (w
)
750 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
)))
752 int sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
756 int left
= WINDOW_SCROLL_BAR_AREA_X (w
);
757 int width
= (WINDOW_CONFIG_SCROLL_BAR_COLS (w
)
758 * FRAME_COLUMN_WIDTH (f
));
762 /* Bitmap fills the fringe. */
763 if (left
+ width
== p
->x
)
764 bx
= left
+ sb_width
;
765 else if (p
->x
+ p
->wd
== left
)
769 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
771 nx
= width
- sb_width
;
772 by
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
774 ny
= row
->visible_height
;
779 if (left
+ width
== bx
)
781 bx
= left
+ sb_width
;
782 nx
+= width
- sb_width
;
784 else if (bx
+ nx
== left
)
785 nx
+= width
- sb_width
;
790 if (bx
>= 0 && nx
> 0)
791 XFillRectangle (display
, window
, face
->gc
, bx
, by
, nx
, ny
);
794 XSetForeground (display
, face
->gc
, face
->foreground
);
800 Pixmap pixmap
, clipmask
= (Pixmap
) 0;
801 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
805 bits
= (char *) (p
->bits
+ p
->dh
);
807 bits
= (char *) p
->bits
+ p
->dh
;
809 /* Draw the bitmap. I believe these small pixmaps can be cached
811 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, p
->wd
, p
->h
,
813 ? (p
->overlay_p
? face
->background
814 : f
->output_data
.x
->cursor_pixel
)
816 face
->background
, depth
);
820 clipmask
= XCreatePixmapFromBitmapData (display
,
821 FRAME_X_DISPLAY_INFO (f
)->root_window
,
824 gcv
.clip_mask
= clipmask
;
825 gcv
.clip_x_origin
= p
->x
;
826 gcv
.clip_y_origin
= p
->y
;
827 XChangeGC (display
, gc
, GCClipMask
| GCClipXOrigin
| GCClipYOrigin
, &gcv
);
830 XCopyArea (display
, pixmap
, window
, gc
, 0, 0,
831 p
->wd
, p
->h
, p
->x
, p
->y
);
832 XFreePixmap (display
, pixmap
);
836 gcv
.clip_mask
= (Pixmap
) 0;
837 XChangeGC (display
, gc
, GCClipMask
, &gcv
);
838 XFreePixmap (display
, clipmask
);
842 XSetClipMask (display
, gc
, None
);
847 /* This is called when starting Emacs and when restarting after
848 suspend. When starting Emacs, no X window is mapped. And nothing
849 must be done to Emacs's own window if it is suspended (though that
853 XTset_terminal_modes (struct terminal
*terminal
)
857 /* This is called when exiting or suspending Emacs. Exiting will make
858 the X-windows go away, and suspending requires no action. */
861 XTreset_terminal_modes (struct terminal
*terminal
)
866 /***********************************************************************
868 ***********************************************************************/
872 static void x_set_glyph_string_clipping (struct glyph_string
*);
873 static void x_set_glyph_string_gc (struct glyph_string
*);
874 static void x_draw_glyph_string_background (struct glyph_string
*,
876 static void x_draw_glyph_string_foreground (struct glyph_string
*);
877 static void x_draw_composite_glyph_string_foreground (struct glyph_string
*);
878 static void x_draw_glyph_string_box (struct glyph_string
*);
879 static void x_draw_glyph_string (struct glyph_string
*);
880 static void x_compute_glyph_string_overhangs (struct glyph_string
*);
881 static void x_set_cursor_gc (struct glyph_string
*);
882 static void x_set_mode_line_face_gc (struct glyph_string
*);
883 static void x_set_mouse_face_gc (struct glyph_string
*);
884 static int x_alloc_lighter_color (struct frame
*, Display
*, Colormap
,
885 unsigned long *, double, int);
886 static void x_setup_relief_color (struct frame
*, struct relief
*,
887 double, int, unsigned long);
888 static void x_setup_relief_colors (struct glyph_string
*);
889 static void x_draw_image_glyph_string (struct glyph_string
*);
890 static void x_draw_image_relief (struct glyph_string
*);
891 static void x_draw_image_foreground (struct glyph_string
*);
892 static void x_draw_image_foreground_1 (struct glyph_string
*, Pixmap
);
893 static void x_clear_glyph_string_rect (struct glyph_string
*, int,
895 static void x_draw_relief_rect (struct frame
*, int, int, int, int,
896 int, int, int, int, int, int,
898 static void x_draw_box_rect (struct glyph_string
*, int, int, int, int,
899 int, int, int, XRectangle
*);
900 static void x_scroll_bar_clear (struct frame
*);
903 static void x_check_font (struct frame
*, struct font
*);
907 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
911 x_set_cursor_gc (struct glyph_string
*s
)
913 if (s
->font
== FRAME_FONT (s
->f
)
914 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
915 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
917 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
920 /* Cursor on non-default face: must merge. */
924 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
925 xgcv
.foreground
= s
->face
->background
;
927 /* If the glyph would be invisible, try a different foreground. */
928 if (xgcv
.foreground
== xgcv
.background
)
929 xgcv
.foreground
= s
->face
->foreground
;
930 if (xgcv
.foreground
== xgcv
.background
)
931 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
932 if (xgcv
.foreground
== xgcv
.background
)
933 xgcv
.foreground
= s
->face
->foreground
;
935 /* Make sure the cursor is distinct from text in this face. */
936 if (xgcv
.background
== s
->face
->background
937 && xgcv
.foreground
== s
->face
->foreground
)
939 xgcv
.background
= s
->face
->foreground
;
940 xgcv
.foreground
= s
->face
->background
;
943 IF_DEBUG (x_check_font (s
->f
, s
->font
));
944 xgcv
.graphics_exposures
= False
;
945 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
947 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
948 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
951 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
952 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
954 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
959 /* Set up S->gc of glyph string S for drawing text in mouse face. */
962 x_set_mouse_face_gc (struct glyph_string
*s
)
967 /* What face has to be used last for the mouse face? */
968 face_id
= MOUSE_HL_INFO (s
->f
)->mouse_face_face_id
;
969 face
= FACE_FROM_ID (s
->f
, face_id
);
971 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
973 if (s
->first_glyph
->type
== CHAR_GLYPH
)
974 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
976 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
977 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
978 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
980 if (s
->font
== s
->face
->font
)
984 /* Otherwise construct scratch_cursor_gc with values from FACE
989 xgcv
.background
= s
->face
->background
;
990 xgcv
.foreground
= s
->face
->foreground
;
991 xgcv
.graphics_exposures
= False
;
992 mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
994 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
995 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
998 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
999 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
1001 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1004 xassert (s
->gc
!= 0);
1008 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1009 Faces to use in the mode line have already been computed when the
1010 matrix was built, so there isn't much to do, here. */
1013 x_set_mode_line_face_gc (struct glyph_string
*s
)
1015 s
->gc
= s
->face
->gc
;
1019 /* Set S->gc of glyph string S for drawing that glyph string. Set
1020 S->stippled_p to a non-zero value if the face of S has a stipple
1024 x_set_glyph_string_gc (struct glyph_string
*s
)
1026 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1028 if (s
->hl
== DRAW_NORMAL_TEXT
)
1030 s
->gc
= s
->face
->gc
;
1031 s
->stippled_p
= s
->face
->stipple
!= 0;
1033 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1035 x_set_mode_line_face_gc (s
);
1036 s
->stippled_p
= s
->face
->stipple
!= 0;
1038 else if (s
->hl
== DRAW_CURSOR
)
1040 x_set_cursor_gc (s
);
1043 else if (s
->hl
== DRAW_MOUSE_FACE
)
1045 x_set_mouse_face_gc (s
);
1046 s
->stippled_p
= s
->face
->stipple
!= 0;
1048 else if (s
->hl
== DRAW_IMAGE_RAISED
1049 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1051 s
->gc
= s
->face
->gc
;
1052 s
->stippled_p
= s
->face
->stipple
!= 0;
1056 s
->gc
= s
->face
->gc
;
1057 s
->stippled_p
= s
->face
->stipple
!= 0;
1060 /* GC must have been set. */
1061 xassert (s
->gc
!= 0);
1065 /* Set clipping for output of glyph string S. S may be part of a mode
1066 line or menu if we don't have X toolkit support. */
1069 x_set_glyph_string_clipping (struct glyph_string
*s
)
1071 XRectangle
*r
= s
->clip
;
1072 int n
= get_glyph_string_clip_rects (s
, r
, 2);
1075 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, r
, n
, Unsorted
);
1080 /* Set SRC's clipping for output of glyph string DST. This is called
1081 when we are drawing DST's left_overhang or right_overhang only in
1085 x_set_glyph_string_clipping_exactly (struct glyph_string
*src
, struct glyph_string
*dst
)
1090 r
.width
= src
->width
;
1092 r
.height
= src
->height
;
1095 XSetClipRectangles (dst
->display
, dst
->gc
, 0, 0, &r
, 1, Unsorted
);
1100 Compute left and right overhang of glyph string S. */
1103 x_compute_glyph_string_overhangs (struct glyph_string
*s
)
1106 && (s
->first_glyph
->type
== CHAR_GLYPH
1107 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
1109 struct font_metrics metrics
;
1111 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1113 unsigned *code
= alloca (sizeof (unsigned) * s
->nchars
);
1114 struct font
*font
= s
->font
;
1117 for (i
= 0; i
< s
->nchars
; i
++)
1118 code
[i
] = (s
->char2b
[i
].byte1
<< 8) | s
->char2b
[i
].byte2
;
1119 font
->driver
->text_extents (font
, code
, s
->nchars
, &metrics
);
1123 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1125 composition_gstring_width (gstring
, s
->cmp_from
, s
->cmp_to
, &metrics
);
1127 s
->right_overhang
= (metrics
.rbearing
> metrics
.width
1128 ? metrics
.rbearing
- metrics
.width
: 0);
1129 s
->left_overhang
= metrics
.lbearing
< 0 ? - metrics
.lbearing
: 0;
1133 s
->right_overhang
= s
->cmp
->rbearing
- s
->cmp
->pixel_width
;
1134 s
->left_overhang
= - s
->cmp
->lbearing
;
1139 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1142 x_clear_glyph_string_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
1145 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
1146 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
1147 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
1148 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
1152 /* Draw the background of glyph_string S. If S->background_filled_p
1153 is non-zero don't draw it. FORCE_P non-zero means draw the
1154 background even if it wouldn't be drawn normally. This is used
1155 when a string preceding S draws into the background of S, or S
1156 contains the first component of a composition. */
1159 x_draw_glyph_string_background (struct glyph_string
*s
, int force_p
)
1161 /* Nothing to do if background has already been drawn or if it
1162 shouldn't be drawn in the first place. */
1163 if (!s
->background_filled_p
)
1165 int box_line_width
= max (s
->face
->box_line_width
, 0);
1169 /* Fill background with a stipple pattern. */
1170 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1171 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1172 s
->y
+ box_line_width
,
1173 s
->background_width
,
1174 s
->height
- 2 * box_line_width
);
1175 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1176 s
->background_filled_p
= 1;
1178 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1179 || s
->font_not_found_p
1180 || s
->extends_to_end_of_line_p
1183 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1184 s
->background_width
,
1185 s
->height
- 2 * box_line_width
);
1186 s
->background_filled_p
= 1;
1192 /* Draw the foreground of glyph string S. */
1195 x_draw_glyph_string_foreground (struct glyph_string
*s
)
1199 /* If first glyph of S has a left box line, start drawing the text
1200 of S to the right of that box line. */
1201 if (s
->face
->box
!= FACE_NO_BOX
1202 && s
->first_glyph
->left_box_line_p
)
1203 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1207 /* Draw characters of S as rectangles if S's font could not be
1209 if (s
->font_not_found_p
)
1211 for (i
= 0; i
< s
->nchars
; ++i
)
1213 struct glyph
*g
= s
->first_glyph
+ i
;
1214 XDrawRectangle (s
->display
, s
->window
,
1215 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1217 x
+= g
->pixel_width
;
1222 struct font
*font
= s
->font
;
1223 int boff
= font
->baseline_offset
;
1226 if (font
->vertical_centering
)
1227 boff
= VCENTER_BASELINE_OFFSET (font
, s
->f
) - boff
;
1229 y
= s
->ybase
- boff
;
1231 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1232 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 0);
1234 font
->driver
->draw (s
, 0, s
->nchars
, x
, y
, 1);
1235 if (s
->face
->overstrike
)
1236 font
->driver
->draw (s
, 0, s
->nchars
, x
+ 1, y
, 0);
1240 /* Draw the foreground of composite glyph string S. */
1243 x_draw_composite_glyph_string_foreground (struct glyph_string
*s
)
1246 struct font
*font
= s
->font
;
1248 /* If first glyph of S has a left box line, start drawing the text
1249 of S to the right of that box line. */
1250 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1251 && s
->first_glyph
->left_box_line_p
)
1252 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1256 /* S is a glyph string for a composition. S->cmp_from is the index
1257 of the first character drawn for glyphs of this composition.
1258 S->cmp_from == 0 means we are drawing the very first character of
1259 this composition. */
1261 /* Draw a rectangle for the composition if the font for the very
1262 first character of the composition could not be loaded. */
1263 if (s
->font_not_found_p
)
1265 if (s
->cmp_from
== 0)
1266 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, s
->y
,
1267 s
->width
- 1, s
->height
- 1);
1269 else if (! s
->first_glyph
->u
.cmp
.automatic
)
1273 for (i
= 0, j
= s
->cmp_from
; i
< s
->nchars
; i
++, j
++)
1274 if (COMPOSITION_GLYPH (s
->cmp
, j
) != '\t')
1276 int xx
= x
+ s
->cmp
->offsets
[j
* 2];
1277 int yy
= y
- s
->cmp
->offsets
[j
* 2 + 1];
1279 font
->driver
->draw (s
, j
, j
+ 1, xx
, yy
, 0);
1280 if (s
->face
->overstrike
)
1281 font
->driver
->draw (s
, j
, j
+ 1, xx
+ 1, yy
, 0);
1286 Lisp_Object gstring
= composition_gstring_from_id (s
->cmp_id
);
1291 for (i
= j
= s
->cmp_from
; i
< s
->cmp_to
; i
++)
1293 glyph
= LGSTRING_GLYPH (gstring
, i
);
1294 if (NILP (LGLYPH_ADJUSTMENT (glyph
)))
1295 width
+= LGLYPH_WIDTH (glyph
);
1298 int xoff
, yoff
, wadjust
;
1302 font
->driver
->draw (s
, j
, i
, x
, y
, 0);
1303 if (s
->face
->overstrike
)
1304 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, 0);
1307 xoff
= LGLYPH_XOFF (glyph
);
1308 yoff
= LGLYPH_YOFF (glyph
);
1309 wadjust
= LGLYPH_WADJUST (glyph
);
1310 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
, y
+ yoff
, 0);
1311 if (s
->face
->overstrike
)
1312 font
->driver
->draw (s
, i
, i
+ 1, x
+ xoff
+ 1, y
+ yoff
, 0);
1320 font
->driver
->draw (s
, j
, i
, x
, y
, 0);
1321 if (s
->face
->overstrike
)
1322 font
->driver
->draw (s
, j
, i
, x
+ 1, y
, 0);
1328 /* Draw the foreground of glyph string S for glyphless characters. */
1331 x_draw_glyphless_glyph_string_foreground (struct glyph_string
*s
)
1333 struct glyph
*glyph
= s
->first_glyph
;
1337 /* If first glyph of S has a left box line, start drawing the text
1338 of S to the right of that box line. */
1339 if (s
->face
&& s
->face
->box
!= FACE_NO_BOX
1340 && s
->first_glyph
->left_box_line_p
)
1341 x
= s
->x
+ eabs (s
->face
->box_line_width
);
1347 for (i
= 0; i
< s
->nchars
; i
++, glyph
++)
1349 char buf
[7], *str
= NULL
;
1350 int len
= glyph
->u
.glyphless
.len
;
1352 if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_ACRONYM
)
1355 && CHAR_TABLE_P (Vglyphless_char_display
)
1356 && (CHAR_TABLE_EXTRA_SLOTS (XCHAR_TABLE (Vglyphless_char_display
))
1360 = (! glyph
->u
.glyphless
.for_no_font
1361 ? CHAR_TABLE_REF (Vglyphless_char_display
,
1362 glyph
->u
.glyphless
.ch
)
1363 : XCHAR_TABLE (Vglyphless_char_display
)->extras
[0]);
1364 if (STRINGP (acronym
))
1365 str
= SSDATA (acronym
);
1368 else if (glyph
->u
.glyphless
.method
== GLYPHLESS_DISPLAY_HEX_CODE
)
1370 sprintf ((char *) buf
, "%0*X",
1371 glyph
->u
.glyphless
.ch
< 0x10000 ? 4 : 6,
1372 glyph
->u
.glyphless
.ch
);
1378 int upper_len
= (len
+ 1) / 2;
1381 /* It is assured that all LEN characters in STR is ASCII. */
1382 for (j
= 0; j
< len
; j
++)
1384 code
= s
->font
->driver
->encode_char (s
->font
, str
[j
]);
1385 STORE_XCHAR2B (char2b
+ j
, code
>> 8, code
& 0xFF);
1387 s
->font
->driver
->draw (s
, 0, upper_len
,
1388 x
+ glyph
->slice
.glyphless
.upper_xoff
,
1389 s
->ybase
+ glyph
->slice
.glyphless
.upper_yoff
,
1391 s
->font
->driver
->draw (s
, upper_len
, len
,
1392 x
+ glyph
->slice
.glyphless
.lower_xoff
,
1393 s
->ybase
+ glyph
->slice
.glyphless
.lower_yoff
,
1396 if (glyph
->u
.glyphless
.method
!= GLYPHLESS_DISPLAY_THIN_SPACE
)
1397 XDrawRectangle (s
->display
, s
->window
, s
->gc
,
1398 x
, s
->ybase
- glyph
->ascent
,
1399 glyph
->pixel_width
- 1,
1400 glyph
->ascent
+ glyph
->descent
- 1);
1401 x
+= glyph
->pixel_width
;
1405 #ifdef USE_X_TOOLKIT
1407 static struct frame
*x_frame_of_widget (Widget
);
1408 static Boolean
cvt_string_to_pixel (Display
*, XrmValue
*, Cardinal
*,
1409 XrmValue
*, XrmValue
*, XtPointer
*);
1410 static void cvt_pixel_dtor (XtAppContext
, XrmValue
*, XtPointer
,
1411 XrmValue
*, Cardinal
*);
1414 /* Return the frame on which widget WIDGET is used.. Abort if frame
1415 cannot be determined. */
1417 static struct frame
*
1418 x_frame_of_widget (Widget widget
)
1420 struct x_display_info
*dpyinfo
;
1424 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
1426 /* Find the top-level shell of the widget. Note that this function
1427 can be called when the widget is not yet realized, so XtWindow
1428 (widget) == 0. That's the reason we can't simply use
1429 x_any_window_to_frame. */
1430 while (!XtIsTopLevelShell (widget
))
1431 widget
= XtParent (widget
);
1433 /* Look for a frame with that top-level widget. Allocate the color
1434 on that frame to get the right gamma correction value. */
1435 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1436 if (FRAMEP (XCAR (tail
))
1437 && (f
= XFRAME (XCAR (tail
)),
1439 && f
->output_data
.nothing
!= 1
1440 && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
))
1441 && f
->output_data
.x
->widget
== widget
)
1448 /* Allocate the color COLOR->pixel on the screen and display of
1449 widget WIDGET in colormap CMAP. If an exact match cannot be
1450 allocated, try the nearest color available. Value is non-zero
1451 if successful. This is called from lwlib. */
1454 x_alloc_nearest_color_for_widget (Widget widget
, Colormap cmap
, XColor
*color
)
1456 struct frame
*f
= x_frame_of_widget (widget
);
1457 return x_alloc_nearest_color (f
, cmap
, color
);
1461 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1462 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1463 If this produces the same color as PIXEL, try a color where all RGB
1464 values have DELTA added. Return the allocated color in *PIXEL.
1465 DISPLAY is the X display, CMAP is the colormap to operate on.
1466 Value is non-zero if successful. */
1469 x_alloc_lighter_color_for_widget (Widget widget
, Display
*display
, Colormap cmap
,
1470 unsigned long *pixel
, double factor
, int delta
)
1472 struct frame
*f
= x_frame_of_widget (widget
);
1473 return x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
);
1477 /* Structure specifying which arguments should be passed by Xt to
1478 cvt_string_to_pixel. We want the widget's screen and colormap. */
1480 static XtConvertArgRec cvt_string_to_pixel_args
[] =
1482 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.screen
),
1484 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.colormap
),
1489 /* The address of this variable is returned by
1490 cvt_string_to_pixel. */
1492 static Pixel cvt_string_to_pixel_value
;
1495 /* Convert a color name to a pixel color.
1497 DPY is the display we are working on.
1499 ARGS is an array of *NARGS XrmValue structures holding additional
1500 information about the widget for which the conversion takes place.
1501 The contents of this array are determined by the specification
1502 in cvt_string_to_pixel_args.
1504 FROM is a pointer to an XrmValue which points to the color name to
1505 convert. TO is an XrmValue in which to return the pixel color.
1507 CLOSURE_RET is a pointer to user-data, in which we record if
1508 we allocated the color or not.
1510 Value is True if successful, False otherwise. */
1513 cvt_string_to_pixel (Display
*dpy
, XrmValue
*args
, Cardinal
*nargs
,
1514 XrmValue
*from
, XrmValue
*to
,
1515 XtPointer
*closure_ret
)
1525 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1526 "wrongParameters", "cvt_string_to_pixel",
1528 "Screen and colormap args required", NULL
, NULL
);
1532 screen
= *(Screen
**) args
[0].addr
;
1533 cmap
= *(Colormap
*) args
[1].addr
;
1534 color_name
= (String
) from
->addr
;
1536 if (strcmp (color_name
, XtDefaultBackground
) == 0)
1538 *closure_ret
= (XtPointer
) False
;
1539 pixel
= WhitePixelOfScreen (screen
);
1541 else if (strcmp (color_name
, XtDefaultForeground
) == 0)
1543 *closure_ret
= (XtPointer
) False
;
1544 pixel
= BlackPixelOfScreen (screen
);
1546 else if (XParseColor (dpy
, cmap
, color_name
, &color
)
1547 && x_alloc_nearest_color_1 (dpy
, cmap
, &color
))
1549 pixel
= color
.pixel
;
1550 *closure_ret
= (XtPointer
) True
;
1555 Cardinal nparams
= 1;
1557 params
[0] = color_name
;
1558 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1559 "badValue", "cvt_string_to_pixel",
1560 "XtToolkitError", "Invalid color `%s'",
1565 if (to
->addr
!= NULL
)
1567 if (to
->size
< sizeof (Pixel
))
1569 to
->size
= sizeof (Pixel
);
1573 *(Pixel
*) to
->addr
= pixel
;
1577 cvt_string_to_pixel_value
= pixel
;
1578 to
->addr
= (XtPointer
) &cvt_string_to_pixel_value
;
1581 to
->size
= sizeof (Pixel
);
1586 /* Free a pixel color which was previously allocated via
1587 cvt_string_to_pixel. This is registered as the destructor
1588 for this type of resource via XtSetTypeConverter.
1590 APP is the application context in which we work.
1592 TO is a pointer to an XrmValue holding the color to free.
1593 CLOSURE is the value we stored in CLOSURE_RET for this color
1594 in cvt_string_to_pixel.
1596 ARGS and NARGS are like for cvt_string_to_pixel. */
1599 cvt_pixel_dtor (XtAppContext app
, XrmValuePtr to
, XtPointer closure
, XrmValuePtr args
,
1604 XtAppWarningMsg (app
, "wrongParameters", "cvt_pixel_dtor",
1606 "Screen and colormap arguments required",
1609 else if (closure
!= NULL
)
1611 /* We did allocate the pixel, so free it. */
1612 Screen
*screen
= *(Screen
**) args
[0].addr
;
1613 Colormap cmap
= *(Colormap
*) args
[1].addr
;
1614 x_free_dpy_colors (DisplayOfScreen (screen
), screen
, cmap
,
1615 (Pixel
*) to
->addr
, 1);
1620 #endif /* USE_X_TOOLKIT */
1623 /* Value is an array of XColor structures for the contents of the
1624 color map of display DPY. Set *NCELLS to the size of the array.
1625 Note that this probably shouldn't be called for large color maps,
1626 say a 24-bit TrueColor map. */
1628 static const XColor
*
1629 x_color_cells (Display
*dpy
, int *ncells
)
1631 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1633 if (dpyinfo
->color_cells
== NULL
)
1635 Screen
*screen
= dpyinfo
->screen
;
1638 dpyinfo
->ncolor_cells
1639 = XDisplayCells (dpy
, XScreenNumberOfScreen (screen
));
1640 dpyinfo
->color_cells
1641 = (XColor
*) xmalloc (dpyinfo
->ncolor_cells
1642 * sizeof *dpyinfo
->color_cells
);
1644 for (i
= 0; i
< dpyinfo
->ncolor_cells
; ++i
)
1645 dpyinfo
->color_cells
[i
].pixel
= i
;
1647 XQueryColors (dpy
, dpyinfo
->cmap
,
1648 dpyinfo
->color_cells
, dpyinfo
->ncolor_cells
);
1651 *ncells
= dpyinfo
->ncolor_cells
;
1652 return dpyinfo
->color_cells
;
1656 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1657 colors in COLORS. Use cached information, if available. */
1660 x_query_colors (struct frame
*f
, XColor
*colors
, int ncolors
)
1662 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1664 if (dpyinfo
->color_cells
)
1667 for (i
= 0; i
< ncolors
; ++i
)
1669 unsigned long pixel
= colors
[i
].pixel
;
1670 xassert (pixel
< dpyinfo
->ncolor_cells
);
1671 xassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
1672 colors
[i
] = dpyinfo
->color_cells
[pixel
];
1676 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
1680 /* On frame F, translate pixel color to RGB values for the color in
1681 COLOR. Use cached information, if available. */
1684 x_query_color (struct frame
*f
, XColor
*color
)
1686 x_query_colors (f
, color
, 1);
1690 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
1691 exact match can't be allocated, try the nearest color available.
1692 Value is non-zero if successful. Set *COLOR to the color
1696 x_alloc_nearest_color_1 (Display
*dpy
, Colormap cmap
, XColor
*color
)
1700 rc
= XAllocColor (dpy
, cmap
, color
);
1703 /* If we got to this point, the colormap is full, so we're going
1704 to try to get the next closest color. The algorithm used is
1705 a least-squares matching, which is what X uses for closest
1706 color matching with StaticColor visuals. */
1708 unsigned long nearest_delta
= ~ (unsigned long) 0;
1710 const XColor
*cells
= x_color_cells (dpy
, &ncells
);
1712 for (nearest
= i
= 0; i
< ncells
; ++i
)
1714 long dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
1715 long dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
1716 long dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
1717 unsigned long delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
1719 if (delta
< nearest_delta
)
1722 nearest_delta
= delta
;
1726 color
->red
= cells
[nearest
].red
;
1727 color
->green
= cells
[nearest
].green
;
1728 color
->blue
= cells
[nearest
].blue
;
1729 rc
= XAllocColor (dpy
, cmap
, color
);
1733 /* If allocation succeeded, and the allocated pixel color is not
1734 equal to a cached pixel color recorded earlier, there was a
1735 change in the colormap, so clear the color cache. */
1736 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1737 XColor
*cached_color
;
1739 if (dpyinfo
->color_cells
1740 && (cached_color
= &dpyinfo
->color_cells
[color
->pixel
],
1741 (cached_color
->red
!= color
->red
1742 || cached_color
->blue
!= color
->blue
1743 || cached_color
->green
!= color
->green
)))
1745 xfree (dpyinfo
->color_cells
);
1746 dpyinfo
->color_cells
= NULL
;
1747 dpyinfo
->ncolor_cells
= 0;
1751 #ifdef DEBUG_X_COLORS
1753 register_color (color
->pixel
);
1754 #endif /* DEBUG_X_COLORS */
1760 /* Allocate the color COLOR->pixel on frame F, colormap CMAP. If an
1761 exact match can't be allocated, try the nearest color available.
1762 Value is non-zero if successful. Set *COLOR to the color
1766 x_alloc_nearest_color (struct frame
*f
, Colormap cmap
, XColor
*color
)
1768 gamma_correct (f
, color
);
1769 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f
), cmap
, color
);
1773 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
1774 It's necessary to do this instead of just using PIXEL directly to
1775 get color reference counts right. */
1778 x_copy_color (struct frame
*f
, long unsigned int pixel
)
1782 color
.pixel
= pixel
;
1784 x_query_color (f
, &color
);
1785 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
1787 #ifdef DEBUG_X_COLORS
1788 register_color (pixel
);
1794 /* Brightness beyond which a color won't have its highlight brightness
1797 Nominally, highlight colors for `3d' faces are calculated by
1798 brightening an object's color by a constant scale factor, but this
1799 doesn't yield good results for dark colors, so for colors who's
1800 brightness is less than this value (on a scale of 0-65535) have an
1801 use an additional additive factor.
1803 The value here is set so that the default menu-bar/mode-line color
1804 (grey75) will not have its highlights changed at all. */
1805 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
1808 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1809 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1810 If this produces the same color as PIXEL, try a color where all RGB
1811 values have DELTA added. Return the allocated color in *PIXEL.
1812 DISPLAY is the X display, CMAP is the colormap to operate on.
1813 Value is non-zero if successful. */
1816 x_alloc_lighter_color (struct frame
*f
, Display
*display
, Colormap cmap
, long unsigned int *pixel
, double factor
, int delta
)
1822 /* Get RGB color values. */
1823 color
.pixel
= *pixel
;
1824 x_query_color (f
, &color
);
1826 /* Change RGB values by specified FACTOR. Avoid overflow! */
1827 xassert (factor
>= 0);
1828 new.red
= min (0xffff, factor
* color
.red
);
1829 new.green
= min (0xffff, factor
* color
.green
);
1830 new.blue
= min (0xffff, factor
* color
.blue
);
1832 /* Calculate brightness of COLOR. */
1833 bright
= (2 * color
.red
+ 3 * color
.green
+ color
.blue
) / 6;
1835 /* We only boost colors that are darker than
1836 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1837 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1838 /* Make an additive adjustment to NEW, because it's dark enough so
1839 that scaling by FACTOR alone isn't enough. */
1841 /* How far below the limit this color is (0 - 1, 1 being darker). */
1842 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1843 /* The additive adjustment. */
1844 int min_delta
= delta
* dimness
* factor
/ 2;
1848 new.red
= max (0, new.red
- min_delta
);
1849 new.green
= max (0, new.green
- min_delta
);
1850 new.blue
= max (0, new.blue
- min_delta
);
1854 new.red
= min (0xffff, min_delta
+ new.red
);
1855 new.green
= min (0xffff, min_delta
+ new.green
);
1856 new.blue
= min (0xffff, min_delta
+ new.blue
);
1860 /* Try to allocate the color. */
1861 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1864 if (new.pixel
== *pixel
)
1866 /* If we end up with the same color as before, try adding
1867 delta to the RGB values. */
1868 x_free_colors (f
, &new.pixel
, 1);
1870 new.red
= min (0xffff, delta
+ color
.red
);
1871 new.green
= min (0xffff, delta
+ color
.green
);
1872 new.blue
= min (0xffff, delta
+ color
.blue
);
1873 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1884 /* Set up the foreground color for drawing relief lines of glyph
1885 string S. RELIEF is a pointer to a struct relief containing the GC
1886 with which lines will be drawn. Use a color that is FACTOR or
1887 DELTA lighter or darker than the relief's background which is found
1888 in S->f->output_data.x->relief_background. If such a color cannot
1889 be allocated, use DEFAULT_PIXEL, instead. */
1892 x_setup_relief_color (struct frame
*f
, struct relief
*relief
, double factor
, int delta
, long unsigned int default_pixel
)
1895 struct x_output
*di
= f
->output_data
.x
;
1896 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
1897 unsigned long pixel
;
1898 unsigned long background
= di
->relief_background
;
1899 Colormap cmap
= FRAME_X_COLORMAP (f
);
1900 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1901 Display
*dpy
= FRAME_X_DISPLAY (f
);
1903 xgcv
.graphics_exposures
= False
;
1904 xgcv
.line_width
= 1;
1906 /* Free previously allocated color. The color cell will be reused
1907 when it has been freed as many times as it was allocated, so this
1908 doesn't affect faces using the same colors. */
1910 && relief
->allocated_p
)
1912 x_free_colors (f
, &relief
->pixel
, 1);
1913 relief
->allocated_p
= 0;
1916 /* Allocate new color. */
1917 xgcv
.foreground
= default_pixel
;
1919 if (dpyinfo
->n_planes
!= 1
1920 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
1922 relief
->allocated_p
= 1;
1923 xgcv
.foreground
= relief
->pixel
= pixel
;
1926 if (relief
->gc
== 0)
1928 xgcv
.stipple
= dpyinfo
->gray
;
1930 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
1933 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
1937 /* Set up colors for the relief lines around glyph string S. */
1940 x_setup_relief_colors (struct glyph_string
*s
)
1942 struct x_output
*di
= s
->f
->output_data
.x
;
1943 unsigned long color
;
1945 if (s
->face
->use_box_color_for_shadows_p
)
1946 color
= s
->face
->box_color
;
1947 else if (s
->first_glyph
->type
== IMAGE_GLYPH
1949 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
1950 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
1955 /* Get the background color of the face. */
1956 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
1957 color
= xgcv
.background
;
1960 if (di
->white_relief
.gc
== 0
1961 || color
!= di
->relief_background
)
1963 di
->relief_background
= color
;
1964 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
1965 WHITE_PIX_DEFAULT (s
->f
));
1966 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
1967 BLACK_PIX_DEFAULT (s
->f
));
1972 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
1973 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
1974 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
1975 relief. LEFT_P non-zero means draw a relief on the left side of
1976 the rectangle. RIGHT_P non-zero means draw a relief on the right
1977 side of the rectangle. CLIP_RECT is the clipping rectangle to use
1981 x_draw_relief_rect (struct frame
*f
,
1982 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
1983 int raised_p
, int top_p
, int bot_p
, int left_p
, int right_p
,
1984 XRectangle
*clip_rect
)
1986 Display
*dpy
= FRAME_X_DISPLAY (f
);
1987 Window window
= FRAME_X_WINDOW (f
);
1992 gc
= f
->output_data
.x
->white_relief
.gc
;
1994 gc
= f
->output_data
.x
->black_relief
.gc
;
1995 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
1997 /* This code is more complicated than it has to be, because of two
1998 minor hacks to make the boxes look nicer: (i) if width > 1, draw
1999 the outermost line using the black relief. (ii) Omit the four
2006 XDrawLine (dpy
, window
, gc
,
2007 left_x
+ (left_p
? 1 : 0), top_y
,
2008 right_x
+ (right_p
? 0 : 1), top_y
);
2010 for (i
= 1; i
< width
; ++i
)
2011 XDrawLine (dpy
, window
, gc
,
2012 left_x
+ i
* left_p
, top_y
+ i
,
2013 right_x
+ 1 - i
* right_p
, top_y
+ i
);
2020 XDrawLine (dpy
, window
, gc
, left_x
, top_y
+ 1, left_x
, bottom_y
);
2022 XClearArea (dpy
, window
, left_x
, top_y
, 1, 1, False
);
2023 XClearArea (dpy
, window
, left_x
, bottom_y
, 1, 1, False
);
2025 for (i
= (width
> 1 ? 1 : 0); i
< width
; ++i
)
2026 XDrawLine (dpy
, window
, gc
,
2027 left_x
+ i
, top_y
+ i
, left_x
+ i
, bottom_y
- i
+ 1);
2030 XSetClipMask (dpy
, gc
, None
);
2032 gc
= f
->output_data
.x
->black_relief
.gc
;
2034 gc
= f
->output_data
.x
->white_relief
.gc
;
2035 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
2039 /* Outermost top line. */
2041 XDrawLine (dpy
, window
, gc
,
2042 left_x
+ (left_p
? 1 : 0), top_y
,
2043 right_x
+ (right_p
? 0 : 1), top_y
);
2045 /* Outermost left line. */
2047 XDrawLine (dpy
, window
, gc
, left_x
, top_y
+ 1, left_x
, bottom_y
);
2053 XDrawLine (dpy
, window
, gc
,
2054 left_x
+ (left_p
? 1 : 0), bottom_y
,
2055 right_x
+ (right_p
? 0 : 1), bottom_y
);
2056 for (i
= 1; i
< width
; ++i
)
2057 XDrawLine (dpy
, window
, gc
,
2058 left_x
+ i
* left_p
, bottom_y
- i
,
2059 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
2065 XClearArea (dpy
, window
, right_x
, top_y
, 1, 1, False
);
2066 XClearArea (dpy
, window
, right_x
, bottom_y
, 1, 1, False
);
2067 for (i
= 0; i
< width
; ++i
)
2068 XDrawLine (dpy
, window
, gc
,
2069 right_x
- i
, top_y
+ i
+ 1, right_x
- i
, bottom_y
- i
);
2072 XSetClipMask (dpy
, gc
, None
);
2076 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
2077 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
2078 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
2079 left side of the rectangle. RIGHT_P non-zero means draw a line
2080 on the right side of the rectangle. CLIP_RECT is the clipping
2081 rectangle to use when drawing. */
2084 x_draw_box_rect (struct glyph_string
*s
,
2085 int left_x
, int top_y
, int right_x
, int bottom_y
, int width
,
2086 int left_p
, int right_p
, XRectangle
*clip_rect
)
2090 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2091 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
2092 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, clip_rect
, 1, Unsorted
);
2095 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2096 left_x
, top_y
, right_x
- left_x
+ 1, width
);
2100 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2101 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
2104 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2105 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
2109 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2110 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
2112 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2113 XSetClipMask (s
->display
, s
->gc
, None
);
2117 /* Draw a box around glyph string S. */
2120 x_draw_glyph_string_box (struct glyph_string
*s
)
2122 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
2123 int left_p
, right_p
;
2124 struct glyph
*last_glyph
;
2125 XRectangle clip_rect
;
2127 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
2128 ? WINDOW_RIGHT_EDGE_X (s
->w
)
2129 : window_box_right (s
->w
, s
->area
));
2131 /* The glyph that may have a right box line. */
2132 last_glyph
= (s
->cmp
|| s
->img
2134 : s
->first_glyph
+ s
->nchars
- 1);
2136 width
= eabs (s
->face
->box_line_width
);
2137 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
2139 right_x
= (s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
2141 : min (last_x
, s
->x
+ s
->background_width
) - 1);
2143 bottom_y
= top_y
+ s
->height
- 1;
2145 left_p
= (s
->first_glyph
->left_box_line_p
2146 || (s
->hl
== DRAW_MOUSE_FACE
2148 || s
->prev
->hl
!= s
->hl
)));
2149 right_p
= (last_glyph
->right_box_line_p
2150 || (s
->hl
== DRAW_MOUSE_FACE
2152 || s
->next
->hl
!= s
->hl
)));
2154 get_glyph_string_clip_rect (s
, &clip_rect
);
2156 if (s
->face
->box
== FACE_SIMPLE_BOX
)
2157 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2158 left_p
, right_p
, &clip_rect
);
2161 x_setup_relief_colors (s
);
2162 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
2163 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
2168 /* Draw foreground of image glyph string S. */
2171 x_draw_image_foreground (struct glyph_string
*s
)
2174 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2176 /* If first glyph of S has a left box line, start drawing it to the
2177 right of that line. */
2178 if (s
->face
->box
!= FACE_NO_BOX
2179 && s
->first_glyph
->left_box_line_p
2181 x
+= eabs (s
->face
->box_line_width
);
2183 /* If there is a margin around the image, adjust x- and y-position
2185 if (s
->slice
.x
== 0)
2186 x
+= s
->img
->hmargin
;
2187 if (s
->slice
.y
== 0)
2188 y
+= s
->img
->vmargin
;
2194 /* We can't set both a clip mask and use XSetClipRectangles
2195 because the latter also sets a clip mask. We also can't
2196 trust on the shape extension to be available
2197 (XShapeCombineRegion). So, compute the rectangle to draw
2199 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2202 XRectangle clip_rect
, image_rect
, r
;
2204 xgcv
.clip_mask
= s
->img
->mask
;
2205 xgcv
.clip_x_origin
= x
;
2206 xgcv
.clip_y_origin
= y
;
2207 xgcv
.function
= GXcopy
;
2208 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2210 get_glyph_string_clip_rect (s
, &clip_rect
);
2213 image_rect
.width
= s
->slice
.width
;
2214 image_rect
.height
= s
->slice
.height
;
2215 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2216 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2217 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2218 r
.width
, r
.height
, r
.x
, r
.y
);
2222 XRectangle clip_rect
, image_rect
, r
;
2224 get_glyph_string_clip_rect (s
, &clip_rect
);
2227 image_rect
.width
= s
->slice
.width
;
2228 image_rect
.height
= s
->slice
.height
;
2229 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2230 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2231 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2232 r
.width
, r
.height
, r
.x
, r
.y
);
2234 /* When the image has a mask, we can expect that at
2235 least part of a mouse highlight or a block cursor will
2236 be visible. If the image doesn't have a mask, make
2237 a block cursor visible by drawing a rectangle around
2238 the image. I believe it's looking better if we do
2239 nothing here for mouse-face. */
2240 if (s
->hl
== DRAW_CURSOR
)
2242 int r
= s
->img
->relief
;
2244 XDrawRectangle (s
->display
, s
->window
, s
->gc
,
2246 s
->slice
.width
+ r
*2 - 1,
2247 s
->slice
.height
+ r
*2 - 1);
2252 /* Draw a rectangle if image could not be loaded. */
2253 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
2254 s
->slice
.width
- 1, s
->slice
.height
- 1);
2258 /* Draw a relief around the image glyph string S. */
2261 x_draw_image_relief (struct glyph_string
*s
)
2263 int x0
, y0
, x1
, y1
, thick
, raised_p
, extra
;
2266 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2268 /* If first glyph of S has a left box line, start drawing it to the
2269 right of that line. */
2270 if (s
->face
->box
!= FACE_NO_BOX
2271 && s
->first_glyph
->left_box_line_p
2273 x
+= eabs (s
->face
->box_line_width
);
2275 /* If there is a margin around the image, adjust x- and y-position
2277 if (s
->slice
.x
== 0)
2278 x
+= s
->img
->hmargin
;
2279 if (s
->slice
.y
== 0)
2280 y
+= s
->img
->vmargin
;
2282 if (s
->hl
== DRAW_IMAGE_SUNKEN
2283 || s
->hl
== DRAW_IMAGE_RAISED
)
2285 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
2286 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
2290 thick
= eabs (s
->img
->relief
);
2291 raised_p
= s
->img
->relief
> 0;
2294 extra
= s
->face
->id
== TOOL_BAR_FACE_ID
2295 ? XINT (Vtool_bar_button_margin
) : 0;
2297 x0
= x
- thick
- extra
;
2298 y0
= y
- thick
- extra
;
2299 x1
= x
+ s
->slice
.width
+ thick
- 1 + extra
;
2300 y1
= y
+ s
->slice
.height
+ thick
- 1 + extra
;
2302 x_setup_relief_colors (s
);
2303 get_glyph_string_clip_rect (s
, &r
);
2304 x_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
,
2306 s
->slice
.y
+ s
->slice
.height
== s
->img
->height
,
2308 s
->slice
.x
+ s
->slice
.width
== s
->img
->width
,
2313 /* Draw the foreground of image glyph string S to PIXMAP. */
2316 x_draw_image_foreground_1 (struct glyph_string
*s
, Pixmap pixmap
)
2319 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2321 /* If first glyph of S has a left box line, start drawing it to the
2322 right of that line. */
2323 if (s
->face
->box
!= FACE_NO_BOX
2324 && s
->first_glyph
->left_box_line_p
2326 x
+= eabs (s
->face
->box_line_width
);
2328 /* If there is a margin around the image, adjust x- and y-position
2330 if (s
->slice
.x
== 0)
2331 x
+= s
->img
->hmargin
;
2332 if (s
->slice
.y
== 0)
2333 y
+= s
->img
->vmargin
;
2339 /* We can't set both a clip mask and use XSetClipRectangles
2340 because the latter also sets a clip mask. We also can't
2341 trust on the shape extension to be available
2342 (XShapeCombineRegion). So, compute the rectangle to draw
2344 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2348 xgcv
.clip_mask
= s
->img
->mask
;
2349 xgcv
.clip_x_origin
= x
- s
->slice
.x
;
2350 xgcv
.clip_y_origin
= y
- s
->slice
.y
;
2351 xgcv
.function
= GXcopy
;
2352 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2354 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2355 s
->slice
.x
, s
->slice
.y
,
2356 s
->slice
.width
, s
->slice
.height
, x
, y
);
2357 XSetClipMask (s
->display
, s
->gc
, None
);
2361 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2362 s
->slice
.x
, s
->slice
.y
,
2363 s
->slice
.width
, s
->slice
.height
, x
, y
);
2365 /* When the image has a mask, we can expect that at
2366 least part of a mouse highlight or a block cursor will
2367 be visible. If the image doesn't have a mask, make
2368 a block cursor visible by drawing a rectangle around
2369 the image. I believe it's looking better if we do
2370 nothing here for mouse-face. */
2371 if (s
->hl
== DRAW_CURSOR
)
2373 int r
= s
->img
->relief
;
2375 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
- r
, y
- r
,
2376 s
->slice
.width
+ r
*2 - 1,
2377 s
->slice
.height
+ r
*2 - 1);
2382 /* Draw a rectangle if image could not be loaded. */
2383 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
2384 s
->slice
.width
- 1, s
->slice
.height
- 1);
2388 /* Draw part of the background of glyph string S. X, Y, W, and H
2389 give the rectangle to draw. */
2392 x_draw_glyph_string_bg_rect (struct glyph_string
*s
, int x
, int y
, int w
, int h
)
2396 /* Fill background with a stipple pattern. */
2397 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2398 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2399 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2402 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2406 /* Draw image glyph string S.
2409 s->x +-------------------------
2412 | +-------------------------
2415 | | +-------------------
2421 x_draw_image_glyph_string (struct glyph_string
*s
)
2423 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
2424 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2426 Pixmap pixmap
= None
;
2429 if (s
->slice
.y
== 0)
2430 height
-= box_line_vwidth
;
2431 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
2432 height
-= box_line_vwidth
;
2434 /* Fill background with face under the image. Do it only if row is
2435 taller than image or if image has a clip mask to reduce
2437 s
->stippled_p
= s
->face
->stipple
!= 0;
2438 if (height
> s
->slice
.height
2442 || s
->img
->pixmap
== 0
2443 || s
->width
!= s
->background_width
)
2447 /* Create a pixmap as large as the glyph string. Fill it
2448 with the background color. Copy the image to it, using
2449 its mask. Copy the temporary pixmap to the display. */
2450 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2451 int depth
= DefaultDepthOfScreen (screen
);
2453 /* Create a pixmap as large as the glyph string. */
2454 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2455 s
->background_width
,
2458 /* Don't clip in the following because we're working on the
2460 XSetClipMask (s
->display
, s
->gc
, None
);
2462 /* Fill the pixmap with the background color/stipple. */
2465 /* Fill background with a stipple pattern. */
2466 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2467 XSetTSOrigin (s
->display
, s
->gc
, - s
->x
, - s
->y
);
2468 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2469 0, 0, s
->background_width
, s
->height
);
2470 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2471 XSetTSOrigin (s
->display
, s
->gc
, 0, 0);
2476 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2478 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2479 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2480 0, 0, s
->background_width
, s
->height
);
2481 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2489 if (s
->first_glyph
->left_box_line_p
2491 x
+= box_line_hwidth
;
2493 if (s
->slice
.y
== 0)
2494 y
+= box_line_vwidth
;
2496 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
2499 s
->background_filled_p
= 1;
2502 /* Draw the foreground. */
2505 x_draw_image_foreground_1 (s
, pixmap
);
2506 x_set_glyph_string_clipping (s
);
2507 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
2508 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
2509 XFreePixmap (s
->display
, pixmap
);
2512 x_draw_image_foreground (s
);
2514 /* If we must draw a relief around the image, do it. */
2516 || s
->hl
== DRAW_IMAGE_RAISED
2517 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2518 x_draw_image_relief (s
);
2522 /* Draw stretch glyph string S. */
2525 x_draw_stretch_glyph_string (struct glyph_string
*s
)
2527 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2529 if (s
->hl
== DRAW_CURSOR
2530 && !x_stretch_cursor_p
)
2532 /* If `x-stretch-cursor' is nil, don't draw a block cursor as
2533 wide as the stretch glyph. */
2534 int width
, background_width
= s
->background_width
;
2537 if (!s
->row
->reversed_p
)
2539 int left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2543 background_width
-= left_x
- x
;
2549 /* In R2L rows, draw the cursor on the right edge of the
2551 int right_x
= window_box_right_offset (s
->w
, TEXT_AREA
);
2553 if (x
+ background_width
> right_x
)
2554 background_width
-= x
- right_x
;
2555 x
+= background_width
;
2557 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
2558 if (s
->row
->reversed_p
)
2562 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
2564 /* Clear rest using the GC of the original non-cursor face. */
2565 if (width
< background_width
)
2568 int w
= background_width
- width
, h
= s
->height
;
2572 if (!s
->row
->reversed_p
)
2576 if (s
->row
->mouse_face_p
2577 && cursor_in_mouse_face_p (s
->w
))
2579 x_set_mouse_face_gc (s
);
2585 get_glyph_string_clip_rect (s
, &r
);
2586 XSetClipRectangles (s
->display
, gc
, 0, 0, &r
, 1, Unsorted
);
2588 if (s
->face
->stipple
)
2590 /* Fill background with a stipple pattern. */
2591 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2592 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2593 XSetFillStyle (s
->display
, gc
, FillSolid
);
2598 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
2599 XSetForeground (s
->display
, gc
, xgcv
.background
);
2600 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2601 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
2605 else if (!s
->background_filled_p
)
2607 int background_width
= s
->background_width
;
2608 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
2610 /* Don't draw into left margin, fringe or scrollbar area
2611 except for header line and mode line. */
2612 if (x
< left_x
&& !s
->row
->mode_line_p
)
2614 background_width
-= left_x
- x
;
2617 if (background_width
> 0)
2618 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
2621 s
->background_filled_p
= 1;
2625 /* Draw glyph string S. */
2628 x_draw_glyph_string (struct glyph_string
*s
)
2630 int relief_drawn_p
= 0;
2632 /* If S draws into the background of its successors, draw the
2633 background of the successors first so that S can draw into it.
2634 This makes S->next use XDrawString instead of XDrawImageString. */
2635 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2638 struct glyph_string
*next
;
2640 for (width
= 0, next
= s
->next
;
2641 next
&& width
< s
->right_overhang
;
2642 width
+= next
->width
, next
= next
->next
)
2643 if (next
->first_glyph
->type
!= IMAGE_GLYPH
)
2645 x_set_glyph_string_gc (next
);
2646 x_set_glyph_string_clipping (next
);
2647 if (next
->first_glyph
->type
== STRETCH_GLYPH
)
2648 x_draw_stretch_glyph_string (next
);
2650 x_draw_glyph_string_background (next
, 1);
2651 next
->num_clips
= 0;
2655 /* Set up S->gc, set clipping and draw S. */
2656 x_set_glyph_string_gc (s
);
2658 /* Draw relief (if any) in advance for char/composition so that the
2659 glyph string can be drawn over it. */
2660 if (!s
->for_overlaps
2661 && s
->face
->box
!= FACE_NO_BOX
2662 && (s
->first_glyph
->type
== CHAR_GLYPH
2663 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2666 x_set_glyph_string_clipping (s
);
2667 x_draw_glyph_string_background (s
, 1);
2668 x_draw_glyph_string_box (s
);
2669 x_set_glyph_string_clipping (s
);
2672 else if (!s
->clip_head
/* draw_glyphs didn't specify a clip mask. */
2674 && ((s
->prev
&& s
->prev
->hl
!= s
->hl
&& s
->left_overhang
)
2675 || (s
->next
&& s
->next
->hl
!= s
->hl
&& s
->right_overhang
)))
2676 /* We must clip just this glyph. left_overhang part has already
2677 drawn when s->prev was drawn, and right_overhang part will be
2678 drawn later when s->next is drawn. */
2679 x_set_glyph_string_clipping_exactly (s
, s
);
2681 x_set_glyph_string_clipping (s
);
2683 switch (s
->first_glyph
->type
)
2686 x_draw_image_glyph_string (s
);
2690 x_draw_stretch_glyph_string (s
);
2694 if (s
->for_overlaps
)
2695 s
->background_filled_p
= 1;
2697 x_draw_glyph_string_background (s
, 0);
2698 x_draw_glyph_string_foreground (s
);
2701 case COMPOSITE_GLYPH
:
2702 if (s
->for_overlaps
|| (s
->cmp_from
> 0
2703 && ! s
->first_glyph
->u
.cmp
.automatic
))
2704 s
->background_filled_p
= 1;
2706 x_draw_glyph_string_background (s
, 1);
2707 x_draw_composite_glyph_string_foreground (s
);
2710 case GLYPHLESS_GLYPH
:
2711 if (s
->for_overlaps
)
2712 s
->background_filled_p
= 1;
2714 x_draw_glyph_string_background (s
, 1);
2715 x_draw_glyphless_glyph_string_foreground (s
);
2722 if (!s
->for_overlaps
)
2724 /* Draw underline. */
2725 if (s
->face
->underline_p
)
2727 unsigned long thickness
, position
;
2730 if (s
->prev
&& s
->prev
->face
->underline_p
)
2732 /* We use the same underline style as the previous one. */
2733 thickness
= s
->prev
->underline_thickness
;
2734 position
= s
->prev
->underline_position
;
2738 /* Get the underline thickness. Default is 1 pixel. */
2739 if (s
->font
&& s
->font
->underline_thickness
> 0)
2740 thickness
= s
->font
->underline_thickness
;
2743 if (x_underline_at_descent_line
)
2744 position
= (s
->height
- thickness
) - (s
->ybase
- s
->y
);
2747 /* Get the underline position. This is the recommended
2748 vertical offset in pixels from the baseline to the top of
2749 the underline. This is a signed value according to the
2750 specs, and its default is
2752 ROUND ((maximum descent) / 2), with
2753 ROUND(x) = floor (x + 0.5) */
2755 if (x_use_underline_position_properties
2756 && s
->font
&& s
->font
->underline_position
>= 0)
2757 position
= s
->font
->underline_position
;
2759 position
= (s
->font
->descent
+ 1) / 2;
2761 position
= underline_minimum_offset
;
2763 position
= max (position
, underline_minimum_offset
);
2765 /* Check the sanity of thickness and position. We should
2766 avoid drawing underline out of the current line area. */
2767 if (s
->y
+ s
->height
<= s
->ybase
+ position
)
2768 position
= (s
->height
- 1) - (s
->ybase
- s
->y
);
2769 if (s
->y
+ s
->height
< s
->ybase
+ position
+ thickness
)
2770 thickness
= (s
->y
+ s
->height
) - (s
->ybase
+ position
);
2771 s
->underline_thickness
= thickness
;
2772 s
->underline_position
= position
;
2773 y
= s
->ybase
+ position
;
2774 if (s
->face
->underline_defaulted_p
)
2775 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2776 s
->x
, y
, s
->width
, thickness
);
2780 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2781 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
2782 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2783 s
->x
, y
, s
->width
, thickness
);
2784 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2788 /* Draw overline. */
2789 if (s
->face
->overline_p
)
2791 unsigned long dy
= 0, h
= 1;
2793 if (s
->face
->overline_color_defaulted_p
)
2794 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2799 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2800 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
2801 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2803 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2807 /* Draw strike-through. */
2808 if (s
->face
->strike_through_p
)
2810 unsigned long h
= 1;
2811 unsigned long dy
= (s
->height
- h
) / 2;
2813 if (s
->face
->strike_through_color_defaulted_p
)
2814 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2819 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2820 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
2821 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2823 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2827 /* Draw relief if not yet drawn. */
2828 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2829 x_draw_glyph_string_box (s
);
2833 struct glyph_string
*prev
;
2835 for (prev
= s
->prev
; prev
; prev
= prev
->prev
)
2836 if (prev
->hl
!= s
->hl
2837 && prev
->x
+ prev
->width
+ prev
->right_overhang
> s
->x
)
2839 /* As prev was drawn while clipped to its own area, we
2840 must draw the right_overhang part using s->hl now. */
2841 enum draw_glyphs_face save
= prev
->hl
;
2844 x_set_glyph_string_gc (prev
);
2845 x_set_glyph_string_clipping_exactly (s
, prev
);
2846 if (prev
->first_glyph
->type
== CHAR_GLYPH
)
2847 x_draw_glyph_string_foreground (prev
);
2849 x_draw_composite_glyph_string_foreground (prev
);
2850 XSetClipMask (prev
->display
, prev
->gc
, None
);
2852 prev
->num_clips
= 0;
2858 struct glyph_string
*next
;
2860 for (next
= s
->next
; next
; next
= next
->next
)
2861 if (next
->hl
!= s
->hl
2862 && next
->x
- next
->left_overhang
< s
->x
+ s
->width
)
2864 /* As next will be drawn while clipped to its own area,
2865 we must draw the left_overhang part using s->hl now. */
2866 enum draw_glyphs_face save
= next
->hl
;
2869 x_set_glyph_string_gc (next
);
2870 x_set_glyph_string_clipping_exactly (s
, next
);
2871 if (next
->first_glyph
->type
== CHAR_GLYPH
)
2872 x_draw_glyph_string_foreground (next
);
2874 x_draw_composite_glyph_string_foreground (next
);
2875 XSetClipMask (next
->display
, next
->gc
, None
);
2877 next
->num_clips
= 0;
2882 /* Reset clipping. */
2883 XSetClipMask (s
->display
, s
->gc
, None
);
2887 /* Shift display to make room for inserted glyphs. */
2890 x_shift_glyphs_for_insert (struct frame
*f
, int x
, int y
, int width
, int height
, int shift_by
)
2892 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
2893 f
->output_data
.x
->normal_gc
,
2894 x
, y
, width
, height
,
2898 /* Delete N glyphs at the nominal cursor position. Not implemented
2902 x_delete_glyphs (struct frame
*f
, register int n
)
2908 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
2909 If they are <= 0, this is probably an error. */
2912 x_clear_area (Display
*dpy
, Window window
, int x
, int y
, int width
, int height
, int exposures
)
2914 xassert (width
> 0 && height
> 0);
2915 XClearArea (dpy
, window
, x
, y
, width
, height
, exposures
);
2919 /* Clear an entire frame. */
2922 x_clear_frame (struct frame
*f
)
2924 /* Clearing the frame will erase any cursor, so mark them all as no
2926 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2927 output_cursor
.hpos
= output_cursor
.vpos
= 0;
2928 output_cursor
.x
= -1;
2930 /* We don't set the output cursor here because there will always
2931 follow an explicit cursor_to. */
2933 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
2935 /* We have to clear the scroll bars, too. If we have changed
2936 colors or something like that, then they should be notified. */
2937 x_scroll_bar_clear (f
);
2939 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
2940 /* Make sure scroll bars are redrawn. As they aren't redrawn by
2941 redisplay, do it here. */
2942 if (FRAME_GTK_WIDGET (f
))
2943 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
2946 XFlush (FRAME_X_DISPLAY (f
));
2953 /* Invert the middle quarter of the frame for .15 sec. */
2955 /* We use the select system call to do the waiting, so we have to make
2956 sure it's available. If it isn't, we just won't do visual bells. */
2958 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
2961 /* Subtract the `struct timeval' values X and Y, storing the result in
2962 *RESULT. Return 1 if the difference is negative, otherwise 0. */
2965 timeval_subtract (struct timeval
*result
, struct timeval x
, struct timeval y
)
2967 /* Perform the carry for the later subtraction by updating y. This
2968 is safer because on some systems the tv_sec member is unsigned. */
2969 if (x
.tv_usec
< y
.tv_usec
)
2971 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
2972 y
.tv_usec
-= 1000000 * nsec
;
2976 if (x
.tv_usec
- y
.tv_usec
> 1000000)
2978 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
2979 y
.tv_usec
+= 1000000 * nsec
;
2983 /* Compute the time remaining to wait. tv_usec is certainly
2985 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
2986 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
2988 /* Return indication of whether the result should be considered
2990 return x
.tv_sec
< y
.tv_sec
;
2994 XTflash (struct frame
*f
)
3000 /* Use Gdk routines to draw. This way, we won't draw over scroll bars
3001 when the scroll bars and the edit widget share the same X window. */
3002 GdkWindow
*window
= gtk_widget_get_window (FRAME_GTK_WIDGET (f
));
3005 vals
.foreground
.pixel
= (FRAME_FOREGROUND_PIXEL (f
)
3006 ^ FRAME_BACKGROUND_PIXEL (f
));
3007 vals
.function
= GDK_XOR
;
3008 gc
= gdk_gc_new_with_values (window
,
3009 &vals
, GDK_GC_FUNCTION
| GDK_GC_FOREGROUND
);
3010 #define XFillRectangle(d, win, gc, x, y, w, h) \
3011 gdk_draw_rectangle (window, gc, TRUE, x, y, w, h)
3015 /* Create a GC that will use the GXxor function to flip foreground
3016 pixels into background pixels. */
3020 values
.function
= GXxor
;
3021 values
.foreground
= (FRAME_FOREGROUND_PIXEL (f
)
3022 ^ FRAME_BACKGROUND_PIXEL (f
));
3024 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3025 GCFunction
| GCForeground
, &values
);
3029 /* Get the height not including a menu bar widget. */
3030 int height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, FRAME_LINES (f
));
3031 /* Height of each line to flash. */
3032 int flash_height
= FRAME_LINE_HEIGHT (f
);
3033 /* These will be the left and right margins of the rectangles. */
3034 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
3035 int flash_right
= FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
3039 /* Don't flash the area between a scroll bar and the frame
3040 edge it is next to. */
3041 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f
))
3043 case vertical_scroll_bar_left
:
3044 flash_left
+= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
3047 case vertical_scroll_bar_right
:
3048 flash_right
-= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
3055 width
= flash_right
- flash_left
;
3057 /* If window is tall, flash top and bottom line. */
3058 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3060 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3062 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3063 + FRAME_TOP_MARGIN_HEIGHT (f
)),
3064 width
, flash_height
);
3065 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3067 (height
- flash_height
3068 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3069 width
, flash_height
);
3073 /* If it is short, flash it all. */
3074 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3075 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3076 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3081 struct timeval wakeup
;
3083 EMACS_GET_TIME (wakeup
);
3085 /* Compute time to wait until, propagating carry from usecs. */
3086 wakeup
.tv_usec
+= 150000;
3087 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
3088 wakeup
.tv_usec
%= 1000000;
3090 /* Keep waiting until past the time wakeup or any input gets
3092 while (! detect_input_pending ())
3094 struct timeval current
;
3095 struct timeval timeout
;
3097 EMACS_GET_TIME (current
);
3099 /* Break if result would be negative. */
3100 if (timeval_subtract (¤t
, wakeup
, current
))
3103 /* How long `select' should wait. */
3105 timeout
.tv_usec
= 10000;
3107 /* Try to wait that long--but we might wake up sooner. */
3108 select (0, NULL
, NULL
, NULL
, &timeout
);
3112 /* If window is tall, flash top and bottom line. */
3113 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
3115 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3117 (FRAME_INTERNAL_BORDER_WIDTH (f
)
3118 + FRAME_TOP_MARGIN_HEIGHT (f
)),
3119 width
, flash_height
);
3120 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3122 (height
- flash_height
3123 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
3124 width
, flash_height
);
3127 /* If it is short, flash it all. */
3128 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
3129 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3130 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3133 g_object_unref (G_OBJECT (gc
));
3134 #undef XFillRectangle
3136 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
3145 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
3149 XTtoggle_invisible_pointer (FRAME_PTR f
, int invisible
)
3154 if (FRAME_X_DISPLAY_INFO (f
)->invisible_cursor
!= 0)
3155 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3156 FRAME_X_DISPLAY_INFO (f
)->invisible_cursor
);
3159 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3160 f
->output_data
.x
->current_cursor
);
3161 f
->pointer_invisible
= invisible
;
3166 /* Make audible bell. */
3169 XTring_bell (struct frame
*f
)
3171 if (FRAME_X_DISPLAY (f
))
3173 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
3180 XBell (FRAME_X_DISPLAY (f
), 0);
3181 XFlush (FRAME_X_DISPLAY (f
));
3188 /* Specify how many text lines, from the top of the window,
3189 should be affected by insert-lines and delete-lines operations.
3190 This, and those operations, are used only within an update
3191 that is bounded by calls to x_update_begin and x_update_end. */
3194 XTset_terminal_window (struct frame
*f
, int n
)
3196 /* This function intentionally left blank. */
3201 /***********************************************************************
3203 ***********************************************************************/
3205 /* Perform an insert-lines or delete-lines operation, inserting N
3206 lines or deleting -N lines at vertical position VPOS. */
3209 x_ins_del_lines (struct frame
*f
, int vpos
, int n
)
3215 /* Scroll part of the display as described by RUN. */
3218 x_scroll_run (struct window
*w
, struct run
*run
)
3220 struct frame
*f
= XFRAME (w
->frame
);
3221 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
3223 /* Get frame-relative bounding box of the text display area of W,
3224 without mode lines. Include in this box the left and right
3226 window_box (w
, -1, &x
, &y
, &width
, &height
);
3228 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
3229 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
3230 bottom_y
= y
+ height
;
3234 /* Scrolling up. Make sure we don't copy part of the mode
3235 line at the bottom. */
3236 if (from_y
+ run
->height
> bottom_y
)
3237 height
= bottom_y
- from_y
;
3239 height
= run
->height
;
3243 /* Scolling down. Make sure we don't copy over the mode line.
3245 if (to_y
+ run
->height
> bottom_y
)
3246 height
= bottom_y
- to_y
;
3248 height
= run
->height
;
3253 /* Cursor off. Will be switched on again in x_update_window_end. */
3257 XCopyArea (FRAME_X_DISPLAY (f
),
3258 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
3259 f
->output_data
.x
->normal_gc
,
3269 /***********************************************************************
3271 ***********************************************************************/
3275 frame_highlight (struct frame
*f
)
3277 /* We used to only do this if Vx_no_window_manager was non-nil, but
3278 the ICCCM (section 4.1.6) says that the window's border pixmap
3279 and border pixel are window attributes which are "private to the
3280 client", so we can always change it to whatever we want. */
3282 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3283 f
->output_data
.x
->border_pixel
);
3285 x_update_cursor (f
, 1);
3286 x_set_frame_alpha (f
);
3290 frame_unhighlight (struct frame
*f
)
3292 /* We used to only do this if Vx_no_window_manager was non-nil, but
3293 the ICCCM (section 4.1.6) says that the window's border pixmap
3294 and border pixel are window attributes which are "private to the
3295 client", so we can always change it to whatever we want. */
3297 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3298 f
->output_data
.x
->border_tile
);
3300 x_update_cursor (f
, 1);
3301 x_set_frame_alpha (f
);
3304 /* The focus has changed. Update the frames as necessary to reflect
3305 the new situation. Note that we can't change the selected frame
3306 here, because the Lisp code we are interrupting might become confused.
3307 Each event gets marked with the frame in which it occurred, so the
3308 Lisp code can tell when the switch took place by examining the events. */
3311 x_new_focus_frame (struct x_display_info
*dpyinfo
, struct frame
*frame
)
3313 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
3315 if (frame
!= dpyinfo
->x_focus_frame
)
3317 /* Set this before calling other routines, so that they see
3318 the correct value of x_focus_frame. */
3319 dpyinfo
->x_focus_frame
= frame
;
3321 if (old_focus
&& old_focus
->auto_lower
)
3322 x_lower_frame (old_focus
);
3324 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
3325 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
3327 pending_autoraise_frame
= 0;
3330 x_frame_rehighlight (dpyinfo
);
3333 /* Handle FocusIn and FocusOut state changes for FRAME.
3334 If FRAME has focus and there exists more than one frame, puts
3335 a FOCUS_IN_EVENT into *BUFP. */
3338 x_focus_changed (int type
, int state
, struct x_display_info
*dpyinfo
, struct frame
*frame
, struct input_event
*bufp
)
3340 if (type
== FocusIn
)
3342 if (dpyinfo
->x_focus_event_frame
!= frame
)
3344 x_new_focus_frame (dpyinfo
, frame
);
3345 dpyinfo
->x_focus_event_frame
= frame
;
3347 /* Don't stop displaying the initial startup message
3348 for a switch-frame event we don't need. */
3349 if (NILP (Vterminal_frame
)
3350 && CONSP (Vframe_list
)
3351 && !NILP (XCDR (Vframe_list
)))
3353 bufp
->kind
= FOCUS_IN_EVENT
;
3354 XSETFRAME (bufp
->frame_or_window
, frame
);
3358 frame
->output_data
.x
->focus_state
|= state
;
3361 if (FRAME_XIC (frame
))
3362 XSetICFocus (FRAME_XIC (frame
));
3365 else if (type
== FocusOut
)
3367 frame
->output_data
.x
->focus_state
&= ~state
;
3369 if (dpyinfo
->x_focus_event_frame
== frame
)
3371 dpyinfo
->x_focus_event_frame
= 0;
3372 x_new_focus_frame (dpyinfo
, 0);
3376 if (FRAME_XIC (frame
))
3377 XUnsetICFocus (FRAME_XIC (frame
));
3379 if (frame
->pointer_invisible
)
3380 XTtoggle_invisible_pointer (frame
, 0);
3384 /* The focus may have changed. Figure out if it is a real focus change,
3385 by checking both FocusIn/Out and Enter/LeaveNotify events.
3387 Returns FOCUS_IN_EVENT event in *BUFP. */
3390 x_detect_focus_change (struct x_display_info
*dpyinfo
, XEvent
*event
, struct input_event
*bufp
)
3392 struct frame
*frame
;
3394 frame
= x_any_window_to_frame (dpyinfo
, event
->xany
.window
);
3398 switch (event
->type
)
3403 struct frame
*focus_frame
= dpyinfo
->x_focus_event_frame
;
3405 = focus_frame
? focus_frame
->output_data
.x
->focus_state
: 0;
3407 if (event
->xcrossing
.detail
!= NotifyInferior
3408 && event
->xcrossing
.focus
3409 && ! (focus_state
& FOCUS_EXPLICIT
))
3410 x_focus_changed ((event
->type
== EnterNotify
? FocusIn
: FocusOut
),
3412 dpyinfo
, frame
, bufp
);
3418 x_focus_changed (event
->type
,
3419 (event
->xfocus
.detail
== NotifyPointer
?
3420 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
3421 dpyinfo
, frame
, bufp
);
3425 if (event
->xclient
.message_type
== dpyinfo
->Xatom_XEMBED
)
3427 enum xembed_message msg
= event
->xclient
.data
.l
[1];
3428 x_focus_changed ((msg
== XEMBED_FOCUS_IN
? FocusIn
: FocusOut
),
3429 FOCUS_EXPLICIT
, dpyinfo
, frame
, bufp
);
3436 /* Handle an event saying the mouse has moved out of an Emacs frame. */
3439 x_mouse_leave (struct x_display_info
*dpyinfo
)
3441 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
3444 /* The focus has changed, or we have redirected a frame's focus to
3445 another frame (this happens when a frame uses a surrogate
3446 mini-buffer frame). Shift the highlight as appropriate.
3448 The FRAME argument doesn't necessarily have anything to do with which
3449 frame is being highlighted or un-highlighted; we only use it to find
3450 the appropriate X display info. */
3453 XTframe_rehighlight (struct frame
*frame
)
3455 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
3459 x_frame_rehighlight (struct x_display_info
*dpyinfo
)
3461 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
3463 if (dpyinfo
->x_focus_frame
)
3465 dpyinfo
->x_highlight_frame
3466 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
3467 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
3468 : dpyinfo
->x_focus_frame
);
3469 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
3471 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
3472 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
3476 dpyinfo
->x_highlight_frame
= 0;
3478 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
3481 frame_unhighlight (old_highlight
);
3482 if (dpyinfo
->x_highlight_frame
)
3483 frame_highlight (dpyinfo
->x_highlight_frame
);
3489 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
3491 /* Initialize mode_switch_bit and modifier_meaning. */
3493 x_find_modifier_meanings (struct x_display_info
*dpyinfo
)
3495 int min_code
, max_code
;
3498 XModifierKeymap
*mods
;
3500 dpyinfo
->meta_mod_mask
= 0;
3501 dpyinfo
->shift_lock_mask
= 0;
3502 dpyinfo
->alt_mod_mask
= 0;
3503 dpyinfo
->super_mod_mask
= 0;
3504 dpyinfo
->hyper_mod_mask
= 0;
3506 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
3508 syms
= XGetKeyboardMapping (dpyinfo
->display
,
3509 min_code
, max_code
- min_code
+ 1,
3511 mods
= XGetModifierMapping (dpyinfo
->display
);
3513 /* Scan the modifier table to see which modifier bits the Meta and
3514 Alt keysyms are on. */
3516 int row
, col
; /* The row and column in the modifier table. */
3517 int found_alt_or_meta
;
3519 for (row
= 3; row
< 8; row
++)
3521 found_alt_or_meta
= 0;
3522 for (col
= 0; col
< mods
->max_keypermod
; col
++)
3524 KeyCode code
= mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
3526 /* Zeroes are used for filler. Skip them. */
3530 /* Are any of this keycode's keysyms a meta key? */
3534 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
3536 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
3542 found_alt_or_meta
= 1;
3543 dpyinfo
->meta_mod_mask
|= (1 << row
);
3548 found_alt_or_meta
= 1;
3549 dpyinfo
->alt_mod_mask
|= (1 << row
);
3554 if (!found_alt_or_meta
)
3555 dpyinfo
->hyper_mod_mask
|= (1 << row
);
3556 code_col
= syms_per_code
;
3557 col
= mods
->max_keypermod
;
3562 if (!found_alt_or_meta
)
3563 dpyinfo
->super_mod_mask
|= (1 << row
);
3564 code_col
= syms_per_code
;
3565 col
= mods
->max_keypermod
;
3569 /* Ignore this if it's not on the lock modifier. */
3570 if (!found_alt_or_meta
&& ((1 << row
) == LockMask
))
3571 dpyinfo
->shift_lock_mask
= LockMask
;
3572 code_col
= syms_per_code
;
3573 col
= mods
->max_keypermod
;
3582 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
3583 if (! dpyinfo
->meta_mod_mask
)
3585 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
3586 dpyinfo
->alt_mod_mask
= 0;
3589 /* If some keys are both alt and meta,
3590 make them just meta, not alt. */
3591 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
3593 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
3596 XFree ((char *) syms
);
3597 XFreeModifiermap (mods
);
3600 /* Convert between the modifier bits X uses and the modifier bits
3604 x_x_to_emacs_modifiers (struct x_display_info
*dpyinfo
, unsigned int state
)
3606 EMACS_UINT mod_meta
= meta_modifier
;
3607 EMACS_UINT mod_alt
= alt_modifier
;
3608 EMACS_UINT mod_hyper
= hyper_modifier
;
3609 EMACS_UINT mod_super
= super_modifier
;
3612 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3613 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
3614 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3615 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
3616 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3617 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
3618 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3619 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
3622 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
3623 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
3624 | ((state
& dpyinfo
->meta_mod_mask
) ? mod_meta
: 0)
3625 | ((state
& dpyinfo
->alt_mod_mask
) ? mod_alt
: 0)
3626 | ((state
& dpyinfo
->super_mod_mask
) ? mod_super
: 0)
3627 | ((state
& dpyinfo
->hyper_mod_mask
) ? mod_hyper
: 0));
3631 x_emacs_to_x_modifiers (struct x_display_info
*dpyinfo
, unsigned int state
)
3633 EMACS_UINT mod_meta
= meta_modifier
;
3634 EMACS_UINT mod_alt
= alt_modifier
;
3635 EMACS_UINT mod_hyper
= hyper_modifier
;
3636 EMACS_UINT mod_super
= super_modifier
;
3640 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3641 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
3642 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3643 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
3644 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3645 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
3646 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3647 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
3650 return ( ((state
& mod_alt
) ? dpyinfo
->alt_mod_mask
: 0)
3651 | ((state
& mod_super
) ? dpyinfo
->super_mod_mask
: 0)
3652 | ((state
& mod_hyper
) ? dpyinfo
->hyper_mod_mask
: 0)
3653 | ((state
& shift_modifier
) ? ShiftMask
: 0)
3654 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
3655 | ((state
& mod_meta
) ? dpyinfo
->meta_mod_mask
: 0));
3658 /* Convert a keysym to its name. */
3661 x_get_keysym_name (int keysym
)
3666 value
= XKeysymToString (keysym
);
3674 /* Mouse clicks and mouse movement. Rah. */
3676 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3678 If the event is a button press, then note that we have grabbed
3682 construct_mouse_click (struct input_event
*result
, XButtonEvent
*event
, struct frame
*f
)
3684 /* Make the event type NO_EVENT; we'll change that when we decide
3686 result
->kind
= MOUSE_CLICK_EVENT
;
3687 result
->code
= event
->button
- Button1
;
3688 result
->timestamp
= event
->time
;
3689 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
3691 | (event
->type
== ButtonRelease
3695 XSETINT (result
->x
, event
->x
);
3696 XSETINT (result
->y
, event
->y
);
3697 XSETFRAME (result
->frame_or_window
, f
);
3703 /* Function to report a mouse movement to the mainstream Emacs code.
3704 The input handler calls this.
3706 We have received a mouse movement event, which is given in *event.
3707 If the mouse is over a different glyph than it was last time, tell
3708 the mainstream emacs code by setting mouse_moved. If not, ask for
3709 another motion event, so we can check again the next time it moves. */
3711 static XMotionEvent last_mouse_motion_event
;
3712 static Lisp_Object last_mouse_motion_frame
;
3715 note_mouse_movement (FRAME_PTR frame
, XMotionEvent
*event
)
3717 last_mouse_movement_time
= event
->time
;
3718 last_mouse_motion_event
= *event
;
3719 XSETFRAME (last_mouse_motion_frame
, frame
);
3721 if (!FRAME_X_OUTPUT (frame
))
3724 if (event
->window
!= FRAME_X_WINDOW (frame
))
3726 frame
->mouse_moved
= 1;
3727 last_mouse_scroll_bar
= Qnil
;
3728 note_mouse_highlight (frame
, -1, -1);
3729 last_mouse_glyph_frame
= 0;
3734 /* Has the mouse moved off the glyph it was on at the last sighting? */
3735 if (frame
!= last_mouse_glyph_frame
3736 || event
->x
< last_mouse_glyph
.x
3737 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
3738 || event
->y
< last_mouse_glyph
.y
3739 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
3741 frame
->mouse_moved
= 1;
3742 last_mouse_scroll_bar
= Qnil
;
3743 note_mouse_highlight (frame
, event
->x
, event
->y
);
3744 /* Remember which glyph we're now on. */
3745 remember_mouse_glyph (frame
, event
->x
, event
->y
, &last_mouse_glyph
);
3746 last_mouse_glyph_frame
= frame
;
3754 /************************************************************************
3756 ************************************************************************/
3759 redo_mouse_highlight (void)
3761 if (!NILP (last_mouse_motion_frame
)
3762 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
3763 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
3764 last_mouse_motion_event
.x
,
3765 last_mouse_motion_event
.y
);
3770 /* Return the current position of the mouse.
3771 *FP should be a frame which indicates which display to ask about.
3773 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
3774 and *PART to the frame, window, and scroll bar part that the mouse
3775 is over. Set *X and *Y to the portion and whole of the mouse's
3776 position on the scroll bar.
3778 If the mouse movement started elsewhere, set *FP to the frame the
3779 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
3782 Set *TIME to the server time-stamp for the time at which the mouse
3783 was at this position.
3785 Don't store anything if we don't have a valid set of values to report.
3787 This clears the mouse_moved flag, so we can wait for the next mouse
3791 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
)
3797 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
3798 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3804 Window dummy_window
;
3807 Lisp_Object frame
, tail
;
3809 /* Clear the mouse-moved flag for every frame on this display. */
3810 FOR_EACH_FRAME (tail
, frame
)
3811 if (FRAME_X_P (XFRAME (frame
))
3812 && FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
3813 XFRAME (frame
)->mouse_moved
= 0;
3815 last_mouse_scroll_bar
= Qnil
;
3817 /* Figure out which root window we're on. */
3818 XQueryPointer (FRAME_X_DISPLAY (*fp
),
3819 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
3821 /* The root window which contains the pointer. */
3824 /* Trash which we can't trust if the pointer is on
3825 a different screen. */
3828 /* The position on that root window. */
3831 /* More trash we can't trust. */
3834 /* Modifier keys and pointer buttons, about which
3836 (unsigned int *) &dummy
);
3838 /* Now we have a position on the root; find the innermost window
3839 containing the pointer. */
3843 int parent_x
= 0, parent_y
= 0;
3847 /* XTranslateCoordinates can get errors if the window
3848 structure is changing at the same time this function
3849 is running. So at least we must not crash from them. */
3851 x_catch_errors (FRAME_X_DISPLAY (*fp
));
3853 if (FRAME_X_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
3854 && FRAME_LIVE_P (last_mouse_frame
))
3856 /* If mouse was grabbed on a frame, give coords for that frame
3857 even if the mouse is now outside it. */
3858 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3860 /* From-window, to-window. */
3861 root
, FRAME_X_WINDOW (last_mouse_frame
),
3863 /* From-position, to-position. */
3864 root_x
, root_y
, &win_x
, &win_y
,
3868 f1
= last_mouse_frame
;
3874 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3876 /* From-window, to-window. */
3879 /* From-position, to-position. */
3880 root_x
, root_y
, &win_x
, &win_y
,
3885 if (child
== None
|| child
== win
)
3888 /* We don't wan't to know the innermost window. We
3889 want the edit window. For non-Gtk+ the innermost
3890 window is the edit window. For Gtk+ it might not
3891 be. It might be the tool bar for example. */
3892 if (x_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
))
3900 /* Now we know that:
3901 win is the innermost window containing the pointer
3902 (XTC says it has no child containing the pointer),
3903 win_x and win_y are the pointer's position in it
3904 (XTC did this the last time through), and
3905 parent_x and parent_y are the pointer's position in win's parent.
3906 (They are what win_x and win_y were when win was child.
3907 If win is the root window, it has no parent, and
3908 parent_{x,y} are invalid, but that's okay, because we'll
3909 never use them in that case.) */
3912 /* We don't wan't to know the innermost window. We
3913 want the edit window. */
3914 f1
= x_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
3916 /* Is win one of our frames? */
3917 f1
= x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
3920 #ifdef USE_X_TOOLKIT
3921 /* If we end up with the menu bar window, say it's not
3924 && f1
->output_data
.x
->menubar_widget
3925 && win
== XtWindow (f1
->output_data
.x
->menubar_widget
))
3927 #endif /* USE_X_TOOLKIT */
3930 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
3933 x_uncatch_errors ();
3935 /* If not, is it one of our scroll bars? */
3938 struct scroll_bar
*bar
;
3940 bar
= x_window_to_scroll_bar (FRAME_X_DISPLAY (*fp
), win
);
3944 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3950 if (f1
== 0 && insist
> 0)
3951 f1
= SELECTED_FRAME ();
3955 /* Ok, we found a frame. Store all the values.
3956 last_mouse_glyph is a rectangle used to reduce the
3957 generation of mouse events. To not miss any motion
3958 events, we must divide the frame into rectangles of the
3959 size of the smallest character that could be displayed
3960 on it, i.e. into the same rectangles that matrices on
3961 the frame are divided into. */
3963 remember_mouse_glyph (f1
, win_x
, win_y
, &last_mouse_glyph
);
3964 last_mouse_glyph_frame
= f1
;
3969 XSETINT (*x
, win_x
);
3970 XSETINT (*y
, win_y
);
3971 *time
= last_mouse_movement_time
;
3981 /***********************************************************************
3983 ***********************************************************************/
3985 /* Scroll bar support. */
3987 /* Given an X window ID and a DISPLAY, find the struct scroll_bar which
3989 This can be called in GC, so we have to make sure to strip off mark
3992 static struct scroll_bar
*
3993 x_window_to_scroll_bar (Display
*display
, Window window_id
)
3997 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
3998 window_id
= (Window
) xg_get_scroll_id_for_window (display
, window_id
);
3999 #endif /* USE_GTK && USE_TOOLKIT_SCROLL_BARS */
4001 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
4003 Lisp_Object frame
, bar
, condemned
;
4005 frame
= XCAR (tail
);
4006 /* All elements of Vframe_list should be frames. */
4007 if (! FRAMEP (frame
))
4010 if (! FRAME_X_P (XFRAME (frame
)))
4013 /* Scan this frame's scroll bar list for a scroll bar with the
4015 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
4016 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
4017 /* This trick allows us to search both the ordinary and
4018 condemned scroll bar lists with one loop. */
4019 ! NILP (bar
) || (bar
= condemned
,
4022 bar
= XSCROLL_BAR (bar
)->next
)
4023 if (XSCROLL_BAR (bar
)->x_window
== window_id
&&
4024 FRAME_X_DISPLAY (XFRAME (frame
)) == display
)
4025 return XSCROLL_BAR (bar
);
4032 #if defined USE_LUCID
4034 /* Return the Lucid menu bar WINDOW is part of. Return null
4035 if WINDOW is not part of a menu bar. */
4038 x_window_to_menu_bar (Window window
)
4042 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
4044 if (FRAME_X_P (XFRAME (XCAR (tail
))))
4046 Lisp_Object frame
= XCAR (tail
);
4047 Widget menu_bar
= XFRAME (frame
)->output_data
.x
->menubar_widget
;
4049 if (menu_bar
&& xlwmenu_window_p (menu_bar
, window
))
4057 #endif /* USE_LUCID */
4060 /************************************************************************
4062 ************************************************************************/
4064 #ifdef USE_TOOLKIT_SCROLL_BARS
4066 static void x_scroll_bar_to_input_event (XEvent
*, struct input_event
*);
4067 static void x_send_scroll_bar_event (Lisp_Object
, int, int, int);
4068 static void x_create_toolkit_scroll_bar (struct frame
*,
4069 struct scroll_bar
*);
4070 static void x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*,
4074 /* Lisp window being scrolled. Set when starting to interact with
4075 a toolkit scroll bar, reset to nil when ending the interaction. */
4077 static Lisp_Object window_being_scrolled
;
4079 /* Last scroll bar part sent in xm_scroll_callback. */
4081 static int last_scroll_bar_part
;
4083 /* Whether this is an Xaw with arrow-scrollbars. This should imply
4084 that movements of 1/20 of the screen size are mapped to up/down. */
4087 /* Id of action hook installed for scroll bars. */
4089 static XtActionHookId action_hook_id
;
4091 static Boolean xaw3d_arrow_scroll
;
4093 /* Whether the drag scrolling maintains the mouse at the top of the
4094 thumb. If not, resizing the thumb needs to be done more carefully
4095 to avoid jerkyness. */
4097 static Boolean xaw3d_pick_top
;
4099 /* Action hook installed via XtAppAddActionHook when toolkit scroll
4100 bars are used.. The hook is responsible for detecting when
4101 the user ends an interaction with the scroll bar, and generates
4102 a `end-scroll' SCROLL_BAR_CLICK_EVENT' event if so. */
4105 xt_action_hook (Widget widget
, XtPointer client_data
, String action_name
,
4106 XEvent
*event
, String
*params
, Cardinal
*num_params
)
4109 const char *end_action
;
4112 scroll_bar_p
= XmIsScrollBar (widget
);
4113 end_action
= "Release";
4114 #else /* !USE_MOTIF i.e. use Xaw */
4115 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
4116 end_action
= "EndScroll";
4117 #endif /* USE_MOTIF */
4120 && strcmp (action_name
, end_action
) == 0
4121 && WINDOWP (window_being_scrolled
))
4125 x_send_scroll_bar_event (window_being_scrolled
,
4126 scroll_bar_end_scroll
, 0, 0);
4127 w
= XWINDOW (window_being_scrolled
);
4129 if (!NILP (XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
))
4131 XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
= Qnil
;
4132 /* The thumb size is incorrect while dragging: fix it. */
4133 set_vertical_scroll_bar (w
);
4135 window_being_scrolled
= Qnil
;
4136 last_scroll_bar_part
= -1;
4138 /* Xt timeouts no longer needed. */
4139 toolkit_scroll_bar_interaction
= 0;
4142 #endif /* not USE_GTK */
4144 /* A vector of windows used for communication between
4145 x_send_scroll_bar_event and x_scroll_bar_to_input_event. */
4147 static struct window
**scroll_bar_windows
;
4148 static int scroll_bar_windows_size
;
4151 /* Send a client message with message type Xatom_Scrollbar for a
4152 scroll action to the frame of WINDOW. PART is a value identifying
4153 the part of the scroll bar that was clicked on. PORTION is the
4154 amount to scroll of a whole of WHOLE. */
4157 x_send_scroll_bar_event (Lisp_Object window
, int part
, int portion
, int whole
)
4160 XClientMessageEvent
*ev
= (XClientMessageEvent
*) &event
;
4161 struct window
*w
= XWINDOW (window
);
4162 struct frame
*f
= XFRAME (w
->frame
);
4167 /* Construct a ClientMessage event to send to the frame. */
4168 ev
->type
= ClientMessage
;
4169 ev
->message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_Scrollbar
;
4170 ev
->display
= FRAME_X_DISPLAY (f
);
4171 ev
->window
= FRAME_X_WINDOW (f
);
4174 /* We can only transfer 32 bits in the XClientMessageEvent, which is
4175 not enough to store a pointer or Lisp_Object on a 64 bit system.
4176 So, store the window in scroll_bar_windows and pass the index
4177 into that array in the event. */
4178 for (i
= 0; i
< scroll_bar_windows_size
; ++i
)
4179 if (scroll_bar_windows
[i
] == NULL
)
4182 if (i
== scroll_bar_windows_size
)
4184 int new_size
= max (10, 2 * scroll_bar_windows_size
);
4185 size_t nbytes
= new_size
* sizeof *scroll_bar_windows
;
4186 size_t old_nbytes
= scroll_bar_windows_size
* sizeof *scroll_bar_windows
;
4188 scroll_bar_windows
= (struct window
**) xrealloc (scroll_bar_windows
,
4190 memset (&scroll_bar_windows
[i
], 0, nbytes
- old_nbytes
);
4191 scroll_bar_windows_size
= new_size
;
4194 scroll_bar_windows
[i
] = w
;
4195 ev
->data
.l
[0] = (long) i
;
4196 ev
->data
.l
[1] = (long) part
;
4197 ev
->data
.l
[2] = (long) 0;
4198 ev
->data
.l
[3] = (long) portion
;
4199 ev
->data
.l
[4] = (long) whole
;
4201 /* Make Xt timeouts work while the scroll bar is active. */
4202 toolkit_scroll_bar_interaction
= 1;
4203 #ifdef USE_X_TOOLKIT
4204 x_activate_timeout_atimer ();
4207 /* Setting the event mask to zero means that the message will
4208 be sent to the client that created the window, and if that
4209 window no longer exists, no event will be sent. */
4210 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
4215 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
4219 x_scroll_bar_to_input_event (XEvent
*event
, struct input_event
*ievent
)
4221 XClientMessageEvent
*ev
= (XClientMessageEvent
*) event
;
4226 w
= scroll_bar_windows
[ev
->data
.l
[0]];
4227 scroll_bar_windows
[ev
->data
.l
[0]] = NULL
;
4229 XSETWINDOW (window
, w
);
4230 f
= XFRAME (w
->frame
);
4232 ievent
->kind
= SCROLL_BAR_CLICK_EVENT
;
4233 ievent
->frame_or_window
= window
;
4236 ievent
->timestamp
= CurrentTime
;
4238 ievent
->timestamp
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
4240 ievent
->part
= ev
->data
.l
[1];
4241 ievent
->code
= ev
->data
.l
[2];
4242 ievent
->x
= make_number ((int) ev
->data
.l
[3]);
4243 ievent
->y
= make_number ((int) ev
->data
.l
[4]);
4244 ievent
->modifiers
= 0;
4250 /* Minimum and maximum values used for Motif scroll bars. */
4252 #define XM_SB_MAX 10000000
4255 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
4256 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
4257 CALL_DATA is a pointer to a XmScrollBarCallbackStruct. */
4260 xm_scroll_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
4262 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4263 XmScrollBarCallbackStruct
*cs
= (XmScrollBarCallbackStruct
*) call_data
;
4264 int part
= -1, whole
= 0, portion
= 0;
4268 case XmCR_DECREMENT
:
4269 bar
->dragging
= Qnil
;
4270 part
= scroll_bar_up_arrow
;
4273 case XmCR_INCREMENT
:
4274 bar
->dragging
= Qnil
;
4275 part
= scroll_bar_down_arrow
;
4278 case XmCR_PAGE_DECREMENT
:
4279 bar
->dragging
= Qnil
;
4280 part
= scroll_bar_above_handle
;
4283 case XmCR_PAGE_INCREMENT
:
4284 bar
->dragging
= Qnil
;
4285 part
= scroll_bar_below_handle
;
4289 bar
->dragging
= Qnil
;
4290 part
= scroll_bar_to_top
;
4293 case XmCR_TO_BOTTOM
:
4294 bar
->dragging
= Qnil
;
4295 part
= scroll_bar_to_bottom
;
4302 /* Get the slider size. */
4304 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
4307 whole
= XM_SB_MAX
- slider_size
;
4308 portion
= min (cs
->value
, whole
);
4309 part
= scroll_bar_handle
;
4310 bar
->dragging
= make_number (cs
->value
);
4314 case XmCR_VALUE_CHANGED
:
4320 window_being_scrolled
= bar
->window
;
4321 last_scroll_bar_part
= part
;
4322 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4326 #elif defined USE_GTK
4328 /* Scroll bar callback for GTK scroll bars. WIDGET is the scroll
4329 bar widget. DATA is a pointer to the scroll_bar structure. */
4332 xg_scroll_callback (GtkRange
*range
,
4333 GtkScrollType scroll
,
4337 struct scroll_bar
*bar
= (struct scroll_bar
*) user_data
;
4339 int part
= -1, whole
= 0, portion
= 0;
4340 GtkAdjustment
*adj
= GTK_ADJUSTMENT (gtk_range_get_adjustment (range
));
4341 FRAME_PTR f
= (FRAME_PTR
) g_object_get_data (G_OBJECT (range
), XG_FRAME_DATA
);
4343 if (xg_ignore_gtk_scrollbar
) return FALSE
;
4344 position
= gtk_adjustment_get_value (adj
);
4349 case GTK_SCROLL_JUMP
:
4350 /* Buttons 1 2 or 3 must be grabbed. */
4351 if (FRAME_X_DISPLAY_INFO (f
)->grabbed
!= 0
4352 && FRAME_X_DISPLAY_INFO (f
)->grabbed
< (1 << 4))
4354 part
= scroll_bar_handle
;
4355 whole
= gtk_adjustment_get_upper (adj
) -
4356 gtk_adjustment_get_page_size (adj
);
4357 portion
= min ((int)position
, whole
);
4358 bar
->dragging
= make_number ((int)portion
);
4361 case GTK_SCROLL_STEP_BACKWARD
:
4362 part
= scroll_bar_up_arrow
;
4363 bar
->dragging
= Qnil
;
4365 case GTK_SCROLL_STEP_FORWARD
:
4366 part
= scroll_bar_down_arrow
;
4367 bar
->dragging
= Qnil
;
4369 case GTK_SCROLL_PAGE_BACKWARD
:
4370 part
= scroll_bar_above_handle
;
4371 bar
->dragging
= Qnil
;
4373 case GTK_SCROLL_PAGE_FORWARD
:
4374 part
= scroll_bar_below_handle
;
4375 bar
->dragging
= Qnil
;
4381 window_being_scrolled
= bar
->window
;
4382 last_scroll_bar_part
= part
;
4383 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4389 /* Callback for button release. Sets dragging to Qnil when dragging is done. */
4392 xg_end_scroll_callback (GtkWidget
*widget
,
4393 GdkEventButton
*event
,
4396 struct scroll_bar
*bar
= (struct scroll_bar
*) user_data
;
4397 bar
->dragging
= Qnil
;
4398 if (WINDOWP (window_being_scrolled
))
4400 x_send_scroll_bar_event (window_being_scrolled
,
4401 scroll_bar_end_scroll
, 0, 0);
4402 window_being_scrolled
= Qnil
;
4409 #else /* not USE_GTK and not USE_MOTIF */
4411 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
4412 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
4413 scroll bar struct. CALL_DATA is a pointer to a float saying where
4417 xaw_jump_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
4419 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4420 float top
= *(float *) call_data
;
4422 int whole
, portion
, height
;
4425 /* Get the size of the thumb, a value between 0 and 1. */
4427 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
4431 portion
= shown
< 1 ? top
* whole
: 0;
4433 if (shown
< 1 && (eabs (top
+ shown
- 1) < 1.0/height
))
4434 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
4435 the bottom, so we force the scrolling whenever we see that we're
4436 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
4437 we try to ensure that we always stay two pixels away from the
4439 part
= scroll_bar_down_arrow
;
4441 part
= scroll_bar_handle
;
4443 window_being_scrolled
= bar
->window
;
4444 bar
->dragging
= make_number (portion
);
4445 last_scroll_bar_part
= part
;
4446 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4450 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
4451 i.e. line or page up or down. WIDGET is the Xaw scroll bar
4452 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
4453 the scroll bar. CALL_DATA is an integer specifying the action that
4454 has taken place. Its magnitude is in the range 0..height of the
4455 scroll bar. Negative values mean scroll towards buffer start.
4456 Values < height of scroll bar mean line-wise movement. */
4459 xaw_scroll_callback (Widget widget
, XtPointer client_data
, XtPointer call_data
)
4461 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4462 /* The position really is stored cast to a pointer. */
4463 int position
= (long) call_data
;
4467 /* Get the height of the scroll bar. */
4469 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
4472 if (eabs (position
) >= height
)
4473 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
4475 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
4476 it maps line-movement to call_data = max(5, height/20). */
4477 else if (xaw3d_arrow_scroll
&& eabs (position
) <= max (5, height
/ 20))
4478 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
4480 part
= scroll_bar_move_ratio
;
4482 window_being_scrolled
= bar
->window
;
4483 bar
->dragging
= Qnil
;
4484 last_scroll_bar_part
= part
;
4485 x_send_scroll_bar_event (bar
->window
, part
, position
, height
);
4488 #endif /* not USE_GTK and not USE_MOTIF */
4490 #define SCROLL_BAR_NAME "verticalScrollBar"
4492 /* Create the widget for scroll bar BAR on frame F. Record the widget
4493 and X window of the scroll bar in BAR. */
4497 x_create_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
4499 const char *scroll_bar_name
= SCROLL_BAR_NAME
;
4502 xg_create_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
4503 G_CALLBACK (xg_end_scroll_callback
),
4508 #else /* not USE_GTK */
4511 x_create_toolkit_scroll_bar (struct frame
*f
, struct scroll_bar
*bar
)
4517 char *scroll_bar_name
= SCROLL_BAR_NAME
;
4518 unsigned long pixel
;
4523 /* Set resources. Create the widget. */
4524 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4525 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
4526 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
4527 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
4528 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
4529 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
4530 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
4532 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4535 XtSetArg (av
[ac
], XmNforeground
, pixel
);
4539 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4542 XtSetArg (av
[ac
], XmNbackground
, pixel
);
4546 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
4547 scroll_bar_name
, av
, ac
);
4549 /* Add one callback for everything that can happen. */
4550 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
4552 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
4554 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
4556 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
4558 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
4560 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
4562 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
4565 /* Realize the widget. Only after that is the X window created. */
4566 XtRealizeWidget (widget
);
4568 /* Set the cursor to an arrow. I didn't find a resource to do that.
4569 And I'm wondering why it hasn't an arrow cursor by default. */
4570 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
4571 f
->output_data
.x
->nontext_cursor
);
4573 #else /* !USE_MOTIF i.e. use Xaw */
4575 /* Set resources. Create the widget. The background of the
4576 Xaw3d scroll bar widget is a little bit light for my taste.
4577 We don't alter it here to let users change it according
4578 to their taste with `emacs*verticalScrollBar.background: xxx'. */
4579 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4580 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
4581 /* For smoother scrolling with Xaw3d -sm */
4582 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
4584 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4587 XtSetArg (av
[ac
], XtNforeground
, pixel
);
4591 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4594 XtSetArg (av
[ac
], XtNbackground
, pixel
);
4598 /* Top/bottom shadow colors. */
4600 /* Allocate them, if necessary. */
4601 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
4603 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4606 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
4607 FRAME_X_COLORMAP (f
),
4608 &pixel
, 1.2, 0x8000))
4610 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
4613 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4615 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4618 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
),
4619 FRAME_X_COLORMAP (f
),
4620 &pixel
, 0.6, 0x4000))
4622 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
4626 #ifdef XtNbeNiceToColormap
4627 /* Tell the toolkit about them. */
4628 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
4629 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4630 /* We tried to allocate a color for the top/bottom shadow, and
4631 failed, so tell Xaw3d to use dithering instead. */
4632 /* But only if we have a small colormap. Xaw3d can allocate nice
4635 XtSetArg (av
[ac
], XtNbeNiceToColormap
,
4636 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)) < 16);
4640 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
4641 be more consistent with other emacs 3d colors, and since Xaw3d is
4642 not good at dealing with allocation failure. */
4644 /* This tells Xaw3d to use real colors instead of dithering for
4646 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
4649 /* Specify the colors. */
4650 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
4653 XtSetArg (av
[ac
], XtNtopShadowPixel
, pixel
);
4656 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
4659 XtSetArg (av
[ac
], XtNbottomShadowPixel
, pixel
);
4665 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
4666 f
->output_data
.x
->edit_widget
, av
, ac
);
4670 char *val
= initial
;
4671 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
4672 #ifdef XtNarrowScrollbars
4673 XtNarrowScrollbars
, (XtPointer
) &xaw3d_arrow_scroll
,
4675 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
4676 if (xaw3d_arrow_scroll
|| val
== initial
)
4677 { /* ARROW_SCROLL */
4678 xaw3d_arrow_scroll
= True
;
4679 /* Isn't that just a personal preference ? --Stef */
4680 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
4684 /* Define callbacks. */
4685 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
4686 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
4689 /* Realize the widget. Only after that is the X window created. */
4690 XtRealizeWidget (widget
);
4692 #endif /* !USE_MOTIF */
4694 /* Install an action hook that lets us detect when the user
4695 finishes interacting with a scroll bar. */
4696 if (action_hook_id
== 0)
4697 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
4699 /* Remember X window and widget in the scroll bar vector. */
4700 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
4701 xwindow
= XtWindow (widget
);
4702 bar
->x_window
= xwindow
;
4706 #endif /* not USE_GTK */
4709 /* Set the thumb size and position of scroll bar BAR. We are currently
4710 displaying PORTION out of a whole WHOLE, and our position POSITION. */
4714 x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
, int whole
)
4716 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
4719 #else /* not USE_GTK */
4721 x_set_toolkit_scroll_bar_thumb (struct scroll_bar
*bar
, int portion
, int position
,
4724 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4725 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4732 /* We use an estimate of 30 chars per line rather than the real
4733 `portion' value. This has the disadvantage that the thumb size
4734 is not very representative, but it makes our life a lot easier.
4735 Otherwise, we have to constantly adjust the thumb size, which
4736 we can't always do quickly enough: while dragging, the size of
4737 the thumb might prevent the user from dragging the thumb all the
4738 way to the end. but Motif and some versions of Xaw3d don't allow
4739 updating the thumb size while dragging. Also, even if we can update
4740 its size, the update will often happen too late.
4741 If you don't believe it, check out revision 1.650 of xterm.c to see
4742 what hoops we were going through and the still poor behavior we got. */
4743 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
4744 /* When the thumb is at the bottom, position == whole.
4745 So we need to increase `whole' to make space for the thumb. */
4752 top
= (float) position
/ whole
;
4753 shown
= (float) portion
/ whole
;
4756 if (NILP (bar
->dragging
))
4760 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
4761 is the scroll bar's maximum and MIN is the scroll bar's minimum
4763 size
= shown
* XM_SB_MAX
;
4764 size
= min (size
, XM_SB_MAX
);
4765 size
= max (size
, 1);
4767 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
4768 value
= top
* XM_SB_MAX
;
4769 value
= min (value
, XM_SB_MAX
- size
);
4771 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
4773 #else /* !USE_MOTIF i.e. use Xaw */
4779 top
= (float) position
/ whole
;
4780 shown
= (float) portion
/ whole
;
4784 float old_top
, old_shown
;
4786 XtVaGetValues (widget
,
4787 XtNtopOfThumb
, &old_top
,
4788 XtNshown
, &old_shown
,
4792 /* Massage the top+shown values. */
4793 if (NILP (bar
->dragging
) || last_scroll_bar_part
== scroll_bar_down_arrow
)
4794 top
= max (0, min (1, top
));
4797 /* Keep two pixels available for moving the thumb down. */
4798 shown
= max (0, min (1 - top
- (2.0 / height
), shown
));
4800 /* If the call to XawScrollbarSetThumb below doesn't seem to work,
4801 check that your system's configuration file contains a define
4802 for `NARROWPROTO'. See s/freebsd.h for an example. */
4803 if (top
!= old_top
|| shown
!= old_shown
)
4805 if (NILP (bar
->dragging
))
4806 XawScrollbarSetThumb (widget
, top
, shown
);
4809 /* Try to make the scrolling a tad smoother. */
4810 if (!xaw3d_pick_top
)
4811 shown
= min (shown
, old_shown
);
4813 XawScrollbarSetThumb (widget
, top
, shown
);
4817 #endif /* !USE_MOTIF */
4821 #endif /* not USE_GTK */
4823 #endif /* USE_TOOLKIT_SCROLL_BARS */
4827 /************************************************************************
4828 Scroll bars, general
4829 ************************************************************************/
4831 /* Create a scroll bar and return the scroll bar vector for it. W is
4832 the Emacs window on which to create the scroll bar. TOP, LEFT,
4833 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
4836 static struct scroll_bar
*
4837 x_scroll_bar_create (struct window
*w
, int top
, int left
, int width
, int height
)
4839 struct frame
*f
= XFRAME (w
->frame
);
4840 struct scroll_bar
*bar
4841 = ALLOCATE_PSEUDOVECTOR (struct scroll_bar
, x_window
, PVEC_OTHER
);
4845 #ifdef USE_TOOLKIT_SCROLL_BARS
4846 x_create_toolkit_scroll_bar (f
, bar
);
4847 #else /* not USE_TOOLKIT_SCROLL_BARS */
4849 XSetWindowAttributes a
;
4853 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4854 if (a
.background_pixel
== -1)
4855 a
.background_pixel
= FRAME_BACKGROUND_PIXEL (f
);
4857 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
4858 | ButtonMotionMask
| PointerMotionHintMask
4860 a
.cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
4862 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
4864 /* Clear the area of W that will serve as a scroll bar. This is
4865 for the case that a window has been split horizontally. In
4866 this case, no clear_frame is generated to reduce flickering. */
4867 if (width
> 0 && height
> 0)
4868 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4870 window_box_height (w
), False
);
4872 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4873 /* Position and size of scroll bar. */
4874 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4876 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4878 /* Border width, depth, class, and visual. */
4885 bar
->x_window
= window
;
4887 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4889 XSETWINDOW (bar
->window
, w
);
4893 bar
->height
= height
;
4896 bar
->dragging
= Qnil
;
4897 bar
->fringe_extended_p
= 0;
4899 /* Add bar to its frame's list of scroll bars. */
4900 bar
->next
= FRAME_SCROLL_BARS (f
);
4902 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
4903 if (!NILP (bar
->next
))
4904 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4906 /* Map the window/widget. */
4907 #ifdef USE_TOOLKIT_SCROLL_BARS
4910 xg_update_scrollbar_pos (f
,
4913 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4914 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4916 #else /* not USE_GTK */
4917 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4918 XtConfigureWidget (scroll_bar
,
4919 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4921 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4922 max (height
, 1), 0);
4923 XtMapWidget (scroll_bar
);
4924 #endif /* not USE_GTK */
4926 #else /* not USE_TOOLKIT_SCROLL_BARS */
4927 XMapRaised (FRAME_X_DISPLAY (f
), bar
->x_window
);
4928 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4935 #ifndef USE_TOOLKIT_SCROLL_BARS
4937 /* Draw BAR's handle in the proper position.
4939 If the handle is already drawn from START to END, don't bother
4940 redrawing it, unless REBUILD is non-zero; in that case, always
4941 redraw it. (REBUILD is handy for drawing the handle after expose
4944 Normally, we want to constrain the start and end of the handle to
4945 fit inside its rectangle, but if the user is dragging the scroll
4946 bar handle, we want to let them drag it down all the way, so that
4947 the bar's top is as far down as it goes; otherwise, there's no way
4948 to move to the very end of the buffer. */
4951 x_scroll_bar_set_handle (struct scroll_bar
*bar
, int start
, int end
, int rebuild
)
4953 int dragging
= ! NILP (bar
->dragging
);
4954 Window w
= bar
->x_window
;
4955 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4956 GC gc
= f
->output_data
.x
->normal_gc
;
4958 /* If the display is already accurate, do nothing. */
4960 && start
== bar
->start
4967 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, bar
->width
);
4968 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, bar
->height
);
4969 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
4971 /* Make sure the values are reasonable, and try to preserve
4972 the distance between start and end. */
4974 int length
= end
- start
;
4978 else if (start
> top_range
)
4980 end
= start
+ length
;
4984 else if (end
> top_range
&& ! dragging
)
4988 /* Store the adjusted setting in the scroll bar. */
4992 /* Clip the end position, just for display. */
4993 if (end
> top_range
)
4996 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
4997 below top positions, to make sure the handle is always at least
4998 that many pixels tall. */
4999 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
5001 /* Draw the empty space above the handle. Note that we can't clear
5002 zero-height areas; that means "clear to end of window." */
5004 x_clear_area (FRAME_X_DISPLAY (f
), w
,
5005 /* x, y, width, height, and exposures. */
5006 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
5007 VERTICAL_SCROLL_BAR_TOP_BORDER
,
5008 inside_width
, start
,
5011 /* Change to proper foreground color if one is specified. */
5012 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5013 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5014 f
->output_data
.x
->scroll_bar_foreground_pixel
);
5016 /* Draw the handle itself. */
5017 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
5018 /* x, y, width, height */
5019 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
5020 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
5021 inside_width
, end
- start
);
5023 /* Restore the foreground color of the GC if we changed it above. */
5024 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5025 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5026 FRAME_FOREGROUND_PIXEL (f
));
5028 /* Draw the empty space below the handle. Note that we can't
5029 clear zero-height areas; that means "clear to end of window." */
5030 if (end
< inside_height
)
5031 x_clear_area (FRAME_X_DISPLAY (f
), w
,
5032 /* x, y, width, height, and exposures. */
5033 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
5034 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
5035 inside_width
, inside_height
- end
,
5043 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5045 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
5049 x_scroll_bar_remove (struct scroll_bar
*bar
)
5051 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5054 #ifdef USE_TOOLKIT_SCROLL_BARS
5056 xg_remove_scroll_bar (f
, bar
->x_window
);
5057 #else /* not USE_GTK */
5058 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
5059 #endif /* not USE_GTK */
5061 XDestroyWindow (FRAME_X_DISPLAY (f
), bar
->x_window
);
5064 /* Disassociate this scroll bar from its window. */
5065 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
5071 /* Set the handle of the vertical scroll bar for WINDOW to indicate
5072 that we are displaying PORTION characters out of a total of WHOLE
5073 characters, starting at POSITION. If WINDOW has no scroll bar,
5077 XTset_vertical_scroll_bar (struct window
*w
, int portion
, int whole
, int position
)
5079 struct frame
*f
= XFRAME (w
->frame
);
5080 struct scroll_bar
*bar
;
5081 int top
, height
, left
, sb_left
, width
, sb_width
;
5082 int window_y
, window_height
;
5083 #ifdef USE_TOOLKIT_SCROLL_BARS
5084 int fringe_extended_p
;
5087 /* Get window dimensions. */
5088 window_box (w
, -1, 0, &window_y
, 0, &window_height
);
5090 width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
5091 height
= window_height
;
5093 /* Compute the left edge of the scroll bar area. */
5094 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
5096 /* Compute the width of the scroll bar which might be less than
5097 the width of the area reserved for the scroll bar. */
5098 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
) > 0)
5099 sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
5103 /* Compute the left edge of the scroll bar. */
5104 #ifdef USE_TOOLKIT_SCROLL_BARS
5105 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
5106 sb_left
= left
+ (WINDOW_RIGHTMOST_P (w
) ? width
- sb_width
: 0);
5108 sb_left
= left
+ (WINDOW_LEFTMOST_P (w
) ? 0 : width
- sb_width
);
5110 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
5111 sb_left
= left
+ width
- sb_width
;
5116 #ifdef USE_TOOLKIT_SCROLL_BARS
5117 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
5118 fringe_extended_p
= (WINDOW_LEFTMOST_P (w
)
5119 && WINDOW_LEFT_FRINGE_WIDTH (w
)
5120 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5121 || WINDOW_LEFT_MARGIN_COLS (w
) == 0));
5123 fringe_extended_p
= (WINDOW_RIGHTMOST_P (w
)
5124 && WINDOW_RIGHT_FRINGE_WIDTH (w
)
5125 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5126 || WINDOW_RIGHT_MARGIN_COLS (w
) == 0));
5129 /* Does the scroll bar exist yet? */
5130 if (NILP (w
->vertical_scroll_bar
))
5132 if (width
> 0 && height
> 0)
5135 #ifdef USE_TOOLKIT_SCROLL_BARS
5136 if (fringe_extended_p
)
5137 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5138 sb_left
, top
, sb_width
, height
, False
);
5141 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5142 left
, top
, width
, height
, False
);
5146 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
5150 /* It may just need to be moved and resized. */
5151 unsigned int mask
= 0;
5153 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5157 if (sb_left
!= bar
->left
)
5159 if (top
!= bar
->top
)
5161 if (sb_width
!= bar
->width
)
5163 if (height
!= bar
->height
)
5166 #ifdef USE_TOOLKIT_SCROLL_BARS
5168 /* Move/size the scroll bar widget. */
5169 if (mask
|| bar
->fringe_extended_p
!= fringe_extended_p
)
5171 /* Since toolkit scroll bars are smaller than the space reserved
5172 for them on the frame, we have to clear "under" them. */
5173 if (width
> 0 && height
> 0)
5175 if (fringe_extended_p
)
5176 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5177 sb_left
, top
, sb_width
, height
, False
);
5179 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5180 left
, top
, width
, height
, False
);
5183 xg_update_scrollbar_pos (f
,
5186 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5187 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
*2,
5189 #else /* not USE_GTK */
5190 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
5191 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5193 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
5194 max (height
, 1), 0);
5195 #endif /* not USE_GTK */
5197 #else /* not USE_TOOLKIT_SCROLL_BARS */
5199 /* Clear areas not covered by the scroll bar because of
5200 VERTICAL_SCROLL_BAR_WIDTH_TRIM. */
5201 if (VERTICAL_SCROLL_BAR_WIDTH_TRIM
)
5203 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5204 left
, top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5206 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5207 left
+ width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5208 top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5212 /* Clear areas not covered by the scroll bar because it's not as
5213 wide as the area reserved for it. This makes sure a
5214 previous mode line display is cleared after C-x 2 C-x 1, for
5217 int area_width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
5218 int rest
= area_width
- sb_width
;
5219 if (rest
> 0 && height
> 0)
5221 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
5222 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5223 left
+ area_width
- rest
, top
,
5224 rest
, height
, False
);
5226 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5227 left
, top
, rest
, height
, False
);
5231 /* Move/size the scroll bar window. */
5236 wc
.x
= sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5238 wc
.width
= sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2;
5240 XConfigureWindow (FRAME_X_DISPLAY (f
), bar
->x_window
,
5244 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5246 /* Remember new settings. */
5247 bar
->left
= sb_left
;
5249 bar
->width
= sb_width
;
5250 bar
->height
= height
;
5255 #ifdef USE_TOOLKIT_SCROLL_BARS
5256 bar
->fringe_extended_p
= fringe_extended_p
;
5258 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
5259 #else /* not USE_TOOLKIT_SCROLL_BARS */
5260 /* Set the scroll bar's current state, unless we're currently being
5262 if (NILP (bar
->dragging
))
5264 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
5267 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
5270 int start
= ((double) position
* top_range
) / whole
;
5271 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
5272 x_scroll_bar_set_handle (bar
, start
, end
, 0);
5275 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5277 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
5281 /* The following three hooks are used when we're doing a thorough
5282 redisplay of the frame. We don't explicitly know which scroll bars
5283 are going to be deleted, because keeping track of when windows go
5284 away is a real pain - "Can you say set-window-configuration, boys
5285 and girls?" Instead, we just assert at the beginning of redisplay
5286 that *all* scroll bars are to be removed, and then save a scroll bar
5287 from the fiery pit when we actually redisplay its window. */
5289 /* Arrange for all scroll bars on FRAME to be removed at the next call
5290 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
5291 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
5294 XTcondemn_scroll_bars (FRAME_PTR frame
)
5296 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
5297 while (! NILP (FRAME_SCROLL_BARS (frame
)))
5300 bar
= FRAME_SCROLL_BARS (frame
);
5301 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
5302 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
5303 XSCROLL_BAR (bar
)->prev
= Qnil
;
5304 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
5305 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
5306 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
5311 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
5312 Note that WINDOW isn't necessarily condemned at all. */
5315 XTredeem_scroll_bar (struct window
*window
)
5317 struct scroll_bar
*bar
;
5320 /* We can't redeem this window's scroll bar if it doesn't have one. */
5321 if (NILP (window
->vertical_scroll_bar
))
5324 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
5326 /* Unlink it from the condemned list. */
5327 f
= XFRAME (WINDOW_FRAME (window
));
5328 if (NILP (bar
->prev
))
5330 /* If the prev pointer is nil, it must be the first in one of
5332 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
5333 /* It's not condemned. Everything's fine. */
5335 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
5336 window
->vertical_scroll_bar
))
5337 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
5339 /* If its prev pointer is nil, it must be at the front of
5340 one or the other! */
5344 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
5346 if (! NILP (bar
->next
))
5347 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
5349 bar
->next
= FRAME_SCROLL_BARS (f
);
5351 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
5352 if (! NILP (bar
->next
))
5353 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
5356 /* Remove all scroll bars on FRAME that haven't been saved since the
5357 last call to `*condemn_scroll_bars_hook'. */
5360 XTjudge_scroll_bars (FRAME_PTR f
)
5362 Lisp_Object bar
, next
;
5364 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
5366 /* Clear out the condemned list now so we won't try to process any
5367 more events on the hapless scroll bars. */
5368 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
5370 for (; ! NILP (bar
); bar
= next
)
5372 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
5374 x_scroll_bar_remove (b
);
5377 b
->next
= b
->prev
= Qnil
;
5380 /* Now there should be no references to the condemned scroll bars,
5381 and they should get garbage-collected. */
5385 #ifndef USE_TOOLKIT_SCROLL_BARS
5386 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
5387 is a no-op when using toolkit scroll bars.
5389 This may be called from a signal handler, so we have to ignore GC
5393 x_scroll_bar_expose (struct scroll_bar
*bar
, XEvent
*event
)
5395 Window w
= bar
->x_window
;
5396 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5397 GC gc
= f
->output_data
.x
->normal_gc
;
5398 int width_trim
= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5402 x_scroll_bar_set_handle (bar
, bar
->start
, bar
->end
, 1);
5404 /* Switch to scroll bar foreground color. */
5405 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5406 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5407 f
->output_data
.x
->scroll_bar_foreground_pixel
);
5409 /* Draw a one-pixel border just inside the edges of the scroll bar. */
5410 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
5412 /* x, y, width, height */
5414 bar
->width
- 1 - width_trim
- width_trim
,
5417 /* Restore the foreground color of the GC if we changed it above. */
5418 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
5419 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
5420 FRAME_FOREGROUND_PIXEL (f
));
5425 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5427 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
5428 is set to something other than NO_EVENT, it is enqueued.
5430 This may be called from a signal handler, so we have to ignore GC
5435 x_scroll_bar_handle_click (struct scroll_bar
*bar
, XEvent
*event
, struct input_event
*emacs_event
)
5437 if (! WINDOWP (bar
->window
))
5440 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
5441 emacs_event
->code
= event
->xbutton
.button
- Button1
;
5442 emacs_event
->modifiers
5443 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
5444 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
5445 event
->xbutton
.state
)
5446 | (event
->type
== ButtonRelease
5449 emacs_event
->frame_or_window
= bar
->window
;
5450 emacs_event
->arg
= Qnil
;
5451 emacs_event
->timestamp
= event
->xbutton
.time
;
5454 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
5455 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
5458 if (y
> top_range
) y
= top_range
;
5461 emacs_event
->part
= scroll_bar_above_handle
;
5462 else if (y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5463 emacs_event
->part
= scroll_bar_handle
;
5465 emacs_event
->part
= scroll_bar_below_handle
;
5467 #ifndef USE_TOOLKIT_SCROLL_BARS
5468 /* If the user has released the handle, set it to its final position. */
5469 if (event
->type
== ButtonRelease
5470 && ! NILP (bar
->dragging
))
5472 int new_start
= y
- XINT (bar
->dragging
);
5473 int new_end
= new_start
+ bar
->end
- bar
->start
;
5475 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5476 bar
->dragging
= Qnil
;
5480 XSETINT (emacs_event
->x
, y
);
5481 XSETINT (emacs_event
->y
, top_range
);
5485 #ifndef USE_TOOLKIT_SCROLL_BARS
5487 /* Handle some mouse motion while someone is dragging the scroll bar.
5489 This may be called from a signal handler, so we have to ignore GC
5493 x_scroll_bar_note_movement (struct scroll_bar
*bar
, XEvent
*event
)
5495 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
5497 last_mouse_movement_time
= event
->xmotion
.time
;
5500 XSETVECTOR (last_mouse_scroll_bar
, bar
);
5502 /* If we're dragging the bar, display it. */
5503 if (! NILP (bar
->dragging
))
5505 /* Where should the handle be now? */
5506 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
5508 if (new_start
!= bar
->start
)
5510 int new_end
= new_start
+ bar
->end
- bar
->start
;
5512 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5517 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5519 /* Return information to the user about the current position of the mouse
5520 on the scroll bar. */
5523 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
)
5525 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
5526 Window w
= bar
->x_window
;
5527 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5529 Window dummy_window
;
5531 unsigned int dummy_mask
;
5535 /* Get the mouse's position relative to the scroll bar window, and
5537 if (! XQueryPointer (FRAME_X_DISPLAY (f
), w
,
5539 /* Root, child, root x and root y. */
5540 &dummy_window
, &dummy_window
,
5541 &dummy_coord
, &dummy_coord
,
5543 /* Position relative to scroll bar. */
5546 /* Mouse buttons and modifier keys. */
5552 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, bar
->height
);
5554 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
5556 if (! NILP (bar
->dragging
))
5557 win_y
-= XINT (bar
->dragging
);
5561 if (win_y
> top_range
)
5565 *bar_window
= bar
->window
;
5567 if (! NILP (bar
->dragging
))
5568 *part
= scroll_bar_handle
;
5569 else if (win_y
< bar
->start
)
5570 *part
= scroll_bar_above_handle
;
5571 else if (win_y
< bar
->end
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5572 *part
= scroll_bar_handle
;
5574 *part
= scroll_bar_below_handle
;
5576 XSETINT (*x
, win_y
);
5577 XSETINT (*y
, top_range
);
5580 last_mouse_scroll_bar
= Qnil
;
5583 *time
= last_mouse_movement_time
;
5589 /* The screen has been cleared so we may have changed foreground or
5590 background colors, and the scroll bars may need to be redrawn.
5591 Clear out the scroll bars, and ask for expose events, so we can
5595 x_scroll_bar_clear (FRAME_PTR f
)
5597 #ifndef USE_TOOLKIT_SCROLL_BARS
5600 /* We can have scroll bars even if this is 0,
5601 if we just turned off scroll bar mode.
5602 But in that case we should not clear them. */
5603 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5604 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
5605 bar
= XSCROLL_BAR (bar
)->next
)
5606 XClearArea (FRAME_X_DISPLAY (f
),
5607 XSCROLL_BAR (bar
)->x_window
,
5609 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5613 /* The main X event-reading loop - XTread_socket. */
5615 /* This holds the state XLookupString needs to implement dead keys
5616 and other tricks known as "compose processing". _X Window System_
5617 says that a portable program can't use this, but Stephen Gildea assures
5618 me that letting the compiler initialize it to zeros will work okay.
5620 This must be defined outside of XTread_socket, for the same reasons
5621 given for enter_timestamp, above. */
5623 static XComposeStatus compose_status
;
5625 /* Record the last 100 characters stored
5626 to help debug the loss-of-chars-during-GC problem. */
5628 static int temp_index
;
5629 static short temp_buffer
[100];
5631 #define STORE_KEYSYM_FOR_DEBUG(keysym) \
5632 if (temp_index == sizeof temp_buffer / sizeof (short)) \
5634 temp_buffer[temp_index++] = (keysym)
5636 /* Set this to nonzero to fake an "X I/O error"
5637 on a particular display. */
5639 struct x_display_info
*XTread_socket_fake_io_error
;
5641 /* When we find no input here, we occasionally do a no-op command
5642 to verify that the X server is still running and we can still talk with it.
5643 We try all the open displays, one by one.
5644 This variable is used for cycling thru the displays. */
5646 static struct x_display_info
*next_noop_dpyinfo
;
5648 #define SET_SAVED_BUTTON_EVENT \
5651 if (f->output_data.x->saved_menu_event == 0) \
5652 f->output_data.x->saved_menu_event \
5653 = (XEvent *) xmalloc (sizeof (XEvent)); \
5654 *f->output_data.x->saved_menu_event = event; \
5655 inev.ie.kind = MENU_BAR_ACTIVATE_EVENT; \
5656 XSETFRAME (inev.ie.frame_or_window, f); \
5667 /* Filter events for the current X input method.
5668 DPYINFO is the display this event is for.
5669 EVENT is the X event to filter.
5671 Returns non-zero if the event was filtered, caller shall not process
5673 Returns zero if event is wasn't filtered. */
5677 x_filter_event (struct x_display_info
*dpyinfo
, XEvent
*event
)
5679 /* XFilterEvent returns non-zero if the input method has
5680 consumed the event. We pass the frame's X window to
5681 XFilterEvent because that's the one for which the IC
5684 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
5685 event
->xclient
.window
);
5687 return XFilterEvent (event
, f1
? FRAME_X_WINDOW (f1
) : None
);
5692 static int current_count
;
5693 static int current_finish
;
5694 static struct input_event
*current_hold_quit
;
5696 /* This is the filter function invoked by the GTK event loop.
5697 It is invoked before the XEvent is translated to a GdkEvent,
5698 so we have a chance to act on the event before GTK. */
5699 static GdkFilterReturn
5700 event_handler_gdk (GdkXEvent
*gxev
, GdkEvent
*ev
, gpointer data
)
5702 XEvent
*xev
= (XEvent
*) gxev
;
5705 if (current_count
>= 0)
5707 struct x_display_info
*dpyinfo
;
5709 dpyinfo
= x_display_info_for_display (xev
->xany
.display
);
5712 /* Filter events for the current X input method.
5713 GTK calls XFilterEvent but not for key press and release,
5714 so we do it here. */
5715 if ((xev
->type
== KeyPress
|| xev
->type
== KeyRelease
)
5717 && x_filter_event (dpyinfo
, xev
))
5720 return GDK_FILTER_REMOVE
;
5725 current_finish
= X_EVENT_NORMAL
;
5728 handle_one_xevent (dpyinfo
, xev
, ¤t_finish
,
5732 current_finish
= x_dispatch_event (xev
, xev
->xany
.display
);
5736 if (current_finish
== X_EVENT_GOTO_OUT
|| current_finish
== X_EVENT_DROP
)
5737 return GDK_FILTER_REMOVE
;
5739 return GDK_FILTER_CONTINUE
;
5741 #endif /* USE_GTK */
5744 static void xembed_send_message (struct frame
*f
, Time time
,
5745 enum xembed_message message
,
5746 long detail
, long data1
, long data2
);
5748 /* Handles the XEvent EVENT on display DPYINFO.
5750 *FINISH is X_EVENT_GOTO_OUT if caller should stop reading events.
5751 *FINISH is zero if caller should continue reading events.
5752 *FINISH is X_EVENT_DROP if event should not be passed to the toolkit.
5754 We return the number of characters stored into the buffer. */
5757 handle_one_xevent (struct x_display_info
*dpyinfo
, XEvent
*eventp
, int *finish
, struct input_event
*hold_quit
)
5760 struct input_event ie
;
5761 struct selection_input_event sie
;
5766 struct frame
*f
= NULL
;
5767 struct coding_system coding
;
5768 XEvent event
= *eventp
;
5769 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
5771 *finish
= X_EVENT_NORMAL
;
5773 EVENT_INIT (inev
.ie
);
5774 inev
.ie
.kind
= NO_EVENT
;
5777 if (pending_event_wait
.eventtype
== event
.type
)
5778 pending_event_wait
.eventtype
= 0; /* Indicates we got it. */
5784 if (event
.xclient
.message_type
5785 == dpyinfo
->Xatom_wm_protocols
5786 && event
.xclient
.format
== 32)
5788 if (event
.xclient
.data
.l
[0]
5789 == dpyinfo
->Xatom_wm_take_focus
)
5791 /* Use x_any_window_to_frame because this
5792 could be the shell widget window
5793 if the frame has no title bar. */
5794 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5796 /* Not quite sure this is needed -pd */
5797 if (f
&& FRAME_XIC (f
))
5798 XSetICFocus (FRAME_XIC (f
));
5800 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
5801 instructs the WM to set the input focus automatically for
5802 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
5803 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
5804 it has set the focus. So, XSetInputFocus below is not
5807 The call to XSetInputFocus below has also caused trouble. In
5808 cases where the XSetInputFocus done by the WM and the one
5809 below are temporally close (on a fast machine), the call
5810 below can generate additional FocusIn events which confuse
5813 /* Since we set WM_TAKE_FOCUS, we must call
5814 XSetInputFocus explicitly. But not if f is null,
5815 since that might be an event for a deleted frame. */
5818 Display
*d
= event
.xclient
.display
;
5819 /* Catch and ignore errors, in case window has been
5820 iconified by a window manager such as GWM. */
5822 XSetInputFocus (d
, event
.xclient
.window
,
5823 /* The ICCCM says this is
5824 the only valid choice. */
5826 event
.xclient
.data
.l
[1]);
5827 /* This is needed to detect the error
5828 if there is an error. */
5830 x_uncatch_errors ();
5832 /* Not certain about handling scroll bars here */
5837 if (event
.xclient
.data
.l
[0]
5838 == dpyinfo
->Xatom_wm_save_yourself
)
5840 /* Save state modify the WM_COMMAND property to
5841 something which can reinstate us. This notifies
5842 the session manager, who's looking for such a
5843 PropertyNotify. Can restart processing when
5844 a keyboard or mouse event arrives. */
5845 /* If we have a session manager, don't set this.
5846 KDE will then start two Emacsen, one for the
5847 session manager and one for this. */
5849 if (! x_session_have_connection ())
5852 f
= x_top_window_to_frame (dpyinfo
,
5853 event
.xclient
.window
);
5854 /* This is just so we only give real data once
5855 for a single Emacs process. */
5856 if (f
== SELECTED_FRAME ())
5857 XSetCommand (FRAME_X_DISPLAY (f
),
5858 event
.xclient
.window
,
5859 initial_argv
, initial_argc
);
5861 XSetCommand (FRAME_X_DISPLAY (f
),
5862 event
.xclient
.window
,
5868 if (event
.xclient
.data
.l
[0]
5869 == dpyinfo
->Xatom_wm_delete_window
)
5871 f
= x_any_window_to_frame (dpyinfo
,
5872 event
.xclient
.window
);
5874 goto OTHER
; /* May be a dialog that is to be removed */
5876 inev
.ie
.kind
= DELETE_WINDOW_EVENT
;
5877 XSETFRAME (inev
.ie
.frame_or_window
, f
);
5884 if (event
.xclient
.message_type
5885 == dpyinfo
->Xatom_wm_configure_denied
)
5890 if (event
.xclient
.message_type
5891 == dpyinfo
->Xatom_wm_window_moved
)
5894 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
5896 new_x
= event
.xclient
.data
.s
[0];
5897 new_y
= event
.xclient
.data
.s
[1];
5901 f
->left_pos
= new_x
;
5908 if (event
.xclient
.message_type
5909 == dpyinfo
->Xatom_editres
)
5911 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5913 _XEditResCheckMessages (f
->output_data
.x
->widget
, NULL
,
5917 #endif /* HACK_EDITRES */
5919 if ((event
.xclient
.message_type
5920 == dpyinfo
->Xatom_DONE
)
5921 || (event
.xclient
.message_type
5922 == dpyinfo
->Xatom_PAGE
))
5924 /* Ghostview job completed. Kill it. We could
5925 reply with "Next" if we received "Page", but we
5926 currently never do because we are interested in
5927 images, only, which should have 1 page. */
5928 Pixmap pixmap
= (Pixmap
) event
.xclient
.data
.l
[1];
5929 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
5932 x_kill_gs_process (pixmap
, f
);
5933 expose_frame (f
, 0, 0, 0, 0);
5937 #ifdef USE_TOOLKIT_SCROLL_BARS
5938 /* Scroll bar callbacks send a ClientMessage from which
5939 we construct an input_event. */
5940 if (event
.xclient
.message_type
5941 == dpyinfo
->Xatom_Scrollbar
)
5943 x_scroll_bar_to_input_event (&event
, &inev
.ie
);
5944 *finish
= X_EVENT_GOTO_OUT
;
5947 #endif /* USE_TOOLKIT_SCROLL_BARS */
5949 /* XEmbed messages from the embedder (if any). */
5950 if (event
.xclient
.message_type
5951 == dpyinfo
->Xatom_XEMBED
)
5953 enum xembed_message msg
= event
.xclient
.data
.l
[1];
5954 if (msg
== XEMBED_FOCUS_IN
|| msg
== XEMBED_FOCUS_OUT
)
5955 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
5957 *finish
= X_EVENT_GOTO_OUT
;
5961 xft_settings_event (dpyinfo
, &event
);
5963 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5966 if (x_handle_dnd_message (f
, &event
.xclient
, dpyinfo
, &inev
.ie
))
5967 *finish
= X_EVENT_DROP
;
5971 case SelectionNotify
:
5972 last_user_time
= event
.xselection
.time
;
5973 #ifdef USE_X_TOOLKIT
5974 if (! x_window_to_frame (dpyinfo
, event
.xselection
.requestor
))
5976 #endif /* not USE_X_TOOLKIT */
5977 x_handle_selection_notify (&event
.xselection
);
5980 case SelectionClear
: /* Someone has grabbed ownership. */
5981 last_user_time
= event
.xselectionclear
.time
;
5982 #ifdef USE_X_TOOLKIT
5983 if (! x_window_to_frame (dpyinfo
, event
.xselectionclear
.window
))
5985 #endif /* USE_X_TOOLKIT */
5987 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
5989 inev
.ie
.kind
= SELECTION_CLEAR_EVENT
;
5990 SELECTION_EVENT_DISPLAY (&inev
.sie
) = eventp
->display
;
5991 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
5992 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
5993 inev
.ie
.frame_or_window
= Qnil
;
5997 case SelectionRequest
: /* Someone wants our selection. */
5998 last_user_time
= event
.xselectionrequest
.time
;
5999 #ifdef USE_X_TOOLKIT
6000 if (!x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
))
6002 #endif /* USE_X_TOOLKIT */
6004 XSelectionRequestEvent
*eventp
6005 = (XSelectionRequestEvent
*) &event
;
6007 inev
.ie
.kind
= SELECTION_REQUEST_EVENT
;
6008 SELECTION_EVENT_DISPLAY (&inev
.sie
) = eventp
->display
;
6009 SELECTION_EVENT_REQUESTOR (&inev
.sie
) = eventp
->requestor
;
6010 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
6011 SELECTION_EVENT_TARGET (&inev
.sie
) = eventp
->target
;
6012 SELECTION_EVENT_PROPERTY (&inev
.sie
) = eventp
->property
;
6013 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
6014 inev
.ie
.frame_or_window
= Qnil
;
6018 case PropertyNotify
:
6019 last_user_time
= event
.xproperty
.time
;
6020 f
= x_top_window_to_frame (dpyinfo
, event
.xproperty
.window
);
6021 if (f
&& event
.xproperty
.atom
== dpyinfo
->Xatom_net_wm_state
)
6022 x_handle_net_wm_state (f
, &event
.xproperty
);
6024 x_handle_property_notify (&event
.xproperty
);
6025 xft_settings_event (dpyinfo
, &event
);
6028 case ReparentNotify
:
6029 f
= x_top_window_to_frame (dpyinfo
, event
.xreparent
.window
);
6033 f
->output_data
.x
->parent_desc
= event
.xreparent
.parent
;
6034 x_real_positions (f
, &x
, &y
);
6038 /* Perhaps reparented due to a WM restart. Reset this. */
6039 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_UNKNOWN
;
6040 FRAME_X_DISPLAY_INFO (f
)->net_supported_window
= 0;
6045 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
6049 /* This seems to be needed for GTK 2.6. */
6050 x_clear_area (event
.xexpose
.display
,
6051 event
.xexpose
.window
,
6052 event
.xexpose
.x
, event
.xexpose
.y
,
6053 event
.xexpose
.width
, event
.xexpose
.height
,
6056 if (f
->async_visible
== 0)
6058 f
->async_visible
= 1;
6059 f
->async_iconified
= 0;
6060 f
->output_data
.x
->has_been_visible
= 1;
6061 SET_FRAME_GARBAGED (f
);
6065 event
.xexpose
.x
, event
.xexpose
.y
,
6066 event
.xexpose
.width
, event
.xexpose
.height
);
6070 #ifndef USE_TOOLKIT_SCROLL_BARS
6071 struct scroll_bar
*bar
;
6073 #if defined USE_LUCID
6074 /* Submenus of the Lucid menu bar aren't widgets
6075 themselves, so there's no way to dispatch events
6076 to them. Recognize this case separately. */
6079 = x_window_to_menu_bar (event
.xexpose
.window
);
6081 xlwmenu_redisplay (widget
);
6083 #endif /* USE_LUCID */
6085 #ifdef USE_TOOLKIT_SCROLL_BARS
6086 /* Dispatch event to the widget. */
6088 #else /* not USE_TOOLKIT_SCROLL_BARS */
6089 bar
= x_window_to_scroll_bar (event
.xexpose
.display
,
6090 event
.xexpose
.window
);
6093 x_scroll_bar_expose (bar
, &event
);
6094 #ifdef USE_X_TOOLKIT
6097 #endif /* USE_X_TOOLKIT */
6098 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6102 case GraphicsExpose
: /* This occurs when an XCopyArea's
6103 source area was obscured or not
6105 f
= x_window_to_frame (dpyinfo
, event
.xgraphicsexpose
.drawable
);
6109 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
6110 event
.xgraphicsexpose
.width
,
6111 event
.xgraphicsexpose
.height
);
6113 #ifdef USE_X_TOOLKIT
6116 #endif /* USE_X_TOOLKIT */
6119 case NoExpose
: /* This occurs when an XCopyArea's
6120 source area was completely
6125 /* Redo the mouse-highlight after the tooltip has gone. */
6126 if (event
.xmap
.window
== tip_window
)
6129 redo_mouse_highlight ();
6132 f
= x_top_window_to_frame (dpyinfo
, event
.xunmap
.window
);
6133 if (f
) /* F may no longer exist if
6134 the frame was deleted. */
6136 /* While a frame is unmapped, display generation is
6137 disabled; you don't want to spend time updating a
6138 display that won't ever be seen. */
6139 f
->async_visible
= 0;
6140 /* We can't distinguish, from the event, whether the window
6141 has become iconified or invisible. So assume, if it
6142 was previously visible, than now it is iconified.
6143 But x_make_frame_invisible clears both
6144 the visible flag and the iconified flag;
6145 and that way, we know the window is not iconified now. */
6146 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
6148 f
->async_iconified
= 1;
6150 inev
.ie
.kind
= ICONIFY_EVENT
;
6151 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6157 if (event
.xmap
.window
== tip_window
)
6158 /* The tooltip has been drawn already. Avoid
6159 the SET_FRAME_GARBAGED below. */
6162 /* We use x_top_window_to_frame because map events can
6163 come for sub-windows and they don't mean that the
6164 frame is visible. */
6165 f
= x_top_window_to_frame (dpyinfo
, event
.xmap
.window
);
6168 /* wait_reading_process_output will notice this and update
6169 the frame's display structures.
6170 If we where iconified, we should not set garbaged,
6171 because that stops redrawing on Expose events. This looks
6172 bad if we are called from a recursive event loop
6173 (x_dispatch_event), for example when a dialog is up. */
6174 if (! f
->async_iconified
)
6175 SET_FRAME_GARBAGED (f
);
6177 /* Check if fullscreen was specified before we where mapped the
6178 first time, i.e. from the command line. */
6179 if (!f
->output_data
.x
->has_been_visible
)
6180 x_check_fullscreen (f
);
6182 f
->async_visible
= 1;
6183 f
->async_iconified
= 0;
6184 f
->output_data
.x
->has_been_visible
= 1;
6188 inev
.ie
.kind
= DEICONIFY_EVENT
;
6189 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6191 else if (! NILP (Vframe_list
)
6192 && ! NILP (XCDR (Vframe_list
)))
6193 /* Force a redisplay sooner or later
6194 to update the frame titles
6195 in case this is the second frame. */
6196 record_asynch_buffer_change ();
6199 xg_frame_resized (f
, -1, -1);
6206 last_user_time
= event
.xkey
.time
;
6207 ignore_next_mouse_click_timeout
= 0;
6209 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6210 /* Dispatch KeyPress events when in menu. */
6211 if (popup_activated ())
6215 f
= x_any_window_to_frame (dpyinfo
, event
.xkey
.window
);
6217 /* If mouse-highlight is an integer, input clears out
6218 mouse highlighting. */
6219 if (!hlinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
6221 || !EQ (f
->tool_bar_window
, hlinfo
->mouse_face_window
)))
6223 clear_mouse_face (hlinfo
);
6224 hlinfo
->mouse_face_hidden
= 1;
6227 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
6230 /* Scroll bars consume key events, but we want
6231 the keys to go to the scroll bar's frame. */
6232 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
6234 if (widget
&& XmIsScrollBar (widget
))
6236 widget
= XtParent (widget
);
6237 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
6240 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
6244 KeySym keysym
, orig_keysym
;
6245 /* al%imercury@uunet.uu.net says that making this 81
6246 instead of 80 fixed a bug whereby meta chars made
6249 It seems that some version of XmbLookupString has
6250 a bug of not returning XBufferOverflow in
6251 status_return even if the input is too long to
6252 fit in 81 bytes. So, we must prepare sufficient
6253 bytes for copy_buffer. 513 bytes (256 chars for
6254 two-byte character set) seems to be a fairly good
6255 approximation. -- 2000.8.10 handa@etl.go.jp */
6256 unsigned char copy_buffer
[513];
6257 unsigned char *copy_bufptr
= copy_buffer
;
6258 int copy_bufsiz
= sizeof (copy_buffer
);
6260 Lisp_Object coding_system
= Qlatin_1
;
6264 /* Don't pass keys to GTK. A Tab will shift focus to the
6265 tool bar in GTK 2.4. Keys will still go to menus and
6266 dialogs because in that case popup_activated is TRUE
6268 *finish
= X_EVENT_DROP
;
6272 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f
),
6273 extra_keyboard_modifiers
);
6274 modifiers
= event
.xkey
.state
;
6276 /* This will have to go some day... */
6278 /* make_lispy_event turns chars into control chars.
6279 Don't do it here because XLookupString is too eager. */
6280 event
.xkey
.state
&= ~ControlMask
;
6281 event
.xkey
.state
&= ~(dpyinfo
->meta_mod_mask
6282 | dpyinfo
->super_mod_mask
6283 | dpyinfo
->hyper_mod_mask
6284 | dpyinfo
->alt_mod_mask
);
6286 /* In case Meta is ComposeCharacter,
6287 clear its status. According to Markus Ehrnsperger
6288 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
6289 this enables ComposeCharacter to work whether or
6290 not it is combined with Meta. */
6291 if (modifiers
& dpyinfo
->meta_mod_mask
)
6292 memset (&compose_status
, 0, sizeof (compose_status
));
6297 Status status_return
;
6299 coding_system
= Vlocale_coding_system
;
6300 nbytes
= XmbLookupString (FRAME_XIC (f
),
6301 &event
.xkey
, (char *) copy_bufptr
,
6302 copy_bufsiz
, &keysym
,
6304 if (status_return
== XBufferOverflow
)
6306 copy_bufsiz
= nbytes
+ 1;
6307 copy_bufptr
= (unsigned char *) alloca (copy_bufsiz
);
6308 nbytes
= XmbLookupString (FRAME_XIC (f
),
6309 &event
.xkey
, (char *) copy_bufptr
,
6310 copy_bufsiz
, &keysym
,
6313 /* Xutf8LookupString is a new but already deprecated interface. -stef */
6314 if (status_return
== XLookupNone
)
6316 else if (status_return
== XLookupChars
)
6321 else if (status_return
!= XLookupKeySym
6322 && status_return
!= XLookupBoth
)
6326 nbytes
= XLookupString (&event
.xkey
, (char *) copy_bufptr
,
6327 copy_bufsiz
, &keysym
,
6330 nbytes
= XLookupString (&event
.xkey
, (char *) copy_bufptr
,
6331 copy_bufsiz
, &keysym
,
6335 /* If not using XIM/XIC, and a compose sequence is in progress,
6336 we break here. Otherwise, chars_matched is always 0. */
6337 if (compose_status
.chars_matched
> 0 && nbytes
== 0)
6340 memset (&compose_status
, 0, sizeof (compose_status
));
6341 orig_keysym
= keysym
;
6343 /* Common for all keysym input events. */
6344 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6346 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), modifiers
);
6347 inev
.ie
.timestamp
= event
.xkey
.time
;
6349 /* First deal with keysyms which have defined
6350 translations to characters. */
6351 if (keysym
>= 32 && keysym
< 128)
6352 /* Avoid explicitly decoding each ASCII character. */
6354 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
6355 inev
.ie
.code
= keysym
;
6359 /* Keysyms directly mapped to Unicode characters. */
6360 if (keysym
>= 0x01000000 && keysym
<= 0x0110FFFF)
6362 if (keysym
< 0x01000080)
6363 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
6365 inev
.ie
.kind
= MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
6366 inev
.ie
.code
= keysym
& 0xFFFFFF;
6370 /* Now non-ASCII. */
6371 if (HASH_TABLE_P (Vx_keysym_table
)
6372 && (NATNUMP (c
= Fgethash (make_number (keysym
),
6376 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (XFASTINT (c
))
6377 ? ASCII_KEYSTROKE_EVENT
6378 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6379 inev
.ie
.code
= XFASTINT (c
);
6383 /* Random non-modifier sorts of keysyms. */
6384 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
6385 || keysym
== XK_Delete
6386 #ifdef XK_ISO_Left_Tab
6387 || (keysym
>= XK_ISO_Left_Tab
6388 && keysym
<= XK_ISO_Enter
)
6390 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
6391 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
6393 /* This recognizes the "extended function
6394 keys". It seems there's no cleaner way.
6395 Test IsModifierKey to avoid handling
6396 mode_switch incorrectly. */
6397 || ((unsigned) (keysym
) >= XK_Select
6398 && (unsigned)(keysym
) < XK_KP_Space
)
6400 #ifdef XK_dead_circumflex
6401 || orig_keysym
== XK_dead_circumflex
6403 #ifdef XK_dead_grave
6404 || orig_keysym
== XK_dead_grave
6406 #ifdef XK_dead_tilde
6407 || orig_keysym
== XK_dead_tilde
6409 #ifdef XK_dead_diaeresis
6410 || orig_keysym
== XK_dead_diaeresis
6412 #ifdef XK_dead_macron
6413 || orig_keysym
== XK_dead_macron
6415 #ifdef XK_dead_degree
6416 || orig_keysym
== XK_dead_degree
6418 #ifdef XK_dead_acute
6419 || orig_keysym
== XK_dead_acute
6421 #ifdef XK_dead_cedilla
6422 || orig_keysym
== XK_dead_cedilla
6424 #ifdef XK_dead_breve
6425 || orig_keysym
== XK_dead_breve
6427 #ifdef XK_dead_ogonek
6428 || orig_keysym
== XK_dead_ogonek
6430 #ifdef XK_dead_caron
6431 || orig_keysym
== XK_dead_caron
6433 #ifdef XK_dead_doubleacute
6434 || orig_keysym
== XK_dead_doubleacute
6436 #ifdef XK_dead_abovedot
6437 || orig_keysym
== XK_dead_abovedot
6439 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
6440 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
6441 /* Any "vendor-specific" key is ok. */
6442 || (orig_keysym
& (1 << 28))
6443 || (keysym
!= NoSymbol
&& nbytes
== 0))
6444 && ! (IsModifierKey (orig_keysym
)
6445 /* The symbols from XK_ISO_Lock
6446 to XK_ISO_Last_Group_Lock
6447 don't have real modifiers but
6448 should be treated similarly to
6449 Mode_switch by Emacs. */
6450 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
6451 || ((unsigned)(orig_keysym
)
6453 && (unsigned)(orig_keysym
)
6454 <= XK_ISO_Last_Group_Lock
)
6458 STORE_KEYSYM_FOR_DEBUG (keysym
);
6459 /* make_lispy_event will convert this to a symbolic
6461 inev
.ie
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
6462 inev
.ie
.code
= keysym
;
6466 { /* Raw bytes, not keysym. */
6471 for (i
= 0, nchars
= 0; i
< nbytes
; i
++)
6473 if (ASCII_BYTE_P (copy_bufptr
[i
]))
6475 STORE_KEYSYM_FOR_DEBUG (copy_bufptr
[i
]);
6478 if (nchars
< nbytes
)
6480 /* Decode the input data. */
6483 /* The input should be decoded with `coding_system'
6484 which depends on which X*LookupString function
6485 we used just above and the locale. */
6486 setup_coding_system (coding_system
, &coding
);
6487 coding
.src_multibyte
= 0;
6488 coding
.dst_multibyte
= 1;
6489 /* The input is converted to events, thus we can't
6490 handle composition. Anyway, there's no XIM that
6491 gives us composition information. */
6492 coding
.common_flags
&= ~CODING_ANNOTATION_MASK
;
6494 require
= MAX_MULTIBYTE_LENGTH
* nbytes
;
6495 coding
.destination
= alloca (require
);
6496 coding
.dst_bytes
= require
;
6497 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
6498 decode_coding_c_string (&coding
, copy_bufptr
, nbytes
, Qnil
);
6499 nbytes
= coding
.produced
;
6500 nchars
= coding
.produced_char
;
6501 copy_bufptr
= coding
.destination
;
6504 /* Convert the input data to a sequence of
6505 character events. */
6506 for (i
= 0; i
< nbytes
; i
+= len
)
6508 if (nchars
== nbytes
)
6509 c
= copy_bufptr
[i
], len
= 1;
6511 c
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
, len
);
6512 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (c
)
6513 ? ASCII_KEYSTROKE_EVENT
6514 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6516 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
6521 inev
.ie
.kind
= NO_EVENT
; /* Already stored above. */
6523 if (keysym
== NoSymbol
)
6529 /* Don't dispatch this event since XtDispatchEvent calls
6530 XFilterEvent, and two calls in a row may freeze the
6538 last_user_time
= event
.xkey
.time
;
6540 /* Don't dispatch this event since XtDispatchEvent calls
6541 XFilterEvent, and two calls in a row may freeze the
6549 last_user_time
= event
.xcrossing
.time
;
6550 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6552 f
= x_any_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
6554 if (f
&& x_mouse_click_focus_ignore_position
)
6555 ignore_next_mouse_click_timeout
= event
.xmotion
.time
+ 200;
6557 /* EnterNotify counts as mouse movement,
6558 so update things that depend on mouse position. */
6559 if (f
&& !f
->output_data
.x
->hourglass_p
)
6560 note_mouse_movement (f
, &event
.xmotion
);
6562 /* We may get an EnterNotify on the buttons in the toolbar. In that
6563 case we moved out of any highlighted area and need to note this. */
6564 if (!f
&& last_mouse_glyph_frame
)
6565 note_mouse_movement (last_mouse_glyph_frame
, &event
.xmotion
);
6570 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6574 last_user_time
= event
.xcrossing
.time
;
6575 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6577 f
= x_top_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
6580 if (f
== hlinfo
->mouse_face_mouse_frame
)
6582 /* If we move outside the frame, then we're
6583 certainly no longer on any text in the frame. */
6584 clear_mouse_face (hlinfo
);
6585 hlinfo
->mouse_face_mouse_frame
= 0;
6588 /* Generate a nil HELP_EVENT to cancel a help-echo.
6589 Do it only if there's something to cancel.
6590 Otherwise, the startup message is cleared when
6591 the mouse leaves the frame. */
6592 if (any_help_event_p
)
6596 /* See comment in EnterNotify above */
6597 else if (last_mouse_glyph_frame
)
6598 note_mouse_movement (last_mouse_glyph_frame
, &event
.xmotion
);
6603 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6608 last_user_time
= event
.xmotion
.time
;
6609 previous_help_echo_string
= help_echo_string
;
6610 help_echo_string
= Qnil
;
6612 if (dpyinfo
->grabbed
&& last_mouse_frame
6613 && FRAME_LIVE_P (last_mouse_frame
))
6614 f
= last_mouse_frame
;
6616 f
= x_window_to_frame (dpyinfo
, event
.xmotion
.window
);
6618 if (hlinfo
->mouse_face_hidden
)
6620 hlinfo
->mouse_face_hidden
= 0;
6621 clear_mouse_face (hlinfo
);
6625 if (f
&& xg_event_is_for_scrollbar (f
, &event
))
6631 /* Generate SELECT_WINDOW_EVENTs when needed.
6632 Don't let popup menus influence things (bug#1261). */
6633 if (!NILP (Vmouse_autoselect_window
) && !popup_activated ())
6637 window
= window_from_coordinates (f
,
6638 event
.xmotion
.x
, event
.xmotion
.y
,
6641 /* Window will be selected only when it is not selected now and
6642 last mouse movement event was not in it. Minibuffer window
6643 will be selected only when it is active. */
6644 if (WINDOWP (window
)
6645 && !EQ (window
, last_window
)
6646 && !EQ (window
, selected_window
)
6647 /* For click-to-focus window managers
6648 create event iff we don't leave the
6650 && (focus_follows_mouse
6651 || (EQ (XWINDOW (window
)->frame
,
6652 XWINDOW (selected_window
)->frame
))))
6654 inev
.ie
.kind
= SELECT_WINDOW_EVENT
;
6655 inev
.ie
.frame_or_window
= window
;
6660 if (!note_mouse_movement (f
, &event
.xmotion
))
6661 help_echo_string
= previous_help_echo_string
;
6665 #ifndef USE_TOOLKIT_SCROLL_BARS
6666 struct scroll_bar
*bar
6667 = x_window_to_scroll_bar (event
.xmotion
.display
,
6668 event
.xmotion
.window
);
6671 x_scroll_bar_note_movement (bar
, &event
);
6672 #endif /* USE_TOOLKIT_SCROLL_BARS */
6674 /* If we move outside the frame, then we're
6675 certainly no longer on any text in the frame. */
6676 clear_mouse_face (hlinfo
);
6679 /* If the contents of the global variable help_echo_string
6680 has changed, generate a HELP_EVENT. */
6681 if (!NILP (help_echo_string
)
6682 || !NILP (previous_help_echo_string
))
6687 case ConfigureNotify
:
6688 f
= x_top_window_to_frame (dpyinfo
, event
.xconfigure
.window
);
6691 && (f
= x_any_window_to_frame (dpyinfo
, event
.xconfigure
.window
))
6692 && event
.xconfigure
.window
== FRAME_X_WINDOW (f
))
6694 xg_frame_resized (f
, event
.xconfigure
.width
,
6695 event
.xconfigure
.height
);
6701 #ifndef USE_X_TOOLKIT
6703 int rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, event
.xconfigure
.height
);
6704 int columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, event
.xconfigure
.width
);
6706 /* In the toolkit version, change_frame_size
6707 is called by the code that handles resizing
6708 of the EmacsFrame widget. */
6710 /* Even if the number of character rows and columns has
6711 not changed, the font size may have changed, so we need
6712 to check the pixel dimensions as well. */
6713 if (columns
!= FRAME_COLS (f
)
6714 || rows
!= FRAME_LINES (f
)
6715 || event
.xconfigure
.width
!= FRAME_PIXEL_WIDTH (f
)
6716 || event
.xconfigure
.height
!= FRAME_PIXEL_HEIGHT (f
))
6718 change_frame_size (f
, rows
, columns
, 0, 1, 0);
6719 SET_FRAME_GARBAGED (f
);
6720 cancel_mouse_face (f
);
6723 FRAME_PIXEL_WIDTH (f
) = event
.xconfigure
.width
;
6724 FRAME_PIXEL_HEIGHT (f
) = event
.xconfigure
.height
;
6725 #endif /* not USE_GTK */
6729 /* GTK creates windows but doesn't map them.
6730 Only get real positions when mapped. */
6731 if (FRAME_GTK_OUTER_WIDGET (f
)
6732 && gtk_widget_get_mapped (FRAME_GTK_OUTER_WIDGET (f
)))
6735 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
6739 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
6740 xic_set_statusarea (f
);
6749 /* If we decide we want to generate an event to be seen
6750 by the rest of Emacs, we put it here. */
6753 memset (&compose_status
, 0, sizeof (compose_status
));
6754 last_mouse_glyph_frame
= 0;
6755 last_user_time
= event
.xbutton
.time
;
6757 if (dpyinfo
->grabbed
6759 && FRAME_LIVE_P (last_mouse_frame
))
6760 f
= last_mouse_frame
;
6762 f
= x_window_to_frame (dpyinfo
, event
.xbutton
.window
);
6765 if (f
&& xg_event_is_for_scrollbar (f
, &event
))
6770 /* Is this in the tool-bar? */
6771 if (WINDOWP (f
->tool_bar_window
)
6772 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
6775 int x
= event
.xbutton
.x
;
6776 int y
= event
.xbutton
.y
;
6778 window
= window_from_coordinates (f
, x
, y
, 0, 1);
6779 tool_bar_p
= EQ (window
, f
->tool_bar_window
);
6781 if (tool_bar_p
&& event
.xbutton
.button
< 4)
6783 handle_tool_bar_click (f
, x
, y
,
6784 event
.xbutton
.type
== ButtonPress
,
6785 x_x_to_emacs_modifiers (dpyinfo
,
6786 event
.xbutton
.state
));
6791 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6792 if (! popup_activated ())
6795 if (ignore_next_mouse_click_timeout
)
6797 if (event
.type
== ButtonPress
6798 && (int)(event
.xbutton
.time
- ignore_next_mouse_click_timeout
) > 0)
6800 ignore_next_mouse_click_timeout
= 0;
6801 construct_mouse_click (&inev
.ie
, &event
.xbutton
, f
);
6803 if (event
.type
== ButtonRelease
)
6804 ignore_next_mouse_click_timeout
= 0;
6807 construct_mouse_click (&inev
.ie
, &event
.xbutton
, f
);
6809 if (FRAME_X_EMBEDDED_P (f
))
6810 xembed_send_message (f
, event
.xbutton
.time
,
6811 XEMBED_REQUEST_FOCUS
, 0, 0, 0);
6815 struct scroll_bar
*bar
6816 = x_window_to_scroll_bar (event
.xbutton
.display
,
6817 event
.xbutton
.window
);
6819 #ifdef USE_TOOLKIT_SCROLL_BARS
6820 /* Make the "Ctrl-Mouse-2 splits window" work for toolkit
6822 if (bar
&& event
.xbutton
.state
& ControlMask
)
6824 x_scroll_bar_handle_click (bar
, &event
, &inev
.ie
);
6825 *finish
= X_EVENT_DROP
;
6827 #else /* not USE_TOOLKIT_SCROLL_BARS */
6829 x_scroll_bar_handle_click (bar
, &event
, &inev
.ie
);
6830 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6833 if (event
.type
== ButtonPress
)
6835 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
6836 last_mouse_frame
= f
;
6839 last_tool_bar_item
= -1;
6842 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
6844 /* Ignore any mouse motion that happened before this event;
6845 any subsequent mouse-movement Emacs events should reflect
6846 only motion after the ButtonPress/Release. */
6850 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6851 f
= x_menubar_window_to_frame (dpyinfo
, &event
);
6852 /* For a down-event in the menu bar,
6853 don't pass it to Xt right now.
6854 Instead, save it away
6855 and we will pass it to Xt from kbd_buffer_get_event.
6856 That way, we can run some Lisp code first. */
6857 if (! popup_activated ()
6859 /* Gtk+ menus only react to the first three buttons. */
6860 && event
.xbutton
.button
< 3
6862 && f
&& event
.type
== ButtonPress
6863 /* Verify the event is really within the menu bar
6864 and not just sent to it due to grabbing. */
6865 && event
.xbutton
.x
>= 0
6866 && event
.xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
6867 && event
.xbutton
.y
>= 0
6868 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
6869 && event
.xbutton
.same_screen
)
6871 SET_SAVED_BUTTON_EVENT
;
6872 XSETFRAME (last_mouse_press_frame
, f
);
6873 *finish
= X_EVENT_DROP
;
6875 else if (event
.type
== ButtonPress
)
6877 last_mouse_press_frame
= Qnil
;
6882 #endif /* USE_X_TOOLKIT || USE_GTK */
6886 case CirculateNotify
:
6889 case CirculateRequest
:
6892 case VisibilityNotify
:
6896 /* Someone has changed the keyboard mapping - update the
6898 switch (event
.xmapping
.request
)
6900 case MappingModifier
:
6901 x_find_modifier_meanings (dpyinfo
);
6902 /* This is meant to fall through. */
6903 case MappingKeyboard
:
6904 XRefreshKeyboardMapping (&event
.xmapping
);
6909 xft_settings_event (dpyinfo
, &event
);
6914 #ifdef USE_X_TOOLKIT
6916 if (*finish
!= X_EVENT_DROP
)
6917 XtDispatchEvent (&event
);
6919 #endif /* USE_X_TOOLKIT */
6924 if (inev
.ie
.kind
!= NO_EVENT
)
6926 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
6931 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
6936 XSETFRAME (frame
, f
);
6942 any_help_event_p
= 1;
6943 gen_help_event (help_echo_string
, frame
, help_echo_window
,
6944 help_echo_object
, help_echo_pos
);
6948 help_echo_string
= Qnil
;
6949 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
6959 /* Handles the XEvent EVENT on display DISPLAY.
6960 This is used for event loops outside the normal event handling,
6961 i.e. looping while a popup menu or a dialog is posted.
6963 Returns the value handle_one_xevent sets in the finish argument. */
6965 x_dispatch_event (XEvent
*event
, Display
*display
)
6967 struct x_display_info
*dpyinfo
;
6968 int finish
= X_EVENT_NORMAL
;
6970 dpyinfo
= x_display_info_for_display (display
);
6973 handle_one_xevent (dpyinfo
, event
, &finish
, 0);
6979 /* Read events coming from the X server.
6980 This routine is called by the SIGIO handler.
6981 We return as soon as there are no more events to be read.
6983 We return the number of characters stored into the buffer,
6984 thus pretending to be `read' (except the characters we store
6985 in the keyboard buffer can be multibyte, so are not necessarily
6988 EXPECTED is nonzero if the caller knows input is available. */
6991 XTread_socket (struct terminal
*terminal
, int expected
, struct input_event
*hold_quit
)
6995 int event_found
= 0;
6997 if (interrupt_input_blocked
)
6999 interrupt_input_pending
= 1;
7001 pending_signals
= 1;
7006 interrupt_input_pending
= 0;
7008 pending_signals
= pending_atimers
;
7012 /* So people can tell when we have read the available input. */
7013 input_signal_count
++;
7017 /* For debugging, this gives a way to fake an I/O error. */
7018 if (terminal
->display_info
.x
== XTread_socket_fake_io_error
)
7020 XTread_socket_fake_io_error
= 0;
7021 x_io_error_quitter (terminal
->display_info
.x
->display
);
7025 while (XPending (terminal
->display_info
.x
->display
))
7029 XNextEvent (terminal
->display_info
.x
->display
, &event
);
7032 /* Filter events for the current X input method. */
7033 if (x_filter_event (terminal
->display_info
.x
, &event
))
7038 count
+= handle_one_xevent (terminal
->display_info
.x
,
7039 &event
, &finish
, hold_quit
);
7041 if (finish
== X_EVENT_GOTO_OUT
)
7047 /* For GTK we must use the GTK event loop. But XEvents gets passed
7048 to our filter function above, and then to the big event switch.
7049 We use a bunch of globals to communicate with our filter function,
7050 that is kind of ugly, but it works.
7052 There is no way to do one display at the time, GTK just does events
7053 from all displays. */
7055 while (gtk_events_pending ())
7057 current_count
= count
;
7058 current_hold_quit
= hold_quit
;
7060 gtk_main_iteration ();
7062 count
= current_count
;
7064 current_hold_quit
= 0;
7066 if (current_finish
== X_EVENT_GOTO_OUT
)
7069 #endif /* USE_GTK */
7073 /* On some systems, an X bug causes Emacs to get no more events
7074 when the window is destroyed. Detect that. (1994.) */
7077 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
7078 One XNOOP in 100 loops will make Emacs terminate.
7079 B. Bretthauer, 1994 */
7081 if (x_noop_count
>= 100)
7085 if (next_noop_dpyinfo
== 0)
7086 next_noop_dpyinfo
= x_display_list
;
7088 XNoOp (next_noop_dpyinfo
->display
);
7090 /* Each time we get here, cycle through the displays now open. */
7091 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
7095 /* If the focus was just given to an auto-raising frame,
7097 /* ??? This ought to be able to handle more than one such frame. */
7098 if (pending_autoraise_frame
)
7100 x_raise_frame (pending_autoraise_frame
);
7101 pending_autoraise_frame
= 0;
7113 /***********************************************************************
7115 ***********************************************************************/
7117 /* Set clipping for output in glyph row ROW. W is the window in which
7118 we operate. GC is the graphics context to set clipping in.
7120 ROW may be a text row or, e.g., a mode line. Text rows must be
7121 clipped to the interior of the window dedicated to text display,
7122 mode lines must be clipped to the whole window. */
7125 x_clip_to_row (struct window
*w
, struct glyph_row
*row
, int area
, GC gc
)
7127 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7128 XRectangle clip_rect
;
7129 int window_x
, window_y
, window_width
;
7131 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
7133 clip_rect
.x
= window_x
;
7134 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, row
->y
));
7135 clip_rect
.y
= max (clip_rect
.y
, window_y
);
7136 clip_rect
.width
= window_width
;
7137 clip_rect
.height
= row
->visible_height
;
7139 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
7143 /* Draw a hollow box cursor on window W in glyph row ROW. */
7146 x_draw_hollow_cursor (struct window
*w
, struct glyph_row
*row
)
7148 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7149 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7150 Display
*dpy
= FRAME_X_DISPLAY (f
);
7153 struct glyph
*cursor_glyph
;
7156 /* Get the glyph the cursor is on. If we can't tell because
7157 the current matrix is invalid or such, give up. */
7158 cursor_glyph
= get_phys_cursor_glyph (w
);
7159 if (cursor_glyph
== NULL
)
7162 /* Compute frame-relative coordinates for phys cursor. */
7163 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &x
, &y
, &h
);
7164 wd
= w
->phys_cursor_width
;
7166 /* The foreground of cursor_gc is typically the same as the normal
7167 background color, which can cause the cursor box to be invisible. */
7168 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7169 if (dpyinfo
->scratch_cursor_gc
)
7170 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
7172 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
7173 GCForeground
, &xgcv
);
7174 gc
= dpyinfo
->scratch_cursor_gc
;
7176 /* Set clipping, draw the rectangle, and reset clipping again. */
7177 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7178 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
- 1);
7179 XSetClipMask (dpy
, gc
, None
);
7183 /* Draw a bar cursor on window W in glyph row ROW.
7185 Implementation note: One would like to draw a bar cursor with an
7186 angle equal to the one given by the font property XA_ITALIC_ANGLE.
7187 Unfortunately, I didn't find a font yet that has this property set.
7191 x_draw_bar_cursor (struct window
*w
, struct glyph_row
*row
, int width
, enum text_cursor_kinds kind
)
7193 struct frame
*f
= XFRAME (w
->frame
);
7194 struct glyph
*cursor_glyph
;
7196 /* If cursor is out of bounds, don't draw garbage. This can happen
7197 in mini-buffer windows when switching between echo area glyphs
7199 cursor_glyph
= get_phys_cursor_glyph (w
);
7200 if (cursor_glyph
== NULL
)
7203 /* If on an image, draw like a normal cursor. That's usually better
7204 visible than drawing a bar, esp. if the image is large so that
7205 the bar might not be in the window. */
7206 if (cursor_glyph
->type
== IMAGE_GLYPH
)
7208 struct glyph_row
*row
;
7209 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
7210 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
7214 Display
*dpy
= FRAME_X_DISPLAY (f
);
7215 Window window
= FRAME_X_WINDOW (f
);
7216 GC gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
7217 unsigned long mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
7218 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
7221 /* If the glyph's background equals the color we normally draw
7222 the bars cursor in, the bar cursor in its normal color is
7223 invisible. Use the glyph's foreground color instead in this
7224 case, on the assumption that the glyph's colors are chosen so
7225 that the glyph is legible. */
7226 if (face
->background
== f
->output_data
.x
->cursor_pixel
)
7227 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
7229 xgcv
.background
= xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7230 xgcv
.graphics_exposures
= 0;
7233 XChangeGC (dpy
, gc
, mask
, &xgcv
);
7236 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
7237 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
7240 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7242 if (kind
== BAR_CURSOR
)
7244 int x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
7247 width
= FRAME_CURSOR_WIDTH (f
);
7248 width
= min (cursor_glyph
->pixel_width
, width
);
7250 w
->phys_cursor_width
= width
;
7252 /* If the character under cursor is R2L, draw the bar cursor
7253 on the right of its glyph, rather than on the left. */
7254 if ((cursor_glyph
->resolved_level
& 1) != 0)
7255 x
+= cursor_glyph
->pixel_width
- width
;
7257 XFillRectangle (dpy
, window
, gc
, x
,
7258 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
7259 width
, row
->height
);
7263 int dummy_x
, dummy_y
, dummy_h
;
7266 width
= row
->height
;
7268 width
= min (row
->height
, width
);
7270 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &dummy_x
,
7271 &dummy_y
, &dummy_h
);
7273 XFillRectangle (dpy
, window
, gc
,
7274 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
7275 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
7276 row
->height
- width
),
7277 w
->phys_cursor_width
, width
);
7280 XSetClipMask (dpy
, gc
, None
);
7285 /* RIF: Define cursor CURSOR on frame F. */
7288 x_define_frame_cursor (struct frame
*f
, Cursor cursor
)
7290 if (!f
->pointer_invisible
7291 && f
->output_data
.x
->current_cursor
!= cursor
)
7292 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
7293 f
->output_data
.x
->current_cursor
= cursor
;
7297 /* RIF: Clear area on frame F. */
7300 x_clear_frame_area (struct frame
*f
, int x
, int y
, int width
, int height
)
7302 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7303 x
, y
, width
, height
, False
);
7305 /* Must queue a redraw, because scroll bars might have been cleared. */
7306 if (FRAME_GTK_WIDGET (f
))
7307 gtk_widget_queue_draw (FRAME_GTK_WIDGET (f
));
7312 /* RIF: Draw cursor on window W. */
7315 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
)
7317 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7321 w
->phys_cursor_type
= cursor_type
;
7322 w
->phys_cursor_on_p
= 1;
7324 if (glyph_row
->exact_window_width_line_p
7325 && (glyph_row
->reversed_p
7326 ? (w
->phys_cursor
.hpos
< 0)
7327 : (w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])))
7329 glyph_row
->cursor_in_fringe_p
= 1;
7330 draw_fringe_bitmap (w
, glyph_row
, glyph_row
->reversed_p
);
7334 switch (cursor_type
)
7336 case HOLLOW_BOX_CURSOR
:
7337 x_draw_hollow_cursor (w
, glyph_row
);
7340 case FILLED_BOX_CURSOR
:
7341 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
7345 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
7349 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
7353 w
->phys_cursor_width
= 0;
7362 if (w
== XWINDOW (f
->selected_window
))
7363 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
7364 xic_set_preeditarea (w
, x
, y
);
7369 XFlush (FRAME_X_DISPLAY (f
));
7376 /* Make the x-window of frame F use the gnu icon bitmap. */
7379 x_bitmap_icon (struct frame
*f
, Lisp_Object file
)
7383 if (FRAME_X_WINDOW (f
) == 0)
7386 /* Free up our existing icon bitmap and mask if any. */
7387 if (f
->output_data
.x
->icon_bitmap
> 0)
7388 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7389 f
->output_data
.x
->icon_bitmap
= 0;
7394 /* Use gtk_window_set_icon_from_file () if available,
7395 It's not restricted to bitmaps */
7396 if (xg_set_icon (f
, file
))
7398 #endif /* USE_GTK */
7399 bitmap_id
= x_create_bitmap_from_file (f
, file
);
7400 x_create_bitmap_mask (f
, bitmap_id
);
7404 /* Create the GNU bitmap and mask if necessary. */
7405 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
7411 if (xg_set_icon (f
, xg_default_icon_file
)
7412 || xg_set_icon_from_xpm_data (f
, gnu_xpm_bits
))
7415 #elif defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
7417 rc
= x_create_bitmap_from_xpm_data (f
, gnu_xpm_bits
);
7419 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
7423 /* If all else fails, use the (black and white) xbm image. */
7426 rc
= x_create_bitmap_from_data (f
, (char *) gnu_xbm_bits
,
7427 gnu_xbm_width
, gnu_xbm_height
);
7431 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
7432 x_create_bitmap_mask (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
7436 /* The first time we create the GNU bitmap and mask,
7437 this increments the ref-count one extra time.
7438 As a result, the GNU bitmap and mask are never freed.
7439 That way, we don't have to worry about allocating it again. */
7440 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
7442 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
7445 x_wm_set_icon_pixmap (f
, bitmap_id
);
7446 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
7452 /* Make the x-window of frame F use a rectangle with text.
7453 Use ICON_NAME as the text. */
7456 x_text_icon (struct frame
*f
, const char *icon_name
)
7458 if (FRAME_X_WINDOW (f
) == 0)
7463 text
.value
= (unsigned char *) icon_name
;
7464 text
.encoding
= XA_STRING
;
7466 text
.nitems
= strlen (icon_name
);
7467 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
7470 if (f
->output_data
.x
->icon_bitmap
> 0)
7471 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7472 f
->output_data
.x
->icon_bitmap
= 0;
7473 x_wm_set_icon_pixmap (f
, 0);
7478 #define X_ERROR_MESSAGE_SIZE 200
7480 /* If non-nil, this should be a string.
7481 It means catch X errors and store the error message in this string.
7483 The reason we use a stack is that x_catch_error/x_uncatch_error can
7484 be called from a signal handler.
7487 struct x_error_message_stack
{
7488 char string
[X_ERROR_MESSAGE_SIZE
];
7490 struct x_error_message_stack
*prev
;
7492 static struct x_error_message_stack
*x_error_message
;
7494 /* An X error handler which stores the error message in
7495 *x_error_message. This is called from x_error_handler if
7496 x_catch_errors is in effect. */
7499 x_error_catcher (Display
*display
, XErrorEvent
*error
)
7501 XGetErrorText (display
, error
->error_code
,
7502 x_error_message
->string
,
7503 X_ERROR_MESSAGE_SIZE
);
7506 /* Begin trapping X errors for display DPY. Actually we trap X errors
7507 for all displays, but DPY should be the display you are actually
7510 After calling this function, X protocol errors no longer cause
7511 Emacs to exit; instead, they are recorded in the string
7512 stored in *x_error_message.
7514 Calling x_check_errors signals an Emacs error if an X error has
7515 occurred since the last call to x_catch_errors or x_check_errors.
7517 Calling x_uncatch_errors resumes the normal error handling. */
7519 void x_check_errors (Display
*dpy
, const char *format
);
7522 x_catch_errors (Display
*dpy
)
7524 struct x_error_message_stack
*data
= xmalloc (sizeof (*data
));
7526 /* Make sure any errors from previous requests have been dealt with. */
7530 data
->string
[0] = 0;
7531 data
->prev
= x_error_message
;
7532 x_error_message
= data
;
7535 /* Undo the last x_catch_errors call.
7536 DPY should be the display that was passed to x_catch_errors. */
7539 x_uncatch_errors (void)
7541 struct x_error_message_stack
*tmp
;
7545 /* The display may have been closed before this function is called.
7546 Check if it is still open before calling XSync. */
7547 if (x_display_info_for_display (x_error_message
->dpy
) != 0)
7548 XSync (x_error_message
->dpy
, False
);
7550 tmp
= x_error_message
;
7551 x_error_message
= x_error_message
->prev
;
7556 /* If any X protocol errors have arrived since the last call to
7557 x_catch_errors or x_check_errors, signal an Emacs error using
7558 sprintf (a buffer, FORMAT, the x error message text) as the text. */
7561 x_check_errors (Display
*dpy
, const char *format
)
7563 /* Make sure to catch any errors incurred so far. */
7566 if (x_error_message
->string
[0])
7568 char string
[X_ERROR_MESSAGE_SIZE
];
7569 memcpy (string
, x_error_message
->string
, X_ERROR_MESSAGE_SIZE
);
7570 x_uncatch_errors ();
7571 error (format
, string
);
7575 /* Nonzero if we had any X protocol errors
7576 since we did x_catch_errors on DPY. */
7579 x_had_errors_p (Display
*dpy
)
7581 /* Make sure to catch any errors incurred so far. */
7584 return x_error_message
->string
[0] != 0;
7587 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
7590 x_clear_errors (Display
*dpy
)
7592 x_error_message
->string
[0] = 0;
7595 #if 0 /* See comment in unwind_to_catch why calling this is a bad
7596 * idea. --lorentey */
7597 /* Close off all unclosed x_catch_errors calls. */
7600 x_fully_uncatch_errors (void)
7602 while (x_error_message
)
7603 x_uncatch_errors ();
7607 /* Nonzero if x_catch_errors has been done and not yet canceled. */
7610 x_catching_errors (void)
7612 return x_error_message
!= 0;
7616 static unsigned int x_wire_count
;
7619 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
7624 /* Handle SIGPIPE, which can happen when the connection to a server
7625 simply goes away. SIGPIPE is handled by x_connection_signal.
7626 Don't need to do anything, because the write which caused the
7627 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
7628 which will do the appropriate cleanup for us. */
7631 x_connection_signal (int signalnum
) /* If we don't have an argument, */
7632 /* some compilers complain in signal calls. */
7635 /* USG systems forget handlers when they are used;
7636 must reestablish each time */
7637 signal (signalnum
, x_connection_signal
);
7642 /************************************************************************
7644 ************************************************************************/
7646 /* Error message passed to x_connection_closed. */
7648 static char *error_msg
;
7650 /* Function installed as fatal_error_signal_hook in
7651 x_connection_closed. Print the X error message, and exit normally,
7652 instead of dumping core when XtCloseDisplay fails. */
7655 x_fatal_error_signal (void)
7657 fprintf (stderr
, "%s\n", error_msg
);
7661 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
7662 the text of an error message that lead to the connection loss. */
7665 x_connection_closed (Display
*dpy
, const char *error_message
)
7667 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
7668 Lisp_Object frame
, tail
;
7669 int index
= SPECPDL_INDEX ();
7671 error_msg
= (char *) alloca (strlen (error_message
) + 1);
7672 strcpy (error_msg
, error_message
);
7673 handling_signal
= 0;
7675 /* Inhibit redisplay while frames are being deleted. */
7676 specbind (Qinhibit_redisplay
, Qt
);
7680 /* Protect display from being closed when we delete the last
7682 dpyinfo
->reference_count
++;
7683 dpyinfo
->terminal
->reference_count
++;
7686 /* First delete frames whose mini-buffers are on frames
7687 that are on the dead display. */
7688 FOR_EACH_FRAME (tail
, frame
)
7690 Lisp_Object minibuf_frame
;
7692 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
7693 if (FRAME_X_P (XFRAME (frame
))
7694 && FRAME_X_P (XFRAME (minibuf_frame
))
7695 && ! EQ (frame
, minibuf_frame
)
7696 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
7697 delete_frame (frame
, Qnoelisp
);
7700 /* Now delete all remaining frames on the dead display.
7701 We are now sure none of these is used as the mini-buffer
7702 for another frame that we need to delete. */
7703 FOR_EACH_FRAME (tail
, frame
)
7704 if (FRAME_X_P (XFRAME (frame
))
7705 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
7707 /* Set this to t so that delete_frame won't get confused
7708 trying to find a replacement. */
7709 KVAR (FRAME_KBOARD (XFRAME (frame
)), Vdefault_minibuffer_frame
) = Qt
;
7710 delete_frame (frame
, Qnoelisp
);
7713 /* If DPYINFO is null, this means we didn't open the display in the
7714 first place, so don't try to close it. */
7717 /* We can not call XtCloseDisplay here because it calls XSync.
7718 XSync inside the error handler apparently hangs Emacs. On
7719 current Xt versions, this isn't needed either. */
7721 /* A long-standing GTK bug prevents proper disconnect handling
7722 (https://bugzilla.gnome.org/show_bug.cgi?id=85715). Once,
7723 the resulting Glib error message loop filled a user's disk.
7724 To avoid this, kill Emacs unconditionally on disconnect. */
7725 shut_down_emacs (0, 0, Qnil
);
7726 fprintf (stderr
, "%s\n\
7727 When compiled with GTK, Emacs cannot recover from X disconnects.\n\
7728 This is a GTK bug: https://bugzilla.gnome.org/show_bug.cgi?id=85715\n\
7729 For details, see etc/PROBLEMS.\n",
7732 #endif /* USE_GTK */
7734 /* Indicate that this display is dead. */
7735 dpyinfo
->display
= 0;
7737 dpyinfo
->reference_count
--;
7738 dpyinfo
->terminal
->reference_count
--;
7739 if (dpyinfo
->reference_count
!= 0)
7740 /* We have just closed all frames on this display. */
7745 XSETTERMINAL (tmp
, dpyinfo
->terminal
);
7746 Fdelete_terminal (tmp
, Qnoelisp
);
7750 if (terminal_list
== 0)
7752 fprintf (stderr
, "%s\n", error_msg
);
7753 Fkill_emacs (make_number (70));
7757 /* Ordinary stack unwind doesn't deal with these. */
7759 sigunblock (sigmask (SIGIO
));
7761 sigunblock (sigmask (SIGALRM
));
7762 TOTALLY_UNBLOCK_INPUT
;
7764 unbind_to (index
, Qnil
);
7765 clear_waiting_for_input ();
7766 /* Here, we absolutely have to use a non-local exit (e.g. signal, throw,
7767 longjmp), because returning from this function would get us back into
7768 Xlib's code which will directly call `exit'. */
7769 error ("%s", error_msg
);
7772 /* We specifically use it before defining it, so that gcc doesn't inline it,
7773 otherwise gdb doesn't know how to properly put a breakpoint on it. */
7774 static void x_error_quitter (Display
*, XErrorEvent
*);
7776 /* This is the first-level handler for X protocol errors.
7777 It calls x_error_quitter or x_error_catcher. */
7780 x_error_handler (Display
*display
, XErrorEvent
*error
)
7782 if (x_error_message
)
7783 x_error_catcher (display
, error
);
7785 x_error_quitter (display
, error
);
7789 /* This is the usual handler for X protocol errors.
7790 It kills all frames on the display that we got the error for.
7791 If that was the only one, it prints an error message and kills Emacs. */
7793 /* .gdbinit puts a breakpoint here, so make sure it is not inlined. */
7795 /* On older GCC versions, just putting x_error_quitter
7796 after x_error_handler prevents inlining into the former. */
7798 static void NO_INLINE
7799 x_error_quitter (Display
*display
, XErrorEvent
*error
)
7801 char buf
[256], buf1
[356];
7803 /* Ignore BadName errors. They can happen because of fonts
7804 or colors that are not defined. */
7806 if (error
->error_code
== BadName
)
7809 /* Note that there is no real way portable across R3/R4 to get the
7810 original error handler. */
7812 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
7813 sprintf (buf1
, "X protocol error: %s on protocol request %d",
7814 buf
, error
->request_code
);
7815 x_connection_closed (display
, buf1
);
7819 /* This is the handler for X IO errors, always.
7820 It kills all frames on the display that we lost touch with.
7821 If that was the only one, it prints an error message and kills Emacs. */
7824 x_io_error_quitter (Display
*display
)
7828 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
7829 x_connection_closed (display
, buf
);
7833 /* Changing the font of the frame. */
7835 /* Give frame F the font FONT-OBJECT as its default font. The return
7836 value is FONT-OBJECT. FONTSET is an ID of the fontset for the
7837 frame. If it is negative, generate a new fontset from
7841 x_new_font (struct frame
*f
, Lisp_Object font_object
, int fontset
)
7843 struct font
*font
= XFONT_OBJECT (font_object
);
7846 fontset
= fontset_from_font (font_object
);
7847 FRAME_FONTSET (f
) = fontset
;
7848 if (FRAME_FONT (f
) == font
)
7849 /* This font is already set in frame F. There's nothing more to
7853 FRAME_FONT (f
) = font
;
7854 FRAME_BASELINE_OFFSET (f
) = font
->baseline_offset
;
7855 FRAME_COLUMN_WIDTH (f
) = font
->average_width
;
7856 FRAME_SPACE_WIDTH (f
) = font
->space_width
;
7857 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (font
);
7859 compute_fringe_widths (f
, 1);
7861 /* Compute the scroll bar width in character columns. */
7862 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
7864 int wid
= FRAME_COLUMN_WIDTH (f
);
7865 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
7866 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
-1) / wid
;
7870 int wid
= FRAME_COLUMN_WIDTH (f
);
7871 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
7874 if (FRAME_X_WINDOW (f
) != 0)
7876 /* Don't change the size of a tip frame; there's no point in
7877 doing it because it's done in Fx_show_tip, and it leads to
7878 problems because the tip frame has no widget. */
7879 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
7880 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
7885 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
7888 xic_set_xfontset (f
, SSDATA (fontset_ascii (fontset
)));
7897 /***********************************************************************
7899 ***********************************************************************/
7905 /* XIM destroy callback function, which is called whenever the
7906 connection to input method XIM dies. CLIENT_DATA contains a
7907 pointer to the x_display_info structure corresponding to XIM. */
7910 xim_destroy_callback (XIM xim
, XPointer client_data
, XPointer call_data
)
7912 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
7913 Lisp_Object frame
, tail
;
7917 /* No need to call XDestroyIC.. */
7918 FOR_EACH_FRAME (tail
, frame
)
7920 struct frame
*f
= XFRAME (frame
);
7921 if (FRAME_X_P (f
) && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
7923 FRAME_XIC (f
) = NULL
;
7924 xic_free_xfontset (f
);
7928 /* No need to call XCloseIM. */
7929 dpyinfo
->xim
= NULL
;
7930 XFree (dpyinfo
->xim_styles
);
7934 #endif /* HAVE_X11R6 */
7937 /* This isn't prototyped in OSF 5.0 or 5.1a. */
7938 extern char *XSetIMValues (XIM
, ...);
7941 /* Open the connection to the XIM server on display DPYINFO.
7942 RESOURCE_NAME is the resource name Emacs uses. */
7945 xim_open_dpy (struct x_display_info
*dpyinfo
, char *resource_name
)
7953 XCloseIM (dpyinfo
->xim
);
7954 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
,
7961 XIMCallback destroy
;
7964 /* Get supported styles and XIM values. */
7965 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
7968 destroy
.callback
= xim_destroy_callback
;
7969 destroy
.client_data
= (XPointer
)dpyinfo
;
7970 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
7976 #endif /* HAVE_XIM */
7977 dpyinfo
->xim
= NULL
;
7981 #ifdef HAVE_X11R6_XIM
7983 /* XIM instantiate callback function, which is called whenever an XIM
7984 server is available. DISPLAY is the display of the XIM.
7985 CLIENT_DATA contains a pointer to an xim_inst_t structure created
7986 when the callback was registered. */
7989 xim_instantiate_callback (Display
*display
, XPointer client_data
, XPointer call_data
)
7991 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
7992 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
7994 /* We don't support multiple XIM connections. */
7998 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
8000 /* Create XIC for the existing frames on the same display, as long
8001 as they have no XIC. */
8002 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
8004 Lisp_Object tail
, frame
;
8007 FOR_EACH_FRAME (tail
, frame
)
8009 struct frame
*f
= XFRAME (frame
);
8012 && FRAME_X_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
8013 if (FRAME_XIC (f
) == NULL
)
8015 create_frame_xic (f
);
8016 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
8017 xic_set_statusarea (f
);
8018 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
8020 struct window
*w
= XWINDOW (f
->selected_window
);
8021 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
8030 #endif /* HAVE_X11R6_XIM */
8033 /* Open a connection to the XIM server on display DPYINFO.
8034 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
8035 connection only at the first time. On X11R6, open the connection
8036 in the XIM instantiate callback function. */
8039 xim_initialize (struct x_display_info
*dpyinfo
, char *resource_name
)
8041 dpyinfo
->xim
= NULL
;
8045 #ifdef HAVE_X11R6_XIM
8046 struct xim_inst_t
*xim_inst
;
8049 xim_inst
= (struct xim_inst_t
*) xmalloc (sizeof (struct xim_inst_t
));
8050 dpyinfo
->xim_callback_data
= xim_inst
;
8051 xim_inst
->dpyinfo
= dpyinfo
;
8052 len
= strlen (resource_name
);
8053 xim_inst
->resource_name
= (char *) xmalloc (len
+ 1);
8054 memcpy (xim_inst
->resource_name
, resource_name
, len
+ 1);
8055 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8056 resource_name
, emacs_class
,
8057 xim_instantiate_callback
,
8058 /* This is XPointer in XFree86
8059 but (XPointer *) on Tru64, at
8060 least, hence the configure test. */
8061 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
8062 #else /* not HAVE_X11R6_XIM */
8063 xim_open_dpy (dpyinfo
, resource_name
);
8064 #endif /* not HAVE_X11R6_XIM */
8066 #endif /* HAVE_XIM */
8070 /* Close the connection to the XIM server on display DPYINFO. */
8073 xim_close_dpy (struct x_display_info
*dpyinfo
)
8078 #ifdef HAVE_X11R6_XIM
8079 if (dpyinfo
->display
)
8080 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8082 xim_instantiate_callback
, NULL
);
8083 xfree (dpyinfo
->xim_callback_data
->resource_name
);
8084 xfree (dpyinfo
->xim_callback_data
);
8085 #endif /* HAVE_X11R6_XIM */
8086 if (dpyinfo
->display
)
8087 XCloseIM (dpyinfo
->xim
);
8088 dpyinfo
->xim
= NULL
;
8089 XFree (dpyinfo
->xim_styles
);
8091 #endif /* HAVE_XIM */
8094 #endif /* not HAVE_X11R6_XIM */
8098 /* Calculate the absolute position in frame F
8099 from its current recorded position values and gravity. */
8102 x_calc_absolute_position (struct frame
*f
)
8104 int flags
= f
->size_hint_flags
;
8106 /* We have nothing to do if the current position
8107 is already for the top-left corner. */
8108 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
8111 /* Treat negative positions as relative to the leftmost bottommost
8112 position that fits on the screen. */
8113 if (flags
& XNegative
)
8114 f
->left_pos
= x_display_pixel_width (FRAME_X_DISPLAY_INFO (f
))
8115 - FRAME_PIXEL_WIDTH (f
) + f
->left_pos
;
8118 int height
= FRAME_PIXEL_HEIGHT (f
);
8120 #if defined USE_X_TOOLKIT && defined USE_MOTIF
8121 /* Something is fishy here. When using Motif, starting Emacs with
8122 `-g -0-0', the frame appears too low by a few pixels.
8124 This seems to be so because initially, while Emacs is starting,
8125 the column widget's height and the frame's pixel height are
8126 different. The column widget's height is the right one. In
8127 later invocations, when Emacs is up, the frame's pixel height
8130 It's not obvious where the initial small difference comes from.
8131 2000-12-01, gerd. */
8133 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
8136 if (flags
& YNegative
)
8137 f
->top_pos
= x_display_pixel_height (FRAME_X_DISPLAY_INFO (f
))
8138 - height
+ f
->top_pos
;
8141 /* The left_pos and top_pos
8142 are now relative to the top and left screen edges,
8143 so the flags should correspond. */
8144 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8147 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
8148 to really change the position, and 0 when calling from
8149 x_make_frame_visible (in that case, XOFF and YOFF are the current
8150 position values). It is -1 when calling from x_set_frame_parameters,
8151 which means, do adjust for borders but don't change the gravity. */
8154 x_set_offset (struct frame
*f
, register int xoff
, register int yoff
, int change_gravity
)
8156 int modified_top
, modified_left
;
8158 if (change_gravity
> 0)
8160 FRAME_X_OUTPUT (f
)->left_before_move
= f
->left_pos
;
8161 FRAME_X_OUTPUT (f
)->top_before_move
= f
->top_pos
;
8165 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8167 f
->size_hint_flags
|= XNegative
;
8169 f
->size_hint_flags
|= YNegative
;
8170 f
->win_gravity
= NorthWestGravity
;
8172 x_calc_absolute_position (f
);
8175 x_wm_set_size_hint (f
, (long) 0, 0);
8177 modified_left
= f
->left_pos
;
8178 modified_top
= f
->top_pos
;
8180 if (change_gravity
!= 0 && FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
)
8182 /* Some WMs (twm, wmaker at least) has an offset that is smaller
8183 than the WM decorations. So we use the calculated offset instead
8184 of the WM decoration sizes here (x/y_pixels_outer_diff). */
8185 modified_left
+= FRAME_X_OUTPUT (f
)->move_offset_left
;
8186 modified_top
+= FRAME_X_OUTPUT (f
)->move_offset_top
;
8189 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8190 modified_left
, modified_top
);
8192 x_sync_with_move (f
, f
->left_pos
, f
->top_pos
,
8193 FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8196 /* change_gravity is non-zero when this function is called from Lisp to
8197 programmatically move a frame. In that case, we call
8198 x_check_expected_move to discover if we have a "Type A" or "Type B"
8199 window manager, and, for a "Type A" window manager, adjust the position
8202 We call x_check_expected_move if a programmatic move occurred, and
8203 either the window manager type (A/B) is unknown or it is Type A but we
8204 need to compute the top/left offset adjustment for this frame. */
8206 if (change_gravity
!= 0 &&
8207 (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
8208 || (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
8209 && (FRAME_X_OUTPUT (f
)->move_offset_left
== 0
8210 && FRAME_X_OUTPUT (f
)->move_offset_top
== 0))))
8211 x_check_expected_move (f
, modified_left
, modified_top
);
8216 /* Return non-zero if _NET_SUPPORTING_WM_CHECK window exists and _NET_SUPPORTED
8217 on the root window for frame F contains ATOMNAME.
8218 This is how a WM check shall be done according to the Window Manager
8219 Specification/Extended Window Manager Hints at
8220 http://freedesktop.org/wiki/Specifications/wm-spec. */
8223 wm_supports (struct frame
*f
, Atom want_atom
)
8226 unsigned long actual_size
, bytes_remaining
;
8227 int i
, rc
, actual_format
;
8228 Window wmcheck_window
;
8229 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8230 Window target_window
= dpyinfo
->root_window
;
8231 long max_len
= 65536;
8232 Display
*dpy
= FRAME_X_DISPLAY (f
);
8233 unsigned char *tmp_data
= NULL
;
8234 Atom target_type
= XA_WINDOW
;
8238 x_catch_errors (dpy
);
8239 rc
= XGetWindowProperty (dpy
, target_window
,
8240 dpyinfo
->Xatom_net_supporting_wm_check
,
8241 0, max_len
, False
, target_type
,
8242 &actual_type
, &actual_format
, &actual_size
,
8243 &bytes_remaining
, &tmp_data
);
8245 if (rc
!= Success
|| actual_type
!= XA_WINDOW
|| x_had_errors_p (dpy
))
8247 if (tmp_data
) XFree (tmp_data
);
8248 x_uncatch_errors ();
8253 wmcheck_window
= *(Window
*) tmp_data
;
8256 /* Check if window exists. */
8257 XSelectInput (dpy
, wmcheck_window
, StructureNotifyMask
);
8259 if (x_had_errors_p (dpy
))
8261 x_uncatch_errors ();
8266 if (dpyinfo
->net_supported_window
!= wmcheck_window
)
8268 /* Window changed, reload atoms */
8269 if (dpyinfo
->net_supported_atoms
!= NULL
)
8270 XFree (dpyinfo
->net_supported_atoms
);
8271 dpyinfo
->net_supported_atoms
= NULL
;
8272 dpyinfo
->nr_net_supported_atoms
= 0;
8273 dpyinfo
->net_supported_window
= 0;
8275 target_type
= XA_ATOM
;
8277 rc
= XGetWindowProperty (dpy
, target_window
,
8278 dpyinfo
->Xatom_net_supported
,
8279 0, max_len
, False
, target_type
,
8280 &actual_type
, &actual_format
, &actual_size
,
8281 &bytes_remaining
, &tmp_data
);
8283 if (rc
!= Success
|| actual_type
!= XA_ATOM
|| x_had_errors_p (dpy
))
8285 if (tmp_data
) XFree (tmp_data
);
8286 x_uncatch_errors ();
8291 dpyinfo
->net_supported_atoms
= (Atom
*)tmp_data
;
8292 dpyinfo
->nr_net_supported_atoms
= actual_size
;
8293 dpyinfo
->net_supported_window
= wmcheck_window
;
8298 for (i
= 0; rc
== 0 && i
< dpyinfo
->nr_net_supported_atoms
; ++i
)
8299 rc
= dpyinfo
->net_supported_atoms
[i
] == want_atom
;
8301 x_uncatch_errors ();
8308 set_wm_state (Lisp_Object frame
, int add
, Atom atom
, Atom value
)
8310 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (frame
));
8312 x_send_client_event (frame
, make_number (0), frame
,
8313 dpyinfo
->Xatom_net_wm_state
,
8315 /* 1 = add, 0 = remove */
8317 (make_number (add
? 1 : 0),
8319 (make_fixnum_or_float (atom
),
8321 ? Fcons (make_fixnum_or_float (value
), Qnil
)
8326 x_set_sticky (struct frame
*f
, Lisp_Object new_value
, Lisp_Object old_value
)
8329 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8331 XSETFRAME (frame
, f
);
8333 set_wm_state (frame
, NILP (new_value
) ? 0 : 1,
8334 dpyinfo
->Xatom_net_wm_state_sticky
, None
);
8337 /* Return the current _NET_WM_STATE.
8338 SIZE_STATE is set to one of the FULLSCREEN_* values.
8339 STICKY is set to 1 if the sticky state is set, 0 if not. */
8342 get_current_wm_state (struct frame
*f
,
8348 unsigned long actual_size
, bytes_remaining
;
8349 int i
, rc
, actual_format
;
8350 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8351 long max_len
= 65536;
8352 Display
*dpy
= FRAME_X_DISPLAY (f
);
8353 unsigned char *tmp_data
= NULL
;
8354 Atom target_type
= XA_ATOM
;
8357 *size_state
= FULLSCREEN_NONE
;
8360 x_catch_errors (dpy
);
8361 rc
= XGetWindowProperty (dpy
, window
, dpyinfo
->Xatom_net_wm_state
,
8362 0, max_len
, False
, target_type
,
8363 &actual_type
, &actual_format
, &actual_size
,
8364 &bytes_remaining
, &tmp_data
);
8366 if (rc
!= Success
|| actual_type
!= target_type
|| x_had_errors_p (dpy
))
8368 if (tmp_data
) XFree (tmp_data
);
8369 x_uncatch_errors ();
8374 x_uncatch_errors ();
8376 for (i
= 0; i
< actual_size
; ++i
)
8378 Atom a
= ((Atom
*)tmp_data
)[i
];
8379 if (a
== dpyinfo
->Xatom_net_wm_state_maximized_horz
)
8381 if (*size_state
== FULLSCREEN_HEIGHT
)
8382 *size_state
= FULLSCREEN_MAXIMIZED
;
8384 *size_state
= FULLSCREEN_WIDTH
;
8386 else if (a
== dpyinfo
->Xatom_net_wm_state_maximized_vert
)
8388 if (*size_state
== FULLSCREEN_WIDTH
)
8389 *size_state
= FULLSCREEN_MAXIMIZED
;
8391 *size_state
= FULLSCREEN_HEIGHT
;
8393 else if (a
== dpyinfo
->Xatom_net_wm_state_fullscreen
)
8394 *size_state
= FULLSCREEN_BOTH
;
8395 else if (a
== dpyinfo
->Xatom_net_wm_state_sticky
)
8399 if (tmp_data
) XFree (tmp_data
);
8403 /* Do fullscreen as specified in extended window manager hints */
8406 do_ewmh_fullscreen (struct frame
*f
)
8408 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8409 int have_net_atom
= wm_supports (f
, dpyinfo
->Xatom_net_wm_state
);
8412 get_current_wm_state (f
, FRAME_OUTER_WINDOW (f
), &cur
, &dummy
);
8414 /* Some window managers don't say they support _NET_WM_STATE, but they do say
8415 they support _NET_WM_STATE_FULLSCREEN. Try that also. */
8417 have_net_atom
= wm_supports (f
, dpyinfo
->Xatom_net_wm_state_fullscreen
);
8419 if (have_net_atom
&& cur
!= f
->want_fullscreen
)
8423 XSETFRAME (frame
, f
);
8425 /* Keep number of calls to set_wm_state as low as possible.
8426 Some window managers, or possible Gtk+, hangs when too many
8427 are sent at once. */
8428 switch (f
->want_fullscreen
)
8430 case FULLSCREEN_BOTH
:
8431 if (cur
== FULLSCREEN_WIDTH
|| cur
== FULLSCREEN_MAXIMIZED
8432 || cur
== FULLSCREEN_HEIGHT
)
8433 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_maximized_horz
,
8434 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
8435 set_wm_state (frame
, 1, dpyinfo
->Xatom_net_wm_state_fullscreen
, None
);
8437 case FULLSCREEN_WIDTH
:
8438 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_HEIGHT
8439 || cur
== FULLSCREEN_MAXIMIZED
)
8440 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_fullscreen
,
8441 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
8442 if (cur
!= FULLSCREEN_MAXIMIZED
)
8443 set_wm_state (frame
, 1, dpyinfo
->Xatom_net_wm_state_maximized_horz
, None
);
8445 case FULLSCREEN_HEIGHT
:
8446 if (cur
== FULLSCREEN_BOTH
|| cur
== FULLSCREEN_WIDTH
8447 || cur
== FULLSCREEN_MAXIMIZED
)
8448 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_fullscreen
,
8449 dpyinfo
->Xatom_net_wm_state_maximized_horz
);
8450 if (cur
!= FULLSCREEN_MAXIMIZED
)
8451 set_wm_state (frame
, 1, dpyinfo
->Xatom_net_wm_state_maximized_vert
, None
);
8453 case FULLSCREEN_MAXIMIZED
:
8454 if (cur
== FULLSCREEN_BOTH
)
8455 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_fullscreen
, None
);
8456 set_wm_state (frame
, 1, dpyinfo
->Xatom_net_wm_state_maximized_horz
,
8457 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
8459 case FULLSCREEN_NONE
:
8460 if (cur
== FULLSCREEN_BOTH
)
8461 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_fullscreen
, None
);
8463 set_wm_state (frame
, 0, dpyinfo
->Xatom_net_wm_state_maximized_horz
,
8464 dpyinfo
->Xatom_net_wm_state_maximized_vert
);
8467 f
->want_fullscreen
= FULLSCREEN_NONE
;
8471 return have_net_atom
;
8475 XTfullscreen_hook (FRAME_PTR f
)
8477 if (f
->async_visible
)
8480 x_check_fullscreen (f
);
8488 x_handle_net_wm_state (struct frame
*f
, XPropertyEvent
*event
)
8490 int value
= FULLSCREEN_NONE
;
8494 get_current_wm_state (f
, event
->window
, &value
, &sticky
);
8498 case FULLSCREEN_WIDTH
:
8501 case FULLSCREEN_HEIGHT
:
8504 case FULLSCREEN_BOTH
:
8507 case FULLSCREEN_MAXIMIZED
:
8512 store_frame_param (f
, Qfullscreen
, lval
);
8513 store_frame_param (f
, Qsticky
, sticky
? Qt
: Qnil
);
8516 /* Check if we need to resize the frame due to a fullscreen request.
8517 If so needed, resize the frame. */
8519 x_check_fullscreen (struct frame
*f
)
8521 if (do_ewmh_fullscreen (f
))
8524 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
8525 return; /* Only fullscreen without WM or with EWM hints (above). */
8527 /* Setting fullscreen to nil doesn't do anything. We could save the
8528 last non-fullscreen size and restore it, but it seems like a
8529 lot of work for this unusual case (no window manager running). */
8531 if (f
->want_fullscreen
!= FULLSCREEN_NONE
)
8533 int width
= FRAME_PIXEL_WIDTH (f
), height
= FRAME_PIXEL_HEIGHT (f
);
8534 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8536 switch (f
->want_fullscreen
)
8538 /* No difference between these two when there is no WM */
8539 case FULLSCREEN_BOTH
:
8540 case FULLSCREEN_MAXIMIZED
:
8541 width
= x_display_pixel_width (dpyinfo
);
8542 height
= x_display_pixel_height (dpyinfo
);
8544 case FULLSCREEN_WIDTH
:
8545 width
= x_display_pixel_width (dpyinfo
);
8547 case FULLSCREEN_HEIGHT
:
8548 height
= x_display_pixel_height (dpyinfo
);
8551 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8556 /* This function is called by x_set_offset to determine whether the window
8557 manager interfered with the positioning of the frame. Type A window
8558 managers position the surrounding window manager decorations a small
8559 amount above and left of the user-supplied position. Type B window
8560 managers position the surrounding window manager decorations at the
8561 user-specified position. If we detect a Type A window manager, we
8562 compensate by moving the window right and down by the proper amount. */
8565 x_check_expected_move (struct frame
*f
, int expected_left
, int expected_top
)
8567 int current_left
= 0, current_top
= 0;
8569 /* x_real_positions returns the left and top offsets of the outermost
8570 window manager window around the frame. */
8572 x_real_positions (f
, ¤t_left
, ¤t_top
);
8574 if (current_left
!= expected_left
|| current_top
!= expected_top
)
8576 /* It's a "Type A" window manager. */
8581 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_A
;
8582 FRAME_X_OUTPUT (f
)->move_offset_left
= expected_left
- current_left
;
8583 FRAME_X_OUTPUT (f
)->move_offset_top
= expected_top
- current_top
;
8585 /* Now fix the mispositioned frame's location. */
8587 adjusted_left
= expected_left
+ FRAME_X_OUTPUT (f
)->move_offset_left
;
8588 adjusted_top
= expected_top
+ FRAME_X_OUTPUT (f
)->move_offset_top
;
8590 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8591 adjusted_left
, adjusted_top
);
8593 x_sync_with_move (f
, expected_left
, expected_top
, 0);
8596 /* It's a "Type B" window manager. We don't have to adjust the
8597 frame's position. */
8599 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_B
;
8603 /* Wait for XGetGeometry to return up-to-date position information for a
8604 recently-moved frame. Call this immediately after calling XMoveWindow.
8605 If FUZZY is non-zero, then LEFT and TOP are just estimates of where the
8606 frame has been moved to, so we use a fuzzy position comparison instead
8607 of an exact comparison. */
8610 x_sync_with_move (struct frame
*f
, int left
, int top
, int fuzzy
)
8614 while (count
++ < 50)
8616 int current_left
= 0, current_top
= 0;
8618 /* In theory, this call to XSync only needs to happen once, but in
8619 practice, it doesn't seem to work, hence the need for the surrounding
8622 XSync (FRAME_X_DISPLAY (f
), False
);
8623 x_real_positions (f
, ¤t_left
, ¤t_top
);
8627 /* The left fuzz-factor is 10 pixels. The top fuzz-factor is 40
8630 if (eabs (current_left
- left
) <= 10
8631 && eabs (current_top
- top
) <= 40)
8634 else if (current_left
== left
&& current_top
== top
)
8638 /* As a last resort, just wait 0.5 seconds and hope that XGetGeometry
8639 will then return up-to-date position info. */
8641 wait_reading_process_output (0, 500000, 0, 0, Qnil
, NULL
, 0);
8645 /* Wait for an event on frame F matching EVENTTYPE. */
8647 x_wait_for_event (struct frame
*f
, int eventtype
)
8649 int level
= interrupt_input_blocked
;
8652 EMACS_TIME tmo
, tmo_at
, time_now
;
8653 int fd
= ConnectionNumber (FRAME_X_DISPLAY (f
));
8655 pending_event_wait
.f
= f
;
8656 pending_event_wait
.eventtype
= eventtype
;
8658 /* Set timeout to 0.1 second. Hopefully not noticable.
8659 Maybe it should be configurable. */
8660 EMACS_SET_SECS_USECS (tmo
, 0, 100000);
8661 EMACS_GET_TIME (tmo_at
);
8662 EMACS_ADD_TIME (tmo_at
, tmo_at
, tmo
);
8664 while (pending_event_wait
.eventtype
)
8666 interrupt_input_pending
= 1;
8667 TOTALLY_UNBLOCK_INPUT
;
8668 /* XTread_socket is called after unblock. */
8670 interrupt_input_blocked
= level
;
8675 EMACS_GET_TIME (time_now
);
8676 EMACS_SUB_TIME (tmo
, tmo_at
, time_now
);
8678 if (EMACS_TIME_NEG_P (tmo
) || select (fd
+1, &fds
, NULL
, NULL
, &tmo
) == 0)
8679 break; /* Timeout */
8681 pending_event_wait
.f
= 0;
8682 pending_event_wait
.eventtype
= 0;
8686 /* Change the size of frame F's X window to COLS/ROWS in the case F
8687 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
8688 top-left-corner window gravity for this size change and subsequent
8689 size changes. Otherwise we leave the window gravity unchanged. */
8692 x_set_window_size_1 (struct frame
*f
, int change_gravity
, int cols
, int rows
)
8694 int pixelwidth
, pixelheight
;
8696 check_frame_size (f
, &rows
, &cols
);
8697 f
->scroll_bar_actual_width
8698 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
8700 : FRAME_CONFIG_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
));
8702 compute_fringe_widths (f
, 0);
8704 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
)
8705 + FRAME_TOOLBAR_WIDTH (f
);
8706 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
)
8707 + FRAME_MENUBAR_HEIGHT (f
) + FRAME_TOOLBAR_HEIGHT (f
);
8709 if (change_gravity
) f
->win_gravity
= NorthWestGravity
;
8710 x_wm_set_size_hint (f
, (long) 0, 0);
8711 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8712 pixelwidth
, pixelheight
);
8715 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
8716 receive in the ConfigureNotify event; if we get what we asked
8717 for, then the event won't cause the screen to become garbaged, so
8718 we have to make sure to do it here. */
8719 SET_FRAME_GARBAGED (f
);
8721 /* Now, strictly speaking, we can't be sure that this is accurate,
8722 but the window manager will get around to dealing with the size
8723 change request eventually, and we'll hear how it went when the
8724 ConfigureNotify event gets here.
8726 We could just not bother storing any of this information here,
8727 and let the ConfigureNotify event set everything up, but that
8728 might be kind of confusing to the Lisp code, since size changes
8729 wouldn't be reported in the frame parameters until some random
8730 point in the future when the ConfigureNotify event arrives.
8732 We pass 1 for DELAY since we can't run Lisp code inside of
8735 /* But the ConfigureNotify may in fact never arrive, and then this is
8736 not right if the frame is visible. Instead wait (with timeout)
8737 for the ConfigureNotify. */
8738 if (f
->async_visible
)
8739 x_wait_for_event (f
, ConfigureNotify
);
8742 change_frame_size (f
, rows
, cols
, 0, 1, 0);
8743 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
8744 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
8750 /* Call this to change the size of frame F's x-window.
8751 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
8752 for this size change and subsequent size changes.
8753 Otherwise we leave the window gravity unchanged. */
8756 x_set_window_size (struct frame
*f
, int change_gravity
, int cols
, int rows
)
8760 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
8764 /* When the frame is maximized/fullscreen or running under for
8765 example Xmonad, x_set_window_size_1 will be a no-op.
8766 In that case, the right thing to do is extend rows/cols to
8767 the current frame size. We do that first if x_set_window_size_1
8768 turns out to not be a no-op (there is no way to know).
8769 The size will be adjusted again if the frame gets a
8770 ConfigureNotify event as a result of x_set_window_size. */
8771 int pixelh
= FRAME_PIXEL_HEIGHT (f
);
8772 #ifdef USE_X_TOOLKIT
8773 /* The menu bar is not part of text lines. The tool bar
8775 pixelh
-= FRAME_MENUBAR_HEIGHT (f
);
8777 r
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelh
);
8778 /* Update f->scroll_bar_actual_width because it is used in
8779 FRAME_PIXEL_WIDTH_TO_TEXT_COLS. */
8780 f
->scroll_bar_actual_width
8781 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
8782 c
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, FRAME_PIXEL_WIDTH (f
));
8783 change_frame_size (f
, r
, c
, 0, 1, 0);
8787 if (FRAME_GTK_WIDGET (f
))
8788 xg_frame_set_char_size (f
, cols
, rows
);
8790 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8791 #else /* not USE_GTK */
8793 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8795 #endif /* not USE_GTK */
8797 /* If cursor was outside the new size, mark it as off. */
8798 mark_window_cursors_off (XWINDOW (f
->root_window
));
8800 /* Clear out any recollection of where the mouse highlighting was,
8801 since it might be in a place that's outside the new frame size.
8802 Actually checking whether it is outside is a pain in the neck,
8803 so don't try--just let the highlighting be done afresh with new size. */
8804 cancel_mouse_face (f
);
8809 /* Mouse warping. */
8812 x_set_mouse_position (struct frame
*f
, int x
, int y
)
8816 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
8817 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
8819 if (pix_x
< 0) pix_x
= 0;
8820 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
8822 if (pix_y
< 0) pix_y
= 0;
8823 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
8827 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8828 0, 0, 0, 0, pix_x
, pix_y
);
8832 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
8835 x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
)
8839 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8840 0, 0, 0, 0, pix_x
, pix_y
);
8844 /* Raise frame F. */
8847 x_raise_frame (struct frame
*f
)
8850 if (f
->async_visible
)
8851 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8853 XFlush (FRAME_X_DISPLAY (f
));
8857 /* Lower frame F. */
8860 x_lower_frame (struct frame
*f
)
8862 if (f
->async_visible
)
8865 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8866 XFlush (FRAME_X_DISPLAY (f
));
8871 /* Activate frame with Extended Window Manager Hints */
8874 x_ewmh_activate_frame (FRAME_PTR f
)
8876 /* See Window Manager Specification/Extended Window Manager Hints at
8877 http://freedesktop.org/wiki/Specifications/wm-spec */
8879 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8880 if (f
->async_visible
&& wm_supports (f
, dpyinfo
->Xatom_net_active_window
))
8883 XSETFRAME (frame
, f
);
8884 x_send_client_event (frame
, make_number (0), frame
,
8885 dpyinfo
->Xatom_net_active_window
,
8887 Fcons (make_number (1),
8888 Fcons (make_number (last_user_time
),
8894 XTframe_raise_lower (FRAME_PTR f
, int raise_flag
)
8902 /* XEmbed implementation. */
8905 xembed_set_info (struct frame
*f
, enum xembed_info flags
)
8907 unsigned long data
[2];
8908 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8910 data
[0] = XEMBED_VERSION
;
8913 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8914 dpyinfo
->Xatom_XEMBED_INFO
, dpyinfo
->Xatom_XEMBED_INFO
,
8915 32, PropModeReplace
, (unsigned char *) data
, 2);
8919 xembed_send_message (struct frame
*f
, Time time
, enum xembed_message message
, long int detail
, long int data1
, long int data2
)
8923 event
.xclient
.type
= ClientMessage
;
8924 event
.xclient
.window
= FRAME_X_OUTPUT (f
)->parent_desc
;
8925 event
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_XEMBED
;
8926 event
.xclient
.format
= 32;
8927 event
.xclient
.data
.l
[0] = time
;
8928 event
.xclient
.data
.l
[1] = message
;
8929 event
.xclient
.data
.l
[2] = detail
;
8930 event
.xclient
.data
.l
[3] = data1
;
8931 event
.xclient
.data
.l
[4] = data2
;
8933 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_OUTPUT (f
)->parent_desc
,
8934 False
, NoEventMask
, &event
);
8935 XSync (FRAME_X_DISPLAY (f
), False
);
8938 /* Change of visibility. */
8940 /* This tries to wait until the frame is really visible.
8941 However, if the window manager asks the user where to position
8942 the frame, this will return before the user finishes doing that.
8943 The frame will not actually be visible at that time,
8944 but it will become visible later when the window manager
8945 finishes with it. */
8948 x_make_frame_visible (struct frame
*f
)
8951 int original_top
, original_left
;
8952 int retry_count
= 2;
8958 type
= x_icon_type (f
);
8960 x_bitmap_icon (f
, type
);
8962 if (! FRAME_VISIBLE_P (f
))
8964 /* We test FRAME_GARBAGED_P here to make sure we don't
8965 call x_set_offset a second time
8966 if we get to x_make_frame_visible a second time
8967 before the window gets really visible. */
8968 if (! FRAME_ICONIFIED_P (f
)
8969 && ! FRAME_X_EMBEDDED_P (f
)
8970 && ! f
->output_data
.x
->asked_for_visible
)
8971 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
8973 f
->output_data
.x
->asked_for_visible
= 1;
8975 if (! EQ (Vx_no_window_manager
, Qt
))
8976 x_wm_set_window_state (f
, NormalState
);
8977 #ifdef USE_X_TOOLKIT
8978 if (FRAME_X_EMBEDDED_P (f
))
8979 xembed_set_info (f
, XEMBED_MAPPED
);
8982 /* This was XtPopup, but that did nothing for an iconified frame. */
8983 XtMapWidget (f
->output_data
.x
->widget
);
8985 #else /* not USE_X_TOOLKIT */
8987 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
8988 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
8990 if (FRAME_X_EMBEDDED_P (f
))
8991 xembed_set_info (f
, XEMBED_MAPPED
);
8993 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8994 #endif /* not USE_GTK */
8995 #endif /* not USE_X_TOOLKIT */
8998 XFlush (FRAME_X_DISPLAY (f
));
9000 /* Synchronize to ensure Emacs knows the frame is visible
9001 before we do anything else. We do this loop with input not blocked
9002 so that incoming events are handled. */
9006 /* This must be before UNBLOCK_INPUT
9007 since events that arrive in response to the actions above
9008 will set it when they are handled. */
9009 int previously_visible
= f
->output_data
.x
->has_been_visible
;
9011 original_left
= f
->left_pos
;
9012 original_top
= f
->top_pos
;
9014 /* This must come after we set COUNT. */
9017 /* We unblock here so that arriving X events are processed. */
9019 /* Now move the window back to where it was "supposed to be".
9020 But don't do it if the gravity is negative.
9021 When the gravity is negative, this uses a position
9022 that is 3 pixels too low. Perhaps that's really the border width.
9024 Don't do this if the window has never been visible before,
9025 because the window manager may choose the position
9026 and we don't want to override it. */
9028 if (! FRAME_VISIBLE_P (f
)
9029 && ! FRAME_ICONIFIED_P (f
)
9030 && ! FRAME_X_EMBEDDED_P (f
)
9031 && f
->win_gravity
== NorthWestGravity
9032 && previously_visible
)
9036 unsigned int width
, height
, border
, depth
;
9040 /* On some window managers (such as FVWM) moving an existing
9041 window, even to the same place, causes the window manager
9042 to introduce an offset. This can cause the window to move
9043 to an unexpected location. Check the geometry (a little
9044 slow here) and then verify that the window is in the right
9045 place. If the window is not in the right place, move it
9046 there, and take the potential window manager hit. */
9047 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9048 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
9050 if (original_left
!= x
|| original_top
!= y
)
9051 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
9052 original_left
, original_top
);
9057 XSETFRAME (frame
, f
);
9059 /* Wait until the frame is visible. Process X events until a
9060 MapNotify event has been seen, or until we think we won't get a
9061 MapNotify at all.. */
9062 for (count
= input_signal_count
+ 10;
9063 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
9065 /* Force processing of queued events. */
9068 /* Machines that do polling rather than SIGIO have been
9069 observed to go into a busy-wait here. So we'll fake an
9070 alarm signal to let the handler know that there's something
9071 to be read. We used to raise a real alarm, but it seems
9072 that the handler isn't always enabled here. This is
9074 if (input_polling_used ())
9076 /* It could be confusing if a real alarm arrives while
9077 processing the fake one. Turn it off and let the
9078 handler reset it. */
9079 int old_poll_suppress_count
= poll_suppress_count
;
9080 poll_suppress_count
= 1;
9081 poll_for_input_1 ();
9082 poll_suppress_count
= old_poll_suppress_count
;
9085 /* See if a MapNotify event has been processed. */
9086 FRAME_SAMPLE_VISIBILITY (f
);
9091 (let ((f (selected-frame)))
9095 the frame is not raised with various window managers on
9096 FreeBSD, GNU/Linux and Solaris. It turns out that, for some
9097 unknown reason, the call to XtMapWidget is completely ignored.
9098 Mapping the widget a second time works. */
9100 if (!FRAME_VISIBLE_P (f
) && --retry_count
> 0)
9105 /* Change from mapped state to withdrawn state. */
9107 /* Make the frame visible (mapped and not iconified). */
9110 x_make_frame_invisible (struct frame
*f
)
9114 /* Use the frame's outermost window, not the one we normally draw on. */
9115 window
= FRAME_OUTER_WINDOW (f
);
9117 /* Don't keep the highlight on an invisible frame. */
9118 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9119 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9123 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
9124 that the current position of the window is user-specified, rather than
9125 program-specified, so that when the window is mapped again, it will be
9126 placed at the same location, without forcing the user to position it
9127 by hand again (they have already done that once for this window.) */
9128 x_wm_set_size_hint (f
, (long) 0, 1);
9131 if (FRAME_GTK_OUTER_WIDGET (f
))
9132 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f
));
9135 if (FRAME_X_EMBEDDED_P (f
))
9136 xembed_set_info (f
, 0);
9141 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
9142 DefaultScreen (FRAME_X_DISPLAY (f
))))
9144 UNBLOCK_INPUT_RESIGNAL
;
9145 error ("Can't notify window manager of window withdrawal");
9149 /* We can't distinguish this from iconification
9150 just by the event that we get from the server.
9151 So we can't win using the usual strategy of letting
9152 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
9153 and synchronize with the server to make sure we agree. */
9155 FRAME_ICONIFIED_P (f
) = 0;
9156 f
->async_visible
= 0;
9157 f
->async_iconified
= 0;
9164 /* Change window state from mapped to iconified. */
9167 x_iconify_frame (struct frame
*f
)
9172 /* Don't keep the highlight on an invisible frame. */
9173 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9174 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9176 if (f
->async_iconified
)
9181 FRAME_SAMPLE_VISIBILITY (f
);
9183 type
= x_icon_type (f
);
9185 x_bitmap_icon (f
, type
);
9188 if (FRAME_GTK_OUTER_WIDGET (f
))
9190 if (! FRAME_VISIBLE_P (f
))
9191 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
9193 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
9196 f
->async_iconified
= 1;
9197 f
->async_visible
= 0;
9203 #ifdef USE_X_TOOLKIT
9205 if (! FRAME_VISIBLE_P (f
))
9207 if (! EQ (Vx_no_window_manager
, Qt
))
9208 x_wm_set_window_state (f
, IconicState
);
9209 /* This was XtPopup, but that did nothing for an iconified frame. */
9210 XtMapWidget (f
->output_data
.x
->widget
);
9211 /* The server won't give us any event to indicate
9212 that an invisible frame was changed to an icon,
9213 so we have to record it here. */
9216 f
->async_iconified
= 1;
9217 f
->async_visible
= 0;
9222 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
9223 XtWindow (f
->output_data
.x
->widget
),
9224 DefaultScreen (FRAME_X_DISPLAY (f
)));
9228 error ("Can't notify window manager of iconification");
9230 f
->async_iconified
= 1;
9231 f
->async_visible
= 0;
9235 XFlush (FRAME_X_DISPLAY (f
));
9237 #else /* not USE_X_TOOLKIT */
9239 /* Make sure the X server knows where the window should be positioned,
9240 in case the user deiconifies with the window manager. */
9241 if (! FRAME_VISIBLE_P (f
)
9242 && ! FRAME_ICONIFIED_P (f
)
9243 && ! FRAME_X_EMBEDDED_P (f
))
9244 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
9246 /* Since we don't know which revision of X we're running, we'll use both
9247 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
9249 /* X11R4: send a ClientMessage to the window manager using the
9250 WM_CHANGE_STATE type. */
9254 message
.xclient
.window
= FRAME_X_WINDOW (f
);
9255 message
.xclient
.type
= ClientMessage
;
9256 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
9257 message
.xclient
.format
= 32;
9258 message
.xclient
.data
.l
[0] = IconicState
;
9260 if (! XSendEvent (FRAME_X_DISPLAY (f
),
9261 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
9263 SubstructureRedirectMask
| SubstructureNotifyMask
,
9266 UNBLOCK_INPUT_RESIGNAL
;
9267 error ("Can't notify window manager of iconification");
9271 /* X11R3: set the initial_state field of the window manager hints to
9273 x_wm_set_window_state (f
, IconicState
);
9275 if (!FRAME_VISIBLE_P (f
))
9277 /* If the frame was withdrawn, before, we must map it. */
9278 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9281 f
->async_iconified
= 1;
9282 f
->async_visible
= 0;
9284 XFlush (FRAME_X_DISPLAY (f
));
9286 #endif /* not USE_X_TOOLKIT */
9290 /* Free X resources of frame F. */
9293 x_free_frame_resources (struct frame
*f
)
9295 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9297 struct scroll_bar
*b
;
9298 Mouse_HLInfo
*hlinfo
= &dpyinfo
->mouse_highlight
;
9302 /* If a display connection is dead, don't try sending more
9303 commands to the X server. */
9304 if (dpyinfo
->display
)
9306 /* We must free faces before destroying windows because some
9307 font-driver (e.g. xft) access a window while finishing a
9309 if (FRAME_FACE_CACHE (f
))
9310 free_frame_faces (f
);
9312 if (f
->output_data
.x
->icon_desc
)
9313 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
9315 #ifdef USE_X_TOOLKIT
9316 /* Explicitly destroy the scroll bars of the frame. Without
9317 this, we get "BadDrawable" errors from the toolkit later on,
9318 presumably from expose events generated for the disappearing
9319 toolkit scroll bars. */
9320 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
9322 b
= XSCROLL_BAR (bar
);
9323 x_scroll_bar_remove (b
);
9332 #ifdef USE_X_TOOLKIT
9333 if (f
->output_data
.x
->widget
)
9335 XtDestroyWidget (f
->output_data
.x
->widget
);
9336 f
->output_data
.x
->widget
= NULL
;
9338 /* Tooltips don't have widgets, only a simple X window, even if
9339 we are using a toolkit. */
9340 else if (FRAME_X_WINDOW (f
))
9341 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9343 free_frame_menubar (f
);
9344 #else /* !USE_X_TOOLKIT */
9347 xg_free_frame_widgets (f
);
9348 #endif /* USE_GTK */
9350 if (FRAME_X_WINDOW (f
))
9351 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9352 #endif /* !USE_X_TOOLKIT */
9354 unload_color (f
, FRAME_FOREGROUND_PIXEL (f
));
9355 unload_color (f
, FRAME_BACKGROUND_PIXEL (f
));
9356 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
9357 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
9358 unload_color (f
, f
->output_data
.x
->border_pixel
);
9359 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
9361 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
9362 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
9363 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
9364 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
9365 #ifdef USE_TOOLKIT_SCROLL_BARS
9366 /* Scrollbar shadow colors. */
9367 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
9368 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
9369 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
9370 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
9371 #endif /* USE_TOOLKIT_SCROLL_BARS */
9372 if (f
->output_data
.x
->white_relief
.allocated_p
)
9373 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
9374 if (f
->output_data
.x
->black_relief
.allocated_p
)
9375 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
9378 XFlush (FRAME_X_DISPLAY (f
));
9381 xfree (f
->output_data
.x
->saved_menu_event
);
9382 xfree (f
->output_data
.x
);
9383 f
->output_data
.x
= NULL
;
9385 if (f
== dpyinfo
->x_focus_frame
)
9386 dpyinfo
->x_focus_frame
= 0;
9387 if (f
== dpyinfo
->x_focus_event_frame
)
9388 dpyinfo
->x_focus_event_frame
= 0;
9389 if (f
== dpyinfo
->x_highlight_frame
)
9390 dpyinfo
->x_highlight_frame
= 0;
9392 if (f
== hlinfo
->mouse_face_mouse_frame
)
9394 hlinfo
->mouse_face_beg_row
9395 = hlinfo
->mouse_face_beg_col
= -1;
9396 hlinfo
->mouse_face_end_row
9397 = hlinfo
->mouse_face_end_col
= -1;
9398 hlinfo
->mouse_face_window
= Qnil
;
9399 hlinfo
->mouse_face_deferred_gc
= 0;
9400 hlinfo
->mouse_face_mouse_frame
= 0;
9407 /* Destroy the X window of frame F. */
9410 x_destroy_window (struct frame
*f
)
9412 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9414 /* If a display connection is dead, don't try sending more
9415 commands to the X server. */
9416 if (dpyinfo
->display
!= 0)
9417 x_free_frame_resources (f
);
9419 dpyinfo
->reference_count
--;
9423 /* Setting window manager hints. */
9425 /* Set the normal size hints for the window manager, for frame F.
9426 FLAGS is the flags word to use--or 0 meaning preserve the flags
9427 that the window now has.
9428 If USER_POSITION is nonzero, we set the USPosition
9429 flag (this is useful when FLAGS is 0).
9430 The GTK version is in gtkutils.c */
9434 x_wm_set_size_hint (struct frame
*f
, long flags
, int user_position
)
9436 XSizeHints size_hints
;
9437 Window window
= FRAME_OUTER_WINDOW (f
);
9439 /* Setting PMaxSize caused various problems. */
9440 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
9442 size_hints
.x
= f
->left_pos
;
9443 size_hints
.y
= f
->top_pos
;
9445 size_hints
.height
= FRAME_PIXEL_HEIGHT (f
);
9446 size_hints
.width
= FRAME_PIXEL_WIDTH (f
);
9448 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
9449 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
9450 size_hints
.max_width
= x_display_pixel_width (FRAME_X_DISPLAY_INFO (f
))
9451 - FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9452 size_hints
.max_height
= x_display_pixel_height (FRAME_X_DISPLAY_INFO (f
))
9453 - FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9455 /* Calculate the base and minimum sizes. */
9457 int base_width
, base_height
;
9458 int min_rows
= 0, min_cols
= 0;
9460 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9461 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9463 check_frame_size (f
, &min_rows
, &min_cols
);
9465 /* The window manager uses the base width hints to calculate the
9466 current number of rows and columns in the frame while
9467 resizing; min_width and min_height aren't useful for this
9468 purpose, since they might not give the dimensions for a
9469 zero-row, zero-column frame.
9471 We use the base_width and base_height members if we have
9472 them; otherwise, we set the min_width and min_height members
9473 to the size for a zero x zero frame. */
9475 size_hints
.flags
|= PBaseSize
;
9476 size_hints
.base_width
= base_width
;
9477 size_hints
.base_height
= base_height
+ FRAME_MENUBAR_HEIGHT (f
);
9478 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
9479 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
9482 /* If we don't need the old flags, we don't need the old hint at all. */
9485 size_hints
.flags
|= flags
;
9490 XSizeHints hints
; /* Sometimes I hate X Windows... */
9491 long supplied_return
;
9494 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
9498 size_hints
.flags
|= flags
;
9503 if (hints
.flags
& PSize
)
9504 size_hints
.flags
|= PSize
;
9505 if (hints
.flags
& PPosition
)
9506 size_hints
.flags
|= PPosition
;
9507 if (hints
.flags
& USPosition
)
9508 size_hints
.flags
|= USPosition
;
9509 if (hints
.flags
& USSize
)
9510 size_hints
.flags
|= USSize
;
9517 size_hints
.win_gravity
= f
->win_gravity
;
9518 size_hints
.flags
|= PWinGravity
;
9522 size_hints
.flags
&= ~ PPosition
;
9523 size_hints
.flags
|= USPosition
;
9525 #endif /* PWinGravity */
9527 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
9529 #endif /* not USE_GTK */
9531 /* Used for IconicState or NormalState */
9534 x_wm_set_window_state (struct frame
*f
, int state
)
9536 #ifdef USE_X_TOOLKIT
9539 XtSetArg (al
[0], XtNinitialState
, state
);
9540 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9541 #else /* not USE_X_TOOLKIT */
9542 Window window
= FRAME_X_WINDOW (f
);
9544 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
9545 f
->output_data
.x
->wm_hints
.initial_state
= state
;
9547 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9548 #endif /* not USE_X_TOOLKIT */
9552 x_wm_set_icon_pixmap (struct frame
*f
, int pixmap_id
)
9554 Pixmap icon_pixmap
, icon_mask
;
9556 #if !defined USE_X_TOOLKIT && !defined USE_GTK
9557 Window window
= FRAME_OUTER_WINDOW (f
);
9562 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
9563 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
9564 icon_mask
= x_bitmap_mask (f
, pixmap_id
);
9565 f
->output_data
.x
->wm_hints
.icon_mask
= icon_mask
;
9569 /* It seems there is no way to turn off use of an icon
9577 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
);
9581 #elif defined (USE_X_TOOLKIT) /* same as in x_wm_set_window_state. */
9585 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
9586 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9587 XtSetArg (al
[0], XtNiconMask
, icon_mask
);
9588 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9591 #else /* not USE_X_TOOLKIT && not USE_GTK */
9593 f
->output_data
.x
->wm_hints
.flags
|= (IconPixmapHint
| IconMaskHint
);
9594 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9596 #endif /* not USE_X_TOOLKIT && not USE_GTK */
9600 x_wm_set_icon_position (struct frame
*f
, int icon_x
, int icon_y
)
9602 Window window
= FRAME_OUTER_WINDOW (f
);
9604 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
9605 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
9606 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
9608 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9612 /***********************************************************************
9614 ***********************************************************************/
9618 /* Check that FONT is valid on frame F. It is if it can be found in F's
9622 x_check_font (struct frame
*f
, struct font
*font
)
9626 xassert (font
!= NULL
&& ! NILP (font
->props
[FONT_TYPE_INDEX
]));
9627 if (font
->driver
->check
)
9628 xassert (font
->driver
->check (f
, font
) == 0);
9631 #endif /* GLYPH_DEBUG != 0 */
9634 /***********************************************************************
9636 ***********************************************************************/
9638 #ifdef USE_X_TOOLKIT
9639 static XrmOptionDescRec emacs_options
[] = {
9640 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
9641 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
9643 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
9644 XrmoptionSepArg
, NULL
},
9645 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
9647 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9648 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9649 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
9650 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
9651 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
9652 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
9653 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
9656 /* Whether atimer for Xt timeouts is activated or not. */
9658 static int x_timeout_atimer_activated_flag
;
9660 #endif /* USE_X_TOOLKIT */
9662 static int x_initialized
;
9664 /* Test whether two display-name strings agree up to the dot that separates
9665 the screen number from the server number. */
9667 same_x_server (const char *name1
, const char *name2
)
9670 const char *system_name
= SSDATA (Vsystem_name
);
9671 int system_name_length
= strlen (system_name
);
9672 int length_until_period
= 0;
9674 while (system_name
[length_until_period
] != 0
9675 && system_name
[length_until_period
] != '.')
9676 length_until_period
++;
9678 /* Treat `unix' like an empty host name. */
9679 if (! strncmp (name1
, "unix:", 5))
9681 if (! strncmp (name2
, "unix:", 5))
9683 /* Treat this host's name like an empty host name. */
9684 if (! strncmp (name1
, system_name
, system_name_length
)
9685 && name1
[system_name_length
] == ':')
9686 name1
+= system_name_length
;
9687 if (! strncmp (name2
, system_name
, system_name_length
)
9688 && name2
[system_name_length
] == ':')
9689 name2
+= system_name_length
;
9690 /* Treat this host's domainless name like an empty host name. */
9691 if (! strncmp (name1
, system_name
, length_until_period
)
9692 && name1
[length_until_period
] == ':')
9693 name1
+= length_until_period
;
9694 if (! strncmp (name2
, system_name
, length_until_period
)
9695 && name2
[length_until_period
] == ':')
9696 name2
+= length_until_period
;
9698 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
9702 if (seen_colon
&& *name1
== '.')
9706 && (*name1
== '.' || *name1
== '\0')
9707 && (*name2
== '.' || *name2
== '\0'));
9710 /* Count number of set bits in mask and number of bits to shift to
9711 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
9714 get_bits_and_offset (long unsigned int mask
, int *bits
, int *offset
)
9735 /* Return 1 if display DISPLAY is available for use, 0 otherwise.
9736 But don't permanently open it, just test its availability. */
9739 x_display_ok (const char *display
)
9744 dpy
= XOpenDisplay (display
);
9746 XCloseDisplay (dpy
);
9754 my_log_handler (const gchar
*log_domain
, GLogLevelFlags log_level
, const gchar
*message
, gpointer user_data
)
9756 if (!strstr (message
, "g_set_prgname"))
9757 fprintf (stderr
, "%s-WARNING **: %s\n", log_domain
, message
);
9761 /* Open a connection to X display DISPLAY_NAME, and return
9762 the structure that describes the open display.
9763 If we cannot contact the display, return null. */
9765 struct x_display_info
*
9766 x_term_init (Lisp_Object display_name
, char *xrm_option
, char *resource_name
)
9770 struct terminal
*terminal
;
9771 struct x_display_info
*dpyinfo
;
9773 Mouse_HLInfo
*hlinfo
;
9783 if (! x_display_ok (SSDATA (display_name
)))
9784 error ("Display %s can't be opened", SSDATA (display_name
));
9790 char *argv
[NUM_ARGV
];
9791 char **argv2
= argv
;
9794 if (x_initialized
++ > 1)
9796 xg_display_open (SSDATA (display_name
), &dpy
);
9800 static char display_opt
[] = "--display";
9801 static char name_opt
[] = "--name";
9803 for (argc
= 0; argc
< NUM_ARGV
; ++argc
)
9807 argv
[argc
++] = initial_argv
[0];
9809 if (! NILP (display_name
))
9811 argv
[argc
++] = display_opt
;
9812 argv
[argc
++] = SSDATA (display_name
);
9815 argv
[argc
++] = name_opt
;
9816 argv
[argc
++] = resource_name
;
9818 XSetLocaleModifiers ("");
9820 /* Work around GLib bug that outputs a faulty warning. See
9821 https://bugzilla.gnome.org/show_bug.cgi?id=563627. */
9822 id
= g_log_set_handler ("GLib", G_LOG_LEVEL_WARNING
| G_LOG_FLAG_FATAL
9823 | G_LOG_FLAG_RECURSION
, my_log_handler
, NULL
);
9824 gtk_init (&argc
, &argv2
);
9825 g_log_remove_handler ("GLib", id
);
9827 /* gtk_init does set_locale. We must fix locale after calling it. */
9831 dpy
= GDK_DISPLAY ();
9833 /* NULL window -> events for all windows go to our function */
9834 gdk_window_add_filter (NULL
, event_handler_gdk
, NULL
);
9836 /* Load our own gtkrc if it exists. */
9838 const char *file
= "~/.emacs.d/gtkrc";
9839 Lisp_Object s
, abs_file
;
9841 s
= make_string (file
, strlen (file
));
9842 abs_file
= Fexpand_file_name (s
, Qnil
);
9844 if (! NILP (abs_file
) && !NILP (Ffile_readable_p (abs_file
)))
9845 gtk_rc_parse (SSDATA (abs_file
));
9848 XSetErrorHandler (x_error_handler
);
9849 XSetIOErrorHandler (x_io_error_quitter
);
9852 #else /* not USE_GTK */
9853 #ifdef USE_X_TOOLKIT
9854 /* weiner@footloose.sps.mot.com reports that this causes
9856 X protocol error: BadAtom (invalid Atom parameter)
9857 on protocol request 18skiloaf.
9858 So let's not use it until R6. */
9860 XtSetLanguageProc (NULL
, NULL
, NULL
);
9871 argv
[argc
++] = "-xrm";
9872 argv
[argc
++] = xrm_option
;
9874 turn_on_atimers (0);
9875 dpy
= XtOpenDisplay (Xt_app_con
, SSDATA (display_name
),
9876 resource_name
, EMACS_CLASS
,
9877 emacs_options
, XtNumber (emacs_options
),
9879 turn_on_atimers (1);
9882 /* I think this is to compensate for XtSetLanguageProc. */
9887 #else /* not USE_X_TOOLKIT */
9888 XSetLocaleModifiers ("");
9889 dpy
= XOpenDisplay (SSDATA (display_name
));
9890 #endif /* not USE_X_TOOLKIT */
9891 #endif /* not USE_GTK*/
9893 /* Detect failure. */
9900 /* We have definitely succeeded. Record the new connection. */
9902 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
9903 memset (dpyinfo
, 0, sizeof *dpyinfo
);
9904 hlinfo
= &dpyinfo
->mouse_highlight
;
9906 terminal
= x_create_terminal (dpyinfo
);
9909 struct x_display_info
*share
;
9912 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
9913 share
= share
->next
, tail
= XCDR (tail
))
9914 if (same_x_server (SSDATA (XCAR (XCAR (tail
))),
9915 SSDATA (display_name
)))
9918 terminal
->kboard
= share
->terminal
->kboard
;
9921 terminal
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
9922 init_kboard (terminal
->kboard
);
9923 KVAR (terminal
->kboard
, Vwindow_system
) = Qx
;
9925 /* Add the keyboard to the list before running Lisp code (via
9926 Qvendor_specific_keysyms below), since these are not traced
9927 via terminals but only through all_kboards. */
9928 terminal
->kboard
->next_kboard
= all_kboards
;
9929 all_kboards
= terminal
->kboard
;
9931 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
9933 char *vendor
= ServerVendor (dpy
);
9935 /* Protect terminal from GC before removing it from the
9936 list of terminals. */
9937 struct gcpro gcpro1
;
9938 Lisp_Object gcpro_term
;
9939 XSETTERMINAL (gcpro_term
, terminal
);
9940 GCPRO1 (gcpro_term
);
9942 /* Temporarily hide the partially initialized terminal. */
9943 terminal_list
= terminal
->next_terminal
;
9945 KVAR (terminal
->kboard
, Vsystem_key_alist
)
9946 = call1 (Qvendor_specific_keysyms
,
9947 vendor
? build_string (vendor
) : empty_unibyte_string
);
9949 terminal
->next_terminal
= terminal_list
;
9950 terminal_list
= terminal
;
9954 /* Don't let the initial kboard remain current longer than necessary.
9955 That would cause problems if a file loaded on startup tries to
9956 prompt in the mini-buffer. */
9957 if (current_kboard
== initial_kboard
)
9958 current_kboard
= terminal
->kboard
;
9960 terminal
->kboard
->reference_count
++;
9963 /* Put this display on the chain. */
9964 dpyinfo
->next
= x_display_list
;
9965 x_display_list
= dpyinfo
;
9967 /* Put it on x_display_name_list as well, to keep them parallel. */
9968 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
9969 x_display_name_list
);
9970 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
9972 dpyinfo
->display
= dpy
;
9974 /* Set the name of the terminal. */
9975 terminal
->name
= (char *) xmalloc (SBYTES (display_name
) + 1);
9976 strncpy (terminal
->name
, SSDATA (display_name
), SBYTES (display_name
));
9977 terminal
->name
[SBYTES (display_name
)] = 0;
9980 XSetAfterFunction (x_current_display
, x_trace_wire
);
9984 = (char *) xmalloc (SBYTES (Vinvocation_name
)
9985 + SBYTES (Vsystem_name
)
9987 sprintf (dpyinfo
->x_id_name
, "%s@%s",
9988 SSDATA (Vinvocation_name
), SSDATA (Vsystem_name
));
9990 /* Figure out which modifier bits mean what. */
9991 x_find_modifier_meanings (dpyinfo
);
9993 /* Get the scroll bar cursor. */
9995 /* We must create a GTK cursor, it is required for GTK widgets. */
9996 dpyinfo
->xg_cursor
= xg_create_default_cursor (dpyinfo
->display
);
9997 #endif /* USE_GTK */
9999 dpyinfo
->vertical_scroll_bar_cursor
10000 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
10002 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
10003 resource_name
, EMACS_CLASS
);
10004 #ifdef HAVE_XRMSETDATABASE
10005 XrmSetDatabase (dpyinfo
->display
, xrdb
);
10007 dpyinfo
->display
->db
= xrdb
;
10009 /* Put the rdb where we can find it in a way that works on
10011 dpyinfo
->xrdb
= xrdb
;
10013 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
10014 DefaultScreen (dpyinfo
->display
));
10015 select_visual (dpyinfo
);
10016 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
10017 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
10018 dpyinfo
->client_leader_window
= 0;
10019 dpyinfo
->grabbed
= 0;
10020 dpyinfo
->reference_count
= 0;
10021 dpyinfo
->icon_bitmap_id
= -1;
10022 dpyinfo
->n_fonts
= 0;
10023 dpyinfo
->bitmaps
= 0;
10024 dpyinfo
->bitmaps_size
= 0;
10025 dpyinfo
->bitmaps_last
= 0;
10026 dpyinfo
->scratch_cursor_gc
= 0;
10027 hlinfo
->mouse_face_mouse_frame
= 0;
10028 hlinfo
->mouse_face_deferred_gc
= 0;
10029 hlinfo
->mouse_face_beg_row
= hlinfo
->mouse_face_beg_col
= -1;
10030 hlinfo
->mouse_face_end_row
= hlinfo
->mouse_face_end_col
= -1;
10031 hlinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
10032 hlinfo
->mouse_face_window
= Qnil
;
10033 hlinfo
->mouse_face_overlay
= Qnil
;
10034 hlinfo
->mouse_face_mouse_x
= hlinfo
->mouse_face_mouse_y
= 0;
10035 hlinfo
->mouse_face_defer
= 0;
10036 hlinfo
->mouse_face_hidden
= 0;
10037 dpyinfo
->x_focus_frame
= 0;
10038 dpyinfo
->x_focus_event_frame
= 0;
10039 dpyinfo
->x_highlight_frame
= 0;
10040 dpyinfo
->wm_type
= X_WMTYPE_UNKNOWN
;
10042 /* See if we can construct pixel values from RGB values. */
10043 dpyinfo
->red_bits
= dpyinfo
->blue_bits
= dpyinfo
->green_bits
= 0;
10044 dpyinfo
->red_offset
= dpyinfo
->blue_offset
= dpyinfo
->green_offset
= 0;
10046 if (dpyinfo
->visual
->class == TrueColor
)
10048 get_bits_and_offset (dpyinfo
->visual
->red_mask
,
10049 &dpyinfo
->red_bits
, &dpyinfo
->red_offset
);
10050 get_bits_and_offset (dpyinfo
->visual
->blue_mask
,
10051 &dpyinfo
->blue_bits
, &dpyinfo
->blue_offset
);
10052 get_bits_and_offset (dpyinfo
->visual
->green_mask
,
10053 &dpyinfo
->green_bits
, &dpyinfo
->green_offset
);
10056 /* See if a private colormap is requested. */
10057 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
10059 if (dpyinfo
->visual
->class == PseudoColor
)
10062 value
= display_x_get_resource (dpyinfo
,
10063 build_string ("privateColormap"),
10064 build_string ("PrivateColormap"),
10066 if (STRINGP (value
)
10067 && (!strcmp (SSDATA (value
), "true")
10068 || !strcmp (SSDATA (value
), "on")))
10069 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
10073 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
10074 dpyinfo
->visual
, AllocNone
);
10078 /* If we are using Xft, check dpi value in X resources.
10079 It is better we use it as well, since Xft will use it, as will all
10080 Gnome applications. If our real DPI is smaller or larger than the
10081 one Xft uses, our font will look smaller or larger than other
10082 for other applications, even if it is the same font name (monospace-10
10084 char *v
= XGetDefault (dpyinfo
->display
, "Xft", "dpi");
10086 if (v
!= NULL
&& sscanf (v
, "%lf", &d
) == 1)
10087 dpyinfo
->resy
= dpyinfo
->resx
= d
;
10091 if (dpyinfo
->resy
< 1)
10093 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
10094 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
10095 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
10096 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10097 dpyinfo
->resy
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10098 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
10099 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
10100 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10101 dpyinfo
->resx
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10110 { "WM_PROTOCOLS", &dpyinfo
->Xatom_wm_protocols
},
10111 { "WM_TAKE_FOCUS", &dpyinfo
->Xatom_wm_take_focus
},
10112 { "WM_SAVE_YOURSELF", &dpyinfo
->Xatom_wm_save_yourself
},
10113 { "WM_DELETE_WINDOW", &dpyinfo
->Xatom_wm_delete_window
},
10114 { "WM_CHANGE_STATE", &dpyinfo
->Xatom_wm_change_state
},
10115 { "WM_CONFIGURE_DENIED", &dpyinfo
->Xatom_wm_configure_denied
},
10116 { "WM_MOVED", &dpyinfo
->Xatom_wm_window_moved
},
10117 { "WM_CLIENT_LEADER", &dpyinfo
->Xatom_wm_client_leader
},
10118 { "Editres", &dpyinfo
->Xatom_editres
},
10119 { "CLIPBOARD", &dpyinfo
->Xatom_CLIPBOARD
},
10120 { "TIMESTAMP", &dpyinfo
->Xatom_TIMESTAMP
},
10121 { "TEXT", &dpyinfo
->Xatom_TEXT
},
10122 { "COMPOUND_TEXT", &dpyinfo
->Xatom_COMPOUND_TEXT
},
10123 { "UTF8_STRING", &dpyinfo
->Xatom_UTF8_STRING
},
10124 { "DELETE", &dpyinfo
->Xatom_DELETE
},
10125 { "MULTIPLE", &dpyinfo
->Xatom_MULTIPLE
},
10126 { "INCR", &dpyinfo
->Xatom_INCR
},
10127 { "_EMACS_TMP_", &dpyinfo
->Xatom_EMACS_TMP
},
10128 { "TARGETS", &dpyinfo
->Xatom_TARGETS
},
10129 { "NULL", &dpyinfo
->Xatom_NULL
},
10130 { "ATOM_PAIR", &dpyinfo
->Xatom_ATOM_PAIR
},
10131 { "_XEMBED_INFO", &dpyinfo
->Xatom_XEMBED_INFO
},
10132 /* For properties of font. */
10133 { "PIXEL_SIZE", &dpyinfo
->Xatom_PIXEL_SIZE
},
10134 { "AVERAGE_WIDTH", &dpyinfo
->Xatom_AVERAGE_WIDTH
},
10135 { "_MULE_BASELINE_OFFSET", &dpyinfo
->Xatom_MULE_BASELINE_OFFSET
},
10136 { "_MULE_RELATIVE_COMPOSE", &dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
},
10137 { "_MULE_DEFAULT_ASCENT", &dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
},
10138 /* Ghostscript support. */
10139 { "DONE", &dpyinfo
->Xatom_DONE
},
10140 { "PAGE", &dpyinfo
->Xatom_PAGE
},
10141 { "SCROLLBAR", &dpyinfo
->Xatom_Scrollbar
},
10142 { "_XEMBED", &dpyinfo
->Xatom_XEMBED
},
10144 { "_NET_WM_STATE", &dpyinfo
->Xatom_net_wm_state
},
10145 { "_NET_WM_STATE_FULLSCREEN", &dpyinfo
->Xatom_net_wm_state_fullscreen
},
10146 { "_NET_WM_STATE_MAXIMIZED_HORZ",
10147 &dpyinfo
->Xatom_net_wm_state_maximized_horz
},
10148 { "_NET_WM_STATE_MAXIMIZED_VERT",
10149 &dpyinfo
->Xatom_net_wm_state_maximized_vert
},
10150 { "_NET_WM_STATE_STICKY", &dpyinfo
->Xatom_net_wm_state_sticky
},
10151 { "_NET_WM_WINDOW_TYPE", &dpyinfo
->Xatom_net_window_type
},
10152 { "_NET_WM_WINDOW_TYPE_TOOLTIP",
10153 &dpyinfo
->Xatom_net_window_type_tooltip
},
10154 { "_NET_WM_ICON_NAME", &dpyinfo
->Xatom_net_wm_icon_name
},
10155 { "_NET_WM_NAME", &dpyinfo
->Xatom_net_wm_name
},
10156 { "_NET_SUPPORTED", &dpyinfo
->Xatom_net_supported
},
10157 { "_NET_SUPPORTING_WM_CHECK", &dpyinfo
->Xatom_net_supporting_wm_check
},
10158 { "_NET_WM_WINDOW_OPACITY", &dpyinfo
->Xatom_net_wm_window_opacity
},
10159 { "_NET_ACTIVE_WINDOW", &dpyinfo
->Xatom_net_active_window
},
10160 { "_NET_FRAME_EXTENTS", &dpyinfo
->Xatom_net_frame_extents
},
10161 /* Session management */
10162 { "SM_CLIENT_ID", &dpyinfo
->Xatom_SM_CLIENT_ID
},
10163 { "_XSETTINGS_SETTINGS", &dpyinfo
->Xatom_xsettings_prop
},
10164 { "MANAGER", &dpyinfo
->Xatom_xsettings_mgr
},
10168 const int atom_count
= sizeof (atom_refs
) / sizeof (atom_refs
[0]);
10169 /* 1 for _XSETTINGS_SN */
10170 const int total_atom_count
= 1 + atom_count
;
10171 Atom
*atoms_return
= xmalloc (sizeof (Atom
) * total_atom_count
);
10172 char **atom_names
= xmalloc (sizeof (char *) * total_atom_count
);
10173 char xsettings_atom_name
[64];
10175 for (i
= 0; i
< atom_count
; i
++)
10176 atom_names
[i
] = (char *) atom_refs
[i
].name
;
10178 /* Build _XSETTINGS_SN atom name */
10179 snprintf (xsettings_atom_name
, sizeof (xsettings_atom_name
),
10180 "_XSETTINGS_S%d", XScreenNumberOfScreen (dpyinfo
->screen
));
10181 atom_names
[i
] = xsettings_atom_name
;
10183 XInternAtoms (dpyinfo
->display
, atom_names
, total_atom_count
,
10184 False
, atoms_return
);
10186 for (i
= 0; i
< atom_count
; i
++)
10187 *atom_refs
[i
].atom
= atoms_return
[i
];
10189 /* Manual copy of last atom */
10190 dpyinfo
->Xatom_xsettings_sel
= atoms_return
[i
];
10192 xfree (atom_names
);
10193 xfree (atoms_return
);
10196 dpyinfo
->x_dnd_atoms_size
= 8;
10197 dpyinfo
->x_dnd_atoms_length
= 0;
10198 dpyinfo
->x_dnd_atoms
= xmalloc (sizeof (*dpyinfo
->x_dnd_atoms
)
10199 * dpyinfo
->x_dnd_atoms_size
);
10201 dpyinfo
->net_supported_atoms
= NULL
;
10202 dpyinfo
->nr_net_supported_atoms
= 0;
10203 dpyinfo
->net_supported_window
= 0;
10205 connection
= ConnectionNumber (dpyinfo
->display
);
10206 dpyinfo
->connection
= connection
;
10210 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
10212 gray_bitmap_width
, gray_bitmap_height
,
10213 (unsigned long) 1, (unsigned long) 0, 1);
10217 xim_initialize (dpyinfo
, resource_name
);
10220 xsettings_initialize (dpyinfo
);
10222 /* This is only needed for distinguishing keyboard and process input. */
10223 if (connection
!= 0)
10224 add_keyboard_wait_descriptor (connection
);
10227 fcntl (connection
, F_SETOWN
, getpid ());
10228 #endif /* ! defined (F_SETOWN) */
10231 if (interrupt_input
)
10232 init_sigio (connection
);
10233 #endif /* ! defined (SIGIO) */
10237 Display
*dpy
= dpyinfo
->display
;
10238 XrmValue d
, fr
, to
;
10241 d
.addr
= (XPointer
)&dpy
;
10242 d
.size
= sizeof (Display
*);
10243 fr
.addr
= XtDefaultFont
;
10244 fr
.size
= sizeof (XtDefaultFont
);
10245 to
.size
= sizeof (Font
*);
10246 to
.addr
= (XPointer
)&font
;
10247 x_catch_errors (dpy
);
10248 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
10250 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
10251 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
10252 x_uncatch_errors ();
10256 /* See if we should run in synchronous mode. This is useful
10257 for debugging X code. */
10260 value
= display_x_get_resource (dpyinfo
,
10261 build_string ("synchronous"),
10262 build_string ("Synchronous"),
10264 if (STRINGP (value
)
10265 && (!strcmp (SSDATA (value
), "true")
10266 || !strcmp (SSDATA (value
), "on")))
10267 XSynchronize (dpyinfo
->display
, True
);
10272 value
= display_x_get_resource (dpyinfo
,
10273 build_string ("useXIM"),
10274 build_string ("UseXIM"),
10277 if (STRINGP (value
)
10278 && (!strcmp (SSDATA (value
), "false")
10279 || !strcmp (SSDATA (value
), "off")))
10282 if (STRINGP (value
)
10283 && (!strcmp (SSDATA (value
), "true")
10284 || !strcmp (SSDATA (value
), "on")))
10290 /* Only do this for the very first display in the Emacs session.
10291 Ignore X session management when Emacs was first started on a
10293 if (terminal
->id
== 1)
10294 x_session_initialize (dpyinfo
);
10302 /* Get rid of display DPYINFO, deleting all frames on it,
10303 and without sending any more commands to the X server. */
10306 x_delete_display (struct x_display_info
*dpyinfo
)
10308 struct terminal
*t
;
10310 /* Close all frames and delete the generic struct terminal for this
10312 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
10313 if (t
->type
== output_x_window
&& t
->display_info
.x
== dpyinfo
)
10316 /* Close X session management when we close its display. */
10317 if (t
->id
== 1 && x_session_have_connection ())
10318 x_session_close ();
10320 delete_terminal (t
);
10324 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
10326 /* Discard this display from x_display_name_list and x_display_list.
10327 We can't use Fdelq because that can quit. */
10328 if (! NILP (x_display_name_list
)
10329 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
10330 x_display_name_list
= XCDR (x_display_name_list
);
10335 tail
= x_display_name_list
;
10336 while (CONSP (tail
) && CONSP (XCDR (tail
)))
10338 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
10340 XSETCDR (tail
, XCDR (XCDR (tail
)));
10343 tail
= XCDR (tail
);
10347 if (next_noop_dpyinfo
== dpyinfo
)
10348 next_noop_dpyinfo
= dpyinfo
->next
;
10350 if (x_display_list
== dpyinfo
)
10351 x_display_list
= dpyinfo
->next
;
10354 struct x_display_info
*tail
;
10356 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
10357 if (tail
->next
== dpyinfo
)
10358 tail
->next
= tail
->next
->next
;
10361 xfree (dpyinfo
->x_id_name
);
10362 xfree (dpyinfo
->x_dnd_atoms
);
10363 xfree (dpyinfo
->color_cells
);
10367 #ifdef USE_X_TOOLKIT
10369 /* Atimer callback function for TIMER. Called every 0.1s to process
10370 Xt timeouts, if needed. We must avoid calling XtAppPending as
10371 much as possible because that function does an implicit XFlush
10372 that slows us down. */
10375 x_process_timeouts (struct atimer
*timer
)
10378 x_timeout_atimer_activated_flag
= 0;
10379 if (toolkit_scroll_bar_interaction
|| popup_activated ())
10381 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
10382 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
10383 /* Reactivate the atimer for next time. */
10384 x_activate_timeout_atimer ();
10389 /* Install an asynchronous timer that processes Xt timeout events
10390 every 0.1s as long as either `toolkit_scroll_bar_interaction' or
10391 `popup_activated_flag' (in xmenu.c) is set. Make sure to call this
10392 function whenever these variables are set. This is necessary
10393 because some widget sets use timeouts internally, for example the
10394 LessTif menu bar, or the Xaw3d scroll bar. When Xt timeouts aren't
10395 processed, these widgets don't behave normally. */
10398 x_activate_timeout_atimer (void)
10401 if (!x_timeout_atimer_activated_flag
)
10403 EMACS_TIME interval
;
10405 EMACS_SET_SECS_USECS (interval
, 0, 100000);
10406 start_atimer (ATIMER_RELATIVE
, interval
, x_process_timeouts
, 0);
10407 x_timeout_atimer_activated_flag
= 1;
10412 #endif /* USE_X_TOOLKIT */
10415 /* Set up use of X before we make the first connection. */
10417 extern frame_parm_handler x_frame_parm_handlers
[];
10419 static struct redisplay_interface x_redisplay_interface
=
10421 x_frame_parm_handlers
,
10425 x_clear_end_of_line
,
10427 x_after_update_window_line
,
10428 x_update_window_begin
,
10429 x_update_window_end
,
10435 0, /* flush_display_optional */
10437 x_clear_window_mouse_face
,
10438 x_get_glyph_overhangs
,
10439 x_fix_overlapping_area
,
10440 x_draw_fringe_bitmap
,
10441 0, /* define_fringe_bitmap */
10442 0, /* destroy_fringe_bitmap */
10443 x_compute_glyph_string_overhangs
,
10444 x_draw_glyph_string
,
10445 x_define_frame_cursor
,
10446 x_clear_frame_area
,
10447 x_draw_window_cursor
,
10448 x_draw_vertical_window_border
,
10449 x_shift_glyphs_for_insert
10453 /* This function is called when the last frame on a display is deleted. */
10455 x_delete_terminal (struct terminal
*terminal
)
10457 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
10459 /* Protect against recursive calls. delete_frame in
10460 delete_terminal calls us back when it deletes our last frame. */
10461 if (!terminal
->name
)
10466 /* We must close our connection to the XIM server before closing the
10469 xim_close_dpy (dpyinfo
);
10472 /* If called from x_connection_closed, the display may already be closed
10473 and dpyinfo->display was set to 0 to indicate that. */
10474 if (dpyinfo
->display
)
10476 x_destroy_all_bitmaps (dpyinfo
);
10477 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
10479 /* Whether or not XCloseDisplay destroys the associated resource
10480 database depends on the version of libX11. To avoid both
10481 crash and memory leak, we dissociate the database from the
10482 display and then destroy dpyinfo->xrdb ourselves.
10484 Unfortunately, the above strategy does not work in some
10485 situations due to a bug in newer versions of libX11: because
10486 XrmSetDatabase doesn't clear the flag XlibDisplayDfltRMDB if
10487 dpy->db is NULL, XCloseDisplay destroys the associated
10488 database whereas it has not been created by XGetDefault
10489 (Bug#21974 in freedesktop.org Bugzilla). As a workaround, we
10490 don't destroy the database here in order to avoid the crash
10491 in the above situations for now, though that may cause memory
10492 leaks in other situations. */
10494 #ifdef HAVE_XRMSETDATABASE
10495 XrmSetDatabase (dpyinfo
->display
, NULL
);
10497 dpyinfo
->display
->db
= NULL
;
10499 /* We used to call XrmDestroyDatabase from x_delete_display, but
10500 some older versions of libX11 crash if we call it after
10501 closing all the displays. */
10502 XrmDestroyDatabase (dpyinfo
->xrdb
);
10506 xg_display_close (dpyinfo
->display
);
10508 #ifdef USE_X_TOOLKIT
10509 XtCloseDisplay (dpyinfo
->display
);
10511 XCloseDisplay (dpyinfo
->display
);
10513 #endif /* ! USE_GTK */
10516 /* Mark as dead. */
10517 dpyinfo
->display
= NULL
;
10518 x_delete_display (dpyinfo
);
10522 /* Create a struct terminal, initialize it with the X11 specific
10523 functions and make DISPLAY->TERMINAL point to it. */
10525 static struct terminal
*
10526 x_create_terminal (struct x_display_info
*dpyinfo
)
10528 struct terminal
*terminal
;
10530 terminal
= create_terminal ();
10532 terminal
->type
= output_x_window
;
10533 terminal
->display_info
.x
= dpyinfo
;
10534 dpyinfo
->terminal
= terminal
;
10536 /* kboard is initialized in x_term_init. */
10538 terminal
->clear_frame_hook
= x_clear_frame
;
10539 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
10540 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
10541 terminal
->ring_bell_hook
= XTring_bell
;
10542 terminal
->toggle_invisible_pointer_hook
= XTtoggle_invisible_pointer
;
10543 terminal
->reset_terminal_modes_hook
= XTreset_terminal_modes
;
10544 terminal
->set_terminal_modes_hook
= XTset_terminal_modes
;
10545 terminal
->update_begin_hook
= x_update_begin
;
10546 terminal
->update_end_hook
= x_update_end
;
10547 terminal
->set_terminal_window_hook
= XTset_terminal_window
;
10548 terminal
->read_socket_hook
= XTread_socket
;
10549 terminal
->frame_up_to_date_hook
= XTframe_up_to_date
;
10550 terminal
->mouse_position_hook
= XTmouse_position
;
10551 terminal
->frame_rehighlight_hook
= XTframe_rehighlight
;
10552 terminal
->frame_raise_lower_hook
= XTframe_raise_lower
;
10553 terminal
->fullscreen_hook
= XTfullscreen_hook
;
10554 terminal
->set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
10555 terminal
->condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
10556 terminal
->redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
10557 terminal
->judge_scroll_bars_hook
= XTjudge_scroll_bars
;
10559 terminal
->delete_frame_hook
= x_destroy_window
;
10560 terminal
->delete_terminal_hook
= x_delete_terminal
;
10562 terminal
->rif
= &x_redisplay_interface
;
10563 terminal
->scroll_region_ok
= 1; /* We'll scroll partial frames. */
10564 terminal
->char_ins_del_ok
= 1;
10565 terminal
->line_ins_del_ok
= 1; /* We'll just blt 'em. */
10566 terminal
->fast_clear_end_of_line
= 1; /* X does this well. */
10567 terminal
->memory_below_frame
= 0; /* We don't remember what scrolls
10574 x_initialize (void)
10579 last_tool_bar_item
= -1;
10580 any_help_event_p
= 0;
10581 ignore_next_mouse_click_timeout
= 0;
10584 current_count
= -1;
10587 /* Try to use interrupt input; if we can't, then start polling. */
10588 Fset_input_interrupt_mode (Qt
);
10590 #ifdef USE_X_TOOLKIT
10591 XtToolkitInitialize ();
10593 Xt_app_con
= XtCreateApplicationContext ();
10595 /* Register a converter from strings to pixels, which uses
10596 Emacs' color allocation infrastructure. */
10597 XtAppSetTypeConverter (Xt_app_con
,
10598 XtRString
, XtRPixel
, cvt_string_to_pixel
,
10599 cvt_string_to_pixel_args
,
10600 XtNumber (cvt_string_to_pixel_args
),
10601 XtCacheByDisplay
, cvt_pixel_dtor
);
10603 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
10606 #ifdef USE_TOOLKIT_SCROLL_BARS
10608 xaw3d_arrow_scroll
= False
;
10609 xaw3d_pick_top
= True
;
10613 pending_autoraise_frame
= 0;
10614 pending_event_wait
.f
= 0;
10615 pending_event_wait
.eventtype
= 0;
10617 /* Note that there is no real way portable across R3/R4 to get the
10618 original error handler. */
10619 XSetErrorHandler (x_error_handler
);
10620 XSetIOErrorHandler (x_io_error_quitter
);
10622 signal (SIGPIPE
, x_connection_signal
);
10624 xgselect_initialize ();
10629 syms_of_xterm (void)
10631 x_error_message
= NULL
;
10633 staticpro (&x_display_name_list
);
10634 x_display_name_list
= Qnil
;
10636 staticpro (&last_mouse_scroll_bar
);
10637 last_mouse_scroll_bar
= Qnil
;
10639 staticpro (&Qvendor_specific_keysyms
);
10640 Qvendor_specific_keysyms
= intern_c_string ("vendor-specific-keysyms");
10642 staticpro (&Qlatin_1
);
10643 Qlatin_1
= intern_c_string ("latin-1");
10645 staticpro (&last_mouse_press_frame
);
10646 last_mouse_press_frame
= Qnil
;
10649 xg_default_icon_file
= make_pure_c_string ("icons/hicolor/scalable/apps/emacs.svg");
10650 staticpro (&xg_default_icon_file
);
10652 Qx_gtk_map_stock
= intern_c_string ("x-gtk-map-stock");
10653 staticpro (&Qx_gtk_map_stock
);
10656 DEFVAR_BOOL ("x-use-underline-position-properties",
10657 x_use_underline_position_properties
,
10658 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
10659 A value of nil means ignore them. If you encounter fonts with bogus
10660 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
10661 to 4.1, set this to nil. You can also use `underline-minimum-offset'
10662 to override the font's UNDERLINE_POSITION for small font display
10664 x_use_underline_position_properties
= 1;
10666 DEFVAR_BOOL ("x-underline-at-descent-line",
10667 x_underline_at_descent_line
,
10668 doc
: /* *Non-nil means to draw the underline at the same place as the descent line.
10669 A value of nil means to draw the underline according to the value of the
10670 variable `x-use-underline-position-properties', which is usually at the
10671 baseline level. The default value is nil. */);
10672 x_underline_at_descent_line
= 0;
10674 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
10675 x_mouse_click_focus_ignore_position
,
10676 doc
: /* Non-nil means that a mouse click to focus a frame does not move point.
10677 This variable is only used when the window manager requires that you
10678 click on a frame to select it (give it focus). In that case, a value
10679 of nil, means that the selected window and cursor position changes to
10680 reflect the mouse click position, while a non-nil value means that the
10681 selected window or cursor position is preserved. */);
10682 x_mouse_click_focus_ignore_position
= 0;
10684 DEFVAR_LISP ("x-toolkit-scroll-bars", Vx_toolkit_scroll_bars
,
10685 doc
: /* Which toolkit scroll bars Emacs uses, if any.
10686 A value of nil means Emacs doesn't use toolkit scroll bars.
10687 With the X Window system, the value is a symbol describing the
10688 X toolkit. Possible values are: gtk, motif, xaw, or xaw3d.
10689 With MS Windows, the value is t. */);
10690 #ifdef USE_TOOLKIT_SCROLL_BARS
10692 Vx_toolkit_scroll_bars
= intern_c_string ("motif");
10693 #elif defined HAVE_XAW3D
10694 Vx_toolkit_scroll_bars
= intern_c_string ("xaw3d");
10696 Vx_toolkit_scroll_bars
= intern_c_string ("gtk");
10698 Vx_toolkit_scroll_bars
= intern_c_string ("xaw");
10701 Vx_toolkit_scroll_bars
= Qnil
;
10704 staticpro (&last_mouse_motion_frame
);
10705 last_mouse_motion_frame
= Qnil
;
10707 Qmodifier_value
= intern_c_string ("modifier-value");
10708 Qalt
= intern_c_string ("alt");
10709 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
10710 Qhyper
= intern_c_string ("hyper");
10711 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
10712 Qmeta
= intern_c_string ("meta");
10713 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
10714 Qsuper
= intern_c_string ("super");
10715 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
10717 DEFVAR_LISP ("x-alt-keysym", Vx_alt_keysym
,
10718 doc
: /* Which keys Emacs uses for the alt modifier.
10719 This should be one of the symbols `alt', `hyper', `meta', `super'.
10720 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
10721 is nil, which is the same as `alt'. */);
10722 Vx_alt_keysym
= Qnil
;
10724 DEFVAR_LISP ("x-hyper-keysym", Vx_hyper_keysym
,
10725 doc
: /* Which keys Emacs uses for the hyper modifier.
10726 This should be one of the symbols `alt', `hyper', `meta', `super'.
10727 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
10728 default is nil, which is the same as `hyper'. */);
10729 Vx_hyper_keysym
= Qnil
;
10731 DEFVAR_LISP ("x-meta-keysym", Vx_meta_keysym
,
10732 doc
: /* Which keys Emacs uses for the meta modifier.
10733 This should be one of the symbols `alt', `hyper', `meta', `super'.
10734 For example, `meta' means use the Meta_L and Meta_R keysyms. The
10735 default is nil, which is the same as `meta'. */);
10736 Vx_meta_keysym
= Qnil
;
10738 DEFVAR_LISP ("x-super-keysym", Vx_super_keysym
,
10739 doc
: /* Which keys Emacs uses for the super modifier.
10740 This should be one of the symbols `alt', `hyper', `meta', `super'.
10741 For example, `super' means use the Super_L and Super_R keysyms. The
10742 default is nil, which is the same as `super'. */);
10743 Vx_super_keysym
= Qnil
;
10745 DEFVAR_LISP ("x-keysym-table", Vx_keysym_table
,
10746 doc
: /* Hash table of character codes indexed by X keysym codes. */);
10747 Vx_keysym_table
= make_hash_table (Qeql
, make_number (900),
10748 make_float (DEFAULT_REHASH_SIZE
),
10749 make_float (DEFAULT_REHASH_THRESHOLD
),
10753 #endif /* HAVE_X_WINDOWS */