1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1989, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
3 2002, 2003, 2004, 2005 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 2, or (at your option)
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; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
22 /* New display code by Gerd Moellmann <gerd@gnu.org>. */
23 /* Xt features made by Fred Pierresteguy. */
27 /* On 4.3 these lose if they come after xterm.h. */
28 /* Putting these at the beginning seems to be standard for other .c files. */
36 #include "blockinput.h"
38 /* Need syssignal.h for various externs and definitions that may be required
39 by some configurations for calls to signal later in this source file. */
40 #include "syssignal.h"
42 /* This may include sys/types.h, and that somehow loses
43 if this is not done before the other system files. */
45 #include <X11/cursorfont.h>
47 /* Load sys/types.h if not already loaded.
48 In some systems loading it twice is suicidal. */
50 #include <sys/types.h>
54 #include <sys/ioctl.h>
55 #endif /* ! defined (BSD_SYSTEM) */
59 #ifndef INCLUDED_FCNTL
66 /* Caused redefinition of DBL_DIG on Netbsd; seems not to be needed. */
67 /* #include <sys/param.h> */
73 #include "dispextern.h"
75 #include "termhooks.h"
83 #include "intervals.h"
89 #include <X11/Shell.h>
92 #ifdef HAVE_SYS_TIME_H
104 extern int xlwmenu_window_p
P_ ((Widget w
, Window window
));
105 extern void xlwmenu_redisplay
P_ ((Widget
));
108 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
110 extern void free_frame_menubar
P_ ((struct frame
*));
111 extern struct frame
*x_menubar_window_to_frame
P_ ((struct x_display_info
*,
116 #if (XtSpecificationRelease >= 5) && !defined(NO_EDITRES)
118 extern void _XEditResCheckMessages ();
119 #endif /* not NO_EDITRES */
121 /* Include toolkit specific headers for the scroll bar widget. */
123 #ifdef USE_TOOLKIT_SCROLL_BARS
124 #if defined USE_MOTIF
125 #include <Xm/Xm.h> /* for LESSTIF_VERSION */
126 #include <Xm/ScrollBar.h>
127 #else /* !USE_MOTIF i.e. use Xaw */
130 #include <X11/Xaw3d/Simple.h>
131 #include <X11/Xaw3d/Scrollbar.h>
132 #include <X11/Xaw3d/ThreeD.h>
133 #else /* !HAVE_XAW3D */
134 #include <X11/Xaw/Simple.h>
135 #include <X11/Xaw/Scrollbar.h>
136 #endif /* !HAVE_XAW3D */
138 #define XtNpickTop "pickTop"
139 #endif /* !XtNpickTop */
140 #endif /* !USE_MOTIF */
141 #endif /* USE_TOOLKIT_SCROLL_BARS */
143 #endif /* USE_X_TOOLKIT */
145 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
146 #define x_any_window_to_frame x_window_to_frame
147 #define x_top_window_to_frame x_window_to_frame
152 #ifndef XtNinitialState
153 #define XtNinitialState "initialState"
157 #define abs(x) ((x) < 0 ? -(x) : (x))
159 /* Default to using XIM if available. */
163 int use_xim
= 0; /* configure --without-xim */
168 /* Non-nil means Emacs uses toolkit scroll bars. */
170 Lisp_Object Vx_toolkit_scroll_bars
;
172 /* Non-zero means that a HELP_EVENT has been generated since Emacs
175 static int any_help_event_p
;
177 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
178 static Lisp_Object last_window
;
180 /* Non-zero means make use of UNDERLINE_POSITION font properties. */
182 int x_use_underline_position_properties
;
184 /* This is a chain of structures for all the X displays currently in
187 struct x_display_info
*x_display_list
;
189 /* This is a list of cons cells, each of the form (NAME
190 . FONT-LIST-CACHE), one for each element of x_display_list and in
191 the same order. NAME is the name of the frame. FONT-LIST-CACHE
192 records previous values returned by x-list-fonts. */
194 Lisp_Object x_display_name_list
;
196 /* Frame being updated by update_frame. This is declared in term.c.
197 This is set by update_begin and looked at by all the XT functions.
198 It is zero while not inside an update. In that case, the XT
199 functions assume that `selected_frame' is the frame to apply to. */
201 extern struct frame
*updating_frame
;
203 /* This is a frame waiting to be auto-raised, within XTread_socket. */
205 struct frame
*pending_autoraise_frame
;
208 /* The application context for Xt use. */
209 XtAppContext Xt_app_con
;
210 static String Xt_default_resources
[] = {0};
211 #endif /* USE_X_TOOLKIT */
213 /* Non-zero means user is interacting with a toolkit scroll bar. */
215 static int toolkit_scroll_bar_interaction
;
217 /* Non-zero means to not move point as a result of clicking on a
218 frame to focus it (when focus-follows-mouse is nil). */
220 int x_mouse_click_focus_ignore_position
;
222 /* Non-zero timeout value means ignore next mouse click if it arrives
223 before that timeout elapses (i.e. as part of the same sequence of
224 events resulting from clicking on a frame to select it). */
226 static unsigned long ignore_next_mouse_click_timeout
;
230 Formerly, we used PointerMotionHintMask (in standard_event_mask)
231 so that we would have to call XQueryPointer after each MotionNotify
232 event to ask for another such event. However, this made mouse tracking
233 slow, and there was a bug that made it eventually stop.
235 Simply asking for MotionNotify all the time seems to work better.
237 In order to avoid asking for motion events and then throwing most
238 of them away or busy-polling the server for mouse positions, we ask
239 the server for pointer motion hints. This means that we get only
240 one event per group of mouse movements. "Groups" are delimited by
241 other kinds of events (focus changes and button clicks, for
242 example), or by XQueryPointer calls; when one of these happens, we
243 get another MotionNotify event the next time the mouse moves. This
244 is at least as efficient as getting motion events when mouse
245 tracking is on, and I suspect only negligibly worse when tracking
248 /* Where the mouse was last time we reported a mouse event. */
250 static XRectangle last_mouse_glyph
;
251 static FRAME_PTR last_mouse_glyph_frame
;
252 static Lisp_Object last_mouse_press_frame
;
254 /* The scroll bar in which the last X motion event occurred.
256 If the last X motion event occurred in a scroll bar, we set this so
257 XTmouse_position can know whether to report a scroll bar motion or
260 If the last X motion event didn't occur in a scroll bar, we set
261 this to Qnil, to tell XTmouse_position to return an ordinary motion
264 static Lisp_Object last_mouse_scroll_bar
;
266 /* This is a hack. We would really prefer that XTmouse_position would
267 return the time associated with the position it returns, but there
268 doesn't seem to be any way to wrest the time-stamp from the server
269 along with the position query. So, we just keep track of the time
270 of the last movement we received, and return that in hopes that
271 it's somewhat accurate. */
273 static Time last_mouse_movement_time
;
275 /* Incremented by XTread_socket whenever it really tries to read
279 static int volatile input_signal_count
;
281 static int input_signal_count
;
284 /* Used locally within XTread_socket. */
286 static int x_noop_count
;
288 /* Initial values of argv and argc. */
290 extern char **initial_argv
;
291 extern int initial_argc
;
293 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
295 /* Tells if a window manager is present or not. */
297 extern Lisp_Object Vx_no_window_manager
;
299 extern Lisp_Object Qeql
;
303 /* A mask of extra modifier bits to put into every keyboard char. */
305 extern EMACS_INT extra_keyboard_modifiers
;
307 /* The keysyms to use for the various modifiers. */
309 Lisp_Object Vx_alt_keysym
, Vx_hyper_keysym
, Vx_meta_keysym
, Vx_super_keysym
;
310 Lisp_Object Vx_keysym_table
;
311 static Lisp_Object Qalt
, Qhyper
, Qmeta
, Qsuper
, Qmodifier_value
;
313 static Lisp_Object Qvendor_specific_keysyms
;
314 static Lisp_Object Qlatin_1
;
316 /* Used in x_flush. */
318 extern Lisp_Object Vinhibit_redisplay
;
320 extern XrmDatabase x_load_resources
P_ ((Display
*, char *, char *, char *));
321 extern int x_bitmap_mask
P_ ((FRAME_PTR
, int));
323 static int x_alloc_nearest_color_1
P_ ((Display
*, Colormap
, XColor
*));
324 static void x_set_window_size_1
P_ ((struct frame
*, int, int, int));
325 static const XColor
*x_color_cells
P_ ((Display
*, int *));
326 static void x_update_window_end
P_ ((struct window
*, int, int));
327 void x_delete_display
P_ ((struct x_display_info
*));
328 static unsigned int x_x_to_emacs_modifiers
P_ ((struct x_display_info
*,
330 static int x_io_error_quitter
P_ ((Display
*));
331 int x_catch_errors
P_ ((Display
*));
332 void x_uncatch_errors
P_ ((Display
*, int));
333 void x_lower_frame
P_ ((struct frame
*));
334 void x_scroll_bar_clear
P_ ((struct frame
*));
335 int x_had_errors_p
P_ ((Display
*));
336 void x_wm_set_size_hint
P_ ((struct frame
*, long, int));
337 void x_raise_frame
P_ ((struct frame
*));
338 void x_set_window_size
P_ ((struct frame
*, int, int, int));
339 void x_wm_set_window_state
P_ ((struct frame
*, int));
340 void x_wm_set_icon_pixmap
P_ ((struct frame
*, int));
341 static struct terminal
*x_create_terminal
P_ ((struct x_display_info
*));
342 void x_delete_terminal
P_ ((struct terminal
*));
343 void x_initialize
P_ ((void));
344 static void x_font_min_bounds
P_ ((XFontStruct
*, int *, int *));
345 static int x_compute_min_glyph_bounds
P_ ((struct frame
*));
346 static void x_update_end
P_ ((struct frame
*));
347 static void XTframe_up_to_date
P_ ((struct frame
*));
348 static void XTset_terminal_modes
P_ ((struct terminal
*));
349 static void XTreset_terminal_modes
P_ ((struct terminal
*));
350 static void x_clear_frame
P_ ((struct frame
*));
351 static void frame_highlight
P_ ((struct frame
*));
352 static void frame_unhighlight
P_ ((struct frame
*));
353 static void x_new_focus_frame
P_ ((struct x_display_info
*, struct frame
*));
354 static void x_focus_changed
P_ ((int, int, struct x_display_info
*,
355 struct frame
*, struct input_event
*));
356 static void x_detect_focus_change
P_ ((struct x_display_info
*,
357 XEvent
*, struct input_event
*));
358 static void XTframe_rehighlight
P_ ((struct frame
*));
359 static void x_frame_rehighlight
P_ ((struct x_display_info
*));
360 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
361 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int,
362 enum text_cursor_kinds
));
364 static void x_clip_to_row
P_ ((struct window
*, struct glyph_row
*, int, GC
));
365 static void x_flush
P_ ((struct frame
*f
));
366 static void x_update_begin
P_ ((struct frame
*));
367 static void x_update_window_begin
P_ ((struct window
*));
368 static void x_after_update_window_line
P_ ((struct glyph_row
*));
369 static struct scroll_bar
*x_window_to_scroll_bar
P_ ((Display
*, Window
));
370 static void x_scroll_bar_report_motion
P_ ((struct frame
**, Lisp_Object
*,
371 enum scroll_bar_part
*,
372 Lisp_Object
*, Lisp_Object
*,
374 static void x_check_fullscreen
P_ ((struct frame
*));
375 static void x_check_expected_move
P_ ((struct frame
*));
376 static int handle_one_xevent
P_ ((struct x_display_info
*, XEvent
*,
377 int *, struct input_event
*));
380 /* Flush display of frame F, or of all frames if F is null. */
386 /* Don't call XFlush when it is not safe to redisplay; the X
387 connection may be broken. */
388 if (!NILP (Vinhibit_redisplay
))
394 Lisp_Object rest
, frame
;
395 FOR_EACH_FRAME (rest
, frame
)
396 if (FRAME_X_P (XFRAME (frame
)))
397 x_flush (XFRAME (frame
));
399 else if (FRAME_X_P (f
))
400 XFlush (FRAME_X_DISPLAY (f
));
405 /* Remove calls to XFlush by defining XFlush to an empty replacement.
406 Calls to XFlush should be unnecessary because the X output buffer
407 is flushed automatically as needed by calls to XPending,
408 XNextEvent, or XWindowEvent according to the XFlush man page.
409 XTread_socket calls XPending. Removing XFlush improves
412 #define XFlush(DISPLAY) (void) 0
415 /***********************************************************************
417 ***********************************************************************/
421 /* This is a function useful for recording debugging information about
422 the sequence of occurrences in this file. */
430 struct record event_record
[100];
432 int event_record_index
;
434 record_event (locus
, type
)
438 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
439 event_record_index
= 0;
441 event_record
[event_record_index
].locus
= locus
;
442 event_record
[event_record_index
].type
= type
;
443 event_record_index
++;
450 /* Return the struct x_display_info corresponding to DPY. */
452 struct x_display_info
*
453 x_display_info_for_display (dpy
)
456 struct x_display_info
*dpyinfo
;
458 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
459 if (dpyinfo
->display
== dpy
)
467 /***********************************************************************
468 Starting and ending an update
469 ***********************************************************************/
471 /* Start an update of frame F. This function is installed as a hook
472 for update_begin, i.e. it is called when update_begin is called.
473 This function is called prior to calls to x_update_window_begin for
474 each window being updated. Currently, there is nothing to do here
475 because all interesting stuff is done on a window basis. */
485 /* Start update of window W. Set the global variable updated_window
486 to the window being updated and set output_cursor to the cursor
490 x_update_window_begin (w
)
493 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
494 struct x_display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
497 set_output_cursor (&w
->cursor
);
501 if (f
== display_info
->mouse_face_mouse_frame
)
503 /* Don't do highlighting for mouse motion during the update. */
504 display_info
->mouse_face_defer
= 1;
506 /* If F needs to be redrawn, simply forget about any prior mouse
508 if (FRAME_GARBAGED_P (f
))
509 display_info
->mouse_face_window
= Qnil
;
511 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
512 their mouse_face_p flag set, which means that they are always
513 unequal to rows in a desired matrix which never have that
514 flag set. So, rows containing mouse-face glyphs are never
515 scrolled, and we don't have to switch the mouse highlight off
516 here to prevent it from being scrolled. */
518 /* Can we tell that this update does not affect the window
519 where the mouse highlight is? If so, no need to turn off.
520 Likewise, don't do anything if the frame is garbaged;
521 in that case, the frame's current matrix that we would use
522 is all wrong, and we will redisplay that line anyway. */
523 if (!NILP (display_info
->mouse_face_window
)
524 && w
== XWINDOW (display_info
->mouse_face_window
))
528 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
529 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
532 if (i
< w
->desired_matrix
->nrows
)
533 clear_mouse_face (display_info
);
542 /* Draw a vertical window border from (x,y0) to (x,y1) */
545 x_draw_vertical_window_border (w
, x
, y0
, y1
)
549 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
552 face
= FACE_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
554 XSetForeground (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
557 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
558 f
->output_data
.x
->normal_gc
, x
, y0
, x
, y1
);
561 /* End update of window W (which is equal to updated_window).
563 Draw vertical borders between horizontally adjacent windows, and
564 display W's cursor if CURSOR_ON_P is non-zero.
566 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
567 glyphs in mouse-face were overwritten. In that case we have to
568 make sure that the mouse-highlight is properly redrawn.
570 W may be a menu bar pseudo-window in case we don't have X toolkit
571 support. Such windows don't have a cursor, so don't display it
575 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
577 int cursor_on_p
, mouse_face_overwritten_p
;
579 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
581 if (!w
->pseudo_window_p
)
586 display_and_set_cursor (w
, 1, output_cursor
.hpos
,
588 output_cursor
.x
, output_cursor
.y
);
590 if (draw_window_fringes (w
, 1))
591 x_draw_vertical_border (w
);
596 /* If a row with mouse-face was overwritten, arrange for
597 XTframe_up_to_date to redisplay the mouse highlight. */
598 if (mouse_face_overwritten_p
)
600 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
601 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
602 dpyinfo
->mouse_face_window
= Qnil
;
605 updated_window
= NULL
;
609 /* End update of frame F. This function is installed as a hook in
616 /* Mouse highlight may be displayed again. */
617 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
621 XFlush (FRAME_X_DISPLAY (f
));
627 /* This function is called from various places in xdisp.c whenever a
628 complete update has been performed. The global variable
629 updated_window is not available here. */
632 XTframe_up_to_date (f
)
637 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
639 if (dpyinfo
->mouse_face_deferred_gc
640 || f
== dpyinfo
->mouse_face_mouse_frame
)
643 if (dpyinfo
->mouse_face_mouse_frame
)
644 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
645 dpyinfo
->mouse_face_mouse_x
,
646 dpyinfo
->mouse_face_mouse_y
);
647 dpyinfo
->mouse_face_deferred_gc
= 0;
654 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
655 arrow bitmaps, or clear the fringes if no bitmaps are required
656 before DESIRED_ROW is made current. The window being updated is
657 found in updated_window. This function It is called from
658 update_window_line only if it is known that there are differences
659 between bitmaps to be drawn between current row and DESIRED_ROW. */
662 x_after_update_window_line (desired_row
)
663 struct glyph_row
*desired_row
;
665 struct window
*w
= updated_window
;
671 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
672 desired_row
->redraw_fringe_bitmaps_p
= 1;
674 /* When a window has disappeared, make sure that no rest of
675 full-width rows stays visible in the internal border. Could
676 check here if updated_window is the leftmost/rightmost window,
677 but I guess it's not worth doing since vertically split windows
678 are almost never used, internal border is rarely set, and the
679 overhead is very small. */
680 if (windows_or_buffers_changed
681 && desired_row
->full_width_p
682 && (f
= XFRAME (w
->frame
),
683 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
685 && (height
= desired_row
->visible_height
,
688 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
690 /* Internal border is drawn below the tool bar. */
691 if (WINDOWP (f
->tool_bar_window
)
692 && w
== XWINDOW (f
->tool_bar_window
))
696 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
697 0, y
, width
, height
, False
);
698 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
699 FRAME_PIXEL_WIDTH (f
) - width
,
700 y
, width
, height
, False
);
706 x_draw_fringe_bitmap (w
, row
, p
)
708 struct glyph_row
*row
;
709 struct draw_fringe_bitmap_params
*p
;
711 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
712 Display
*display
= FRAME_X_DISPLAY (f
);
713 Window window
= FRAME_X_WINDOW (f
);
714 GC gc
= f
->output_data
.x
->normal_gc
;
715 struct face
*face
= p
->face
;
718 /* Must clip because of partially visible lines. */
719 rowY
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
722 /* Adjust position of "bottom aligned" bitmap on partially
725 int oldVH
= row
->visible_height
;
726 row
->visible_height
= p
->h
;
727 row
->y
-= rowY
- p
->y
;
728 x_clip_to_row (w
, row
, -1, gc
);
730 row
->visible_height
= oldVH
;
733 x_clip_to_row (w
, row
, -1, gc
);
735 if (p
->bx
>= 0 && !p
->overlay_p
)
737 /* In case the same realized face is used for fringes and
738 for something displayed in the text (e.g. face `region' on
739 mono-displays, the fill style may have been changed to
740 FillSolid in x_draw_glyph_string_background. */
742 XSetFillStyle (display
, face
->gc
, FillOpaqueStippled
);
744 XSetForeground (display
, face
->gc
, face
->background
);
746 XFillRectangle (display
, window
, face
->gc
,
747 p
->bx
, p
->by
, p
->nx
, p
->ny
);
750 XSetForeground (display
, face
->gc
, face
->foreground
);
756 Pixmap pixmap
, clipmask
= (Pixmap
) 0;
757 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
761 bits
= (unsigned char *)(p
->bits
+ p
->dh
);
763 bits
= (unsigned char *)p
->bits
+ p
->dh
;
765 /* Draw the bitmap. I believe these small pixmaps can be cached
767 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, p
->wd
, p
->h
,
769 ? (p
->overlay_p
? face
->background
770 : f
->output_data
.x
->cursor_pixel
)
772 face
->background
, depth
);
776 clipmask
= XCreatePixmapFromBitmapData (display
,
777 FRAME_X_DISPLAY_INFO (f
)->root_window
,
780 gcv
.clip_mask
= clipmask
;
781 gcv
.clip_x_origin
= p
->x
;
782 gcv
.clip_y_origin
= p
->y
;
783 XChangeGC (display
, gc
, GCClipMask
| GCClipXOrigin
| GCClipYOrigin
, &gcv
);
786 XCopyArea (display
, pixmap
, window
, gc
, 0, 0,
787 p
->wd
, p
->h
, p
->x
, p
->y
);
788 XFreePixmap (display
, pixmap
);
792 gcv
.clip_mask
= (Pixmap
) 0;
793 XChangeGC (display
, gc
, GCClipMask
, &gcv
);
794 XFreePixmap (display
, clipmask
);
798 XSetClipMask (display
, gc
, None
);
803 /* This is called when starting Emacs and when restarting after
804 suspend. When starting Emacs, no X window is mapped. And nothing
805 must be done to Emacs's own window if it is suspended (though that
809 XTset_terminal_modes (struct terminal
*terminal
)
813 /* This is called when exiting or suspending Emacs. Exiting will make
814 the X-windows go away, and suspending requires no action. */
817 XTreset_terminal_modes (struct terminal
*terminal
)
823 /***********************************************************************
825 ***********************************************************************/
827 /* Function prototypes of this page. */
829 static int x_encode_char
P_ ((int, XChar2b
*, struct font_info
*, int *));
832 /* Get metrics of character CHAR2B in FONT. Value is null if CHAR2B
833 is not contained in the font. */
836 x_per_char_metric (font
, char2b
, font_type
)
839 int font_type
; /* unused on X */
841 /* The result metric information. */
842 XCharStruct
*pcm
= NULL
;
844 xassert (font
&& char2b
);
846 if (font
->per_char
!= NULL
)
848 if (font
->min_byte1
== 0 && font
->max_byte1
== 0)
850 /* min_char_or_byte2 specifies the linear character index
851 corresponding to the first element of the per_char array,
852 max_char_or_byte2 is the index of the last character. A
853 character with non-zero CHAR2B->byte1 is not in the font.
854 A character with byte2 less than min_char_or_byte2 or
855 greater max_char_or_byte2 is not in the font. */
856 if (char2b
->byte1
== 0
857 && char2b
->byte2
>= font
->min_char_or_byte2
858 && char2b
->byte2
<= font
->max_char_or_byte2
)
859 pcm
= font
->per_char
+ char2b
->byte2
- font
->min_char_or_byte2
;
863 /* If either min_byte1 or max_byte1 are nonzero, both
864 min_char_or_byte2 and max_char_or_byte2 are less than
865 256, and the 2-byte character index values corresponding
866 to the per_char array element N (counting from 0) are:
868 byte1 = N/D + min_byte1
869 byte2 = N\D + min_char_or_byte2
873 D = max_char_or_byte2 - min_char_or_byte2 + 1
875 \ = integer modulus */
876 if (char2b
->byte1
>= font
->min_byte1
877 && char2b
->byte1
<= font
->max_byte1
878 && char2b
->byte2
>= font
->min_char_or_byte2
879 && char2b
->byte2
<= font
->max_char_or_byte2
)
881 pcm
= (font
->per_char
882 + ((font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1)
883 * (char2b
->byte1
- font
->min_byte1
))
884 + (char2b
->byte2
- font
->min_char_or_byte2
));
890 /* If the per_char pointer is null, all glyphs between the first
891 and last character indexes inclusive have the same
892 information, as given by both min_bounds and max_bounds. */
893 if (char2b
->byte2
>= font
->min_char_or_byte2
894 && char2b
->byte2
<= font
->max_char_or_byte2
)
895 pcm
= &font
->max_bounds
;
899 || (pcm
->width
== 0 && (pcm
->rbearing
- pcm
->lbearing
) == 0))
904 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
905 the two-byte form of C. Encoding is returned in *CHAR2B. */
908 x_encode_char (c
, char2b
, font_info
, two_byte_p
)
911 struct font_info
*font_info
;
914 int charset
= CHAR_CHARSET (c
);
915 XFontStruct
*font
= font_info
->font
;
917 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
918 This may be either a program in a special encoder language or a
920 if (font_info
->font_encoder
)
922 /* It's a program. */
923 struct ccl_program
*ccl
= font_info
->font_encoder
;
925 check_ccl_update (ccl
);
926 if (CHARSET_DIMENSION (charset
) == 1)
928 ccl
->reg
[0] = charset
;
929 ccl
->reg
[1] = char2b
->byte2
;
934 ccl
->reg
[0] = charset
;
935 ccl
->reg
[1] = char2b
->byte1
;
936 ccl
->reg
[2] = char2b
->byte2
;
939 ccl_driver (ccl
, NULL
, NULL
, 0, 0, NULL
);
941 /* We assume that MSBs are appropriately set/reset by CCL
943 if (font
->max_byte1
== 0) /* 1-byte font */
944 char2b
->byte1
= 0, char2b
->byte2
= ccl
->reg
[1];
946 char2b
->byte1
= ccl
->reg
[1], char2b
->byte2
= ccl
->reg
[2];
948 else if (font_info
->encoding
[charset
])
950 /* Fixed encoding scheme. See fontset.h for the meaning of the
952 int enc
= font_info
->encoding
[charset
];
954 if ((enc
== 1 || enc
== 2)
955 && CHARSET_DIMENSION (charset
) == 2)
956 char2b
->byte1
|= 0x80;
958 if (enc
== 1 || enc
== 3)
959 char2b
->byte2
|= 0x80;
963 *two_byte_p
= ((XFontStruct
*) (font_info
->font
))->max_byte1
> 0;
965 return FONT_TYPE_UNKNOWN
;
970 /***********************************************************************
972 ***********************************************************************/
976 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
977 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
978 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
980 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
981 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
982 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
983 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
984 static void x_compute_glyph_string_overhangs
P_ ((struct glyph_string
*));
985 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
986 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
987 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
988 static int x_alloc_lighter_color
P_ ((struct frame
*, Display
*, Colormap
,
989 unsigned long *, double, int));
990 static void x_setup_relief_color
P_ ((struct frame
*, struct relief
*,
991 double, int, unsigned long));
992 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
993 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
994 static void x_draw_image_relief
P_ ((struct glyph_string
*));
995 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
996 static void x_draw_image_foreground_1
P_ ((struct glyph_string
*, Pixmap
));
997 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
999 static void x_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
1000 int, int, int, int, int, int,
1002 static void x_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
1003 int, int, int, XRectangle
*));
1006 static void x_check_font
P_ ((struct frame
*, XFontStruct
*));
1010 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
1015 struct glyph_string
*s
;
1017 if (s
->font
== FRAME_FONT (s
->f
)
1018 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
1019 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
1021 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
1024 /* Cursor on non-default face: must merge. */
1028 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
1029 xgcv
.foreground
= s
->face
->background
;
1031 /* If the glyph would be invisible, try a different foreground. */
1032 if (xgcv
.foreground
== xgcv
.background
)
1033 xgcv
.foreground
= s
->face
->foreground
;
1034 if (xgcv
.foreground
== xgcv
.background
)
1035 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
1036 if (xgcv
.foreground
== xgcv
.background
)
1037 xgcv
.foreground
= s
->face
->foreground
;
1039 /* Make sure the cursor is distinct from text in this face. */
1040 if (xgcv
.background
== s
->face
->background
1041 && xgcv
.foreground
== s
->face
->foreground
)
1043 xgcv
.background
= s
->face
->foreground
;
1044 xgcv
.foreground
= s
->face
->background
;
1047 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1048 xgcv
.font
= s
->font
->fid
;
1049 xgcv
.graphics_exposures
= False
;
1050 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
1052 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1053 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1056 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1057 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
1059 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1064 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1067 x_set_mouse_face_gc (s
)
1068 struct glyph_string
*s
;
1073 /* What face has to be used last for the mouse face? */
1074 face_id
= FRAME_X_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
1075 face
= FACE_FROM_ID (s
->f
, face_id
);
1077 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1079 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1080 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
);
1082 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0);
1083 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1084 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1086 /* If font in this face is same as S->font, use it. */
1087 if (s
->font
== s
->face
->font
)
1088 s
->gc
= s
->face
->gc
;
1091 /* Otherwise construct scratch_cursor_gc with values from FACE
1096 xgcv
.background
= s
->face
->background
;
1097 xgcv
.foreground
= s
->face
->foreground
;
1098 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1099 xgcv
.font
= s
->font
->fid
;
1100 xgcv
.graphics_exposures
= False
;
1101 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
1103 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1104 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1107 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1108 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
1110 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1113 xassert (s
->gc
!= 0);
1117 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1118 Faces to use in the mode line have already been computed when the
1119 matrix was built, so there isn't much to do, here. */
1122 x_set_mode_line_face_gc (s
)
1123 struct glyph_string
*s
;
1125 s
->gc
= s
->face
->gc
;
1129 /* Set S->gc of glyph string S for drawing that glyph string. Set
1130 S->stippled_p to a non-zero value if the face of S has a stipple
1134 x_set_glyph_string_gc (s
)
1135 struct glyph_string
*s
;
1137 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1139 if (s
->hl
== DRAW_NORMAL_TEXT
)
1141 s
->gc
= s
->face
->gc
;
1142 s
->stippled_p
= s
->face
->stipple
!= 0;
1144 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1146 x_set_mode_line_face_gc (s
);
1147 s
->stippled_p
= s
->face
->stipple
!= 0;
1149 else if (s
->hl
== DRAW_CURSOR
)
1151 x_set_cursor_gc (s
);
1154 else if (s
->hl
== DRAW_MOUSE_FACE
)
1156 x_set_mouse_face_gc (s
);
1157 s
->stippled_p
= s
->face
->stipple
!= 0;
1159 else if (s
->hl
== DRAW_IMAGE_RAISED
1160 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1162 s
->gc
= s
->face
->gc
;
1163 s
->stippled_p
= s
->face
->stipple
!= 0;
1167 s
->gc
= s
->face
->gc
;
1168 s
->stippled_p
= s
->face
->stipple
!= 0;
1171 /* GC must have been set. */
1172 xassert (s
->gc
!= 0);
1176 /* Set clipping for output of glyph string S. S may be part of a mode
1177 line or menu if we don't have X toolkit support. */
1180 x_set_glyph_string_clipping (s
)
1181 struct glyph_string
*s
;
1184 get_glyph_string_clip_rect (s
, &r
);
1185 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, &r
, 1, Unsorted
);
1190 Compute left and right overhang of glyph string S. If S is a glyph
1191 string for a composition, assume overhangs don't exist. */
1194 x_compute_glyph_string_overhangs (s
)
1195 struct glyph_string
*s
;
1198 && s
->first_glyph
->type
== CHAR_GLYPH
)
1201 int direction
, font_ascent
, font_descent
;
1202 XTextExtents16 (s
->font
, s
->char2b
, s
->nchars
, &direction
,
1203 &font_ascent
, &font_descent
, &cs
);
1204 s
->right_overhang
= cs
.rbearing
> cs
.width
? cs
.rbearing
- cs
.width
: 0;
1205 s
->left_overhang
= cs
.lbearing
< 0 ? -cs
.lbearing
: 0;
1210 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1213 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
1214 struct glyph_string
*s
;
1218 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
1219 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
1220 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
1221 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
1225 /* Draw the background of glyph_string S. If S->background_filled_p
1226 is non-zero don't draw it. FORCE_P non-zero means draw the
1227 background even if it wouldn't be drawn normally. This is used
1228 when a string preceding S draws into the background of S, or S
1229 contains the first component of a composition. */
1232 x_draw_glyph_string_background (s
, force_p
)
1233 struct glyph_string
*s
;
1236 /* Nothing to do if background has already been drawn or if it
1237 shouldn't be drawn in the first place. */
1238 if (!s
->background_filled_p
)
1240 int box_line_width
= max (s
->face
->box_line_width
, 0);
1244 /* Fill background with a stipple pattern. */
1245 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1246 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1247 s
->y
+ box_line_width
,
1248 s
->background_width
,
1249 s
->height
- 2 * box_line_width
);
1250 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1251 s
->background_filled_p
= 1;
1253 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1254 || s
->font_not_found_p
1255 || s
->extends_to_end_of_line_p
1258 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1259 s
->background_width
,
1260 s
->height
- 2 * box_line_width
);
1261 s
->background_filled_p
= 1;
1267 /* Draw the foreground of glyph string S. */
1270 x_draw_glyph_string_foreground (s
)
1271 struct glyph_string
*s
;
1275 /* If first glyph of S has a left box line, start drawing the text
1276 of S to the right of that box line. */
1277 if (s
->face
->box
!= FACE_NO_BOX
1278 && s
->first_glyph
->left_box_line_p
)
1279 x
= s
->x
+ abs (s
->face
->box_line_width
);
1283 /* Draw characters of S as rectangles if S's font could not be
1285 if (s
->font_not_found_p
)
1287 for (i
= 0; i
< s
->nchars
; ++i
)
1289 struct glyph
*g
= s
->first_glyph
+ i
;
1290 XDrawRectangle (s
->display
, s
->window
,
1291 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1293 x
+= g
->pixel_width
;
1298 char *char1b
= (char *) s
->char2b
;
1299 int boff
= s
->font_info
->baseline_offset
;
1301 if (s
->font_info
->vertical_centering
)
1302 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
1304 /* If we can use 8-bit functions, condense S->char2b. */
1306 for (i
= 0; i
< s
->nchars
; ++i
)
1307 char1b
[i
] = s
->char2b
[i
].byte2
;
1309 /* Draw text with XDrawString if background has already been
1310 filled. Otherwise, use XDrawImageString. (Note that
1311 XDrawImageString is usually faster than XDrawString.) Always
1312 use XDrawImageString when drawing the cursor so that there is
1313 no chance that characters under a box cursor are invisible. */
1315 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1317 /* Draw characters with 16-bit or 8-bit functions. */
1319 XDrawString16 (s
->display
, s
->window
, s
->gc
, x
,
1320 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
1322 XDrawString (s
->display
, s
->window
, s
->gc
, x
,
1323 s
->ybase
- boff
, char1b
, s
->nchars
);
1328 XDrawImageString16 (s
->display
, s
->window
, s
->gc
, x
,
1329 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
1331 XDrawImageString (s
->display
, s
->window
, s
->gc
, x
,
1332 s
->ybase
- boff
, char1b
, s
->nchars
);
1335 if (s
->face
->overstrike
)
1337 /* For overstriking (to simulate bold-face), draw the
1338 characters again shifted to the right by one pixel. */
1340 XDrawString16 (s
->display
, s
->window
, s
->gc
, x
+ 1,
1341 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
1343 XDrawString (s
->display
, s
->window
, s
->gc
, x
+ 1,
1344 s
->ybase
- boff
, char1b
, s
->nchars
);
1349 /* Draw the foreground of composite glyph string S. */
1352 x_draw_composite_glyph_string_foreground (s
)
1353 struct glyph_string
*s
;
1357 /* If first glyph of S has a left box line, start drawing the text
1358 of S to the right of that box line. */
1359 if (s
->face
->box
!= FACE_NO_BOX
1360 && s
->first_glyph
->left_box_line_p
)
1361 x
= s
->x
+ abs (s
->face
->box_line_width
);
1365 /* S is a glyph string for a composition. S->gidx is the index of
1366 the first character drawn for glyphs of this composition.
1367 S->gidx == 0 means we are drawing the very first character of
1368 this composition. */
1370 /* Draw a rectangle for the composition if the font for the very
1371 first character of the composition could not be loaded. */
1372 if (s
->font_not_found_p
)
1375 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, s
->y
,
1376 s
->width
- 1, s
->height
- 1);
1380 for (i
= 0; i
< s
->nchars
; i
++, ++s
->gidx
)
1382 XDrawString16 (s
->display
, s
->window
, s
->gc
,
1383 x
+ s
->cmp
->offsets
[s
->gidx
* 2],
1384 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
1386 if (s
->face
->overstrike
)
1387 XDrawString16 (s
->display
, s
->window
, s
->gc
,
1388 x
+ s
->cmp
->offsets
[s
->gidx
* 2] + 1,
1389 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
1396 #ifdef USE_X_TOOLKIT
1398 static struct frame
*x_frame_of_widget
P_ ((Widget
));
1399 static Boolean cvt_string_to_pixel
P_ ((Display
*, XrmValue
*, Cardinal
*,
1400 XrmValue
*, XrmValue
*, XtPointer
*));
1401 static void cvt_pixel_dtor
P_ ((XtAppContext
, XrmValue
*, XtPointer
,
1402 XrmValue
*, Cardinal
*));
1405 /* Return the frame on which widget WIDGET is used.. Abort if frame
1406 cannot be determined. */
1408 static struct frame
*
1409 x_frame_of_widget (widget
)
1412 struct x_display_info
*dpyinfo
;
1416 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
1418 /* Find the top-level shell of the widget. Note that this function
1419 can be called when the widget is not yet realized, so XtWindow
1420 (widget) == 0. That's the reason we can't simply use
1421 x_any_window_to_frame. */
1422 while (!XtIsTopLevelShell (widget
))
1423 widget
= XtParent (widget
);
1425 /* Look for a frame with that top-level widget. Allocate the color
1426 on that frame to get the right gamma correction value. */
1427 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1428 if (GC_FRAMEP (XCAR (tail
))
1429 && (f
= XFRAME (XCAR (tail
)),
1431 && f
->output_data
.nothing
!= 1
1432 && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
))
1433 && f
->output_data
.x
->widget
== widget
)
1440 /* Allocate the color COLOR->pixel on the screen and display of
1441 widget WIDGET in colormap CMAP. If an exact match cannot be
1442 allocated, try the nearest color available. Value is non-zero
1443 if successful. This is called from lwlib. */
1446 x_alloc_nearest_color_for_widget (widget
, cmap
, color
)
1451 struct frame
*f
= x_frame_of_widget (widget
);
1452 return x_alloc_nearest_color (f
, cmap
, color
);
1456 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1457 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1458 If this produces the same color as PIXEL, try a color where all RGB
1459 values have DELTA added. Return the allocated color in *PIXEL.
1460 DISPLAY is the X display, CMAP is the colormap to operate on.
1461 Value is non-zero if successful. */
1464 x_alloc_lighter_color_for_widget (widget
, display
, cmap
, pixel
, factor
, delta
)
1468 unsigned long *pixel
;
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 (dpy
, args
, nargs
, from
, to
, closure_ret
)
1517 XrmValue
*from
, *to
;
1518 XtPointer
*closure_ret
;
1528 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1529 "wrongParameters", "cvt_string_to_pixel",
1531 "Screen and colormap args required", NULL
, NULL
);
1535 screen
= *(Screen
**) args
[0].addr
;
1536 cmap
= *(Colormap
*) args
[1].addr
;
1537 color_name
= (String
) from
->addr
;
1539 if (strcmp (color_name
, XtDefaultBackground
) == 0)
1541 *closure_ret
= (XtPointer
) False
;
1542 pixel
= WhitePixelOfScreen (screen
);
1544 else if (strcmp (color_name
, XtDefaultForeground
) == 0)
1546 *closure_ret
= (XtPointer
) False
;
1547 pixel
= BlackPixelOfScreen (screen
);
1549 else if (XParseColor (dpy
, cmap
, color_name
, &color
)
1550 && x_alloc_nearest_color_1 (dpy
, cmap
, &color
))
1552 pixel
= color
.pixel
;
1553 *closure_ret
= (XtPointer
) True
;
1558 Cardinal nparams
= 1;
1560 params
[0] = color_name
;
1561 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1562 "badValue", "cvt_string_to_pixel",
1563 "XtToolkitError", "Invalid color `%s'",
1568 if (to
->addr
!= NULL
)
1570 if (to
->size
< sizeof (Pixel
))
1572 to
->size
= sizeof (Pixel
);
1576 *(Pixel
*) to
->addr
= pixel
;
1580 cvt_string_to_pixel_value
= pixel
;
1581 to
->addr
= (XtPointer
) &cvt_string_to_pixel_value
;
1584 to
->size
= sizeof (Pixel
);
1589 /* Free a pixel color which was previously allocated via
1590 cvt_string_to_pixel. This is registered as the destructor
1591 for this type of resource via XtSetTypeConverter.
1593 APP is the application context in which we work.
1595 TO is a pointer to an XrmValue holding the color to free.
1596 CLOSURE is the value we stored in CLOSURE_RET for this color
1597 in cvt_string_to_pixel.
1599 ARGS and NARGS are like for cvt_string_to_pixel. */
1602 cvt_pixel_dtor (app
, to
, closure
, args
, nargs
)
1611 XtAppWarningMsg (app
, "wrongParameters", "cvt_pixel_dtor",
1613 "Screen and colormap arguments required",
1616 else if (closure
!= NULL
)
1618 /* We did allocate the pixel, so free it. */
1619 Screen
*screen
= *(Screen
**) args
[0].addr
;
1620 Colormap cmap
= *(Colormap
*) args
[1].addr
;
1621 x_free_dpy_colors (DisplayOfScreen (screen
), screen
, cmap
,
1622 (Pixel
*) to
->addr
, 1);
1627 #endif /* USE_X_TOOLKIT */
1630 /* Value is an array of XColor structures for the contents of the
1631 color map of display DPY. Set *NCELLS to the size of the array.
1632 Note that this probably shouldn't be called for large color maps,
1633 say a 24-bit TrueColor map. */
1635 static const XColor
*
1636 x_color_cells (dpy
, ncells
)
1640 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1642 if (dpyinfo
->color_cells
== NULL
)
1644 Screen
*screen
= dpyinfo
->screen
;
1647 dpyinfo
->ncolor_cells
1648 = XDisplayCells (dpy
, XScreenNumberOfScreen (screen
));
1649 dpyinfo
->color_cells
1650 = (XColor
*) xmalloc (dpyinfo
->ncolor_cells
1651 * sizeof *dpyinfo
->color_cells
);
1653 for (i
= 0; i
< dpyinfo
->ncolor_cells
; ++i
)
1654 dpyinfo
->color_cells
[i
].pixel
= i
;
1656 XQueryColors (dpy
, dpyinfo
->cmap
,
1657 dpyinfo
->color_cells
, dpyinfo
->ncolor_cells
);
1660 *ncells
= dpyinfo
->ncolor_cells
;
1661 return dpyinfo
->color_cells
;
1665 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1666 colors in COLORS. Use cached information, if available. */
1669 x_query_colors (f
, colors
, ncolors
)
1674 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1676 if (dpyinfo
->color_cells
)
1679 for (i
= 0; i
< ncolors
; ++i
)
1681 unsigned long pixel
= colors
[i
].pixel
;
1682 xassert (pixel
< dpyinfo
->ncolor_cells
);
1683 xassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
1684 colors
[i
] = dpyinfo
->color_cells
[pixel
];
1688 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
1692 /* On frame F, translate pixel color to RGB values for the color in
1693 COLOR. Use cached information, if available. */
1696 x_query_color (f
, color
)
1700 x_query_colors (f
, color
, 1);
1704 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
1705 exact match can't be allocated, try the nearest color available.
1706 Value is non-zero if successful. Set *COLOR to the color
1710 x_alloc_nearest_color_1 (dpy
, cmap
, color
)
1717 rc
= XAllocColor (dpy
, cmap
, color
);
1720 /* If we got to this point, the colormap is full, so we're going
1721 to try to get the next closest color. The algorithm used is
1722 a least-squares matching, which is what X uses for closest
1723 color matching with StaticColor visuals. */
1725 unsigned long nearest_delta
= ~0;
1727 const XColor
*cells
= x_color_cells (dpy
, &ncells
);
1729 for (nearest
= i
= 0; i
< ncells
; ++i
)
1731 long dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
1732 long dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
1733 long dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
1734 unsigned long delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
1736 if (delta
< nearest_delta
)
1739 nearest_delta
= delta
;
1743 color
->red
= cells
[nearest
].red
;
1744 color
->green
= cells
[nearest
].green
;
1745 color
->blue
= cells
[nearest
].blue
;
1746 rc
= XAllocColor (dpy
, cmap
, color
);
1750 /* If allocation succeeded, and the allocated pixel color is not
1751 equal to a cached pixel color recorded earlier, there was a
1752 change in the colormap, so clear the color cache. */
1753 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1754 XColor
*cached_color
;
1756 if (dpyinfo
->color_cells
1757 && (cached_color
= &dpyinfo
->color_cells
[color
->pixel
],
1758 (cached_color
->red
!= color
->red
1759 || cached_color
->blue
!= color
->blue
1760 || cached_color
->green
!= color
->green
)))
1762 xfree (dpyinfo
->color_cells
);
1763 dpyinfo
->color_cells
= NULL
;
1764 dpyinfo
->ncolor_cells
= 0;
1768 #ifdef DEBUG_X_COLORS
1770 register_color (color
->pixel
);
1771 #endif /* DEBUG_X_COLORS */
1777 /* Allocate the color COLOR->pixel on frame F, colormap CMAP. If an
1778 exact match can't be allocated, try the nearest color available.
1779 Value is non-zero if successful. Set *COLOR to the color
1783 x_alloc_nearest_color (f
, cmap
, color
)
1788 gamma_correct (f
, color
);
1789 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f
), cmap
, color
);
1793 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
1794 It's necessary to do this instead of just using PIXEL directly to
1795 get color reference counts right. */
1798 x_copy_color (f
, pixel
)
1800 unsigned long pixel
;
1804 color
.pixel
= pixel
;
1806 x_query_color (f
, &color
);
1807 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
1809 #ifdef DEBUG_X_COLORS
1810 register_color (pixel
);
1816 /* Allocate color PIXEL on display DPY. PIXEL must already be allocated.
1817 It's necessary to do this instead of just using PIXEL directly to
1818 get color reference counts right. */
1821 x_copy_dpy_color (dpy
, cmap
, pixel
)
1824 unsigned long pixel
;
1828 color
.pixel
= pixel
;
1830 XQueryColor (dpy
, cmap
, &color
);
1831 XAllocColor (dpy
, cmap
, &color
);
1833 #ifdef DEBUG_X_COLORS
1834 register_color (pixel
);
1840 /* Brightness beyond which a color won't have its highlight brightness
1843 Nominally, highlight colors for `3d' faces are calculated by
1844 brightening an object's color by a constant scale factor, but this
1845 doesn't yield good results for dark colors, so for colors who's
1846 brightness is less than this value (on a scale of 0-65535) have an
1847 use an additional additive factor.
1849 The value here is set so that the default menu-bar/mode-line color
1850 (grey75) will not have its highlights changed at all. */
1851 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
1854 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1855 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1856 If this produces the same color as PIXEL, try a color where all RGB
1857 values have DELTA added. Return the allocated color in *PIXEL.
1858 DISPLAY is the X display, CMAP is the colormap to operate on.
1859 Value is non-zero if successful. */
1862 x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
)
1866 unsigned long *pixel
;
1874 /* Get RGB color values. */
1875 color
.pixel
= *pixel
;
1876 x_query_color (f
, &color
);
1878 /* Change RGB values by specified FACTOR. Avoid overflow! */
1879 xassert (factor
>= 0);
1880 new.red
= min (0xffff, factor
* color
.red
);
1881 new.green
= min (0xffff, factor
* color
.green
);
1882 new.blue
= min (0xffff, factor
* color
.blue
);
1884 /* Calculate brightness of COLOR. */
1885 bright
= (2 * color
.red
+ 3 * color
.green
+ color
.blue
) / 6;
1887 /* We only boost colors that are darker than
1888 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1889 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1890 /* Make an additive adjustment to NEW, because it's dark enough so
1891 that scaling by FACTOR alone isn't enough. */
1893 /* How far below the limit this color is (0 - 1, 1 being darker). */
1894 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1895 /* The additive adjustment. */
1896 int min_delta
= delta
* dimness
* factor
/ 2;
1900 new.red
= max (0, new.red
- min_delta
);
1901 new.green
= max (0, new.green
- min_delta
);
1902 new.blue
= max (0, new.blue
- min_delta
);
1906 new.red
= min (0xffff, min_delta
+ new.red
);
1907 new.green
= min (0xffff, min_delta
+ new.green
);
1908 new.blue
= min (0xffff, min_delta
+ new.blue
);
1912 /* Try to allocate the color. */
1913 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1916 if (new.pixel
== *pixel
)
1918 /* If we end up with the same color as before, try adding
1919 delta to the RGB values. */
1920 x_free_colors (f
, &new.pixel
, 1);
1922 new.red
= min (0xffff, delta
+ color
.red
);
1923 new.green
= min (0xffff, delta
+ color
.green
);
1924 new.blue
= min (0xffff, delta
+ color
.blue
);
1925 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1936 /* Set up the foreground color for drawing relief lines of glyph
1937 string S. RELIEF is a pointer to a struct relief containing the GC
1938 with which lines will be drawn. Use a color that is FACTOR or
1939 DELTA lighter or darker than the relief's background which is found
1940 in S->f->output_data.x->relief_background. If such a color cannot
1941 be allocated, use DEFAULT_PIXEL, instead. */
1944 x_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
1946 struct relief
*relief
;
1949 unsigned long default_pixel
;
1952 struct x_output
*di
= f
->output_data
.x
;
1953 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
1954 unsigned long pixel
;
1955 unsigned long background
= di
->relief_background
;
1956 Colormap cmap
= FRAME_X_COLORMAP (f
);
1957 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1958 Display
*dpy
= FRAME_X_DISPLAY (f
);
1960 xgcv
.graphics_exposures
= False
;
1961 xgcv
.line_width
= 1;
1963 /* Free previously allocated color. The color cell will be reused
1964 when it has been freed as many times as it was allocated, so this
1965 doesn't affect faces using the same colors. */
1967 && relief
->allocated_p
)
1969 x_free_colors (f
, &relief
->pixel
, 1);
1970 relief
->allocated_p
= 0;
1973 /* Allocate new color. */
1974 xgcv
.foreground
= default_pixel
;
1976 if (dpyinfo
->n_planes
!= 1
1977 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
1979 relief
->allocated_p
= 1;
1980 xgcv
.foreground
= relief
->pixel
= pixel
;
1983 if (relief
->gc
== 0)
1985 xgcv
.stipple
= dpyinfo
->gray
;
1987 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
1990 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
1994 /* Set up colors for the relief lines around glyph string S. */
1997 x_setup_relief_colors (s
)
1998 struct glyph_string
*s
;
2000 struct x_output
*di
= s
->f
->output_data
.x
;
2001 unsigned long color
;
2003 if (s
->face
->use_box_color_for_shadows_p
)
2004 color
= s
->face
->box_color
;
2005 else if (s
->first_glyph
->type
== IMAGE_GLYPH
2007 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
2008 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
2013 /* Get the background color of the face. */
2014 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
2015 color
= xgcv
.background
;
2018 if (di
->white_relief
.gc
== 0
2019 || color
!= di
->relief_background
)
2021 di
->relief_background
= color
;
2022 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
2023 WHITE_PIX_DEFAULT (s
->f
));
2024 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
2025 BLACK_PIX_DEFAULT (s
->f
));
2030 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
2031 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
2032 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
2033 relief. LEFT_P non-zero means draw a relief on the left side of
2034 the rectangle. RIGHT_P non-zero means draw a relief on the right
2035 side of the rectangle. CLIP_RECT is the clipping rectangle to use
2039 x_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
2040 raised_p
, top_p
, bot_p
, left_p
, right_p
, clip_rect
)
2042 int left_x
, top_y
, right_x
, bottom_y
, width
;
2043 int top_p
, bot_p
, left_p
, right_p
, raised_p
;
2044 XRectangle
*clip_rect
;
2046 Display
*dpy
= FRAME_X_DISPLAY (f
);
2047 Window window
= FRAME_X_WINDOW (f
);
2052 gc
= f
->output_data
.x
->white_relief
.gc
;
2054 gc
= f
->output_data
.x
->black_relief
.gc
;
2055 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
2059 for (i
= 0; i
< width
; ++i
)
2060 XDrawLine (dpy
, window
, gc
,
2061 left_x
+ i
* left_p
, top_y
+ i
,
2062 right_x
+ 1 - i
* right_p
, top_y
+ i
);
2066 for (i
= 0; i
< width
; ++i
)
2067 XDrawLine (dpy
, window
, gc
,
2068 left_x
+ i
, top_y
+ i
, left_x
+ i
, bottom_y
- i
+ 1);
2070 XSetClipMask (dpy
, gc
, None
);
2072 gc
= f
->output_data
.x
->black_relief
.gc
;
2074 gc
= f
->output_data
.x
->white_relief
.gc
;
2075 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
2079 for (i
= 0; i
< width
; ++i
)
2080 XDrawLine (dpy
, window
, gc
,
2081 left_x
+ i
* left_p
, bottom_y
- i
,
2082 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
2086 for (i
= 0; i
< width
; ++i
)
2087 XDrawLine (dpy
, window
, gc
,
2088 right_x
- i
, top_y
+ i
+ 1, right_x
- i
, bottom_y
- i
);
2090 XSetClipMask (dpy
, gc
, None
);
2094 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
2095 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
2096 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
2097 left side of the rectangle. RIGHT_P non-zero means draw a line
2098 on the right side of the rectangle. CLIP_RECT is the clipping
2099 rectangle to use when drawing. */
2102 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2103 left_p
, right_p
, clip_rect
)
2104 struct glyph_string
*s
;
2105 int left_x
, top_y
, right_x
, bottom_y
, width
, left_p
, right_p
;
2106 XRectangle
*clip_rect
;
2110 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2111 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
2112 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, clip_rect
, 1, Unsorted
);
2115 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2116 left_x
, top_y
, right_x
- left_x
+ 1, width
);
2120 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2121 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
2124 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2125 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
2129 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2130 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
2132 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2133 XSetClipMask (s
->display
, s
->gc
, None
);
2137 /* Draw a box around glyph string S. */
2140 x_draw_glyph_string_box (s
)
2141 struct glyph_string
*s
;
2143 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
2144 int left_p
, right_p
;
2145 struct glyph
*last_glyph
;
2146 XRectangle clip_rect
;
2148 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
2149 ? WINDOW_RIGHT_EDGE_X (s
->w
)
2150 : window_box_right (s
->w
, s
->area
));
2152 /* The glyph that may have a right box line. */
2153 last_glyph
= (s
->cmp
|| s
->img
2155 : s
->first_glyph
+ s
->nchars
- 1);
2157 width
= abs (s
->face
->box_line_width
);
2158 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
2160 right_x
= (s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
2162 : min (last_x
, s
->x
+ s
->background_width
) - 1);
2164 bottom_y
= top_y
+ s
->height
- 1;
2166 left_p
= (s
->first_glyph
->left_box_line_p
2167 || (s
->hl
== DRAW_MOUSE_FACE
2169 || s
->prev
->hl
!= s
->hl
)));
2170 right_p
= (last_glyph
->right_box_line_p
2171 || (s
->hl
== DRAW_MOUSE_FACE
2173 || s
->next
->hl
!= s
->hl
)));
2175 get_glyph_string_clip_rect (s
, &clip_rect
);
2177 if (s
->face
->box
== FACE_SIMPLE_BOX
)
2178 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2179 left_p
, right_p
, &clip_rect
);
2182 x_setup_relief_colors (s
);
2183 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
2184 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
2189 /* Draw foreground of image glyph string S. */
2192 x_draw_image_foreground (s
)
2193 struct glyph_string
*s
;
2196 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2198 /* If first glyph of S has a left box line, start drawing it to the
2199 right of that line. */
2200 if (s
->face
->box
!= FACE_NO_BOX
2201 && s
->first_glyph
->left_box_line_p
2203 x
+= abs (s
->face
->box_line_width
);
2205 /* If there is a margin around the image, adjust x- and y-position
2207 if (s
->slice
.x
== 0)
2208 x
+= s
->img
->hmargin
;
2209 if (s
->slice
.y
== 0)
2210 y
+= s
->img
->vmargin
;
2216 /* We can't set both a clip mask and use XSetClipRectangles
2217 because the latter also sets a clip mask. We also can't
2218 trust on the shape extension to be available
2219 (XShapeCombineRegion). So, compute the rectangle to draw
2221 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2224 XRectangle clip_rect
, image_rect
, r
;
2226 xgcv
.clip_mask
= s
->img
->mask
;
2227 xgcv
.clip_x_origin
= x
;
2228 xgcv
.clip_y_origin
= y
;
2229 xgcv
.function
= GXcopy
;
2230 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2232 get_glyph_string_clip_rect (s
, &clip_rect
);
2235 image_rect
.width
= s
->slice
.width
;
2236 image_rect
.height
= s
->slice
.height
;
2237 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2238 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2239 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2240 r
.width
, r
.height
, r
.x
, r
.y
);
2244 XRectangle clip_rect
, image_rect
, r
;
2246 get_glyph_string_clip_rect (s
, &clip_rect
);
2249 image_rect
.width
= s
->slice
.width
;
2250 image_rect
.height
= s
->slice
.height
;
2251 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2252 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2253 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2254 r
.width
, r
.height
, r
.x
, r
.y
);
2256 /* When the image has a mask, we can expect that at
2257 least part of a mouse highlight or a block cursor will
2258 be visible. If the image doesn't have a mask, make
2259 a block cursor visible by drawing a rectangle around
2260 the image. I believe it's looking better if we do
2261 nothing here for mouse-face. */
2262 if (s
->hl
== DRAW_CURSOR
)
2264 int r
= s
->img
->relief
;
2266 XDrawRectangle (s
->display
, s
->window
, s
->gc
,
2268 s
->slice
.width
+ r
*2 - 1,
2269 s
->slice
.height
+ r
*2 - 1);
2274 /* Draw a rectangle if image could not be loaded. */
2275 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
2276 s
->slice
.width
- 1, s
->slice
.height
- 1);
2280 /* Draw a relief around the image glyph string S. */
2283 x_draw_image_relief (s
)
2284 struct glyph_string
*s
;
2286 int x0
, y0
, x1
, y1
, thick
, raised_p
;
2289 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2291 /* If first glyph of S has a left box line, start drawing it to the
2292 right of that line. */
2293 if (s
->face
->box
!= FACE_NO_BOX
2294 && s
->first_glyph
->left_box_line_p
2296 x
+= abs (s
->face
->box_line_width
);
2298 /* If there is a margin around the image, adjust x- and y-position
2300 if (s
->slice
.x
== 0)
2301 x
+= s
->img
->hmargin
;
2302 if (s
->slice
.y
== 0)
2303 y
+= s
->img
->vmargin
;
2305 if (s
->hl
== DRAW_IMAGE_SUNKEN
2306 || s
->hl
== DRAW_IMAGE_RAISED
)
2308 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
2309 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
2313 thick
= abs (s
->img
->relief
);
2314 raised_p
= s
->img
->relief
> 0;
2319 x1
= x
+ s
->slice
.width
+ thick
- 1;
2320 y1
= y
+ s
->slice
.height
+ thick
- 1;
2322 x_setup_relief_colors (s
);
2323 get_glyph_string_clip_rect (s
, &r
);
2324 x_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
,
2326 s
->slice
.y
+ s
->slice
.height
== s
->img
->height
,
2328 s
->slice
.x
+ s
->slice
.width
== s
->img
->width
,
2333 /* Draw the foreground of image glyph string S to PIXMAP. */
2336 x_draw_image_foreground_1 (s
, pixmap
)
2337 struct glyph_string
*s
;
2341 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2343 /* If first glyph of S has a left box line, start drawing it to the
2344 right of that line. */
2345 if (s
->face
->box
!= FACE_NO_BOX
2346 && s
->first_glyph
->left_box_line_p
2348 x
+= abs (s
->face
->box_line_width
);
2350 /* If there is a margin around the image, adjust x- and y-position
2352 if (s
->slice
.x
== 0)
2353 x
+= s
->img
->hmargin
;
2354 if (s
->slice
.y
== 0)
2355 y
+= s
->img
->vmargin
;
2361 /* We can't set both a clip mask and use XSetClipRectangles
2362 because the latter also sets a clip mask. We also can't
2363 trust on the shape extension to be available
2364 (XShapeCombineRegion). So, compute the rectangle to draw
2366 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2370 xgcv
.clip_mask
= s
->img
->mask
;
2371 xgcv
.clip_x_origin
= x
- s
->slice
.x
;
2372 xgcv
.clip_y_origin
= y
- s
->slice
.y
;
2373 xgcv
.function
= GXcopy
;
2374 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2376 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2377 s
->slice
.x
, s
->slice
.y
,
2378 s
->slice
.width
, s
->slice
.height
, x
, y
);
2379 XSetClipMask (s
->display
, s
->gc
, None
);
2383 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2384 s
->slice
.x
, s
->slice
.y
,
2385 s
->slice
.width
, s
->slice
.height
, x
, y
);
2387 /* When the image has a mask, we can expect that at
2388 least part of a mouse highlight or a block cursor will
2389 be visible. If the image doesn't have a mask, make
2390 a block cursor visible by drawing a rectangle around
2391 the image. I believe it's looking better if we do
2392 nothing here for mouse-face. */
2393 if (s
->hl
== DRAW_CURSOR
)
2395 int r
= s
->img
->relief
;
2397 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
- r
, y
- r
,
2398 s
->slice
.width
+ r
*2 - 1,
2399 s
->slice
.height
+ r
*2 - 1);
2404 /* Draw a rectangle if image could not be loaded. */
2405 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
2406 s
->slice
.width
- 1, s
->slice
.height
- 1);
2410 /* Draw part of the background of glyph string S. X, Y, W, and H
2411 give the rectangle to draw. */
2414 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
2415 struct glyph_string
*s
;
2420 /* Fill background with a stipple pattern. */
2421 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2422 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2423 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2426 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2430 /* Draw image glyph string S.
2433 s->x +-------------------------
2436 | +-------------------------
2439 | | +-------------------
2445 x_draw_image_glyph_string (s
)
2446 struct glyph_string
*s
;
2448 int box_line_hwidth
= abs (s
->face
->box_line_width
);
2449 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2451 Pixmap pixmap
= None
;
2454 if (s
->slice
.y
== 0)
2455 height
-= box_line_vwidth
;
2456 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
2457 height
-= box_line_vwidth
;
2459 /* Fill background with face under the image. Do it only if row is
2460 taller than image or if image has a clip mask to reduce
2462 s
->stippled_p
= s
->face
->stipple
!= 0;
2463 if (height
> s
->slice
.height
2467 || s
->img
->pixmap
== 0
2468 || s
->width
!= s
->background_width
)
2472 /* Create a pixmap as large as the glyph string. Fill it
2473 with the background color. Copy the image to it, using
2474 its mask. Copy the temporary pixmap to the display. */
2475 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2476 int depth
= DefaultDepthOfScreen (screen
);
2478 /* Create a pixmap as large as the glyph string. */
2479 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2480 s
->background_width
,
2483 /* Don't clip in the following because we're working on the
2485 XSetClipMask (s
->display
, s
->gc
, None
);
2487 /* Fill the pixmap with the background color/stipple. */
2490 /* Fill background with a stipple pattern. */
2491 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2492 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2493 0, 0, s
->background_width
, s
->height
);
2494 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2499 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2501 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2502 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2503 0, 0, s
->background_width
, s
->height
);
2504 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2512 if (s
->first_glyph
->left_box_line_p
2514 x
+= box_line_hwidth
;
2516 if (s
->slice
.y
== 0)
2517 y
+= box_line_vwidth
;
2519 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
2522 s
->background_filled_p
= 1;
2525 /* Draw the foreground. */
2528 x_draw_image_foreground_1 (s
, pixmap
);
2529 x_set_glyph_string_clipping (s
);
2530 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
2531 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
2532 XFreePixmap (s
->display
, pixmap
);
2535 x_draw_image_foreground (s
);
2537 /* If we must draw a relief around the image, do it. */
2539 || s
->hl
== DRAW_IMAGE_RAISED
2540 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2541 x_draw_image_relief (s
);
2545 /* Draw stretch glyph string S. */
2548 x_draw_stretch_glyph_string (s
)
2549 struct glyph_string
*s
;
2551 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2552 s
->stippled_p
= s
->face
->stipple
!= 0;
2554 if (s
->hl
== DRAW_CURSOR
2555 && !x_stretch_cursor_p
)
2557 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
2558 as wide as the stretch glyph. */
2559 int width
= min (FRAME_COLUMN_WIDTH (s
->f
), s
->background_width
);
2562 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, width
, s
->height
);
2564 /* Clear rest using the GC of the original non-cursor face. */
2565 if (width
< s
->background_width
)
2567 int x
= s
->x
+ width
, y
= s
->y
;
2568 int w
= s
->background_width
- width
, h
= s
->height
;
2572 if (s
->row
->mouse_face_p
2573 && cursor_in_mouse_face_p (s
->w
))
2575 x_set_mouse_face_gc (s
);
2581 get_glyph_string_clip_rect (s
, &r
);
2582 XSetClipRectangles (s
->display
, gc
, 0, 0, &r
, 1, Unsorted
);
2584 if (s
->face
->stipple
)
2586 /* Fill background with a stipple pattern. */
2587 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2588 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2589 XSetFillStyle (s
->display
, gc
, FillSolid
);
2594 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
2595 XSetForeground (s
->display
, gc
, xgcv
.background
);
2596 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2597 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
2601 else if (!s
->background_filled_p
)
2602 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, s
->background_width
,
2605 s
->background_filled_p
= 1;
2609 /* Draw glyph string S. */
2612 x_draw_glyph_string (s
)
2613 struct glyph_string
*s
;
2615 int relief_drawn_p
= 0;
2617 /* If S draws into the background of its successor, draw the
2618 background of the successor first so that S can draw into it.
2619 This makes S->next use XDrawString instead of XDrawImageString. */
2620 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
)
2622 xassert (s
->next
->img
== NULL
);
2623 x_set_glyph_string_gc (s
->next
);
2624 x_set_glyph_string_clipping (s
->next
);
2625 x_draw_glyph_string_background (s
->next
, 1);
2628 /* Set up S->gc, set clipping and draw S. */
2629 x_set_glyph_string_gc (s
);
2631 /* Draw relief (if any) in advance for char/composition so that the
2632 glyph string can be drawn over it. */
2633 if (!s
->for_overlaps
2634 && s
->face
->box
!= FACE_NO_BOX
2635 && (s
->first_glyph
->type
== CHAR_GLYPH
2636 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2639 x_set_glyph_string_clipping (s
);
2640 x_draw_glyph_string_background (s
, 1);
2641 x_draw_glyph_string_box (s
);
2642 x_set_glyph_string_clipping (s
);
2646 x_set_glyph_string_clipping (s
);
2648 switch (s
->first_glyph
->type
)
2651 x_draw_image_glyph_string (s
);
2655 x_draw_stretch_glyph_string (s
);
2659 if (s
->for_overlaps
)
2660 s
->background_filled_p
= 1;
2662 x_draw_glyph_string_background (s
, 0);
2663 x_draw_glyph_string_foreground (s
);
2666 case COMPOSITE_GLYPH
:
2667 if (s
->for_overlaps
|| s
->gidx
> 0)
2668 s
->background_filled_p
= 1;
2670 x_draw_glyph_string_background (s
, 1);
2671 x_draw_composite_glyph_string_foreground (s
);
2678 if (!s
->for_overlaps
)
2680 /* Draw underline. */
2681 if (s
->face
->underline_p
)
2683 unsigned long tem
, h
;
2686 /* Get the underline thickness. Default is 1 pixel. */
2687 if (!XGetFontProperty (s
->font
, XA_UNDERLINE_THICKNESS
, &h
))
2690 /* Get the underline position. This is the recommended
2691 vertical offset in pixels from the baseline to the top of
2692 the underline. This is a signed value according to the
2693 specs, and its default is
2695 ROUND ((maximum descent) / 2), with
2696 ROUND(x) = floor (x + 0.5) */
2698 if (x_use_underline_position_properties
2699 && XGetFontProperty (s
->font
, XA_UNDERLINE_POSITION
, &tem
))
2700 y
= s
->ybase
+ (long) tem
;
2701 else if (s
->face
->font
)
2702 y
= s
->ybase
+ (s
->face
->font
->max_bounds
.descent
+ 1) / 2;
2704 y
= s
->y
+ s
->height
- h
;
2706 if (s
->face
->underline_defaulted_p
)
2707 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2708 s
->x
, y
, s
->width
, h
);
2712 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2713 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
2714 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2715 s
->x
, y
, s
->width
, h
);
2716 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2720 /* Draw overline. */
2721 if (s
->face
->overline_p
)
2723 unsigned long dy
= 0, h
= 1;
2725 if (s
->face
->overline_color_defaulted_p
)
2726 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2731 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2732 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
2733 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2735 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2739 /* Draw strike-through. */
2740 if (s
->face
->strike_through_p
)
2742 unsigned long h
= 1;
2743 unsigned long dy
= (s
->height
- h
) / 2;
2745 if (s
->face
->strike_through_color_defaulted_p
)
2746 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2751 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2752 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
2753 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2755 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2759 /* Draw relief if not yet drawn. */
2760 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2761 x_draw_glyph_string_box (s
);
2764 /* Reset clipping. */
2765 XSetClipMask (s
->display
, s
->gc
, None
);
2768 /* Shift display to make room for inserted glyphs. */
2771 x_shift_glyphs_for_insert (f
, x
, y
, width
, height
, shift_by
)
2773 int x
, y
, width
, height
, shift_by
;
2775 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
2776 f
->output_data
.x
->normal_gc
,
2777 x
, y
, width
, height
,
2781 /* Delete N glyphs at the nominal cursor position. Not implemented
2785 x_delete_glyphs (f
, n
)
2793 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
2794 If they are <= 0, this is probably an error. */
2797 x_clear_area (dpy
, window
, x
, y
, width
, height
, exposures
)
2804 xassert (width
> 0 && height
> 0);
2805 XClearArea (dpy
, window
, x
, y
, width
, height
, exposures
);
2809 /* Clear an entire frame. */
2812 x_clear_frame (struct frame
*f
)
2814 /* Clearing the frame will erase any cursor, so mark them all as no
2816 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2817 output_cursor
.hpos
= output_cursor
.vpos
= 0;
2818 output_cursor
.x
= -1;
2820 /* We don't set the output cursor here because there will always
2821 follow an explicit cursor_to. */
2823 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
2825 /* We have to clear the scroll bars, too. If we have changed
2826 colors or something like that, then they should be notified. */
2827 x_scroll_bar_clear (f
);
2829 XFlush (FRAME_X_DISPLAY (f
));
2836 /* Invert the middle quarter of the frame for .15 sec. */
2838 /* We use the select system call to do the waiting, so we have to make
2839 sure it's available. If it isn't, we just won't do visual bells. */
2841 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
2844 /* Subtract the `struct timeval' values X and Y, storing the result in
2845 *RESULT. Return 1 if the difference is negative, otherwise 0. */
2848 timeval_subtract (result
, x
, y
)
2849 struct timeval
*result
, x
, y
;
2851 /* Perform the carry for the later subtraction by updating y. This
2852 is safer because on some systems the tv_sec member is unsigned. */
2853 if (x
.tv_usec
< y
.tv_usec
)
2855 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
2856 y
.tv_usec
-= 1000000 * nsec
;
2860 if (x
.tv_usec
- y
.tv_usec
> 1000000)
2862 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
2863 y
.tv_usec
+= 1000000 * nsec
;
2867 /* Compute the time remaining to wait. tv_usec is certainly
2869 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
2870 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
2872 /* Return indication of whether the result should be considered
2874 return x
.tv_sec
< y
.tv_sec
;
2886 /* Create a GC that will use the GXxor function to flip foreground
2887 pixels into background pixels. */
2891 values
.function
= GXxor
;
2892 values
.foreground
= (f
->output_data
.x
->foreground_pixel
2893 ^ f
->output_data
.x
->background_pixel
);
2895 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2896 GCFunction
| GCForeground
, &values
);
2900 /* Get the height not including a menu bar widget. */
2901 int height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, FRAME_LINES (f
));
2902 /* Height of each line to flash. */
2903 int flash_height
= FRAME_LINE_HEIGHT (f
);
2904 /* These will be the left and right margins of the rectangles. */
2905 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
2906 int flash_right
= FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
2910 /* Don't flash the area between a scroll bar and the frame
2911 edge it is next to. */
2912 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f
))
2914 case vertical_scroll_bar_left
:
2915 flash_left
+= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
2918 case vertical_scroll_bar_right
:
2919 flash_right
-= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
2926 width
= flash_right
- flash_left
;
2928 /* If window is tall, flash top and bottom line. */
2929 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
2931 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2933 (FRAME_INTERNAL_BORDER_WIDTH (f
)
2934 + FRAME_TOOL_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
)),
2935 width
, flash_height
);
2936 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2938 (height
- flash_height
2939 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
2940 width
, flash_height
);
2943 /* If it is short, flash it all. */
2944 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2945 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
2946 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
2951 struct timeval wakeup
;
2953 EMACS_GET_TIME (wakeup
);
2955 /* Compute time to wait until, propagating carry from usecs. */
2956 wakeup
.tv_usec
+= 150000;
2957 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
2958 wakeup
.tv_usec
%= 1000000;
2960 /* Keep waiting until past the time wakeup or any input gets
2962 while (! detect_input_pending ())
2964 struct timeval current
;
2965 struct timeval timeout
;
2967 EMACS_GET_TIME (current
);
2969 /* Break if result would be negative. */
2970 if (timeval_subtract (¤t
, wakeup
, current
))
2973 /* How long `select' should wait. */
2975 timeout
.tv_usec
= 10000;
2977 /* Try to wait that long--but we might wake up sooner. */
2978 select (0, NULL
, NULL
, NULL
, &timeout
);
2982 /* If window is tall, flash top and bottom line. */
2983 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
2985 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2987 (FRAME_INTERNAL_BORDER_WIDTH (f
)
2988 + FRAME_TOOL_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
)),
2989 width
, flash_height
);
2990 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2992 (height
- flash_height
2993 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
2994 width
, flash_height
);
2997 /* If it is short, flash it all. */
2998 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2999 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
3000 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3002 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
3010 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
3013 /* Make audible bell. */
3018 struct frame
*f
= SELECTED_FRAME ();
3020 if (FRAME_X_DISPLAY (f
))
3022 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
3029 XBell (FRAME_X_DISPLAY (f
), 0);
3030 XFlush (FRAME_X_DISPLAY (f
));
3037 /* Specify how many text lines, from the top of the window,
3038 should be affected by insert-lines and delete-lines operations.
3039 This, and those operations, are used only within an update
3040 that is bounded by calls to x_update_begin and x_update_end. */
3043 XTset_terminal_window (n
)
3046 /* This function intentionally left blank. */
3051 /***********************************************************************
3053 ***********************************************************************/
3055 /* Perform an insert-lines or delete-lines operation, inserting N
3056 lines or deleting -N lines at vertical position VPOS. */
3059 x_ins_del_lines (f
, vpos
, n
)
3067 /* Scroll part of the display as described by RUN. */
3070 x_scroll_run (w
, run
)
3074 struct frame
*f
= XFRAME (w
->frame
);
3075 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
3077 /* Get frame-relative bounding box of the text display area of W,
3078 without mode lines. Include in this box the left and right
3080 window_box (w
, -1, &x
, &y
, &width
, &height
);
3082 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
3083 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
3084 bottom_y
= y
+ height
;
3088 /* Scrolling up. Make sure we don't copy part of the mode
3089 line at the bottom. */
3090 if (from_y
+ run
->height
> bottom_y
)
3091 height
= bottom_y
- from_y
;
3093 height
= run
->height
;
3097 /* Scolling down. Make sure we don't copy over the mode line.
3099 if (to_y
+ run
->height
> bottom_y
)
3100 height
= bottom_y
- to_y
;
3102 height
= run
->height
;
3107 /* Cursor off. Will be switched on again in x_update_window_end. */
3111 XCopyArea (FRAME_X_DISPLAY (f
),
3112 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
3113 f
->output_data
.x
->normal_gc
,
3123 /***********************************************************************
3125 ***********************************************************************/
3132 /* We used to only do this if Vx_no_window_manager was non-nil, but
3133 the ICCCM (section 4.1.6) says that the window's border pixmap
3134 and border pixel are window attributes which are "private to the
3135 client", so we can always change it to whatever we want. */
3137 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3138 f
->output_data
.x
->border_pixel
);
3140 x_update_cursor (f
, 1);
3144 frame_unhighlight (f
)
3147 /* We used to only do this if Vx_no_window_manager was non-nil, but
3148 the ICCCM (section 4.1.6) says that the window's border pixmap
3149 and border pixel are window attributes which are "private to the
3150 client", so we can always change it to whatever we want. */
3152 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3153 f
->output_data
.x
->border_tile
);
3155 x_update_cursor (f
, 1);
3158 /* The focus has changed. Update the frames as necessary to reflect
3159 the new situation. Note that we can't change the selected frame
3160 here, because the Lisp code we are interrupting might become confused.
3161 Each event gets marked with the frame in which it occurred, so the
3162 Lisp code can tell when the switch took place by examining the events. */
3165 x_new_focus_frame (dpyinfo
, frame
)
3166 struct x_display_info
*dpyinfo
;
3167 struct frame
*frame
;
3169 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
3171 if (frame
!= dpyinfo
->x_focus_frame
)
3173 /* Set this before calling other routines, so that they see
3174 the correct value of x_focus_frame. */
3175 dpyinfo
->x_focus_frame
= frame
;
3177 if (old_focus
&& old_focus
->auto_lower
)
3178 x_lower_frame (old_focus
);
3181 selected_frame
= frame
;
3182 XSETFRAME (XWINDOW (selected_frame
->selected_window
)->frame
,
3184 Fselect_window (selected_frame
->selected_window
, Qnil
);
3185 choose_minibuf_frame ();
3188 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
3189 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
3191 pending_autoraise_frame
= 0;
3194 x_frame_rehighlight (dpyinfo
);
3197 /* Handle FocusIn and FocusOut state changes for FRAME.
3198 If FRAME has focus and there exists more than one frame, puts
3199 a FOCUS_IN_EVENT into *BUFP. */
3202 x_focus_changed (type
, state
, dpyinfo
, frame
, bufp
)
3205 struct x_display_info
*dpyinfo
;
3206 struct frame
*frame
;
3207 struct input_event
*bufp
;
3209 if (type
== FocusIn
)
3211 if (dpyinfo
->x_focus_event_frame
!= frame
)
3213 x_new_focus_frame (dpyinfo
, frame
);
3214 dpyinfo
->x_focus_event_frame
= frame
;
3216 /* Don't stop displaying the initial startup message
3217 for a switch-frame event we don't need. */
3218 if (GC_NILP (Vterminal_frame
)
3219 && GC_CONSP (Vframe_list
)
3220 && !GC_NILP (XCDR (Vframe_list
)))
3222 bufp
->kind
= FOCUS_IN_EVENT
;
3223 XSETFRAME (bufp
->frame_or_window
, frame
);
3227 frame
->output_data
.x
->focus_state
|= state
;
3230 if (FRAME_XIC (frame
))
3231 XSetICFocus (FRAME_XIC (frame
));
3234 else if (type
== FocusOut
)
3236 frame
->output_data
.x
->focus_state
&= ~state
;
3238 if (dpyinfo
->x_focus_event_frame
== frame
)
3240 dpyinfo
->x_focus_event_frame
= 0;
3241 x_new_focus_frame (dpyinfo
, 0);
3245 if (FRAME_XIC (frame
))
3246 XUnsetICFocus (FRAME_XIC (frame
));
3251 /* The focus may have changed. Figure out if it is a real focus change,
3252 by checking both FocusIn/Out and Enter/LeaveNotify events.
3254 Returns FOCUS_IN_EVENT event in *BUFP. */
3257 x_detect_focus_change (dpyinfo
, event
, bufp
)
3258 struct x_display_info
*dpyinfo
;
3260 struct input_event
*bufp
;
3262 struct frame
*frame
;
3264 frame
= x_any_window_to_frame (dpyinfo
, event
->xany
.window
);
3268 switch (event
->type
)
3273 struct frame
*focus_frame
= dpyinfo
->x_focus_event_frame
;
3275 = focus_frame
? focus_frame
->output_data
.x
->focus_state
: 0;
3277 if (event
->xcrossing
.detail
!= NotifyInferior
3278 && event
->xcrossing
.focus
3279 && ! (focus_state
& FOCUS_EXPLICIT
))
3280 x_focus_changed ((event
->type
== EnterNotify
? FocusIn
: FocusOut
),
3282 dpyinfo
, frame
, bufp
);
3288 x_focus_changed (event
->type
,
3289 (event
->xfocus
.detail
== NotifyPointer
?
3290 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
3291 dpyinfo
, frame
, bufp
);
3297 /* Handle an event saying the mouse has moved out of an Emacs frame. */
3300 x_mouse_leave (dpyinfo
)
3301 struct x_display_info
*dpyinfo
;
3303 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
3306 /* The focus has changed, or we have redirected a frame's focus to
3307 another frame (this happens when a frame uses a surrogate
3308 mini-buffer frame). Shift the highlight as appropriate.
3310 The FRAME argument doesn't necessarily have anything to do with which
3311 frame is being highlighted or un-highlighted; we only use it to find
3312 the appropriate X display info. */
3315 XTframe_rehighlight (frame
)
3316 struct frame
*frame
;
3318 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
3322 x_frame_rehighlight (dpyinfo
)
3323 struct x_display_info
*dpyinfo
;
3325 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
3327 if (dpyinfo
->x_focus_frame
)
3329 dpyinfo
->x_highlight_frame
3330 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
3331 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
3332 : dpyinfo
->x_focus_frame
);
3333 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
3335 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
3336 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
3340 dpyinfo
->x_highlight_frame
= 0;
3342 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
3345 frame_unhighlight (old_highlight
);
3346 if (dpyinfo
->x_highlight_frame
)
3347 frame_highlight (dpyinfo
->x_highlight_frame
);
3353 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
3355 /* Initialize mode_switch_bit and modifier_meaning. */
3357 x_find_modifier_meanings (dpyinfo
)
3358 struct x_display_info
*dpyinfo
;
3360 int min_code
, max_code
;
3363 XModifierKeymap
*mods
;
3365 dpyinfo
->meta_mod_mask
= 0;
3366 dpyinfo
->shift_lock_mask
= 0;
3367 dpyinfo
->alt_mod_mask
= 0;
3368 dpyinfo
->super_mod_mask
= 0;
3369 dpyinfo
->hyper_mod_mask
= 0;
3372 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
3374 min_code
= dpyinfo
->display
->min_keycode
;
3375 max_code
= dpyinfo
->display
->max_keycode
;
3378 syms
= XGetKeyboardMapping (dpyinfo
->display
,
3379 min_code
, max_code
- min_code
+ 1,
3381 mods
= XGetModifierMapping (dpyinfo
->display
);
3383 /* Scan the modifier table to see which modifier bits the Meta and
3384 Alt keysyms are on. */
3386 int row
, col
; /* The row and column in the modifier table. */
3387 int found_alt_or_meta
;
3389 for (row
= 3; row
< 8; row
++)
3391 found_alt_or_meta
= 0;
3392 for (col
= 0; col
< mods
->max_keypermod
; col
++)
3394 KeyCode code
= mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
3396 /* Zeroes are used for filler. Skip them. */
3400 /* Are any of this keycode's keysyms a meta key? */
3404 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
3406 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
3412 found_alt_or_meta
= 1;
3413 dpyinfo
->meta_mod_mask
|= (1 << row
);
3418 found_alt_or_meta
= 1;
3419 dpyinfo
->alt_mod_mask
|= (1 << row
);
3424 if (!found_alt_or_meta
)
3425 dpyinfo
->hyper_mod_mask
|= (1 << row
);
3426 code_col
= syms_per_code
;
3427 col
= mods
->max_keypermod
;
3432 if (!found_alt_or_meta
)
3433 dpyinfo
->super_mod_mask
|= (1 << row
);
3434 code_col
= syms_per_code
;
3435 col
= mods
->max_keypermod
;
3439 /* Ignore this if it's not on the lock modifier. */
3440 if (!found_alt_or_meta
&& ((1 << row
) == LockMask
))
3441 dpyinfo
->shift_lock_mask
= LockMask
;
3442 code_col
= syms_per_code
;
3443 col
= mods
->max_keypermod
;
3452 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
3453 if (! dpyinfo
->meta_mod_mask
)
3455 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
3456 dpyinfo
->alt_mod_mask
= 0;
3459 /* If some keys are both alt and meta,
3460 make them just meta, not alt. */
3461 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
3463 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
3466 XFree ((char *) syms
);
3467 XFreeModifiermap (mods
);
3470 /* Convert between the modifier bits X uses and the modifier bits
3474 x_x_to_emacs_modifiers (dpyinfo
, state
)
3475 struct x_display_info
*dpyinfo
;
3478 EMACS_UINT mod_meta
= meta_modifier
;
3479 EMACS_UINT mod_alt
= alt_modifier
;
3480 EMACS_UINT mod_hyper
= hyper_modifier
;
3481 EMACS_UINT mod_super
= super_modifier
;
3484 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3485 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
3486 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3487 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
3488 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3489 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
3490 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3491 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
3494 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
3495 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
3496 | ((state
& dpyinfo
->meta_mod_mask
) ? mod_meta
: 0)
3497 | ((state
& dpyinfo
->alt_mod_mask
) ? mod_alt
: 0)
3498 | ((state
& dpyinfo
->super_mod_mask
) ? mod_super
: 0)
3499 | ((state
& dpyinfo
->hyper_mod_mask
) ? mod_hyper
: 0));
3503 x_emacs_to_x_modifiers (dpyinfo
, state
)
3504 struct x_display_info
*dpyinfo
;
3507 EMACS_UINT mod_meta
= meta_modifier
;
3508 EMACS_UINT mod_alt
= alt_modifier
;
3509 EMACS_UINT mod_hyper
= hyper_modifier
;
3510 EMACS_UINT mod_super
= super_modifier
;
3514 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3515 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
3516 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3517 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
3518 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3519 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
3520 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3521 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
3524 return ( ((state
& mod_alt
) ? dpyinfo
->alt_mod_mask
: 0)
3525 | ((state
& mod_super
) ? dpyinfo
->super_mod_mask
: 0)
3526 | ((state
& mod_hyper
) ? dpyinfo
->hyper_mod_mask
: 0)
3527 | ((state
& shift_modifier
) ? ShiftMask
: 0)
3528 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
3529 | ((state
& mod_meta
) ? dpyinfo
->meta_mod_mask
: 0));
3532 /* Convert a keysym to its name. */
3535 x_get_keysym_name (keysym
)
3541 value
= XKeysymToString (keysym
);
3549 /* Mouse clicks and mouse movement. Rah. */
3551 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3553 If the event is a button press, then note that we have grabbed
3557 construct_mouse_click (result
, event
, f
)
3558 struct input_event
*result
;
3559 XButtonEvent
*event
;
3562 /* Make the event type NO_EVENT; we'll change that when we decide
3564 result
->kind
= MOUSE_CLICK_EVENT
;
3565 result
->code
= event
->button
- Button1
;
3566 result
->timestamp
= event
->time
;
3567 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
3569 | (event
->type
== ButtonRelease
3573 XSETINT (result
->x
, event
->x
);
3574 XSETINT (result
->y
, event
->y
);
3575 XSETFRAME (result
->frame_or_window
, f
);
3581 /* Function to report a mouse movement to the mainstream Emacs code.
3582 The input handler calls this.
3584 We have received a mouse movement event, which is given in *event.
3585 If the mouse is over a different glyph than it was last time, tell
3586 the mainstream emacs code by setting mouse_moved. If not, ask for
3587 another motion event, so we can check again the next time it moves. */
3589 static XMotionEvent last_mouse_motion_event
;
3590 static Lisp_Object last_mouse_motion_frame
;
3593 note_mouse_movement (frame
, event
)
3595 XMotionEvent
*event
;
3597 last_mouse_movement_time
= event
->time
;
3598 last_mouse_motion_event
= *event
;
3599 XSETFRAME (last_mouse_motion_frame
, frame
);
3601 if (event
->window
!= FRAME_X_WINDOW (frame
))
3603 frame
->mouse_moved
= 1;
3604 last_mouse_scroll_bar
= Qnil
;
3605 note_mouse_highlight (frame
, -1, -1);
3606 last_mouse_glyph_frame
= 0;
3611 /* Has the mouse moved off the glyph it was on at the last sighting? */
3612 if (frame
!= last_mouse_glyph_frame
3613 || event
->x
< last_mouse_glyph
.x
3614 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
3615 || event
->y
< last_mouse_glyph
.y
3616 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
3618 frame
->mouse_moved
= 1;
3619 last_mouse_scroll_bar
= Qnil
;
3620 note_mouse_highlight (frame
, event
->x
, event
->y
);
3621 /* Remember which glyph we're now on. */
3622 remember_mouse_glyph (frame
, event
->x
, event
->y
, &last_mouse_glyph
);
3623 last_mouse_glyph_frame
= frame
;
3631 /************************************************************************
3633 ************************************************************************/
3636 redo_mouse_highlight ()
3638 if (!NILP (last_mouse_motion_frame
)
3639 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
3640 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
3641 last_mouse_motion_event
.x
,
3642 last_mouse_motion_event
.y
);
3647 /* Return the current position of the mouse.
3648 *FP should be a frame which indicates which display to ask about.
3650 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
3651 and *PART to the frame, window, and scroll bar part that the mouse
3652 is over. Set *X and *Y to the portion and whole of the mouse's
3653 position on the scroll bar.
3655 If the mouse movement started elsewhere, set *FP to the frame the
3656 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
3659 Set *TIME to the server time-stamp for the time at which the mouse
3660 was at this position.
3662 Don't store anything if we don't have a valid set of values to report.
3664 This clears the mouse_moved flag, so we can wait for the next mouse
3668 XTmouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
3671 Lisp_Object
*bar_window
;
3672 enum scroll_bar_part
*part
;
3674 unsigned long *time
;
3680 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
3681 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3687 Window dummy_window
;
3690 Lisp_Object frame
, tail
;
3692 /* Clear the mouse-moved flag for every frame on this display. */
3693 FOR_EACH_FRAME (tail
, frame
)
3694 if (FRAME_X_P (XFRAME (frame
))
3695 && FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
3696 XFRAME (frame
)->mouse_moved
= 0;
3698 last_mouse_scroll_bar
= Qnil
;
3700 /* Figure out which root window we're on. */
3701 XQueryPointer (FRAME_X_DISPLAY (*fp
),
3702 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
3704 /* The root window which contains the pointer. */
3707 /* Trash which we can't trust if the pointer is on
3708 a different screen. */
3711 /* The position on that root window. */
3714 /* More trash we can't trust. */
3717 /* Modifier keys and pointer buttons, about which
3719 (unsigned int *) &dummy
);
3721 /* Now we have a position on the root; find the innermost window
3722 containing the pointer. */
3726 int parent_x
= 0, parent_y
= 0;
3731 /* XTranslateCoordinates can get errors if the window
3732 structure is changing at the same time this function
3733 is running. So at least we must not crash from them. */
3735 count
= x_catch_errors (FRAME_X_DISPLAY (*fp
));
3737 if (FRAME_X_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
3738 && FRAME_LIVE_P (last_mouse_frame
))
3740 /* If mouse was grabbed on a frame, give coords for that frame
3741 even if the mouse is now outside it. */
3742 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3744 /* From-window, to-window. */
3745 root
, FRAME_X_WINDOW (last_mouse_frame
),
3747 /* From-position, to-position. */
3748 root_x
, root_y
, &win_x
, &win_y
,
3752 f1
= last_mouse_frame
;
3758 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3760 /* From-window, to-window. */
3763 /* From-position, to-position. */
3764 root_x
, root_y
, &win_x
, &win_y
,
3769 if (child
== None
|| child
== win
)
3777 /* Now we know that:
3778 win is the innermost window containing the pointer
3779 (XTC says it has no child containing the pointer),
3780 win_x and win_y are the pointer's position in it
3781 (XTC did this the last time through), and
3782 parent_x and parent_y are the pointer's position in win's parent.
3783 (They are what win_x and win_y were when win was child.
3784 If win is the root window, it has no parent, and
3785 parent_{x,y} are invalid, but that's okay, because we'll
3786 never use them in that case.) */
3788 /* Is win one of our frames? */
3789 f1
= x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
3791 #ifdef USE_X_TOOLKIT
3792 /* If we end up with the menu bar window, say it's not
3795 && f1
->output_data
.x
->menubar_widget
3796 && win
== XtWindow (f1
->output_data
.x
->menubar_widget
))
3798 #endif /* USE_X_TOOLKIT */
3801 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
3804 x_uncatch_errors (FRAME_X_DISPLAY (*fp
), count
);
3806 /* If not, is it one of our scroll bars? */
3809 struct scroll_bar
*bar
;
3811 bar
= x_window_to_scroll_bar (FRAME_X_DISPLAY (*fp
), win
);
3815 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3821 if (f1
== 0 && insist
> 0)
3822 f1
= SELECTED_FRAME ();
3826 /* Ok, we found a frame. Store all the values.
3827 last_mouse_glyph is a rectangle used to reduce the
3828 generation of mouse events. To not miss any motion
3829 events, we must divide the frame into rectangles of the
3830 size of the smallest character that could be displayed
3831 on it, i.e. into the same rectangles that matrices on
3832 the frame are divided into. */
3834 remember_mouse_glyph (f1
, win_x
, win_y
, &last_mouse_glyph
);
3835 last_mouse_glyph_frame
= f1
;
3840 XSETINT (*x
, win_x
);
3841 XSETINT (*y
, win_y
);
3842 *time
= last_mouse_movement_time
;
3852 /***********************************************************************
3854 ***********************************************************************/
3856 /* Scroll bar support. */
3858 /* Given an X window ID and a DISPLAY, find the struct scroll_bar which
3860 This can be called in GC, so we have to make sure to strip off mark
3863 static struct scroll_bar
*
3864 x_window_to_scroll_bar (display
, window_id
)
3870 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
3871 window_id
= (Window
) xg_get_scroll_id_for_window (display
, window_id
);
3872 #endif /* USE_GTK && USE_TOOLKIT_SCROLL_BARS */
3874 for (tail
= Vframe_list
;
3875 XGCTYPE (tail
) == Lisp_Cons
;
3878 Lisp_Object frame
, bar
, condemned
;
3880 frame
= XCAR (tail
);
3881 /* All elements of Vframe_list should be frames. */
3882 if (! GC_FRAMEP (frame
))
3885 if (! FRAME_X_P (XFRAME (frame
)))
3888 /* Scan this frame's scroll bar list for a scroll bar with the
3890 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3891 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3892 /* This trick allows us to search both the ordinary and
3893 condemned scroll bar lists with one loop. */
3894 ! GC_NILP (bar
) || (bar
= condemned
,
3897 bar
= XSCROLL_BAR (bar
)->next
)
3898 if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)) == window_id
&&
3899 FRAME_X_DISPLAY (XFRAME (frame
)) == display
)
3900 return XSCROLL_BAR (bar
);
3907 #if defined USE_LUCID
3909 /* Return the Lucid menu bar WINDOW is part of. Return null
3910 if WINDOW is not part of a menu bar. */
3913 x_window_to_menu_bar (window
)
3918 for (tail
= Vframe_list
;
3919 XGCTYPE (tail
) == Lisp_Cons
;
3922 if (FRAME_X_P (XFRAME (XCAR (tail
))))
3924 Lisp_Object frame
= XCAR (tail
);
3925 Widget menu_bar
= XFRAME (frame
)->output_data
.x
->menubar_widget
;
3927 if (menu_bar
&& xlwmenu_window_p (menu_bar
, window
))
3935 #endif /* USE_LUCID */
3938 /************************************************************************
3940 ************************************************************************/
3942 #ifdef USE_TOOLKIT_SCROLL_BARS
3944 static void x_scroll_bar_to_input_event
P_ ((XEvent
*, struct input_event
*));
3945 static void x_send_scroll_bar_event
P_ ((Lisp_Object
, int, int, int));
3946 static void x_create_toolkit_scroll_bar
P_ ((struct frame
*,
3947 struct scroll_bar
*));
3948 static void x_set_toolkit_scroll_bar_thumb
P_ ((struct scroll_bar
*,
3952 /* Lisp window being scrolled. Set when starting to interact with
3953 a toolkit scroll bar, reset to nil when ending the interaction. */
3955 static Lisp_Object window_being_scrolled
;
3957 /* Last scroll bar part sent in xm_scroll_callback. */
3959 static int last_scroll_bar_part
;
3961 /* Whether this is an Xaw with arrow-scrollbars. This should imply
3962 that movements of 1/20 of the screen size are mapped to up/down. */
3965 /* Id of action hook installed for scroll bars. */
3967 static XtActionHookId action_hook_id
;
3969 static Boolean xaw3d_arrow_scroll
;
3971 /* Whether the drag scrolling maintains the mouse at the top of the
3972 thumb. If not, resizing the thumb needs to be done more carefully
3973 to avoid jerkyness. */
3975 static Boolean xaw3d_pick_top
;
3977 /* Action hook installed via XtAppAddActionHook when toolkit scroll
3978 bars are used.. The hook is responsible for detecting when
3979 the user ends an interaction with the scroll bar, and generates
3980 a `end-scroll' SCROLL_BAR_CLICK_EVENT' event if so. */
3983 xt_action_hook (widget
, client_data
, action_name
, event
, params
,
3986 XtPointer client_data
;
3990 Cardinal
*num_params
;
3996 scroll_bar_p
= XmIsScrollBar (widget
);
3997 end_action
= "Release";
3998 #else /* !USE_MOTIF i.e. use Xaw */
3999 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
4000 end_action
= "EndScroll";
4001 #endif /* USE_MOTIF */
4004 && strcmp (action_name
, end_action
) == 0
4005 && WINDOWP (window_being_scrolled
))
4009 x_send_scroll_bar_event (window_being_scrolled
,
4010 scroll_bar_end_scroll
, 0, 0);
4011 w
= XWINDOW (window_being_scrolled
);
4013 if (!NILP (XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
))
4015 XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
= Qnil
;
4016 /* The thumb size is incorrect while dragging: fix it. */
4017 set_vertical_scroll_bar (w
);
4019 window_being_scrolled
= Qnil
;
4020 last_scroll_bar_part
= -1;
4022 /* Xt timeouts no longer needed. */
4023 toolkit_scroll_bar_interaction
= 0;
4026 #endif /* not USE_GTK */
4028 /* A vector of windows used for communication between
4029 x_send_scroll_bar_event and x_scroll_bar_to_input_event. */
4031 static struct window
**scroll_bar_windows
;
4032 static int scroll_bar_windows_size
;
4035 /* Send a client message with message type Xatom_Scrollbar for a
4036 scroll action to the frame of WINDOW. PART is a value identifying
4037 the part of the scroll bar that was clicked on. PORTION is the
4038 amount to scroll of a whole of WHOLE. */
4041 x_send_scroll_bar_event (window
, part
, portion
, whole
)
4043 int part
, portion
, whole
;
4046 XClientMessageEvent
*ev
= (XClientMessageEvent
*) &event
;
4047 struct window
*w
= XWINDOW (window
);
4048 struct frame
*f
= XFRAME (w
->frame
);
4053 /* Construct a ClientMessage event to send to the frame. */
4054 ev
->type
= ClientMessage
;
4055 ev
->message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_Scrollbar
;
4056 ev
->display
= FRAME_X_DISPLAY (f
);
4057 ev
->window
= FRAME_X_WINDOW (f
);
4060 /* We can only transfer 32 bits in the XClientMessageEvent, which is
4061 not enough to store a pointer or Lisp_Object on a 64 bit system.
4062 So, store the window in scroll_bar_windows and pass the index
4063 into that array in the event. */
4064 for (i
= 0; i
< scroll_bar_windows_size
; ++i
)
4065 if (scroll_bar_windows
[i
] == NULL
)
4068 if (i
== scroll_bar_windows_size
)
4070 int new_size
= max (10, 2 * scroll_bar_windows_size
);
4071 size_t nbytes
= new_size
* sizeof *scroll_bar_windows
;
4072 size_t old_nbytes
= scroll_bar_windows_size
* sizeof *scroll_bar_windows
;
4074 scroll_bar_windows
= (struct window
**) xrealloc (scroll_bar_windows
,
4076 bzero (&scroll_bar_windows
[i
], nbytes
- old_nbytes
);
4077 scroll_bar_windows_size
= new_size
;
4080 scroll_bar_windows
[i
] = w
;
4081 ev
->data
.l
[0] = (long) i
;
4082 ev
->data
.l
[1] = (long) part
;
4083 ev
->data
.l
[2] = (long) 0;
4084 ev
->data
.l
[3] = (long) portion
;
4085 ev
->data
.l
[4] = (long) whole
;
4087 /* Make Xt timeouts work while the scroll bar is active. */
4088 toolkit_scroll_bar_interaction
= 1;
4090 /* Setting the event mask to zero means that the message will
4091 be sent to the client that created the window, and if that
4092 window no longer exists, no event will be sent. */
4093 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
4098 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
4102 x_scroll_bar_to_input_event (event
, ievent
)
4104 struct input_event
*ievent
;
4106 XClientMessageEvent
*ev
= (XClientMessageEvent
*) event
;
4111 w
= scroll_bar_windows
[ev
->data
.l
[0]];
4112 scroll_bar_windows
[ev
->data
.l
[0]] = NULL
;
4114 XSETWINDOW (window
, w
);
4115 f
= XFRAME (w
->frame
);
4117 ievent
->kind
= SCROLL_BAR_CLICK_EVENT
;
4118 ievent
->frame_or_window
= window
;
4121 ievent
->timestamp
= CurrentTime
;
4123 ievent
->timestamp
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
4125 ievent
->part
= ev
->data
.l
[1];
4126 ievent
->code
= ev
->data
.l
[2];
4127 ievent
->x
= make_number ((int) ev
->data
.l
[3]);
4128 ievent
->y
= make_number ((int) ev
->data
.l
[4]);
4129 ievent
->modifiers
= 0;
4135 /* Minimum and maximum values used for Motif scroll bars. */
4137 #define XM_SB_MAX 10000000
4140 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
4141 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
4142 CALL_DATA is a pointer to a XmScrollBarCallbackStruct. */
4145 xm_scroll_callback (widget
, client_data
, call_data
)
4147 XtPointer client_data
, call_data
;
4149 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4150 XmScrollBarCallbackStruct
*cs
= (XmScrollBarCallbackStruct
*) call_data
;
4151 int part
= -1, whole
= 0, portion
= 0;
4155 case XmCR_DECREMENT
:
4156 bar
->dragging
= Qnil
;
4157 part
= scroll_bar_up_arrow
;
4160 case XmCR_INCREMENT
:
4161 bar
->dragging
= Qnil
;
4162 part
= scroll_bar_down_arrow
;
4165 case XmCR_PAGE_DECREMENT
:
4166 bar
->dragging
= Qnil
;
4167 part
= scroll_bar_above_handle
;
4170 case XmCR_PAGE_INCREMENT
:
4171 bar
->dragging
= Qnil
;
4172 part
= scroll_bar_below_handle
;
4176 bar
->dragging
= Qnil
;
4177 part
= scroll_bar_to_top
;
4180 case XmCR_TO_BOTTOM
:
4181 bar
->dragging
= Qnil
;
4182 part
= scroll_bar_to_bottom
;
4189 /* Get the slider size. */
4191 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
4194 whole
= XM_SB_MAX
- slider_size
;
4195 portion
= min (cs
->value
, whole
);
4196 part
= scroll_bar_handle
;
4197 bar
->dragging
= make_number (cs
->value
);
4201 case XmCR_VALUE_CHANGED
:
4207 window_being_scrolled
= bar
->window
;
4208 last_scroll_bar_part
= part
;
4209 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4214 #else /* !USE_MOTIF, i.e. Xaw or GTK */
4216 /* Scroll bar callback for GTK scroll bars. WIDGET is the scroll
4217 bar widget. DATA is a pointer to the scroll_bar structure. */
4220 xg_scroll_callback (widget
, data
)
4224 struct scroll_bar
*bar
= (struct scroll_bar
*) data
;
4230 int part
= -1, whole
= 0, portion
= 0;
4231 GtkAdjustment
*adj
= GTK_ADJUSTMENT (gtk_range_get_adjustment (widget
));
4233 position
= gtk_adjustment_get_value (adj
);
4235 p
= g_object_get_data (G_OBJECT (widget
), XG_LAST_SB_DATA
);
4238 p
= (gdouble
*) xmalloc (sizeof (gdouble
));
4240 g_object_set_data (G_OBJECT (widget
), XG_LAST_SB_DATA
, p
);
4246 if (xg_ignore_gtk_scrollbar
) return;
4248 diff
= (int) (position
- previous
);
4250 if (diff
== (int) adj
->step_increment
)
4252 part
= scroll_bar_down_arrow
;
4253 bar
->dragging
= Qnil
;
4255 else if (-diff
== (int) adj
->step_increment
)
4257 part
= scroll_bar_up_arrow
;
4258 bar
->dragging
= Qnil
;
4260 else if (diff
== (int) adj
->page_increment
)
4262 part
= scroll_bar_below_handle
;
4263 bar
->dragging
= Qnil
;
4265 else if (-diff
== (int) adj
->page_increment
)
4267 part
= scroll_bar_above_handle
;
4268 bar
->dragging
= Qnil
;
4272 part
= scroll_bar_handle
;
4273 whole
= adj
->upper
- adj
->page_size
;
4274 portion
= min ((int)position
, whole
);
4275 bar
->dragging
= make_number ((int)portion
);
4280 window_being_scrolled
= bar
->window
;
4281 last_scroll_bar_part
= part
;
4282 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4286 #else /* not USE_GTK */
4288 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
4289 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
4290 scroll bar struct. CALL_DATA is a pointer to a float saying where
4294 xaw_jump_callback (widget
, client_data
, call_data
)
4296 XtPointer client_data
, call_data
;
4298 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4299 float top
= *(float *) call_data
;
4301 int whole
, portion
, height
;
4304 /* Get the size of the thumb, a value between 0 and 1. */
4306 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
4310 portion
= shown
< 1 ? top
* whole
: 0;
4312 if (shown
< 1 && (abs (top
+ shown
- 1) < 1.0/height
))
4313 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
4314 the bottom, so we force the scrolling whenever we see that we're
4315 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
4316 we try to ensure that we always stay two pixels away from the
4318 part
= scroll_bar_down_arrow
;
4320 part
= scroll_bar_handle
;
4322 window_being_scrolled
= bar
->window
;
4323 bar
->dragging
= make_number (portion
);
4324 last_scroll_bar_part
= part
;
4325 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4329 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
4330 i.e. line or page up or down. WIDGET is the Xaw scroll bar
4331 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
4332 the scroll bar. CALL_DATA is an integer specifying the action that
4333 has taken place. Its magnitude is in the range 0..height of the
4334 scroll bar. Negative values mean scroll towards buffer start.
4335 Values < height of scroll bar mean line-wise movement. */
4338 xaw_scroll_callback (widget
, client_data
, call_data
)
4340 XtPointer client_data
, call_data
;
4342 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4343 /* The position really is stored cast to a pointer. */
4344 int position
= (long) call_data
;
4348 /* Get the height of the scroll bar. */
4350 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
4353 if (abs (position
) >= height
)
4354 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
4356 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
4357 it maps line-movement to call_data = max(5, height/20). */
4358 else if (xaw3d_arrow_scroll
&& abs (position
) <= max (5, height
/ 20))
4359 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
4361 part
= scroll_bar_move_ratio
;
4363 window_being_scrolled
= bar
->window
;
4364 bar
->dragging
= Qnil
;
4365 last_scroll_bar_part
= part
;
4366 x_send_scroll_bar_event (bar
->window
, part
, position
, height
);
4369 #endif /* not USE_GTK */
4370 #endif /* not USE_MOTIF */
4372 #define SCROLL_BAR_NAME "verticalScrollBar"
4374 /* Create the widget for scroll bar BAR on frame F. Record the widget
4375 and X window of the scroll bar in BAR. */
4379 x_create_toolkit_scroll_bar (f
, bar
)
4381 struct scroll_bar
*bar
;
4383 char *scroll_bar_name
= SCROLL_BAR_NAME
;
4386 xg_create_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
4391 #else /* not USE_GTK */
4394 x_create_toolkit_scroll_bar (f
, bar
)
4396 struct scroll_bar
*bar
;
4402 char *scroll_bar_name
= SCROLL_BAR_NAME
;
4403 unsigned long pixel
;
4408 /* Set resources. Create the widget. */
4409 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4410 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
4411 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
4412 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
4413 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
4414 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
4415 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
4417 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4420 XtSetArg (av
[ac
], XmNforeground
, pixel
);
4424 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4427 XtSetArg (av
[ac
], XmNbackground
, pixel
);
4431 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
4432 scroll_bar_name
, av
, ac
);
4434 /* Add one callback for everything that can happen. */
4435 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
4437 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
4439 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
4441 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
4443 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
4445 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
4447 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
4450 /* Realize the widget. Only after that is the X window created. */
4451 XtRealizeWidget (widget
);
4453 /* Set the cursor to an arrow. I didn't find a resource to do that.
4454 And I'm wondering why it hasn't an arrow cursor by default. */
4455 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
4456 f
->output_data
.x
->nontext_cursor
);
4458 #else /* !USE_MOTIF i.e. use Xaw */
4460 /* Set resources. Create the widget. The background of the
4461 Xaw3d scroll bar widget is a little bit light for my taste.
4462 We don't alter it here to let users change it according
4463 to their taste with `emacs*verticalScrollBar.background: xxx'. */
4464 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4465 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
4466 /* For smoother scrolling with Xaw3d -sm */
4467 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
4469 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4472 XtSetArg (av
[ac
], XtNforeground
, pixel
);
4476 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4479 XtSetArg (av
[ac
], XtNbackground
, pixel
);
4483 /* Top/bottom shadow colors. */
4485 /* Allocate them, if necessary. */
4486 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
4488 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4489 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
4490 &pixel
, 1.2, 0x8000))
4492 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
4494 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4496 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4497 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
4498 &pixel
, 0.6, 0x4000))
4500 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
4503 #ifdef XtNbeNiceToColormap
4504 /* Tell the toolkit about them. */
4505 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
4506 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4507 /* We tried to allocate a color for the top/bottom shadow, and
4508 failed, so tell Xaw3d to use dithering instead. */
4510 XtSetArg (av
[ac
], XtNbeNiceToColormap
, True
);
4514 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
4515 be more consistent with other emacs 3d colors, and since Xaw3d is
4516 not good at dealing with allocation failure. */
4518 /* This tells Xaw3d to use real colors instead of dithering for
4520 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
4523 /* Specify the colors. */
4524 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
4527 XtSetArg (av
[ac
], XtNtopShadowPixel
, pixel
);
4530 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
4533 XtSetArg (av
[ac
], XtNbottomShadowPixel
, pixel
);
4539 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
4540 f
->output_data
.x
->edit_widget
, av
, ac
);
4544 char *val
= initial
;
4545 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
4546 #ifdef XtNarrowScrollbars
4547 XtNarrowScrollbars
, (XtPointer
) &xaw3d_arrow_scroll
,
4549 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
4550 if (xaw3d_arrow_scroll
|| val
== initial
)
4551 { /* ARROW_SCROLL */
4552 xaw3d_arrow_scroll
= True
;
4553 /* Isn't that just a personal preference ? --Stef */
4554 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
4558 /* Define callbacks. */
4559 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
4560 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
4563 /* Realize the widget. Only after that is the X window created. */
4564 XtRealizeWidget (widget
);
4566 #endif /* !USE_MOTIF */
4568 /* Install an action hook that lets us detect when the user
4569 finishes interacting with a scroll bar. */
4570 if (action_hook_id
== 0)
4571 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
4573 /* Remember X window and widget in the scroll bar vector. */
4574 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
4575 xwindow
= XtWindow (widget
);
4576 SET_SCROLL_BAR_X_WINDOW (bar
, xwindow
);
4580 #endif /* not USE_GTK */
4583 /* Set the thumb size and position of scroll bar BAR. We are currently
4584 displaying PORTION out of a whole WHOLE, and our position POSITION. */
4588 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
4589 struct scroll_bar
*bar
;
4590 int portion
, position
, whole
;
4592 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
4595 #else /* not USE_GTK */
4597 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
4598 struct scroll_bar
*bar
;
4599 int portion
, position
, whole
;
4601 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4602 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4609 /* We use an estimate of 30 chars per line rather than the real
4610 `portion' value. This has the disadvantage that the thumb size
4611 is not very representative, but it makes our life a lot easier.
4612 Otherwise, we have to constantly adjust the thumb size, which
4613 we can't always do quickly enough: while dragging, the size of
4614 the thumb might prevent the user from dragging the thumb all the
4615 way to the end. but Motif and some versions of Xaw3d don't allow
4616 updating the thumb size while dragging. Also, even if we can update
4617 its size, the update will often happen too late.
4618 If you don't believe it, check out revision 1.650 of xterm.c to see
4619 what hoops we were going through and the still poor behavior we got. */
4620 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
4621 /* When the thumb is at the bottom, position == whole.
4622 So we need to increase `whole' to make space for the thumb. */
4629 top
= (float) position
/ whole
;
4630 shown
= (float) portion
/ whole
;
4633 if (NILP (bar
->dragging
))
4637 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
4638 is the scroll bar's maximum and MIN is the scroll bar's minimum
4640 size
= shown
* XM_SB_MAX
;
4641 size
= min (size
, XM_SB_MAX
);
4642 size
= max (size
, 1);
4644 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
4645 value
= top
* XM_SB_MAX
;
4646 value
= min (value
, XM_SB_MAX
- size
);
4648 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
4650 #else /* !USE_MOTIF i.e. use Xaw */
4656 top
= (float) position
/ whole
;
4657 shown
= (float) portion
/ whole
;
4661 float old_top
, old_shown
;
4663 XtVaGetValues (widget
,
4664 XtNtopOfThumb
, &old_top
,
4665 XtNshown
, &old_shown
,
4669 /* Massage the top+shown values. */
4670 if (NILP (bar
->dragging
) || last_scroll_bar_part
== scroll_bar_down_arrow
)
4671 top
= max (0, min (1, top
));
4674 /* Keep two pixels available for moving the thumb down. */
4675 shown
= max (0, min (1 - top
- (2.0 / height
), shown
));
4677 /* If the call to XawScrollbarSetThumb below doesn't seem to work,
4678 check that your system's configuration file contains a define
4679 for `NARROWPROTO'. See s/freebsd.h for an example. */
4680 if (top
!= old_top
|| shown
!= old_shown
)
4682 if (NILP (bar
->dragging
))
4683 XawScrollbarSetThumb (widget
, top
, shown
);
4686 /* Try to make the scrolling a tad smoother. */
4687 if (!xaw3d_pick_top
)
4688 shown
= min (shown
, old_shown
);
4690 XawScrollbarSetThumb (widget
, top
, shown
);
4694 #endif /* !USE_MOTIF */
4698 #endif /* not USE_GTK */
4700 #endif /* USE_TOOLKIT_SCROLL_BARS */
4704 /************************************************************************
4705 Scroll bars, general
4706 ************************************************************************/
4708 /* Create a scroll bar and return the scroll bar vector for it. W is
4709 the Emacs window on which to create the scroll bar. TOP, LEFT,
4710 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
4713 static struct scroll_bar
*
4714 x_scroll_bar_create (w
, top
, left
, width
, height
)
4716 int top
, left
, width
, height
;
4718 struct frame
*f
= XFRAME (w
->frame
);
4719 struct scroll_bar
*bar
4720 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
4724 #ifdef USE_TOOLKIT_SCROLL_BARS
4725 x_create_toolkit_scroll_bar (f
, bar
);
4726 #else /* not USE_TOOLKIT_SCROLL_BARS */
4728 XSetWindowAttributes a
;
4732 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4733 if (a
.background_pixel
== -1)
4734 a
.background_pixel
= f
->output_data
.x
->background_pixel
;
4736 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
4737 | ButtonMotionMask
| PointerMotionHintMask
4739 a
.cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
4741 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
4743 /* Clear the area of W that will serve as a scroll bar. This is
4744 for the case that a window has been split horizontally. In
4745 this case, no clear_frame is generated to reduce flickering. */
4746 if (width
> 0 && height
> 0)
4747 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4749 window_box_height (w
), False
);
4751 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4752 /* Position and size of scroll bar. */
4753 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4755 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4757 /* Border width, depth, class, and visual. */
4764 SET_SCROLL_BAR_X_WINDOW (bar
, window
);
4766 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4768 XSETWINDOW (bar
->window
, w
);
4769 XSETINT (bar
->top
, top
);
4770 XSETINT (bar
->left
, left
);
4771 XSETINT (bar
->width
, width
);
4772 XSETINT (bar
->height
, height
);
4773 XSETINT (bar
->start
, 0);
4774 XSETINT (bar
->end
, 0);
4775 bar
->dragging
= Qnil
;
4777 /* Add bar to its frame's list of scroll bars. */
4778 bar
->next
= FRAME_SCROLL_BARS (f
);
4780 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
4781 if (!NILP (bar
->next
))
4782 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4784 /* Map the window/widget. */
4785 #ifdef USE_TOOLKIT_SCROLL_BARS
4788 xg_update_scrollbar_pos (f
,
4789 SCROLL_BAR_X_WINDOW (bar
),
4791 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4792 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4794 xg_show_scroll_bar (SCROLL_BAR_X_WINDOW (bar
));
4795 #else /* not USE_GTK */
4796 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4797 XtConfigureWidget (scroll_bar
,
4798 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4800 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4801 max (height
, 1), 0);
4802 XtMapWidget (scroll_bar
);
4803 #endif /* not USE_GTK */
4805 #else /* not USE_TOOLKIT_SCROLL_BARS */
4806 XMapRaised (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
4807 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4814 /* Draw BAR's handle in the proper position.
4816 If the handle is already drawn from START to END, don't bother
4817 redrawing it, unless REBUILD is non-zero; in that case, always
4818 redraw it. (REBUILD is handy for drawing the handle after expose
4821 Normally, we want to constrain the start and end of the handle to
4822 fit inside its rectangle, but if the user is dragging the scroll
4823 bar handle, we want to let them drag it down all the way, so that
4824 the bar's top is as far down as it goes; otherwise, there's no way
4825 to move to the very end of the buffer. */
4827 #ifndef USE_TOOLKIT_SCROLL_BARS
4830 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
4831 struct scroll_bar
*bar
;
4835 int dragging
= ! NILP (bar
->dragging
);
4836 Window w
= SCROLL_BAR_X_WINDOW (bar
);
4837 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4838 GC gc
= f
->output_data
.x
->normal_gc
;
4840 /* If the display is already accurate, do nothing. */
4842 && start
== XINT (bar
->start
)
4843 && end
== XINT (bar
->end
))
4849 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, XINT (bar
->width
));
4850 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
4851 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
4853 /* Make sure the values are reasonable, and try to preserve
4854 the distance between start and end. */
4856 int length
= end
- start
;
4860 else if (start
> top_range
)
4862 end
= start
+ length
;
4866 else if (end
> top_range
&& ! dragging
)
4870 /* Store the adjusted setting in the scroll bar. */
4871 XSETINT (bar
->start
, start
);
4872 XSETINT (bar
->end
, end
);
4874 /* Clip the end position, just for display. */
4875 if (end
> top_range
)
4878 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
4879 below top positions, to make sure the handle is always at least
4880 that many pixels tall. */
4881 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4883 /* Draw the empty space above the handle. Note that we can't clear
4884 zero-height areas; that means "clear to end of window." */
4886 x_clear_area (FRAME_X_DISPLAY (f
), w
,
4887 /* x, y, width, height, and exposures. */
4888 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4889 VERTICAL_SCROLL_BAR_TOP_BORDER
,
4890 inside_width
, start
,
4893 /* Change to proper foreground color if one is specified. */
4894 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
4895 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
4896 f
->output_data
.x
->scroll_bar_foreground_pixel
);
4898 /* Draw the handle itself. */
4899 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
4900 /* x, y, width, height */
4901 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4902 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
4903 inside_width
, end
- start
);
4905 /* Restore the foreground color of the GC if we changed it above. */
4906 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
4907 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
4908 f
->output_data
.x
->foreground_pixel
);
4910 /* Draw the empty space below the handle. Note that we can't
4911 clear zero-height areas; that means "clear to end of window." */
4912 if (end
< inside_height
)
4913 x_clear_area (FRAME_X_DISPLAY (f
), w
,
4914 /* x, y, width, height, and exposures. */
4915 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4916 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
4917 inside_width
, inside_height
- end
,
4925 #endif /* !USE_TOOLKIT_SCROLL_BARS */
4927 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
4931 x_scroll_bar_remove (bar
)
4932 struct scroll_bar
*bar
;
4934 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4937 #ifdef USE_TOOLKIT_SCROLL_BARS
4939 xg_remove_scroll_bar (f
, SCROLL_BAR_X_WINDOW (bar
));
4940 #else /* not USE_GTK */
4941 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
4942 #endif /* not USE_GTK */
4944 XDestroyWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
4947 /* Disassociate this scroll bar from its window. */
4948 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
4954 /* Set the handle of the vertical scroll bar for WINDOW to indicate
4955 that we are displaying PORTION characters out of a total of WHOLE
4956 characters, starting at POSITION. If WINDOW has no scroll bar,
4960 XTset_vertical_scroll_bar (w
, portion
, whole
, position
)
4962 int portion
, whole
, position
;
4964 struct frame
*f
= XFRAME (w
->frame
);
4965 struct scroll_bar
*bar
;
4966 int top
, height
, left
, sb_left
, width
, sb_width
;
4967 int window_y
, window_height
;
4969 /* Get window dimensions. */
4970 window_box (w
, -1, 0, &window_y
, 0, &window_height
);
4972 width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
4973 height
= window_height
;
4975 /* Compute the left edge of the scroll bar area. */
4976 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
4978 /* Compute the width of the scroll bar which might be less than
4979 the width of the area reserved for the scroll bar. */
4980 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
) > 0)
4981 sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
4985 /* Compute the left edge of the scroll bar. */
4986 #ifdef USE_TOOLKIT_SCROLL_BARS
4987 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
4989 (WINDOW_RIGHTMOST_P (w
)
4990 ? width
- sb_width
- (width
- sb_width
) / 2
4994 (WINDOW_LEFTMOST_P (w
)
4995 ? (width
- sb_width
) / 2
4996 : width
- sb_width
));
4998 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
4999 sb_left
= left
+ width
- sb_width
;
5004 /* Does the scroll bar exist yet? */
5005 if (NILP (w
->vertical_scroll_bar
))
5007 if (width
> 0 && height
> 0)
5010 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5011 left
, top
, width
, height
, False
);
5015 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
5019 /* It may just need to be moved and resized. */
5020 unsigned int mask
= 0;
5022 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5026 if (sb_left
!= XINT (bar
->left
))
5028 if (top
!= XINT (bar
->top
))
5030 if (sb_width
!= XINT (bar
->width
))
5032 if (height
!= XINT (bar
->height
))
5035 #ifdef USE_TOOLKIT_SCROLL_BARS
5037 /* Move/size the scroll bar widget. */
5040 /* Since toolkit scroll bars are smaller than the space reserved
5041 for them on the frame, we have to clear "under" them. */
5042 if (width
> 0 && height
> 0)
5043 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5044 left
, top
, width
, height
, False
);
5046 xg_update_scrollbar_pos (f
,
5047 SCROLL_BAR_X_WINDOW (bar
),
5049 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5050 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
*2,
5052 #else /* not USE_GTK */
5053 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
5054 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5056 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
5057 max (height
, 1), 0);
5058 #endif /* not USE_GTK */
5060 #else /* not USE_TOOLKIT_SCROLL_BARS */
5062 /* Clear areas not covered by the scroll bar because of
5063 VERTICAL_SCROLL_BAR_WIDTH_TRIM. */
5064 if (VERTICAL_SCROLL_BAR_WIDTH_TRIM
)
5066 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5067 left
, top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5069 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5070 left
+ width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5071 top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5075 /* Clear areas not covered by the scroll bar because it's not as
5076 wide as the area reserved for it. This makes sure a
5077 previous mode line display is cleared after C-x 2 C-x 1, for
5080 int area_width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
5081 int rest
= area_width
- sb_width
;
5082 if (rest
> 0 && height
> 0)
5084 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
5085 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5086 left
+ area_width
- rest
, top
,
5087 rest
, height
, False
);
5089 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5090 left
, top
, rest
, height
, False
);
5094 /* Move/size the scroll bar window. */
5099 wc
.x
= sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5101 wc
.width
= sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2;
5103 XConfigureWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
),
5107 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5109 /* Remember new settings. */
5110 XSETINT (bar
->left
, sb_left
);
5111 XSETINT (bar
->top
, top
);
5112 XSETINT (bar
->width
, sb_width
);
5113 XSETINT (bar
->height
, height
);
5118 #ifdef USE_TOOLKIT_SCROLL_BARS
5119 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
5120 #else /* not USE_TOOLKIT_SCROLL_BARS */
5121 /* Set the scroll bar's current state, unless we're currently being
5123 if (NILP (bar
->dragging
))
5125 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
5128 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
5131 int start
= ((double) position
* top_range
) / whole
;
5132 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
5133 x_scroll_bar_set_handle (bar
, start
, end
, 0);
5136 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5138 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
5142 /* The following three hooks are used when we're doing a thorough
5143 redisplay of the frame. We don't explicitly know which scroll bars
5144 are going to be deleted, because keeping track of when windows go
5145 away is a real pain - "Can you say set-window-configuration, boys
5146 and girls?" Instead, we just assert at the beginning of redisplay
5147 that *all* scroll bars are to be removed, and then save a scroll bar
5148 from the fiery pit when we actually redisplay its window. */
5150 /* Arrange for all scroll bars on FRAME to be removed at the next call
5151 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
5152 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
5155 XTcondemn_scroll_bars (frame
)
5158 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
5159 while (! NILP (FRAME_SCROLL_BARS (frame
)))
5162 bar
= FRAME_SCROLL_BARS (frame
);
5163 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
5164 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
5165 XSCROLL_BAR (bar
)->prev
= Qnil
;
5166 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
5167 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
5168 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
5173 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
5174 Note that WINDOW isn't necessarily condemned at all. */
5177 XTredeem_scroll_bar (window
)
5178 struct window
*window
;
5180 struct scroll_bar
*bar
;
5183 /* We can't redeem this window's scroll bar if it doesn't have one. */
5184 if (NILP (window
->vertical_scroll_bar
))
5187 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
5189 /* Unlink it from the condemned list. */
5190 f
= XFRAME (WINDOW_FRAME (window
));
5191 if (NILP (bar
->prev
))
5193 /* If the prev pointer is nil, it must be the first in one of
5195 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
5196 /* It's not condemned. Everything's fine. */
5198 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
5199 window
->vertical_scroll_bar
))
5200 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
5202 /* If its prev pointer is nil, it must be at the front of
5203 one or the other! */
5207 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
5209 if (! NILP (bar
->next
))
5210 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
5212 bar
->next
= FRAME_SCROLL_BARS (f
);
5214 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
5215 if (! NILP (bar
->next
))
5216 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
5219 /* Remove all scroll bars on FRAME that haven't been saved since the
5220 last call to `*condemn_scroll_bars_hook'. */
5223 XTjudge_scroll_bars (f
)
5226 Lisp_Object bar
, next
;
5228 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
5230 /* Clear out the condemned list now so we won't try to process any
5231 more events on the hapless scroll bars. */
5232 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
5234 for (; ! NILP (bar
); bar
= next
)
5236 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
5238 x_scroll_bar_remove (b
);
5241 b
->next
= b
->prev
= Qnil
;
5244 /* Now there should be no references to the condemned scroll bars,
5245 and they should get garbage-collected. */
5249 #ifndef USE_TOOLKIT_SCROLL_BARS
5250 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
5251 is a no-op when using toolkit scroll bars.
5253 This may be called from a signal handler, so we have to ignore GC
5257 x_scroll_bar_expose (bar
, event
)
5258 struct scroll_bar
*bar
;
5261 Window w
= SCROLL_BAR_X_WINDOW (bar
);
5262 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5263 GC gc
= f
->output_data
.x
->normal_gc
;
5264 int width_trim
= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5268 x_scroll_bar_set_handle (bar
, XINT (bar
->start
), XINT (bar
->end
), 1);
5270 /* Draw a one-pixel border just inside the edges of the scroll bar. */
5271 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
5273 /* x, y, width, height */
5275 XINT (bar
->width
) - 1 - width_trim
- width_trim
,
5276 XINT (bar
->height
) - 1);
5281 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5283 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
5284 is set to something other than NO_EVENT, it is enqueued.
5286 This may be called from a signal handler, so we have to ignore GC
5291 x_scroll_bar_handle_click (bar
, event
, emacs_event
)
5292 struct scroll_bar
*bar
;
5294 struct input_event
*emacs_event
;
5296 if (! GC_WINDOWP (bar
->window
))
5299 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
5300 emacs_event
->code
= event
->xbutton
.button
- Button1
;
5301 emacs_event
->modifiers
5302 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
5303 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
5304 event
->xbutton
.state
)
5305 | (event
->type
== ButtonRelease
5308 emacs_event
->frame_or_window
= bar
->window
;
5309 emacs_event
->arg
= Qnil
;
5310 emacs_event
->timestamp
= event
->xbutton
.time
;
5313 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5315 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
5318 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
5319 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
5322 if (y
> top_range
) y
= top_range
;
5324 if (y
< XINT (bar
->start
))
5325 emacs_event
->part
= scroll_bar_above_handle
;
5326 else if (y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5327 emacs_event
->part
= scroll_bar_handle
;
5329 emacs_event
->part
= scroll_bar_below_handle
;
5331 /* Just because the user has clicked on the handle doesn't mean
5332 they want to drag it. Lisp code needs to be able to decide
5333 whether or not we're dragging. */
5335 /* If the user has just clicked on the handle, record where they're
5337 if (event
->type
== ButtonPress
5338 && emacs_event
->part
== scroll_bar_handle
)
5339 XSETINT (bar
->dragging
, y
- XINT (bar
->start
));
5342 #ifndef USE_TOOLKIT_SCROLL_BARS
5343 /* If the user has released the handle, set it to its final position. */
5344 if (event
->type
== ButtonRelease
5345 && ! NILP (bar
->dragging
))
5347 int new_start
= y
- XINT (bar
->dragging
);
5348 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
5350 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5351 bar
->dragging
= Qnil
;
5355 /* Same deal here as the other #if 0. */
5357 /* Clicks on the handle are always reported as occurring at the top of
5359 if (emacs_event
->part
== scroll_bar_handle
)
5360 emacs_event
->x
= bar
->start
;
5362 XSETINT (emacs_event
->x
, y
);
5364 XSETINT (emacs_event
->x
, y
);
5367 XSETINT (emacs_event
->y
, top_range
);
5371 #ifndef USE_TOOLKIT_SCROLL_BARS
5373 /* Handle some mouse motion while someone is dragging the scroll bar.
5375 This may be called from a signal handler, so we have to ignore GC
5379 x_scroll_bar_note_movement (bar
, event
)
5380 struct scroll_bar
*bar
;
5383 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
5385 last_mouse_movement_time
= event
->xmotion
.time
;
5388 XSETVECTOR (last_mouse_scroll_bar
, bar
);
5390 /* If we're dragging the bar, display it. */
5391 if (! GC_NILP (bar
->dragging
))
5393 /* Where should the handle be now? */
5394 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
5396 if (new_start
!= XINT (bar
->start
))
5398 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
5400 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5405 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5407 /* Return information to the user about the current position of the mouse
5408 on the scroll bar. */
5411 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
5413 Lisp_Object
*bar_window
;
5414 enum scroll_bar_part
*part
;
5416 unsigned long *time
;
5418 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
5419 Window w
= SCROLL_BAR_X_WINDOW (bar
);
5420 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5422 Window dummy_window
;
5424 unsigned int dummy_mask
;
5428 /* Get the mouse's position relative to the scroll bar window, and
5430 if (! XQueryPointer (FRAME_X_DISPLAY (f
), w
,
5432 /* Root, child, root x and root y. */
5433 &dummy_window
, &dummy_window
,
5434 &dummy_coord
, &dummy_coord
,
5436 /* Position relative to scroll bar. */
5439 /* Mouse buttons and modifier keys. */
5446 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
5449 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
5451 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
5453 if (! NILP (bar
->dragging
))
5454 win_y
-= XINT (bar
->dragging
);
5458 if (win_y
> top_range
)
5462 *bar_window
= bar
->window
;
5464 if (! NILP (bar
->dragging
))
5465 *part
= scroll_bar_handle
;
5466 else if (win_y
< XINT (bar
->start
))
5467 *part
= scroll_bar_above_handle
;
5468 else if (win_y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5469 *part
= scroll_bar_handle
;
5471 *part
= scroll_bar_below_handle
;
5473 XSETINT (*x
, win_y
);
5474 XSETINT (*y
, top_range
);
5477 last_mouse_scroll_bar
= Qnil
;
5480 *time
= last_mouse_movement_time
;
5486 /* The screen has been cleared so we may have changed foreground or
5487 background colors, and the scroll bars may need to be redrawn.
5488 Clear out the scroll bars, and ask for expose events, so we can
5492 x_scroll_bar_clear (f
)
5495 #ifndef USE_TOOLKIT_SCROLL_BARS
5498 /* We can have scroll bars even if this is 0,
5499 if we just turned off scroll bar mode.
5500 But in that case we should not clear them. */
5501 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5502 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
5503 bar
= XSCROLL_BAR (bar
)->next
)
5504 XClearArea (FRAME_X_DISPLAY (f
),
5505 SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)),
5507 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5511 /* The main X event-reading loop - XTread_socket. */
5514 /* Time stamp of enter window event. This is only used by XTread_socket,
5515 but we have to put it out here, since static variables within functions
5516 sometimes don't work. */
5518 static Time enter_timestamp
;
5521 /* This holds the state XLookupString needs to implement dead keys
5522 and other tricks known as "compose processing". _X Window System_
5523 says that a portable program can't use this, but Stephen Gildea assures
5524 me that letting the compiler initialize it to zeros will work okay.
5526 This must be defined outside of XTread_socket, for the same reasons
5527 given for enter_timestamp, above. */
5529 static XComposeStatus compose_status
;
5531 /* Record the last 100 characters stored
5532 to help debug the loss-of-chars-during-GC problem. */
5534 static int temp_index
;
5535 static short temp_buffer
[100];
5537 #define STORE_KEYSYM_FOR_DEBUG(keysym) \
5538 if (temp_index == sizeof temp_buffer / sizeof (short)) \
5540 temp_buffer[temp_index++] = (keysym)
5542 /* Set this to nonzero to fake an "X I/O error"
5543 on a particular display. */
5545 struct x_display_info
*XTread_socket_fake_io_error
;
5547 /* When we find no input here, we occasionally do a no-op command
5548 to verify that the X server is still running and we can still talk with it.
5549 We try all the open displays, one by one.
5550 This variable is used for cycling thru the displays. */
5552 static struct x_display_info
*next_noop_dpyinfo
;
5554 #define SET_SAVED_MENU_EVENT(size) \
5557 if (f->output_data.x->saved_menu_event == 0) \
5558 f->output_data.x->saved_menu_event \
5559 = (XEvent *) xmalloc (sizeof (XEvent)); \
5560 bcopy (&event, f->output_data.x->saved_menu_event, size); \
5561 inev.ie.kind = MENU_BAR_ACTIVATE_EVENT; \
5562 XSETFRAME (inev.ie.frame_or_window, f); \
5566 #define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
5567 #define SET_SAVED_KEY_EVENT SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
5577 /* Filter events for the current X input method.
5578 DPYINFO is the display this event is for.
5579 EVENT is the X event to filter.
5581 Returns non-zero if the event was filtered, caller shall not process
5583 Returns zero if event is wasn't filtered. */
5587 x_filter_event (dpyinfo
, event
)
5588 struct x_display_info
*dpyinfo
;
5591 /* XFilterEvent returns non-zero if the input method has
5592 consumed the event. We pass the frame's X window to
5593 XFilterEvent because that's the one for which the IC
5596 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
5597 event
->xclient
.window
);
5599 return XFilterEvent (event
, f1
? FRAME_X_WINDOW (f1
) : None
);
5604 static int current_count
;
5605 static int current_finish
;
5606 static struct input_event
*current_hold_quit
;
5608 /* This is the filter function invoked by the GTK event loop.
5609 It is invoked before the XEvent is translated to a GdkEvent,
5610 so we have a chance to act on the event before GTK. */
5611 static GdkFilterReturn
5612 event_handler_gdk (gxev
, ev
, data
)
5617 XEvent
*xev
= (XEvent
*) gxev
;
5619 if (current_count
>= 0)
5621 struct x_display_info
*dpyinfo
;
5623 dpyinfo
= x_display_info_for_display (xev
->xany
.display
);
5626 /* Filter events for the current X input method.
5627 GTK calls XFilterEvent but not for key press and release,
5628 so we do it here. */
5629 if (xev
->type
== KeyPress
|| xev
->type
== KeyRelease
)
5630 if (dpyinfo
&& x_filter_event (dpyinfo
, xev
))
5631 return GDK_FILTER_REMOVE
;
5635 current_finish
= X_EVENT_NORMAL
;
5639 handle_one_xevent (dpyinfo
, xev
, ¤t_finish
,
5644 current_finish
= x_dispatch_event (xev
, xev
->xany
.display
);
5646 if (current_finish
== X_EVENT_GOTO_OUT
|| current_finish
== X_EVENT_DROP
)
5647 return GDK_FILTER_REMOVE
;
5649 return GDK_FILTER_CONTINUE
;
5651 #endif /* USE_GTK */
5654 /* Handles the XEvent EVENT on display DPYINFO.
5656 *FINISH is X_EVENT_GOTO_OUT if caller should stop reading events.
5657 *FINISH is zero if caller should continue reading events.
5658 *FINISH is X_EVENT_DROP if event should not be passed to the toolkit.
5660 We return the number of characters stored into the buffer. */
5663 handle_one_xevent (dpyinfo
, eventp
, finish
, hold_quit
)
5664 struct x_display_info
*dpyinfo
;
5667 struct input_event
*hold_quit
;
5670 struct input_event ie
;
5671 struct selection_input_event sie
;
5676 struct frame
*f
= NULL
;
5677 struct coding_system coding
;
5678 XEvent event
= *eventp
;
5680 *finish
= X_EVENT_NORMAL
;
5682 EVENT_INIT (inev
.ie
);
5683 inev
.ie
.kind
= NO_EVENT
;
5690 if (event
.xclient
.message_type
5691 == dpyinfo
->Xatom_wm_protocols
5692 && event
.xclient
.format
== 32)
5694 if (event
.xclient
.data
.l
[0]
5695 == dpyinfo
->Xatom_wm_take_focus
)
5697 /* Use x_any_window_to_frame because this
5698 could be the shell widget window
5699 if the frame has no title bar. */
5700 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5702 /* Not quite sure this is needed -pd */
5703 if (f
&& FRAME_XIC (f
))
5704 XSetICFocus (FRAME_XIC (f
));
5706 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
5707 instructs the WM to set the input focus automatically for
5708 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
5709 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
5710 it has set the focus. So, XSetInputFocus below is not
5713 The call to XSetInputFocus below has also caused trouble. In
5714 cases where the XSetInputFocus done by the WM and the one
5715 below are temporally close (on a fast machine), the call
5716 below can generate additional FocusIn events which confuse
5719 /* Since we set WM_TAKE_FOCUS, we must call
5720 XSetInputFocus explicitly. But not if f is null,
5721 since that might be an event for a deleted frame. */
5724 Display
*d
= event
.xclient
.display
;
5725 /* Catch and ignore errors, in case window has been
5726 iconified by a window manager such as GWM. */
5727 int count
= x_catch_errors (d
);
5728 XSetInputFocus (d
, event
.xclient
.window
,
5729 /* The ICCCM says this is
5730 the only valid choice. */
5732 event
.xclient
.data
.l
[1]);
5733 /* This is needed to detect the error
5734 if there is an error. */
5736 x_uncatch_errors (d
, count
);
5738 /* Not certain about handling scroll bars here */
5743 if (event
.xclient
.data
.l
[0]
5744 == dpyinfo
->Xatom_wm_save_yourself
)
5746 /* Save state modify the WM_COMMAND property to
5747 something which can reinstate us. This notifies
5748 the session manager, who's looking for such a
5749 PropertyNotify. Can restart processing when
5750 a keyboard or mouse event arrives. */
5751 /* If we have a session manager, don't set this.
5752 KDE will then start two Emacsen, one for the
5753 session manager and one for this. */
5755 if (! x_session_have_connection ())
5758 f
= x_top_window_to_frame (dpyinfo
,
5759 event
.xclient
.window
);
5760 /* This is just so we only give real data once
5761 for a single Emacs process. */
5762 if (f
== SELECTED_FRAME ())
5763 XSetCommand (FRAME_X_DISPLAY (f
),
5764 event
.xclient
.window
,
5765 initial_argv
, initial_argc
);
5767 XSetCommand (FRAME_X_DISPLAY (f
),
5768 event
.xclient
.window
,
5774 if (event
.xclient
.data
.l
[0]
5775 == dpyinfo
->Xatom_wm_delete_window
)
5777 f
= x_any_window_to_frame (dpyinfo
,
5778 event
.xclient
.window
);
5780 goto OTHER
; /* May be a dialog that is to be removed */
5782 inev
.ie
.kind
= DELETE_WINDOW_EVENT
;
5783 XSETFRAME (inev
.ie
.frame_or_window
, f
);
5790 if (event
.xclient
.message_type
5791 == dpyinfo
->Xatom_wm_configure_denied
)
5796 if (event
.xclient
.message_type
5797 == dpyinfo
->Xatom_wm_window_moved
)
5800 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
5802 new_x
= event
.xclient
.data
.s
[0];
5803 new_y
= event
.xclient
.data
.s
[1];
5807 f
->left_pos
= new_x
;
5814 if (event
.xclient
.message_type
5815 == dpyinfo
->Xatom_editres
)
5817 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5818 _XEditResCheckMessages (f
->output_data
.x
->widget
, NULL
,
5822 #endif /* HACK_EDITRES */
5824 if ((event
.xclient
.message_type
5825 == dpyinfo
->Xatom_DONE
)
5826 || (event
.xclient
.message_type
5827 == dpyinfo
->Xatom_PAGE
))
5829 /* Ghostview job completed. Kill it. We could
5830 reply with "Next" if we received "Page", but we
5831 currently never do because we are interested in
5832 images, only, which should have 1 page. */
5833 Pixmap pixmap
= (Pixmap
) event
.xclient
.data
.l
[1];
5834 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
5835 x_kill_gs_process (pixmap
, f
);
5836 expose_frame (f
, 0, 0, 0, 0);
5840 #ifdef USE_TOOLKIT_SCROLL_BARS
5841 /* Scroll bar callbacks send a ClientMessage from which
5842 we construct an input_event. */
5843 if (event
.xclient
.message_type
5844 == dpyinfo
->Xatom_Scrollbar
)
5846 x_scroll_bar_to_input_event (&event
, &inev
.ie
);
5847 *finish
= X_EVENT_GOTO_OUT
;
5850 #endif /* USE_TOOLKIT_SCROLL_BARS */
5852 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5857 if (x_handle_dnd_message (f
, &event
.xclient
, dpyinfo
, &inev
.ie
))
5858 *finish
= X_EVENT_DROP
;
5862 case SelectionNotify
:
5863 #ifdef USE_X_TOOLKIT
5864 if (! x_window_to_frame (dpyinfo
, event
.xselection
.requestor
))
5866 #endif /* not USE_X_TOOLKIT */
5867 x_handle_selection_notify (&event
.xselection
);
5870 case SelectionClear
: /* Someone has grabbed ownership. */
5871 #ifdef USE_X_TOOLKIT
5872 if (! x_window_to_frame (dpyinfo
, event
.xselectionclear
.window
))
5874 #endif /* USE_X_TOOLKIT */
5876 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
5878 inev
.ie
.kind
= SELECTION_CLEAR_EVENT
;
5879 SELECTION_EVENT_DISPLAY (&inev
.sie
) = eventp
->display
;
5880 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
5881 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
5882 inev
.ie
.frame_or_window
= Qnil
;
5886 case SelectionRequest
: /* Someone wants our selection. */
5887 #ifdef USE_X_TOOLKIT
5888 if (!x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
))
5890 #endif /* USE_X_TOOLKIT */
5892 XSelectionRequestEvent
*eventp
5893 = (XSelectionRequestEvent
*) &event
;
5895 inev
.ie
.kind
= SELECTION_REQUEST_EVENT
;
5896 SELECTION_EVENT_DISPLAY (&inev
.sie
) = eventp
->display
;
5897 SELECTION_EVENT_REQUESTOR (&inev
.sie
) = eventp
->requestor
;
5898 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
5899 SELECTION_EVENT_TARGET (&inev
.sie
) = eventp
->target
;
5900 SELECTION_EVENT_PROPERTY (&inev
.sie
) = eventp
->property
;
5901 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
5902 inev
.ie
.frame_or_window
= Qnil
;
5906 case PropertyNotify
:
5907 #if 0 /* This is plain wrong. In the case that we are waiting for a
5908 PropertyNotify used as an ACK in incremental selection
5909 transfer, the property will be on the receiver's window. */
5910 #if defined USE_X_TOOLKIT
5911 if (!x_any_window_to_frame (dpyinfo
, event
.xproperty
.window
))
5915 x_handle_property_notify (&event
.xproperty
);
5918 case ReparentNotify
:
5919 f
= x_top_window_to_frame (dpyinfo
, event
.xreparent
.window
);
5923 f
->output_data
.x
->parent_desc
= event
.xreparent
.parent
;
5924 x_real_positions (f
, &x
, &y
);
5928 /* Perhaps reparented due to a WM restart. Reset this. */
5929 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_UNKNOWN
;
5934 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
5937 x_check_fullscreen (f
);
5940 /* This seems to be needed for GTK 2.6. */
5941 x_clear_area (event
.xexpose
.display
,
5942 event
.xexpose
.window
,
5943 event
.xexpose
.x
, event
.xexpose
.y
,
5944 event
.xexpose
.width
, event
.xexpose
.height
,
5947 if (f
->async_visible
== 0)
5949 f
->async_visible
= 1;
5950 f
->async_iconified
= 0;
5951 f
->output_data
.x
->has_been_visible
= 1;
5952 SET_FRAME_GARBAGED (f
);
5956 event
.xexpose
.x
, event
.xexpose
.y
,
5957 event
.xexpose
.width
, event
.xexpose
.height
);
5961 #ifndef USE_TOOLKIT_SCROLL_BARS
5962 struct scroll_bar
*bar
;
5964 #if defined USE_LUCID
5965 /* Submenus of the Lucid menu bar aren't widgets
5966 themselves, so there's no way to dispatch events
5967 to them. Recognize this case separately. */
5970 = x_window_to_menu_bar (event
.xexpose
.window
);
5972 xlwmenu_redisplay (widget
);
5974 #endif /* USE_LUCID */
5976 #ifdef USE_TOOLKIT_SCROLL_BARS
5977 /* Dispatch event to the widget. */
5979 #else /* not USE_TOOLKIT_SCROLL_BARS */
5980 bar
= x_window_to_scroll_bar (event
.xexpose
.display
,
5981 event
.xexpose
.window
);
5984 x_scroll_bar_expose (bar
, &event
);
5985 #ifdef USE_X_TOOLKIT
5988 #endif /* USE_X_TOOLKIT */
5989 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5993 case GraphicsExpose
: /* This occurs when an XCopyArea's
5994 source area was obscured or not
5996 f
= x_window_to_frame (dpyinfo
, event
.xgraphicsexpose
.drawable
);
6000 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
6001 event
.xgraphicsexpose
.width
,
6002 event
.xgraphicsexpose
.height
);
6004 #ifdef USE_X_TOOLKIT
6007 #endif /* USE_X_TOOLKIT */
6010 case NoExpose
: /* This occurs when an XCopyArea's
6011 source area was completely
6016 /* Redo the mouse-highlight after the tooltip has gone. */
6017 if (event
.xmap
.window
== tip_window
)
6020 redo_mouse_highlight ();
6023 f
= x_top_window_to_frame (dpyinfo
, event
.xunmap
.window
);
6024 if (f
) /* F may no longer exist if
6025 the frame was deleted. */
6027 /* While a frame is unmapped, display generation is
6028 disabled; you don't want to spend time updating a
6029 display that won't ever be seen. */
6030 f
->async_visible
= 0;
6031 /* We can't distinguish, from the event, whether the window
6032 has become iconified or invisible. So assume, if it
6033 was previously visible, than now it is iconified.
6034 But x_make_frame_invisible clears both
6035 the visible flag and the iconified flag;
6036 and that way, we know the window is not iconified now. */
6037 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
6039 f
->async_iconified
= 1;
6041 inev
.ie
.kind
= ICONIFY_EVENT
;
6042 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6048 if (event
.xmap
.window
== tip_window
)
6049 /* The tooltip has been drawn already. Avoid
6050 the SET_FRAME_GARBAGED below. */
6053 /* We use x_top_window_to_frame because map events can
6054 come for sub-windows and they don't mean that the
6055 frame is visible. */
6056 f
= x_top_window_to_frame (dpyinfo
, event
.xmap
.window
);
6059 /* wait_reading_process_output will notice this and update
6060 the frame's display structures.
6061 If we where iconified, we should not set garbaged,
6062 because that stops redrawing on Expose events. This looks
6063 bad if we are called from a recursive event loop
6064 (x_dispatch_event), for example when a dialog is up. */
6065 if (! f
->async_iconified
)
6066 SET_FRAME_GARBAGED (f
);
6068 f
->async_visible
= 1;
6069 f
->async_iconified
= 0;
6070 f
->output_data
.x
->has_been_visible
= 1;
6074 inev
.ie
.kind
= DEICONIFY_EVENT
;
6075 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6077 else if (! NILP (Vframe_list
)
6078 && ! NILP (XCDR (Vframe_list
)))
6079 /* Force a redisplay sooner or later
6080 to update the frame titles
6081 in case this is the second frame. */
6082 record_asynch_buffer_change ();
6088 ignore_next_mouse_click_timeout
= 0;
6090 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6091 /* Dispatch KeyPress events when in menu. */
6092 if (popup_activated ())
6096 f
= x_any_window_to_frame (dpyinfo
, event
.xkey
.window
);
6098 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
))
6100 clear_mouse_face (dpyinfo
);
6101 dpyinfo
->mouse_face_hidden
= 1;
6104 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
6107 /* Scroll bars consume key events, but we want
6108 the keys to go to the scroll bar's frame. */
6109 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
6111 if (widget
&& XmIsScrollBar (widget
))
6113 widget
= XtParent (widget
);
6114 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
6117 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
6121 KeySym keysym
, orig_keysym
;
6122 /* al%imercury@uunet.uu.net says that making this 81
6123 instead of 80 fixed a bug whereby meta chars made
6126 It seems that some version of XmbLookupString has
6127 a bug of not returning XBufferOverflow in
6128 status_return even if the input is too long to
6129 fit in 81 bytes. So, we must prepare sufficient
6130 bytes for copy_buffer. 513 bytes (256 chars for
6131 two-byte character set) seems to be a fairly good
6132 approximation. -- 2000.8.10 handa@etl.go.jp */
6133 unsigned char copy_buffer
[513];
6134 unsigned char *copy_bufptr
= copy_buffer
;
6135 int copy_bufsiz
= sizeof (copy_buffer
);
6137 Lisp_Object coding_system
= Qlatin_1
;
6141 /* Don't pass keys to GTK. A Tab will shift focus to the
6142 tool bar in GTK 2.4. Keys will still go to menus and
6143 dialogs because in that case popup_activated is TRUE
6145 *finish
= X_EVENT_DROP
;
6149 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f
),
6150 extra_keyboard_modifiers
);
6151 modifiers
= event
.xkey
.state
;
6153 /* This will have to go some day... */
6155 /* make_lispy_event turns chars into control chars.
6156 Don't do it here because XLookupString is too eager. */
6157 event
.xkey
.state
&= ~ControlMask
;
6158 event
.xkey
.state
&= ~(dpyinfo
->meta_mod_mask
6159 | dpyinfo
->super_mod_mask
6160 | dpyinfo
->hyper_mod_mask
6161 | dpyinfo
->alt_mod_mask
);
6163 /* In case Meta is ComposeCharacter,
6164 clear its status. According to Markus Ehrnsperger
6165 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
6166 this enables ComposeCharacter to work whether or
6167 not it is combined with Meta. */
6168 if (modifiers
& dpyinfo
->meta_mod_mask
)
6169 bzero (&compose_status
, sizeof (compose_status
));
6174 Status status_return
;
6176 coding_system
= Vlocale_coding_system
;
6177 nbytes
= XmbLookupString (FRAME_XIC (f
),
6178 &event
.xkey
, copy_bufptr
,
6179 copy_bufsiz
, &keysym
,
6181 if (status_return
== XBufferOverflow
)
6183 copy_bufsiz
= nbytes
+ 1;
6184 copy_bufptr
= (unsigned char *) alloca (copy_bufsiz
);
6185 nbytes
= XmbLookupString (FRAME_XIC (f
),
6186 &event
.xkey
, copy_bufptr
,
6187 copy_bufsiz
, &keysym
,
6190 /* Xutf8LookupString is a new but already deprecated interface. -stef */
6191 #if 0 && defined X_HAVE_UTF8_STRING
6192 else if (status_return
== XLookupKeySym
)
6193 { /* Try again but with utf-8. */
6194 coding_system
= Qutf_8
;
6195 nbytes
= Xutf8LookupString (FRAME_XIC (f
),
6196 &event
.xkey
, copy_bufptr
,
6197 copy_bufsiz
, &keysym
,
6199 if (status_return
== XBufferOverflow
)
6201 copy_bufsiz
= nbytes
+ 1;
6202 copy_bufptr
= (unsigned char *) alloca (copy_bufsiz
);
6203 nbytes
= Xutf8LookupString (FRAME_XIC (f
),
6206 copy_bufsiz
, &keysym
,
6212 if (status_return
== XLookupNone
)
6214 else if (status_return
== XLookupChars
)
6219 else if (status_return
!= XLookupKeySym
6220 && status_return
!= XLookupBoth
)
6224 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
6225 copy_bufsiz
, &keysym
,
6228 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
6229 copy_bufsiz
, &keysym
,
6233 /* If not using XIM/XIC, and a compose sequence is in progress,
6234 we break here. Otherwise, chars_matched is always 0. */
6235 if (compose_status
.chars_matched
> 0 && nbytes
== 0)
6238 bzero (&compose_status
, sizeof (compose_status
));
6239 orig_keysym
= keysym
;
6241 /* Common for all keysym input events. */
6242 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6244 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), modifiers
);
6245 inev
.ie
.timestamp
= event
.xkey
.time
;
6247 /* First deal with keysyms which have defined
6248 translations to characters. */
6249 if (keysym
>= 32 && keysym
< 128)
6250 /* Avoid explicitly decoding each ASCII character. */
6252 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
6253 inev
.ie
.code
= keysym
;
6257 /* Keysyms directly mapped to supported Unicode characters. */
6258 if ((keysym
>= 0x01000100 && keysym
<= 0x010033ff)
6259 || (keysym
>= 0x0100e000 && keysym
<= 0x0100ffff))
6261 int code
, charset_id
, c1
, c2
;
6263 if (keysym
< 0x01002500)
6264 charset_id
= charset_mule_unicode_0100_24ff
,
6265 code
= (keysym
& 0xFFFF) - 0x100;
6266 else if (keysym
< 0x0100e000)
6267 charset_id
= charset_mule_unicode_2500_33ff
,
6268 code
= (keysym
& 0xFFFF) - 0x2500;
6270 charset_id
= charset_mule_unicode_e000_ffff
,
6271 code
= (keysym
& 0xFFFF) - 0xe000;
6272 c1
= (code
/ 96) + 32, c2
= (code
% 96) + 32;
6273 inev
.ie
.kind
= MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
6274 inev
.ie
.code
= MAKE_CHAR (charset_id
, c1
, c2
);
6278 /* Now non-ASCII. */
6279 if (HASH_TABLE_P (Vx_keysym_table
)
6280 && (NATNUMP (c
= Fgethash (make_number (keysym
),
6284 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (XFASTINT (c
))
6285 ? ASCII_KEYSTROKE_EVENT
6286 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6287 inev
.ie
.code
= XFASTINT (c
);
6291 /* Random non-modifier sorts of keysyms. */
6292 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
6293 || keysym
== XK_Delete
6294 #ifdef XK_ISO_Left_Tab
6295 || (keysym
>= XK_ISO_Left_Tab
6296 && keysym
<= XK_ISO_Enter
)
6298 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
6299 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
6301 /* This recognizes the "extended function
6302 keys". It seems there's no cleaner way.
6303 Test IsModifierKey to avoid handling
6304 mode_switch incorrectly. */
6305 || ((unsigned) (keysym
) >= XK_Select
6306 && (unsigned)(keysym
) < XK_KP_Space
)
6308 #ifdef XK_dead_circumflex
6309 || orig_keysym
== XK_dead_circumflex
6311 #ifdef XK_dead_grave
6312 || orig_keysym
== XK_dead_grave
6314 #ifdef XK_dead_tilde
6315 || orig_keysym
== XK_dead_tilde
6317 #ifdef XK_dead_diaeresis
6318 || orig_keysym
== XK_dead_diaeresis
6320 #ifdef XK_dead_macron
6321 || orig_keysym
== XK_dead_macron
6323 #ifdef XK_dead_degree
6324 || orig_keysym
== XK_dead_degree
6326 #ifdef XK_dead_acute
6327 || orig_keysym
== XK_dead_acute
6329 #ifdef XK_dead_cedilla
6330 || orig_keysym
== XK_dead_cedilla
6332 #ifdef XK_dead_breve
6333 || orig_keysym
== XK_dead_breve
6335 #ifdef XK_dead_ogonek
6336 || orig_keysym
== XK_dead_ogonek
6338 #ifdef XK_dead_caron
6339 || orig_keysym
== XK_dead_caron
6341 #ifdef XK_dead_doubleacute
6342 || orig_keysym
== XK_dead_doubleacute
6344 #ifdef XK_dead_abovedot
6345 || orig_keysym
== XK_dead_abovedot
6347 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
6348 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
6349 /* Any "vendor-specific" key is ok. */
6350 || (orig_keysym
& (1 << 28))
6351 || (keysym
!= NoSymbol
&& nbytes
== 0))
6352 && ! (IsModifierKey (orig_keysym
)
6354 #ifdef XK_Mode_switch
6355 || ((unsigned)(orig_keysym
) == XK_Mode_switch
)
6358 || ((unsigned)(orig_keysym
) == XK_Num_Lock
)
6360 #endif /* not HAVE_X11R5 */
6361 /* The symbols from XK_ISO_Lock
6362 to XK_ISO_Last_Group_Lock
6363 don't have real modifiers but
6364 should be treated similarly to
6365 Mode_switch by Emacs. */
6366 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
6367 || ((unsigned)(orig_keysym
)
6369 && (unsigned)(orig_keysym
)
6370 <= XK_ISO_Last_Group_Lock
)
6374 STORE_KEYSYM_FOR_DEBUG (keysym
);
6375 /* make_lispy_event will convert this to a symbolic
6377 inev
.ie
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
6378 inev
.ie
.code
= keysym
;
6382 { /* Raw bytes, not keysym. */
6387 /* The input should be decoded with `coding_system'
6388 which depends on which X*LookupString function
6389 we used just above and the locale. */
6390 setup_coding_system (coding_system
, &coding
);
6391 coding
.src_multibyte
= 0;
6392 coding
.dst_multibyte
= 1;
6393 /* The input is converted to events, thus we can't
6394 handle composition. Anyway, there's no XIM that
6395 gives us composition information. */
6396 coding
.composing
= COMPOSITION_DISABLED
;
6398 for (i
= 0; i
< nbytes
; i
++)
6400 STORE_KEYSYM_FOR_DEBUG (copy_bufptr
[i
]);
6404 /* Decode the input data. */
6408 require
= decoding_buffer_size (&coding
, nbytes
);
6409 p
= (unsigned char *) alloca (require
);
6410 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
6411 /* We explicitly disable composition handling because
6412 key data should not contain any composition sequence. */
6413 coding
.composing
= COMPOSITION_DISABLED
;
6414 decode_coding (&coding
, copy_bufptr
, p
, nbytes
, require
);
6415 nbytes
= coding
.produced
;
6416 nchars
= coding
.produced_char
;
6420 /* Convert the input data to a sequence of
6421 character events. */
6422 for (i
= 0; i
< nbytes
; i
+= len
)
6424 if (nchars
== nbytes
)
6425 c
= copy_bufptr
[i
], len
= 1;
6427 c
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
,
6429 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (c
)
6430 ? ASCII_KEYSTROKE_EVENT
6431 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6433 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
6436 /* Previous code updated count by nchars rather than nbytes,
6437 but that seems bogus to me. ++kfs */
6440 inev
.ie
.kind
= NO_EVENT
; /* Already stored above. */
6442 if (keysym
== NoSymbol
)
6448 /* Don't dispatch this event since XtDispatchEvent calls
6449 XFilterEvent, and two calls in a row may freeze the
6458 /* Don't dispatch this event since XtDispatchEvent calls
6459 XFilterEvent, and two calls in a row may freeze the
6467 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6469 f
= x_any_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
6471 if (f
&& x_mouse_click_focus_ignore_position
)
6472 ignore_next_mouse_click_timeout
= event
.xmotion
.time
+ 200;
6475 if (event
.xcrossing
.focus
)
6477 /* Avoid nasty pop/raise loops. */
6478 if (f
&& (!(f
->auto_raise
)
6480 || (event
.xcrossing
.time
- enter_timestamp
) > 500))
6482 x_new_focus_frame (dpyinfo
, f
);
6483 enter_timestamp
= event
.xcrossing
.time
;
6486 else if (f
== dpyinfo
->x_focus_frame
)
6487 x_new_focus_frame (dpyinfo
, 0);
6490 /* EnterNotify counts as mouse movement,
6491 so update things that depend on mouse position. */
6492 if (f
&& !f
->output_data
.x
->hourglass_p
)
6493 note_mouse_movement (f
, &event
.xmotion
);
6497 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6501 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6503 f
= x_top_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
6506 if (f
== dpyinfo
->mouse_face_mouse_frame
)
6508 /* If we move outside the frame, then we're
6509 certainly no longer on any text in the frame. */
6510 clear_mouse_face (dpyinfo
);
6511 dpyinfo
->mouse_face_mouse_frame
= 0;
6514 /* Generate a nil HELP_EVENT to cancel a help-echo.
6515 Do it only if there's something to cancel.
6516 Otherwise, the startup message is cleared when
6517 the mouse leaves the frame. */
6518 if (any_help_event_p
)
6524 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6529 previous_help_echo_string
= help_echo_string
;
6530 help_echo_string
= Qnil
;
6532 if (dpyinfo
->grabbed
&& last_mouse_frame
6533 && FRAME_LIVE_P (last_mouse_frame
))
6534 f
= last_mouse_frame
;
6536 f
= x_window_to_frame (dpyinfo
, event
.xmotion
.window
);
6538 if (dpyinfo
->mouse_face_hidden
)
6540 dpyinfo
->mouse_face_hidden
= 0;
6541 clear_mouse_face (dpyinfo
);
6547 /* Generate SELECT_WINDOW_EVENTs when needed. */
6548 if (mouse_autoselect_window
)
6552 window
= window_from_coordinates (f
,
6553 event
.xmotion
.x
, event
.xmotion
.y
,
6556 /* Window will be selected only when it is not selected now and
6557 last mouse movement event was not in it. Minibuffer window
6558 will be selected iff it is active. */
6559 if (WINDOWP (window
)
6560 && !EQ (window
, last_window
)
6561 && !EQ (window
, selected_window
))
6563 inev
.ie
.kind
= SELECT_WINDOW_EVENT
;
6564 inev
.ie
.frame_or_window
= window
;
6569 if (!note_mouse_movement (f
, &event
.xmotion
))
6570 help_echo_string
= previous_help_echo_string
;
6574 #ifndef USE_TOOLKIT_SCROLL_BARS
6575 struct scroll_bar
*bar
6576 = x_window_to_scroll_bar (event
.xmotion
.display
,
6577 event
.xmotion
.window
);
6580 x_scroll_bar_note_movement (bar
, &event
);
6581 #endif /* USE_TOOLKIT_SCROLL_BARS */
6583 /* If we move outside the frame, then we're
6584 certainly no longer on any text in the frame. */
6585 clear_mouse_face (dpyinfo
);
6588 /* If the contents of the global variable help_echo_string
6589 has changed, generate a HELP_EVENT. */
6590 if (!NILP (help_echo_string
)
6591 || !NILP (previous_help_echo_string
))
6596 case ConfigureNotify
:
6597 f
= x_top_window_to_frame (dpyinfo
, event
.xconfigure
.window
);
6600 #ifndef USE_X_TOOLKIT
6602 xg_resize_widgets (f
, event
.xconfigure
.width
,
6603 event
.xconfigure
.height
);
6604 #else /* not USE_GTK */
6605 /* If there is a pending resize for fullscreen, don't
6606 do this one, the right one will come later.
6607 The toolkit version doesn't seem to need this, but we
6608 need to reset it below. */
6610 = ((f
->want_fullscreen
& FULLSCREEN_WAIT
)
6611 && f
->new_text_cols
!= 0);
6612 int rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, event
.xconfigure
.height
);
6613 int columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, event
.xconfigure
.width
);
6618 /* In the toolkit version, change_frame_size
6619 is called by the code that handles resizing
6620 of the EmacsFrame widget. */
6622 /* Even if the number of character rows and columns has
6623 not changed, the font size may have changed, so we need
6624 to check the pixel dimensions as well. */
6625 if (columns
!= FRAME_COLS (f
)
6626 || rows
!= FRAME_LINES (f
)
6627 || event
.xconfigure
.width
!= FRAME_PIXEL_WIDTH (f
)
6628 || event
.xconfigure
.height
!= FRAME_PIXEL_HEIGHT (f
))
6630 change_frame_size (f
, rows
, columns
, 0, 1, 0);
6631 SET_FRAME_GARBAGED (f
);
6632 cancel_mouse_face (f
);
6634 #endif /* not USE_GTK */
6637 FRAME_PIXEL_WIDTH (f
) = event
.xconfigure
.width
;
6638 FRAME_PIXEL_HEIGHT (f
) = event
.xconfigure
.height
;
6641 /* GTK creates windows but doesn't map them.
6642 Only get real positions and check fullscreen when mapped. */
6643 if (FRAME_GTK_OUTER_WIDGET (f
)
6644 && GTK_WIDGET_MAPPED (FRAME_GTK_OUTER_WIDGET (f
)))
6647 /* What we have now is the position of Emacs's own window.
6648 Convert that to the position of the window manager window. */
6649 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
6651 x_check_expected_move (f
);
6652 if (f
->want_fullscreen
& FULLSCREEN_WAIT
)
6653 f
->want_fullscreen
&= ~(FULLSCREEN_WAIT
|FULLSCREEN_BOTH
);
6657 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
6658 xic_set_statusarea (f
);
6661 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
6663 /* Since the WM decorations come below top_pos now,
6664 we must put them below top_pos in the future. */
6665 f
->win_gravity
= NorthWestGravity
;
6666 x_wm_set_size_hint (f
, (long) 0, 0);
6674 /* If we decide we want to generate an event to be seen
6675 by the rest of Emacs, we put it here. */
6678 bzero (&compose_status
, sizeof (compose_status
));
6679 last_mouse_glyph_frame
= 0;
6681 if (dpyinfo
->grabbed
6683 && FRAME_LIVE_P (last_mouse_frame
))
6684 f
= last_mouse_frame
;
6686 f
= x_window_to_frame (dpyinfo
, event
.xbutton
.window
);
6690 /* Is this in the tool-bar? */
6691 if (WINDOWP (f
->tool_bar_window
)
6692 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
6695 int x
= event
.xbutton
.x
;
6696 int y
= event
.xbutton
.y
;
6698 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 1);
6699 if (EQ (window
, f
->tool_bar_window
))
6701 if (event
.xbutton
.type
== ButtonPress
)
6702 handle_tool_bar_click (f
, x
, y
, 1, 0);
6704 handle_tool_bar_click (f
, x
, y
, 0,
6705 x_x_to_emacs_modifiers (dpyinfo
,
6706 event
.xbutton
.state
));
6712 if (!dpyinfo
->x_focus_frame
6713 || f
== dpyinfo
->x_focus_frame
)
6715 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6716 if (! popup_activated ())
6719 if (ignore_next_mouse_click_timeout
)
6721 if (event
.type
== ButtonPress
6722 && (int)(event
.xbutton
.time
- ignore_next_mouse_click_timeout
) > 0)
6724 ignore_next_mouse_click_timeout
= 0;
6725 construct_mouse_click (&inev
.ie
, &event
.xbutton
, f
);
6727 if (event
.type
== ButtonRelease
)
6728 ignore_next_mouse_click_timeout
= 0;
6731 construct_mouse_click (&inev
.ie
, &event
.xbutton
, f
);
6737 struct scroll_bar
*bar
6738 = x_window_to_scroll_bar (event
.xbutton
.display
,
6739 event
.xbutton
.window
);
6741 #ifdef USE_TOOLKIT_SCROLL_BARS
6742 /* Make the "Ctrl-Mouse-2 splits window" work for toolkit
6744 if (bar
&& event
.xbutton
.state
& ControlMask
)
6746 x_scroll_bar_handle_click (bar
, &event
, &inev
.ie
);
6747 *finish
= X_EVENT_DROP
;
6749 #else /* not USE_TOOLKIT_SCROLL_BARS */
6751 x_scroll_bar_handle_click (bar
, &event
, &inev
.ie
);
6752 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6755 if (event
.type
== ButtonPress
)
6757 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
6758 last_mouse_frame
= f
;
6761 last_tool_bar_item
= -1;
6764 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
6766 /* Ignore any mouse motion that happened before this event;
6767 any subsequent mouse-movement Emacs events should reflect
6768 only motion after the ButtonPress/Release. */
6772 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6773 f
= x_menubar_window_to_frame (dpyinfo
, event
.xbutton
.window
);
6774 /* For a down-event in the menu bar,
6775 don't pass it to Xt right now.
6776 Instead, save it away
6777 and we will pass it to Xt from kbd_buffer_get_event.
6778 That way, we can run some Lisp code first. */
6781 ! popup_activated ()
6784 f
&& event
.type
== ButtonPress
6785 /* Verify the event is really within the menu bar
6786 and not just sent to it due to grabbing. */
6787 && event
.xbutton
.x
>= 0
6788 && event
.xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
6789 && event
.xbutton
.y
>= 0
6790 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
6791 && event
.xbutton
.same_screen
)
6793 SET_SAVED_BUTTON_EVENT
;
6794 XSETFRAME (last_mouse_press_frame
, f
);
6796 *finish
= X_EVENT_DROP
;
6799 else if (event
.type
== ButtonPress
)
6801 last_mouse_press_frame
= Qnil
;
6805 #ifdef USE_MOTIF /* This should do not harm for Lucid,
6806 but I am trying to be cautious. */
6807 else if (event
.type
== ButtonRelease
)
6809 if (!NILP (last_mouse_press_frame
))
6811 f
= XFRAME (last_mouse_press_frame
);
6812 if (f
->output_data
.x
)
6813 SET_SAVED_BUTTON_EVENT
;
6818 #endif /* USE_MOTIF */
6821 #endif /* USE_X_TOOLKIT || USE_GTK */
6825 case CirculateNotify
:
6828 case CirculateRequest
:
6831 case VisibilityNotify
:
6835 /* Someone has changed the keyboard mapping - update the
6837 switch (event
.xmapping
.request
)
6839 case MappingModifier
:
6840 x_find_modifier_meanings (dpyinfo
);
6841 /* This is meant to fall through. */
6842 case MappingKeyboard
:
6843 XRefreshKeyboardMapping (&event
.xmapping
);
6849 #ifdef USE_X_TOOLKIT
6851 if (*finish
!= X_EVENT_DROP
)
6852 XtDispatchEvent (&event
);
6854 #endif /* USE_X_TOOLKIT */
6859 if (inev
.ie
.kind
!= NO_EVENT
)
6861 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
6866 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
6871 XSETFRAME (frame
, f
);
6877 any_help_event_p
= 1;
6878 gen_help_event (help_echo_string
, frame
, help_echo_window
,
6879 help_echo_object
, help_echo_pos
);
6883 help_echo_string
= Qnil
;
6884 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
6894 /* Handles the XEvent EVENT on display DISPLAY.
6895 This is used for event loops outside the normal event handling,
6896 i.e. looping while a popup menu or a dialog is posted.
6898 Returns the value handle_one_xevent sets in the finish argument. */
6900 x_dispatch_event (event
, display
)
6904 struct x_display_info
*dpyinfo
;
6905 int finish
= X_EVENT_NORMAL
;
6907 dpyinfo
= x_display_info_for_display (display
);
6910 handle_one_xevent (dpyinfo
, event
, &finish
, 0);
6916 /* Read events coming from the X server.
6917 This routine is called by the SIGIO handler.
6918 We return as soon as there are no more events to be read.
6920 We return the number of characters stored into the buffer,
6921 thus pretending to be `read'.
6923 EXPECTED is nonzero if the caller knows input is available. */
6926 XTread_socket (terminal
, expected
, hold_quit
)
6927 struct terminal
*terminal
;
6929 struct input_event
*hold_quit
;
6933 int event_found
= 0;
6934 struct x_display_info
*dpyinfo
;
6936 if (interrupt_input_blocked
)
6938 interrupt_input_pending
= 1;
6942 interrupt_input_pending
= 0;
6945 /* So people can tell when we have read the available input. */
6946 input_signal_count
++;
6950 /* Find the display we are supposed to read input for.
6951 It's the one communicating on descriptor SD. */
6952 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
6954 #if 0 /* This ought to be unnecessary; let's verify it. */
6956 /* If available, Xlib uses FIOSNBIO to make the socket
6957 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
6958 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
6959 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
6960 fcntl (dpyinfo
->connection
, F_SETFL
, 0);
6961 #endif /* ! defined (FIOSNBIO) */
6964 #if 0 /* This code can't be made to work, with multiple displays,
6965 and appears not to be used on any system any more.
6966 Also keyboard.c doesn't turn O_NDELAY on and off
6967 for X connections. */
6970 if (! (fcntl (dpyinfo
->connection
, F_GETFL
, 0) & O_NDELAY
))
6972 extern int read_alarm_should_throw
;
6973 read_alarm_should_throw
= 1;
6974 XPeekEvent (dpyinfo
->display
, &event
);
6975 read_alarm_should_throw
= 0;
6977 #endif /* HAVE_SELECT */
6981 /* For debugging, this gives a way to fake an I/O error. */
6982 if (dpyinfo
== XTread_socket_fake_io_error
)
6984 XTread_socket_fake_io_error
= 0;
6985 x_io_error_quitter (dpyinfo
->display
);
6989 /* Only check session manager input for the primary display. */
6990 if (terminal
->id
== 1 && x_session_have_connection ())
6992 struct input_event inev
;
6994 /* We don't need to EVENT_INIT (inev) here, as
6995 x_session_check_input copies an entire input_event. */
6996 if (x_session_check_input (&inev
))
6998 kbd_buffer_store_event_hold (&inev
, hold_quit
);
7006 while (XPending (dpyinfo
->display
))
7010 XNextEvent (dpyinfo
->display
, &event
);
7013 /* Filter events for the current X input method. */
7014 if (x_filter_event (dpyinfo
, &event
))
7019 count
+= handle_one_xevent (dpyinfo
, &event
, &finish
, hold_quit
);
7021 if (finish
== X_EVENT_GOTO_OUT
)
7024 #endif /* not USE_GTK */
7029 /* For GTK we must use the GTK event loop. But XEvents gets passed
7030 to our filter function above, and then to the big event switch.
7031 We use a bunch of globals to communicate with our filter function,
7032 that is kind of ugly, but it works.
7034 There is no way to do one display at the time, GTK just does events
7035 from all displays. */
7037 while (gtk_events_pending ())
7039 current_count
= count
;
7040 current_hold_quit
= hold_quit
;
7042 gtk_main_iteration ();
7044 count
= current_count
;
7046 current_hold_quit
= 0;
7048 if (current_finish
== X_EVENT_GOTO_OUT
)
7051 #endif /* USE_GTK */
7055 /* On some systems, an X bug causes Emacs to get no more events
7056 when the window is destroyed. Detect that. (1994.) */
7059 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
7060 One XNOOP in 100 loops will make Emacs terminate.
7061 B. Bretthauer, 1994 */
7063 if (x_noop_count
>= 100)
7067 if (next_noop_dpyinfo
== 0)
7068 next_noop_dpyinfo
= x_display_list
;
7070 XNoOp (next_noop_dpyinfo
->display
);
7072 /* Each time we get here, cycle through the displays now open. */
7073 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
7077 /* If the focus was just given to an auto-raising frame,
7079 /* ??? This ought to be able to handle more than one such frame. */
7080 if (pending_autoraise_frame
)
7082 x_raise_frame (pending_autoraise_frame
);
7083 pending_autoraise_frame
= 0;
7095 /***********************************************************************
7097 ***********************************************************************/
7099 /* Set clipping for output in glyph row ROW. W is the window in which
7100 we operate. GC is the graphics context to set clipping in.
7102 ROW may be a text row or, e.g., a mode line. Text rows must be
7103 clipped to the interior of the window dedicated to text display,
7104 mode lines must be clipped to the whole window. */
7107 x_clip_to_row (w
, row
, area
, gc
)
7109 struct glyph_row
*row
;
7113 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7114 XRectangle clip_rect
;
7115 int window_x
, window_y
, window_width
;
7117 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
7119 clip_rect
.x
= window_x
;
7120 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, row
->y
));
7121 clip_rect
.y
= max (clip_rect
.y
, window_y
);
7122 clip_rect
.width
= window_width
;
7123 clip_rect
.height
= row
->visible_height
;
7125 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
7129 /* Draw a hollow box cursor on window W in glyph row ROW. */
7132 x_draw_hollow_cursor (w
, row
)
7134 struct glyph_row
*row
;
7136 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7137 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7138 Display
*dpy
= FRAME_X_DISPLAY (f
);
7141 struct glyph
*cursor_glyph
;
7144 /* Get the glyph the cursor is on. If we can't tell because
7145 the current matrix is invalid or such, give up. */
7146 cursor_glyph
= get_phys_cursor_glyph (w
);
7147 if (cursor_glyph
== NULL
)
7150 /* Compute frame-relative coordinates for phys cursor. */
7151 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
7152 y
= get_phys_cursor_geometry (w
, row
, cursor_glyph
, &h
);
7153 wd
= w
->phys_cursor_width
;
7155 /* The foreground of cursor_gc is typically the same as the normal
7156 background color, which can cause the cursor box to be invisible. */
7157 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7158 if (dpyinfo
->scratch_cursor_gc
)
7159 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
7161 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
7162 GCForeground
, &xgcv
);
7163 gc
= dpyinfo
->scratch_cursor_gc
;
7165 /* Set clipping, draw the rectangle, and reset clipping again. */
7166 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7167 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
);
7168 XSetClipMask (dpy
, gc
, None
);
7172 /* Draw a bar cursor on window W in glyph row ROW.
7174 Implementation note: One would like to draw a bar cursor with an
7175 angle equal to the one given by the font property XA_ITALIC_ANGLE.
7176 Unfortunately, I didn't find a font yet that has this property set.
7180 x_draw_bar_cursor (w
, row
, width
, kind
)
7182 struct glyph_row
*row
;
7184 enum text_cursor_kinds kind
;
7186 struct frame
*f
= XFRAME (w
->frame
);
7187 struct glyph
*cursor_glyph
;
7189 /* If cursor is out of bounds, don't draw garbage. This can happen
7190 in mini-buffer windows when switching between echo area glyphs
7192 cursor_glyph
= get_phys_cursor_glyph (w
);
7193 if (cursor_glyph
== NULL
)
7196 /* If on an image, draw like a normal cursor. That's usually better
7197 visible than drawing a bar, esp. if the image is large so that
7198 the bar might not be in the window. */
7199 if (cursor_glyph
->type
== IMAGE_GLYPH
)
7201 struct glyph_row
*row
;
7202 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
7203 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
7207 Display
*dpy
= FRAME_X_DISPLAY (f
);
7208 Window window
= FRAME_X_WINDOW (f
);
7209 GC gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
7210 unsigned long mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
7211 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
7214 /* If the glyph's background equals the color we normally draw
7215 the bar cursor in, the bar cursor in its normal color is
7216 invisible. Use the glyph's foreground color instead in this
7217 case, on the assumption that the glyph's colors are chosen so
7218 that the glyph is legible. */
7219 if (face
->background
== f
->output_data
.x
->cursor_pixel
)
7220 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
7222 xgcv
.background
= xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7223 xgcv
.graphics_exposures
= 0;
7226 XChangeGC (dpy
, gc
, mask
, &xgcv
);
7229 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
7230 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
7234 width
= FRAME_CURSOR_WIDTH (f
);
7235 width
= min (cursor_glyph
->pixel_width
, width
);
7237 w
->phys_cursor_width
= width
;
7238 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7240 if (kind
== BAR_CURSOR
)
7241 XFillRectangle (dpy
, window
, gc
,
7242 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
7243 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
7244 width
, row
->height
);
7246 XFillRectangle (dpy
, window
, gc
,
7247 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
7248 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
7249 row
->height
- width
),
7250 cursor_glyph
->pixel_width
,
7253 XSetClipMask (dpy
, gc
, None
);
7258 /* RIF: Define cursor CURSOR on frame F. */
7261 x_define_frame_cursor (f
, cursor
)
7265 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
7269 /* RIF: Clear area on frame F. */
7272 x_clear_frame_area (f
, x
, y
, width
, height
)
7274 int x
, y
, width
, height
;
7276 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7277 x
, y
, width
, height
, False
);
7281 /* RIF: Draw cursor on window W. */
7284 x_draw_window_cursor (w
, glyph_row
, x
, y
, cursor_type
, cursor_width
, on_p
, active_p
)
7286 struct glyph_row
*glyph_row
;
7288 int cursor_type
, cursor_width
;
7291 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7295 w
->phys_cursor_type
= cursor_type
;
7296 w
->phys_cursor_on_p
= 1;
7298 if (glyph_row
->exact_window_width_line_p
7299 && w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])
7301 glyph_row
->cursor_in_fringe_p
= 1;
7302 draw_fringe_bitmap (w
, glyph_row
, 0);
7305 switch (cursor_type
)
7307 case HOLLOW_BOX_CURSOR
:
7308 x_draw_hollow_cursor (w
, glyph_row
);
7311 case FILLED_BOX_CURSOR
:
7312 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
7316 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
7320 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
7324 w
->phys_cursor_width
= 0;
7332 if (w
== XWINDOW (f
->selected_window
))
7333 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
7334 xic_set_preeditarea (w
, x
, y
);
7339 XFlush (FRAME_X_DISPLAY (f
));
7346 /* Make the x-window of frame F use the gnu icon bitmap. */
7349 x_bitmap_icon (f
, file
)
7355 if (FRAME_X_WINDOW (f
) == 0)
7358 /* Free up our existing icon bitmap and mask if any. */
7359 if (f
->output_data
.x
->icon_bitmap
> 0)
7360 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7361 f
->output_data
.x
->icon_bitmap
= 0;
7366 /* Use gtk_window_set_icon_from_file () if available,
7367 It's not restricted to bitmaps */
7368 if (xg_set_icon (f
, file
))
7370 #endif /* USE_GTK */
7371 bitmap_id
= x_create_bitmap_from_file (f
, file
);
7372 x_create_bitmap_mask (f
, bitmap_id
);
7376 /* Create the GNU bitmap and mask if necessary. */
7377 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
7381 #if defined (HAVE_XPM) && defined (HAVE_X_WINDOWS)
7383 if (xg_set_icon_from_xpm_data (f
, gnu_xpm_bits
))
7386 rc
= x_create_bitmap_from_xpm_data (f
, gnu_xpm_bits
);
7388 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
7389 #endif /* USE_GTK */
7390 #endif /* defined (HAVE_XPM) && defined (HAVE_X_WINDOWS) */
7392 /* If all else fails, use the (black and white) xbm image. */
7395 rc
= x_create_bitmap_from_data (f
, gnu_xbm_bits
,
7396 gnu_xbm_width
, gnu_xbm_height
);
7400 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
= rc
;
7401 x_create_bitmap_mask (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
7405 /* The first time we create the GNU bitmap and mask,
7406 this increments the ref-count one extra time.
7407 As a result, the GNU bitmap and mask are never freed.
7408 That way, we don't have to worry about allocating it again. */
7409 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
7411 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
7414 x_wm_set_icon_pixmap (f
, bitmap_id
);
7415 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
7421 /* Make the x-window of frame F use a rectangle with text.
7422 Use ICON_NAME as the text. */
7425 x_text_icon (f
, icon_name
)
7429 if (FRAME_X_WINDOW (f
) == 0)
7435 text
.value
= (unsigned char *) icon_name
;
7436 text
.encoding
= XA_STRING
;
7438 text
.nitems
= strlen (icon_name
);
7439 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
7441 #else /* not HAVE_X11R4 */
7442 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), icon_name
);
7443 #endif /* not HAVE_X11R4 */
7445 if (f
->output_data
.x
->icon_bitmap
> 0)
7446 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7447 f
->output_data
.x
->icon_bitmap
= 0;
7448 x_wm_set_icon_pixmap (f
, 0);
7453 #define X_ERROR_MESSAGE_SIZE 200
7455 /* If non-nil, this should be a string.
7456 It means catch X errors and store the error message in this string. */
7458 static Lisp_Object x_error_message_string
;
7460 /* An X error handler which stores the error message in
7461 x_error_message_string. This is called from x_error_handler if
7462 x_catch_errors is in effect. */
7465 x_error_catcher (display
, error
)
7469 XGetErrorText (display
, error
->error_code
,
7470 SDATA (x_error_message_string
),
7471 X_ERROR_MESSAGE_SIZE
);
7474 /* Begin trapping X errors for display DPY. Actually we trap X errors
7475 for all displays, but DPY should be the display you are actually
7478 After calling this function, X protocol errors no longer cause
7479 Emacs to exit; instead, they are recorded in the string
7480 stored in x_error_message_string.
7482 Calling x_check_errors signals an Emacs error if an X error has
7483 occurred since the last call to x_catch_errors or x_check_errors.
7485 Calling x_uncatch_errors resumes the normal error handling. */
7487 void x_check_errors ();
7488 static Lisp_Object
x_catch_errors_unwind ();
7491 x_catch_errors (dpy
)
7494 int count
= SPECPDL_INDEX ();
7496 /* Make sure any errors from previous requests have been dealt with. */
7499 record_unwind_protect (x_catch_errors_unwind
,
7500 Fcons (make_save_value (dpy
, 0),
7501 x_error_message_string
));
7503 x_error_message_string
= make_uninit_string (X_ERROR_MESSAGE_SIZE
);
7504 SSET (x_error_message_string
, 0, 0);
7509 /* Unbind the binding that we made to check for X errors. */
7512 x_catch_errors_unwind (old_val
)
7513 Lisp_Object old_val
;
7515 Lisp_Object first
= XCAR (old_val
);
7516 Display
*dpy
= XSAVE_VALUE (first
)->pointer
;
7518 /* The display may have been closed before this function is called.
7519 Check if it is still open before calling XSync. */
7520 if (x_display_info_for_display (dpy
) != 0)
7527 x_error_message_string
= XCDR (old_val
);
7531 /* If any X protocol errors have arrived since the last call to
7532 x_catch_errors or x_check_errors, signal an Emacs error using
7533 sprintf (a buffer, FORMAT, the x error message text) as the text. */
7536 x_check_errors (dpy
, format
)
7540 /* Make sure to catch any errors incurred so far. */
7543 if (SREF (x_error_message_string
, 0))
7544 error (format
, SDATA (x_error_message_string
));
7547 /* Nonzero if we had any X protocol errors
7548 since we did x_catch_errors on DPY. */
7551 x_had_errors_p (dpy
)
7554 /* Make sure to catch any errors incurred so far. */
7557 return SREF (x_error_message_string
, 0) != 0;
7560 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
7563 x_clear_errors (dpy
)
7566 SSET (x_error_message_string
, 0, 0);
7569 /* Stop catching X protocol errors and let them make Emacs die.
7570 DPY should be the display that was passed to x_catch_errors.
7571 COUNT should be the value that was returned by
7572 the corresponding call to x_catch_errors. */
7575 x_uncatch_errors (dpy
, count
)
7579 unbind_to (count
, Qnil
);
7583 static unsigned int x_wire_count
;
7586 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
7591 /* Handle SIGPIPE, which can happen when the connection to a server
7592 simply goes away. SIGPIPE is handled by x_connection_signal.
7593 Don't need to do anything, because the write which caused the
7594 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
7595 which will do the appropriate cleanup for us. */
7598 x_connection_signal (signalnum
) /* If we don't have an argument, */
7599 int signalnum
; /* some compilers complain in signal calls. */
7602 /* USG systems forget handlers when they are used;
7603 must reestablish each time */
7604 signal (signalnum
, x_connection_signal
);
7609 /************************************************************************
7611 ************************************************************************/
7613 /* Error message passed to x_connection_closed. */
7615 static char *error_msg
;
7617 /* Function installed as fatal_error_signal_hook in
7618 x_connection_closed. Print the X error message, and exit normally,
7619 instead of dumping core when XtCloseDisplay fails. */
7622 x_fatal_error_signal ()
7624 fprintf (stderr
, "%s\n", error_msg
);
7628 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
7629 the text of an error message that lead to the connection loss. */
7632 x_connection_closed (dpy
, error_message
)
7634 char *error_message
;
7636 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
7637 Lisp_Object frame
, tail
;
7639 int index
= SPECPDL_INDEX ();
7641 error_msg
= (char *) alloca (strlen (error_message
) + 1);
7642 strcpy (error_msg
, error_message
);
7643 handling_signal
= 0;
7645 /* Prevent being called recursively because of an error condition
7646 below. Otherwise, we might end up with printing ``can't find per
7647 display information'' in the recursive call instead of printing
7648 the original message here. */
7649 count
= x_catch_errors (dpy
);
7651 /* Inhibit redisplay while frames are being deleted. */
7652 specbind (Qinhibit_redisplay
, Qt
);
7656 /* Protect display from being closed when we delete the last
7658 dpyinfo
->reference_count
++;
7659 dpyinfo
->terminal
->reference_count
++;
7662 /* First delete frames whose mini-buffers are on frames
7663 that are on the dead display. */
7664 FOR_EACH_FRAME (tail
, frame
)
7666 Lisp_Object minibuf_frame
;
7668 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
7669 if (FRAME_X_P (XFRAME (frame
))
7670 && FRAME_X_P (XFRAME (minibuf_frame
))
7671 && ! EQ (frame
, minibuf_frame
)
7672 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
7673 Fdelete_frame (frame
, Qt
);
7676 /* Now delete all remaining frames on the dead display.
7677 We are now sure none of these is used as the mini-buffer
7678 for another frame that we need to delete. */
7679 FOR_EACH_FRAME (tail
, frame
)
7680 if (FRAME_X_P (XFRAME (frame
))
7681 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
7683 /* Set this to t so that Fdelete_frame won't get confused
7684 trying to find a replacement. */
7685 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
7686 Fdelete_frame (frame
, Qt
);
7689 /* We have to close the display to inform Xt that it doesn't
7690 exist anymore. If we don't, Xt will continue to wait for
7691 events from the display. As a consequence, a sequence of
7693 M-x make-frame-on-display RET :1 RET
7694 ...kill the new frame, so that we get an IO error...
7695 M-x make-frame-on-display RET :1 RET
7697 will indefinitely wait in Xt for events for display `:1', opened
7698 in the first class to make-frame-on-display.
7700 Closing the display is reported to lead to a bus error on
7701 OpenWindows in certain situations. I suspect that is a bug
7702 in OpenWindows. I don't know how to cicumvent it here. */
7704 #ifdef USE_X_TOOLKIT
7705 /* If DPYINFO is null, this means we didn't open the display
7706 in the first place, so don't try to close it. */
7709 extern void (*fatal_error_signal_hook
) P_ ((void));
7710 fatal_error_signal_hook
= x_fatal_error_signal
;
7711 XtCloseDisplay (dpy
);
7712 fatal_error_signal_hook
= NULL
;
7718 xg_display_close (dpyinfo
->display
);
7723 /* Indicate that this display is dead. */
7724 dpyinfo
->display
= 0;
7726 dpyinfo
->reference_count
--;
7727 dpyinfo
->terminal
->reference_count
--;
7728 if (dpyinfo
->reference_count
!= 0)
7729 /* We have just closed all frames on this display. */
7732 x_delete_display (dpyinfo
);
7735 x_uncatch_errors (dpy
, count
);
7737 if (terminal_list
== 0)
7739 fprintf (stderr
, "%s\n", error_msg
);
7740 shut_down_emacs (0, 0, Qnil
);
7744 /* Ordinary stack unwind doesn't deal with these. */
7746 sigunblock (sigmask (SIGIO
));
7748 sigunblock (sigmask (SIGALRM
));
7749 TOTALLY_UNBLOCK_INPUT
;
7751 unbind_to (index
, Qnil
);
7752 clear_waiting_for_input ();
7753 error ("%s", error_msg
);
7756 /* We specifically use it before defining it, so that gcc doesn't inline it,
7757 otherwise gdb doesn't know how to properly put a breakpoint on it. */
7758 static void x_error_quitter (Display
*display
, XErrorEvent
*error
);
7760 /* This is the first-level handler for X protocol errors.
7761 It calls x_error_quitter or x_error_catcher. */
7764 x_error_handler (display
, error
)
7768 if (! NILP (x_error_message_string
))
7769 x_error_catcher (display
, error
);
7771 x_error_quitter (display
, error
);
7775 /* This is the usual handler for X protocol errors.
7776 It kills all frames on the display that we got the error for.
7777 If that was the only one, it prints an error message and kills Emacs. */
7779 /* .gdbinit puts a breakpoint here, so make sure it is not inlined. */
7781 #if __GNUC__ >= 3 /* On GCC 3.0 we might get a warning. */
7782 #define NO_INLINE __attribute__((noinline))
7787 /* Some versions of GNU/Linux define noinline in their headers. */
7793 /* On older GCC versions, just putting x_error_quitter
7794 after x_error_handler prevents inlining into the former. */
7796 static void NO_INLINE
7797 x_error_quitter (display
, error
)
7801 char buf
[256], buf1
[356];
7803 /* Note that there is no real way portable across R3/R4 to get the
7804 original error handler. */
7806 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
7807 sprintf (buf1
, "X protocol error: %s on protocol request %d",
7808 buf
, error
->request_code
);
7809 x_connection_closed (display
, buf1
);
7813 /* This is the handler for X IO errors, always.
7814 It kills all frames on the display that we lost touch with.
7815 If that was the only one, it prints an error message and kills Emacs. */
7818 x_io_error_quitter (display
)
7823 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
7824 x_connection_closed (display
, buf
);
7828 /* Changing the font of the frame. */
7830 /* Give frame F the font named FONTNAME as its default font, and
7831 return the full name of that font. FONTNAME may be a wildcard
7832 pattern; in that case, we choose some font that fits the pattern.
7833 The return value shows which font we chose. */
7836 x_new_font (f
, fontname
)
7838 register char *fontname
;
7840 struct font_info
*fontp
7841 = FS_LOAD_FONT (f
, 0, fontname
, -1);
7846 FRAME_FONT (f
) = (XFontStruct
*) (fontp
->font
);
7847 FRAME_BASELINE_OFFSET (f
) = fontp
->baseline_offset
;
7848 FRAME_FONTSET (f
) = -1;
7850 FRAME_COLUMN_WIDTH (f
) = fontp
->average_width
;
7851 FRAME_SPACE_WIDTH (f
) = fontp
->space_width
;
7852 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (FRAME_FONT (f
));
7854 compute_fringe_widths (f
, 1);
7856 /* Compute the scroll bar width in character columns. */
7857 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
7859 int wid
= FRAME_COLUMN_WIDTH (f
);
7860 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
7861 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
-1) / wid
;
7865 int wid
= FRAME_COLUMN_WIDTH (f
);
7866 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
7869 /* Now make the frame display the given font. */
7870 if (FRAME_X_WINDOW (f
) != 0)
7872 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
7873 FRAME_FONT (f
)->fid
);
7874 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->reverse_gc
,
7875 FRAME_FONT (f
)->fid
);
7876 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->cursor_gc
,
7877 FRAME_FONT (f
)->fid
);
7879 /* Don't change the size of a tip frame; there's no point in
7880 doing it because it's done in Fx_show_tip, and it leads to
7881 problems because the tip frame has no widget. */
7882 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
7883 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
7886 return build_string (fontp
->full_name
);
7889 /* Give frame F the fontset named FONTSETNAME as its default font, and
7890 return the full name of that fontset. FONTSETNAME may be a wildcard
7891 pattern; in that case, we choose some fontset that fits the pattern.
7892 The return value shows which fontset we chose. */
7895 x_new_fontset (f
, fontsetname
)
7899 int fontset
= fs_query_fontset (build_string (fontsetname
), 0);
7905 if (FRAME_FONTSET (f
) == fontset
)
7906 /* This fontset is already set in frame F. There's nothing more
7908 return fontset_name (fontset
);
7910 result
= x_new_font (f
, (SDATA (fontset_ascii (fontset
))));
7912 if (!STRINGP (result
))
7913 /* Can't load ASCII font. */
7916 /* Since x_new_font doesn't update any fontset information, do it now. */
7917 FRAME_FONTSET (f
) = fontset
;
7921 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
7922 xic_set_xfontset (f
, SDATA (fontset_ascii (fontset
)));
7925 return build_string (fontsetname
);
7929 /***********************************************************************
7931 ***********************************************************************/
7937 /* XIM destroy callback function, which is called whenever the
7938 connection to input method XIM dies. CLIENT_DATA contains a
7939 pointer to the x_display_info structure corresponding to XIM. */
7942 xim_destroy_callback (xim
, client_data
, call_data
)
7944 XPointer client_data
;
7947 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
7948 Lisp_Object frame
, tail
;
7952 /* No need to call XDestroyIC.. */
7953 FOR_EACH_FRAME (tail
, frame
)
7955 struct frame
*f
= XFRAME (frame
);
7956 if (FRAME_X_P (f
) && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
7958 FRAME_XIC (f
) = NULL
;
7959 xic_free_xfontset (f
);
7963 /* No need to call XCloseIM. */
7964 dpyinfo
->xim
= NULL
;
7965 XFree (dpyinfo
->xim_styles
);
7969 #endif /* HAVE_X11R6 */
7972 /* This isn't prototyped in OSF 5.0 or 5.1a. */
7973 extern char *XSetIMValues
P_ ((XIM
, ...));
7976 /* Open the connection to the XIM server on display DPYINFO.
7977 RESOURCE_NAME is the resource name Emacs uses. */
7980 xim_open_dpy (dpyinfo
, resource_name
)
7981 struct x_display_info
*dpyinfo
;
7982 char *resource_name
;
7989 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
,
7996 XIMCallback destroy
;
7999 /* Get supported styles and XIM values. */
8000 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
8003 destroy
.callback
= xim_destroy_callback
;
8004 destroy
.client_data
= (XPointer
)dpyinfo
;
8005 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
8011 #endif /* HAVE_XIM */
8012 dpyinfo
->xim
= NULL
;
8016 #ifdef HAVE_X11R6_XIM
8020 struct x_display_info
*dpyinfo
;
8021 char *resource_name
;
8024 /* XIM instantiate callback function, which is called whenever an XIM
8025 server is available. DISPLAY is the display of the XIM.
8026 CLIENT_DATA contains a pointer to an xim_inst_t structure created
8027 when the callback was registered. */
8030 xim_instantiate_callback (display
, client_data
, call_data
)
8032 XPointer client_data
;
8035 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
8036 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
8038 /* We don't support multiple XIM connections. */
8042 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
8044 /* Create XIC for the existing frames on the same display, as long
8045 as they have no XIC. */
8046 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
8048 Lisp_Object tail
, frame
;
8051 FOR_EACH_FRAME (tail
, frame
)
8053 struct frame
*f
= XFRAME (frame
);
8056 && FRAME_X_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
8057 if (FRAME_XIC (f
) == NULL
)
8059 create_frame_xic (f
);
8060 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
8061 xic_set_statusarea (f
);
8062 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
8064 struct window
*w
= XWINDOW (f
->selected_window
);
8065 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
8074 #endif /* HAVE_X11R6_XIM */
8077 /* Open a connection to the XIM server on display DPYINFO.
8078 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
8079 connection only at the first time. On X11R6, open the connection
8080 in the XIM instantiate callback function. */
8083 xim_initialize (dpyinfo
, resource_name
)
8084 struct x_display_info
*dpyinfo
;
8085 char *resource_name
;
8090 #ifdef HAVE_X11R6_XIM
8091 struct xim_inst_t
*xim_inst
;
8094 dpyinfo
->xim
= NULL
;
8095 xim_inst
= (struct xim_inst_t
*) xmalloc (sizeof (struct xim_inst_t
));
8096 xim_inst
->dpyinfo
= dpyinfo
;
8097 len
= strlen (resource_name
);
8098 xim_inst
->resource_name
= (char *) xmalloc (len
+ 1);
8099 bcopy (resource_name
, xim_inst
->resource_name
, len
+ 1);
8100 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8101 resource_name
, EMACS_CLASS
,
8102 xim_instantiate_callback
,
8103 /* This is XPointer in XFree86
8104 but (XPointer *) on Tru64, at
8105 least, hence the configure test. */
8106 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
8107 #else /* not HAVE_X11R6_XIM */
8108 dpyinfo
->xim
= NULL
;
8109 xim_open_dpy (dpyinfo
, resource_name
);
8110 #endif /* not HAVE_X11R6_XIM */
8114 #endif /* HAVE_XIM */
8115 dpyinfo
->xim
= NULL
;
8119 /* Close the connection to the XIM server on display DPYINFO. */
8122 xim_close_dpy (dpyinfo
)
8123 struct x_display_info
*dpyinfo
;
8128 #ifdef HAVE_X11R6_XIM
8129 if (dpyinfo
->display
)
8130 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8132 xim_instantiate_callback
, NULL
);
8133 #endif /* not HAVE_X11R6_XIM */
8134 if (dpyinfo
->display
)
8135 XCloseIM (dpyinfo
->xim
);
8136 dpyinfo
->xim
= NULL
;
8137 XFree (dpyinfo
->xim_styles
);
8139 #endif /* HAVE_XIM */
8142 #endif /* not HAVE_X11R6_XIM */
8146 /* Calculate the absolute position in frame F
8147 from its current recorded position values and gravity. */
8150 x_calc_absolute_position (f
)
8153 int flags
= f
->size_hint_flags
;
8155 /* We have nothing to do if the current position
8156 is already for the top-left corner. */
8157 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
8160 /* Treat negative positions as relative to the leftmost bottommost
8161 position that fits on the screen. */
8162 if (flags
& XNegative
)
8163 f
->left_pos
= (FRAME_X_DISPLAY_INFO (f
)->width
8164 - FRAME_PIXEL_WIDTH (f
) + f
->left_pos
);
8167 int height
= FRAME_PIXEL_HEIGHT (f
);
8169 #if defined USE_X_TOOLKIT && defined USE_MOTIF
8170 /* Something is fishy here. When using Motif, starting Emacs with
8171 `-g -0-0', the frame appears too low by a few pixels.
8173 This seems to be so because initially, while Emacs is starting,
8174 the column widget's height and the frame's pixel height are
8175 different. The column widget's height is the right one. In
8176 later invocations, when Emacs is up, the frame's pixel height
8179 It's not obvious where the initial small difference comes from.
8180 2000-12-01, gerd. */
8182 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
8185 if (flags
& YNegative
)
8186 f
->top_pos
= (FRAME_X_DISPLAY_INFO (f
)->height
- height
+ f
->top_pos
);
8189 /* The left_pos and top_pos
8190 are now relative to the top and left screen edges,
8191 so the flags should correspond. */
8192 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8195 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
8196 to really change the position, and 0 when calling from
8197 x_make_frame_visible (in that case, XOFF and YOFF are the current
8198 position values). It is -1 when calling from x_set_frame_parameters,
8199 which means, do adjust for borders but don't change the gravity. */
8202 x_set_offset (f
, xoff
, yoff
, change_gravity
)
8204 register int xoff
, yoff
;
8207 int modified_top
, modified_left
;
8209 if (change_gravity
> 0)
8213 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8215 f
->size_hint_flags
|= XNegative
;
8217 f
->size_hint_flags
|= YNegative
;
8218 f
->win_gravity
= NorthWestGravity
;
8220 x_calc_absolute_position (f
);
8223 x_wm_set_size_hint (f
, (long) 0, 0);
8225 modified_left
= f
->left_pos
;
8226 modified_top
= f
->top_pos
;
8228 if (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
)
8230 /* Some WMs (twm, wmaker at least) has an offset that is smaller
8231 than the WM decorations. So we use the calculated offset instead
8232 of the WM decoration sizes here (x/y_pixels_outer_diff). */
8233 modified_left
+= FRAME_X_OUTPUT (f
)->move_offset_left
;
8234 modified_top
+= FRAME_X_OUTPUT (f
)->move_offset_top
;
8237 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8238 modified_left
, modified_top
);
8240 if (FRAME_VISIBLE_P (f
)
8241 && FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
)
8243 FRAME_X_OUTPUT (f
)->check_expected_move
= 1;
8244 FRAME_X_OUTPUT (f
)->expected_top
= f
->top_pos
;
8245 FRAME_X_OUTPUT (f
)->expected_left
= f
->left_pos
;
8251 /* Check if we need to resize the frame due to a fullscreen request.
8252 If so needed, resize the frame. */
8254 x_check_fullscreen (f
)
8257 if (f
->want_fullscreen
& FULLSCREEN_BOTH
)
8259 int width
, height
, ign
;
8261 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
8263 x_fullscreen_adjust (f
, &width
, &height
, &ign
, &ign
);
8265 /* We do not need to move the window, it shall be taken care of
8266 when setting WM manager hints.
8267 If the frame is visible already, the position is checked by
8268 x_check_expected_move. */
8269 if (FRAME_COLS (f
) != width
|| FRAME_LINES (f
) != height
)
8271 change_frame_size (f
, height
, width
, 0, 1, 0);
8272 SET_FRAME_GARBAGED (f
);
8273 cancel_mouse_face (f
);
8275 /* Wait for the change of frame size to occur */
8276 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
8281 /* If frame parameters are set after the frame is mapped, we need to move
8283 Some window managers moves the window to the right position, some
8284 moves the outer window manager window to the specified position.
8285 Here we check that we are in the right spot. If not, make a second
8286 move, assuming we are dealing with the second kind of window manager. */
8288 x_check_expected_move (f
)
8291 if (FRAME_X_OUTPUT (f
)->check_expected_move
)
8293 int expect_top
= FRAME_X_OUTPUT (f
)->expected_top
;
8294 int expect_left
= FRAME_X_OUTPUT (f
)->expected_left
;
8296 if (expect_top
!= f
->top_pos
|| expect_left
!= f
->left_pos
)
8298 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_A
;
8299 FRAME_X_OUTPUT (f
)->move_offset_left
= expect_left
- f
->left_pos
;
8300 FRAME_X_OUTPUT (f
)->move_offset_top
= expect_top
- f
->top_pos
;
8302 f
->left_pos
= expect_left
;
8303 f
->top_pos
= expect_top
;
8304 x_set_offset (f
, expect_left
, expect_top
, 0);
8306 else if (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
)
8307 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_B
;
8309 /* Just do this once */
8310 FRAME_X_OUTPUT (f
)->check_expected_move
= 0;
8315 /* Change the size of frame F's X window to COLS/ROWS in the case F
8316 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
8317 top-left-corner window gravity for this size change and subsequent
8318 size changes. Otherwise we leave the window gravity unchanged. */
8321 x_set_window_size_1 (f
, change_gravity
, cols
, rows
)
8326 int pixelwidth
, pixelheight
;
8328 check_frame_size (f
, &rows
, &cols
);
8329 f
->scroll_bar_actual_width
8330 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
8332 : FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0
8333 ? FRAME_CONFIG_SCROLL_BAR_WIDTH (f
)
8334 : (FRAME_CONFIG_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
)));
8336 compute_fringe_widths (f
, 0);
8338 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
8339 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
);
8341 f
->win_gravity
= NorthWestGravity
;
8342 x_wm_set_size_hint (f
, (long) 0, 0);
8344 XSync (FRAME_X_DISPLAY (f
), False
);
8345 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8346 pixelwidth
, pixelheight
);
8348 /* Now, strictly speaking, we can't be sure that this is accurate,
8349 but the window manager will get around to dealing with the size
8350 change request eventually, and we'll hear how it went when the
8351 ConfigureNotify event gets here.
8353 We could just not bother storing any of this information here,
8354 and let the ConfigureNotify event set everything up, but that
8355 might be kind of confusing to the Lisp code, since size changes
8356 wouldn't be reported in the frame parameters until some random
8357 point in the future when the ConfigureNotify event arrives.
8359 We pass 1 for DELAY since we can't run Lisp code inside of
8361 change_frame_size (f
, rows
, cols
, 0, 1, 0);
8362 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
8363 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
8365 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
8366 receive in the ConfigureNotify event; if we get what we asked
8367 for, then the event won't cause the screen to become garbaged, so
8368 we have to make sure to do it here. */
8369 SET_FRAME_GARBAGED (f
);
8371 XFlush (FRAME_X_DISPLAY (f
));
8375 /* Call this to change the size of frame F's x-window.
8376 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
8377 for this size change and subsequent size changes.
8378 Otherwise we leave the window gravity unchanged. */
8381 x_set_window_size (f
, change_gravity
, cols
, rows
)
8389 if (FRAME_GTK_WIDGET (f
))
8390 xg_frame_set_char_size (f
, cols
, rows
);
8392 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8395 if (f
->output_data
.x
->widget
!= NULL
)
8397 /* The x and y position of the widget is clobbered by the
8398 call to XtSetValues within EmacsFrameSetCharSize.
8399 This is a real kludge, but I don't understand Xt so I can't
8400 figure out a correct fix. Can anyone else tell me? -- rms. */
8401 int xpos
= f
->output_data
.x
->widget
->core
.x
;
8402 int ypos
= f
->output_data
.x
->widget
->core
.y
;
8403 EmacsFrameSetCharSize (f
->output_data
.x
->edit_widget
, cols
, rows
);
8404 f
->output_data
.x
->widget
->core
.x
= xpos
;
8405 f
->output_data
.x
->widget
->core
.y
= ypos
;
8408 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8410 #else /* not USE_X_TOOLKIT */
8412 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8414 #endif /* not USE_X_TOOLKIT */
8416 /* If cursor was outside the new size, mark it as off. */
8417 mark_window_cursors_off (XWINDOW (f
->root_window
));
8419 /* Clear out any recollection of where the mouse highlighting was,
8420 since it might be in a place that's outside the new frame size.
8421 Actually checking whether it is outside is a pain in the neck,
8422 so don't try--just let the highlighting be done afresh with new size. */
8423 cancel_mouse_face (f
);
8428 /* Mouse warping. */
8431 x_set_mouse_position (f
, x
, y
)
8437 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
8438 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
8440 if (pix_x
< 0) pix_x
= 0;
8441 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
8443 if (pix_y
< 0) pix_y
= 0;
8444 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
8448 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8449 0, 0, 0, 0, pix_x
, pix_y
);
8453 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
8456 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
8462 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8463 0, 0, 0, 0, pix_x
, pix_y
);
8467 /* focus shifting, raising and lowering. */
8470 x_focus_on_frame (f
)
8473 #if 0 /* This proves to be unpleasant. */
8477 /* I don't think that the ICCCM allows programs to do things like this
8478 without the interaction of the window manager. Whatever you end up
8479 doing with this code, do it to x_unfocus_frame too. */
8480 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8481 RevertToPointerRoot
, CurrentTime
);
8490 /* Look at the remarks in x_focus_on_frame. */
8491 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
8492 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
8493 RevertToPointerRoot
, CurrentTime
);
8497 /* Raise frame F. */
8503 if (f
->async_visible
)
8506 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8507 XFlush (FRAME_X_DISPLAY (f
));
8512 /* Lower frame F. */
8518 if (f
->async_visible
)
8521 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8522 XFlush (FRAME_X_DISPLAY (f
));
8528 XTframe_raise_lower (f
, raise_flag
)
8538 /* Change of visibility. */
8540 /* This tries to wait until the frame is really visible.
8541 However, if the window manager asks the user where to position
8542 the frame, this will return before the user finishes doing that.
8543 The frame will not actually be visible at that time,
8544 but it will become visible later when the window manager
8545 finishes with it. */
8548 x_make_frame_visible (f
)
8552 int original_top
, original_left
;
8553 int retry_count
= 2;
8559 type
= x_icon_type (f
);
8561 x_bitmap_icon (f
, type
);
8563 if (! FRAME_VISIBLE_P (f
))
8565 /* We test FRAME_GARBAGED_P here to make sure we don't
8566 call x_set_offset a second time
8567 if we get to x_make_frame_visible a second time
8568 before the window gets really visible. */
8569 if (! FRAME_ICONIFIED_P (f
)
8570 && ! f
->output_data
.x
->asked_for_visible
)
8571 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
8573 f
->output_data
.x
->asked_for_visible
= 1;
8575 if (! EQ (Vx_no_window_manager
, Qt
))
8576 x_wm_set_window_state (f
, NormalState
);
8577 #ifdef USE_X_TOOLKIT
8578 /* This was XtPopup, but that did nothing for an iconified frame. */
8579 XtMapWidget (f
->output_data
.x
->widget
);
8580 #else /* not USE_X_TOOLKIT */
8582 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
8583 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
8585 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8586 #endif /* not USE_GTK */
8587 #endif /* not USE_X_TOOLKIT */
8588 #if 0 /* This seems to bring back scroll bars in the wrong places
8589 if the window configuration has changed. They seem
8590 to come back ok without this. */
8591 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
8592 XMapSubwindows (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8596 XFlush (FRAME_X_DISPLAY (f
));
8598 /* Synchronize to ensure Emacs knows the frame is visible
8599 before we do anything else. We do this loop with input not blocked
8600 so that incoming events are handled. */
8604 /* This must be before UNBLOCK_INPUT
8605 since events that arrive in response to the actions above
8606 will set it when they are handled. */
8607 int previously_visible
= f
->output_data
.x
->has_been_visible
;
8609 original_left
= f
->left_pos
;
8610 original_top
= f
->top_pos
;
8612 /* This must come after we set COUNT. */
8615 /* We unblock here so that arriving X events are processed. */
8617 /* Now move the window back to where it was "supposed to be".
8618 But don't do it if the gravity is negative.
8619 When the gravity is negative, this uses a position
8620 that is 3 pixels too low. Perhaps that's really the border width.
8622 Don't do this if the window has never been visible before,
8623 because the window manager may choose the position
8624 and we don't want to override it. */
8626 if (! FRAME_VISIBLE_P (f
) && ! FRAME_ICONIFIED_P (f
)
8627 && f
->win_gravity
== NorthWestGravity
8628 && previously_visible
)
8632 unsigned int width
, height
, border
, depth
;
8636 /* On some window managers (such as FVWM) moving an existing
8637 window, even to the same place, causes the window manager
8638 to introduce an offset. This can cause the window to move
8639 to an unexpected location. Check the geometry (a little
8640 slow here) and then verify that the window is in the right
8641 place. If the window is not in the right place, move it
8642 there, and take the potential window manager hit. */
8643 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8644 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
8646 if (original_left
!= x
|| original_top
!= y
)
8647 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8648 original_left
, original_top
);
8653 XSETFRAME (frame
, f
);
8655 /* Wait until the frame is visible. Process X events until a
8656 MapNotify event has been seen, or until we think we won't get a
8657 MapNotify at all.. */
8658 for (count
= input_signal_count
+ 10;
8659 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
8661 /* Force processing of queued events. */
8664 /* Machines that do polling rather than SIGIO have been
8665 observed to go into a busy-wait here. So we'll fake an
8666 alarm signal to let the handler know that there's something
8667 to be read. We used to raise a real alarm, but it seems
8668 that the handler isn't always enabled here. This is
8670 if (input_polling_used ())
8672 /* It could be confusing if a real alarm arrives while
8673 processing the fake one. Turn it off and let the
8674 handler reset it. */
8675 extern void poll_for_input_1
P_ ((void));
8676 int old_poll_suppress_count
= poll_suppress_count
;
8677 poll_suppress_count
= 1;
8678 poll_for_input_1 ();
8679 poll_suppress_count
= old_poll_suppress_count
;
8682 /* See if a MapNotify event has been processed. */
8683 FRAME_SAMPLE_VISIBILITY (f
);
8688 (let ((f (selected-frame)))
8692 the frame is not raised with various window managers on
8693 FreeBSD, GNU/Linux and Solaris. It turns out that, for some
8694 unknown reason, the call to XtMapWidget is completely ignored.
8695 Mapping the widget a second time works. */
8697 if (!FRAME_VISIBLE_P (f
) && --retry_count
> 0)
8702 /* Change from mapped state to withdrawn state. */
8704 /* Make the frame visible (mapped and not iconified). */
8707 x_make_frame_invisible (f
)
8712 /* Use the frame's outermost window, not the one we normally draw on. */
8713 window
= FRAME_OUTER_WINDOW (f
);
8715 /* Don't keep the highlight on an invisible frame. */
8716 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
8717 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
8719 #if 0/* This might add unreliability; I don't trust it -- rms. */
8720 if (! f
->async_visible
&& ! f
->async_iconified
)
8726 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
8727 that the current position of the window is user-specified, rather than
8728 program-specified, so that when the window is mapped again, it will be
8729 placed at the same location, without forcing the user to position it
8730 by hand again (they have already done that once for this window.) */
8731 x_wm_set_size_hint (f
, (long) 0, 1);
8734 if (FRAME_GTK_OUTER_WIDGET (f
))
8735 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f
));
8741 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
8742 DefaultScreen (FRAME_X_DISPLAY (f
))))
8744 UNBLOCK_INPUT_RESIGNAL
;
8745 error ("Can't notify window manager of window withdrawal");
8747 #else /* ! defined (HAVE_X11R4) */
8749 /* Tell the window manager what we're going to do. */
8750 if (! EQ (Vx_no_window_manager
, Qt
))
8754 unmap
.xunmap
.type
= UnmapNotify
;
8755 unmap
.xunmap
.window
= window
;
8756 unmap
.xunmap
.event
= DefaultRootWindow (FRAME_X_DISPLAY (f
));
8757 unmap
.xunmap
.from_configure
= False
;
8758 if (! XSendEvent (FRAME_X_DISPLAY (f
),
8759 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
8761 SubstructureRedirectMaskSubstructureNotifyMask
,
8764 UNBLOCK_INPUT_RESIGNAL
;
8765 error ("Can't notify window manager of withdrawal");
8769 /* Unmap the window ourselves. Cheeky! */
8770 XUnmapWindow (FRAME_X_DISPLAY (f
), window
);
8771 #endif /* ! defined (HAVE_X11R4) */
8774 /* We can't distinguish this from iconification
8775 just by the event that we get from the server.
8776 So we can't win using the usual strategy of letting
8777 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
8778 and synchronize with the server to make sure we agree. */
8780 FRAME_ICONIFIED_P (f
) = 0;
8781 f
->async_visible
= 0;
8782 f
->async_iconified
= 0;
8789 /* Change window state from mapped to iconified. */
8798 /* Don't keep the highlight on an invisible frame. */
8799 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
8800 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
8802 if (f
->async_iconified
)
8807 FRAME_SAMPLE_VISIBILITY (f
);
8809 type
= x_icon_type (f
);
8811 x_bitmap_icon (f
, type
);
8814 if (FRAME_GTK_OUTER_WIDGET (f
))
8816 if (! FRAME_VISIBLE_P (f
))
8817 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
8819 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
8822 f
->async_iconified
= 1;
8823 f
->async_visible
= 0;
8829 #ifdef USE_X_TOOLKIT
8831 if (! FRAME_VISIBLE_P (f
))
8833 if (! EQ (Vx_no_window_manager
, Qt
))
8834 x_wm_set_window_state (f
, IconicState
);
8835 /* This was XtPopup, but that did nothing for an iconified frame. */
8836 XtMapWidget (f
->output_data
.x
->widget
);
8837 /* The server won't give us any event to indicate
8838 that an invisible frame was changed to an icon,
8839 so we have to record it here. */
8842 f
->async_iconified
= 1;
8843 f
->async_visible
= 0;
8848 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
8849 XtWindow (f
->output_data
.x
->widget
),
8850 DefaultScreen (FRAME_X_DISPLAY (f
)));
8854 error ("Can't notify window manager of iconification");
8856 f
->async_iconified
= 1;
8857 f
->async_visible
= 0;
8861 XFlush (FRAME_X_DISPLAY (f
));
8863 #else /* not USE_X_TOOLKIT */
8865 /* Make sure the X server knows where the window should be positioned,
8866 in case the user deiconifies with the window manager. */
8867 if (! FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P (f
))
8868 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
8870 /* Since we don't know which revision of X we're running, we'll use both
8871 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
8873 /* X11R4: send a ClientMessage to the window manager using the
8874 WM_CHANGE_STATE type. */
8878 message
.xclient
.window
= FRAME_X_WINDOW (f
);
8879 message
.xclient
.type
= ClientMessage
;
8880 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
8881 message
.xclient
.format
= 32;
8882 message
.xclient
.data
.l
[0] = IconicState
;
8884 if (! XSendEvent (FRAME_X_DISPLAY (f
),
8885 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
8887 SubstructureRedirectMask
| SubstructureNotifyMask
,
8890 UNBLOCK_INPUT_RESIGNAL
;
8891 error ("Can't notify window manager of iconification");
8895 /* X11R3: set the initial_state field of the window manager hints to
8897 x_wm_set_window_state (f
, IconicState
);
8899 if (!FRAME_VISIBLE_P (f
))
8901 /* If the frame was withdrawn, before, we must map it. */
8902 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8905 f
->async_iconified
= 1;
8906 f
->async_visible
= 0;
8908 XFlush (FRAME_X_DISPLAY (f
));
8910 #endif /* not USE_X_TOOLKIT */
8914 /* Free X resources of frame F. */
8917 x_free_frame_resources (f
)
8920 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8922 struct scroll_bar
*b
;
8926 /* If a display connection is dead, don't try sending more
8927 commands to the X server. */
8928 if (dpyinfo
->display
)
8930 if (f
->output_data
.x
->icon_desc
)
8931 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
8933 #ifdef USE_X_TOOLKIT
8934 /* Explicitly destroy the scroll bars of the frame. Without
8935 this, we get "BadDrawable" errors from the toolkit later on,
8936 presumably from expose events generated for the disappearing
8937 toolkit scroll bars. */
8938 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
8940 b
= XSCROLL_BAR (bar
);
8941 x_scroll_bar_remove (b
);
8950 #ifdef USE_X_TOOLKIT
8951 if (f
->output_data
.x
->widget
)
8953 XtDestroyWidget (f
->output_data
.x
->widget
);
8954 f
->output_data
.x
->widget
= NULL
;
8956 /* Tooltips don't have widgets, only a simple X window, even if
8957 we are using a toolkit. */
8958 else if (FRAME_X_WINDOW (f
))
8959 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8961 free_frame_menubar (f
);
8962 #else /* !USE_X_TOOLKIT */
8965 /* In the GTK version, tooltips are normal X
8966 frames. We must check and free both types. */
8967 if (FRAME_GTK_OUTER_WIDGET (f
))
8969 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
8970 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow below */
8971 FRAME_GTK_OUTER_WIDGET (f
) = 0;
8973 #endif /* USE_GTK */
8975 if (FRAME_X_WINDOW (f
))
8976 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8977 #endif /* !USE_X_TOOLKIT */
8979 unload_color (f
, f
->output_data
.x
->foreground_pixel
);
8980 unload_color (f
, f
->output_data
.x
->background_pixel
);
8981 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
8982 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
8983 unload_color (f
, f
->output_data
.x
->border_pixel
);
8984 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
8986 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
8987 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
8988 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
8989 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
8990 #ifdef USE_TOOLKIT_SCROLL_BARS
8991 /* Scrollbar shadow colors. */
8992 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
8993 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
8994 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
8995 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
8996 #endif /* USE_TOOLKIT_SCROLL_BARS */
8997 if (f
->output_data
.x
->white_relief
.allocated_p
)
8998 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
8999 if (f
->output_data
.x
->black_relief
.allocated_p
)
9000 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
9002 if (FRAME_FACE_CACHE (f
))
9003 free_frame_faces (f
);
9006 XFlush (FRAME_X_DISPLAY (f
));
9009 if (f
->output_data
.x
->saved_menu_event
)
9010 xfree (f
->output_data
.x
->saved_menu_event
);
9012 xfree (f
->output_data
.x
);
9013 f
->output_data
.x
= NULL
;
9015 if (f
== dpyinfo
->x_focus_frame
)
9016 dpyinfo
->x_focus_frame
= 0;
9017 if (f
== dpyinfo
->x_focus_event_frame
)
9018 dpyinfo
->x_focus_event_frame
= 0;
9019 if (f
== dpyinfo
->x_highlight_frame
)
9020 dpyinfo
->x_highlight_frame
= 0;
9022 if (f
== dpyinfo
->mouse_face_mouse_frame
)
9024 dpyinfo
->mouse_face_beg_row
9025 = dpyinfo
->mouse_face_beg_col
= -1;
9026 dpyinfo
->mouse_face_end_row
9027 = dpyinfo
->mouse_face_end_col
= -1;
9028 dpyinfo
->mouse_face_window
= Qnil
;
9029 dpyinfo
->mouse_face_deferred_gc
= 0;
9030 dpyinfo
->mouse_face_mouse_frame
= 0;
9037 /* Destroy the X window of frame F. */
9040 x_destroy_window (f
)
9043 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9045 /* If a display connection is dead, don't try sending more
9046 commands to the X server. */
9047 if (dpyinfo
->display
!= 0)
9048 x_free_frame_resources (f
);
9050 dpyinfo
->reference_count
--;
9054 /* Setting window manager hints. */
9056 /* Set the normal size hints for the window manager, for frame F.
9057 FLAGS is the flags word to use--or 0 meaning preserve the flags
9058 that the window now has.
9059 If USER_POSITION is nonzero, we set the USPosition
9060 flag (this is useful when FLAGS is 0).
9061 The GTK version is in gtkutils.c */
9065 x_wm_set_size_hint (f
, flags
, user_position
)
9070 XSizeHints size_hints
;
9072 #ifdef USE_X_TOOLKIT
9075 Dimension widget_width
, widget_height
;
9078 Window window
= FRAME_OUTER_WINDOW (f
);
9080 /* Setting PMaxSize caused various problems. */
9081 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
9083 size_hints
.x
= f
->left_pos
;
9084 size_hints
.y
= f
->top_pos
;
9086 #ifdef USE_X_TOOLKIT
9087 XtSetArg (al
[ac
], XtNwidth
, &widget_width
); ac
++;
9088 XtSetArg (al
[ac
], XtNheight
, &widget_height
); ac
++;
9089 XtGetValues (f
->output_data
.x
->widget
, al
, ac
);
9090 size_hints
.height
= widget_height
;
9091 size_hints
.width
= widget_width
;
9092 #else /* not USE_X_TOOLKIT */
9093 size_hints
.height
= FRAME_PIXEL_HEIGHT (f
);
9094 size_hints
.width
= FRAME_PIXEL_WIDTH (f
);
9095 #endif /* not USE_X_TOOLKIT */
9097 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
9098 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
9099 size_hints
.max_width
9100 = FRAME_X_DISPLAY_INFO (f
)->width
- FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9101 size_hints
.max_height
9102 = FRAME_X_DISPLAY_INFO (f
)->height
- FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9104 /* Calculate the base and minimum sizes.
9106 (When we use the X toolkit, we don't do it here.
9107 Instead we copy the values that the widgets are using, below.) */
9108 #ifndef USE_X_TOOLKIT
9110 int base_width
, base_height
;
9111 int min_rows
= 0, min_cols
= 0;
9113 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9114 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9116 check_frame_size (f
, &min_rows
, &min_cols
);
9118 /* The window manager uses the base width hints to calculate the
9119 current number of rows and columns in the frame while
9120 resizing; min_width and min_height aren't useful for this
9121 purpose, since they might not give the dimensions for a
9122 zero-row, zero-column frame.
9124 We use the base_width and base_height members if we have
9125 them; otherwise, we set the min_width and min_height members
9126 to the size for a zero x zero frame. */
9129 size_hints
.flags
|= PBaseSize
;
9130 size_hints
.base_width
= base_width
;
9131 size_hints
.base_height
= base_height
;
9132 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
9133 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
9135 size_hints
.min_width
= base_width
;
9136 size_hints
.min_height
= base_height
;
9140 /* If we don't need the old flags, we don't need the old hint at all. */
9143 size_hints
.flags
|= flags
;
9146 #endif /* not USE_X_TOOLKIT */
9149 XSizeHints hints
; /* Sometimes I hate X Windows... */
9150 long supplied_return
;
9154 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
9157 value
= XGetNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
);
9160 #ifdef USE_X_TOOLKIT
9161 size_hints
.base_height
= hints
.base_height
;
9162 size_hints
.base_width
= hints
.base_width
;
9163 size_hints
.min_height
= hints
.min_height
;
9164 size_hints
.min_width
= hints
.min_width
;
9168 size_hints
.flags
|= flags
;
9173 if (hints
.flags
& PSize
)
9174 size_hints
.flags
|= PSize
;
9175 if (hints
.flags
& PPosition
)
9176 size_hints
.flags
|= PPosition
;
9177 if (hints
.flags
& USPosition
)
9178 size_hints
.flags
|= USPosition
;
9179 if (hints
.flags
& USSize
)
9180 size_hints
.flags
|= USSize
;
9184 #ifndef USE_X_TOOLKIT
9189 size_hints
.win_gravity
= f
->win_gravity
;
9190 size_hints
.flags
|= PWinGravity
;
9194 size_hints
.flags
&= ~ PPosition
;
9195 size_hints
.flags
|= USPosition
;
9197 #endif /* PWinGravity */
9200 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
9202 XSetNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
9205 #endif /* not USE_GTK */
9207 /* Used for IconicState or NormalState */
9210 x_wm_set_window_state (f
, state
)
9214 #ifdef USE_X_TOOLKIT
9217 XtSetArg (al
[0], XtNinitialState
, state
);
9218 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9219 #else /* not USE_X_TOOLKIT */
9220 Window window
= FRAME_X_WINDOW (f
);
9222 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
9223 f
->output_data
.x
->wm_hints
.initial_state
= state
;
9225 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9226 #endif /* not USE_X_TOOLKIT */
9230 x_wm_set_icon_pixmap (f
, pixmap_id
)
9234 Pixmap icon_pixmap
, icon_mask
;
9236 #ifndef USE_X_TOOLKIT
9237 Window window
= FRAME_OUTER_WINDOW (f
);
9242 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
9243 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
9244 icon_mask
= x_bitmap_mask (f
, pixmap_id
);
9245 f
->output_data
.x
->wm_hints
.icon_mask
= icon_mask
;
9249 /* It seems there is no way to turn off use of an icon pixmap.
9250 The following line does it, only if no icon has yet been created,
9251 for some window managers. But with mwm it crashes.
9252 Some people say it should clear the IconPixmapHint bit in this case,
9253 but that doesn't work, and the X consortium said it isn't the
9254 right thing at all. Since there is no way to win,
9255 best to explicitly give up. */
9257 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
9258 f
->output_data
.x
->wm_hints
.icon_mask
= None
;
9267 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
);
9271 #elif defined (USE_X_TOOLKIT) /* same as in x_wm_set_window_state. */
9275 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
9276 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9277 XtSetArg (al
[0], XtNiconMask
, icon_mask
);
9278 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9281 #else /* not USE_X_TOOLKIT && not USE_GTK */
9283 f
->output_data
.x
->wm_hints
.flags
|= (IconPixmapHint
| IconMaskHint
);
9284 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9286 #endif /* not USE_X_TOOLKIT && not USE_GTK */
9290 x_wm_set_icon_position (f
, icon_x
, icon_y
)
9294 Window window
= FRAME_OUTER_WINDOW (f
);
9296 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
9297 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
9298 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
9300 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9304 /***********************************************************************
9306 ***********************************************************************/
9308 /* Return a pointer to struct font_info of font FONT_IDX of frame F. */
9311 x_get_font_info (f
, font_idx
)
9315 return (FRAME_X_FONT_TABLE (f
) + font_idx
);
9319 /* Return a list of names of available fonts matching PATTERN on frame F.
9321 If SIZE is > 0, it is the size (maximum bounds width) of fonts
9324 SIZE < 0 means include scalable fonts.
9326 Frame F null means we have not yet created any frame on X, and
9327 consult the first display in x_display_list. MAXNAMES sets a limit
9328 on how many fonts to match. */
9331 x_list_fonts (f
, pattern
, size
, maxnames
)
9333 Lisp_Object pattern
;
9337 Lisp_Object list
= Qnil
, patterns
, newlist
= Qnil
, key
= Qnil
;
9338 Lisp_Object tem
, second_best
;
9339 struct x_display_info
*dpyinfo
9340 = f
? FRAME_X_DISPLAY_INFO (f
) : x_display_list
;
9341 Display
*dpy
= dpyinfo
->display
;
9342 int try_XLoadQueryFont
= 0;
9344 int allow_auto_scaled_font
= 0;
9348 allow_auto_scaled_font
= 1;
9352 patterns
= Fassoc (pattern
, Valternate_fontname_alist
);
9353 if (NILP (patterns
))
9354 patterns
= Fcons (pattern
, Qnil
);
9356 if (maxnames
== 1 && !size
)
9357 /* We can return any single font matching PATTERN. */
9358 try_XLoadQueryFont
= 1;
9360 for (; CONSP (patterns
); patterns
= XCDR (patterns
))
9363 char **names
= NULL
;
9365 pattern
= XCAR (patterns
);
9366 /* See if we cached the result for this particular query.
9367 The cache is an alist of the form:
9368 ((((PATTERN . MAXNAMES) . SCALABLE) (FONTNAME . WIDTH) ...) ...) */
9369 tem
= XCDR (dpyinfo
->name_list_element
);
9370 key
= Fcons (Fcons (pattern
, make_number (maxnames
)),
9371 allow_auto_scaled_font
? Qt
: Qnil
);
9372 list
= Fassoc (key
, tem
);
9375 list
= Fcdr_safe (list
);
9376 /* We have a cashed list. Don't have to get the list again. */
9380 /* At first, put PATTERN in the cache. */
9383 count
= x_catch_errors (dpy
);
9385 if (try_XLoadQueryFont
)
9388 unsigned long value
;
9390 font
= XLoadQueryFont (dpy
, SDATA (pattern
));
9391 if (x_had_errors_p (dpy
))
9393 /* This error is perhaps due to insufficient memory on X
9394 server. Let's just ignore it. */
9396 x_clear_errors (dpy
);
9400 && XGetFontProperty (font
, XA_FONT
, &value
))
9402 char *name
= (char *) XGetAtomName (dpy
, (Atom
) value
);
9403 int len
= strlen (name
);
9406 /* If DXPC (a Differential X Protocol Compressor)
9407 Ver.3.7 is running, XGetAtomName will return null
9408 string. We must avoid such a name. */
9410 try_XLoadQueryFont
= 0;
9414 names
= (char **) alloca (sizeof (char *));
9415 /* Some systems only allow alloca assigned to a
9417 tmp
= (char *) alloca (len
+ 1); names
[0] = tmp
;
9418 bcopy (name
, names
[0], len
+ 1);
9423 try_XLoadQueryFont
= 0;
9426 XFreeFont (dpy
, font
);
9429 if (!try_XLoadQueryFont
)
9431 /* We try at least 10 fonts because XListFonts will return
9432 auto-scaled fonts at the head. */
9439 names
= XListFonts (dpy
, SDATA (pattern
), limit
, &num_fonts
);
9440 if (num_fonts
== limit
)
9443 XFreeFontNames (names
);
9452 names
= XListFonts (dpy
, SDATA (pattern
), max (maxnames
, 10),
9455 if (x_had_errors_p (dpy
))
9457 /* This error is perhaps due to insufficient memory on X
9458 server. Let's just ignore it. */
9460 x_clear_errors (dpy
);
9464 x_uncatch_errors (dpy
, count
);
9471 /* Make a list of all the fonts we got back.
9472 Store that in the font cache for the display. */
9473 for (i
= 0; i
< num_fonts
; i
++)
9477 int average_width
= -1, resx
= 0, dashes
= 0;
9479 /* Count the number of dashes in NAMES[I]. If there are
9480 14 dashes, the field value following 9th dash
9481 (RESOLUTION_X) is nonzero, and the field value
9482 following 12th dash (AVERAGE_WIDTH) is 0, this is a
9483 auto-scaled font which is usually too ugly to be used
9484 for editing. Let's ignore it. */
9489 if (dashes
== 7) /* PIXEL_SIZE field */
9491 else if (dashes
== 9)
9493 else if (dashes
== 12) /* AVERAGE_WIDTH field */
9494 average_width
= atoi (p
);
9497 if (allow_auto_scaled_font
9498 || dashes
< 14 || average_width
!= 0 || resx
== 0)
9500 tem
= build_string (names
[i
]);
9501 if (NILP (Fassoc (tem
, list
)))
9503 if (STRINGP (Vx_pixel_size_width_font_regexp
)
9504 && ((fast_c_string_match_ignore_case
9505 (Vx_pixel_size_width_font_regexp
, names
[i
]))
9507 /* We can set the value of PIXEL_SIZE to the
9508 width of this font. */
9509 list
= Fcons (Fcons (tem
, make_number (width
)), list
);
9511 /* For the moment, width is not known. */
9512 list
= Fcons (Fcons (tem
, Qnil
), list
);
9517 if (!try_XLoadQueryFont
)
9520 XFreeFontNames (names
);
9525 /* Now store the result in the cache. */
9526 XSETCDR (dpyinfo
->name_list_element
,
9527 Fcons (Fcons (key
, list
), XCDR (dpyinfo
->name_list_element
)));
9530 if (NILP (list
)) continue; /* Try the remaining alternatives. */
9532 newlist
= second_best
= Qnil
;
9533 /* Make a list of the fonts that have the right width. */
9534 for (; CONSP (list
); list
= XCDR (list
))
9540 if (!CONSP (tem
) || NILP (XCAR (tem
)))
9544 newlist
= Fcons (XCAR (tem
), newlist
);
9548 if (!INTEGERP (XCDR (tem
)))
9550 /* Since we have not yet known the size of this font, we
9551 must try slow function call XLoadQueryFont. */
9552 XFontStruct
*thisinfo
;
9555 count
= x_catch_errors (dpy
);
9556 thisinfo
= XLoadQueryFont (dpy
,
9557 SDATA (XCAR (tem
)));
9558 if (x_had_errors_p (dpy
))
9560 /* This error is perhaps due to insufficient memory on X
9561 server. Let's just ignore it. */
9563 x_clear_errors (dpy
);
9565 x_uncatch_errors (dpy
, count
);
9571 (thisinfo
->min_bounds
.width
== 0
9573 : make_number (thisinfo
->max_bounds
.width
)));
9575 XFreeFont (dpy
, thisinfo
);
9579 /* For unknown reason, the previous call of XListFont had
9580 returned a font which can't be opened. Record the size
9581 as 0 not to try to open it again. */
9582 XSETCDR (tem
, make_number (0));
9585 found_size
= XINT (XCDR (tem
));
9586 if (found_size
== size
)
9587 newlist
= Fcons (XCAR (tem
), newlist
);
9588 else if (found_size
> 0)
9590 if (NILP (second_best
))
9592 else if (found_size
< size
)
9594 if (XINT (XCDR (second_best
)) > size
9595 || XINT (XCDR (second_best
)) < found_size
)
9600 if (XINT (XCDR (second_best
)) > size
9601 && XINT (XCDR (second_best
)) > found_size
)
9606 if (!NILP (newlist
))
9608 else if (!NILP (second_best
))
9610 newlist
= Fcons (XCAR (second_best
), Qnil
);
9621 /* Check that FONT is valid on frame F. It is if it can be found in F's
9625 x_check_font (f
, font
)
9630 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9632 xassert (font
!= NULL
);
9634 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
9635 if (dpyinfo
->font_table
[i
].name
9636 && font
== dpyinfo
->font_table
[i
].font
)
9639 xassert (i
< dpyinfo
->n_fonts
);
9642 #endif /* GLYPH_DEBUG != 0 */
9644 /* Set *W to the minimum width, *H to the minimum font height of FONT.
9645 Note: There are (broken) X fonts out there with invalid XFontStruct
9646 min_bounds contents. For example, handa@etl.go.jp reports that
9647 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
9648 have font->min_bounds.width == 0. */
9651 x_font_min_bounds (font
, w
, h
)
9655 *h
= FONT_HEIGHT (font
);
9656 *w
= font
->min_bounds
.width
;
9658 /* Try to handle the case where FONT->min_bounds has invalid
9659 contents. Since the only font known to have invalid min_bounds
9660 is fixed-width, use max_bounds if min_bounds seems to be invalid. */
9662 *w
= font
->max_bounds
.width
;
9666 /* Compute the smallest character width and smallest font height over
9667 all fonts available on frame F. Set the members smallest_char_width
9668 and smallest_font_height in F's x_display_info structure to
9669 the values computed. Value is non-zero if smallest_font_height or
9670 smallest_char_width become smaller than they were before. */
9673 x_compute_min_glyph_bounds (f
)
9677 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9679 int old_width
= dpyinfo
->smallest_char_width
;
9680 int old_height
= dpyinfo
->smallest_font_height
;
9682 dpyinfo
->smallest_font_height
= 100000;
9683 dpyinfo
->smallest_char_width
= 100000;
9685 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
9686 if (dpyinfo
->font_table
[i
].name
)
9688 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
9691 font
= (XFontStruct
*) fontp
->font
;
9692 xassert (font
!= (XFontStruct
*) ~0);
9693 x_font_min_bounds (font
, &w
, &h
);
9695 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
9696 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
9699 xassert (dpyinfo
->smallest_char_width
> 0
9700 && dpyinfo
->smallest_font_height
> 0);
9702 return (dpyinfo
->n_fonts
== 1
9703 || dpyinfo
->smallest_char_width
< old_width
9704 || dpyinfo
->smallest_font_height
< old_height
);
9708 /* Load font named FONTNAME of the size SIZE for frame F, and return a
9709 pointer to the structure font_info while allocating it dynamically.
9710 If SIZE is 0, load any size of font.
9711 If loading is failed, return NULL. */
9714 x_load_font (f
, fontname
, size
)
9716 register char *fontname
;
9719 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9720 Lisp_Object font_names
;
9723 /* Get a list of all the fonts that match this name. Once we
9724 have a list of matching fonts, we compare them against the fonts
9725 we already have by comparing names. */
9726 font_names
= x_list_fonts (f
, build_string (fontname
), size
, 1);
9728 if (!NILP (font_names
))
9733 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
9734 for (tail
= font_names
; CONSP (tail
); tail
= XCDR (tail
))
9735 if (dpyinfo
->font_table
[i
].name
9736 && (!strcmp (dpyinfo
->font_table
[i
].name
,
9737 SDATA (XCAR (tail
)))
9738 || !strcmp (dpyinfo
->font_table
[i
].full_name
,
9739 SDATA (XCAR (tail
)))))
9740 return (dpyinfo
->font_table
+ i
);
9743 /* Load the font and add it to the table. */
9747 struct font_info
*fontp
;
9748 unsigned long value
;
9751 /* If we have found fonts by x_list_font, load one of them. If
9752 not, we still try to load a font by the name given as FONTNAME
9753 because XListFonts (called in x_list_font) of some X server has
9754 a bug of not finding a font even if the font surely exists and
9755 is loadable by XLoadQueryFont. */
9756 if (size
> 0 && !NILP (font_names
))
9757 fontname
= (char *) SDATA (XCAR (font_names
));
9760 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
9761 font
= (XFontStruct
*) XLoadQueryFont (FRAME_X_DISPLAY (f
), fontname
);
9762 if (x_had_errors_p (FRAME_X_DISPLAY (f
)))
9764 /* This error is perhaps due to insufficient memory on X
9765 server. Let's just ignore it. */
9767 x_clear_errors (FRAME_X_DISPLAY (f
));
9769 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
9774 /* Find a free slot in the font table. */
9775 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
9776 if (dpyinfo
->font_table
[i
].name
== NULL
)
9779 /* If no free slot found, maybe enlarge the font table. */
9780 if (i
== dpyinfo
->n_fonts
9781 && dpyinfo
->n_fonts
== dpyinfo
->font_table_size
)
9784 dpyinfo
->font_table_size
= max (16, 2 * dpyinfo
->font_table_size
);
9785 sz
= dpyinfo
->font_table_size
* sizeof *dpyinfo
->font_table
;
9787 = (struct font_info
*) xrealloc (dpyinfo
->font_table
, sz
);
9790 fontp
= dpyinfo
->font_table
+ i
;
9791 if (i
== dpyinfo
->n_fonts
)
9794 /* Now fill in the slots of *FONTP. */
9796 bzero (fontp
, sizeof (*fontp
));
9798 fontp
->font_idx
= i
;
9799 fontp
->name
= (char *) xmalloc (strlen (fontname
) + 1);
9800 bcopy (fontname
, fontp
->name
, strlen (fontname
) + 1);
9802 if (font
->min_bounds
.width
== font
->max_bounds
.width
)
9804 /* Fixed width font. */
9805 fontp
->average_width
= fontp
->space_width
= font
->min_bounds
.width
;
9812 char2b
.byte1
= 0x00, char2b
.byte2
= 0x20;
9813 pcm
= x_per_char_metric (font
, &char2b
, 0);
9815 fontp
->space_width
= pcm
->width
;
9817 fontp
->space_width
= FONT_WIDTH (font
);
9819 fontp
->average_width
9820 = (XGetFontProperty (font
, dpyinfo
->Xatom_AVERAGE_WIDTH
, &value
)
9821 ? (long) value
/ 10 : 0);
9822 if (fontp
->average_width
< 0)
9823 fontp
->average_width
= - fontp
->average_width
;
9824 if (fontp
->average_width
== 0)
9828 int width
= pcm
->width
;
9829 for (char2b
.byte2
= 33; char2b
.byte2
<= 126; char2b
.byte2
++)
9830 if ((pcm
= x_per_char_metric (font
, &char2b
, 0)) != NULL
)
9831 width
+= pcm
->width
;
9832 fontp
->average_width
= width
/ 95;
9835 fontp
->average_width
= FONT_WIDTH (font
);
9839 /* Try to get the full name of FONT. Put it in FULL_NAME. */
9841 if (XGetFontProperty (font
, XA_FONT
, &value
))
9843 char *name
= (char *) XGetAtomName (FRAME_X_DISPLAY (f
), (Atom
) value
);
9847 /* Count the number of dashes in the "full name".
9848 If it is too few, this isn't really the font's full name,
9850 In X11R4, the fonts did not come with their canonical names
9861 full_name
= (char *) xmalloc (p
- name
+ 1);
9862 bcopy (name
, full_name
, p
- name
+ 1);
9869 fontp
->full_name
= full_name
;
9871 fontp
->full_name
= fontp
->name
;
9873 fontp
->size
= font
->max_bounds
.width
;
9874 fontp
->height
= FONT_HEIGHT (font
);
9876 if (NILP (font_names
))
9878 /* We come here because of a bug of XListFonts mentioned at
9879 the head of this block. Let's store this information in
9880 the cache for x_list_fonts. */
9881 Lisp_Object lispy_name
= build_string (fontname
);
9882 Lisp_Object lispy_full_name
= build_string (fontp
->full_name
);
9883 Lisp_Object key
= Fcons (Fcons (lispy_name
, make_number (256)),
9886 XSETCDR (dpyinfo
->name_list_element
,
9888 Fcons (Fcons (lispy_full_name
,
9889 make_number (fontp
->size
)),
9891 XCDR (dpyinfo
->name_list_element
)));
9894 key
= Fcons (Fcons (lispy_full_name
, make_number (256)),
9896 XSETCDR (dpyinfo
->name_list_element
,
9898 Fcons (Fcons (lispy_full_name
,
9899 make_number (fontp
->size
)),
9901 XCDR (dpyinfo
->name_list_element
)));
9905 /* The slot `encoding' specifies how to map a character
9906 code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
9907 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
9908 (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
9909 2:0xA020..0xFF7F). For the moment, we don't know which charset
9910 uses this font. So, we set information in fontp->encoding[1]
9911 which is never used by any charset. If mapping can't be
9912 decided, set FONT_ENCODING_NOT_DECIDED. */
9914 = (font
->max_byte1
== 0
9916 ? (font
->min_char_or_byte2
< 0x80
9917 ? (font
->max_char_or_byte2
< 0x80
9918 ? 0 /* 0x20..0x7F */
9919 : FONT_ENCODING_NOT_DECIDED
) /* 0x20..0xFF */
9920 : 1) /* 0xA0..0xFF */
9922 : (font
->min_byte1
< 0x80
9923 ? (font
->max_byte1
< 0x80
9924 ? (font
->min_char_or_byte2
< 0x80
9925 ? (font
->max_char_or_byte2
< 0x80
9926 ? 0 /* 0x2020..0x7F7F */
9927 : FONT_ENCODING_NOT_DECIDED
) /* 0x2020..0x7FFF */
9928 : 3) /* 0x20A0..0x7FFF */
9929 : FONT_ENCODING_NOT_DECIDED
) /* 0x20??..0xA0?? */
9930 : (font
->min_char_or_byte2
< 0x80
9931 ? (font
->max_char_or_byte2
< 0x80
9932 ? 2 /* 0xA020..0xFF7F */
9933 : FONT_ENCODING_NOT_DECIDED
) /* 0xA020..0xFFFF */
9934 : 1))); /* 0xA0A0..0xFFFF */
9936 fontp
->baseline_offset
9937 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_BASELINE_OFFSET
, &value
)
9938 ? (long) value
: 0);
9939 fontp
->relative_compose
9940 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
, &value
)
9941 ? (long) value
: 0);
9942 fontp
->default_ascent
9943 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
, &value
)
9944 ? (long) value
: 0);
9946 /* Set global flag fonts_changed_p to non-zero if the font loaded
9947 has a character with a smaller width than any other character
9948 before, or if the font loaded has a smaller height than any
9949 other font loaded before. If this happens, it will make a
9950 glyph matrix reallocation necessary. */
9951 fonts_changed_p
|= x_compute_min_glyph_bounds (f
);
9958 /* Return a pointer to struct font_info of a font named FONTNAME for
9959 frame F. If no such font is loaded, return NULL. */
9962 x_query_font (f
, fontname
)
9964 register char *fontname
;
9966 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9969 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
9970 if (dpyinfo
->font_table
[i
].name
9971 && (!strcmp (dpyinfo
->font_table
[i
].name
, fontname
)
9972 || !strcmp (dpyinfo
->font_table
[i
].full_name
, fontname
)))
9973 return (dpyinfo
->font_table
+ i
);
9978 /* Find a CCL program for a font specified by FONTP, and set the member
9979 `encoder' of the structure. */
9982 x_find_ccl_program (fontp
)
9983 struct font_info
*fontp
;
9985 Lisp_Object list
, elt
;
9988 for (list
= Vfont_ccl_encoder_alist
; CONSP (list
); list
= XCDR (list
))
9992 && STRINGP (XCAR (elt
))
9993 && ((fast_c_string_match_ignore_case (XCAR (elt
), fontp
->name
)
9995 || (fast_c_string_match_ignore_case (XCAR (elt
), fontp
->full_name
)
10002 struct ccl_program
*ccl
10003 = (struct ccl_program
*) xmalloc (sizeof (struct ccl_program
));
10005 if (setup_ccl_program (ccl
, XCDR (elt
)) < 0)
10008 fontp
->font_encoder
= ccl
;
10014 /***********************************************************************
10016 ***********************************************************************/
10018 #ifdef USE_X_TOOLKIT
10019 static XrmOptionDescRec emacs_options
[] = {
10020 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
10021 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
10023 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
10024 XrmoptionSepArg
, NULL
},
10025 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
10027 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10028 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10029 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10030 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
10031 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
10032 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
10033 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
10035 #endif /* USE_X_TOOLKIT */
10037 static int x_initialized
;
10039 #ifdef MULTI_KBOARD
10040 /* Test whether two display-name strings agree up to the dot that separates
10041 the screen number from the server number. */
10043 same_x_server (name1
, name2
)
10044 const char *name1
, *name2
;
10046 int seen_colon
= 0;
10047 const unsigned char *system_name
= SDATA (Vsystem_name
);
10048 int system_name_length
= strlen (system_name
);
10049 int length_until_period
= 0;
10051 while (system_name
[length_until_period
] != 0
10052 && system_name
[length_until_period
] != '.')
10053 length_until_period
++;
10055 /* Treat `unix' like an empty host name. */
10056 if (! strncmp (name1
, "unix:", 5))
10058 if (! strncmp (name2
, "unix:", 5))
10060 /* Treat this host's name like an empty host name. */
10061 if (! strncmp (name1
, system_name
, system_name_length
)
10062 && name1
[system_name_length
] == ':')
10063 name1
+= system_name_length
;
10064 if (! strncmp (name2
, system_name
, system_name_length
)
10065 && name2
[system_name_length
] == ':')
10066 name2
+= system_name_length
;
10067 /* Treat this host's domainless name like an empty host name. */
10068 if (! strncmp (name1
, system_name
, length_until_period
)
10069 && name1
[length_until_period
] == ':')
10070 name1
+= length_until_period
;
10071 if (! strncmp (name2
, system_name
, length_until_period
)
10072 && name2
[length_until_period
] == ':')
10073 name2
+= length_until_period
;
10075 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
10079 if (seen_colon
&& *name1
== '.')
10083 && (*name1
== '.' || *name1
== '\0')
10084 && (*name2
== '.' || *name2
== '\0'));
10088 /* Count number of set bits in mask and number of bits to shift to
10089 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
10092 get_bits_and_offset (mask
, bits
, offset
)
10093 unsigned long mask
;
10100 while (!(mask
& 1))
10116 struct x_display_info
*
10117 x_term_init (display_name
, xrm_option
, resource_name
)
10118 Lisp_Object display_name
;
10120 char *resource_name
;
10124 struct terminal
*terminal
;
10125 struct x_display_info
*dpyinfo
;
10130 if (!x_initialized
)
10138 #define NUM_ARGV 10
10140 char *argv
[NUM_ARGV
];
10141 char **argv2
= argv
;
10144 #ifndef HAVE_GTK_MULTIDISPLAY
10145 if (!EQ (Vinitial_window_system
, intern ("x")))
10146 error ("Sorry, you cannot connect to X servers with the GTK toolkit");
10149 if (x_initialized
++ > 1)
10151 #ifdef HAVE_GTK_MULTIDISPLAY
10152 /* Opening another display. If xg_display_open returns less
10153 than zero, we are probably on GTK 2.0, which can only handle
10154 one display. GTK 2.2 or later can handle more than one. */
10155 if (xg_display_open (SDATA (display_name
), &dpy
) < 0)
10156 error ("Sorry, this version of GTK can only handle one display");
10158 /* XXX Unfortunately, multiple display support is severely broken
10159 in recent GTK versions, so HAVE_GTK_MULTIDISPLAY is
10160 unconditionally disabled in configure.in. */
10161 error ("Sorry, multiple display support is broken in current GTK versions");
10166 for (argc
= 0; argc
< NUM_ARGV
; ++argc
)
10170 argv
[argc
++] = initial_argv
[0];
10172 if (! NILP (display_name
))
10174 argv
[argc
++] = "--display";
10175 argv
[argc
++] = SDATA (display_name
);
10178 argv
[argc
++] = "--name";
10179 argv
[argc
++] = resource_name
;
10182 XSetLocaleModifiers ("");
10185 gtk_init (&argc
, &argv2
);
10187 /* gtk_init does set_locale. We must fix locale after calling it. */
10191 dpy
= GDK_DISPLAY ();
10193 /* NULL window -> events for all windows go to our function */
10194 gdk_window_add_filter (NULL
, event_handler_gdk
, NULL
);
10196 /* Load our own gtkrc if it exists. */
10198 struct gcpro gcpro1
, gcpro2
;
10199 char *file
= "~/.emacs.d/gtkrc";
10200 Lisp_Object s
, abs_file
;
10202 GCPRO2 (s
, abs_file
);
10203 s
= make_string (file
, strlen (file
));
10204 abs_file
= Fexpand_file_name (s
, Qnil
);
10206 if (! NILP (abs_file
) && !NILP (Ffile_readable_p (abs_file
)))
10207 gtk_rc_parse (SDATA (abs_file
));
10212 XSetErrorHandler (x_error_handler
);
10213 XSetIOErrorHandler (x_io_error_quitter
);
10216 #else /* not USE_GTK */
10217 #ifdef USE_X_TOOLKIT
10218 /* weiner@footloose.sps.mot.com reports that this causes
10220 X protocol error: BadAtom (invalid Atom parameter)
10221 on protocol request 18skiloaf.
10222 So let's not use it until R6. */
10223 #ifdef HAVE_X11XTR6
10224 XtSetLanguageProc (NULL
, NULL
, NULL
);
10235 argv
[argc
++] = "-xrm";
10236 argv
[argc
++] = xrm_option
;
10238 turn_on_atimers (0);
10239 dpy
= XtOpenDisplay (Xt_app_con
, SDATA (display_name
),
10240 resource_name
, EMACS_CLASS
,
10241 emacs_options
, XtNumber (emacs_options
),
10243 turn_on_atimers (1);
10245 #ifdef HAVE_X11XTR6
10246 /* I think this is to compensate for XtSetLanguageProc. */
10251 #else /* not USE_X_TOOLKIT */
10253 XSetLocaleModifiers ("");
10255 dpy
= XOpenDisplay (SDATA (display_name
));
10256 #endif /* not USE_X_TOOLKIT */
10257 #endif /* not USE_GTK*/
10259 /* Detect failure. */
10266 /* We have definitely succeeded. Record the new connection. */
10268 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
10269 bzero (dpyinfo
, sizeof *dpyinfo
);
10271 terminal
= x_create_terminal (dpyinfo
);
10273 #ifdef MULTI_KBOARD
10275 struct x_display_info
*share
;
10278 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
10279 share
= share
->next
, tail
= XCDR (tail
))
10280 if (same_x_server (SDATA (XCAR (XCAR (tail
))),
10281 SDATA (display_name
)))
10284 terminal
->kboard
= share
->terminal
->kboard
;
10287 terminal
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
10288 init_kboard (terminal
->kboard
);
10289 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
10291 char *vendor
= ServerVendor (dpy
);
10293 terminal
->kboard
->Vsystem_key_alist
10294 = call1 (Qvendor_specific_keysyms
,
10295 build_string (vendor
? vendor
: ""));
10299 terminal
->kboard
->next_kboard
= all_kboards
;
10300 all_kboards
= terminal
->kboard
;
10301 /* Don't let the initial kboard remain current longer than necessary.
10302 That would cause problems if a file loaded on startup tries to
10303 prompt in the mini-buffer. */
10304 if (current_kboard
== initial_kboard
)
10305 current_kboard
= terminal
->kboard
;
10307 terminal
->kboard
->reference_count
++;
10311 /* Put this display on the chain. */
10312 dpyinfo
->next
= x_display_list
;
10313 x_display_list
= dpyinfo
;
10315 /* Put it on x_display_name_list as well, to keep them parallel. */
10316 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
10317 x_display_name_list
);
10318 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
10320 dpyinfo
->display
= dpy
;
10322 /* Set the name of the terminal. */
10323 terminal
->name
= (char *) xmalloc (SBYTES (display_name
) + 1);
10324 strncpy (terminal
->name
, SDATA (display_name
), SBYTES (display_name
));
10325 terminal
->name
[SBYTES (display_name
)] = 0;
10328 XSetAfterFunction (x_current_display
, x_trace_wire
);
10332 = (char *) xmalloc (SBYTES (Vinvocation_name
)
10333 + SBYTES (Vsystem_name
)
10335 sprintf (dpyinfo
->x_id_name
, "%s@%s",
10336 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
10338 /* Figure out which modifier bits mean what. */
10339 x_find_modifier_meanings (dpyinfo
);
10341 /* Get the scroll bar cursor. */
10343 /* We must create a GTK cursor, it is required for GTK widgets. */
10344 dpyinfo
->xg_cursor
= xg_create_default_cursor (dpyinfo
->display
);
10345 #endif /* USE_GTK */
10347 dpyinfo
->vertical_scroll_bar_cursor
10348 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
10350 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
10351 resource_name
, EMACS_CLASS
);
10352 #ifdef HAVE_XRMSETDATABASE
10353 XrmSetDatabase (dpyinfo
->display
, xrdb
);
10355 dpyinfo
->display
->db
= xrdb
;
10357 /* Put the rdb where we can find it in a way that works on
10359 dpyinfo
->xrdb
= xrdb
;
10361 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
10362 DefaultScreen (dpyinfo
->display
));
10363 select_visual (dpyinfo
);
10364 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
10365 dpyinfo
->height
= HeightOfScreen (dpyinfo
->screen
);
10366 dpyinfo
->width
= WidthOfScreen (dpyinfo
->screen
);
10367 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
10368 dpyinfo
->client_leader_window
= 0;
10369 dpyinfo
->grabbed
= 0;
10370 dpyinfo
->reference_count
= 0;
10371 dpyinfo
->icon_bitmap_id
= -1;
10372 dpyinfo
->font_table
= NULL
;
10373 dpyinfo
->n_fonts
= 0;
10374 dpyinfo
->font_table_size
= 0;
10375 dpyinfo
->bitmaps
= 0;
10376 dpyinfo
->bitmaps_size
= 0;
10377 dpyinfo
->bitmaps_last
= 0;
10378 dpyinfo
->scratch_cursor_gc
= 0;
10379 dpyinfo
->mouse_face_mouse_frame
= 0;
10380 dpyinfo
->mouse_face_deferred_gc
= 0;
10381 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
10382 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
10383 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
10384 dpyinfo
->mouse_face_window
= Qnil
;
10385 dpyinfo
->mouse_face_overlay
= Qnil
;
10386 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
10387 dpyinfo
->mouse_face_defer
= 0;
10388 dpyinfo
->mouse_face_hidden
= 0;
10389 dpyinfo
->x_focus_frame
= 0;
10390 dpyinfo
->x_focus_event_frame
= 0;
10391 dpyinfo
->x_highlight_frame
= 0;
10392 dpyinfo
->image_cache
= make_image_cache ();
10393 dpyinfo
->wm_type
= X_WMTYPE_UNKNOWN
;
10395 /* See if we can construct pixel values from RGB values. */
10396 dpyinfo
->red_bits
= dpyinfo
->blue_bits
= dpyinfo
->green_bits
= 0;
10397 dpyinfo
->red_offset
= dpyinfo
->blue_offset
= dpyinfo
->green_offset
= 0;
10399 if (dpyinfo
->visual
->class == TrueColor
)
10401 get_bits_and_offset (dpyinfo
->visual
->red_mask
,
10402 &dpyinfo
->red_bits
, &dpyinfo
->red_offset
);
10403 get_bits_and_offset (dpyinfo
->visual
->blue_mask
,
10404 &dpyinfo
->blue_bits
, &dpyinfo
->blue_offset
);
10405 get_bits_and_offset (dpyinfo
->visual
->green_mask
,
10406 &dpyinfo
->green_bits
, &dpyinfo
->green_offset
);
10409 /* See if a private colormap is requested. */
10410 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
10412 if (dpyinfo
->visual
->class == PseudoColor
)
10415 value
= display_x_get_resource (dpyinfo
,
10416 build_string ("privateColormap"),
10417 build_string ("PrivateColormap"),
10419 if (STRINGP (value
)
10420 && (!strcmp (SDATA (value
), "true")
10421 || !strcmp (SDATA (value
), "on")))
10422 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
10426 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
10427 dpyinfo
->visual
, AllocNone
);
10430 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
10431 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
10432 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
10433 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10434 dpyinfo
->resy
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10435 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
10436 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10437 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
10438 dpyinfo
->resx
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10441 dpyinfo
->Xatom_wm_protocols
10442 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
10443 dpyinfo
->Xatom_wm_take_focus
10444 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
10445 dpyinfo
->Xatom_wm_save_yourself
10446 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
10447 dpyinfo
->Xatom_wm_delete_window
10448 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
10449 dpyinfo
->Xatom_wm_change_state
10450 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
10451 dpyinfo
->Xatom_wm_configure_denied
10452 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
10453 dpyinfo
->Xatom_wm_window_moved
10454 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
10455 dpyinfo
->Xatom_wm_client_leader
10456 = XInternAtom (dpyinfo
->display
, "WM_CLIENT_LEADER", False
);
10457 dpyinfo
->Xatom_editres
10458 = XInternAtom (dpyinfo
->display
, "Editres", False
);
10459 dpyinfo
->Xatom_CLIPBOARD
10460 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
10461 dpyinfo
->Xatom_TIMESTAMP
10462 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
10463 dpyinfo
->Xatom_TEXT
10464 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
10465 dpyinfo
->Xatom_COMPOUND_TEXT
10466 = XInternAtom (dpyinfo
->display
, "COMPOUND_TEXT", False
);
10467 dpyinfo
->Xatom_UTF8_STRING
10468 = XInternAtom (dpyinfo
->display
, "UTF8_STRING", False
);
10469 dpyinfo
->Xatom_DELETE
10470 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
10471 dpyinfo
->Xatom_MULTIPLE
10472 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
10473 dpyinfo
->Xatom_INCR
10474 = XInternAtom (dpyinfo
->display
, "INCR", False
);
10475 dpyinfo
->Xatom_EMACS_TMP
10476 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
10477 dpyinfo
->Xatom_TARGETS
10478 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
10479 dpyinfo
->Xatom_NULL
10480 = XInternAtom (dpyinfo
->display
, "NULL", False
);
10481 dpyinfo
->Xatom_ATOM_PAIR
10482 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
10483 /* For properties of font. */
10484 dpyinfo
->Xatom_PIXEL_SIZE
10485 = XInternAtom (dpyinfo
->display
, "PIXEL_SIZE", False
);
10486 dpyinfo
->Xatom_AVERAGE_WIDTH
10487 = XInternAtom (dpyinfo
->display
, "AVERAGE_WIDTH", False
);
10488 dpyinfo
->Xatom_MULE_BASELINE_OFFSET
10489 = XInternAtom (dpyinfo
->display
, "_MULE_BASELINE_OFFSET", False
);
10490 dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
10491 = XInternAtom (dpyinfo
->display
, "_MULE_RELATIVE_COMPOSE", False
);
10492 dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
10493 = XInternAtom (dpyinfo
->display
, "_MULE_DEFAULT_ASCENT", False
);
10495 /* Ghostscript support. */
10496 dpyinfo
->Xatom_PAGE
= XInternAtom (dpyinfo
->display
, "PAGE", False
);
10497 dpyinfo
->Xatom_DONE
= XInternAtom (dpyinfo
->display
, "DONE", False
);
10499 dpyinfo
->Xatom_Scrollbar
= XInternAtom (dpyinfo
->display
, "SCROLLBAR",
10502 dpyinfo
->cut_buffers_initialized
= 0;
10504 connection
= ConnectionNumber (dpyinfo
->display
);
10505 dpyinfo
->connection
= connection
;
10510 null_bits
[0] = 0x00;
10512 dpyinfo
->null_pixel
10513 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
10514 null_bits
, 1, 1, (long) 0, (long) 0,
10519 extern int gray_bitmap_width
, gray_bitmap_height
;
10520 extern char *gray_bitmap_bits
;
10522 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
10524 gray_bitmap_width
, gray_bitmap_height
,
10525 (unsigned long) 1, (unsigned long) 0, 1);
10529 xim_initialize (dpyinfo
, resource_name
);
10532 #ifdef subprocesses
10533 /* This is only needed for distinguishing keyboard and process input. */
10534 if (connection
!= 0)
10535 add_keyboard_wait_descriptor (connection
);
10538 #ifndef F_SETOWN_BUG
10540 #ifdef F_SETOWN_SOCK_NEG
10541 /* stdin is a socket here */
10542 fcntl (connection
, F_SETOWN
, -getpid ());
10543 #else /* ! defined (F_SETOWN_SOCK_NEG) */
10544 fcntl (connection
, F_SETOWN
, getpid ());
10545 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
10546 #endif /* ! defined (F_SETOWN) */
10547 #endif /* F_SETOWN_BUG */
10550 if (interrupt_input
)
10551 init_sigio (connection
);
10552 #endif /* ! defined (SIGIO) */
10555 #ifdef HAVE_X11R5 /* It seems X11R4 lacks XtCvtStringToFont, and XPointer. */
10556 /* Make sure that we have a valid font for dialog boxes
10557 so that Xt does not crash. */
10559 Display
*dpy
= dpyinfo
->display
;
10560 XrmValue d
, fr
, to
;
10564 d
.addr
= (XPointer
)&dpy
;
10565 d
.size
= sizeof (Display
*);
10566 fr
.addr
= XtDefaultFont
;
10567 fr
.size
= sizeof (XtDefaultFont
);
10568 to
.size
= sizeof (Font
*);
10569 to
.addr
= (XPointer
)&font
;
10570 count
= x_catch_errors (dpy
);
10571 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
10573 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
10574 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
10575 x_uncatch_errors (dpy
, count
);
10580 /* See if we should run in synchronous mode. This is useful
10581 for debugging X code. */
10584 value
= display_x_get_resource (dpyinfo
,
10585 build_string ("synchronous"),
10586 build_string ("Synchronous"),
10588 if (STRINGP (value
)
10589 && (!strcmp (SDATA (value
), "true")
10590 || !strcmp (SDATA (value
), "on")))
10591 XSynchronize (dpyinfo
->display
, True
);
10596 value
= display_x_get_resource (dpyinfo
,
10597 build_string ("useXIM"),
10598 build_string ("UseXIM"),
10601 if (STRINGP (value
)
10602 && (!strcmp (XSTRING (value
)->data
, "false")
10603 || !strcmp (XSTRING (value
)->data
, "off")))
10606 if (STRINGP (value
)
10607 && (!strcmp (XSTRING (value
)->data
, "true")
10608 || !strcmp (XSTRING (value
)->data
, "on")))
10614 /* Only do this for the very first display in the Emacs session.
10615 Ignore X session management when Emacs was first started on a
10617 if (terminal
->id
== 1)
10618 x_session_initialize (dpyinfo
);
10626 /* Get rid of display DPYINFO, assuming all frames are already gone,
10627 and without sending any more commands to the X server. */
10630 x_delete_display (dpyinfo
)
10631 struct x_display_info
*dpyinfo
;
10634 struct terminal
*t
;
10636 /* Delete the generic struct terminal for this X display. */
10637 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
10638 if (t
->type
== output_x_window
&& t
->display_info
.x
== dpyinfo
)
10640 /* Close X session management when we close its display. */
10641 if (t
->id
== 1 && x_session_have_connection ())
10644 delete_terminal (t
);
10648 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
10650 /* Discard this display from x_display_name_list and x_display_list.
10651 We can't use Fdelq because that can quit. */
10652 if (! NILP (x_display_name_list
)
10653 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
10654 x_display_name_list
= XCDR (x_display_name_list
);
10659 tail
= x_display_name_list
;
10660 while (CONSP (tail
) && CONSP (XCDR (tail
)))
10662 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
10664 XSETCDR (tail
, XCDR (XCDR (tail
)));
10667 tail
= XCDR (tail
);
10671 if (next_noop_dpyinfo
== dpyinfo
)
10672 next_noop_dpyinfo
= dpyinfo
->next
;
10674 if (x_display_list
== dpyinfo
)
10675 x_display_list
= dpyinfo
->next
;
10678 struct x_display_info
*tail
;
10680 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
10681 if (tail
->next
== dpyinfo
)
10682 tail
->next
= tail
->next
->next
;
10685 #ifndef USE_X_TOOLKIT /* I'm told Xt does this itself. */
10686 #ifndef AIX /* On AIX, XCloseDisplay calls this. */
10687 XrmDestroyDatabase (dpyinfo
->xrdb
);
10692 xim_close_dpy (dpyinfo
);
10695 /* Free the font names in the font table. */
10696 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
10697 if (dpyinfo
->font_table
[i
].name
)
10699 if (dpyinfo
->font_table
[i
].name
!= dpyinfo
->font_table
[i
].full_name
)
10700 xfree (dpyinfo
->font_table
[i
].full_name
);
10701 xfree (dpyinfo
->font_table
[i
].name
);
10704 if (dpyinfo
->font_table
&& dpyinfo
->font_table
->font_encoder
)
10705 xfree (dpyinfo
->font_table
->font_encoder
);
10707 if (dpyinfo
->font_table
)
10708 xfree (dpyinfo
->font_table
);
10709 xfree (dpyinfo
->x_id_name
);
10710 xfree (dpyinfo
->color_cells
);
10714 #ifdef USE_X_TOOLKIT
10716 /* Atimer callback function for TIMER. Called every 0.1s to process
10717 Xt timeouts, if needed. We must avoid calling XtAppPending as
10718 much as possible because that function does an implicit XFlush
10719 that slows us down. */
10722 x_process_timeouts (timer
)
10723 struct atimer
*timer
;
10725 if (toolkit_scroll_bar_interaction
|| popup_activated ())
10728 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
10729 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
10734 #endif /* USE_X_TOOLKIT */
10737 /* Set up use of X before we make the first connection. */
10739 extern frame_parm_handler x_frame_parm_handlers
[];
10741 static struct redisplay_interface x_redisplay_interface
=
10743 x_frame_parm_handlers
,
10747 x_clear_end_of_line
,
10749 x_after_update_window_line
,
10750 x_update_window_begin
,
10751 x_update_window_end
,
10757 0, /* flush_display_optional */
10759 x_clear_window_mouse_face
,
10760 x_get_glyph_overhangs
,
10761 x_fix_overlapping_area
,
10762 x_draw_fringe_bitmap
,
10763 0, /* define_fringe_bitmap */
10764 0, /* destroy_fringe_bitmap */
10767 x_compute_glyph_string_overhangs
,
10768 x_draw_glyph_string
,
10769 x_define_frame_cursor
,
10770 x_clear_frame_area
,
10771 x_draw_window_cursor
,
10772 x_draw_vertical_window_border
,
10773 x_shift_glyphs_for_insert
10777 /* This function is called when the last frame on a display is deleted. */
10779 x_delete_terminal (struct terminal
*terminal
)
10781 struct x_display_info
*dpyinfo
= terminal
->display_info
.x
;
10785 /* Free the fonts in the font table. */
10786 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
10787 if (dpyinfo
->font_table
[i
].name
)
10789 XFreeFont (dpyinfo
->display
, dpyinfo
->font_table
[i
].font
);
10792 x_destroy_all_bitmaps (dpyinfo
);
10793 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
10795 #ifdef USE_X_TOOLKIT
10796 XtCloseDisplay (dpyinfo
->display
);
10799 xg_display_close (dpyinfo
->display
);
10801 XCloseDisplay (dpyinfo
->display
);
10805 x_delete_display (dpyinfo
);
10810 static struct terminal
*
10811 x_create_terminal (struct x_display_info
*dpyinfo
)
10813 struct terminal
*terminal
;
10815 terminal
= create_terminal ();
10817 terminal
->type
= output_x_window
;
10818 terminal
->display_info
.x
= dpyinfo
;
10819 dpyinfo
->terminal
= terminal
;
10821 /* kboard is initialized in x_term_init. */
10823 terminal
->clear_frame_hook
= x_clear_frame
;
10824 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
10825 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
10826 terminal
->ring_bell_hook
= XTring_bell
;
10827 terminal
->reset_terminal_modes_hook
= XTreset_terminal_modes
;
10828 terminal
->set_terminal_modes_hook
= XTset_terminal_modes
;
10829 terminal
->update_begin_hook
= x_update_begin
;
10830 terminal
->update_end_hook
= x_update_end
;
10831 terminal
->set_terminal_window_hook
= XTset_terminal_window
;
10832 terminal
->read_socket_hook
= XTread_socket
;
10833 terminal
->frame_up_to_date_hook
= XTframe_up_to_date
;
10834 terminal
->mouse_position_hook
= XTmouse_position
;
10835 terminal
->frame_rehighlight_hook
= XTframe_rehighlight
;
10836 terminal
->frame_raise_lower_hook
= XTframe_raise_lower
;
10837 terminal
->set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
10838 terminal
->condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
10839 terminal
->redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
10840 terminal
->judge_scroll_bars_hook
= XTjudge_scroll_bars
;
10842 terminal
->delete_frame_hook
= x_destroy_window
;
10843 terminal
->delete_terminal_hook
= x_delete_terminal
;
10845 terminal
->rif
= &x_redisplay_interface
;
10846 terminal
->scroll_region_ok
= 1; /* We'll scroll partial frames. */
10847 terminal
->char_ins_del_ok
= 1;
10848 terminal
->line_ins_del_ok
= 1; /* We'll just blt 'em. */
10849 terminal
->fast_clear_end_of_line
= 1; /* X does this well. */
10850 terminal
->memory_below_frame
= 0; /* We don't remember what scrolls
10862 last_tool_bar_item
= -1;
10863 any_help_event_p
= 0;
10864 ignore_next_mouse_click_timeout
= 0;
10867 current_count
= -1;
10870 /* Try to use interrupt input; if we can't, then start polling. */
10871 Fset_input_interrupt_mode (Qt
);
10873 #ifdef USE_X_TOOLKIT
10874 XtToolkitInitialize ();
10876 Xt_app_con
= XtCreateApplicationContext ();
10878 /* Register a converter from strings to pixels, which uses
10879 Emacs' color allocation infrastructure. */
10880 XtAppSetTypeConverter (Xt_app_con
,
10881 XtRString
, XtRPixel
, cvt_string_to_pixel
,
10882 cvt_string_to_pixel_args
,
10883 XtNumber (cvt_string_to_pixel_args
),
10884 XtCacheByDisplay
, cvt_pixel_dtor
);
10886 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
10888 /* Install an asynchronous timer that processes Xt timeout events
10889 every 0.1s. This is necessary because some widget sets use
10890 timeouts internally, for example the LessTif menu bar, or the
10891 Xaw3d scroll bar. When Xt timouts aren't processed, these
10892 widgets don't behave normally. */
10894 EMACS_TIME interval
;
10895 EMACS_SET_SECS_USECS (interval
, 0, 100000);
10896 start_atimer (ATIMER_CONTINUOUS
, interval
, x_process_timeouts
, 0);
10900 #ifdef USE_TOOLKIT_SCROLL_BARS
10902 xaw3d_arrow_scroll
= False
;
10903 xaw3d_pick_top
= True
;
10907 /* Note that there is no real way portable across R3/R4 to get the
10908 original error handler. */
10909 XSetErrorHandler (x_error_handler
);
10910 XSetIOErrorHandler (x_io_error_quitter
);
10912 /* Disable Window Change signals; they are handled by X events. */
10913 #if 0 /* Don't. We may want to open tty frames later. */
10915 signal (SIGWINCH
, SIG_DFL
);
10916 #endif /* SIGWINCH */
10919 signal (SIGPIPE
, x_connection_signal
);
10926 staticpro (&x_error_message_string
);
10927 x_error_message_string
= Qnil
;
10929 staticpro (&x_display_name_list
);
10930 x_display_name_list
= Qnil
;
10932 staticpro (&last_mouse_scroll_bar
);
10933 last_mouse_scroll_bar
= Qnil
;
10935 staticpro (&Qvendor_specific_keysyms
);
10936 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
10938 staticpro (&Qutf_8
);
10939 Qutf_8
= intern ("utf-8");
10940 staticpro (&Qlatin_1
);
10941 Qlatin_1
= intern ("latin-1");
10943 staticpro (&last_mouse_press_frame
);
10944 last_mouse_press_frame
= Qnil
;
10946 DEFVAR_BOOL ("x-use-underline-position-properties",
10947 &x_use_underline_position_properties
,
10948 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
10949 nil means ignore them. If you encounter fonts with bogus
10950 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
10951 to 4.1, set this to nil. */);
10952 x_use_underline_position_properties
= 1;
10954 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
10955 &x_mouse_click_focus_ignore_position
,
10956 doc
: /* Non-nil means that a mouse click to focus a frame does not move point.
10957 This variable is only used when the window manager requires that you
10958 click on a frame to select it (give it focus). In that case, a value
10959 of nil, means that the selected window and cursor position changes to
10960 reflect the mouse click position, while a non-nil value means that the
10961 selected window or cursor position is preserved. */);
10962 x_mouse_click_focus_ignore_position
= 0;
10964 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
10965 doc
: /* What X toolkit scroll bars Emacs uses.
10966 A value of nil means Emacs doesn't use X toolkit scroll bars.
10967 Otherwise, value is a symbol describing the X toolkit. */);
10968 #ifdef USE_TOOLKIT_SCROLL_BARS
10970 Vx_toolkit_scroll_bars
= intern ("motif");
10971 #elif defined HAVE_XAW3D
10972 Vx_toolkit_scroll_bars
= intern ("xaw3d");
10974 Vx_toolkit_scroll_bars
= intern ("gtk");
10976 Vx_toolkit_scroll_bars
= intern ("xaw");
10979 Vx_toolkit_scroll_bars
= Qnil
;
10982 staticpro (&last_mouse_motion_frame
);
10983 last_mouse_motion_frame
= Qnil
;
10985 Qmodifier_value
= intern ("modifier-value");
10986 Qalt
= intern ("alt");
10987 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
10988 Qhyper
= intern ("hyper");
10989 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
10990 Qmeta
= intern ("meta");
10991 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
10992 Qsuper
= intern ("super");
10993 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
10995 DEFVAR_LISP ("x-alt-keysym", &Vx_alt_keysym
,
10996 doc
: /* Which keys Emacs uses for the alt modifier.
10997 This should be one of the symbols `alt', `hyper', `meta', `super'.
10998 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
10999 is nil, which is the same as `alt'. */);
11000 Vx_alt_keysym
= Qnil
;
11002 DEFVAR_LISP ("x-hyper-keysym", &Vx_hyper_keysym
,
11003 doc
: /* Which keys Emacs uses for the hyper modifier.
11004 This should be one of the symbols `alt', `hyper', `meta', `super'.
11005 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
11006 default is nil, which is the same as `hyper'. */);
11007 Vx_hyper_keysym
= Qnil
;
11009 DEFVAR_LISP ("x-meta-keysym", &Vx_meta_keysym
,
11010 doc
: /* Which keys Emacs uses for the meta modifier.
11011 This should be one of the symbols `alt', `hyper', `meta', `super'.
11012 For example, `meta' means use the Meta_L and Meta_R keysyms. The
11013 default is nil, which is the same as `meta'. */);
11014 Vx_meta_keysym
= Qnil
;
11016 DEFVAR_LISP ("x-super-keysym", &Vx_super_keysym
,
11017 doc
: /* Which keys Emacs uses for the super modifier.
11018 This should be one of the symbols `alt', `hyper', `meta', `super'.
11019 For example, `super' means use the Super_L and Super_R keysyms. The
11020 default is nil, which is the same as `super'. */);
11021 Vx_super_keysym
= Qnil
;
11023 DEFVAR_LISP ("x-keysym-table", &Vx_keysym_table
,
11024 doc
: /* Hash table of character codes indexed by X keysym codes. */);
11025 Vx_keysym_table
= make_hash_table (Qeql
, make_number (900),
11026 make_float (DEFAULT_REHASH_SIZE
),
11027 make_float (DEFAULT_REHASH_THRESHOLD
),
11031 #endif /* HAVE_X_WINDOWS */
11033 /* arch-tag: 6d4e4cb7-abc1-4302-9585-d84dcfb09d0f
11034 (do not change this comment) */