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 Lisp_Object last_mouse_press_frame
;
253 /* The scroll bar in which the last X motion event occurred.
255 If the last X motion event occurred in a scroll bar, we set this so
256 XTmouse_position can know whether to report a scroll bar motion or
259 If the last X motion event didn't occur in a scroll bar, we set
260 this to Qnil, to tell XTmouse_position to return an ordinary motion
263 static Lisp_Object last_mouse_scroll_bar
;
265 /* This is a hack. We would really prefer that XTmouse_position would
266 return the time associated with the position it returns, but there
267 doesn't seem to be any way to wrest the time-stamp from the server
268 along with the position query. So, we just keep track of the time
269 of the last movement we received, and return that in hopes that
270 it's somewhat accurate. */
272 static Time last_mouse_movement_time
;
274 /* Incremented by XTread_socket whenever it really tries to read
278 static int volatile input_signal_count
;
280 static int input_signal_count
;
283 /* Used locally within XTread_socket. */
285 static int x_noop_count
;
287 /* Initial values of argv and argc. */
289 extern char **initial_argv
;
290 extern int initial_argc
;
292 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
294 /* Tells if a window manager is present or not. */
296 extern Lisp_Object Vx_no_window_manager
;
298 extern Lisp_Object Qeql
;
302 /* A mask of extra modifier bits to put into every keyboard char. */
304 extern EMACS_INT extra_keyboard_modifiers
;
306 /* The keysyms to use for the various modifiers. */
308 Lisp_Object Vx_alt_keysym
, Vx_hyper_keysym
, Vx_meta_keysym
, Vx_super_keysym
;
309 Lisp_Object Vx_keysym_table
;
310 static Lisp_Object Qalt
, Qhyper
, Qmeta
, Qsuper
, Qmodifier_value
;
312 static Lisp_Object Qvendor_specific_keysyms
;
313 static Lisp_Object Qlatin_1
;
315 /* Used in x_flush. */
317 extern Lisp_Object Vinhibit_redisplay
;
319 extern XrmDatabase x_load_resources
P_ ((Display
*, char *, char *, char *));
320 extern int x_bitmap_mask
P_ ((FRAME_PTR
, int));
322 static int x_alloc_nearest_color_1
P_ ((Display
*, Colormap
, XColor
*));
323 static void x_set_window_size_1
P_ ((struct frame
*, int, int, int));
324 static const XColor
*x_color_cells
P_ ((Display
*, int *));
325 static void x_update_window_end
P_ ((struct window
*, int, int));
326 void x_delete_display
P_ ((struct x_display_info
*));
327 static unsigned int x_x_to_emacs_modifiers
P_ ((struct x_display_info
*,
329 static int x_io_error_quitter
P_ ((Display
*));
330 int x_catch_errors
P_ ((Display
*));
331 void x_uncatch_errors
P_ ((Display
*, int));
332 void x_lower_frame
P_ ((struct frame
*));
333 void x_scroll_bar_clear
P_ ((struct frame
*));
334 int x_had_errors_p
P_ ((Display
*));
335 void x_wm_set_size_hint
P_ ((struct frame
*, long, int));
336 void x_raise_frame
P_ ((struct frame
*));
337 void x_set_window_size
P_ ((struct frame
*, int, int, int));
338 void x_wm_set_window_state
P_ ((struct frame
*, int));
339 void x_wm_set_icon_pixmap
P_ ((struct frame
*, int));
340 struct device
*x_create_device
P_ ((struct x_display_info
*));
341 void x_delete_device
P_ ((struct device
*));
342 void x_initialize
P_ ((void));
343 static void x_font_min_bounds
P_ ((XFontStruct
*, int *, int *));
344 static int x_compute_min_glyph_bounds
P_ ((struct frame
*));
345 static void x_update_end
P_ ((struct frame
*));
346 static void XTframe_up_to_date
P_ ((struct frame
*));
347 static void XTset_terminal_modes
P_ ((struct device
*));
348 static void XTreset_terminal_modes
P_ ((struct device
*));
349 static void x_clear_frame
P_ ((struct frame
*));
350 static void frame_highlight
P_ ((struct frame
*));
351 static void frame_unhighlight
P_ ((struct frame
*));
352 static void x_new_focus_frame
P_ ((struct x_display_info
*, struct frame
*));
353 static void x_focus_changed
P_ ((int, int, struct x_display_info
*,
354 struct frame
*, struct input_event
*));
355 static void x_detect_focus_change
P_ ((struct x_display_info
*,
356 XEvent
*, struct input_event
*));
357 static void XTframe_rehighlight
P_ ((struct frame
*));
358 static void x_frame_rehighlight
P_ ((struct x_display_info
*));
359 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
360 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int,
361 enum text_cursor_kinds
));
363 static void x_clip_to_row
P_ ((struct window
*, struct glyph_row
*, int, GC
));
364 static void x_flush
P_ ((struct frame
*f
));
365 static void x_update_begin
P_ ((struct frame
*));
366 static void x_update_window_begin
P_ ((struct window
*));
367 static void x_after_update_window_line
P_ ((struct glyph_row
*));
368 static struct scroll_bar
*x_window_to_scroll_bar
P_ ((Display
*, Window
));
369 static void x_scroll_bar_report_motion
P_ ((struct frame
**, Lisp_Object
*,
370 enum scroll_bar_part
*,
371 Lisp_Object
*, Lisp_Object
*,
373 static void x_check_fullscreen
P_ ((struct frame
*));
374 static void x_check_expected_move
P_ ((struct frame
*));
375 static int handle_one_xevent
P_ ((struct x_display_info
*, XEvent
*,
376 int *, struct input_event
*));
379 /* Flush display of frame F, or of all frames if F is null. */
385 /* Don't call XFlush when it is not safe to redisplay; the X
386 connection may be broken. */
387 if (!NILP (Vinhibit_redisplay
))
393 Lisp_Object rest
, frame
;
394 FOR_EACH_FRAME (rest
, frame
)
395 if (FRAME_X_P (XFRAME (frame
)))
396 x_flush (XFRAME (frame
));
398 else if (FRAME_X_P (f
))
399 XFlush (FRAME_X_DISPLAY (f
));
404 /* Remove calls to XFlush by defining XFlush to an empty replacement.
405 Calls to XFlush should be unnecessary because the X output buffer
406 is flushed automatically as needed by calls to XPending,
407 XNextEvent, or XWindowEvent according to the XFlush man page.
408 XTread_socket calls XPending. Removing XFlush improves
411 #define XFlush(DISPLAY) (void) 0
414 /***********************************************************************
416 ***********************************************************************/
420 /* This is a function useful for recording debugging information about
421 the sequence of occurrences in this file. */
429 struct record event_record
[100];
431 int event_record_index
;
433 record_event (locus
, type
)
437 if (event_record_index
== sizeof (event_record
) / sizeof (struct record
))
438 event_record_index
= 0;
440 event_record
[event_record_index
].locus
= locus
;
441 event_record
[event_record_index
].type
= type
;
442 event_record_index
++;
449 /* Return the struct x_display_info corresponding to DPY. */
451 struct x_display_info
*
452 x_display_info_for_display (dpy
)
455 struct x_display_info
*dpyinfo
;
457 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
458 if (dpyinfo
->display
== dpy
)
466 /***********************************************************************
467 Starting and ending an update
468 ***********************************************************************/
470 /* Start an update of frame F. This function is installed as a hook
471 for update_begin, i.e. it is called when update_begin is called.
472 This function is called prior to calls to x_update_window_begin for
473 each window being updated. Currently, there is nothing to do here
474 because all interesting stuff is done on a window basis. */
484 /* Start update of window W. Set the global variable updated_window
485 to the window being updated and set output_cursor to the cursor
489 x_update_window_begin (w
)
492 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
493 struct x_display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
496 set_output_cursor (&w
->cursor
);
500 if (f
== display_info
->mouse_face_mouse_frame
)
502 /* Don't do highlighting for mouse motion during the update. */
503 display_info
->mouse_face_defer
= 1;
505 /* If F needs to be redrawn, simply forget about any prior mouse
507 if (FRAME_GARBAGED_P (f
))
508 display_info
->mouse_face_window
= Qnil
;
510 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
511 their mouse_face_p flag set, which means that they are always
512 unequal to rows in a desired matrix which never have that
513 flag set. So, rows containing mouse-face glyphs are never
514 scrolled, and we don't have to switch the mouse highlight off
515 here to prevent it from being scrolled. */
517 /* Can we tell that this update does not affect the window
518 where the mouse highlight is? If so, no need to turn off.
519 Likewise, don't do anything if the frame is garbaged;
520 in that case, the frame's current matrix that we would use
521 is all wrong, and we will redisplay that line anyway. */
522 if (!NILP (display_info
->mouse_face_window
)
523 && w
== XWINDOW (display_info
->mouse_face_window
))
527 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
528 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
531 if (i
< w
->desired_matrix
->nrows
)
532 clear_mouse_face (display_info
);
541 /* Draw a vertical window border from (x,y0) to (x,y1) */
544 x_draw_vertical_window_border (w
, x
, y0
, y1
)
548 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
551 face
= FACE_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
553 XSetForeground (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
556 XDrawLine (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
557 f
->output_data
.x
->normal_gc
, x
, y0
, x
, y1
);
560 /* End update of window W (which is equal to updated_window).
562 Draw vertical borders between horizontally adjacent windows, and
563 display W's cursor if CURSOR_ON_P is non-zero.
565 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
566 glyphs in mouse-face were overwritten. In that case we have to
567 make sure that the mouse-highlight is properly redrawn.
569 W may be a menu bar pseudo-window in case we don't have X toolkit
570 support. Such windows don't have a cursor, so don't display it
574 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
576 int cursor_on_p
, mouse_face_overwritten_p
;
578 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (XFRAME (w
->frame
));
580 if (!w
->pseudo_window_p
)
585 display_and_set_cursor (w
, 1, output_cursor
.hpos
,
587 output_cursor
.x
, output_cursor
.y
);
589 if (draw_window_fringes (w
, 1))
590 x_draw_vertical_border (w
);
595 /* If a row with mouse-face was overwritten, arrange for
596 XTframe_up_to_date to redisplay the mouse highlight. */
597 if (mouse_face_overwritten_p
)
599 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
600 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
601 dpyinfo
->mouse_face_window
= Qnil
;
604 updated_window
= NULL
;
608 /* End update of frame F. This function is installed as a hook in
615 /* Mouse highlight may be displayed again. */
616 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
620 XFlush (FRAME_X_DISPLAY (f
));
626 /* This function is called from various places in xdisp.c whenever a
627 complete update has been performed. The global variable
628 updated_window is not available here. */
631 XTframe_up_to_date (f
)
636 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
638 if (dpyinfo
->mouse_face_deferred_gc
639 || f
== dpyinfo
->mouse_face_mouse_frame
)
642 if (dpyinfo
->mouse_face_mouse_frame
)
643 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
644 dpyinfo
->mouse_face_mouse_x
,
645 dpyinfo
->mouse_face_mouse_y
);
646 dpyinfo
->mouse_face_deferred_gc
= 0;
653 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
654 arrow bitmaps, or clear the fringes if no bitmaps are required
655 before DESIRED_ROW is made current. The window being updated is
656 found in updated_window. This function It is called from
657 update_window_line only if it is known that there are differences
658 between bitmaps to be drawn between current row and DESIRED_ROW. */
661 x_after_update_window_line (desired_row
)
662 struct glyph_row
*desired_row
;
664 struct window
*w
= updated_window
;
670 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
671 desired_row
->redraw_fringe_bitmaps_p
= 1;
673 /* When a window has disappeared, make sure that no rest of
674 full-width rows stays visible in the internal border. Could
675 check here if updated_window is the leftmost/rightmost window,
676 but I guess it's not worth doing since vertically split windows
677 are almost never used, internal border is rarely set, and the
678 overhead is very small. */
679 if (windows_or_buffers_changed
680 && desired_row
->full_width_p
681 && (f
= XFRAME (w
->frame
),
682 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
684 && (height
= desired_row
->visible_height
,
687 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
689 /* Internal border is drawn below the tool bar. */
690 if (WINDOWP (f
->tool_bar_window
)
691 && w
== XWINDOW (f
->tool_bar_window
))
695 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
696 0, y
, width
, height
, False
);
697 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
698 FRAME_PIXEL_WIDTH (f
) - width
,
699 y
, width
, height
, False
);
705 x_draw_fringe_bitmap (w
, row
, p
)
707 struct glyph_row
*row
;
708 struct draw_fringe_bitmap_params
*p
;
710 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
711 Display
*display
= FRAME_X_DISPLAY (f
);
712 Window window
= FRAME_X_WINDOW (f
);
713 GC gc
= f
->output_data
.x
->normal_gc
;
714 struct face
*face
= p
->face
;
717 /* Must clip because of partially visible lines. */
718 rowY
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
721 /* Adjust position of "bottom aligned" bitmap on partially
724 int oldVH
= row
->visible_height
;
725 row
->visible_height
= p
->h
;
726 row
->y
-= rowY
- p
->y
;
727 x_clip_to_row (w
, row
, -1, gc
);
729 row
->visible_height
= oldVH
;
732 x_clip_to_row (w
, row
, -1, gc
);
734 if (p
->bx
>= 0 && !p
->overlay_p
)
736 /* In case the same realized face is used for fringes and
737 for something displayed in the text (e.g. face `region' on
738 mono-displays, the fill style may have been changed to
739 FillSolid in x_draw_glyph_string_background. */
741 XSetFillStyle (display
, face
->gc
, FillOpaqueStippled
);
743 XSetForeground (display
, face
->gc
, face
->background
);
745 XFillRectangle (display
, window
, face
->gc
,
746 p
->bx
, p
->by
, p
->nx
, p
->ny
);
749 XSetForeground (display
, face
->gc
, face
->foreground
);
755 Pixmap pixmap
, clipmask
= (Pixmap
) 0;
756 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
760 bits
= (unsigned char *)(p
->bits
+ p
->dh
);
762 bits
= (unsigned char *)p
->bits
+ p
->dh
;
764 /* Draw the bitmap. I believe these small pixmaps can be cached
766 pixmap
= XCreatePixmapFromBitmapData (display
, window
, bits
, p
->wd
, p
->h
,
768 ? (p
->overlay_p
? face
->background
769 : f
->output_data
.x
->cursor_pixel
)
771 face
->background
, depth
);
775 clipmask
= XCreatePixmapFromBitmapData (display
,
776 FRAME_X_DISPLAY_INFO (f
)->root_window
,
779 gcv
.clip_mask
= clipmask
;
780 gcv
.clip_x_origin
= p
->x
;
781 gcv
.clip_y_origin
= p
->y
;
782 XChangeGC (display
, gc
, GCClipMask
| GCClipXOrigin
| GCClipYOrigin
, &gcv
);
785 XCopyArea (display
, pixmap
, window
, gc
, 0, 0,
786 p
->wd
, p
->h
, p
->x
, p
->y
);
787 XFreePixmap (display
, pixmap
);
791 gcv
.clip_mask
= (Pixmap
) 0;
792 XChangeGC (display
, gc
, GCClipMask
, &gcv
);
793 XFreePixmap (display
, clipmask
);
797 XSetClipMask (display
, gc
, None
);
802 /* This is called when starting Emacs and when restarting after
803 suspend. When starting Emacs, no X window is mapped. And nothing
804 must be done to Emacs's own window if it is suspended (though that
808 XTset_terminal_modes (struct device
*device
)
812 /* This is called when exiting or suspending Emacs. Exiting will make
813 the X-windows go away, and suspending requires no action. */
816 XTreset_terminal_modes (struct device
*device
)
822 /***********************************************************************
824 ***********************************************************************/
826 /* Function prototypes of this page. */
828 static int x_encode_char
P_ ((int, XChar2b
*, struct font_info
*, int *));
831 /* Get metrics of character CHAR2B in FONT. Value is null if CHAR2B
832 is not contained in the font. */
835 x_per_char_metric (font
, char2b
, font_type
)
838 int font_type
; /* unused on X */
840 /* The result metric information. */
841 XCharStruct
*pcm
= NULL
;
843 xassert (font
&& char2b
);
845 if (font
->per_char
!= NULL
)
847 if (font
->min_byte1
== 0 && font
->max_byte1
== 0)
849 /* min_char_or_byte2 specifies the linear character index
850 corresponding to the first element of the per_char array,
851 max_char_or_byte2 is the index of the last character. A
852 character with non-zero CHAR2B->byte1 is not in the font.
853 A character with byte2 less than min_char_or_byte2 or
854 greater max_char_or_byte2 is not in the font. */
855 if (char2b
->byte1
== 0
856 && char2b
->byte2
>= font
->min_char_or_byte2
857 && char2b
->byte2
<= font
->max_char_or_byte2
)
858 pcm
= font
->per_char
+ char2b
->byte2
- font
->min_char_or_byte2
;
862 /* If either min_byte1 or max_byte1 are nonzero, both
863 min_char_or_byte2 and max_char_or_byte2 are less than
864 256, and the 2-byte character index values corresponding
865 to the per_char array element N (counting from 0) are:
867 byte1 = N/D + min_byte1
868 byte2 = N\D + min_char_or_byte2
872 D = max_char_or_byte2 - min_char_or_byte2 + 1
874 \ = integer modulus */
875 if (char2b
->byte1
>= font
->min_byte1
876 && char2b
->byte1
<= font
->max_byte1
877 && char2b
->byte2
>= font
->min_char_or_byte2
878 && char2b
->byte2
<= font
->max_char_or_byte2
)
880 pcm
= (font
->per_char
881 + ((font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1)
882 * (char2b
->byte1
- font
->min_byte1
))
883 + (char2b
->byte2
- font
->min_char_or_byte2
));
889 /* If the per_char pointer is null, all glyphs between the first
890 and last character indexes inclusive have the same
891 information, as given by both min_bounds and max_bounds. */
892 if (char2b
->byte2
>= font
->min_char_or_byte2
893 && char2b
->byte2
<= font
->max_char_or_byte2
)
894 pcm
= &font
->max_bounds
;
898 || (pcm
->width
== 0 && (pcm
->rbearing
- pcm
->lbearing
) == 0))
903 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
904 the two-byte form of C. Encoding is returned in *CHAR2B. */
907 x_encode_char (c
, char2b
, font_info
, two_byte_p
)
910 struct font_info
*font_info
;
913 int charset
= CHAR_CHARSET (c
);
914 XFontStruct
*font
= font_info
->font
;
916 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
917 This may be either a program in a special encoder language or a
919 if (font_info
->font_encoder
)
921 /* It's a program. */
922 struct ccl_program
*ccl
= font_info
->font_encoder
;
924 check_ccl_update (ccl
);
925 if (CHARSET_DIMENSION (charset
) == 1)
927 ccl
->reg
[0] = charset
;
928 ccl
->reg
[1] = char2b
->byte2
;
933 ccl
->reg
[0] = charset
;
934 ccl
->reg
[1] = char2b
->byte1
;
935 ccl
->reg
[2] = char2b
->byte2
;
938 ccl_driver (ccl
, NULL
, NULL
, 0, 0, NULL
);
940 /* We assume that MSBs are appropriately set/reset by CCL
942 if (font
->max_byte1
== 0) /* 1-byte font */
943 char2b
->byte1
= 0, char2b
->byte2
= ccl
->reg
[1];
945 char2b
->byte1
= ccl
->reg
[1], char2b
->byte2
= ccl
->reg
[2];
947 else if (font_info
->encoding
[charset
])
949 /* Fixed encoding scheme. See fontset.h for the meaning of the
951 int enc
= font_info
->encoding
[charset
];
953 if ((enc
== 1 || enc
== 2)
954 && CHARSET_DIMENSION (charset
) == 2)
955 char2b
->byte1
|= 0x80;
957 if (enc
== 1 || enc
== 3)
958 char2b
->byte2
|= 0x80;
962 *two_byte_p
= ((XFontStruct
*) (font_info
->font
))->max_byte1
> 0;
964 return FONT_TYPE_UNKNOWN
;
969 /***********************************************************************
971 ***********************************************************************/
975 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
976 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
977 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
979 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
980 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
981 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
982 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
983 static void x_compute_glyph_string_overhangs
P_ ((struct glyph_string
*));
984 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
985 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
986 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
987 static int x_alloc_lighter_color
P_ ((struct frame
*, Display
*, Colormap
,
988 unsigned long *, double, int));
989 static void x_setup_relief_color
P_ ((struct frame
*, struct relief
*,
990 double, int, unsigned long));
991 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
992 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
993 static void x_draw_image_relief
P_ ((struct glyph_string
*));
994 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
995 static void x_draw_image_foreground_1
P_ ((struct glyph_string
*, Pixmap
));
996 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
998 static void x_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
999 int, int, int, int, int, int,
1001 static void x_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
1002 int, int, int, XRectangle
*));
1005 static void x_check_font
P_ ((struct frame
*, XFontStruct
*));
1009 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
1014 struct glyph_string
*s
;
1016 if (s
->font
== FRAME_FONT (s
->f
)
1017 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
1018 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
1020 s
->gc
= s
->f
->output_data
.x
->cursor_gc
;
1023 /* Cursor on non-default face: must merge. */
1027 xgcv
.background
= s
->f
->output_data
.x
->cursor_pixel
;
1028 xgcv
.foreground
= s
->face
->background
;
1030 /* If the glyph would be invisible, try a different foreground. */
1031 if (xgcv
.foreground
== xgcv
.background
)
1032 xgcv
.foreground
= s
->face
->foreground
;
1033 if (xgcv
.foreground
== xgcv
.background
)
1034 xgcv
.foreground
= s
->f
->output_data
.x
->cursor_foreground_pixel
;
1035 if (xgcv
.foreground
== xgcv
.background
)
1036 xgcv
.foreground
= s
->face
->foreground
;
1038 /* Make sure the cursor is distinct from text in this face. */
1039 if (xgcv
.background
== s
->face
->background
1040 && xgcv
.foreground
== s
->face
->foreground
)
1042 xgcv
.background
= s
->face
->foreground
;
1043 xgcv
.foreground
= s
->face
->background
;
1046 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1047 xgcv
.font
= s
->font
->fid
;
1048 xgcv
.graphics_exposures
= False
;
1049 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
1051 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1052 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1055 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1056 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
1058 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1063 /* Set up S->gc of glyph string S for drawing text in mouse face. */
1066 x_set_mouse_face_gc (s
)
1067 struct glyph_string
*s
;
1072 /* What face has to be used last for the mouse face? */
1073 face_id
= FRAME_X_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
1074 face
= FACE_FROM_ID (s
->f
, face_id
);
1076 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
1078 if (s
->first_glyph
->type
== CHAR_GLYPH
)
1079 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
);
1081 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0);
1082 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
1083 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1085 /* If font in this face is same as S->font, use it. */
1086 if (s
->font
== s
->face
->font
)
1087 s
->gc
= s
->face
->gc
;
1090 /* Otherwise construct scratch_cursor_gc with values from FACE
1095 xgcv
.background
= s
->face
->background
;
1096 xgcv
.foreground
= s
->face
->foreground
;
1097 IF_DEBUG (x_check_font (s
->f
, s
->font
));
1098 xgcv
.font
= s
->font
->fid
;
1099 xgcv
.graphics_exposures
= False
;
1100 mask
= GCForeground
| GCBackground
| GCFont
| GCGraphicsExposures
;
1102 if (FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
1103 XChangeGC (s
->display
, FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
1106 FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
1107 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
1109 s
->gc
= FRAME_X_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
1112 xassert (s
->gc
!= 0);
1116 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
1117 Faces to use in the mode line have already been computed when the
1118 matrix was built, so there isn't much to do, here. */
1121 x_set_mode_line_face_gc (s
)
1122 struct glyph_string
*s
;
1124 s
->gc
= s
->face
->gc
;
1128 /* Set S->gc of glyph string S for drawing that glyph string. Set
1129 S->stippled_p to a non-zero value if the face of S has a stipple
1133 x_set_glyph_string_gc (s
)
1134 struct glyph_string
*s
;
1136 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
1138 if (s
->hl
== DRAW_NORMAL_TEXT
)
1140 s
->gc
= s
->face
->gc
;
1141 s
->stippled_p
= s
->face
->stipple
!= 0;
1143 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
1145 x_set_mode_line_face_gc (s
);
1146 s
->stippled_p
= s
->face
->stipple
!= 0;
1148 else if (s
->hl
== DRAW_CURSOR
)
1150 x_set_cursor_gc (s
);
1153 else if (s
->hl
== DRAW_MOUSE_FACE
)
1155 x_set_mouse_face_gc (s
);
1156 s
->stippled_p
= s
->face
->stipple
!= 0;
1158 else if (s
->hl
== DRAW_IMAGE_RAISED
1159 || s
->hl
== DRAW_IMAGE_SUNKEN
)
1161 s
->gc
= s
->face
->gc
;
1162 s
->stippled_p
= s
->face
->stipple
!= 0;
1166 s
->gc
= s
->face
->gc
;
1167 s
->stippled_p
= s
->face
->stipple
!= 0;
1170 /* GC must have been set. */
1171 xassert (s
->gc
!= 0);
1175 /* Set clipping for output of glyph string S. S may be part of a mode
1176 line or menu if we don't have X toolkit support. */
1179 x_set_glyph_string_clipping (s
)
1180 struct glyph_string
*s
;
1183 get_glyph_string_clip_rect (s
, &r
);
1184 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, &r
, 1, Unsorted
);
1189 Compute left and right overhang of glyph string S. If S is a glyph
1190 string for a composition, assume overhangs don't exist. */
1193 x_compute_glyph_string_overhangs (s
)
1194 struct glyph_string
*s
;
1197 && s
->first_glyph
->type
== CHAR_GLYPH
)
1200 int direction
, font_ascent
, font_descent
;
1201 XTextExtents16 (s
->font
, s
->char2b
, s
->nchars
, &direction
,
1202 &font_ascent
, &font_descent
, &cs
);
1203 s
->right_overhang
= cs
.rbearing
> cs
.width
? cs
.rbearing
- cs
.width
: 0;
1204 s
->left_overhang
= cs
.lbearing
< 0 ? -cs
.lbearing
: 0;
1209 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
1212 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
1213 struct glyph_string
*s
;
1217 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
, &xgcv
);
1218 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
1219 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
1220 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
1224 /* Draw the background of glyph_string S. If S->background_filled_p
1225 is non-zero don't draw it. FORCE_P non-zero means draw the
1226 background even if it wouldn't be drawn normally. This is used
1227 when a string preceding S draws into the background of S, or S
1228 contains the first component of a composition. */
1231 x_draw_glyph_string_background (s
, force_p
)
1232 struct glyph_string
*s
;
1235 /* Nothing to do if background has already been drawn or if it
1236 shouldn't be drawn in the first place. */
1237 if (!s
->background_filled_p
)
1239 int box_line_width
= max (s
->face
->box_line_width
, 0);
1243 /* Fill background with a stipple pattern. */
1244 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
1245 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
1246 s
->y
+ box_line_width
,
1247 s
->background_width
,
1248 s
->height
- 2 * box_line_width
);
1249 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
1250 s
->background_filled_p
= 1;
1252 else if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
1253 || s
->font_not_found_p
1254 || s
->extends_to_end_of_line_p
1257 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
1258 s
->background_width
,
1259 s
->height
- 2 * box_line_width
);
1260 s
->background_filled_p
= 1;
1266 /* Draw the foreground of glyph string S. */
1269 x_draw_glyph_string_foreground (s
)
1270 struct glyph_string
*s
;
1274 /* If first glyph of S has a left box line, start drawing the text
1275 of S to the right of that box line. */
1276 if (s
->face
->box
!= FACE_NO_BOX
1277 && s
->first_glyph
->left_box_line_p
)
1278 x
= s
->x
+ abs (s
->face
->box_line_width
);
1282 /* Draw characters of S as rectangles if S's font could not be
1284 if (s
->font_not_found_p
)
1286 for (i
= 0; i
< s
->nchars
; ++i
)
1288 struct glyph
*g
= s
->first_glyph
+ i
;
1289 XDrawRectangle (s
->display
, s
->window
,
1290 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
1292 x
+= g
->pixel_width
;
1297 char *char1b
= (char *) s
->char2b
;
1298 int boff
= s
->font_info
->baseline_offset
;
1300 if (s
->font_info
->vertical_centering
)
1301 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
1303 /* If we can use 8-bit functions, condense S->char2b. */
1305 for (i
= 0; i
< s
->nchars
; ++i
)
1306 char1b
[i
] = s
->char2b
[i
].byte2
;
1308 /* Draw text with XDrawString if background has already been
1309 filled. Otherwise, use XDrawImageString. (Note that
1310 XDrawImageString is usually faster than XDrawString.) Always
1311 use XDrawImageString when drawing the cursor so that there is
1312 no chance that characters under a box cursor are invisible. */
1313 if (s
->for_overlaps_p
1314 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
1316 /* Draw characters with 16-bit or 8-bit functions. */
1318 XDrawString16 (s
->display
, s
->window
, s
->gc
, x
,
1319 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
1321 XDrawString (s
->display
, s
->window
, s
->gc
, x
,
1322 s
->ybase
- boff
, char1b
, s
->nchars
);
1327 XDrawImageString16 (s
->display
, s
->window
, s
->gc
, x
,
1328 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
1330 XDrawImageString (s
->display
, s
->window
, s
->gc
, x
,
1331 s
->ybase
- boff
, char1b
, s
->nchars
);
1334 if (s
->face
->overstrike
)
1336 /* For overstriking (to simulate bold-face), draw the
1337 characters again shifted to the right by one pixel. */
1339 XDrawString16 (s
->display
, s
->window
, s
->gc
, x
+ 1,
1340 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
1342 XDrawString (s
->display
, s
->window
, s
->gc
, x
+ 1,
1343 s
->ybase
- boff
, char1b
, s
->nchars
);
1348 /* Draw the foreground of composite glyph string S. */
1351 x_draw_composite_glyph_string_foreground (s
)
1352 struct glyph_string
*s
;
1356 /* If first glyph of S has a left box line, start drawing the text
1357 of S to the right of that box line. */
1358 if (s
->face
->box
!= FACE_NO_BOX
1359 && s
->first_glyph
->left_box_line_p
)
1360 x
= s
->x
+ abs (s
->face
->box_line_width
);
1364 /* S is a glyph string for a composition. S->gidx is the index of
1365 the first character drawn for glyphs of this composition.
1366 S->gidx == 0 means we are drawing the very first character of
1367 this composition. */
1369 /* Draw a rectangle for the composition if the font for the very
1370 first character of the composition could not be loaded. */
1371 if (s
->font_not_found_p
)
1374 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, s
->y
,
1375 s
->width
- 1, s
->height
- 1);
1379 for (i
= 0; i
< s
->nchars
; i
++, ++s
->gidx
)
1381 XDrawString16 (s
->display
, s
->window
, s
->gc
,
1382 x
+ s
->cmp
->offsets
[s
->gidx
* 2],
1383 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
1385 if (s
->face
->overstrike
)
1386 XDrawString16 (s
->display
, s
->window
, s
->gc
,
1387 x
+ s
->cmp
->offsets
[s
->gidx
* 2] + 1,
1388 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
1395 #ifdef USE_X_TOOLKIT
1397 static struct frame
*x_frame_of_widget
P_ ((Widget
));
1398 static Boolean cvt_string_to_pixel
P_ ((Display
*, XrmValue
*, Cardinal
*,
1399 XrmValue
*, XrmValue
*, XtPointer
*));
1400 static void cvt_pixel_dtor
P_ ((XtAppContext
, XrmValue
*, XtPointer
,
1401 XrmValue
*, Cardinal
*));
1404 /* Return the frame on which widget WIDGET is used.. Abort if frame
1405 cannot be determined. */
1407 static struct frame
*
1408 x_frame_of_widget (widget
)
1411 struct x_display_info
*dpyinfo
;
1415 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
1417 /* Find the top-level shell of the widget. Note that this function
1418 can be called when the widget is not yet realized, so XtWindow
1419 (widget) == 0. That's the reason we can't simply use
1420 x_any_window_to_frame. */
1421 while (!XtIsTopLevelShell (widget
))
1422 widget
= XtParent (widget
);
1424 /* Look for a frame with that top-level widget. Allocate the color
1425 on that frame to get the right gamma correction value. */
1426 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
1427 if (GC_FRAMEP (XCAR (tail
))
1428 && (f
= XFRAME (XCAR (tail
)),
1430 && f
->output_data
.nothing
!= 1
1431 && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
))
1432 && f
->output_data
.x
->widget
== widget
)
1439 /* Allocate the color COLOR->pixel on the screen and display of
1440 widget WIDGET in colormap CMAP. If an exact match cannot be
1441 allocated, try the nearest color available. Value is non-zero
1442 if successful. This is called from lwlib. */
1445 x_alloc_nearest_color_for_widget (widget
, cmap
, color
)
1450 struct frame
*f
= x_frame_of_widget (widget
);
1451 return x_alloc_nearest_color (f
, cmap
, color
);
1455 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1456 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1457 If this produces the same color as PIXEL, try a color where all RGB
1458 values have DELTA added. Return the allocated color in *PIXEL.
1459 DISPLAY is the X display, CMAP is the colormap to operate on.
1460 Value is non-zero if successful. */
1463 x_alloc_lighter_color_for_widget (widget
, display
, cmap
, pixel
, factor
, delta
)
1467 unsigned long *pixel
;
1471 struct frame
*f
= x_frame_of_widget (widget
);
1472 return x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
);
1476 /* Structure specifying which arguments should be passed by Xt to
1477 cvt_string_to_pixel. We want the widget's screen and colormap. */
1479 static XtConvertArgRec cvt_string_to_pixel_args
[] =
1481 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.screen
),
1483 {XtWidgetBaseOffset
, (XtPointer
) XtOffset (Widget
, core
.colormap
),
1488 /* The address of this variable is returned by
1489 cvt_string_to_pixel. */
1491 static Pixel cvt_string_to_pixel_value
;
1494 /* Convert a color name to a pixel color.
1496 DPY is the display we are working on.
1498 ARGS is an array of *NARGS XrmValue structures holding additional
1499 information about the widget for which the conversion takes place.
1500 The contents of this array are determined by the specification
1501 in cvt_string_to_pixel_args.
1503 FROM is a pointer to an XrmValue which points to the color name to
1504 convert. TO is an XrmValue in which to return the pixel color.
1506 CLOSURE_RET is a pointer to user-data, in which we record if
1507 we allocated the color or not.
1509 Value is True if successful, False otherwise. */
1512 cvt_string_to_pixel (dpy
, args
, nargs
, from
, to
, closure_ret
)
1516 XrmValue
*from
, *to
;
1517 XtPointer
*closure_ret
;
1527 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1528 "wrongParameters", "cvt_string_to_pixel",
1530 "Screen and colormap args required", NULL
, NULL
);
1534 screen
= *(Screen
**) args
[0].addr
;
1535 cmap
= *(Colormap
*) args
[1].addr
;
1536 color_name
= (String
) from
->addr
;
1538 if (strcmp (color_name
, XtDefaultBackground
) == 0)
1540 *closure_ret
= (XtPointer
) False
;
1541 pixel
= WhitePixelOfScreen (screen
);
1543 else if (strcmp (color_name
, XtDefaultForeground
) == 0)
1545 *closure_ret
= (XtPointer
) False
;
1546 pixel
= BlackPixelOfScreen (screen
);
1548 else if (XParseColor (dpy
, cmap
, color_name
, &color
)
1549 && x_alloc_nearest_color_1 (dpy
, cmap
, &color
))
1551 pixel
= color
.pixel
;
1552 *closure_ret
= (XtPointer
) True
;
1557 Cardinal nparams
= 1;
1559 params
[0] = color_name
;
1560 XtAppWarningMsg (XtDisplayToApplicationContext (dpy
),
1561 "badValue", "cvt_string_to_pixel",
1562 "XtToolkitError", "Invalid color `%s'",
1567 if (to
->addr
!= NULL
)
1569 if (to
->size
< sizeof (Pixel
))
1571 to
->size
= sizeof (Pixel
);
1575 *(Pixel
*) to
->addr
= pixel
;
1579 cvt_string_to_pixel_value
= pixel
;
1580 to
->addr
= (XtPointer
) &cvt_string_to_pixel_value
;
1583 to
->size
= sizeof (Pixel
);
1588 /* Free a pixel color which was previously allocated via
1589 cvt_string_to_pixel. This is registered as the destructor
1590 for this type of resource via XtSetTypeConverter.
1592 APP is the application context in which we work.
1594 TO is a pointer to an XrmValue holding the color to free.
1595 CLOSURE is the value we stored in CLOSURE_RET for this color
1596 in cvt_string_to_pixel.
1598 ARGS and NARGS are like for cvt_string_to_pixel. */
1601 cvt_pixel_dtor (app
, to
, closure
, args
, nargs
)
1610 XtAppWarningMsg (app
, "wrongParameters", "cvt_pixel_dtor",
1612 "Screen and colormap arguments required",
1615 else if (closure
!= NULL
)
1617 /* We did allocate the pixel, so free it. */
1618 Screen
*screen
= *(Screen
**) args
[0].addr
;
1619 Colormap cmap
= *(Colormap
*) args
[1].addr
;
1620 x_free_dpy_colors (DisplayOfScreen (screen
), screen
, cmap
,
1621 (Pixel
*) to
->addr
, 1);
1626 #endif /* USE_X_TOOLKIT */
1629 /* Value is an array of XColor structures for the contents of the
1630 color map of display DPY. Set *NCELLS to the size of the array.
1631 Note that this probably shouldn't be called for large color maps,
1632 say a 24-bit TrueColor map. */
1634 static const XColor
*
1635 x_color_cells (dpy
, ncells
)
1639 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1641 if (dpyinfo
->color_cells
== NULL
)
1643 Screen
*screen
= dpyinfo
->screen
;
1646 dpyinfo
->ncolor_cells
1647 = XDisplayCells (dpy
, XScreenNumberOfScreen (screen
));
1648 dpyinfo
->color_cells
1649 = (XColor
*) xmalloc (dpyinfo
->ncolor_cells
1650 * sizeof *dpyinfo
->color_cells
);
1652 for (i
= 0; i
< dpyinfo
->ncolor_cells
; ++i
)
1653 dpyinfo
->color_cells
[i
].pixel
= i
;
1655 XQueryColors (dpy
, dpyinfo
->cmap
,
1656 dpyinfo
->color_cells
, dpyinfo
->ncolor_cells
);
1659 *ncells
= dpyinfo
->ncolor_cells
;
1660 return dpyinfo
->color_cells
;
1664 /* On frame F, translate pixel colors to RGB values for the NCOLORS
1665 colors in COLORS. Use cached information, if available. */
1668 x_query_colors (f
, colors
, ncolors
)
1673 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1675 if (dpyinfo
->color_cells
)
1678 for (i
= 0; i
< ncolors
; ++i
)
1680 unsigned long pixel
= colors
[i
].pixel
;
1681 xassert (pixel
< dpyinfo
->ncolor_cells
);
1682 xassert (dpyinfo
->color_cells
[pixel
].pixel
== pixel
);
1683 colors
[i
] = dpyinfo
->color_cells
[pixel
];
1687 XQueryColors (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), colors
, ncolors
);
1691 /* On frame F, translate pixel color to RGB values for the color in
1692 COLOR. Use cached information, if available. */
1695 x_query_color (f
, color
)
1699 x_query_colors (f
, color
, 1);
1703 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
1704 exact match can't be allocated, try the nearest color available.
1705 Value is non-zero if successful. Set *COLOR to the color
1709 x_alloc_nearest_color_1 (dpy
, cmap
, color
)
1716 rc
= XAllocColor (dpy
, cmap
, color
);
1719 /* If we got to this point, the colormap is full, so we're going
1720 to try to get the next closest color. The algorithm used is
1721 a least-squares matching, which is what X uses for closest
1722 color matching with StaticColor visuals. */
1724 unsigned long nearest_delta
= ~0;
1726 const XColor
*cells
= x_color_cells (dpy
, &ncells
);
1728 for (nearest
= i
= 0; i
< ncells
; ++i
)
1730 long dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
1731 long dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
1732 long dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
1733 unsigned long delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
1735 if (delta
< nearest_delta
)
1738 nearest_delta
= delta
;
1742 color
->red
= cells
[nearest
].red
;
1743 color
->green
= cells
[nearest
].green
;
1744 color
->blue
= cells
[nearest
].blue
;
1745 rc
= XAllocColor (dpy
, cmap
, color
);
1749 /* If allocation succeeded, and the allocated pixel color is not
1750 equal to a cached pixel color recorded earlier, there was a
1751 change in the colormap, so clear the color cache. */
1752 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
1753 XColor
*cached_color
;
1755 if (dpyinfo
->color_cells
1756 && (cached_color
= &dpyinfo
->color_cells
[color
->pixel
],
1757 (cached_color
->red
!= color
->red
1758 || cached_color
->blue
!= color
->blue
1759 || cached_color
->green
!= color
->green
)))
1761 xfree (dpyinfo
->color_cells
);
1762 dpyinfo
->color_cells
= NULL
;
1763 dpyinfo
->ncolor_cells
= 0;
1767 #ifdef DEBUG_X_COLORS
1769 register_color (color
->pixel
);
1770 #endif /* DEBUG_X_COLORS */
1776 /* Allocate the color COLOR->pixel on frame F, colormap CMAP. If an
1777 exact match can't be allocated, try the nearest color available.
1778 Value is non-zero if successful. Set *COLOR to the color
1782 x_alloc_nearest_color (f
, cmap
, color
)
1787 gamma_correct (f
, color
);
1788 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f
), cmap
, color
);
1792 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
1793 It's necessary to do this instead of just using PIXEL directly to
1794 get color reference counts right. */
1797 x_copy_color (f
, pixel
)
1799 unsigned long pixel
;
1803 color
.pixel
= pixel
;
1805 x_query_color (f
, &color
);
1806 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
1808 #ifdef DEBUG_X_COLORS
1809 register_color (pixel
);
1815 /* Allocate color PIXEL on display DPY. PIXEL must already be allocated.
1816 It's necessary to do this instead of just using PIXEL directly to
1817 get color reference counts right. */
1820 x_copy_dpy_color (dpy
, cmap
, pixel
)
1823 unsigned long pixel
;
1827 color
.pixel
= pixel
;
1829 XQueryColor (dpy
, cmap
, &color
);
1830 XAllocColor (dpy
, cmap
, &color
);
1832 #ifdef DEBUG_X_COLORS
1833 register_color (pixel
);
1839 /* Brightness beyond which a color won't have its highlight brightness
1842 Nominally, highlight colors for `3d' faces are calculated by
1843 brightening an object's color by a constant scale factor, but this
1844 doesn't yield good results for dark colors, so for colors who's
1845 brightness is less than this value (on a scale of 0-65535) have an
1846 use an additional additive factor.
1848 The value here is set so that the default menu-bar/mode-line color
1849 (grey75) will not have its highlights changed at all. */
1850 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
1853 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
1854 or DELTA. Try a color with RGB values multiplied by FACTOR first.
1855 If this produces the same color as PIXEL, try a color where all RGB
1856 values have DELTA added. Return the allocated color in *PIXEL.
1857 DISPLAY is the X display, CMAP is the colormap to operate on.
1858 Value is non-zero if successful. */
1861 x_alloc_lighter_color (f
, display
, cmap
, pixel
, factor
, delta
)
1865 unsigned long *pixel
;
1873 /* Get RGB color values. */
1874 color
.pixel
= *pixel
;
1875 x_query_color (f
, &color
);
1877 /* Change RGB values by specified FACTOR. Avoid overflow! */
1878 xassert (factor
>= 0);
1879 new.red
= min (0xffff, factor
* color
.red
);
1880 new.green
= min (0xffff, factor
* color
.green
);
1881 new.blue
= min (0xffff, factor
* color
.blue
);
1883 /* Calculate brightness of COLOR. */
1884 bright
= (2 * color
.red
+ 3 * color
.green
+ color
.blue
) / 6;
1886 /* We only boost colors that are darker than
1887 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
1888 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
1889 /* Make an additive adjustment to NEW, because it's dark enough so
1890 that scaling by FACTOR alone isn't enough. */
1892 /* How far below the limit this color is (0 - 1, 1 being darker). */
1893 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
1894 /* The additive adjustment. */
1895 int min_delta
= delta
* dimness
* factor
/ 2;
1899 new.red
= max (0, new.red
- min_delta
);
1900 new.green
= max (0, new.green
- min_delta
);
1901 new.blue
= max (0, new.blue
- min_delta
);
1905 new.red
= min (0xffff, min_delta
+ new.red
);
1906 new.green
= min (0xffff, min_delta
+ new.green
);
1907 new.blue
= min (0xffff, min_delta
+ new.blue
);
1911 /* Try to allocate the color. */
1912 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1915 if (new.pixel
== *pixel
)
1917 /* If we end up with the same color as before, try adding
1918 delta to the RGB values. */
1919 x_free_colors (f
, &new.pixel
, 1);
1921 new.red
= min (0xffff, delta
+ color
.red
);
1922 new.green
= min (0xffff, delta
+ color
.green
);
1923 new.blue
= min (0xffff, delta
+ color
.blue
);
1924 success_p
= x_alloc_nearest_color (f
, cmap
, &new);
1935 /* Set up the foreground color for drawing relief lines of glyph
1936 string S. RELIEF is a pointer to a struct relief containing the GC
1937 with which lines will be drawn. Use a color that is FACTOR or
1938 DELTA lighter or darker than the relief's background which is found
1939 in S->f->output_data.x->relief_background. If such a color cannot
1940 be allocated, use DEFAULT_PIXEL, instead. */
1943 x_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
1945 struct relief
*relief
;
1948 unsigned long default_pixel
;
1951 struct x_output
*di
= f
->output_data
.x
;
1952 unsigned long mask
= GCForeground
| GCLineWidth
| GCGraphicsExposures
;
1953 unsigned long pixel
;
1954 unsigned long background
= di
->relief_background
;
1955 Colormap cmap
= FRAME_X_COLORMAP (f
);
1956 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1957 Display
*dpy
= FRAME_X_DISPLAY (f
);
1959 xgcv
.graphics_exposures
= False
;
1960 xgcv
.line_width
= 1;
1962 /* Free previously allocated color. The color cell will be reused
1963 when it has been freed as many times as it was allocated, so this
1964 doesn't affect faces using the same colors. */
1966 && relief
->allocated_p
)
1968 x_free_colors (f
, &relief
->pixel
, 1);
1969 relief
->allocated_p
= 0;
1972 /* Allocate new color. */
1973 xgcv
.foreground
= default_pixel
;
1975 if (dpyinfo
->n_planes
!= 1
1976 && x_alloc_lighter_color (f
, dpy
, cmap
, &pixel
, factor
, delta
))
1978 relief
->allocated_p
= 1;
1979 xgcv
.foreground
= relief
->pixel
= pixel
;
1982 if (relief
->gc
== 0)
1984 xgcv
.stipple
= dpyinfo
->gray
;
1986 relief
->gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
), mask
, &xgcv
);
1989 XChangeGC (dpy
, relief
->gc
, mask
, &xgcv
);
1993 /* Set up colors for the relief lines around glyph string S. */
1996 x_setup_relief_colors (s
)
1997 struct glyph_string
*s
;
1999 struct x_output
*di
= s
->f
->output_data
.x
;
2000 unsigned long color
;
2002 if (s
->face
->use_box_color_for_shadows_p
)
2003 color
= s
->face
->box_color
;
2004 else if (s
->first_glyph
->type
== IMAGE_GLYPH
2006 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
2007 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
2012 /* Get the background color of the face. */
2013 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
2014 color
= xgcv
.background
;
2017 if (di
->white_relief
.gc
== 0
2018 || color
!= di
->relief_background
)
2020 di
->relief_background
= color
;
2021 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
2022 WHITE_PIX_DEFAULT (s
->f
));
2023 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
2024 BLACK_PIX_DEFAULT (s
->f
));
2029 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
2030 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
2031 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
2032 relief. LEFT_P non-zero means draw a relief on the left side of
2033 the rectangle. RIGHT_P non-zero means draw a relief on the right
2034 side of the rectangle. CLIP_RECT is the clipping rectangle to use
2038 x_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
2039 raised_p
, top_p
, bot_p
, left_p
, right_p
, clip_rect
)
2041 int left_x
, top_y
, right_x
, bottom_y
, width
;
2042 int top_p
, bot_p
, left_p
, right_p
, raised_p
;
2043 XRectangle
*clip_rect
;
2045 Display
*dpy
= FRAME_X_DISPLAY (f
);
2046 Window window
= FRAME_X_WINDOW (f
);
2051 gc
= f
->output_data
.x
->white_relief
.gc
;
2053 gc
= f
->output_data
.x
->black_relief
.gc
;
2054 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
2058 for (i
= 0; i
< width
; ++i
)
2059 XDrawLine (dpy
, window
, gc
,
2060 left_x
+ i
* left_p
, top_y
+ i
,
2061 right_x
+ 1 - i
* right_p
, top_y
+ i
);
2065 for (i
= 0; i
< width
; ++i
)
2066 XDrawLine (dpy
, window
, gc
,
2067 left_x
+ i
, top_y
+ i
, left_x
+ i
, bottom_y
- i
+ 1);
2069 XSetClipMask (dpy
, gc
, None
);
2071 gc
= f
->output_data
.x
->black_relief
.gc
;
2073 gc
= f
->output_data
.x
->white_relief
.gc
;
2074 XSetClipRectangles (dpy
, gc
, 0, 0, clip_rect
, 1, Unsorted
);
2078 for (i
= 0; i
< width
; ++i
)
2079 XDrawLine (dpy
, window
, gc
,
2080 left_x
+ i
* left_p
, bottom_y
- i
,
2081 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
2085 for (i
= 0; i
< width
; ++i
)
2086 XDrawLine (dpy
, window
, gc
,
2087 right_x
- i
, top_y
+ i
+ 1, right_x
- i
, bottom_y
- i
);
2089 XSetClipMask (dpy
, gc
, None
);
2093 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
2094 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
2095 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
2096 left side of the rectangle. RIGHT_P non-zero means draw a line
2097 on the right side of the rectangle. CLIP_RECT is the clipping
2098 rectangle to use when drawing. */
2101 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2102 left_p
, right_p
, clip_rect
)
2103 struct glyph_string
*s
;
2104 int left_x
, top_y
, right_x
, bottom_y
, width
, left_p
, right_p
;
2105 XRectangle
*clip_rect
;
2109 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2110 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
2111 XSetClipRectangles (s
->display
, s
->gc
, 0, 0, clip_rect
, 1, Unsorted
);
2114 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2115 left_x
, top_y
, right_x
- left_x
+ 1, width
);
2119 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2120 left_x
, top_y
, width
, bottom_y
- top_y
+ 1);
2123 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2124 left_x
, bottom_y
- width
+ 1, right_x
- left_x
+ 1, width
);
2128 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2129 right_x
- width
+ 1, top_y
, width
, bottom_y
- top_y
+ 1);
2131 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2132 XSetClipMask (s
->display
, s
->gc
, None
);
2136 /* Draw a box around glyph string S. */
2139 x_draw_glyph_string_box (s
)
2140 struct glyph_string
*s
;
2142 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
2143 int left_p
, right_p
;
2144 struct glyph
*last_glyph
;
2145 XRectangle clip_rect
;
2147 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
2148 ? WINDOW_RIGHT_EDGE_X (s
->w
)
2149 : window_box_right (s
->w
, s
->area
));
2151 /* The glyph that may have a right box line. */
2152 last_glyph
= (s
->cmp
|| s
->img
2154 : s
->first_glyph
+ s
->nchars
- 1);
2156 width
= abs (s
->face
->box_line_width
);
2157 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
2159 right_x
= (s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
2161 : min (last_x
, s
->x
+ s
->background_width
) - 1);
2163 bottom_y
= top_y
+ s
->height
- 1;
2165 left_p
= (s
->first_glyph
->left_box_line_p
2166 || (s
->hl
== DRAW_MOUSE_FACE
2168 || s
->prev
->hl
!= s
->hl
)));
2169 right_p
= (last_glyph
->right_box_line_p
2170 || (s
->hl
== DRAW_MOUSE_FACE
2172 || s
->next
->hl
!= s
->hl
)));
2174 get_glyph_string_clip_rect (s
, &clip_rect
);
2176 if (s
->face
->box
== FACE_SIMPLE_BOX
)
2177 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
2178 left_p
, right_p
, &clip_rect
);
2181 x_setup_relief_colors (s
);
2182 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
2183 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
2188 /* Draw foreground of image glyph string S. */
2191 x_draw_image_foreground (s
)
2192 struct glyph_string
*s
;
2195 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2197 /* If first glyph of S has a left box line, start drawing it to the
2198 right of that line. */
2199 if (s
->face
->box
!= FACE_NO_BOX
2200 && s
->first_glyph
->left_box_line_p
2202 x
+= abs (s
->face
->box_line_width
);
2204 /* If there is a margin around the image, adjust x- and y-position
2206 if (s
->slice
.x
== 0)
2207 x
+= s
->img
->hmargin
;
2208 if (s
->slice
.y
== 0)
2209 y
+= s
->img
->vmargin
;
2215 /* We can't set both a clip mask and use XSetClipRectangles
2216 because the latter also sets a clip mask. We also can't
2217 trust on the shape extension to be available
2218 (XShapeCombineRegion). So, compute the rectangle to draw
2220 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2223 XRectangle clip_rect
, image_rect
, r
;
2225 xgcv
.clip_mask
= s
->img
->mask
;
2226 xgcv
.clip_x_origin
= x
;
2227 xgcv
.clip_y_origin
= y
;
2228 xgcv
.function
= GXcopy
;
2229 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2231 get_glyph_string_clip_rect (s
, &clip_rect
);
2234 image_rect
.width
= s
->slice
.width
;
2235 image_rect
.height
= s
->slice
.height
;
2236 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2237 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2238 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2239 r
.width
, r
.height
, r
.x
, r
.y
);
2243 XRectangle clip_rect
, image_rect
, r
;
2245 get_glyph_string_clip_rect (s
, &clip_rect
);
2248 image_rect
.width
= s
->slice
.width
;
2249 image_rect
.height
= s
->slice
.height
;
2250 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
2251 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
2252 s
->slice
.x
+ r
.x
- x
, s
->slice
.y
+ r
.y
- y
,
2253 r
.width
, r
.height
, r
.x
, r
.y
);
2255 /* When the image has a mask, we can expect that at
2256 least part of a mouse highlight or a block cursor will
2257 be visible. If the image doesn't have a mask, make
2258 a block cursor visible by drawing a rectangle around
2259 the image. I believe it's looking better if we do
2260 nothing here for mouse-face. */
2261 if (s
->hl
== DRAW_CURSOR
)
2263 int r
= s
->img
->relief
;
2265 XDrawRectangle (s
->display
, s
->window
, s
->gc
,
2267 s
->slice
.width
+ r
*2 - 1,
2268 s
->slice
.height
+ r
*2 - 1);
2273 /* Draw a rectangle if image could not be loaded. */
2274 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
2275 s
->slice
.width
- 1, s
->slice
.height
- 1);
2279 /* Draw a relief around the image glyph string S. */
2282 x_draw_image_relief (s
)
2283 struct glyph_string
*s
;
2285 int x0
, y0
, x1
, y1
, thick
, raised_p
;
2288 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2290 /* If first glyph of S has a left box line, start drawing it to the
2291 right of that line. */
2292 if (s
->face
->box
!= FACE_NO_BOX
2293 && s
->first_glyph
->left_box_line_p
2295 x
+= abs (s
->face
->box_line_width
);
2297 /* If there is a margin around the image, adjust x- and y-position
2299 if (s
->slice
.x
== 0)
2300 x
+= s
->img
->hmargin
;
2301 if (s
->slice
.y
== 0)
2302 y
+= s
->img
->vmargin
;
2304 if (s
->hl
== DRAW_IMAGE_SUNKEN
2305 || s
->hl
== DRAW_IMAGE_RAISED
)
2307 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
2308 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
2312 thick
= abs (s
->img
->relief
);
2313 raised_p
= s
->img
->relief
> 0;
2318 x1
= x
+ s
->slice
.width
+ thick
- 1;
2319 y1
= y
+ s
->slice
.height
+ thick
- 1;
2321 x_setup_relief_colors (s
);
2322 get_glyph_string_clip_rect (s
, &r
);
2323 x_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
,
2325 s
->slice
.y
+ s
->slice
.height
== s
->img
->height
,
2327 s
->slice
.x
+ s
->slice
.width
== s
->img
->width
,
2332 /* Draw the foreground of image glyph string S to PIXMAP. */
2335 x_draw_image_foreground_1 (s
, pixmap
)
2336 struct glyph_string
*s
;
2340 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
, &s
->slice
);
2342 /* If first glyph of S has a left box line, start drawing it to the
2343 right of that line. */
2344 if (s
->face
->box
!= FACE_NO_BOX
2345 && s
->first_glyph
->left_box_line_p
2347 x
+= abs (s
->face
->box_line_width
);
2349 /* If there is a margin around the image, adjust x- and y-position
2351 if (s
->slice
.x
== 0)
2352 x
+= s
->img
->hmargin
;
2353 if (s
->slice
.y
== 0)
2354 y
+= s
->img
->vmargin
;
2360 /* We can't set both a clip mask and use XSetClipRectangles
2361 because the latter also sets a clip mask. We also can't
2362 trust on the shape extension to be available
2363 (XShapeCombineRegion). So, compute the rectangle to draw
2365 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
2369 xgcv
.clip_mask
= s
->img
->mask
;
2370 xgcv
.clip_x_origin
= x
- s
->slice
.x
;
2371 xgcv
.clip_y_origin
= y
- s
->slice
.y
;
2372 xgcv
.function
= GXcopy
;
2373 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
2375 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2376 s
->slice
.x
, s
->slice
.y
,
2377 s
->slice
.width
, s
->slice
.height
, x
, y
);
2378 XSetClipMask (s
->display
, s
->gc
, None
);
2382 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
2383 s
->slice
.x
, s
->slice
.y
,
2384 s
->slice
.width
, s
->slice
.height
, x
, y
);
2386 /* When the image has a mask, we can expect that at
2387 least part of a mouse highlight or a block cursor will
2388 be visible. If the image doesn't have a mask, make
2389 a block cursor visible by drawing a rectangle around
2390 the image. I believe it's looking better if we do
2391 nothing here for mouse-face. */
2392 if (s
->hl
== DRAW_CURSOR
)
2394 int r
= s
->img
->relief
;
2396 XDrawRectangle (s
->display
, s
->window
, s
->gc
, x
- r
, y
- r
,
2397 s
->slice
.width
+ r
*2 - 1,
2398 s
->slice
.height
+ r
*2 - 1);
2403 /* Draw a rectangle if image could not be loaded. */
2404 XDrawRectangle (s
->display
, pixmap
, s
->gc
, x
, y
,
2405 s
->slice
.width
- 1, s
->slice
.height
- 1);
2409 /* Draw part of the background of glyph string S. X, Y, W, and H
2410 give the rectangle to draw. */
2413 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
2414 struct glyph_string
*s
;
2419 /* Fill background with a stipple pattern. */
2420 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2421 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
2422 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2425 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
2429 /* Draw image glyph string S.
2432 s->x +-------------------------
2435 | +-------------------------
2438 | | +-------------------
2444 x_draw_image_glyph_string (s
)
2445 struct glyph_string
*s
;
2447 int box_line_hwidth
= abs (s
->face
->box_line_width
);
2448 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
2450 Pixmap pixmap
= None
;
2453 if (s
->slice
.y
== 0)
2454 height
-= box_line_vwidth
;
2455 if (s
->slice
.y
+ s
->slice
.height
>= s
->img
->height
)
2456 height
-= box_line_vwidth
;
2458 /* Fill background with face under the image. Do it only if row is
2459 taller than image or if image has a clip mask to reduce
2461 s
->stippled_p
= s
->face
->stipple
!= 0;
2462 if (height
> s
->slice
.height
2466 || s
->img
->pixmap
== 0
2467 || s
->width
!= s
->background_width
)
2471 /* Create a pixmap as large as the glyph string. Fill it
2472 with the background color. Copy the image to it, using
2473 its mask. Copy the temporary pixmap to the display. */
2474 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
2475 int depth
= DefaultDepthOfScreen (screen
);
2477 /* Create a pixmap as large as the glyph string. */
2478 pixmap
= XCreatePixmap (s
->display
, s
->window
,
2479 s
->background_width
,
2482 /* Don't clip in the following because we're working on the
2484 XSetClipMask (s
->display
, s
->gc
, None
);
2486 /* Fill the pixmap with the background color/stipple. */
2489 /* Fill background with a stipple pattern. */
2490 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2491 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2492 0, 0, s
->background_width
, s
->height
);
2493 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2498 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
2500 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
2501 XFillRectangle (s
->display
, pixmap
, s
->gc
,
2502 0, 0, s
->background_width
, s
->height
);
2503 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2511 if (s
->first_glyph
->left_box_line_p
2513 x
+= box_line_hwidth
;
2515 if (s
->slice
.y
== 0)
2516 y
+= box_line_vwidth
;
2518 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
2521 s
->background_filled_p
= 1;
2524 /* Draw the foreground. */
2527 x_draw_image_foreground_1 (s
, pixmap
);
2528 x_set_glyph_string_clipping (s
);
2529 XCopyArea (s
->display
, pixmap
, s
->window
, s
->gc
,
2530 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
2531 XFreePixmap (s
->display
, pixmap
);
2534 x_draw_image_foreground (s
);
2536 /* If we must draw a relief around the image, do it. */
2538 || s
->hl
== DRAW_IMAGE_RAISED
2539 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2540 x_draw_image_relief (s
);
2544 /* Draw stretch glyph string S. */
2547 x_draw_stretch_glyph_string (s
)
2548 struct glyph_string
*s
;
2550 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
2551 s
->stippled_p
= s
->face
->stipple
!= 0;
2553 if (s
->hl
== DRAW_CURSOR
2554 && !x_stretch_cursor_p
)
2556 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
2557 as wide as the stretch glyph. */
2558 int width
= min (FRAME_COLUMN_WIDTH (s
->f
), s
->background_width
);
2561 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, width
, s
->height
);
2563 /* Clear rest using the GC of the original non-cursor face. */
2564 if (width
< s
->background_width
)
2566 int x
= s
->x
+ width
, y
= s
->y
;
2567 int w
= s
->background_width
- width
, h
= s
->height
;
2571 if (s
->row
->mouse_face_p
2572 && cursor_in_mouse_face_p (s
->w
))
2574 x_set_mouse_face_gc (s
);
2580 get_glyph_string_clip_rect (s
, &r
);
2581 XSetClipRectangles (s
->display
, gc
, 0, 0, &r
, 1, Unsorted
);
2583 if (s
->face
->stipple
)
2585 /* Fill background with a stipple pattern. */
2586 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
2587 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2588 XSetFillStyle (s
->display
, gc
, FillSolid
);
2593 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
2594 XSetForeground (s
->display
, gc
, xgcv
.background
);
2595 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
2596 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
2600 else if (!s
->background_filled_p
)
2601 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, s
->background_width
,
2604 s
->background_filled_p
= 1;
2608 /* Draw glyph string S. */
2611 x_draw_glyph_string (s
)
2612 struct glyph_string
*s
;
2614 int relief_drawn_p
= 0;
2616 /* If S draws into the background of its successor, draw the
2617 background of the successor first so that S can draw into it.
2618 This makes S->next use XDrawString instead of XDrawImageString. */
2619 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps_p
)
2621 xassert (s
->next
->img
== NULL
);
2622 x_set_glyph_string_gc (s
->next
);
2623 x_set_glyph_string_clipping (s
->next
);
2624 x_draw_glyph_string_background (s
->next
, 1);
2627 /* Set up S->gc, set clipping and draw S. */
2628 x_set_glyph_string_gc (s
);
2630 /* Draw relief (if any) in advance for char/composition so that the
2631 glyph string can be drawn over it. */
2632 if (!s
->for_overlaps_p
2633 && s
->face
->box
!= FACE_NO_BOX
2634 && (s
->first_glyph
->type
== CHAR_GLYPH
2635 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
2638 x_set_glyph_string_clipping (s
);
2639 x_draw_glyph_string_background (s
, 1);
2640 x_draw_glyph_string_box (s
);
2641 x_set_glyph_string_clipping (s
);
2645 x_set_glyph_string_clipping (s
);
2647 switch (s
->first_glyph
->type
)
2650 x_draw_image_glyph_string (s
);
2654 x_draw_stretch_glyph_string (s
);
2658 if (s
->for_overlaps_p
)
2659 s
->background_filled_p
= 1;
2661 x_draw_glyph_string_background (s
, 0);
2662 x_draw_glyph_string_foreground (s
);
2665 case COMPOSITE_GLYPH
:
2666 if (s
->for_overlaps_p
|| s
->gidx
> 0)
2667 s
->background_filled_p
= 1;
2669 x_draw_glyph_string_background (s
, 1);
2670 x_draw_composite_glyph_string_foreground (s
);
2677 if (!s
->for_overlaps_p
)
2679 /* Draw underline. */
2680 if (s
->face
->underline_p
)
2682 unsigned long tem
, h
;
2685 /* Get the underline thickness. Default is 1 pixel. */
2686 if (!XGetFontProperty (s
->font
, XA_UNDERLINE_THICKNESS
, &h
))
2689 /* Get the underline position. This is the recommended
2690 vertical offset in pixels from the baseline to the top of
2691 the underline. This is a signed value according to the
2692 specs, and its default is
2694 ROUND ((maximum descent) / 2), with
2695 ROUND(x) = floor (x + 0.5) */
2697 if (x_use_underline_position_properties
2698 && XGetFontProperty (s
->font
, XA_UNDERLINE_POSITION
, &tem
))
2699 y
= s
->ybase
+ (long) tem
;
2700 else if (s
->face
->font
)
2701 y
= s
->ybase
+ (s
->face
->font
->max_bounds
.descent
+ 1) / 2;
2703 y
= s
->y
+ s
->height
- h
;
2705 if (s
->face
->underline_defaulted_p
)
2706 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2707 s
->x
, y
, s
->width
, h
);
2711 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2712 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
2713 XFillRectangle (s
->display
, s
->window
, s
->gc
,
2714 s
->x
, y
, s
->width
, h
);
2715 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2719 /* Draw overline. */
2720 if (s
->face
->overline_p
)
2722 unsigned long dy
= 0, h
= 1;
2724 if (s
->face
->overline_color_defaulted_p
)
2725 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2730 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2731 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
2732 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2734 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2738 /* Draw strike-through. */
2739 if (s
->face
->strike_through_p
)
2741 unsigned long h
= 1;
2742 unsigned long dy
= (s
->height
- h
) / 2;
2744 if (s
->face
->strike_through_color_defaulted_p
)
2745 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2750 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
2751 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
2752 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
2754 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
2758 /* Draw relief if not yet drawn. */
2759 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
2760 x_draw_glyph_string_box (s
);
2763 /* Reset clipping. */
2764 XSetClipMask (s
->display
, s
->gc
, None
);
2767 /* Shift display to make room for inserted glyphs. */
2770 x_shift_glyphs_for_insert (f
, x
, y
, width
, height
, shift_by
)
2772 int x
, y
, width
, height
, shift_by
;
2774 XCopyArea (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
2775 f
->output_data
.x
->normal_gc
,
2776 x
, y
, width
, height
,
2780 /* Delete N glyphs at the nominal cursor position. Not implemented
2784 x_delete_glyphs (f
, n
)
2792 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
2793 If they are <= 0, this is probably an error. */
2796 x_clear_area (dpy
, window
, x
, y
, width
, height
, exposures
)
2803 xassert (width
> 0 && height
> 0);
2804 XClearArea (dpy
, window
, x
, y
, width
, height
, exposures
);
2808 /* Clear an entire frame. */
2811 x_clear_frame (struct frame
*f
)
2813 /* Clearing the frame will erase any cursor, so mark them all as no
2815 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
2816 output_cursor
.hpos
= output_cursor
.vpos
= 0;
2817 output_cursor
.x
= -1;
2819 /* We don't set the output cursor here because there will always
2820 follow an explicit cursor_to. */
2822 XClearWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
2824 /* We have to clear the scroll bars, too. If we have changed
2825 colors or something like that, then they should be notified. */
2826 x_scroll_bar_clear (f
);
2828 XFlush (FRAME_X_DISPLAY (f
));
2835 /* Invert the middle quarter of the frame for .15 sec. */
2837 /* We use the select system call to do the waiting, so we have to make
2838 sure it's available. If it isn't, we just won't do visual bells. */
2840 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
2843 /* Subtract the `struct timeval' values X and Y, storing the result in
2844 *RESULT. Return 1 if the difference is negative, otherwise 0. */
2847 timeval_subtract (result
, x
, y
)
2848 struct timeval
*result
, x
, y
;
2850 /* Perform the carry for the later subtraction by updating y. This
2851 is safer because on some systems the tv_sec member is unsigned. */
2852 if (x
.tv_usec
< y
.tv_usec
)
2854 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
2855 y
.tv_usec
-= 1000000 * nsec
;
2859 if (x
.tv_usec
- y
.tv_usec
> 1000000)
2861 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
2862 y
.tv_usec
+= 1000000 * nsec
;
2866 /* Compute the time remaining to wait. tv_usec is certainly
2868 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
2869 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
2871 /* Return indication of whether the result should be considered
2873 return x
.tv_sec
< y
.tv_sec
;
2885 /* Create a GC that will use the GXxor function to flip foreground
2886 pixels into background pixels. */
2890 values
.function
= GXxor
;
2891 values
.foreground
= (f
->output_data
.x
->foreground_pixel
2892 ^ f
->output_data
.x
->background_pixel
);
2894 gc
= XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2895 GCFunction
| GCForeground
, &values
);
2899 /* Get the height not including a menu bar widget. */
2900 int height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, FRAME_LINES (f
));
2901 /* Height of each line to flash. */
2902 int flash_height
= FRAME_LINE_HEIGHT (f
);
2903 /* These will be the left and right margins of the rectangles. */
2904 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
2905 int flash_right
= FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
2909 /* Don't flash the area between a scroll bar and the frame
2910 edge it is next to. */
2911 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f
))
2913 case vertical_scroll_bar_left
:
2914 flash_left
+= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
2917 case vertical_scroll_bar_right
:
2918 flash_right
-= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
2925 width
= flash_right
- flash_left
;
2927 /* If window is tall, flash top and bottom line. */
2928 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
2930 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2932 (FRAME_INTERNAL_BORDER_WIDTH (f
)
2933 + FRAME_TOOL_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
)),
2934 width
, flash_height
);
2935 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2937 (height
- flash_height
2938 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
2939 width
, flash_height
);
2942 /* If it is short, flash it all. */
2943 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2944 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
2945 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
2950 struct timeval wakeup
;
2952 EMACS_GET_TIME (wakeup
);
2954 /* Compute time to wait until, propagating carry from usecs. */
2955 wakeup
.tv_usec
+= 150000;
2956 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
2957 wakeup
.tv_usec
%= 1000000;
2959 /* Keep waiting until past the time wakeup or any input gets
2961 while (! detect_input_pending ())
2963 struct timeval current
;
2964 struct timeval timeout
;
2966 EMACS_GET_TIME (current
);
2968 /* Break if result would be negative. */
2969 if (timeval_subtract (¤t
, wakeup
, current
))
2972 /* How long `select' should wait. */
2974 timeout
.tv_usec
= 10000;
2976 /* Try to wait that long--but we might wake up sooner. */
2977 select (0, NULL
, NULL
, NULL
, &timeout
);
2981 /* If window is tall, flash top and bottom line. */
2982 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
2984 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2986 (FRAME_INTERNAL_BORDER_WIDTH (f
)
2987 + FRAME_TOOL_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
)),
2988 width
, flash_height
);
2989 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2991 (height
- flash_height
2992 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
2993 width
, flash_height
);
2996 /* If it is short, flash it all. */
2997 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), gc
,
2998 flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
2999 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
3001 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
3009 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
3012 /* Make audible bell. */
3017 struct frame
*f
= SELECTED_FRAME ();
3019 if (FRAME_X_DISPLAY (f
))
3021 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
3028 XBell (FRAME_X_DISPLAY (f
), 0);
3029 XFlush (FRAME_X_DISPLAY (f
));
3036 /* Specify how many text lines, from the top of the window,
3037 should be affected by insert-lines and delete-lines operations.
3038 This, and those operations, are used only within an update
3039 that is bounded by calls to x_update_begin and x_update_end. */
3042 XTset_terminal_window (n
)
3045 /* This function intentionally left blank. */
3050 /***********************************************************************
3052 ***********************************************************************/
3054 /* Perform an insert-lines or delete-lines operation, inserting N
3055 lines or deleting -N lines at vertical position VPOS. */
3058 x_ins_del_lines (f
, vpos
, n
)
3066 /* Scroll part of the display as described by RUN. */
3069 x_scroll_run (w
, run
)
3073 struct frame
*f
= XFRAME (w
->frame
);
3074 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
3076 /* Get frame-relative bounding box of the text display area of W,
3077 without mode lines. Include in this box the left and right
3079 window_box (w
, -1, &x
, &y
, &width
, &height
);
3081 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
3082 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
3083 bottom_y
= y
+ height
;
3087 /* Scrolling up. Make sure we don't copy part of the mode
3088 line at the bottom. */
3089 if (from_y
+ run
->height
> bottom_y
)
3090 height
= bottom_y
- from_y
;
3092 height
= run
->height
;
3096 /* Scolling down. Make sure we don't copy over the mode line.
3098 if (to_y
+ run
->height
> bottom_y
)
3099 height
= bottom_y
- to_y
;
3101 height
= run
->height
;
3106 /* Cursor off. Will be switched on again in x_update_window_end. */
3110 XCopyArea (FRAME_X_DISPLAY (f
),
3111 FRAME_X_WINDOW (f
), FRAME_X_WINDOW (f
),
3112 f
->output_data
.x
->normal_gc
,
3122 /***********************************************************************
3124 ***********************************************************************/
3131 /* We used to only do this if Vx_no_window_manager was non-nil, but
3132 the ICCCM (section 4.1.6) says that the window's border pixmap
3133 and border pixel are window attributes which are "private to the
3134 client", so we can always change it to whatever we want. */
3136 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3137 f
->output_data
.x
->border_pixel
);
3139 x_update_cursor (f
, 1);
3143 frame_unhighlight (f
)
3146 /* We used to only do this if Vx_no_window_manager was non-nil, but
3147 the ICCCM (section 4.1.6) says that the window's border pixmap
3148 and border pixel are window attributes which are "private to the
3149 client", so we can always change it to whatever we want. */
3151 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3152 f
->output_data
.x
->border_tile
);
3154 x_update_cursor (f
, 1);
3157 /* The focus has changed. Update the frames as necessary to reflect
3158 the new situation. Note that we can't change the selected frame
3159 here, because the Lisp code we are interrupting might become confused.
3160 Each event gets marked with the frame in which it occurred, so the
3161 Lisp code can tell when the switch took place by examining the events. */
3164 x_new_focus_frame (dpyinfo
, frame
)
3165 struct x_display_info
*dpyinfo
;
3166 struct frame
*frame
;
3168 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
3170 if (frame
!= dpyinfo
->x_focus_frame
)
3172 /* Set this before calling other routines, so that they see
3173 the correct value of x_focus_frame. */
3174 dpyinfo
->x_focus_frame
= frame
;
3176 if (old_focus
&& old_focus
->auto_lower
)
3177 x_lower_frame (old_focus
);
3180 selected_frame
= frame
;
3181 XSETFRAME (XWINDOW (selected_frame
->selected_window
)->frame
,
3183 Fselect_window (selected_frame
->selected_window
, Qnil
);
3184 choose_minibuf_frame ();
3187 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
3188 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
3190 pending_autoraise_frame
= 0;
3193 x_frame_rehighlight (dpyinfo
);
3196 /* Handle FocusIn and FocusOut state changes for FRAME.
3197 If FRAME has focus and there exists more than one frame, puts
3198 a FOCUS_IN_EVENT into *BUFP. */
3201 x_focus_changed (type
, state
, dpyinfo
, frame
, bufp
)
3204 struct x_display_info
*dpyinfo
;
3205 struct frame
*frame
;
3206 struct input_event
*bufp
;
3208 if (type
== FocusIn
)
3210 if (dpyinfo
->x_focus_event_frame
!= frame
)
3212 x_new_focus_frame (dpyinfo
, frame
);
3213 dpyinfo
->x_focus_event_frame
= frame
;
3215 /* Don't stop displaying the initial startup message
3216 for a switch-frame event we don't need. */
3217 if (GC_NILP (Vterminal_frame
)
3218 && GC_CONSP (Vframe_list
)
3219 && !GC_NILP (XCDR (Vframe_list
)))
3221 bufp
->kind
= FOCUS_IN_EVENT
;
3222 XSETFRAME (bufp
->frame_or_window
, frame
);
3226 frame
->output_data
.x
->focus_state
|= state
;
3229 if (FRAME_XIC (frame
))
3230 XSetICFocus (FRAME_XIC (frame
));
3233 else if (type
== FocusOut
)
3235 frame
->output_data
.x
->focus_state
&= ~state
;
3237 if (dpyinfo
->x_focus_event_frame
== frame
)
3239 dpyinfo
->x_focus_event_frame
= 0;
3240 x_new_focus_frame (dpyinfo
, 0);
3244 if (FRAME_XIC (frame
))
3245 XUnsetICFocus (FRAME_XIC (frame
));
3250 /* The focus may have changed. Figure out if it is a real focus change,
3251 by checking both FocusIn/Out and Enter/LeaveNotify events.
3253 Returns FOCUS_IN_EVENT event in *BUFP. */
3256 x_detect_focus_change (dpyinfo
, event
, bufp
)
3257 struct x_display_info
*dpyinfo
;
3259 struct input_event
*bufp
;
3261 struct frame
*frame
;
3263 frame
= x_any_window_to_frame (dpyinfo
, event
->xany
.window
);
3267 switch (event
->type
)
3272 struct frame
*focus_frame
= dpyinfo
->x_focus_event_frame
;
3274 = focus_frame
? focus_frame
->output_data
.x
->focus_state
: 0;
3276 if (event
->xcrossing
.detail
!= NotifyInferior
3277 && event
->xcrossing
.focus
3278 && ! (focus_state
& FOCUS_EXPLICIT
))
3279 x_focus_changed ((event
->type
== EnterNotify
? FocusIn
: FocusOut
),
3281 dpyinfo
, frame
, bufp
);
3287 x_focus_changed (event
->type
,
3288 (event
->xfocus
.detail
== NotifyPointer
?
3289 FOCUS_IMPLICIT
: FOCUS_EXPLICIT
),
3290 dpyinfo
, frame
, bufp
);
3296 /* Handle an event saying the mouse has moved out of an Emacs frame. */
3299 x_mouse_leave (dpyinfo
)
3300 struct x_display_info
*dpyinfo
;
3302 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
3305 /* The focus has changed, or we have redirected a frame's focus to
3306 another frame (this happens when a frame uses a surrogate
3307 mini-buffer frame). Shift the highlight as appropriate.
3309 The FRAME argument doesn't necessarily have anything to do with which
3310 frame is being highlighted or un-highlighted; we only use it to find
3311 the appropriate X display info. */
3314 XTframe_rehighlight (frame
)
3315 struct frame
*frame
;
3317 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
3321 x_frame_rehighlight (dpyinfo
)
3322 struct x_display_info
*dpyinfo
;
3324 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
3326 if (dpyinfo
->x_focus_frame
)
3328 dpyinfo
->x_highlight_frame
3329 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
3330 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
3331 : dpyinfo
->x_focus_frame
);
3332 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
3334 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
3335 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
3339 dpyinfo
->x_highlight_frame
= 0;
3341 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
3344 frame_unhighlight (old_highlight
);
3345 if (dpyinfo
->x_highlight_frame
)
3346 frame_highlight (dpyinfo
->x_highlight_frame
);
3352 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
3354 /* Initialize mode_switch_bit and modifier_meaning. */
3356 x_find_modifier_meanings (dpyinfo
)
3357 struct x_display_info
*dpyinfo
;
3359 int min_code
, max_code
;
3362 XModifierKeymap
*mods
;
3364 dpyinfo
->meta_mod_mask
= 0;
3365 dpyinfo
->shift_lock_mask
= 0;
3366 dpyinfo
->alt_mod_mask
= 0;
3367 dpyinfo
->super_mod_mask
= 0;
3368 dpyinfo
->hyper_mod_mask
= 0;
3371 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
3373 min_code
= dpyinfo
->display
->min_keycode
;
3374 max_code
= dpyinfo
->display
->max_keycode
;
3377 syms
= XGetKeyboardMapping (dpyinfo
->display
,
3378 min_code
, max_code
- min_code
+ 1,
3380 mods
= XGetModifierMapping (dpyinfo
->display
);
3382 /* Scan the modifier table to see which modifier bits the Meta and
3383 Alt keysyms are on. */
3385 int row
, col
; /* The row and column in the modifier table. */
3386 int found_alt_or_meta
;
3388 for (row
= 3; row
< 8; row
++)
3390 found_alt_or_meta
= 0;
3391 for (col
= 0; col
< mods
->max_keypermod
; col
++)
3393 KeyCode code
= mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
3395 /* Zeroes are used for filler. Skip them. */
3399 /* Are any of this keycode's keysyms a meta key? */
3403 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
3405 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
3411 found_alt_or_meta
= 1;
3412 dpyinfo
->meta_mod_mask
|= (1 << row
);
3417 found_alt_or_meta
= 1;
3418 dpyinfo
->alt_mod_mask
|= (1 << row
);
3423 if (!found_alt_or_meta
)
3424 dpyinfo
->hyper_mod_mask
|= (1 << row
);
3425 code_col
= syms_per_code
;
3426 col
= mods
->max_keypermod
;
3431 if (!found_alt_or_meta
)
3432 dpyinfo
->super_mod_mask
|= (1 << row
);
3433 code_col
= syms_per_code
;
3434 col
= mods
->max_keypermod
;
3438 /* Ignore this if it's not on the lock modifier. */
3439 if (!found_alt_or_meta
&& ((1 << row
) == LockMask
))
3440 dpyinfo
->shift_lock_mask
= LockMask
;
3441 code_col
= syms_per_code
;
3442 col
= mods
->max_keypermod
;
3451 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
3452 if (! dpyinfo
->meta_mod_mask
)
3454 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
3455 dpyinfo
->alt_mod_mask
= 0;
3458 /* If some keys are both alt and meta,
3459 make them just meta, not alt. */
3460 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
3462 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
3465 XFree ((char *) syms
);
3466 XFreeModifiermap (mods
);
3469 /* Convert between the modifier bits X uses and the modifier bits
3473 x_x_to_emacs_modifiers (dpyinfo
, state
)
3474 struct x_display_info
*dpyinfo
;
3477 EMACS_UINT mod_meta
= meta_modifier
;
3478 EMACS_UINT mod_alt
= alt_modifier
;
3479 EMACS_UINT mod_hyper
= hyper_modifier
;
3480 EMACS_UINT mod_super
= super_modifier
;
3483 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3484 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
3485 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3486 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
3487 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3488 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
3489 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3490 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
3493 return ( ((state
& (ShiftMask
| dpyinfo
->shift_lock_mask
)) ? shift_modifier
: 0)
3494 | ((state
& ControlMask
) ? ctrl_modifier
: 0)
3495 | ((state
& dpyinfo
->meta_mod_mask
) ? mod_meta
: 0)
3496 | ((state
& dpyinfo
->alt_mod_mask
) ? mod_alt
: 0)
3497 | ((state
& dpyinfo
->super_mod_mask
) ? mod_super
: 0)
3498 | ((state
& dpyinfo
->hyper_mod_mask
) ? mod_hyper
: 0));
3502 x_emacs_to_x_modifiers (dpyinfo
, state
)
3503 struct x_display_info
*dpyinfo
;
3506 EMACS_UINT mod_meta
= meta_modifier
;
3507 EMACS_UINT mod_alt
= alt_modifier
;
3508 EMACS_UINT mod_hyper
= hyper_modifier
;
3509 EMACS_UINT mod_super
= super_modifier
;
3513 tem
= Fget (Vx_alt_keysym
, Qmodifier_value
);
3514 if (! EQ (tem
, Qnil
)) mod_alt
= XUINT (tem
);
3515 tem
= Fget (Vx_meta_keysym
, Qmodifier_value
);
3516 if (! EQ (tem
, Qnil
)) mod_meta
= XUINT (tem
);
3517 tem
= Fget (Vx_hyper_keysym
, Qmodifier_value
);
3518 if (! EQ (tem
, Qnil
)) mod_hyper
= XUINT (tem
);
3519 tem
= Fget (Vx_super_keysym
, Qmodifier_value
);
3520 if (! EQ (tem
, Qnil
)) mod_super
= XUINT (tem
);
3523 return ( ((state
& mod_alt
) ? dpyinfo
->alt_mod_mask
: 0)
3524 | ((state
& mod_super
) ? dpyinfo
->super_mod_mask
: 0)
3525 | ((state
& mod_hyper
) ? dpyinfo
->hyper_mod_mask
: 0)
3526 | ((state
& shift_modifier
) ? ShiftMask
: 0)
3527 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
3528 | ((state
& mod_meta
) ? dpyinfo
->meta_mod_mask
: 0));
3531 /* Convert a keysym to its name. */
3534 x_get_keysym_name (keysym
)
3540 value
= XKeysymToString (keysym
);
3548 /* Mouse clicks and mouse movement. Rah. */
3550 /* Prepare a mouse-event in *RESULT for placement in the input queue.
3552 If the event is a button press, then note that we have grabbed
3556 construct_mouse_click (result
, event
, f
)
3557 struct input_event
*result
;
3558 XButtonEvent
*event
;
3561 /* Make the event type NO_EVENT; we'll change that when we decide
3563 result
->kind
= MOUSE_CLICK_EVENT
;
3564 result
->code
= event
->button
- Button1
;
3565 result
->timestamp
= event
->time
;
3566 result
->modifiers
= (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
3568 | (event
->type
== ButtonRelease
3572 XSETINT (result
->x
, event
->x
);
3573 XSETINT (result
->y
, event
->y
);
3574 XSETFRAME (result
->frame_or_window
, f
);
3580 /* Function to report a mouse movement to the mainstream Emacs code.
3581 The input handler calls this.
3583 We have received a mouse movement event, which is given in *event.
3584 If the mouse is over a different glyph than it was last time, tell
3585 the mainstream emacs code by setting mouse_moved. If not, ask for
3586 another motion event, so we can check again the next time it moves. */
3588 static XMotionEvent last_mouse_motion_event
;
3589 static Lisp_Object last_mouse_motion_frame
;
3592 note_mouse_movement (frame
, event
)
3594 XMotionEvent
*event
;
3596 last_mouse_movement_time
= event
->time
;
3597 last_mouse_motion_event
= *event
;
3598 XSETFRAME (last_mouse_motion_frame
, frame
);
3600 if (event
->window
!= FRAME_X_WINDOW (frame
))
3602 frame
->mouse_moved
= 1;
3603 last_mouse_scroll_bar
= Qnil
;
3604 note_mouse_highlight (frame
, -1, -1);
3607 /* Has the mouse moved off the glyph it was on at the last sighting? */
3608 else if (event
->x
< last_mouse_glyph
.x
3609 || event
->x
>= last_mouse_glyph
.x
+ last_mouse_glyph
.width
3610 || event
->y
< last_mouse_glyph
.y
3611 || event
->y
>= last_mouse_glyph
.y
+ last_mouse_glyph
.height
)
3613 frame
->mouse_moved
= 1;
3614 last_mouse_scroll_bar
= Qnil
;
3615 note_mouse_highlight (frame
, event
->x
, event
->y
);
3620 /************************************************************************
3622 ************************************************************************/
3625 redo_mouse_highlight ()
3627 if (!NILP (last_mouse_motion_frame
)
3628 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
3629 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
3630 last_mouse_motion_event
.x
,
3631 last_mouse_motion_event
.y
);
3635 static int glyph_rect
P_ ((struct frame
*f
, int, int, XRectangle
*));
3638 /* Try to determine frame pixel position and size of the glyph under
3639 frame pixel coordinates X/Y on frame F . Return the position and
3640 size in *RECT. Value is non-zero if we could compute these
3644 glyph_rect (f
, x
, y
, rect
)
3651 struct glyph_row
*r
, *end_row
;
3653 window
= window_from_coordinates (f
, x
, y
, 0, &x
, &y
, 0);
3657 w
= XWINDOW (window
);
3658 r
= MATRIX_FIRST_TEXT_ROW (w
->current_matrix
);
3659 end_row
= r
+ w
->current_matrix
->nrows
- 1;
3661 for (; r
< end_row
&& r
->enabled_p
; ++r
)
3665 struct glyph
*g
= r
->glyphs
[TEXT_AREA
];
3666 struct glyph
*end
= g
+ r
->used
[TEXT_AREA
];
3668 while (g
< end
&& gx
< x
)
3669 gx
+= g
->pixel_width
, ++g
;
3672 rect
->width
= g
->pixel_width
;
3673 rect
->height
= r
->height
;
3674 rect
->x
= WINDOW_TO_FRAME_PIXEL_X (w
, gx
);
3675 rect
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, r
->y
);
3686 /* Return the current position of the mouse.
3687 *FP should be a frame which indicates which display to ask about.
3689 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
3690 and *PART to the frame, window, and scroll bar part that the mouse
3691 is over. Set *X and *Y to the portion and whole of the mouse's
3692 position on the scroll bar.
3694 If the mouse movement started elsewhere, set *FP to the frame the
3695 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
3698 Set *TIME to the server time-stamp for the time at which the mouse
3699 was at this position.
3701 Don't store anything if we don't have a valid set of values to report.
3703 This clears the mouse_moved flag, so we can wait for the next mouse
3707 XTmouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
3710 Lisp_Object
*bar_window
;
3711 enum scroll_bar_part
*part
;
3713 unsigned long *time
;
3719 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
3720 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
3726 Window dummy_window
;
3729 Lisp_Object frame
, tail
;
3731 /* Clear the mouse-moved flag for every frame on this display. */
3732 FOR_EACH_FRAME (tail
, frame
)
3733 if (FRAME_X_P (XFRAME (frame
))
3734 && FRAME_X_DISPLAY (XFRAME (frame
)) == FRAME_X_DISPLAY (*fp
))
3735 XFRAME (frame
)->mouse_moved
= 0;
3737 last_mouse_scroll_bar
= Qnil
;
3739 /* Figure out which root window we're on. */
3740 XQueryPointer (FRAME_X_DISPLAY (*fp
),
3741 DefaultRootWindow (FRAME_X_DISPLAY (*fp
)),
3743 /* The root window which contains the pointer. */
3746 /* Trash which we can't trust if the pointer is on
3747 a different screen. */
3750 /* The position on that root window. */
3753 /* More trash we can't trust. */
3756 /* Modifier keys and pointer buttons, about which
3758 (unsigned int *) &dummy
);
3760 /* Now we have a position on the root; find the innermost window
3761 containing the pointer. */
3765 int parent_x
= 0, parent_y
= 0;
3770 /* XTranslateCoordinates can get errors if the window
3771 structure is changing at the same time this function
3772 is running. So at least we must not crash from them. */
3774 count
= x_catch_errors (FRAME_X_DISPLAY (*fp
));
3776 if (FRAME_X_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
3777 && FRAME_LIVE_P (last_mouse_frame
))
3779 /* If mouse was grabbed on a frame, give coords for that frame
3780 even if the mouse is now outside it. */
3781 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3783 /* From-window, to-window. */
3784 root
, FRAME_X_WINDOW (last_mouse_frame
),
3786 /* From-position, to-position. */
3787 root_x
, root_y
, &win_x
, &win_y
,
3791 f1
= last_mouse_frame
;
3797 XTranslateCoordinates (FRAME_X_DISPLAY (*fp
),
3799 /* From-window, to-window. */
3802 /* From-position, to-position. */
3803 root_x
, root_y
, &win_x
, &win_y
,
3808 if (child
== None
|| child
== win
)
3816 /* Now we know that:
3817 win is the innermost window containing the pointer
3818 (XTC says it has no child containing the pointer),
3819 win_x and win_y are the pointer's position in it
3820 (XTC did this the last time through), and
3821 parent_x and parent_y are the pointer's position in win's parent.
3822 (They are what win_x and win_y were when win was child.
3823 If win is the root window, it has no parent, and
3824 parent_{x,y} are invalid, but that's okay, because we'll
3825 never use them in that case.) */
3827 /* Is win one of our frames? */
3828 f1
= x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp
), win
);
3830 #ifdef USE_X_TOOLKIT
3831 /* If we end up with the menu bar window, say it's not
3834 && f1
->output_data
.x
->menubar_widget
3835 && win
== XtWindow (f1
->output_data
.x
->menubar_widget
))
3837 #endif /* USE_X_TOOLKIT */
3840 if (x_had_errors_p (FRAME_X_DISPLAY (*fp
)))
3843 x_uncatch_errors (FRAME_X_DISPLAY (*fp
), count
);
3845 /* If not, is it one of our scroll bars? */
3848 struct scroll_bar
*bar
;
3850 bar
= x_window_to_scroll_bar (FRAME_X_DISPLAY (*fp
), win
);
3854 f1
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
3860 if (f1
== 0 && insist
> 0)
3861 f1
= SELECTED_FRAME ();
3865 /* Ok, we found a frame. Store all the values.
3866 last_mouse_glyph is a rectangle used to reduce the
3867 generation of mouse events. To not miss any motion
3868 events, we must divide the frame into rectangles of the
3869 size of the smallest character that could be displayed
3870 on it, i.e. into the same rectangles that matrices on
3871 the frame are divided into. */
3873 int width
, height
, gx
, gy
;
3876 if (glyph_rect (f1
, win_x
, win_y
, &rect
))
3877 last_mouse_glyph
= rect
;
3880 width
= FRAME_SMALLEST_CHAR_WIDTH (f1
);
3881 height
= FRAME_SMALLEST_FONT_HEIGHT (f1
);
3885 /* Arrange for the division in FRAME_PIXEL_X_TO_COL etc. to
3886 round down even for negative values. */
3891 gx
= (gx
+ width
- 1) / width
* width
;
3892 gy
= (gy
+ height
- 1) / height
* height
;
3894 last_mouse_glyph
.width
= width
;
3895 last_mouse_glyph
.height
= height
;
3896 last_mouse_glyph
.x
= gx
;
3897 last_mouse_glyph
.y
= gy
;
3903 XSETINT (*x
, win_x
);
3904 XSETINT (*y
, win_y
);
3905 *time
= last_mouse_movement_time
;
3915 /***********************************************************************
3917 ***********************************************************************/
3919 /* Scroll bar support. */
3921 /* Given an X window ID and a DISPLAY, find the struct scroll_bar which
3923 This can be called in GC, so we have to make sure to strip off mark
3926 static struct scroll_bar
*
3927 x_window_to_scroll_bar (display
, window_id
)
3933 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
3934 window_id
= (Window
) xg_get_scroll_id_for_window (display
, window_id
);
3935 #endif /* USE_GTK && USE_TOOLKIT_SCROLL_BARS */
3937 for (tail
= Vframe_list
;
3938 XGCTYPE (tail
) == Lisp_Cons
;
3941 Lisp_Object frame
, bar
, condemned
;
3943 frame
= XCAR (tail
);
3944 /* All elements of Vframe_list should be frames. */
3945 if (! GC_FRAMEP (frame
))
3948 if (! FRAME_X_P (XFRAME (frame
)))
3951 /* Scan this frame's scroll bar list for a scroll bar with the
3953 condemned
= FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame
));
3954 for (bar
= FRAME_SCROLL_BARS (XFRAME (frame
));
3955 /* This trick allows us to search both the ordinary and
3956 condemned scroll bar lists with one loop. */
3957 ! GC_NILP (bar
) || (bar
= condemned
,
3960 bar
= XSCROLL_BAR (bar
)->next
)
3961 if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)) == window_id
&&
3962 FRAME_X_DISPLAY (XFRAME (frame
)) == display
)
3963 return XSCROLL_BAR (bar
);
3970 #if defined USE_LUCID
3972 /* Return the Lucid menu bar WINDOW is part of. Return null
3973 if WINDOW is not part of a menu bar. */
3976 x_window_to_menu_bar (window
)
3981 for (tail
= Vframe_list
;
3982 XGCTYPE (tail
) == Lisp_Cons
;
3985 if (FRAME_X_P (XFRAME (XCAR (tail
))))
3987 Lisp_Object frame
= XCAR (tail
);
3988 Widget menu_bar
= XFRAME (frame
)->output_data
.x
->menubar_widget
;
3990 if (menu_bar
&& xlwmenu_window_p (menu_bar
, window
))
3998 #endif /* USE_LUCID */
4001 /************************************************************************
4003 ************************************************************************/
4005 #ifdef USE_TOOLKIT_SCROLL_BARS
4007 static void x_scroll_bar_to_input_event
P_ ((XEvent
*, struct input_event
*));
4008 static void x_send_scroll_bar_event
P_ ((Lisp_Object
, int, int, int));
4009 static void x_create_toolkit_scroll_bar
P_ ((struct frame
*,
4010 struct scroll_bar
*));
4011 static void x_set_toolkit_scroll_bar_thumb
P_ ((struct scroll_bar
*,
4015 /* Lisp window being scrolled. Set when starting to interact with
4016 a toolkit scroll bar, reset to nil when ending the interaction. */
4018 static Lisp_Object window_being_scrolled
;
4020 /* Last scroll bar part sent in xm_scroll_callback. */
4022 static int last_scroll_bar_part
;
4024 /* Whether this is an Xaw with arrow-scrollbars. This should imply
4025 that movements of 1/20 of the screen size are mapped to up/down. */
4028 /* Id of action hook installed for scroll bars. */
4030 static XtActionHookId action_hook_id
;
4032 static Boolean xaw3d_arrow_scroll
;
4034 /* Whether the drag scrolling maintains the mouse at the top of the
4035 thumb. If not, resizing the thumb needs to be done more carefully
4036 to avoid jerkyness. */
4038 static Boolean xaw3d_pick_top
;
4040 extern void set_vertical_scroll_bar
P_ ((struct window
*));
4042 /* Action hook installed via XtAppAddActionHook when toolkit scroll
4043 bars are used.. The hook is responsible for detecting when
4044 the user ends an interaction with the scroll bar, and generates
4045 a `end-scroll' SCROLL_BAR_CLICK_EVENT' event if so. */
4048 xt_action_hook (widget
, client_data
, action_name
, event
, params
,
4051 XtPointer client_data
;
4055 Cardinal
*num_params
;
4061 scroll_bar_p
= XmIsScrollBar (widget
);
4062 end_action
= "Release";
4063 #else /* !USE_MOTIF i.e. use Xaw */
4064 scroll_bar_p
= XtIsSubclass (widget
, scrollbarWidgetClass
);
4065 end_action
= "EndScroll";
4066 #endif /* USE_MOTIF */
4069 && strcmp (action_name
, end_action
) == 0
4070 && WINDOWP (window_being_scrolled
))
4074 x_send_scroll_bar_event (window_being_scrolled
,
4075 scroll_bar_end_scroll
, 0, 0);
4076 w
= XWINDOW (window_being_scrolled
);
4078 if (!NILP (XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
))
4080 XSCROLL_BAR (w
->vertical_scroll_bar
)->dragging
= Qnil
;
4081 /* The thumb size is incorrect while dragging: fix it. */
4082 set_vertical_scroll_bar (w
);
4084 window_being_scrolled
= Qnil
;
4085 last_scroll_bar_part
= -1;
4087 /* Xt timeouts no longer needed. */
4088 toolkit_scroll_bar_interaction
= 0;
4091 #endif /* not USE_GTK */
4093 /* A vector of windows used for communication between
4094 x_send_scroll_bar_event and x_scroll_bar_to_input_event. */
4096 static struct window
**scroll_bar_windows
;
4097 static int scroll_bar_windows_size
;
4100 /* Send a client message with message type Xatom_Scrollbar for a
4101 scroll action to the frame of WINDOW. PART is a value identifying
4102 the part of the scroll bar that was clicked on. PORTION is the
4103 amount to scroll of a whole of WHOLE. */
4106 x_send_scroll_bar_event (window
, part
, portion
, whole
)
4108 int part
, portion
, whole
;
4111 XClientMessageEvent
*ev
= (XClientMessageEvent
*) &event
;
4112 struct window
*w
= XWINDOW (window
);
4113 struct frame
*f
= XFRAME (w
->frame
);
4118 /* Construct a ClientMessage event to send to the frame. */
4119 ev
->type
= ClientMessage
;
4120 ev
->message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_Scrollbar
;
4121 ev
->display
= FRAME_X_DISPLAY (f
);
4122 ev
->window
= FRAME_X_WINDOW (f
);
4125 /* We can only transfer 32 bits in the XClientMessageEvent, which is
4126 not enough to store a pointer or Lisp_Object on a 64 bit system.
4127 So, store the window in scroll_bar_windows and pass the index
4128 into that array in the event. */
4129 for (i
= 0; i
< scroll_bar_windows_size
; ++i
)
4130 if (scroll_bar_windows
[i
] == NULL
)
4133 if (i
== scroll_bar_windows_size
)
4135 int new_size
= max (10, 2 * scroll_bar_windows_size
);
4136 size_t nbytes
= new_size
* sizeof *scroll_bar_windows
;
4137 size_t old_nbytes
= scroll_bar_windows_size
* sizeof *scroll_bar_windows
;
4139 scroll_bar_windows
= (struct window
**) xrealloc (scroll_bar_windows
,
4141 bzero (&scroll_bar_windows
[i
], nbytes
- old_nbytes
);
4142 scroll_bar_windows_size
= new_size
;
4145 scroll_bar_windows
[i
] = w
;
4146 ev
->data
.l
[0] = (long) i
;
4147 ev
->data
.l
[1] = (long) part
;
4148 ev
->data
.l
[2] = (long) 0;
4149 ev
->data
.l
[3] = (long) portion
;
4150 ev
->data
.l
[4] = (long) whole
;
4152 /* Make Xt timeouts work while the scroll bar is active. */
4153 toolkit_scroll_bar_interaction
= 1;
4155 /* Setting the event mask to zero means that the message will
4156 be sent to the client that created the window, and if that
4157 window no longer exists, no event will be sent. */
4158 XSendEvent (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), False
, 0, &event
);
4163 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
4167 x_scroll_bar_to_input_event (event
, ievent
)
4169 struct input_event
*ievent
;
4171 XClientMessageEvent
*ev
= (XClientMessageEvent
*) event
;
4176 w
= scroll_bar_windows
[ev
->data
.l
[0]];
4177 scroll_bar_windows
[ev
->data
.l
[0]] = NULL
;
4179 XSETWINDOW (window
, w
);
4180 f
= XFRAME (w
->frame
);
4182 ievent
->kind
= SCROLL_BAR_CLICK_EVENT
;
4183 ievent
->frame_or_window
= window
;
4186 ievent
->timestamp
= CurrentTime
;
4188 ievent
->timestamp
= XtLastTimestampProcessed (FRAME_X_DISPLAY (f
));
4190 ievent
->part
= ev
->data
.l
[1];
4191 ievent
->code
= ev
->data
.l
[2];
4192 ievent
->x
= make_number ((int) ev
->data
.l
[3]);
4193 ievent
->y
= make_number ((int) ev
->data
.l
[4]);
4194 ievent
->modifiers
= 0;
4200 /* Minimum and maximum values used for Motif scroll bars. */
4202 #define XM_SB_MAX 10000000
4205 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
4206 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
4207 CALL_DATA is a pointer to a XmScrollBarCallbackStruct. */
4210 xm_scroll_callback (widget
, client_data
, call_data
)
4212 XtPointer client_data
, call_data
;
4214 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4215 XmScrollBarCallbackStruct
*cs
= (XmScrollBarCallbackStruct
*) call_data
;
4216 int part
= -1, whole
= 0, portion
= 0;
4220 case XmCR_DECREMENT
:
4221 bar
->dragging
= Qnil
;
4222 part
= scroll_bar_up_arrow
;
4225 case XmCR_INCREMENT
:
4226 bar
->dragging
= Qnil
;
4227 part
= scroll_bar_down_arrow
;
4230 case XmCR_PAGE_DECREMENT
:
4231 bar
->dragging
= Qnil
;
4232 part
= scroll_bar_above_handle
;
4235 case XmCR_PAGE_INCREMENT
:
4236 bar
->dragging
= Qnil
;
4237 part
= scroll_bar_below_handle
;
4241 bar
->dragging
= Qnil
;
4242 part
= scroll_bar_to_top
;
4245 case XmCR_TO_BOTTOM
:
4246 bar
->dragging
= Qnil
;
4247 part
= scroll_bar_to_bottom
;
4254 /* Get the slider size. */
4256 XtVaGetValues (widget
, XmNsliderSize
, &slider_size
, NULL
);
4259 whole
= XM_SB_MAX
- slider_size
;
4260 portion
= min (cs
->value
, whole
);
4261 part
= scroll_bar_handle
;
4262 bar
->dragging
= make_number (cs
->value
);
4266 case XmCR_VALUE_CHANGED
:
4272 window_being_scrolled
= bar
->window
;
4273 last_scroll_bar_part
= part
;
4274 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4279 #else /* !USE_MOTIF, i.e. Xaw or GTK */
4281 /* Scroll bar callback for GTK scroll bars. WIDGET is the scroll
4282 bar widget. DATA is a pointer to the scroll_bar structure. */
4285 xg_scroll_callback (widget
, data
)
4289 struct scroll_bar
*bar
= (struct scroll_bar
*) data
;
4295 int part
= -1, whole
= 0, portion
= 0;
4296 GtkAdjustment
*adj
= GTK_ADJUSTMENT (gtk_range_get_adjustment (widget
));
4298 position
= gtk_adjustment_get_value (adj
);
4300 p
= g_object_get_data (G_OBJECT (widget
), XG_LAST_SB_DATA
);
4303 p
= (gdouble
*) xmalloc (sizeof (gdouble
));
4305 g_object_set_data (G_OBJECT (widget
), XG_LAST_SB_DATA
, p
);
4311 if (xg_ignore_gtk_scrollbar
) return;
4313 diff
= (int) (position
- previous
);
4315 if (diff
== (int) adj
->step_increment
)
4317 part
= scroll_bar_down_arrow
;
4318 bar
->dragging
= Qnil
;
4320 else if (-diff
== (int) adj
->step_increment
)
4322 part
= scroll_bar_up_arrow
;
4323 bar
->dragging
= Qnil
;
4325 else if (diff
== (int) adj
->page_increment
)
4327 part
= scroll_bar_below_handle
;
4328 bar
->dragging
= Qnil
;
4330 else if (-diff
== (int) adj
->page_increment
)
4332 part
= scroll_bar_above_handle
;
4333 bar
->dragging
= Qnil
;
4337 part
= scroll_bar_handle
;
4338 whole
= adj
->upper
- adj
->page_size
;
4339 portion
= min ((int)position
, whole
);
4340 bar
->dragging
= make_number ((int)portion
);
4345 window_being_scrolled
= bar
->window
;
4346 last_scroll_bar_part
= part
;
4347 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4351 #else /* not USE_GTK */
4353 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
4354 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
4355 scroll bar struct. CALL_DATA is a pointer to a float saying where
4359 xaw_jump_callback (widget
, client_data
, call_data
)
4361 XtPointer client_data
, call_data
;
4363 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4364 float top
= *(float *) call_data
;
4366 int whole
, portion
, height
;
4369 /* Get the size of the thumb, a value between 0 and 1. */
4371 XtVaGetValues (widget
, XtNshown
, &shown
, XtNheight
, &height
, NULL
);
4375 portion
= shown
< 1 ? top
* whole
: 0;
4377 if (shown
< 1 && (abs (top
+ shown
- 1) < 1.0/height
))
4378 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
4379 the bottom, so we force the scrolling whenever we see that we're
4380 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
4381 we try to ensure that we always stay two pixels away from the
4383 part
= scroll_bar_down_arrow
;
4385 part
= scroll_bar_handle
;
4387 window_being_scrolled
= bar
->window
;
4388 bar
->dragging
= make_number (portion
);
4389 last_scroll_bar_part
= part
;
4390 x_send_scroll_bar_event (bar
->window
, part
, portion
, whole
);
4394 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
4395 i.e. line or page up or down. WIDGET is the Xaw scroll bar
4396 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
4397 the scroll bar. CALL_DATA is an integer specifying the action that
4398 has taken place. Its magnitude is in the range 0..height of the
4399 scroll bar. Negative values mean scroll towards buffer start.
4400 Values < height of scroll bar mean line-wise movement. */
4403 xaw_scroll_callback (widget
, client_data
, call_data
)
4405 XtPointer client_data
, call_data
;
4407 struct scroll_bar
*bar
= (struct scroll_bar
*) client_data
;
4408 /* The position really is stored cast to a pointer. */
4409 int position
= (long) call_data
;
4413 /* Get the height of the scroll bar. */
4415 XtVaGetValues (widget
, XtNheight
, &height
, NULL
);
4418 if (abs (position
) >= height
)
4419 part
= (position
< 0) ? scroll_bar_above_handle
: scroll_bar_below_handle
;
4421 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
4422 it maps line-movement to call_data = max(5, height/20). */
4423 else if (xaw3d_arrow_scroll
&& abs (position
) <= max (5, height
/ 20))
4424 part
= (position
< 0) ? scroll_bar_up_arrow
: scroll_bar_down_arrow
;
4426 part
= scroll_bar_move_ratio
;
4428 window_being_scrolled
= bar
->window
;
4429 bar
->dragging
= Qnil
;
4430 last_scroll_bar_part
= part
;
4431 x_send_scroll_bar_event (bar
->window
, part
, position
, height
);
4434 #endif /* not USE_GTK */
4435 #endif /* not USE_MOTIF */
4437 #define SCROLL_BAR_NAME "verticalScrollBar"
4439 /* Create the widget for scroll bar BAR on frame F. Record the widget
4440 and X window of the scroll bar in BAR. */
4444 x_create_toolkit_scroll_bar (f
, bar
)
4446 struct scroll_bar
*bar
;
4448 char *scroll_bar_name
= SCROLL_BAR_NAME
;
4451 xg_create_scroll_bar (f
, bar
, G_CALLBACK (xg_scroll_callback
),
4456 #else /* not USE_GTK */
4459 x_create_toolkit_scroll_bar (f
, bar
)
4461 struct scroll_bar
*bar
;
4467 char *scroll_bar_name
= SCROLL_BAR_NAME
;
4468 unsigned long pixel
;
4473 /* Set resources. Create the widget. */
4474 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4475 XtSetArg (av
[ac
], XmNminimum
, 0); ++ac
;
4476 XtSetArg (av
[ac
], XmNmaximum
, XM_SB_MAX
); ++ac
;
4477 XtSetArg (av
[ac
], XmNorientation
, XmVERTICAL
); ++ac
;
4478 XtSetArg (av
[ac
], XmNprocessingDirection
, XmMAX_ON_BOTTOM
), ++ac
;
4479 XtSetArg (av
[ac
], XmNincrement
, 1); ++ac
;
4480 XtSetArg (av
[ac
], XmNpageIncrement
, 1); ++ac
;
4482 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4485 XtSetArg (av
[ac
], XmNforeground
, pixel
);
4489 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4492 XtSetArg (av
[ac
], XmNbackground
, pixel
);
4496 widget
= XmCreateScrollBar (f
->output_data
.x
->edit_widget
,
4497 scroll_bar_name
, av
, ac
);
4499 /* Add one callback for everything that can happen. */
4500 XtAddCallback (widget
, XmNdecrementCallback
, xm_scroll_callback
,
4502 XtAddCallback (widget
, XmNdragCallback
, xm_scroll_callback
,
4504 XtAddCallback (widget
, XmNincrementCallback
, xm_scroll_callback
,
4506 XtAddCallback (widget
, XmNpageDecrementCallback
, xm_scroll_callback
,
4508 XtAddCallback (widget
, XmNpageIncrementCallback
, xm_scroll_callback
,
4510 XtAddCallback (widget
, XmNtoBottomCallback
, xm_scroll_callback
,
4512 XtAddCallback (widget
, XmNtoTopCallback
, xm_scroll_callback
,
4515 /* Realize the widget. Only after that is the X window created. */
4516 XtRealizeWidget (widget
);
4518 /* Set the cursor to an arrow. I didn't find a resource to do that.
4519 And I'm wondering why it hasn't an arrow cursor by default. */
4520 XDefineCursor (XtDisplay (widget
), XtWindow (widget
),
4521 f
->output_data
.x
->nontext_cursor
);
4523 #else /* !USE_MOTIF i.e. use Xaw */
4525 /* Set resources. Create the widget. The background of the
4526 Xaw3d scroll bar widget is a little bit light for my taste.
4527 We don't alter it here to let users change it according
4528 to their taste with `emacs*verticalScrollBar.background: xxx'. */
4529 XtSetArg (av
[ac
], XtNmappedWhenManaged
, False
); ++ac
;
4530 XtSetArg (av
[ac
], XtNorientation
, XtorientVertical
); ++ac
;
4531 /* For smoother scrolling with Xaw3d -sm */
4532 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
4534 pixel
= f
->output_data
.x
->scroll_bar_foreground_pixel
;
4537 XtSetArg (av
[ac
], XtNforeground
, pixel
);
4541 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4544 XtSetArg (av
[ac
], XtNbackground
, pixel
);
4548 /* Top/bottom shadow colors. */
4550 /* Allocate them, if necessary. */
4551 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1)
4553 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4554 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
4555 &pixel
, 1.2, 0x8000))
4557 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= pixel
;
4559 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4561 pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4562 if (!x_alloc_lighter_color (f
, FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
4563 &pixel
, 0.6, 0x4000))
4565 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= pixel
;
4568 #ifdef XtNbeNiceToColormap
4569 /* Tell the toolkit about them. */
4570 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
== -1
4571 || f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
== -1)
4572 /* We tried to allocate a color for the top/bottom shadow, and
4573 failed, so tell Xaw3d to use dithering instead. */
4575 XtSetArg (av
[ac
], XtNbeNiceToColormap
, True
);
4579 /* Tell what colors Xaw3d should use for the top/bottom shadow, to
4580 be more consistent with other emacs 3d colors, and since Xaw3d is
4581 not good at dealing with allocation failure. */
4583 /* This tells Xaw3d to use real colors instead of dithering for
4585 XtSetArg (av
[ac
], XtNbeNiceToColormap
, False
);
4588 /* Specify the colors. */
4589 pixel
= f
->output_data
.x
->scroll_bar_top_shadow_pixel
;
4592 XtSetArg (av
[ac
], XtNtopShadowPixel
, pixel
);
4595 pixel
= f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
;
4598 XtSetArg (av
[ac
], XtNbottomShadowPixel
, pixel
);
4604 widget
= XtCreateWidget (scroll_bar_name
, scrollbarWidgetClass
,
4605 f
->output_data
.x
->edit_widget
, av
, ac
);
4609 char *val
= initial
;
4610 XtVaGetValues (widget
, XtNscrollVCursor
, (XtPointer
) &val
,
4611 #ifdef XtNarrowScrollbars
4612 XtNarrowScrollbars
, (XtPointer
) &xaw3d_arrow_scroll
,
4614 XtNpickTop
, (XtPointer
) &xaw3d_pick_top
, NULL
);
4615 if (xaw3d_arrow_scroll
|| val
== initial
)
4616 { /* ARROW_SCROLL */
4617 xaw3d_arrow_scroll
= True
;
4618 /* Isn't that just a personal preference ? --Stef */
4619 XtVaSetValues (widget
, XtNcursorName
, "top_left_arrow", NULL
);
4623 /* Define callbacks. */
4624 XtAddCallback (widget
, XtNjumpProc
, xaw_jump_callback
, (XtPointer
) bar
);
4625 XtAddCallback (widget
, XtNscrollProc
, xaw_scroll_callback
,
4628 /* Realize the widget. Only after that is the X window created. */
4629 XtRealizeWidget (widget
);
4631 #endif /* !USE_MOTIF */
4633 /* Install an action hook that lets us detect when the user
4634 finishes interacting with a scroll bar. */
4635 if (action_hook_id
== 0)
4636 action_hook_id
= XtAppAddActionHook (Xt_app_con
, xt_action_hook
, 0);
4638 /* Remember X window and widget in the scroll bar vector. */
4639 SET_SCROLL_BAR_X_WIDGET (bar
, widget
);
4640 xwindow
= XtWindow (widget
);
4641 SET_SCROLL_BAR_X_WINDOW (bar
, xwindow
);
4645 #endif /* not USE_GTK */
4648 /* Set the thumb size and position of scroll bar BAR. We are currently
4649 displaying PORTION out of a whole WHOLE, and our position POSITION. */
4653 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
4654 struct scroll_bar
*bar
;
4655 int portion
, position
, whole
;
4657 xg_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
4660 #else /* not USE_GTK */
4662 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
4663 struct scroll_bar
*bar
;
4664 int portion
, position
, whole
;
4666 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4667 Widget widget
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4674 /* We use an estimate of 30 chars per line rather than the real
4675 `portion' value. This has the disadvantage that the thumb size
4676 is not very representative, but it makes our life a lot easier.
4677 Otherwise, we have to constantly adjust the thumb size, which
4678 we can't always do quickly enough: while dragging, the size of
4679 the thumb might prevent the user from dragging the thumb all the
4680 way to the end. but Motif and some versions of Xaw3d don't allow
4681 updating the thumb size while dragging. Also, even if we can update
4682 its size, the update will often happen too late.
4683 If you don't believe it, check out revision 1.650 of xterm.c to see
4684 what hoops we were going through and the still poor behavior we got. */
4685 portion
= WINDOW_TOTAL_LINES (XWINDOW (bar
->window
)) * 30;
4686 /* When the thumb is at the bottom, position == whole.
4687 So we need to increase `whole' to make space for the thumb. */
4694 top
= (float) position
/ whole
;
4695 shown
= (float) portion
/ whole
;
4698 if (NILP (bar
->dragging
))
4702 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
4703 is the scroll bar's maximum and MIN is the scroll bar's minimum
4705 size
= shown
* XM_SB_MAX
;
4706 size
= min (size
, XM_SB_MAX
);
4707 size
= max (size
, 1);
4709 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
4710 value
= top
* XM_SB_MAX
;
4711 value
= min (value
, XM_SB_MAX
- size
);
4713 XmScrollBarSetValues (widget
, value
, size
, 0, 0, False
);
4715 #else /* !USE_MOTIF i.e. use Xaw */
4721 top
= (float) position
/ whole
;
4722 shown
= (float) portion
/ whole
;
4726 float old_top
, old_shown
;
4728 XtVaGetValues (widget
,
4729 XtNtopOfThumb
, &old_top
,
4730 XtNshown
, &old_shown
,
4734 /* Massage the top+shown values. */
4735 if (NILP (bar
->dragging
) || last_scroll_bar_part
== scroll_bar_down_arrow
)
4736 top
= max (0, min (1, top
));
4739 /* Keep two pixels available for moving the thumb down. */
4740 shown
= max (0, min (1 - top
- (2.0 / height
), shown
));
4742 /* If the call to XawScrollbarSetThumb below doesn't seem to work,
4743 check that your system's configuration file contains a define
4744 for `NARROWPROTO'. See s/freebsd.h for an example. */
4745 if (top
!= old_top
|| shown
!= old_shown
)
4747 if (NILP (bar
->dragging
))
4748 XawScrollbarSetThumb (widget
, top
, shown
);
4751 /* Try to make the scrolling a tad smoother. */
4752 if (!xaw3d_pick_top
)
4753 shown
= min (shown
, old_shown
);
4755 XawScrollbarSetThumb (widget
, top
, shown
);
4759 #endif /* !USE_MOTIF */
4763 #endif /* not USE_GTK */
4765 #endif /* USE_TOOLKIT_SCROLL_BARS */
4769 /************************************************************************
4770 Scroll bars, general
4771 ************************************************************************/
4773 /* Create a scroll bar and return the scroll bar vector for it. W is
4774 the Emacs window on which to create the scroll bar. TOP, LEFT,
4775 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
4778 static struct scroll_bar
*
4779 x_scroll_bar_create (w
, top
, left
, width
, height
)
4781 int top
, left
, width
, height
;
4783 struct frame
*f
= XFRAME (w
->frame
);
4784 struct scroll_bar
*bar
4785 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
4789 #ifdef USE_TOOLKIT_SCROLL_BARS
4790 x_create_toolkit_scroll_bar (f
, bar
);
4791 #else /* not USE_TOOLKIT_SCROLL_BARS */
4793 XSetWindowAttributes a
;
4797 a
.background_pixel
= f
->output_data
.x
->scroll_bar_background_pixel
;
4798 if (a
.background_pixel
== -1)
4799 a
.background_pixel
= f
->output_data
.x
->background_pixel
;
4801 a
.event_mask
= (ButtonPressMask
| ButtonReleaseMask
4802 | ButtonMotionMask
| PointerMotionHintMask
4804 a
.cursor
= FRAME_X_DISPLAY_INFO (f
)->vertical_scroll_bar_cursor
;
4806 mask
= (CWBackPixel
| CWEventMask
| CWCursor
);
4808 /* Clear the area of W that will serve as a scroll bar. This is
4809 for the case that a window has been split horizontally. In
4810 this case, no clear_frame is generated to reduce flickering. */
4811 if (width
> 0 && height
> 0)
4812 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4814 window_box_height (w
), False
);
4816 window
= XCreateWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
4817 /* Position and size of scroll bar. */
4818 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4820 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4822 /* Border width, depth, class, and visual. */
4829 SET_SCROLL_BAR_X_WINDOW (bar
, window
);
4831 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4833 XSETWINDOW (bar
->window
, w
);
4834 XSETINT (bar
->top
, top
);
4835 XSETINT (bar
->left
, left
);
4836 XSETINT (bar
->width
, width
);
4837 XSETINT (bar
->height
, height
);
4838 XSETINT (bar
->start
, 0);
4839 XSETINT (bar
->end
, 0);
4840 bar
->dragging
= Qnil
;
4842 /* Add bar to its frame's list of scroll bars. */
4843 bar
->next
= FRAME_SCROLL_BARS (f
);
4845 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
4846 if (!NILP (bar
->next
))
4847 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
4849 /* Map the window/widget. */
4850 #ifdef USE_TOOLKIT_SCROLL_BARS
4853 xg_update_scrollbar_pos (f
,
4854 SCROLL_BAR_X_WINDOW (bar
),
4856 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4857 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4859 xg_show_scroll_bar (SCROLL_BAR_X_WINDOW (bar
));
4860 #else /* not USE_GTK */
4861 Widget scroll_bar
= SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
);
4862 XtConfigureWidget (scroll_bar
,
4863 left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
4865 width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
4866 max (height
, 1), 0);
4867 XtMapWidget (scroll_bar
);
4868 #endif /* not USE_GTK */
4870 #else /* not USE_TOOLKIT_SCROLL_BARS */
4871 XMapRaised (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
4872 #endif /* not USE_TOOLKIT_SCROLL_BARS */
4879 /* Draw BAR's handle in the proper position.
4881 If the handle is already drawn from START to END, don't bother
4882 redrawing it, unless REBUILD is non-zero; in that case, always
4883 redraw it. (REBUILD is handy for drawing the handle after expose
4886 Normally, we want to constrain the start and end of the handle to
4887 fit inside its rectangle, but if the user is dragging the scroll
4888 bar handle, we want to let them drag it down all the way, so that
4889 the bar's top is as far down as it goes; otherwise, there's no way
4890 to move to the very end of the buffer. */
4892 #ifndef USE_TOOLKIT_SCROLL_BARS
4895 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
4896 struct scroll_bar
*bar
;
4900 int dragging
= ! NILP (bar
->dragging
);
4901 Window w
= SCROLL_BAR_X_WINDOW (bar
);
4902 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
4903 GC gc
= f
->output_data
.x
->normal_gc
;
4905 /* If the display is already accurate, do nothing. */
4907 && start
== XINT (bar
->start
)
4908 && end
== XINT (bar
->end
))
4914 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, XINT (bar
->width
));
4915 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
4916 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
4918 /* Make sure the values are reasonable, and try to preserve
4919 the distance between start and end. */
4921 int length
= end
- start
;
4925 else if (start
> top_range
)
4927 end
= start
+ length
;
4931 else if (end
> top_range
&& ! dragging
)
4935 /* Store the adjusted setting in the scroll bar. */
4936 XSETINT (bar
->start
, start
);
4937 XSETINT (bar
->end
, end
);
4939 /* Clip the end position, just for display. */
4940 if (end
> top_range
)
4943 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
4944 below top positions, to make sure the handle is always at least
4945 that many pixels tall. */
4946 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
4948 /* Draw the empty space above the handle. Note that we can't clear
4949 zero-height areas; that means "clear to end of window." */
4951 x_clear_area (FRAME_X_DISPLAY (f
), w
,
4952 /* x, y, width, height, and exposures. */
4953 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4954 VERTICAL_SCROLL_BAR_TOP_BORDER
,
4955 inside_width
, start
,
4958 /* Change to proper foreground color if one is specified. */
4959 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
4960 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
4961 f
->output_data
.x
->scroll_bar_foreground_pixel
);
4963 /* Draw the handle itself. */
4964 XFillRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
4965 /* x, y, width, height */
4966 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4967 VERTICAL_SCROLL_BAR_TOP_BORDER
+ start
,
4968 inside_width
, end
- start
);
4970 /* Restore the foreground color of the GC if we changed it above. */
4971 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
4972 XSetForeground (FRAME_X_DISPLAY (f
), gc
,
4973 f
->output_data
.x
->foreground_pixel
);
4975 /* Draw the empty space below the handle. Note that we can't
4976 clear zero-height areas; that means "clear to end of window." */
4977 if (end
< inside_height
)
4978 x_clear_area (FRAME_X_DISPLAY (f
), w
,
4979 /* x, y, width, height, and exposures. */
4980 VERTICAL_SCROLL_BAR_LEFT_BORDER
,
4981 VERTICAL_SCROLL_BAR_TOP_BORDER
+ end
,
4982 inside_width
, inside_height
- end
,
4990 #endif /* !USE_TOOLKIT_SCROLL_BARS */
4992 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
4996 x_scroll_bar_remove (bar
)
4997 struct scroll_bar
*bar
;
4999 struct frame
*f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5002 #ifdef USE_TOOLKIT_SCROLL_BARS
5004 xg_remove_scroll_bar (f
, SCROLL_BAR_X_WINDOW (bar
));
5005 #else /* not USE_GTK */
5006 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
));
5007 #endif /* not USE_GTK */
5009 XDestroyWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
));
5012 /* Disassociate this scroll bar from its window. */
5013 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
5019 /* Set the handle of the vertical scroll bar for WINDOW to indicate
5020 that we are displaying PORTION characters out of a total of WHOLE
5021 characters, starting at POSITION. If WINDOW has no scroll bar,
5025 XTset_vertical_scroll_bar (w
, portion
, whole
, position
)
5027 int portion
, whole
, position
;
5029 struct frame
*f
= XFRAME (w
->frame
);
5030 struct scroll_bar
*bar
;
5031 int top
, height
, left
, sb_left
, width
, sb_width
;
5032 int window_y
, window_height
;
5034 /* Get window dimensions. */
5035 window_box (w
, -1, 0, &window_y
, 0, &window_height
);
5037 width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
5038 height
= window_height
;
5040 /* Compute the left edge of the scroll bar area. */
5041 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
5043 /* Compute the width of the scroll bar which might be less than
5044 the width of the area reserved for the scroll bar. */
5045 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
) > 0)
5046 sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
5050 /* Compute the left edge of the scroll bar. */
5051 #ifdef USE_TOOLKIT_SCROLL_BARS
5052 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
5054 (WINDOW_RIGHTMOST_P (w
)
5055 ? width
- sb_width
- (width
- sb_width
) / 2
5059 (WINDOW_LEFTMOST_P (w
)
5060 ? (width
- sb_width
) / 2
5061 : width
- sb_width
));
5063 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
5064 sb_left
= left
+ width
- sb_width
;
5069 /* Does the scroll bar exist yet? */
5070 if (NILP (w
->vertical_scroll_bar
))
5072 if (width
> 0 && height
> 0)
5075 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5076 left
, top
, width
, height
, False
);
5080 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
);
5084 /* It may just need to be moved and resized. */
5085 unsigned int mask
= 0;
5087 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5091 if (sb_left
!= XINT (bar
->left
))
5093 if (top
!= XINT (bar
->top
))
5095 if (sb_width
!= XINT (bar
->width
))
5097 if (height
!= XINT (bar
->height
))
5100 #ifdef USE_TOOLKIT_SCROLL_BARS
5102 /* Move/size the scroll bar widget. */
5105 /* Since toolkit scroll bars are smaller than the space reserved
5106 for them on the frame, we have to clear "under" them. */
5107 if (width
> 0 && height
> 0)
5108 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5109 left
, top
, width
, height
, False
);
5111 xg_update_scrollbar_pos (f
,
5112 SCROLL_BAR_X_WINDOW (bar
),
5114 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5115 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
*2,
5117 #else /* not USE_GTK */
5118 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f
), bar
),
5119 sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5121 sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
5122 max (height
, 1), 0);
5123 #endif /* not USE_GTK */
5125 #else /* not USE_TOOLKIT_SCROLL_BARS */
5127 /* Clear areas not covered by the scroll bar because of
5128 VERTICAL_SCROLL_BAR_WIDTH_TRIM. */
5129 if (VERTICAL_SCROLL_BAR_WIDTH_TRIM
)
5131 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5132 left
, top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5134 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5135 left
+ width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5136 top
, VERTICAL_SCROLL_BAR_WIDTH_TRIM
,
5140 /* Clear areas not covered by the scroll bar because it's not as
5141 wide as the area reserved for it. This makes sure a
5142 previous mode line display is cleared after C-x 2 C-x 1, for
5145 int area_width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
5146 int rest
= area_width
- sb_width
;
5147 if (rest
> 0 && height
> 0)
5149 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
5150 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5151 left
+ area_width
- rest
, top
,
5152 rest
, height
, False
);
5154 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
5155 left
, top
, rest
, height
, False
);
5159 /* Move/size the scroll bar window. */
5164 wc
.x
= sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5166 wc
.width
= sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2;
5168 XConfigureWindow (FRAME_X_DISPLAY (f
), SCROLL_BAR_X_WINDOW (bar
),
5172 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5174 /* Remember new settings. */
5175 XSETINT (bar
->left
, sb_left
);
5176 XSETINT (bar
->top
, top
);
5177 XSETINT (bar
->width
, sb_width
);
5178 XSETINT (bar
->height
, height
);
5183 #ifdef USE_TOOLKIT_SCROLL_BARS
5184 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
5185 #else /* not USE_TOOLKIT_SCROLL_BARS */
5186 /* Set the scroll bar's current state, unless we're currently being
5188 if (NILP (bar
->dragging
))
5190 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
5193 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
5196 int start
= ((double) position
* top_range
) / whole
;
5197 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
5198 x_scroll_bar_set_handle (bar
, start
, end
, 0);
5201 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5203 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
5207 /* The following three hooks are used when we're doing a thorough
5208 redisplay of the frame. We don't explicitly know which scroll bars
5209 are going to be deleted, because keeping track of when windows go
5210 away is a real pain - "Can you say set-window-configuration, boys
5211 and girls?" Instead, we just assert at the beginning of redisplay
5212 that *all* scroll bars are to be removed, and then save a scroll bar
5213 from the fiery pit when we actually redisplay its window. */
5215 /* Arrange for all scroll bars on FRAME to be removed at the next call
5216 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
5217 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
5220 XTcondemn_scroll_bars (frame
)
5223 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
5224 while (! NILP (FRAME_SCROLL_BARS (frame
)))
5227 bar
= FRAME_SCROLL_BARS (frame
);
5228 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
5229 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
5230 XSCROLL_BAR (bar
)->prev
= Qnil
;
5231 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
5232 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
5233 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
5238 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
5239 Note that WINDOW isn't necessarily condemned at all. */
5242 XTredeem_scroll_bar (window
)
5243 struct window
*window
;
5245 struct scroll_bar
*bar
;
5248 /* We can't redeem this window's scroll bar if it doesn't have one. */
5249 if (NILP (window
->vertical_scroll_bar
))
5252 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
5254 /* Unlink it from the condemned list. */
5255 f
= XFRAME (WINDOW_FRAME (window
));
5256 if (NILP (bar
->prev
))
5258 /* If the prev pointer is nil, it must be the first in one of
5260 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
5261 /* It's not condemned. Everything's fine. */
5263 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
5264 window
->vertical_scroll_bar
))
5265 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
5267 /* If its prev pointer is nil, it must be at the front of
5268 one or the other! */
5272 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
5274 if (! NILP (bar
->next
))
5275 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
5277 bar
->next
= FRAME_SCROLL_BARS (f
);
5279 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
5280 if (! NILP (bar
->next
))
5281 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
5284 /* Remove all scroll bars on FRAME that haven't been saved since the
5285 last call to `*condemn_scroll_bars_hook'. */
5288 XTjudge_scroll_bars (f
)
5291 Lisp_Object bar
, next
;
5293 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
5295 /* Clear out the condemned list now so we won't try to process any
5296 more events on the hapless scroll bars. */
5297 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
5299 for (; ! NILP (bar
); bar
= next
)
5301 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
5303 x_scroll_bar_remove (b
);
5306 b
->next
= b
->prev
= Qnil
;
5309 /* Now there should be no references to the condemned scroll bars,
5310 and they should get garbage-collected. */
5314 #ifndef USE_TOOLKIT_SCROLL_BARS
5315 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
5316 is a no-op when using toolkit scroll bars.
5318 This may be called from a signal handler, so we have to ignore GC
5322 x_scroll_bar_expose (bar
, event
)
5323 struct scroll_bar
*bar
;
5326 Window w
= SCROLL_BAR_X_WINDOW (bar
);
5327 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5328 GC gc
= f
->output_data
.x
->normal_gc
;
5329 int width_trim
= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
5333 x_scroll_bar_set_handle (bar
, XINT (bar
->start
), XINT (bar
->end
), 1);
5335 /* Draw a one-pixel border just inside the edges of the scroll bar. */
5336 XDrawRectangle (FRAME_X_DISPLAY (f
), w
, gc
,
5338 /* x, y, width, height */
5340 XINT (bar
->width
) - 1 - width_trim
- width_trim
,
5341 XINT (bar
->height
) - 1);
5346 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5348 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
5349 is set to something other than NO_EVENT, it is enqueued.
5351 This may be called from a signal handler, so we have to ignore GC
5356 x_scroll_bar_handle_click (bar
, event
, emacs_event
)
5357 struct scroll_bar
*bar
;
5359 struct input_event
*emacs_event
;
5361 if (! GC_WINDOWP (bar
->window
))
5364 emacs_event
->kind
= SCROLL_BAR_CLICK_EVENT
;
5365 emacs_event
->code
= event
->xbutton
.button
- Button1
;
5366 emacs_event
->modifiers
5367 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
5368 (XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)))),
5369 event
->xbutton
.state
)
5370 | (event
->type
== ButtonRelease
5373 emacs_event
->frame_or_window
= bar
->window
;
5374 emacs_event
->arg
= Qnil
;
5375 emacs_event
->timestamp
= event
->xbutton
.time
;
5378 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5380 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
5383 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
5384 int y
= event
->xbutton
.y
- VERTICAL_SCROLL_BAR_TOP_BORDER
;
5387 if (y
> top_range
) y
= top_range
;
5389 if (y
< XINT (bar
->start
))
5390 emacs_event
->part
= scroll_bar_above_handle
;
5391 else if (y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5392 emacs_event
->part
= scroll_bar_handle
;
5394 emacs_event
->part
= scroll_bar_below_handle
;
5396 /* Just because the user has clicked on the handle doesn't mean
5397 they want to drag it. Lisp code needs to be able to decide
5398 whether or not we're dragging. */
5400 /* If the user has just clicked on the handle, record where they're
5402 if (event
->type
== ButtonPress
5403 && emacs_event
->part
== scroll_bar_handle
)
5404 XSETINT (bar
->dragging
, y
- XINT (bar
->start
));
5407 #ifndef USE_TOOLKIT_SCROLL_BARS
5408 /* If the user has released the handle, set it to its final position. */
5409 if (event
->type
== ButtonRelease
5410 && ! NILP (bar
->dragging
))
5412 int new_start
= y
- XINT (bar
->dragging
);
5413 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
5415 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5416 bar
->dragging
= Qnil
;
5420 /* Same deal here as the other #if 0. */
5422 /* Clicks on the handle are always reported as occurring at the top of
5424 if (emacs_event
->part
== scroll_bar_handle
)
5425 emacs_event
->x
= bar
->start
;
5427 XSETINT (emacs_event
->x
, y
);
5429 XSETINT (emacs_event
->x
, y
);
5432 XSETINT (emacs_event
->y
, top_range
);
5436 #ifndef USE_TOOLKIT_SCROLL_BARS
5438 /* Handle some mouse motion while someone is dragging the scroll bar.
5440 This may be called from a signal handler, so we have to ignore GC
5444 x_scroll_bar_note_movement (bar
, event
)
5445 struct scroll_bar
*bar
;
5448 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
5450 last_mouse_movement_time
= event
->xmotion
.time
;
5453 XSETVECTOR (last_mouse_scroll_bar
, bar
);
5455 /* If we're dragging the bar, display it. */
5456 if (! GC_NILP (bar
->dragging
))
5458 /* Where should the handle be now? */
5459 int new_start
= event
->xmotion
.y
- XINT (bar
->dragging
);
5461 if (new_start
!= XINT (bar
->start
))
5463 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
5465 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5470 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5472 /* Return information to the user about the current position of the mouse
5473 on the scroll bar. */
5476 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
5478 Lisp_Object
*bar_window
;
5479 enum scroll_bar_part
*part
;
5481 unsigned long *time
;
5483 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
5484 Window w
= SCROLL_BAR_X_WINDOW (bar
);
5485 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5487 Window dummy_window
;
5489 unsigned int dummy_mask
;
5493 /* Get the mouse's position relative to the scroll bar window, and
5495 if (! XQueryPointer (FRAME_X_DISPLAY (f
), w
,
5497 /* Root, child, root x and root y. */
5498 &dummy_window
, &dummy_window
,
5499 &dummy_coord
, &dummy_coord
,
5501 /* Position relative to scroll bar. */
5504 /* Mouse buttons and modifier keys. */
5511 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
5514 = VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
5516 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
5518 if (! NILP (bar
->dragging
))
5519 win_y
-= XINT (bar
->dragging
);
5523 if (win_y
> top_range
)
5527 *bar_window
= bar
->window
;
5529 if (! NILP (bar
->dragging
))
5530 *part
= scroll_bar_handle
;
5531 else if (win_y
< XINT (bar
->start
))
5532 *part
= scroll_bar_above_handle
;
5533 else if (win_y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5534 *part
= scroll_bar_handle
;
5536 *part
= scroll_bar_below_handle
;
5538 XSETINT (*x
, win_y
);
5539 XSETINT (*y
, top_range
);
5542 last_mouse_scroll_bar
= Qnil
;
5545 *time
= last_mouse_movement_time
;
5551 /* The screen has been cleared so we may have changed foreground or
5552 background colors, and the scroll bars may need to be redrawn.
5553 Clear out the scroll bars, and ask for expose events, so we can
5557 x_scroll_bar_clear (f
)
5560 #ifndef USE_TOOLKIT_SCROLL_BARS
5563 /* We can have scroll bars even if this is 0,
5564 if we just turned off scroll bar mode.
5565 But in that case we should not clear them. */
5566 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5567 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
5568 bar
= XSCROLL_BAR (bar
)->next
)
5569 XClearArea (FRAME_X_DISPLAY (f
),
5570 SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
)),
5572 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5576 /* The main X event-reading loop - XTread_socket. */
5579 /* Time stamp of enter window event. This is only used by XTread_socket,
5580 but we have to put it out here, since static variables within functions
5581 sometimes don't work. */
5583 static Time enter_timestamp
;
5586 /* This holds the state XLookupString needs to implement dead keys
5587 and other tricks known as "compose processing". _X Window System_
5588 says that a portable program can't use this, but Stephen Gildea assures
5589 me that letting the compiler initialize it to zeros will work okay.
5591 This must be defined outside of XTread_socket, for the same reasons
5592 given for enter_timestamp, above. */
5594 static XComposeStatus compose_status
;
5596 /* Record the last 100 characters stored
5597 to help debug the loss-of-chars-during-GC problem. */
5599 static int temp_index
;
5600 static short temp_buffer
[100];
5602 #define STORE_KEYSYM_FOR_DEBUG(keysym) \
5603 if (temp_index == sizeof temp_buffer / sizeof (short)) \
5605 temp_buffer[temp_index++] = (keysym)
5607 /* Set this to nonzero to fake an "X I/O error"
5608 on a particular display. */
5610 struct x_display_info
*XTread_socket_fake_io_error
;
5612 /* When we find no input here, we occasionally do a no-op command
5613 to verify that the X server is still running and we can still talk with it.
5614 We try all the open displays, one by one.
5615 This variable is used for cycling thru the displays. */
5617 static struct x_display_info
*next_noop_dpyinfo
;
5619 #define SET_SAVED_MENU_EVENT(size) \
5622 if (f->output_data.x->saved_menu_event == 0) \
5623 f->output_data.x->saved_menu_event \
5624 = (XEvent *) xmalloc (sizeof (XEvent)); \
5625 bcopy (&event, f->output_data.x->saved_menu_event, size); \
5626 inev.ie.kind = MENU_BAR_ACTIVATE_EVENT; \
5627 XSETFRAME (inev.ie.frame_or_window, f); \
5631 #define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
5632 #define SET_SAVED_KEY_EVENT SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
5642 /* Filter events for the current X input method.
5643 DPYINFO is the display this event is for.
5644 EVENT is the X event to filter.
5646 Returns non-zero if the event was filtered, caller shall not process
5648 Returns zero if event is wasn't filtered. */
5652 x_filter_event (dpyinfo
, event
)
5653 struct x_display_info
*dpyinfo
;
5656 /* XFilterEvent returns non-zero if the input method has
5657 consumed the event. We pass the frame's X window to
5658 XFilterEvent because that's the one for which the IC
5661 struct frame
*f1
= x_any_window_to_frame (dpyinfo
,
5662 event
->xclient
.window
);
5664 return XFilterEvent (event
, f1
? FRAME_X_WINDOW (f1
) : None
);
5669 static int current_count
;
5670 static int current_finish
;
5671 static struct input_event
*current_hold_quit
;
5673 /* This is the filter function invoked by the GTK event loop.
5674 It is invoked before the XEvent is translated to a GdkEvent,
5675 so we have a chance to act on the event before GTK. */
5676 static GdkFilterReturn
5677 event_handler_gdk (gxev
, ev
, data
)
5682 XEvent
*xev
= (XEvent
*) gxev
;
5684 if (current_count
>= 0)
5686 struct x_display_info
*dpyinfo
;
5688 dpyinfo
= x_display_info_for_display (xev
->xany
.display
);
5691 /* Filter events for the current X input method.
5692 GTK calls XFilterEvent but not for key press and release,
5693 so we do it here. */
5694 if (xev
->type
== KeyPress
|| xev
->type
== KeyRelease
)
5695 if (dpyinfo
&& x_filter_event (dpyinfo
, xev
))
5696 return GDK_FILTER_REMOVE
;
5700 current_finish
= X_EVENT_NORMAL
;
5704 handle_one_xevent (dpyinfo
, xev
, ¤t_finish
,
5709 current_finish
= x_dispatch_event (xev
, xev
->xany
.display
);
5711 if (current_finish
== X_EVENT_GOTO_OUT
|| current_finish
== X_EVENT_DROP
)
5712 return GDK_FILTER_REMOVE
;
5714 return GDK_FILTER_CONTINUE
;
5716 #endif /* USE_GTK */
5719 /* Handles the XEvent EVENT on display DPYINFO.
5721 *FINISH is X_EVENT_GOTO_OUT if caller should stop reading events.
5722 *FINISH is zero if caller should continue reading events.
5723 *FINISH is X_EVENT_DROP if event should not be passed to the toolkit.
5725 We return the number of characters stored into the buffer. */
5728 handle_one_xevent (dpyinfo
, eventp
, finish
, hold_quit
)
5729 struct x_display_info
*dpyinfo
;
5732 struct input_event
*hold_quit
;
5735 struct input_event ie
;
5736 struct selection_input_event sie
;
5742 struct coding_system coding
;
5743 XEvent event
= *eventp
;
5745 *finish
= X_EVENT_NORMAL
;
5747 EVENT_INIT (inev
.ie
);
5748 inev
.ie
.kind
= NO_EVENT
;
5755 if (event
.xclient
.message_type
5756 == dpyinfo
->Xatom_wm_protocols
5757 && event
.xclient
.format
== 32)
5759 if (event
.xclient
.data
.l
[0]
5760 == dpyinfo
->Xatom_wm_take_focus
)
5762 /* Use x_any_window_to_frame because this
5763 could be the shell widget window
5764 if the frame has no title bar. */
5765 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5767 /* Not quite sure this is needed -pd */
5768 if (f
&& FRAME_XIC (f
))
5769 XSetICFocus (FRAME_XIC (f
));
5771 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
5772 instructs the WM to set the input focus automatically for
5773 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
5774 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
5775 it has set the focus. So, XSetInputFocus below is not
5778 The call to XSetInputFocus below has also caused trouble. In
5779 cases where the XSetInputFocus done by the WM and the one
5780 below are temporally close (on a fast machine), the call
5781 below can generate additional FocusIn events which confuse
5784 /* Since we set WM_TAKE_FOCUS, we must call
5785 XSetInputFocus explicitly. But not if f is null,
5786 since that might be an event for a deleted frame. */
5789 Display
*d
= event
.xclient
.display
;
5790 /* Catch and ignore errors, in case window has been
5791 iconified by a window manager such as GWM. */
5792 int count
= x_catch_errors (d
);
5793 XSetInputFocus (d
, event
.xclient
.window
,
5794 /* The ICCCM says this is
5795 the only valid choice. */
5797 event
.xclient
.data
.l
[1]);
5798 /* This is needed to detect the error
5799 if there is an error. */
5801 x_uncatch_errors (d
, count
);
5803 /* Not certain about handling scroll bars here */
5808 if (event
.xclient
.data
.l
[0]
5809 == dpyinfo
->Xatom_wm_save_yourself
)
5811 /* Save state modify the WM_COMMAND property to
5812 something which can reinstate us. This notifies
5813 the session manager, who's looking for such a
5814 PropertyNotify. Can restart processing when
5815 a keyboard or mouse event arrives. */
5816 /* If we have a session manager, don't set this.
5817 KDE will then start two Emacsen, one for the
5818 session manager and one for this. */
5820 if (! x_session_have_connection ())
5823 f
= x_top_window_to_frame (dpyinfo
,
5824 event
.xclient
.window
);
5825 /* This is just so we only give real data once
5826 for a single Emacs process. */
5827 if (f
== SELECTED_FRAME ())
5828 XSetCommand (FRAME_X_DISPLAY (f
),
5829 event
.xclient
.window
,
5830 initial_argv
, initial_argc
);
5832 XSetCommand (FRAME_X_DISPLAY (f
),
5833 event
.xclient
.window
,
5839 if (event
.xclient
.data
.l
[0]
5840 == dpyinfo
->Xatom_wm_delete_window
)
5842 f
= x_any_window_to_frame (dpyinfo
,
5843 event
.xclient
.window
);
5845 goto OTHER
; /* May be a dialog that is to be removed */
5847 inev
.ie
.kind
= DELETE_WINDOW_EVENT
;
5848 XSETFRAME (inev
.ie
.frame_or_window
, f
);
5855 if (event
.xclient
.message_type
5856 == dpyinfo
->Xatom_wm_configure_denied
)
5861 if (event
.xclient
.message_type
5862 == dpyinfo
->Xatom_wm_window_moved
)
5865 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
5867 new_x
= event
.xclient
.data
.s
[0];
5868 new_y
= event
.xclient
.data
.s
[1];
5872 f
->left_pos
= new_x
;
5879 if (event
.xclient
.message_type
5880 == dpyinfo
->Xatom_editres
)
5882 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5883 _XEditResCheckMessages (f
->output_data
.x
->widget
, NULL
,
5887 #endif /* HACK_EDITRES */
5889 if ((event
.xclient
.message_type
5890 == dpyinfo
->Xatom_DONE
)
5891 || (event
.xclient
.message_type
5892 == dpyinfo
->Xatom_PAGE
))
5894 /* Ghostview job completed. Kill it. We could
5895 reply with "Next" if we received "Page", but we
5896 currently never do because we are interested in
5897 images, only, which should have 1 page. */
5898 Pixmap pixmap
= (Pixmap
) event
.xclient
.data
.l
[1];
5899 f
= x_window_to_frame (dpyinfo
, event
.xclient
.window
);
5900 x_kill_gs_process (pixmap
, f
);
5901 expose_frame (f
, 0, 0, 0, 0);
5905 #ifdef USE_TOOLKIT_SCROLL_BARS
5906 /* Scroll bar callbacks send a ClientMessage from which
5907 we construct an input_event. */
5908 if (event
.xclient
.message_type
5909 == dpyinfo
->Xatom_Scrollbar
)
5911 x_scroll_bar_to_input_event (&event
, &inev
.ie
);
5912 *finish
= X_EVENT_GOTO_OUT
;
5915 #endif /* USE_TOOLKIT_SCROLL_BARS */
5917 f
= x_any_window_to_frame (dpyinfo
, event
.xclient
.window
);
5922 if (x_handle_dnd_message (f
, &event
.xclient
, dpyinfo
, &inev
.ie
))
5923 *finish
= X_EVENT_DROP
;
5927 case SelectionNotify
:
5928 #ifdef USE_X_TOOLKIT
5929 if (! x_window_to_frame (dpyinfo
, event
.xselection
.requestor
))
5931 #endif /* not USE_X_TOOLKIT */
5932 x_handle_selection_notify (&event
.xselection
);
5935 case SelectionClear
: /* Someone has grabbed ownership. */
5936 #ifdef USE_X_TOOLKIT
5937 if (! x_window_to_frame (dpyinfo
, event
.xselectionclear
.window
))
5939 #endif /* USE_X_TOOLKIT */
5941 XSelectionClearEvent
*eventp
= (XSelectionClearEvent
*) &event
;
5943 inev
.ie
.kind
= SELECTION_CLEAR_EVENT
;
5944 SELECTION_EVENT_DISPLAY (&inev
.sie
) = eventp
->display
;
5945 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
5946 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
5947 inev
.ie
.frame_or_window
= Qnil
;
5951 case SelectionRequest
: /* Someone wants our selection. */
5952 #ifdef USE_X_TOOLKIT
5953 if (!x_window_to_frame (dpyinfo
, event
.xselectionrequest
.owner
))
5955 #endif /* USE_X_TOOLKIT */
5957 XSelectionRequestEvent
*eventp
5958 = (XSelectionRequestEvent
*) &event
;
5960 inev
.ie
.kind
= SELECTION_REQUEST_EVENT
;
5961 SELECTION_EVENT_DISPLAY (&inev
.sie
) = eventp
->display
;
5962 SELECTION_EVENT_REQUESTOR (&inev
.sie
) = eventp
->requestor
;
5963 SELECTION_EVENT_SELECTION (&inev
.sie
) = eventp
->selection
;
5964 SELECTION_EVENT_TARGET (&inev
.sie
) = eventp
->target
;
5965 SELECTION_EVENT_PROPERTY (&inev
.sie
) = eventp
->property
;
5966 SELECTION_EVENT_TIME (&inev
.sie
) = eventp
->time
;
5967 inev
.ie
.frame_or_window
= Qnil
;
5971 case PropertyNotify
:
5972 #if 0 /* This is plain wrong. In the case that we are waiting for a
5973 PropertyNotify used as an ACK in incremental selection
5974 transfer, the property will be on the receiver's window. */
5975 #if defined USE_X_TOOLKIT
5976 if (!x_any_window_to_frame (dpyinfo
, event
.xproperty
.window
))
5980 x_handle_property_notify (&event
.xproperty
);
5983 case ReparentNotify
:
5984 f
= x_top_window_to_frame (dpyinfo
, event
.xreparent
.window
);
5988 f
->output_data
.x
->parent_desc
= event
.xreparent
.parent
;
5989 x_real_positions (f
, &x
, &y
);
5993 /* Perhaps reparented due to a WM restart. Reset this. */
5994 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_UNKNOWN
;
5999 f
= x_window_to_frame (dpyinfo
, event
.xexpose
.window
);
6002 x_check_fullscreen (f
);
6005 /* This seems to be needed for GTK 2.6. */
6006 x_clear_area (event
.xexpose
.display
,
6007 event
.xexpose
.window
,
6008 event
.xexpose
.x
, event
.xexpose
.y
,
6009 event
.xexpose
.width
, event
.xexpose
.height
,
6012 if (f
->async_visible
== 0)
6014 f
->async_visible
= 1;
6015 f
->async_iconified
= 0;
6016 f
->output_data
.x
->has_been_visible
= 1;
6017 SET_FRAME_GARBAGED (f
);
6021 event
.xexpose
.x
, event
.xexpose
.y
,
6022 event
.xexpose
.width
, event
.xexpose
.height
);
6026 #ifndef USE_TOOLKIT_SCROLL_BARS
6027 struct scroll_bar
*bar
;
6029 #if defined USE_LUCID
6030 /* Submenus of the Lucid menu bar aren't widgets
6031 themselves, so there's no way to dispatch events
6032 to them. Recognize this case separately. */
6035 = x_window_to_menu_bar (event
.xexpose
.window
);
6037 xlwmenu_redisplay (widget
);
6039 #endif /* USE_LUCID */
6041 #ifdef USE_TOOLKIT_SCROLL_BARS
6042 /* Dispatch event to the widget. */
6044 #else /* not USE_TOOLKIT_SCROLL_BARS */
6045 bar
= x_window_to_scroll_bar (event
.xexpose
.display
,
6046 event
.xexpose
.window
);
6049 x_scroll_bar_expose (bar
, &event
);
6050 #ifdef USE_X_TOOLKIT
6053 #endif /* USE_X_TOOLKIT */
6054 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6058 case GraphicsExpose
: /* This occurs when an XCopyArea's
6059 source area was obscured or not
6061 f
= x_window_to_frame (dpyinfo
, event
.xgraphicsexpose
.drawable
);
6065 event
.xgraphicsexpose
.x
, event
.xgraphicsexpose
.y
,
6066 event
.xgraphicsexpose
.width
,
6067 event
.xgraphicsexpose
.height
);
6069 #ifdef USE_X_TOOLKIT
6072 #endif /* USE_X_TOOLKIT */
6075 case NoExpose
: /* This occurs when an XCopyArea's
6076 source area was completely
6081 /* Redo the mouse-highlight after the tooltip has gone. */
6082 if (event
.xmap
.window
== tip_window
)
6085 redo_mouse_highlight ();
6088 f
= x_top_window_to_frame (dpyinfo
, event
.xunmap
.window
);
6089 if (f
) /* F may no longer exist if
6090 the frame was deleted. */
6092 /* While a frame is unmapped, display generation is
6093 disabled; you don't want to spend time updating a
6094 display that won't ever be seen. */
6095 f
->async_visible
= 0;
6096 /* We can't distinguish, from the event, whether the window
6097 has become iconified or invisible. So assume, if it
6098 was previously visible, than now it is iconified.
6099 But x_make_frame_invisible clears both
6100 the visible flag and the iconified flag;
6101 and that way, we know the window is not iconified now. */
6102 if (FRAME_VISIBLE_P (f
) || FRAME_ICONIFIED_P (f
))
6104 f
->async_iconified
= 1;
6106 inev
.ie
.kind
= ICONIFY_EVENT
;
6107 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6113 if (event
.xmap
.window
== tip_window
)
6114 /* The tooltip has been drawn already. Avoid
6115 the SET_FRAME_GARBAGED below. */
6118 /* We use x_top_window_to_frame because map events can
6119 come for sub-windows and they don't mean that the
6120 frame is visible. */
6121 f
= x_top_window_to_frame (dpyinfo
, event
.xmap
.window
);
6124 /* wait_reading_process_output will notice this and update
6125 the frame's display structures.
6126 If we where iconified, we should not set garbaged,
6127 because that stops redrawing on Expose events. This looks
6128 bad if we are called from a recursive event loop
6129 (x_dispatch_event), for example when a dialog is up. */
6130 if (! f
->async_iconified
)
6131 SET_FRAME_GARBAGED (f
);
6133 f
->async_visible
= 1;
6134 f
->async_iconified
= 0;
6135 f
->output_data
.x
->has_been_visible
= 1;
6139 inev
.ie
.kind
= DEICONIFY_EVENT
;
6140 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6142 else if (! NILP (Vframe_list
)
6143 && ! NILP (XCDR (Vframe_list
)))
6144 /* Force a redisplay sooner or later
6145 to update the frame titles
6146 in case this is the second frame. */
6147 record_asynch_buffer_change ();
6153 ignore_next_mouse_click_timeout
= 0;
6155 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6156 /* Dispatch KeyPress events when in menu. */
6157 if (popup_activated ())
6161 f
= x_any_window_to_frame (dpyinfo
, event
.xkey
.window
);
6163 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
))
6165 clear_mouse_face (dpyinfo
);
6166 dpyinfo
->mouse_face_hidden
= 1;
6169 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
6172 /* Scroll bars consume key events, but we want
6173 the keys to go to the scroll bar's frame. */
6174 Widget widget
= XtWindowToWidget (dpyinfo
->display
,
6176 if (widget
&& XmIsScrollBar (widget
))
6178 widget
= XtParent (widget
);
6179 f
= x_any_window_to_frame (dpyinfo
, XtWindow (widget
));
6182 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
6186 KeySym keysym
, orig_keysym
;
6187 /* al%imercury@uunet.uu.net says that making this 81
6188 instead of 80 fixed a bug whereby meta chars made
6191 It seems that some version of XmbLookupString has
6192 a bug of not returning XBufferOverflow in
6193 status_return even if the input is too long to
6194 fit in 81 bytes. So, we must prepare sufficient
6195 bytes for copy_buffer. 513 bytes (256 chars for
6196 two-byte character set) seems to be a fairly good
6197 approximation. -- 2000.8.10 handa@etl.go.jp */
6198 unsigned char copy_buffer
[513];
6199 unsigned char *copy_bufptr
= copy_buffer
;
6200 int copy_bufsiz
= sizeof (copy_buffer
);
6202 Lisp_Object coding_system
= Qlatin_1
;
6206 /* Don't pass keys to GTK. A Tab will shift focus to the
6207 tool bar in GTK 2.4. Keys will still go to menus and
6208 dialogs because in that case popup_activated is TRUE
6210 *finish
= X_EVENT_DROP
;
6214 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f
),
6215 extra_keyboard_modifiers
);
6216 modifiers
= event
.xkey
.state
;
6218 /* This will have to go some day... */
6220 /* make_lispy_event turns chars into control chars.
6221 Don't do it here because XLookupString is too eager. */
6222 event
.xkey
.state
&= ~ControlMask
;
6223 event
.xkey
.state
&= ~(dpyinfo
->meta_mod_mask
6224 | dpyinfo
->super_mod_mask
6225 | dpyinfo
->hyper_mod_mask
6226 | dpyinfo
->alt_mod_mask
);
6228 /* In case Meta is ComposeCharacter,
6229 clear its status. According to Markus Ehrnsperger
6230 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
6231 this enables ComposeCharacter to work whether or
6232 not it is combined with Meta. */
6233 if (modifiers
& dpyinfo
->meta_mod_mask
)
6234 bzero (&compose_status
, sizeof (compose_status
));
6239 Status status_return
;
6241 coding_system
= Vlocale_coding_system
;
6242 nbytes
= XmbLookupString (FRAME_XIC (f
),
6243 &event
.xkey
, copy_bufptr
,
6244 copy_bufsiz
, &keysym
,
6246 if (status_return
== XBufferOverflow
)
6248 copy_bufsiz
= nbytes
+ 1;
6249 copy_bufptr
= (char *) alloca (copy_bufsiz
);
6250 nbytes
= XmbLookupString (FRAME_XIC (f
),
6251 &event
.xkey
, copy_bufptr
,
6252 copy_bufsiz
, &keysym
,
6255 /* Xutf8LookupString is a new but already deprecated interface. -stef */
6256 #if 0 && defined X_HAVE_UTF8_STRING
6257 else if (status_return
== XLookupKeySym
)
6258 { /* Try again but with utf-8. */
6259 coding_system
= Qutf_8
;
6260 nbytes
= Xutf8LookupString (FRAME_XIC (f
),
6261 &event
.xkey
, copy_bufptr
,
6262 copy_bufsiz
, &keysym
,
6264 if (status_return
== XBufferOverflow
)
6266 copy_bufsiz
= nbytes
+ 1;
6267 copy_bufptr
= (char *) alloca (copy_bufsiz
);
6268 nbytes
= Xutf8LookupString (FRAME_XIC (f
),
6271 copy_bufsiz
, &keysym
,
6277 if (status_return
== XLookupNone
)
6279 else if (status_return
== XLookupChars
)
6284 else if (status_return
!= XLookupKeySym
6285 && status_return
!= XLookupBoth
)
6289 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
6290 copy_bufsiz
, &keysym
,
6293 nbytes
= XLookupString (&event
.xkey
, copy_bufptr
,
6294 copy_bufsiz
, &keysym
,
6298 /* If not using XIM/XIC, and a compose sequence is in progress,
6299 we break here. Otherwise, chars_matched is always 0. */
6300 if (compose_status
.chars_matched
> 0 && nbytes
== 0)
6303 bzero (&compose_status
, sizeof (compose_status
));
6304 orig_keysym
= keysym
;
6306 /* Common for all keysym input events. */
6307 XSETFRAME (inev
.ie
.frame_or_window
, f
);
6309 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
), modifiers
);
6310 inev
.ie
.timestamp
= event
.xkey
.time
;
6312 /* First deal with keysyms which have defined
6313 translations to characters. */
6314 if (keysym
>= 32 && keysym
< 128)
6315 /* Avoid explicitly decoding each ASCII character. */
6317 inev
.ie
.kind
= ASCII_KEYSTROKE_EVENT
;
6318 inev
.ie
.code
= keysym
;
6322 /* Now non-ASCII. */
6323 if (HASH_TABLE_P (Vx_keysym_table
)
6324 && (NATNUMP (c
= Fgethash (make_number (keysym
),
6328 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (XFASTINT (c
))
6329 ? ASCII_KEYSTROKE_EVENT
6330 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6331 inev
.ie
.code
= XFASTINT (c
);
6335 /* Random non-modifier sorts of keysyms. */
6336 if (((keysym
>= XK_BackSpace
&& keysym
<= XK_Escape
)
6337 || keysym
== XK_Delete
6338 #ifdef XK_ISO_Left_Tab
6339 || (keysym
>= XK_ISO_Left_Tab
6340 && keysym
<= XK_ISO_Enter
)
6342 || IsCursorKey (keysym
) /* 0xff50 <= x < 0xff60 */
6343 || IsMiscFunctionKey (keysym
) /* 0xff60 <= x < VARIES */
6345 /* This recognizes the "extended function
6346 keys". It seems there's no cleaner way.
6347 Test IsModifierKey to avoid handling
6348 mode_switch incorrectly. */
6349 || ((unsigned) (keysym
) >= XK_Select
6350 && (unsigned)(keysym
) < XK_KP_Space
)
6352 #ifdef XK_dead_circumflex
6353 || orig_keysym
== XK_dead_circumflex
6355 #ifdef XK_dead_grave
6356 || orig_keysym
== XK_dead_grave
6358 #ifdef XK_dead_tilde
6359 || orig_keysym
== XK_dead_tilde
6361 #ifdef XK_dead_diaeresis
6362 || orig_keysym
== XK_dead_diaeresis
6364 #ifdef XK_dead_macron
6365 || orig_keysym
== XK_dead_macron
6367 #ifdef XK_dead_degree
6368 || orig_keysym
== XK_dead_degree
6370 #ifdef XK_dead_acute
6371 || orig_keysym
== XK_dead_acute
6373 #ifdef XK_dead_cedilla
6374 || orig_keysym
== XK_dead_cedilla
6376 #ifdef XK_dead_breve
6377 || orig_keysym
== XK_dead_breve
6379 #ifdef XK_dead_ogonek
6380 || orig_keysym
== XK_dead_ogonek
6382 #ifdef XK_dead_caron
6383 || orig_keysym
== XK_dead_caron
6385 #ifdef XK_dead_doubleacute
6386 || orig_keysym
== XK_dead_doubleacute
6388 #ifdef XK_dead_abovedot
6389 || orig_keysym
== XK_dead_abovedot
6391 || IsKeypadKey (keysym
) /* 0xff80 <= x < 0xffbe */
6392 || IsFunctionKey (keysym
) /* 0xffbe <= x < 0xffe1 */
6393 /* Any "vendor-specific" key is ok. */
6394 || (orig_keysym
& (1 << 28))
6395 || (keysym
!= NoSymbol
&& nbytes
== 0))
6396 && ! (IsModifierKey (orig_keysym
)
6398 #ifdef XK_Mode_switch
6399 || ((unsigned)(orig_keysym
) == XK_Mode_switch
)
6402 || ((unsigned)(orig_keysym
) == XK_Num_Lock
)
6404 #endif /* not HAVE_X11R5 */
6405 /* The symbols from XK_ISO_Lock
6406 to XK_ISO_Last_Group_Lock
6407 don't have real modifiers but
6408 should be treated similarly to
6409 Mode_switch by Emacs. */
6410 #if defined XK_ISO_Lock && defined XK_ISO_Last_Group_Lock
6411 || ((unsigned)(orig_keysym
)
6413 && (unsigned)(orig_keysym
)
6414 <= XK_ISO_Last_Group_Lock
)
6418 STORE_KEYSYM_FOR_DEBUG (keysym
);
6419 /* make_lispy_event will convert this to a symbolic
6421 inev
.ie
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
6422 inev
.ie
.code
= keysym
;
6426 { /* Raw bytes, not keysym. */
6431 /* The input should be decoded with `coding_system'
6432 which depends on which X*LookupString function
6433 we used just above and the locale. */
6434 setup_coding_system (coding_system
, &coding
);
6435 coding
.src_multibyte
= 0;
6436 coding
.dst_multibyte
= 1;
6437 /* The input is converted to events, thus we can't
6438 handle composition. Anyway, there's no XIM that
6439 gives us composition information. */
6440 coding
.composing
= COMPOSITION_DISABLED
;
6442 for (i
= 0; i
< nbytes
; i
++)
6444 STORE_KEYSYM_FOR_DEBUG (copy_bufptr
[i
]);
6448 /* Decode the input data. */
6452 require
= decoding_buffer_size (&coding
, nbytes
);
6453 p
= (unsigned char *) alloca (require
);
6454 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
6455 /* We explicitly disable composition handling because
6456 key data should not contain any composition sequence. */
6457 coding
.composing
= COMPOSITION_DISABLED
;
6458 decode_coding (&coding
, copy_bufptr
, p
, nbytes
, require
);
6459 nbytes
= coding
.produced
;
6460 nchars
= coding
.produced_char
;
6464 /* Convert the input data to a sequence of
6465 character events. */
6466 for (i
= 0; i
< nbytes
; i
+= len
)
6468 if (nchars
== nbytes
)
6469 c
= copy_bufptr
[i
], len
= 1;
6471 c
= STRING_CHAR_AND_LENGTH (copy_bufptr
+ i
,
6473 inev
.ie
.kind
= (SINGLE_BYTE_CHAR_P (c
)
6474 ? ASCII_KEYSTROKE_EVENT
6475 : MULTIBYTE_CHAR_KEYSTROKE_EVENT
);
6477 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
6480 /* Previous code updated count by nchars rather than nbytes,
6481 but that seems bogus to me. ++kfs */
6484 inev
.ie
.kind
= NO_EVENT
; /* Already stored above. */
6486 if (keysym
== NoSymbol
)
6492 /* Don't dispatch this event since XtDispatchEvent calls
6493 XFilterEvent, and two calls in a row may freeze the
6502 /* Don't dispatch this event since XtDispatchEvent calls
6503 XFilterEvent, and two calls in a row may freeze the
6511 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6513 f
= x_any_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
6515 if (f
&& x_mouse_click_focus_ignore_position
)
6516 ignore_next_mouse_click_timeout
= event
.xmotion
.time
+ 200;
6519 if (event
.xcrossing
.focus
)
6521 /* Avoid nasty pop/raise loops. */
6522 if (f
&& (!(f
->auto_raise
)
6524 || (event
.xcrossing
.time
- enter_timestamp
) > 500))
6526 x_new_focus_frame (dpyinfo
, f
);
6527 enter_timestamp
= event
.xcrossing
.time
;
6530 else if (f
== dpyinfo
->x_focus_frame
)
6531 x_new_focus_frame (dpyinfo
, 0);
6534 /* EnterNotify counts as mouse movement,
6535 so update things that depend on mouse position. */
6536 if (f
&& !f
->output_data
.x
->hourglass_p
)
6537 note_mouse_movement (f
, &event
.xmotion
);
6541 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6545 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6547 f
= x_top_window_to_frame (dpyinfo
, event
.xcrossing
.window
);
6550 if (f
== dpyinfo
->mouse_face_mouse_frame
)
6552 /* If we move outside the frame, then we're
6553 certainly no longer on any text in the frame. */
6554 clear_mouse_face (dpyinfo
);
6555 dpyinfo
->mouse_face_mouse_frame
= 0;
6558 /* Generate a nil HELP_EVENT to cancel a help-echo.
6559 Do it only if there's something to cancel.
6560 Otherwise, the startup message is cleared when
6561 the mouse leaves the frame. */
6562 if (any_help_event_p
)
6568 x_detect_focus_change (dpyinfo
, &event
, &inev
.ie
);
6573 previous_help_echo_string
= help_echo_string
;
6574 help_echo_string
= help_echo_object
= help_echo_window
= Qnil
;
6577 if (dpyinfo
->grabbed
&& last_mouse_frame
6578 && FRAME_LIVE_P (last_mouse_frame
))
6579 f
= last_mouse_frame
;
6581 f
= x_window_to_frame (dpyinfo
, event
.xmotion
.window
);
6583 if (dpyinfo
->mouse_face_hidden
)
6585 dpyinfo
->mouse_face_hidden
= 0;
6586 clear_mouse_face (dpyinfo
);
6592 /* Generate SELECT_WINDOW_EVENTs when needed. */
6593 if (mouse_autoselect_window
)
6597 window
= window_from_coordinates (f
,
6598 event
.xmotion
.x
, event
.xmotion
.y
,
6601 /* Window will be selected only when it is not selected now and
6602 last mouse movement event was not in it. Minibuffer window
6603 will be selected iff it is active. */
6604 if (WINDOWP (window
)
6605 && !EQ (window
, last_window
)
6606 && !EQ (window
, selected_window
))
6608 inev
.ie
.kind
= SELECT_WINDOW_EVENT
;
6609 inev
.ie
.frame_or_window
= window
;
6614 note_mouse_movement (f
, &event
.xmotion
);
6618 #ifndef USE_TOOLKIT_SCROLL_BARS
6619 struct scroll_bar
*bar
6620 = x_window_to_scroll_bar (event
.xmotion
.display
,
6621 event
.xmotion
.window
);
6624 x_scroll_bar_note_movement (bar
, &event
);
6625 #endif /* USE_TOOLKIT_SCROLL_BARS */
6627 /* If we move outside the frame, then we're
6628 certainly no longer on any text in the frame. */
6629 clear_mouse_face (dpyinfo
);
6632 /* If the contents of the global variable help_echo_string
6633 has changed, generate a HELP_EVENT. */
6634 if (!NILP (help_echo_string
)
6635 || !NILP (previous_help_echo_string
))
6640 case ConfigureNotify
:
6641 f
= x_top_window_to_frame (dpyinfo
, event
.xconfigure
.window
);
6644 #ifndef USE_X_TOOLKIT
6646 xg_resize_widgets (f
, event
.xconfigure
.width
,
6647 event
.xconfigure
.height
);
6648 #else /* not USE_GTK */
6649 /* If there is a pending resize for fullscreen, don't
6650 do this one, the right one will come later.
6651 The toolkit version doesn't seem to need this, but we
6652 need to reset it below. */
6654 = ((f
->want_fullscreen
& FULLSCREEN_WAIT
)
6655 && f
->new_text_cols
!= 0);
6656 int rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, event
.xconfigure
.height
);
6657 int columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, event
.xconfigure
.width
);
6662 /* In the toolkit version, change_frame_size
6663 is called by the code that handles resizing
6664 of the EmacsFrame widget. */
6666 /* Even if the number of character rows and columns has
6667 not changed, the font size may have changed, so we need
6668 to check the pixel dimensions as well. */
6669 if (columns
!= FRAME_COLS (f
)
6670 || rows
!= FRAME_LINES (f
)
6671 || event
.xconfigure
.width
!= FRAME_PIXEL_WIDTH (f
)
6672 || event
.xconfigure
.height
!= FRAME_PIXEL_HEIGHT (f
))
6674 change_frame_size (f
, rows
, columns
, 0, 1, 0);
6675 SET_FRAME_GARBAGED (f
);
6676 cancel_mouse_face (f
);
6678 #endif /* not USE_GTK */
6681 FRAME_PIXEL_WIDTH (f
) = event
.xconfigure
.width
;
6682 FRAME_PIXEL_HEIGHT (f
) = event
.xconfigure
.height
;
6685 /* GTK creates windows but doesn't map them.
6686 Only get real positions and check fullscreen when mapped. */
6687 if (FRAME_GTK_OUTER_WIDGET (f
)
6688 && GTK_WIDGET_MAPPED (FRAME_GTK_OUTER_WIDGET (f
)))
6691 /* What we have now is the position of Emacs's own window.
6692 Convert that to the position of the window manager window. */
6693 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
6695 x_check_expected_move (f
);
6696 if (f
->want_fullscreen
& FULLSCREEN_WAIT
)
6697 f
->want_fullscreen
&= ~(FULLSCREEN_WAIT
|FULLSCREEN_BOTH
);
6701 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMStatusArea
))
6702 xic_set_statusarea (f
);
6705 if (f
->output_data
.x
->parent_desc
!= FRAME_X_DISPLAY_INFO (f
)->root_window
)
6707 /* Since the WM decorations come below top_pos now,
6708 we must put them below top_pos in the future. */
6709 f
->win_gravity
= NorthWestGravity
;
6710 x_wm_set_size_hint (f
, (long) 0, 0);
6718 /* If we decide we want to generate an event to be seen
6719 by the rest of Emacs, we put it here. */
6722 bzero (&compose_status
, sizeof (compose_status
));
6724 if (dpyinfo
->grabbed
6726 && FRAME_LIVE_P (last_mouse_frame
))
6727 f
= last_mouse_frame
;
6729 f
= x_window_to_frame (dpyinfo
, event
.xbutton
.window
);
6733 /* Is this in the tool-bar? */
6734 if (WINDOWP (f
->tool_bar_window
)
6735 && WINDOW_TOTAL_LINES (XWINDOW (f
->tool_bar_window
)))
6738 int x
= event
.xbutton
.x
;
6739 int y
= event
.xbutton
.y
;
6741 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 1);
6742 if (EQ (window
, f
->tool_bar_window
))
6744 if (event
.xbutton
.type
== ButtonPress
)
6745 handle_tool_bar_click (f
, x
, y
, 1, 0);
6747 handle_tool_bar_click (f
, x
, y
, 0,
6748 x_x_to_emacs_modifiers (dpyinfo
,
6749 event
.xbutton
.state
));
6755 if (!dpyinfo
->x_focus_frame
6756 || f
== dpyinfo
->x_focus_frame
)
6758 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6759 if (! popup_activated ())
6762 if (ignore_next_mouse_click_timeout
)
6764 if (event
.type
== ButtonPress
6765 && (int)(event
.xbutton
.time
- ignore_next_mouse_click_timeout
) > 0)
6767 ignore_next_mouse_click_timeout
= 0;
6768 construct_mouse_click (&inev
.ie
, &event
, f
);
6770 if (event
.type
== ButtonRelease
)
6771 ignore_next_mouse_click_timeout
= 0;
6774 construct_mouse_click (&inev
.ie
, &event
, f
);
6780 struct scroll_bar
*bar
6781 = x_window_to_scroll_bar (event
.xbutton
.display
,
6782 event
.xbutton
.window
);
6784 #ifdef USE_TOOLKIT_SCROLL_BARS
6785 /* Make the "Ctrl-Mouse-2 splits window" work for toolkit
6787 if (bar
&& event
.xbutton
.state
& ControlMask
)
6789 x_scroll_bar_handle_click (bar
, &event
, &inev
.ie
);
6790 *finish
= X_EVENT_DROP
;
6792 #else /* not USE_TOOLKIT_SCROLL_BARS */
6794 x_scroll_bar_handle_click (bar
, &event
, &inev
.ie
);
6795 #endif /* not USE_TOOLKIT_SCROLL_BARS */
6798 if (event
.type
== ButtonPress
)
6800 dpyinfo
->grabbed
|= (1 << event
.xbutton
.button
);
6801 last_mouse_frame
= f
;
6804 last_tool_bar_item
= -1;
6807 dpyinfo
->grabbed
&= ~(1 << event
.xbutton
.button
);
6809 /* Ignore any mouse motion that happened before this event;
6810 any subsequent mouse-movement Emacs events should reflect
6811 only motion after the ButtonPress/Release. */
6815 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
6816 f
= x_menubar_window_to_frame (dpyinfo
, event
.xbutton
.window
);
6817 /* For a down-event in the menu bar,
6818 don't pass it to Xt right now.
6819 Instead, save it away
6820 and we will pass it to Xt from kbd_buffer_get_event.
6821 That way, we can run some Lisp code first. */
6824 ! popup_activated ()
6827 f
&& event
.type
== ButtonPress
6828 /* Verify the event is really within the menu bar
6829 and not just sent to it due to grabbing. */
6830 && event
.xbutton
.x
>= 0
6831 && event
.xbutton
.x
< FRAME_PIXEL_WIDTH (f
)
6832 && event
.xbutton
.y
>= 0
6833 && event
.xbutton
.y
< f
->output_data
.x
->menubar_height
6834 && event
.xbutton
.same_screen
)
6836 SET_SAVED_BUTTON_EVENT
;
6837 XSETFRAME (last_mouse_press_frame
, f
);
6839 *finish
= X_EVENT_DROP
;
6842 else if (event
.type
== ButtonPress
)
6844 last_mouse_press_frame
= Qnil
;
6848 #ifdef USE_MOTIF /* This should do not harm for Lucid,
6849 but I am trying to be cautious. */
6850 else if (event
.type
== ButtonRelease
)
6852 if (!NILP (last_mouse_press_frame
))
6854 f
= XFRAME (last_mouse_press_frame
);
6855 if (f
->output_data
.x
)
6856 SET_SAVED_BUTTON_EVENT
;
6861 #endif /* USE_MOTIF */
6864 #endif /* USE_X_TOOLKIT || USE_GTK */
6868 case CirculateNotify
:
6871 case CirculateRequest
:
6874 case VisibilityNotify
:
6878 /* Someone has changed the keyboard mapping - update the
6880 switch (event
.xmapping
.request
)
6882 case MappingModifier
:
6883 x_find_modifier_meanings (dpyinfo
);
6884 /* This is meant to fall through. */
6885 case MappingKeyboard
:
6886 XRefreshKeyboardMapping (&event
.xmapping
);
6892 #ifdef USE_X_TOOLKIT
6894 if (*finish
!= X_EVENT_DROP
)
6895 XtDispatchEvent (&event
);
6897 #endif /* USE_X_TOOLKIT */
6902 if (inev
.ie
.kind
!= NO_EVENT
)
6904 kbd_buffer_store_event_hold (&inev
.ie
, hold_quit
);
6909 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
6914 XSETFRAME (frame
, f
);
6920 any_help_event_p
= 1;
6921 gen_help_event (help_echo_string
, frame
, help_echo_window
,
6922 help_echo_object
, help_echo_pos
);
6926 help_echo_string
= Qnil
;
6927 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
6937 /* Handles the XEvent EVENT on display DISPLAY.
6938 This is used for event loops outside the normal event handling,
6939 i.e. looping while a popup menu or a dialog is posted.
6941 Returns the value handle_one_xevent sets in the finish argument. */
6943 x_dispatch_event (event
, display
)
6947 struct x_display_info
*dpyinfo
;
6948 int finish
= X_EVENT_NORMAL
;
6950 dpyinfo
= x_display_info_for_display (display
);
6953 handle_one_xevent (dpyinfo
, event
, &finish
, 0);
6959 /* Read events coming from the X server.
6960 This routine is called by the SIGIO handler.
6961 We return as soon as there are no more events to be read.
6963 We return the number of characters stored into the buffer,
6964 thus pretending to be `read'.
6966 EXPECTED is nonzero if the caller knows input is available. */
6969 XTread_socket (device
, expected
, hold_quit
)
6970 struct device
*device
;
6972 struct input_event
*hold_quit
;
6976 int event_found
= 0;
6977 struct x_display_info
*dpyinfo
;
6979 if (interrupt_input_blocked
)
6981 interrupt_input_pending
= 1;
6985 interrupt_input_pending
= 0;
6988 /* So people can tell when we have read the available input. */
6989 input_signal_count
++;
6993 /* Find the display we are supposed to read input for.
6994 It's the one communicating on descriptor SD. */
6995 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
6997 #if 0 /* This ought to be unnecessary; let's verify it. */
6999 /* If available, Xlib uses FIOSNBIO to make the socket
7000 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
7001 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
7002 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
7003 fcntl (dpyinfo
->connection
, F_SETFL
, 0);
7004 #endif /* ! defined (FIOSNBIO) */
7007 #if 0 /* This code can't be made to work, with multiple displays,
7008 and appears not to be used on any system any more.
7009 Also keyboard.c doesn't turn O_NDELAY on and off
7010 for X connections. */
7013 if (! (fcntl (dpyinfo
->connection
, F_GETFL
, 0) & O_NDELAY
))
7015 extern int read_alarm_should_throw
;
7016 read_alarm_should_throw
= 1;
7017 XPeekEvent (dpyinfo
->display
, &event
);
7018 read_alarm_should_throw
= 0;
7020 #endif /* HAVE_SELECT */
7024 /* For debugging, this gives a way to fake an I/O error. */
7025 if (dpyinfo
== XTread_socket_fake_io_error
)
7027 XTread_socket_fake_io_error
= 0;
7028 x_io_error_quitter (dpyinfo
->display
);
7032 /* Only check session manager input for the primary display. */
7033 if (device
->id
== 1 && x_session_have_connection ())
7035 struct input_event inev
;
7037 /* We don't need to EVENT_INIT (inev) here, as
7038 x_session_check_input copies an entire input_event. */
7039 if (x_session_check_input (&inev
))
7041 kbd_buffer_store_event_hold (&inev
, hold_quit
);
7049 while (XPending (dpyinfo
->display
))
7053 XNextEvent (dpyinfo
->display
, &event
);
7056 /* Filter events for the current X input method. */
7057 if (x_filter_event (dpyinfo
, &event
))
7062 count
+= handle_one_xevent (dpyinfo
, &event
, &finish
, hold_quit
);
7064 if (finish
== X_EVENT_GOTO_OUT
)
7067 #endif /* not USE_GTK */
7072 /* For GTK we must use the GTK event loop. But XEvents gets passed
7073 to our filter function above, and then to the big event switch.
7074 We use a bunch of globals to communicate with our filter function,
7075 that is kind of ugly, but it works.
7077 There is no way to do one display at the time, GTK just does events
7078 from all displays. */
7080 while (gtk_events_pending ())
7082 current_count
= count
;
7083 current_hold_quit
= hold_quit
;
7085 gtk_main_iteration ();
7087 count
= current_count
;
7089 current_hold_quit
= 0;
7091 if (current_finish
== X_EVENT_GOTO_OUT
)
7094 #endif /* USE_GTK */
7098 /* On some systems, an X bug causes Emacs to get no more events
7099 when the window is destroyed. Detect that. (1994.) */
7102 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
7103 One XNOOP in 100 loops will make Emacs terminate.
7104 B. Bretthauer, 1994 */
7106 if (x_noop_count
>= 100)
7110 if (next_noop_dpyinfo
== 0)
7111 next_noop_dpyinfo
= x_display_list
;
7113 XNoOp (next_noop_dpyinfo
->display
);
7115 /* Each time we get here, cycle through the displays now open. */
7116 next_noop_dpyinfo
= next_noop_dpyinfo
->next
;
7120 /* If the focus was just given to an auto-raising frame,
7122 /* ??? This ought to be able to handle more than one such frame. */
7123 if (pending_autoraise_frame
)
7125 x_raise_frame (pending_autoraise_frame
);
7126 pending_autoraise_frame
= 0;
7138 /***********************************************************************
7140 ***********************************************************************/
7142 /* Set clipping for output in glyph row ROW. W is the window in which
7143 we operate. GC is the graphics context to set clipping in.
7145 ROW may be a text row or, e.g., a mode line. Text rows must be
7146 clipped to the interior of the window dedicated to text display,
7147 mode lines must be clipped to the whole window. */
7150 x_clip_to_row (w
, row
, area
, gc
)
7152 struct glyph_row
*row
;
7156 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7157 XRectangle clip_rect
;
7158 int window_x
, window_y
, window_width
;
7160 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
7162 clip_rect
.x
= window_x
;
7163 clip_rect
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, row
->y
));
7164 clip_rect
.y
= max (clip_rect
.y
, window_y
);
7165 clip_rect
.width
= window_width
;
7166 clip_rect
.height
= row
->visible_height
;
7168 XSetClipRectangles (FRAME_X_DISPLAY (f
), gc
, 0, 0, &clip_rect
, 1, Unsorted
);
7172 /* Draw a hollow box cursor on window W in glyph row ROW. */
7175 x_draw_hollow_cursor (w
, row
)
7177 struct glyph_row
*row
;
7179 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7180 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7181 Display
*dpy
= FRAME_X_DISPLAY (f
);
7184 struct glyph
*cursor_glyph
;
7187 /* Get the glyph the cursor is on. If we can't tell because
7188 the current matrix is invalid or such, give up. */
7189 cursor_glyph
= get_phys_cursor_glyph (w
);
7190 if (cursor_glyph
== NULL
)
7193 /* Compute frame-relative coordinates for phys cursor. */
7194 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
7195 y
= get_phys_cursor_geometry (w
, row
, cursor_glyph
, &h
);
7196 wd
= w
->phys_cursor_width
;
7198 /* The foreground of cursor_gc is typically the same as the normal
7199 background color, which can cause the cursor box to be invisible. */
7200 xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7201 if (dpyinfo
->scratch_cursor_gc
)
7202 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
7204 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_X_WINDOW (f
),
7205 GCForeground
, &xgcv
);
7206 gc
= dpyinfo
->scratch_cursor_gc
;
7208 /* Set clipping, draw the rectangle, and reset clipping again. */
7209 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7210 XDrawRectangle (dpy
, FRAME_X_WINDOW (f
), gc
, x
, y
, wd
, h
);
7211 XSetClipMask (dpy
, gc
, None
);
7215 /* Draw a bar cursor on window W in glyph row ROW.
7217 Implementation note: One would like to draw a bar cursor with an
7218 angle equal to the one given by the font property XA_ITALIC_ANGLE.
7219 Unfortunately, I didn't find a font yet that has this property set.
7223 x_draw_bar_cursor (w
, row
, width
, kind
)
7225 struct glyph_row
*row
;
7227 enum text_cursor_kinds kind
;
7229 struct frame
*f
= XFRAME (w
->frame
);
7230 struct glyph
*cursor_glyph
;
7232 /* If cursor is out of bounds, don't draw garbage. This can happen
7233 in mini-buffer windows when switching between echo area glyphs
7235 cursor_glyph
= get_phys_cursor_glyph (w
);
7236 if (cursor_glyph
== NULL
)
7239 /* If on an image, draw like a normal cursor. That's usually better
7240 visible than drawing a bar, esp. if the image is large so that
7241 the bar might not be in the window. */
7242 if (cursor_glyph
->type
== IMAGE_GLYPH
)
7244 struct glyph_row
*row
;
7245 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
7246 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
7250 Display
*dpy
= FRAME_X_DISPLAY (f
);
7251 Window window
= FRAME_X_WINDOW (f
);
7252 GC gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
7253 unsigned long mask
= GCForeground
| GCBackground
| GCGraphicsExposures
;
7254 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
7257 /* If the glyph's background equals the color we normally draw
7258 the bar cursor in, the bar cursor in its normal color is
7259 invisible. Use the glyph's foreground color instead in this
7260 case, on the assumption that the glyph's colors are chosen so
7261 that the glyph is legible. */
7262 if (face
->background
== f
->output_data
.x
->cursor_pixel
)
7263 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
7265 xgcv
.background
= xgcv
.foreground
= f
->output_data
.x
->cursor_pixel
;
7266 xgcv
.graphics_exposures
= 0;
7269 XChangeGC (dpy
, gc
, mask
, &xgcv
);
7272 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
7273 FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
7277 width
= FRAME_CURSOR_WIDTH (f
);
7278 width
= min (cursor_glyph
->pixel_width
, width
);
7280 w
->phys_cursor_width
= width
;
7281 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
7283 if (kind
== BAR_CURSOR
)
7284 XFillRectangle (dpy
, window
, gc
,
7285 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
7286 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
7287 width
, row
->height
);
7289 XFillRectangle (dpy
, window
, gc
,
7290 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
7291 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
7292 row
->height
- width
),
7293 cursor_glyph
->pixel_width
,
7296 XSetClipMask (dpy
, gc
, None
);
7301 /* RIF: Define cursor CURSOR on frame F. */
7304 x_define_frame_cursor (f
, cursor
)
7308 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
7312 /* RIF: Clear area on frame F. */
7315 x_clear_frame_area (f
, x
, y
, width
, height
)
7317 int x
, y
, width
, height
;
7319 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7320 x
, y
, width
, height
, False
);
7324 /* RIF: Draw cursor on window W. */
7327 x_draw_window_cursor (w
, glyph_row
, x
, y
, cursor_type
, cursor_width
, on_p
, active_p
)
7329 struct glyph_row
*glyph_row
;
7331 int cursor_type
, cursor_width
;
7334 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7338 w
->phys_cursor_type
= cursor_type
;
7339 w
->phys_cursor_on_p
= 1;
7341 if (glyph_row
->exact_window_width_line_p
7342 && w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])
7344 glyph_row
->cursor_in_fringe_p
= 1;
7345 draw_fringe_bitmap (w
, glyph_row
, 0);
7348 switch (cursor_type
)
7350 case HOLLOW_BOX_CURSOR
:
7351 x_draw_hollow_cursor (w
, glyph_row
);
7354 case FILLED_BOX_CURSOR
:
7355 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
7359 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
7363 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
7367 w
->phys_cursor_width
= 0;
7375 if (w
== XWINDOW (f
->selected_window
))
7376 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
7377 xic_set_preeditarea (w
, x
, y
);
7382 XFlush (FRAME_X_DISPLAY (f
));
7389 /* Make the x-window of frame F use the gnu icon bitmap. */
7392 x_bitmap_icon (f
, file
)
7398 if (FRAME_X_WINDOW (f
) == 0)
7401 /* Free up our existing icon bitmap and mask if any. */
7402 if (f
->output_data
.x
->icon_bitmap
> 0)
7403 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7404 f
->output_data
.x
->icon_bitmap
= 0;
7409 /* Use gtk_window_set_icon_from_file () if available,
7410 It's not restricted to bitmaps */
7411 if (xg_set_icon (f
, file
))
7413 #endif /* USE_GTK */
7414 bitmap_id
= x_create_bitmap_from_file (f
, file
);
7415 x_create_bitmap_mask (f
, bitmap_id
);
7419 /* Create the GNU bitmap and mask if necessary. */
7420 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
7422 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
7423 = x_create_bitmap_from_data (f
, gnu_bits
,
7424 gnu_width
, gnu_height
);
7425 x_create_bitmap_mask (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
7428 /* The first time we create the GNU bitmap and mask,
7429 this increments the ref-count one extra time.
7430 As a result, the GNU bitmap and mask are never freed.
7431 That way, we don't have to worry about allocating it again. */
7432 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
7434 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
7437 x_wm_set_icon_pixmap (f
, bitmap_id
);
7438 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
7444 /* Make the x-window of frame F use a rectangle with text.
7445 Use ICON_NAME as the text. */
7448 x_text_icon (f
, icon_name
)
7452 if (FRAME_X_WINDOW (f
) == 0)
7458 text
.value
= (unsigned char *) icon_name
;
7459 text
.encoding
= XA_STRING
;
7461 text
.nitems
= strlen (icon_name
);
7462 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
7464 #else /* not HAVE_X11R4 */
7465 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), icon_name
);
7466 #endif /* not HAVE_X11R4 */
7468 if (f
->output_data
.x
->icon_bitmap
> 0)
7469 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
7470 f
->output_data
.x
->icon_bitmap
= 0;
7471 x_wm_set_icon_pixmap (f
, 0);
7476 #define X_ERROR_MESSAGE_SIZE 200
7478 /* If non-nil, this should be a string.
7479 It means catch X errors and store the error message in this string. */
7481 static Lisp_Object x_error_message_string
;
7483 /* An X error handler which stores the error message in
7484 x_error_message_string. This is called from x_error_handler if
7485 x_catch_errors is in effect. */
7488 x_error_catcher (display
, error
)
7492 XGetErrorText (display
, error
->error_code
,
7493 SDATA (x_error_message_string
),
7494 X_ERROR_MESSAGE_SIZE
);
7497 /* Begin trapping X errors for display DPY. Actually we trap X errors
7498 for all displays, but DPY should be the display you are actually
7501 After calling this function, X protocol errors no longer cause
7502 Emacs to exit; instead, they are recorded in the string
7503 stored in x_error_message_string.
7505 Calling x_check_errors signals an Emacs error if an X error has
7506 occurred since the last call to x_catch_errors or x_check_errors.
7508 Calling x_uncatch_errors resumes the normal error handling. */
7510 void x_check_errors ();
7511 static Lisp_Object
x_catch_errors_unwind ();
7514 x_catch_errors (dpy
)
7517 int count
= SPECPDL_INDEX ();
7519 /* Make sure any errors from previous requests have been dealt with. */
7522 record_unwind_protect (x_catch_errors_unwind
,
7523 Fcons (make_save_value (dpy
, 0),
7524 x_error_message_string
));
7526 x_error_message_string
= make_uninit_string (X_ERROR_MESSAGE_SIZE
);
7527 SSET (x_error_message_string
, 0, 0);
7532 /* Unbind the binding that we made to check for X errors. */
7535 x_catch_errors_unwind (old_val
)
7536 Lisp_Object old_val
;
7538 Lisp_Object first
= XCAR (old_val
);
7539 Display
*dpy
= XSAVE_VALUE (first
)->pointer
;
7541 /* The display may have been closed before this function is called.
7542 Check if it is still open before calling XSync. */
7543 if (x_display_info_for_display (dpy
) != 0)
7550 x_error_message_string
= XCDR (old_val
);
7554 /* If any X protocol errors have arrived since the last call to
7555 x_catch_errors or x_check_errors, signal an Emacs error using
7556 sprintf (a buffer, FORMAT, the x error message text) as the text. */
7559 x_check_errors (dpy
, format
)
7563 /* Make sure to catch any errors incurred so far. */
7566 if (SREF (x_error_message_string
, 0))
7567 error (format
, SDATA (x_error_message_string
));
7570 /* Nonzero if we had any X protocol errors
7571 since we did x_catch_errors on DPY. */
7574 x_had_errors_p (dpy
)
7577 /* Make sure to catch any errors incurred so far. */
7580 return SREF (x_error_message_string
, 0) != 0;
7583 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
7586 x_clear_errors (dpy
)
7589 SSET (x_error_message_string
, 0, 0);
7592 /* Stop catching X protocol errors and let them make Emacs die.
7593 DPY should be the display that was passed to x_catch_errors.
7594 COUNT should be the value that was returned by
7595 the corresponding call to x_catch_errors. */
7598 x_uncatch_errors (dpy
, count
)
7602 unbind_to (count
, Qnil
);
7606 static unsigned int x_wire_count
;
7609 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
7614 /* Handle SIGPIPE, which can happen when the connection to a server
7615 simply goes away. SIGPIPE is handled by x_connection_signal.
7616 Don't need to do anything, because the write which caused the
7617 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
7618 which will do the appropriate cleanup for us. */
7621 x_connection_signal (signalnum
) /* If we don't have an argument, */
7622 int signalnum
; /* some compilers complain in signal calls. */
7625 /* USG systems forget handlers when they are used;
7626 must reestablish each time */
7627 signal (signalnum
, x_connection_signal
);
7632 /************************************************************************
7634 ************************************************************************/
7636 /* Error message passed to x_connection_closed. */
7638 static char *error_msg
;
7640 /* Function installed as fatal_error_signal_hook in
7641 x_connection_closed. Print the X error message, and exit normally,
7642 instead of dumping core when XtCloseDisplay fails. */
7645 x_fatal_error_signal ()
7647 fprintf (stderr
, "%s\n", error_msg
);
7651 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
7652 the text of an error message that lead to the connection loss. */
7655 x_connection_closed (dpy
, error_message
)
7657 char *error_message
;
7659 struct x_display_info
*dpyinfo
= x_display_info_for_display (dpy
);
7660 Lisp_Object frame
, tail
;
7662 int index
= SPECPDL_INDEX ();
7664 error_msg
= (char *) alloca (strlen (error_message
) + 1);
7665 strcpy (error_msg
, error_message
);
7666 handling_signal
= 0;
7668 /* Prevent being called recursively because of an error condition
7669 below. Otherwise, we might end up with printing ``can't find per
7670 display information'' in the recursive call instead of printing
7671 the original message here. */
7672 count
= x_catch_errors (dpy
);
7674 /* Inhibit redisplay while frames are being deleted. */
7675 specbind (Qinhibit_redisplay
, Qt
);
7679 /* Protect display from being closed when we delete the last
7681 dpyinfo
->reference_count
++;
7682 dpyinfo
->device
->reference_count
++;
7685 /* First delete frames whose mini-buffers are on frames
7686 that are on the dead display. */
7687 FOR_EACH_FRAME (tail
, frame
)
7689 Lisp_Object minibuf_frame
;
7691 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
7692 if (FRAME_X_P (XFRAME (frame
))
7693 && FRAME_X_P (XFRAME (minibuf_frame
))
7694 && ! EQ (frame
, minibuf_frame
)
7695 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
7696 Fdelete_frame (frame
, Qt
);
7699 /* Now delete all remaining frames on the dead display.
7700 We are now sure none of these is used as the mini-buffer
7701 for another frame that we need to delete. */
7702 FOR_EACH_FRAME (tail
, frame
)
7703 if (FRAME_X_P (XFRAME (frame
))
7704 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
7706 /* Set this to t so that Fdelete_frame won't get confused
7707 trying to find a replacement. */
7708 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
7709 Fdelete_frame (frame
, Qt
);
7712 /* We have to close the display to inform Xt that it doesn't
7713 exist anymore. If we don't, Xt will continue to wait for
7714 events from the display. As a consequence, a sequence of
7716 M-x make-frame-on-display RET :1 RET
7717 ...kill the new frame, so that we get an IO error...
7718 M-x make-frame-on-display RET :1 RET
7720 will indefinitely wait in Xt for events for display `:1', opened
7721 in the first class to make-frame-on-display.
7723 Closing the display is reported to lead to a bus error on
7724 OpenWindows in certain situations. I suspect that is a bug
7725 in OpenWindows. I don't know how to cicumvent it here. */
7727 #ifdef USE_X_TOOLKIT
7728 /* If DPYINFO is null, this means we didn't open the display
7729 in the first place, so don't try to close it. */
7732 extern void (*fatal_error_signal_hook
) P_ ((void));
7733 fatal_error_signal_hook
= x_fatal_error_signal
;
7734 XtCloseDisplay (dpy
);
7735 fatal_error_signal_hook
= NULL
;
7741 xg_display_close (dpyinfo
->display
);
7746 /* Indicate that this display is dead. */
7747 dpyinfo
->display
= 0;
7749 dpyinfo
->reference_count
--;
7750 dpyinfo
->device
->reference_count
--;
7751 if (dpyinfo
->reference_count
!= 0)
7752 /* We have just closed all frames on this display. */
7755 x_delete_display (dpyinfo
);
7758 x_uncatch_errors (dpy
, count
);
7760 if (device_list
== 0)
7762 fprintf (stderr
, "%s\n", error_msg
);
7763 shut_down_emacs (0, 0, Qnil
);
7767 /* Ordinary stack unwind doesn't deal with these. */
7769 sigunblock (sigmask (SIGIO
));
7771 sigunblock (sigmask (SIGALRM
));
7772 TOTALLY_UNBLOCK_INPUT
;
7774 unbind_to (index
, Qnil
);
7775 clear_waiting_for_input ();
7776 error ("%s", error_msg
);
7779 /* We specifically use it before defining it, so that gcc doesn't inline it,
7780 otherwise gdb doesn't know how to properly put a breakpoint on it. */
7781 static void x_error_quitter (Display
*display
, XErrorEvent
*error
);
7783 /* This is the first-level handler for X protocol errors.
7784 It calls x_error_quitter or x_error_catcher. */
7787 x_error_handler (display
, error
)
7791 if (! NILP (x_error_message_string
))
7792 x_error_catcher (display
, error
);
7794 x_error_quitter (display
, error
);
7798 /* This is the usual handler for X protocol errors.
7799 It kills all frames on the display that we got the error for.
7800 If that was the only one, it prints an error message and kills Emacs. */
7802 /* .gdbinit puts a breakpoint here, so make sure it is not inlined. */
7804 #if __GNUC__ >= 3 /* On GCC 3.0 we might get a warning. */
7805 #define NO_INLINE __attribute__((noinline))
7810 /* Some versions of GNU/Linux define noinline in their headers. */
7816 /* On older GCC versions, just putting x_error_quitter
7817 after x_error_handler prevents inlining into the former. */
7819 static void NO_INLINE
7820 x_error_quitter (display
, error
)
7824 char buf
[256], buf1
[356];
7826 /* Note that there is no real way portable across R3/R4 to get the
7827 original error handler. */
7829 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
7830 sprintf (buf1
, "X protocol error: %s on protocol request %d",
7831 buf
, error
->request_code
);
7832 x_connection_closed (display
, buf1
);
7836 /* This is the handler for X IO errors, always.
7837 It kills all frames on the display that we lost touch with.
7838 If that was the only one, it prints an error message and kills Emacs. */
7841 x_io_error_quitter (display
)
7846 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
7847 x_connection_closed (display
, buf
);
7851 /* Changing the font of the frame. */
7853 /* Give frame F the font named FONTNAME as its default font, and
7854 return the full name of that font. FONTNAME may be a wildcard
7855 pattern; in that case, we choose some font that fits the pattern.
7856 The return value shows which font we chose. */
7859 x_new_font (f
, fontname
)
7861 register char *fontname
;
7863 struct font_info
*fontp
7864 = FS_LOAD_FONT (f
, 0, fontname
, -1);
7869 FRAME_FONT (f
) = (XFontStruct
*) (fontp
->font
);
7870 FRAME_BASELINE_OFFSET (f
) = fontp
->baseline_offset
;
7871 FRAME_FONTSET (f
) = -1;
7873 FRAME_COLUMN_WIDTH (f
) = fontp
->average_width
;
7874 FRAME_SPACE_WIDTH (f
) = fontp
->space_width
;
7875 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (FRAME_FONT (f
));
7877 compute_fringe_widths (f
, 1);
7879 /* Compute the scroll bar width in character columns. */
7880 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
7882 int wid
= FRAME_COLUMN_WIDTH (f
);
7883 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
7884 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
-1) / wid
;
7888 int wid
= FRAME_COLUMN_WIDTH (f
);
7889 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
7892 /* Now make the frame display the given font. */
7893 if (FRAME_X_WINDOW (f
) != 0)
7895 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->normal_gc
,
7896 FRAME_FONT (f
)->fid
);
7897 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->reverse_gc
,
7898 FRAME_FONT (f
)->fid
);
7899 XSetFont (FRAME_X_DISPLAY (f
), f
->output_data
.x
->cursor_gc
,
7900 FRAME_FONT (f
)->fid
);
7902 /* Don't change the size of a tip frame; there's no point in
7903 doing it because it's done in Fx_show_tip, and it leads to
7904 problems because the tip frame has no widget. */
7905 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
7906 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
7909 return build_string (fontp
->full_name
);
7912 /* Give frame F the fontset named FONTSETNAME as its default font, and
7913 return the full name of that fontset. FONTSETNAME may be a wildcard
7914 pattern; in that case, we choose some fontset that fits the pattern.
7915 The return value shows which fontset we chose. */
7918 x_new_fontset (f
, fontsetname
)
7922 int fontset
= fs_query_fontset (build_string (fontsetname
), 0);
7928 if (FRAME_FONTSET (f
) == fontset
)
7929 /* This fontset is already set in frame F. There's nothing more
7931 return fontset_name (fontset
);
7933 result
= x_new_font (f
, (SDATA (fontset_ascii (fontset
))));
7935 if (!STRINGP (result
))
7936 /* Can't load ASCII font. */
7939 /* Since x_new_font doesn't update any fontset information, do it now. */
7940 FRAME_FONTSET (f
) = fontset
;
7944 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
7945 xic_set_xfontset (f
, SDATA (fontset_ascii (fontset
)));
7948 return build_string (fontsetname
);
7952 /***********************************************************************
7954 ***********************************************************************/
7960 /* XIM destroy callback function, which is called whenever the
7961 connection to input method XIM dies. CLIENT_DATA contains a
7962 pointer to the x_display_info structure corresponding to XIM. */
7965 xim_destroy_callback (xim
, client_data
, call_data
)
7967 XPointer client_data
;
7970 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
7971 Lisp_Object frame
, tail
;
7975 /* No need to call XDestroyIC.. */
7976 FOR_EACH_FRAME (tail
, frame
)
7978 struct frame
*f
= XFRAME (frame
);
7979 if (FRAME_X_P (f
) && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
7981 FRAME_XIC (f
) = NULL
;
7982 xic_free_xfontset (f
);
7986 /* No need to call XCloseIM. */
7987 dpyinfo
->xim
= NULL
;
7988 XFree (dpyinfo
->xim_styles
);
7992 #endif /* HAVE_X11R6 */
7995 /* This isn't prototyped in OSF 5.0 or 5.1a. */
7996 extern char *XSetIMValues
P_ ((XIM
, ...));
7999 /* Open the connection to the XIM server on display DPYINFO.
8000 RESOURCE_NAME is the resource name Emacs uses. */
8003 xim_open_dpy (dpyinfo
, resource_name
)
8004 struct x_display_info
*dpyinfo
;
8005 char *resource_name
;
8012 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
,
8019 XIMCallback destroy
;
8022 /* Get supported styles and XIM values. */
8023 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
8026 destroy
.callback
= xim_destroy_callback
;
8027 destroy
.client_data
= (XPointer
)dpyinfo
;
8028 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
8034 #endif /* HAVE_XIM */
8035 dpyinfo
->xim
= NULL
;
8039 #ifdef HAVE_X11R6_XIM
8043 struct x_display_info
*dpyinfo
;
8044 char *resource_name
;
8047 /* XIM instantiate callback function, which is called whenever an XIM
8048 server is available. DISPLAY is the display of the XIM.
8049 CLIENT_DATA contains a pointer to an xim_inst_t structure created
8050 when the callback was registered. */
8053 xim_instantiate_callback (display
, client_data
, call_data
)
8055 XPointer client_data
;
8058 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
8059 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
8061 /* We don't support multiple XIM connections. */
8065 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
8067 /* Create XIC for the existing frames on the same display, as long
8068 as they have no XIC. */
8069 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
8071 Lisp_Object tail
, frame
;
8074 FOR_EACH_FRAME (tail
, frame
)
8076 struct frame
*f
= XFRAME (frame
);
8079 && FRAME_X_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
8080 if (FRAME_XIC (f
) == NULL
)
8082 create_frame_xic (f
);
8083 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
8084 xic_set_statusarea (f
);
8085 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
8087 struct window
*w
= XWINDOW (f
->selected_window
);
8088 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
8097 #endif /* HAVE_X11R6_XIM */
8100 /* Open a connection to the XIM server on display DPYINFO.
8101 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
8102 connection only at the first time. On X11R6, open the connection
8103 in the XIM instantiate callback function. */
8106 xim_initialize (dpyinfo
, resource_name
)
8107 struct x_display_info
*dpyinfo
;
8108 char *resource_name
;
8113 #ifdef HAVE_X11R6_XIM
8114 struct xim_inst_t
*xim_inst
;
8117 dpyinfo
->xim
= NULL
;
8118 xim_inst
= (struct xim_inst_t
*) xmalloc (sizeof (struct xim_inst_t
));
8119 xim_inst
->dpyinfo
= dpyinfo
;
8120 len
= strlen (resource_name
);
8121 xim_inst
->resource_name
= (char *) xmalloc (len
+ 1);
8122 bcopy (resource_name
, xim_inst
->resource_name
, len
+ 1);
8123 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8124 resource_name
, EMACS_CLASS
,
8125 xim_instantiate_callback
,
8126 /* This is XPointer in XFree86
8127 but (XPointer *) on Tru64, at
8128 least, hence the configure test. */
8129 (XRegisterIMInstantiateCallback_arg6
) xim_inst
);
8130 #else /* not HAVE_X11R6_XIM */
8131 dpyinfo
->xim
= NULL
;
8132 xim_open_dpy (dpyinfo
, resource_name
);
8133 #endif /* not HAVE_X11R6_XIM */
8137 #endif /* HAVE_XIM */
8138 dpyinfo
->xim
= NULL
;
8142 /* Close the connection to the XIM server on display DPYINFO. */
8145 xim_close_dpy (dpyinfo
)
8146 struct x_display_info
*dpyinfo
;
8151 #ifdef HAVE_X11R6_XIM
8152 if (dpyinfo
->display
)
8153 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
8155 xim_instantiate_callback
, NULL
);
8156 #endif /* not HAVE_X11R6_XIM */
8157 if (dpyinfo
->display
)
8158 XCloseIM (dpyinfo
->xim
);
8159 dpyinfo
->xim
= NULL
;
8160 XFree (dpyinfo
->xim_styles
);
8162 #endif /* HAVE_XIM */
8165 #endif /* not HAVE_X11R6_XIM */
8169 /* Calculate the absolute position in frame F
8170 from its current recorded position values and gravity. */
8173 x_calc_absolute_position (f
)
8176 int win_x
= 0, win_y
= 0;
8177 int flags
= f
->size_hint_flags
;
8179 /* We have nothing to do if the current position
8180 is already for the top-left corner. */
8181 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
8184 /* Treat negative positions as relative to the leftmost bottommost
8185 position that fits on the screen. */
8186 if (flags
& XNegative
)
8187 f
->left_pos
= (FRAME_X_DISPLAY_INFO (f
)->width
8188 - FRAME_PIXEL_WIDTH (f
) + f
->left_pos
);
8191 int height
= FRAME_PIXEL_HEIGHT (f
);
8193 #if defined USE_X_TOOLKIT && defined USE_MOTIF
8194 /* Something is fishy here. When using Motif, starting Emacs with
8195 `-g -0-0', the frame appears too low by a few pixels.
8197 This seems to be so because initially, while Emacs is starting,
8198 the column widget's height and the frame's pixel height are
8199 different. The column widget's height is the right one. In
8200 later invocations, when Emacs is up, the frame's pixel height
8203 It's not obvious where the initial small difference comes from.
8204 2000-12-01, gerd. */
8206 XtVaGetValues (f
->output_data
.x
->column_widget
, XtNheight
, &height
, NULL
);
8209 if (flags
& YNegative
)
8210 f
->top_pos
= (FRAME_X_DISPLAY_INFO (f
)->height
- height
+ f
->top_pos
);
8213 /* The left_pos and top_pos
8214 are now relative to the top and left screen edges,
8215 so the flags should correspond. */
8216 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8219 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
8220 to really change the position, and 0 when calling from
8221 x_make_frame_visible (in that case, XOFF and YOFF are the current
8222 position values). It is -1 when calling from x_set_frame_parameters,
8223 which means, do adjust for borders but don't change the gravity. */
8226 x_set_offset (f
, xoff
, yoff
, change_gravity
)
8228 register int xoff
, yoff
;
8231 int modified_top
, modified_left
;
8233 if (change_gravity
> 0)
8237 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
8239 f
->size_hint_flags
|= XNegative
;
8241 f
->size_hint_flags
|= YNegative
;
8242 f
->win_gravity
= NorthWestGravity
;
8244 x_calc_absolute_position (f
);
8247 x_wm_set_size_hint (f
, (long) 0, 0);
8249 modified_left
= f
->left_pos
;
8250 modified_top
= f
->top_pos
;
8252 if (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_A
)
8254 /* Some WMs (twm, wmaker at least) has an offset that is smaller
8255 than the WM decorations. So we use the calculated offset instead
8256 of the WM decoration sizes here (x/y_pixels_outer_diff). */
8257 modified_left
+= FRAME_X_OUTPUT (f
)->move_offset_left
;
8258 modified_top
+= FRAME_X_OUTPUT (f
)->move_offset_top
;
8261 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8262 modified_left
, modified_top
);
8264 if (FRAME_VISIBLE_P (f
)
8265 && FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
)
8267 FRAME_X_OUTPUT (f
)->check_expected_move
= 1;
8268 FRAME_X_OUTPUT (f
)->expected_top
= f
->top_pos
;
8269 FRAME_X_OUTPUT (f
)->expected_left
= f
->left_pos
;
8275 /* Check if we need to resize the frame due to a fullscreen request.
8276 If so needed, resize the frame. */
8278 x_check_fullscreen (f
)
8281 if (f
->want_fullscreen
& FULLSCREEN_BOTH
)
8283 int width
, height
, ign
;
8285 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
8287 x_fullscreen_adjust (f
, &width
, &height
, &ign
, &ign
);
8289 /* We do not need to move the window, it shall be taken care of
8290 when setting WM manager hints.
8291 If the frame is visible already, the position is checked by
8292 x_check_expected_move. */
8293 if (FRAME_COLS (f
) != width
|| FRAME_LINES (f
) != height
)
8295 change_frame_size (f
, height
, width
, 0, 1, 0);
8296 SET_FRAME_GARBAGED (f
);
8297 cancel_mouse_face (f
);
8299 /* Wait for the change of frame size to occur */
8300 f
->want_fullscreen
|= FULLSCREEN_WAIT
;
8305 /* If frame parameters are set after the frame is mapped, we need to move
8307 Some window managers moves the window to the right position, some
8308 moves the outer window manager window to the specified position.
8309 Here we check that we are in the right spot. If not, make a second
8310 move, assuming we are dealing with the second kind of window manager. */
8312 x_check_expected_move (f
)
8315 if (FRAME_X_OUTPUT (f
)->check_expected_move
)
8317 int expect_top
= FRAME_X_OUTPUT (f
)->expected_top
;
8318 int expect_left
= FRAME_X_OUTPUT (f
)->expected_left
;
8320 if (expect_top
!= f
->top_pos
|| expect_left
!= f
->left_pos
)
8322 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_A
;
8323 FRAME_X_OUTPUT (f
)->move_offset_left
= expect_left
- f
->left_pos
;
8324 FRAME_X_OUTPUT (f
)->move_offset_top
= expect_top
- f
->top_pos
;
8326 f
->left_pos
= expect_left
;
8327 f
->top_pos
= expect_top
;
8328 x_set_offset (f
, expect_left
, expect_top
, 0);
8330 else if (FRAME_X_DISPLAY_INFO (f
)->wm_type
== X_WMTYPE_UNKNOWN
)
8331 FRAME_X_DISPLAY_INFO (f
)->wm_type
= X_WMTYPE_B
;
8333 /* Just do this once */
8334 FRAME_X_OUTPUT (f
)->check_expected_move
= 0;
8339 /* Change the size of frame F's X window to COLS/ROWS in the case F
8340 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
8341 top-left-corner window gravity for this size change and subsequent
8342 size changes. Otherwise we leave the window gravity unchanged. */
8345 x_set_window_size_1 (f
, change_gravity
, cols
, rows
)
8350 int pixelwidth
, pixelheight
;
8352 check_frame_size (f
, &rows
, &cols
);
8353 f
->scroll_bar_actual_width
8354 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
8356 : FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0
8357 ? FRAME_CONFIG_SCROLL_BAR_WIDTH (f
)
8358 : (FRAME_CONFIG_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
)));
8360 compute_fringe_widths (f
, 0);
8362 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
8363 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
);
8365 f
->win_gravity
= NorthWestGravity
;
8366 x_wm_set_size_hint (f
, (long) 0, 0);
8368 XSync (FRAME_X_DISPLAY (f
), False
);
8369 XResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8370 pixelwidth
, pixelheight
);
8372 /* Now, strictly speaking, we can't be sure that this is accurate,
8373 but the window manager will get around to dealing with the size
8374 change request eventually, and we'll hear how it went when the
8375 ConfigureNotify event gets here.
8377 We could just not bother storing any of this information here,
8378 and let the ConfigureNotify event set everything up, but that
8379 might be kind of confusing to the Lisp code, since size changes
8380 wouldn't be reported in the frame parameters until some random
8381 point in the future when the ConfigureNotify event arrives.
8383 We pass 1 for DELAY since we can't run Lisp code inside of
8385 change_frame_size (f
, rows
, cols
, 0, 1, 0);
8386 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
8387 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
8389 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
8390 receive in the ConfigureNotify event; if we get what we asked
8391 for, then the event won't cause the screen to become garbaged, so
8392 we have to make sure to do it here. */
8393 SET_FRAME_GARBAGED (f
);
8395 XFlush (FRAME_X_DISPLAY (f
));
8399 /* Call this to change the size of frame F's x-window.
8400 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
8401 for this size change and subsequent size changes.
8402 Otherwise we leave the window gravity unchanged. */
8405 x_set_window_size (f
, change_gravity
, cols
, rows
)
8413 if (FRAME_GTK_WIDGET (f
))
8414 xg_frame_set_char_size (f
, cols
, rows
);
8416 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8419 if (f
->output_data
.x
->widget
!= NULL
)
8421 /* The x and y position of the widget is clobbered by the
8422 call to XtSetValues within EmacsFrameSetCharSize.
8423 This is a real kludge, but I don't understand Xt so I can't
8424 figure out a correct fix. Can anyone else tell me? -- rms. */
8425 int xpos
= f
->output_data
.x
->widget
->core
.x
;
8426 int ypos
= f
->output_data
.x
->widget
->core
.y
;
8427 EmacsFrameSetCharSize (f
->output_data
.x
->edit_widget
, cols
, rows
);
8428 f
->output_data
.x
->widget
->core
.x
= xpos
;
8429 f
->output_data
.x
->widget
->core
.y
= ypos
;
8432 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8434 #else /* not USE_X_TOOLKIT */
8436 x_set_window_size_1 (f
, change_gravity
, cols
, rows
);
8438 #endif /* not USE_X_TOOLKIT */
8440 /* If cursor was outside the new size, mark it as off. */
8441 mark_window_cursors_off (XWINDOW (f
->root_window
));
8443 /* Clear out any recollection of where the mouse highlighting was,
8444 since it might be in a place that's outside the new frame size.
8445 Actually checking whether it is outside is a pain in the neck,
8446 so don't try--just let the highlighting be done afresh with new size. */
8447 cancel_mouse_face (f
);
8452 /* Mouse warping. */
8455 x_set_mouse_position (f
, x
, y
)
8461 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
8462 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
8464 if (pix_x
< 0) pix_x
= 0;
8465 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
8467 if (pix_y
< 0) pix_y
= 0;
8468 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
8472 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8473 0, 0, 0, 0, pix_x
, pix_y
);
8477 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
8480 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
8486 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
8487 0, 0, 0, 0, pix_x
, pix_y
);
8491 /* focus shifting, raising and lowering. */
8494 x_focus_on_frame (f
)
8497 #if 0 /* This proves to be unpleasant. */
8501 /* I don't think that the ICCCM allows programs to do things like this
8502 without the interaction of the window manager. Whatever you end up
8503 doing with this code, do it to x_unfocus_frame too. */
8504 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
8505 RevertToPointerRoot
, CurrentTime
);
8514 /* Look at the remarks in x_focus_on_frame. */
8515 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
8516 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
8517 RevertToPointerRoot
, CurrentTime
);
8521 /* Raise frame F. */
8527 if (f
->async_visible
)
8530 XRaiseWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8531 XFlush (FRAME_X_DISPLAY (f
));
8536 /* Lower frame F. */
8542 if (f
->async_visible
)
8545 XLowerWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
));
8546 XFlush (FRAME_X_DISPLAY (f
));
8552 XTframe_raise_lower (f
, raise_flag
)
8562 /* Change of visibility. */
8564 /* This tries to wait until the frame is really visible.
8565 However, if the window manager asks the user where to position
8566 the frame, this will return before the user finishes doing that.
8567 The frame will not actually be visible at that time,
8568 but it will become visible later when the window manager
8569 finishes with it. */
8572 x_make_frame_visible (f
)
8576 int original_top
, original_left
;
8577 int retry_count
= 2;
8583 type
= x_icon_type (f
);
8585 x_bitmap_icon (f
, type
);
8587 if (! FRAME_VISIBLE_P (f
))
8589 /* We test FRAME_GARBAGED_P here to make sure we don't
8590 call x_set_offset a second time
8591 if we get to x_make_frame_visible a second time
8592 before the window gets really visible. */
8593 if (! FRAME_ICONIFIED_P (f
)
8594 && ! f
->output_data
.x
->asked_for_visible
)
8595 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
8597 f
->output_data
.x
->asked_for_visible
= 1;
8599 if (! EQ (Vx_no_window_manager
, Qt
))
8600 x_wm_set_window_state (f
, NormalState
);
8601 #ifdef USE_X_TOOLKIT
8602 /* This was XtPopup, but that did nothing for an iconified frame. */
8603 XtMapWidget (f
->output_data
.x
->widget
);
8604 #else /* not USE_X_TOOLKIT */
8606 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
8607 gtk_window_deiconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
8609 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8610 #endif /* not USE_GTK */
8611 #endif /* not USE_X_TOOLKIT */
8612 #if 0 /* This seems to bring back scroll bars in the wrong places
8613 if the window configuration has changed. They seem
8614 to come back ok without this. */
8615 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
8616 XMapSubwindows (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8620 XFlush (FRAME_X_DISPLAY (f
));
8622 /* Synchronize to ensure Emacs knows the frame is visible
8623 before we do anything else. We do this loop with input not blocked
8624 so that incoming events are handled. */
8628 /* This must be before UNBLOCK_INPUT
8629 since events that arrive in response to the actions above
8630 will set it when they are handled. */
8631 int previously_visible
= f
->output_data
.x
->has_been_visible
;
8633 original_left
= f
->left_pos
;
8634 original_top
= f
->top_pos
;
8636 /* This must come after we set COUNT. */
8639 /* We unblock here so that arriving X events are processed. */
8641 /* Now move the window back to where it was "supposed to be".
8642 But don't do it if the gravity is negative.
8643 When the gravity is negative, this uses a position
8644 that is 3 pixels too low. Perhaps that's really the border width.
8646 Don't do this if the window has never been visible before,
8647 because the window manager may choose the position
8648 and we don't want to override it. */
8650 if (! FRAME_VISIBLE_P (f
) && ! FRAME_ICONIFIED_P (f
)
8651 && f
->win_gravity
== NorthWestGravity
8652 && previously_visible
)
8656 unsigned int width
, height
, border
, depth
;
8660 /* On some window managers (such as FVWM) moving an existing
8661 window, even to the same place, causes the window manager
8662 to introduce an offset. This can cause the window to move
8663 to an unexpected location. Check the geometry (a little
8664 slow here) and then verify that the window is in the right
8665 place. If the window is not in the right place, move it
8666 there, and take the potential window manager hit. */
8667 XGetGeometry (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8668 &rootw
, &x
, &y
, &width
, &height
, &border
, &depth
);
8670 if (original_left
!= x
|| original_top
!= y
)
8671 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
8672 original_left
, original_top
);
8677 XSETFRAME (frame
, f
);
8679 /* Wait until the frame is visible. Process X events until a
8680 MapNotify event has been seen, or until we think we won't get a
8681 MapNotify at all.. */
8682 for (count
= input_signal_count
+ 10;
8683 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
8685 /* Force processing of queued events. */
8688 /* Machines that do polling rather than SIGIO have been
8689 observed to go into a busy-wait here. So we'll fake an
8690 alarm signal to let the handler know that there's something
8691 to be read. We used to raise a real alarm, but it seems
8692 that the handler isn't always enabled here. This is
8694 if (input_polling_used ())
8696 /* It could be confusing if a real alarm arrives while
8697 processing the fake one. Turn it off and let the
8698 handler reset it. */
8699 extern void poll_for_input_1
P_ ((void));
8700 int old_poll_suppress_count
= poll_suppress_count
;
8701 poll_suppress_count
= 1;
8702 poll_for_input_1 ();
8703 poll_suppress_count
= old_poll_suppress_count
;
8706 /* See if a MapNotify event has been processed. */
8707 FRAME_SAMPLE_VISIBILITY (f
);
8712 (let ((f (selected-frame)))
8716 the frame is not raised with various window managers on
8717 FreeBSD, GNU/Linux and Solaris. It turns out that, for some
8718 unknown reason, the call to XtMapWidget is completely ignored.
8719 Mapping the widget a second time works. */
8721 if (!FRAME_VISIBLE_P (f
) && --retry_count
> 0)
8726 /* Change from mapped state to withdrawn state. */
8728 /* Make the frame visible (mapped and not iconified). */
8731 x_make_frame_invisible (f
)
8736 /* Use the frame's outermost window, not the one we normally draw on. */
8737 window
= FRAME_OUTER_WINDOW (f
);
8739 /* Don't keep the highlight on an invisible frame. */
8740 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
8741 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
8743 #if 0/* This might add unreliability; I don't trust it -- rms. */
8744 if (! f
->async_visible
&& ! f
->async_iconified
)
8750 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
8751 that the current position of the window is user-specified, rather than
8752 program-specified, so that when the window is mapped again, it will be
8753 placed at the same location, without forcing the user to position it
8754 by hand again (they have already done that once for this window.) */
8755 x_wm_set_size_hint (f
, (long) 0, 1);
8758 if (FRAME_GTK_OUTER_WIDGET (f
))
8759 gtk_widget_hide (FRAME_GTK_OUTER_WIDGET (f
));
8765 if (! XWithdrawWindow (FRAME_X_DISPLAY (f
), window
,
8766 DefaultScreen (FRAME_X_DISPLAY (f
))))
8768 UNBLOCK_INPUT_RESIGNAL
;
8769 error ("Can't notify window manager of window withdrawal");
8771 #else /* ! defined (HAVE_X11R4) */
8773 /* Tell the window manager what we're going to do. */
8774 if (! EQ (Vx_no_window_manager
, Qt
))
8778 unmap
.xunmap
.type
= UnmapNotify
;
8779 unmap
.xunmap
.window
= window
;
8780 unmap
.xunmap
.event
= DefaultRootWindow (FRAME_X_DISPLAY (f
));
8781 unmap
.xunmap
.from_configure
= False
;
8782 if (! XSendEvent (FRAME_X_DISPLAY (f
),
8783 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
8785 SubstructureRedirectMaskSubstructureNotifyMask
,
8788 UNBLOCK_INPUT_RESIGNAL
;
8789 error ("Can't notify window manager of withdrawal");
8793 /* Unmap the window ourselves. Cheeky! */
8794 XUnmapWindow (FRAME_X_DISPLAY (f
), window
);
8795 #endif /* ! defined (HAVE_X11R4) */
8798 /* We can't distinguish this from iconification
8799 just by the event that we get from the server.
8800 So we can't win using the usual strategy of letting
8801 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
8802 and synchronize with the server to make sure we agree. */
8804 FRAME_ICONIFIED_P (f
) = 0;
8805 f
->async_visible
= 0;
8806 f
->async_iconified
= 0;
8813 /* Change window state from mapped to iconified. */
8822 /* Don't keep the highlight on an invisible frame. */
8823 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
8824 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
8826 if (f
->async_iconified
)
8831 FRAME_SAMPLE_VISIBILITY (f
);
8833 type
= x_icon_type (f
);
8835 x_bitmap_icon (f
, type
);
8838 if (FRAME_GTK_OUTER_WIDGET (f
))
8840 if (! FRAME_VISIBLE_P (f
))
8841 gtk_widget_show_all (FRAME_GTK_OUTER_WIDGET (f
));
8843 gtk_window_iconify (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)));
8846 f
->async_iconified
= 1;
8847 f
->async_visible
= 0;
8853 #ifdef USE_X_TOOLKIT
8855 if (! FRAME_VISIBLE_P (f
))
8857 if (! EQ (Vx_no_window_manager
, Qt
))
8858 x_wm_set_window_state (f
, IconicState
);
8859 /* This was XtPopup, but that did nothing for an iconified frame. */
8860 XtMapWidget (f
->output_data
.x
->widget
);
8861 /* The server won't give us any event to indicate
8862 that an invisible frame was changed to an icon,
8863 so we have to record it here. */
8866 f
->async_iconified
= 1;
8867 f
->async_visible
= 0;
8872 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
8873 XtWindow (f
->output_data
.x
->widget
),
8874 DefaultScreen (FRAME_X_DISPLAY (f
)));
8878 error ("Can't notify window manager of iconification");
8880 f
->async_iconified
= 1;
8881 f
->async_visible
= 0;
8885 XFlush (FRAME_X_DISPLAY (f
));
8887 #else /* not USE_X_TOOLKIT */
8889 /* Make sure the X server knows where the window should be positioned,
8890 in case the user deiconifies with the window manager. */
8891 if (! FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P (f
))
8892 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
8894 /* Since we don't know which revision of X we're running, we'll use both
8895 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
8897 /* X11R4: send a ClientMessage to the window manager using the
8898 WM_CHANGE_STATE type. */
8902 message
.xclient
.window
= FRAME_X_WINDOW (f
);
8903 message
.xclient
.type
= ClientMessage
;
8904 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
8905 message
.xclient
.format
= 32;
8906 message
.xclient
.data
.l
[0] = IconicState
;
8908 if (! XSendEvent (FRAME_X_DISPLAY (f
),
8909 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
8911 SubstructureRedirectMask
| SubstructureNotifyMask
,
8914 UNBLOCK_INPUT_RESIGNAL
;
8915 error ("Can't notify window manager of iconification");
8919 /* X11R3: set the initial_state field of the window manager hints to
8921 x_wm_set_window_state (f
, IconicState
);
8923 if (!FRAME_VISIBLE_P (f
))
8925 /* If the frame was withdrawn, before, we must map it. */
8926 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8929 f
->async_iconified
= 1;
8930 f
->async_visible
= 0;
8932 XFlush (FRAME_X_DISPLAY (f
));
8934 #endif /* not USE_X_TOOLKIT */
8938 /* Free X resources of frame F. */
8941 x_free_frame_resources (f
)
8944 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8946 struct scroll_bar
*b
;
8950 /* If a display connection is dead, don't try sending more
8951 commands to the X server. */
8952 if (dpyinfo
->display
)
8954 if (f
->output_data
.x
->icon_desc
)
8955 XDestroyWindow (FRAME_X_DISPLAY (f
), f
->output_data
.x
->icon_desc
);
8957 #ifdef USE_X_TOOLKIT
8958 /* Explicitly destroy the scroll bars of the frame. Without
8959 this, we get "BadDrawable" errors from the toolkit later on,
8960 presumably from expose events generated for the disappearing
8961 toolkit scroll bars. */
8962 for (bar
= FRAME_SCROLL_BARS (f
); !NILP (bar
); bar
= b
->next
)
8964 b
= XSCROLL_BAR (bar
);
8965 x_scroll_bar_remove (b
);
8974 #ifdef USE_X_TOOLKIT
8975 if (f
->output_data
.x
->widget
)
8977 XtDestroyWidget (f
->output_data
.x
->widget
);
8978 f
->output_data
.x
->widget
= NULL
;
8980 /* Tooltips don't have widgets, only a simple X window, even if
8981 we are using a toolkit. */
8982 else if (FRAME_X_WINDOW (f
))
8983 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
8985 free_frame_menubar (f
);
8986 #else /* !USE_X_TOOLKIT */
8989 /* In the GTK version, tooltips are normal X
8990 frames. We must check and free both types. */
8991 if (FRAME_GTK_OUTER_WIDGET (f
))
8993 gtk_widget_destroy (FRAME_GTK_OUTER_WIDGET (f
));
8994 FRAME_X_WINDOW (f
) = 0; /* Set to avoid XDestroyWindow below */
8995 FRAME_GTK_OUTER_WIDGET (f
) = 0;
8997 #endif /* USE_GTK */
8999 if (FRAME_X_WINDOW (f
))
9000 XDestroyWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9001 #endif /* !USE_X_TOOLKIT */
9003 unload_color (f
, f
->output_data
.x
->foreground_pixel
);
9004 unload_color (f
, f
->output_data
.x
->background_pixel
);
9005 unload_color (f
, f
->output_data
.x
->cursor_pixel
);
9006 unload_color (f
, f
->output_data
.x
->cursor_foreground_pixel
);
9007 unload_color (f
, f
->output_data
.x
->border_pixel
);
9008 unload_color (f
, f
->output_data
.x
->mouse_pixel
);
9010 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
9011 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
9012 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
9013 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
9014 #ifdef USE_TOOLKIT_SCROLL_BARS
9015 /* Scrollbar shadow colors. */
9016 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
9017 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
9018 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
9019 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
9020 #endif /* USE_TOOLKIT_SCROLL_BARS */
9021 if (f
->output_data
.x
->white_relief
.allocated_p
)
9022 unload_color (f
, f
->output_data
.x
->white_relief
.pixel
);
9023 if (f
->output_data
.x
->black_relief
.allocated_p
)
9024 unload_color (f
, f
->output_data
.x
->black_relief
.pixel
);
9026 if (FRAME_FACE_CACHE (f
))
9027 free_frame_faces (f
);
9030 XFlush (FRAME_X_DISPLAY (f
));
9033 if (f
->output_data
.x
->saved_menu_event
)
9034 xfree (f
->output_data
.x
->saved_menu_event
);
9036 xfree (f
->output_data
.x
);
9037 f
->output_data
.x
= NULL
;
9039 if (f
== dpyinfo
->x_focus_frame
)
9040 dpyinfo
->x_focus_frame
= 0;
9041 if (f
== dpyinfo
->x_focus_event_frame
)
9042 dpyinfo
->x_focus_event_frame
= 0;
9043 if (f
== dpyinfo
->x_highlight_frame
)
9044 dpyinfo
->x_highlight_frame
= 0;
9046 if (f
== dpyinfo
->mouse_face_mouse_frame
)
9048 dpyinfo
->mouse_face_beg_row
9049 = dpyinfo
->mouse_face_beg_col
= -1;
9050 dpyinfo
->mouse_face_end_row
9051 = dpyinfo
->mouse_face_end_col
= -1;
9052 dpyinfo
->mouse_face_window
= Qnil
;
9053 dpyinfo
->mouse_face_deferred_gc
= 0;
9054 dpyinfo
->mouse_face_mouse_frame
= 0;
9061 /* Destroy the X window of frame F. */
9064 x_destroy_window (f
)
9067 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9069 /* If a display connection is dead, don't try sending more
9070 commands to the X server. */
9071 if (dpyinfo
->display
!= 0)
9072 x_free_frame_resources (f
);
9074 dpyinfo
->reference_count
--;
9078 /* Setting window manager hints. */
9080 /* Set the normal size hints for the window manager, for frame F.
9081 FLAGS is the flags word to use--or 0 meaning preserve the flags
9082 that the window now has.
9083 If USER_POSITION is nonzero, we set the USPosition
9084 flag (this is useful when FLAGS is 0).
9085 The GTK version is in gtkutils.c */
9089 x_wm_set_size_hint (f
, flags
, user_position
)
9094 XSizeHints size_hints
;
9096 #ifdef USE_X_TOOLKIT
9099 Dimension widget_width
, widget_height
;
9102 Window window
= FRAME_OUTER_WINDOW (f
);
9104 /* Setting PMaxSize caused various problems. */
9105 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
9107 size_hints
.x
= f
->left_pos
;
9108 size_hints
.y
= f
->top_pos
;
9110 #ifdef USE_X_TOOLKIT
9111 XtSetArg (al
[ac
], XtNwidth
, &widget_width
); ac
++;
9112 XtSetArg (al
[ac
], XtNheight
, &widget_height
); ac
++;
9113 XtGetValues (f
->output_data
.x
->widget
, al
, ac
);
9114 size_hints
.height
= widget_height
;
9115 size_hints
.width
= widget_width
;
9116 #else /* not USE_X_TOOLKIT */
9117 size_hints
.height
= FRAME_PIXEL_HEIGHT (f
);
9118 size_hints
.width
= FRAME_PIXEL_WIDTH (f
);
9119 #endif /* not USE_X_TOOLKIT */
9121 size_hints
.width_inc
= FRAME_COLUMN_WIDTH (f
);
9122 size_hints
.height_inc
= FRAME_LINE_HEIGHT (f
);
9123 size_hints
.max_width
9124 = FRAME_X_DISPLAY_INFO (f
)->width
- FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9125 size_hints
.max_height
9126 = FRAME_X_DISPLAY_INFO (f
)->height
- FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9128 /* Calculate the base and minimum sizes.
9130 (When we use the X toolkit, we don't do it here.
9131 Instead we copy the values that the widgets are using, below.) */
9132 #ifndef USE_X_TOOLKIT
9134 int base_width
, base_height
;
9135 int min_rows
= 0, min_cols
= 0;
9137 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
9138 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
9140 check_frame_size (f
, &min_rows
, &min_cols
);
9142 /* The window manager uses the base width hints to calculate the
9143 current number of rows and columns in the frame while
9144 resizing; min_width and min_height aren't useful for this
9145 purpose, since they might not give the dimensions for a
9146 zero-row, zero-column frame.
9148 We use the base_width and base_height members if we have
9149 them; otherwise, we set the min_width and min_height members
9150 to the size for a zero x zero frame. */
9153 size_hints
.flags
|= PBaseSize
;
9154 size_hints
.base_width
= base_width
;
9155 size_hints
.base_height
= base_height
;
9156 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
9157 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
9159 size_hints
.min_width
= base_width
;
9160 size_hints
.min_height
= base_height
;
9164 /* If we don't need the old flags, we don't need the old hint at all. */
9167 size_hints
.flags
|= flags
;
9170 #endif /* not USE_X_TOOLKIT */
9173 XSizeHints hints
; /* Sometimes I hate X Windows... */
9174 long supplied_return
;
9178 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
9181 value
= XGetNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
);
9184 #ifdef USE_X_TOOLKIT
9185 size_hints
.base_height
= hints
.base_height
;
9186 size_hints
.base_width
= hints
.base_width
;
9187 size_hints
.min_height
= hints
.min_height
;
9188 size_hints
.min_width
= hints
.min_width
;
9192 size_hints
.flags
|= flags
;
9197 if (hints
.flags
& PSize
)
9198 size_hints
.flags
|= PSize
;
9199 if (hints
.flags
& PPosition
)
9200 size_hints
.flags
|= PPosition
;
9201 if (hints
.flags
& USPosition
)
9202 size_hints
.flags
|= USPosition
;
9203 if (hints
.flags
& USSize
)
9204 size_hints
.flags
|= USSize
;
9208 #ifndef USE_X_TOOLKIT
9213 size_hints
.win_gravity
= f
->win_gravity
;
9214 size_hints
.flags
|= PWinGravity
;
9218 size_hints
.flags
&= ~ PPosition
;
9219 size_hints
.flags
|= USPosition
;
9221 #endif /* PWinGravity */
9224 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
9226 XSetNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
9229 #endif /* not USE_GTK */
9231 /* Used for IconicState or NormalState */
9234 x_wm_set_window_state (f
, state
)
9238 #ifdef USE_X_TOOLKIT
9241 XtSetArg (al
[0], XtNinitialState
, state
);
9242 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9243 #else /* not USE_X_TOOLKIT */
9244 Window window
= FRAME_X_WINDOW (f
);
9246 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
9247 f
->output_data
.x
->wm_hints
.initial_state
= state
;
9249 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9250 #endif /* not USE_X_TOOLKIT */
9254 x_wm_set_icon_pixmap (f
, pixmap_id
)
9258 Pixmap icon_pixmap
, icon_mask
;
9260 #ifndef USE_X_TOOLKIT
9261 Window window
= FRAME_OUTER_WINDOW (f
);
9266 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
9267 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
9268 icon_mask
= x_bitmap_mask (f
, pixmap_id
);
9269 f
->output_data
.x
->wm_hints
.icon_mask
= icon_mask
;
9273 /* It seems there is no way to turn off use of an icon pixmap.
9274 The following line does it, only if no icon has yet been created,
9275 for some window managers. But with mwm it crashes.
9276 Some people say it should clear the IconPixmapHint bit in this case,
9277 but that doesn't work, and the X consortium said it isn't the
9278 right thing at all. Since there is no way to win,
9279 best to explicitly give up. */
9281 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
9282 f
->output_data
.x
->wm_hints
.icon_mask
= None
;
9291 xg_set_frame_icon (f
, icon_pixmap
, icon_mask
);
9295 #elif defined (USE_X_TOOLKIT) /* same as in x_wm_set_window_state. */
9299 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
9300 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9301 XtSetArg (al
[0], XtNiconMask
, icon_mask
);
9302 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
9305 #else /* not USE_X_TOOLKIT && not USE_GTK */
9307 f
->output_data
.x
->wm_hints
.flags
|= (IconPixmapHint
| IconMaskHint
);
9308 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9310 #endif /* not USE_X_TOOLKIT && not USE_GTK */
9314 x_wm_set_icon_position (f
, icon_x
, icon_y
)
9318 Window window
= FRAME_OUTER_WINDOW (f
);
9320 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
9321 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
9322 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
9324 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
9328 /***********************************************************************
9330 ***********************************************************************/
9332 /* Return a pointer to struct font_info of font FONT_IDX of frame F. */
9335 x_get_font_info (f
, font_idx
)
9339 return (FRAME_X_FONT_TABLE (f
) + font_idx
);
9343 /* Return a list of names of available fonts matching PATTERN on frame F.
9345 If SIZE is > 0, it is the size (maximum bounds width) of fonts
9348 SIZE < 0 means include scalable fonts.
9350 Frame F null means we have not yet created any frame on X, and
9351 consult the first display in x_display_list. MAXNAMES sets a limit
9352 on how many fonts to match. */
9355 x_list_fonts (f
, pattern
, size
, maxnames
)
9357 Lisp_Object pattern
;
9361 Lisp_Object list
= Qnil
, patterns
, newlist
= Qnil
, key
= Qnil
;
9362 Lisp_Object tem
, second_best
;
9363 struct x_display_info
*dpyinfo
9364 = f
? FRAME_X_DISPLAY_INFO (f
) : x_display_list
;
9365 Display
*dpy
= dpyinfo
->display
;
9366 int try_XLoadQueryFont
= 0;
9368 int allow_auto_scaled_font
= 0;
9372 allow_auto_scaled_font
= 1;
9376 patterns
= Fassoc (pattern
, Valternate_fontname_alist
);
9377 if (NILP (patterns
))
9378 patterns
= Fcons (pattern
, Qnil
);
9380 if (maxnames
== 1 && !size
)
9381 /* We can return any single font matching PATTERN. */
9382 try_XLoadQueryFont
= 1;
9384 for (; CONSP (patterns
); patterns
= XCDR (patterns
))
9387 char **names
= NULL
;
9389 pattern
= XCAR (patterns
);
9390 /* See if we cached the result for this particular query.
9391 The cache is an alist of the form:
9392 ((((PATTERN . MAXNAMES) . SCALABLE) (FONTNAME . WIDTH) ...) ...) */
9393 tem
= XCDR (dpyinfo
->name_list_element
);
9394 key
= Fcons (Fcons (pattern
, make_number (maxnames
)),
9395 allow_auto_scaled_font
? Qt
: Qnil
);
9396 list
= Fassoc (key
, tem
);
9399 list
= Fcdr_safe (list
);
9400 /* We have a cashed list. Don't have to get the list again. */
9404 /* At first, put PATTERN in the cache. */
9407 count
= x_catch_errors (dpy
);
9409 if (try_XLoadQueryFont
)
9412 unsigned long value
;
9414 font
= XLoadQueryFont (dpy
, SDATA (pattern
));
9415 if (x_had_errors_p (dpy
))
9417 /* This error is perhaps due to insufficient memory on X
9418 server. Let's just ignore it. */
9420 x_clear_errors (dpy
);
9424 && XGetFontProperty (font
, XA_FONT
, &value
))
9426 char *name
= (char *) XGetAtomName (dpy
, (Atom
) value
);
9427 int len
= strlen (name
);
9430 /* If DXPC (a Differential X Protocol Compressor)
9431 Ver.3.7 is running, XGetAtomName will return null
9432 string. We must avoid such a name. */
9434 try_XLoadQueryFont
= 0;
9438 names
= (char **) alloca (sizeof (char *));
9439 /* Some systems only allow alloca assigned to a
9441 tmp
= (char *) alloca (len
+ 1); names
[0] = tmp
;
9442 bcopy (name
, names
[0], len
+ 1);
9447 try_XLoadQueryFont
= 0;
9450 XFreeFont (dpy
, font
);
9453 if (!try_XLoadQueryFont
)
9455 /* We try at least 10 fonts because XListFonts will return
9456 auto-scaled fonts at the head. */
9463 names
= XListFonts (dpy
, SDATA (pattern
), limit
, &num_fonts
);
9464 if (num_fonts
== limit
)
9467 XFreeFontNames (names
);
9476 names
= XListFonts (dpy
, SDATA (pattern
), max (maxnames
, 10),
9479 if (x_had_errors_p (dpy
))
9481 /* This error is perhaps due to insufficient memory on X
9482 server. Let's just ignore it. */
9484 x_clear_errors (dpy
);
9488 x_uncatch_errors (dpy
, count
);
9495 /* Make a list of all the fonts we got back.
9496 Store that in the font cache for the display. */
9497 for (i
= 0; i
< num_fonts
; i
++)
9501 int average_width
= -1, resx
= 0, dashes
= 0;
9503 /* Count the number of dashes in NAMES[I]. If there are
9504 14 dashes, the field value following 9th dash
9505 (RESOLUTION_X) is nonzero, and the field value
9506 following 12th dash (AVERAGE_WIDTH) is 0, this is a
9507 auto-scaled font which is usually too ugly to be used
9508 for editing. Let's ignore it. */
9513 if (dashes
== 7) /* PIXEL_SIZE field */
9515 else if (dashes
== 9)
9517 else if (dashes
== 12) /* AVERAGE_WIDTH field */
9518 average_width
= atoi (p
);
9521 if (allow_auto_scaled_font
9522 || dashes
< 14 || average_width
!= 0 || resx
== 0)
9524 tem
= build_string (names
[i
]);
9525 if (NILP (Fassoc (tem
, list
)))
9527 if (STRINGP (Vx_pixel_size_width_font_regexp
)
9528 && ((fast_c_string_match_ignore_case
9529 (Vx_pixel_size_width_font_regexp
, names
[i
]))
9531 /* We can set the value of PIXEL_SIZE to the
9532 width of this font. */
9533 list
= Fcons (Fcons (tem
, make_number (width
)), list
);
9535 /* For the moment, width is not known. */
9536 list
= Fcons (Fcons (tem
, Qnil
), list
);
9541 if (!try_XLoadQueryFont
)
9544 XFreeFontNames (names
);
9549 /* Now store the result in the cache. */
9550 XSETCDR (dpyinfo
->name_list_element
,
9551 Fcons (Fcons (key
, list
), XCDR (dpyinfo
->name_list_element
)));
9554 if (NILP (list
)) continue; /* Try the remaining alternatives. */
9556 newlist
= second_best
= Qnil
;
9557 /* Make a list of the fonts that have the right width. */
9558 for (; CONSP (list
); list
= XCDR (list
))
9564 if (!CONSP (tem
) || NILP (XCAR (tem
)))
9568 newlist
= Fcons (XCAR (tem
), newlist
);
9572 if (!INTEGERP (XCDR (tem
)))
9574 /* Since we have not yet known the size of this font, we
9575 must try slow function call XLoadQueryFont. */
9576 XFontStruct
*thisinfo
;
9579 count
= x_catch_errors (dpy
);
9580 thisinfo
= XLoadQueryFont (dpy
,
9581 SDATA (XCAR (tem
)));
9582 if (x_had_errors_p (dpy
))
9584 /* This error is perhaps due to insufficient memory on X
9585 server. Let's just ignore it. */
9587 x_clear_errors (dpy
);
9589 x_uncatch_errors (dpy
, count
);
9595 (thisinfo
->min_bounds
.width
== 0
9597 : make_number (thisinfo
->max_bounds
.width
)));
9599 XFreeFont (dpy
, thisinfo
);
9603 /* For unknown reason, the previous call of XListFont had
9604 returned a font which can't be opened. Record the size
9605 as 0 not to try to open it again. */
9606 XSETCDR (tem
, make_number (0));
9609 found_size
= XINT (XCDR (tem
));
9610 if (found_size
== size
)
9611 newlist
= Fcons (XCAR (tem
), newlist
);
9612 else if (found_size
> 0)
9614 if (NILP (second_best
))
9616 else if (found_size
< size
)
9618 if (XINT (XCDR (second_best
)) > size
9619 || XINT (XCDR (second_best
)) < found_size
)
9624 if (XINT (XCDR (second_best
)) > size
9625 && XINT (XCDR (second_best
)) > found_size
)
9630 if (!NILP (newlist
))
9632 else if (!NILP (second_best
))
9634 newlist
= Fcons (XCAR (second_best
), Qnil
);
9645 /* Check that FONT is valid on frame F. It is if it can be found in F's
9649 x_check_font (f
, font
)
9654 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9656 xassert (font
!= NULL
);
9658 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
9659 if (dpyinfo
->font_table
[i
].name
9660 && font
== dpyinfo
->font_table
[i
].font
)
9663 xassert (i
< dpyinfo
->n_fonts
);
9666 #endif /* GLYPH_DEBUG != 0 */
9668 /* Set *W to the minimum width, *H to the minimum font height of FONT.
9669 Note: There are (broken) X fonts out there with invalid XFontStruct
9670 min_bounds contents. For example, handa@etl.go.jp reports that
9671 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
9672 have font->min_bounds.width == 0. */
9675 x_font_min_bounds (font
, w
, h
)
9679 *h
= FONT_HEIGHT (font
);
9680 *w
= font
->min_bounds
.width
;
9682 /* Try to handle the case where FONT->min_bounds has invalid
9683 contents. Since the only font known to have invalid min_bounds
9684 is fixed-width, use max_bounds if min_bounds seems to be invalid. */
9686 *w
= font
->max_bounds
.width
;
9690 /* Compute the smallest character width and smallest font height over
9691 all fonts available on frame F. Set the members smallest_char_width
9692 and smallest_font_height in F's x_display_info structure to
9693 the values computed. Value is non-zero if smallest_font_height or
9694 smallest_char_width become smaller than they were before. */
9697 x_compute_min_glyph_bounds (f
)
9701 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9703 int old_width
= dpyinfo
->smallest_char_width
;
9704 int old_height
= dpyinfo
->smallest_font_height
;
9706 dpyinfo
->smallest_font_height
= 100000;
9707 dpyinfo
->smallest_char_width
= 100000;
9709 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
9710 if (dpyinfo
->font_table
[i
].name
)
9712 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
9715 font
= (XFontStruct
*) fontp
->font
;
9716 xassert (font
!= (XFontStruct
*) ~0);
9717 x_font_min_bounds (font
, &w
, &h
);
9719 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
9720 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
9723 xassert (dpyinfo
->smallest_char_width
> 0
9724 && dpyinfo
->smallest_font_height
> 0);
9726 return (dpyinfo
->n_fonts
== 1
9727 || dpyinfo
->smallest_char_width
< old_width
9728 || dpyinfo
->smallest_font_height
< old_height
);
9732 /* Load font named FONTNAME of the size SIZE for frame F, and return a
9733 pointer to the structure font_info while allocating it dynamically.
9734 If SIZE is 0, load any size of font.
9735 If loading is failed, return NULL. */
9738 x_load_font (f
, fontname
, size
)
9740 register char *fontname
;
9743 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9744 Lisp_Object font_names
;
9747 /* Get a list of all the fonts that match this name. Once we
9748 have a list of matching fonts, we compare them against the fonts
9749 we already have by comparing names. */
9750 font_names
= x_list_fonts (f
, build_string (fontname
), size
, 1);
9752 if (!NILP (font_names
))
9757 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
9758 for (tail
= font_names
; CONSP (tail
); tail
= XCDR (tail
))
9759 if (dpyinfo
->font_table
[i
].name
9760 && (!strcmp (dpyinfo
->font_table
[i
].name
,
9761 SDATA (XCAR (tail
)))
9762 || !strcmp (dpyinfo
->font_table
[i
].full_name
,
9763 SDATA (XCAR (tail
)))))
9764 return (dpyinfo
->font_table
+ i
);
9767 /* Load the font and add it to the table. */
9771 struct font_info
*fontp
;
9772 unsigned long value
;
9775 /* If we have found fonts by x_list_font, load one of them. If
9776 not, we still try to load a font by the name given as FONTNAME
9777 because XListFonts (called in x_list_font) of some X server has
9778 a bug of not finding a font even if the font surely exists and
9779 is loadable by XLoadQueryFont. */
9780 if (size
> 0 && !NILP (font_names
))
9781 fontname
= (char *) SDATA (XCAR (font_names
));
9784 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
9785 font
= (XFontStruct
*) XLoadQueryFont (FRAME_X_DISPLAY (f
), fontname
);
9786 if (x_had_errors_p (FRAME_X_DISPLAY (f
)))
9788 /* This error is perhaps due to insufficient memory on X
9789 server. Let's just ignore it. */
9791 x_clear_errors (FRAME_X_DISPLAY (f
));
9793 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
9798 /* Find a free slot in the font table. */
9799 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
9800 if (dpyinfo
->font_table
[i
].name
== NULL
)
9803 /* If no free slot found, maybe enlarge the font table. */
9804 if (i
== dpyinfo
->n_fonts
9805 && dpyinfo
->n_fonts
== dpyinfo
->font_table_size
)
9808 dpyinfo
->font_table_size
= max (16, 2 * dpyinfo
->font_table_size
);
9809 sz
= dpyinfo
->font_table_size
* sizeof *dpyinfo
->font_table
;
9811 = (struct font_info
*) xrealloc (dpyinfo
->font_table
, sz
);
9814 fontp
= dpyinfo
->font_table
+ i
;
9815 if (i
== dpyinfo
->n_fonts
)
9818 /* Now fill in the slots of *FONTP. */
9820 bzero (fontp
, sizeof (*fontp
));
9822 fontp
->font_idx
= i
;
9823 fontp
->name
= (char *) xmalloc (strlen (fontname
) + 1);
9824 bcopy (fontname
, fontp
->name
, strlen (fontname
) + 1);
9826 if (font
->min_bounds
.width
== font
->max_bounds
.width
)
9828 /* Fixed width font. */
9829 fontp
->average_width
= fontp
->space_width
= font
->min_bounds
.width
;
9836 char2b
.byte1
= 0x00, char2b
.byte2
= 0x20;
9837 pcm
= x_per_char_metric (font
, &char2b
, 0);
9839 fontp
->space_width
= pcm
->width
;
9841 fontp
->space_width
= FONT_WIDTH (font
);
9843 fontp
->average_width
9844 = (XGetFontProperty (font
, dpyinfo
->Xatom_AVERAGE_WIDTH
, &value
)
9845 ? (long) value
/ 10 : 0);
9846 if (fontp
->average_width
< 0)
9847 fontp
->average_width
= - fontp
->average_width
;
9848 if (fontp
->average_width
== 0)
9852 int width
= pcm
->width
;
9853 for (char2b
.byte2
= 33; char2b
.byte2
<= 126; char2b
.byte2
++)
9854 if ((pcm
= x_per_char_metric (font
, &char2b
, 0)) != NULL
)
9855 width
+= pcm
->width
;
9856 fontp
->average_width
= width
/ 95;
9859 fontp
->average_width
= FONT_WIDTH (font
);
9863 /* Try to get the full name of FONT. Put it in FULL_NAME. */
9865 if (XGetFontProperty (font
, XA_FONT
, &value
))
9867 char *name
= (char *) XGetAtomName (FRAME_X_DISPLAY (f
), (Atom
) value
);
9871 /* Count the number of dashes in the "full name".
9872 If it is too few, this isn't really the font's full name,
9874 In X11R4, the fonts did not come with their canonical names
9885 full_name
= (char *) xmalloc (p
- name
+ 1);
9886 bcopy (name
, full_name
, p
- name
+ 1);
9893 fontp
->full_name
= full_name
;
9895 fontp
->full_name
= fontp
->name
;
9897 fontp
->size
= font
->max_bounds
.width
;
9898 fontp
->height
= FONT_HEIGHT (font
);
9900 if (NILP (font_names
))
9902 /* We come here because of a bug of XListFonts mentioned at
9903 the head of this block. Let's store this information in
9904 the cache for x_list_fonts. */
9905 Lisp_Object lispy_name
= build_string (fontname
);
9906 Lisp_Object lispy_full_name
= build_string (fontp
->full_name
);
9907 Lisp_Object key
= Fcons (Fcons (lispy_name
, make_number (256)),
9910 XSETCDR (dpyinfo
->name_list_element
,
9912 Fcons (Fcons (lispy_full_name
,
9913 make_number (fontp
->size
)),
9915 XCDR (dpyinfo
->name_list_element
)));
9918 key
= Fcons (Fcons (lispy_full_name
, make_number (256)),
9920 XSETCDR (dpyinfo
->name_list_element
,
9922 Fcons (Fcons (lispy_full_name
,
9923 make_number (fontp
->size
)),
9925 XCDR (dpyinfo
->name_list_element
)));
9929 /* The slot `encoding' specifies how to map a character
9930 code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
9931 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
9932 (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
9933 2:0xA020..0xFF7F). For the moment, we don't know which charset
9934 uses this font. So, we set information in fontp->encoding[1]
9935 which is never used by any charset. If mapping can't be
9936 decided, set FONT_ENCODING_NOT_DECIDED. */
9938 = (font
->max_byte1
== 0
9940 ? (font
->min_char_or_byte2
< 0x80
9941 ? (font
->max_char_or_byte2
< 0x80
9942 ? 0 /* 0x20..0x7F */
9943 : FONT_ENCODING_NOT_DECIDED
) /* 0x20..0xFF */
9944 : 1) /* 0xA0..0xFF */
9946 : (font
->min_byte1
< 0x80
9947 ? (font
->max_byte1
< 0x80
9948 ? (font
->min_char_or_byte2
< 0x80
9949 ? (font
->max_char_or_byte2
< 0x80
9950 ? 0 /* 0x2020..0x7F7F */
9951 : FONT_ENCODING_NOT_DECIDED
) /* 0x2020..0x7FFF */
9952 : 3) /* 0x20A0..0x7FFF */
9953 : FONT_ENCODING_NOT_DECIDED
) /* 0x20??..0xA0?? */
9954 : (font
->min_char_or_byte2
< 0x80
9955 ? (font
->max_char_or_byte2
< 0x80
9956 ? 2 /* 0xA020..0xFF7F */
9957 : FONT_ENCODING_NOT_DECIDED
) /* 0xA020..0xFFFF */
9958 : 1))); /* 0xA0A0..0xFFFF */
9960 fontp
->baseline_offset
9961 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_BASELINE_OFFSET
, &value
)
9962 ? (long) value
: 0);
9963 fontp
->relative_compose
9964 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
, &value
)
9965 ? (long) value
: 0);
9966 fontp
->default_ascent
9967 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
, &value
)
9968 ? (long) value
: 0);
9970 /* Set global flag fonts_changed_p to non-zero if the font loaded
9971 has a character with a smaller width than any other character
9972 before, or if the font loaded has a smaller height than any
9973 other font loaded before. If this happens, it will make a
9974 glyph matrix reallocation necessary. */
9975 fonts_changed_p
|= x_compute_min_glyph_bounds (f
);
9982 /* Return a pointer to struct font_info of a font named FONTNAME for
9983 frame F. If no such font is loaded, return NULL. */
9986 x_query_font (f
, fontname
)
9988 register char *fontname
;
9990 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
9993 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
9994 if (dpyinfo
->font_table
[i
].name
9995 && (!strcmp (dpyinfo
->font_table
[i
].name
, fontname
)
9996 || !strcmp (dpyinfo
->font_table
[i
].full_name
, fontname
)))
9997 return (dpyinfo
->font_table
+ i
);
10002 /* Find a CCL program for a font specified by FONTP, and set the member
10003 `encoder' of the structure. */
10006 x_find_ccl_program (fontp
)
10007 struct font_info
*fontp
;
10009 Lisp_Object list
, elt
;
10012 for (list
= Vfont_ccl_encoder_alist
; CONSP (list
); list
= XCDR (list
))
10016 && STRINGP (XCAR (elt
))
10017 && ((fast_c_string_match_ignore_case (XCAR (elt
), fontp
->name
)
10019 || (fast_c_string_match_ignore_case (XCAR (elt
), fontp
->full_name
)
10026 struct ccl_program
*ccl
10027 = (struct ccl_program
*) xmalloc (sizeof (struct ccl_program
));
10029 if (setup_ccl_program (ccl
, XCDR (elt
)) < 0)
10032 fontp
->font_encoder
= ccl
;
10038 /***********************************************************************
10040 ***********************************************************************/
10042 #ifdef USE_X_TOOLKIT
10043 static XrmOptionDescRec emacs_options
[] = {
10044 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
10045 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
10047 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
10048 XrmoptionSepArg
, NULL
},
10049 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
10051 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10052 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10053 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10054 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
10055 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
10056 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
10057 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
10059 #endif /* USE_X_TOOLKIT */
10061 static int x_initialized
;
10063 #ifdef MULTI_KBOARD
10064 /* Test whether two display-name strings agree up to the dot that separates
10065 the screen number from the server number. */
10067 same_x_server (name1
, name2
)
10068 const char *name1
, *name2
;
10070 int seen_colon
= 0;
10071 const unsigned char *system_name
= SDATA (Vsystem_name
);
10072 int system_name_length
= strlen (system_name
);
10073 int length_until_period
= 0;
10075 while (system_name
[length_until_period
] != 0
10076 && system_name
[length_until_period
] != '.')
10077 length_until_period
++;
10079 /* Treat `unix' like an empty host name. */
10080 if (! strncmp (name1
, "unix:", 5))
10082 if (! strncmp (name2
, "unix:", 5))
10084 /* Treat this host's name like an empty host name. */
10085 if (! strncmp (name1
, system_name
, system_name_length
)
10086 && name1
[system_name_length
] == ':')
10087 name1
+= system_name_length
;
10088 if (! strncmp (name2
, system_name
, system_name_length
)
10089 && name2
[system_name_length
] == ':')
10090 name2
+= system_name_length
;
10091 /* Treat this host's domainless name like an empty host name. */
10092 if (! strncmp (name1
, system_name
, length_until_period
)
10093 && name1
[length_until_period
] == ':')
10094 name1
+= length_until_period
;
10095 if (! strncmp (name2
, system_name
, length_until_period
)
10096 && name2
[length_until_period
] == ':')
10097 name2
+= length_until_period
;
10099 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
10103 if (seen_colon
&& *name1
== '.')
10107 && (*name1
== '.' || *name1
== '\0')
10108 && (*name2
== '.' || *name2
== '\0'));
10112 /* Count number of set bits in mask and number of bits to shift to
10113 get to the first bit. With MASK 0x7e0, *BITS is set to 6, and *OFFSET
10116 get_bits_and_offset (mask
, bits
, offset
)
10117 unsigned long mask
;
10124 while (!(mask
& 1))
10140 struct x_display_info
*
10141 x_term_init (display_name
, xrm_option
, resource_name
)
10142 Lisp_Object display_name
;
10144 char *resource_name
;
10148 struct device
*device
;
10149 struct x_display_info
*dpyinfo
;
10154 if (!x_initialized
)
10162 #define NUM_ARGV 10
10164 char *argv
[NUM_ARGV
];
10165 char **argv2
= argv
;
10168 if (x_initialized
++ > 1)
10170 /* Opening another display. If xg_display_open returns less
10171 than zero, we are probably on GTK 2.0, which can only handle
10172 one display. GTK 2.2 or later can handle more than one. */
10173 if (xg_display_open (SDATA (display_name
), &dpy
) < 0)
10174 error ("Sorry, this version of GTK can only handle one display");
10178 for (argc
= 0; argc
< NUM_ARGV
; ++argc
)
10182 argv
[argc
++] = initial_argv
[0];
10184 if (! NILP (display_name
))
10186 argv
[argc
++] = "--display";
10187 argv
[argc
++] = SDATA (display_name
);
10190 argv
[argc
++] = "--name";
10191 argv
[argc
++] = resource_name
;
10194 XSetLocaleModifiers ("");
10197 gtk_init (&argc
, &argv2
);
10199 /* gtk_init does set_locale. We must fix locale after calling it. */
10203 dpy
= GDK_DISPLAY ();
10205 /* NULL window -> events for all windows go to our function */
10206 gdk_window_add_filter (NULL
, event_handler_gdk
, NULL
);
10208 /* Load our own gtkrc if it exists. */
10210 struct gcpro gcpro1
, gcpro2
;
10211 char *file
= "~/.emacs.d/gtkrc";
10212 Lisp_Object s
, abs_file
;
10214 GCPRO2 (s
, abs_file
);
10215 s
= make_string (file
, strlen (file
));
10216 abs_file
= Fexpand_file_name (s
, Qnil
);
10218 if (! NILP (abs_file
) && !NILP (Ffile_readable_p (abs_file
)))
10219 gtk_rc_parse (SDATA (abs_file
));
10224 XSetErrorHandler (x_error_handler
);
10225 XSetIOErrorHandler (x_io_error_quitter
);
10228 #else /* not USE_GTK */
10229 #ifdef USE_X_TOOLKIT
10230 /* weiner@footloose.sps.mot.com reports that this causes
10232 X protocol error: BadAtom (invalid Atom parameter)
10233 on protocol request 18skiloaf.
10234 So let's not use it until R6. */
10235 #ifdef HAVE_X11XTR6
10236 XtSetLanguageProc (NULL
, NULL
, NULL
);
10247 argv
[argc
++] = "-xrm";
10248 argv
[argc
++] = xrm_option
;
10250 turn_on_atimers (0);
10251 dpy
= XtOpenDisplay (Xt_app_con
, SDATA (display_name
),
10252 resource_name
, EMACS_CLASS
,
10253 emacs_options
, XtNumber (emacs_options
),
10255 turn_on_atimers (1);
10257 #ifdef HAVE_X11XTR6
10258 /* I think this is to compensate for XtSetLanguageProc. */
10263 #else /* not USE_X_TOOLKIT */
10265 XSetLocaleModifiers ("");
10267 dpy
= XOpenDisplay (SDATA (display_name
));
10268 #endif /* not USE_X_TOOLKIT */
10269 #endif /* not USE_GTK*/
10271 /* Detect failure. */
10278 /* We have definitely succeeded. Record the new connection. */
10280 dpyinfo
= (struct x_display_info
*) xmalloc (sizeof (struct x_display_info
));
10281 bzero (dpyinfo
, sizeof *dpyinfo
);
10283 device
= x_create_device (dpyinfo
);
10285 #ifdef MULTI_KBOARD
10287 struct x_display_info
*share
;
10290 for (share
= x_display_list
, tail
= x_display_name_list
; share
;
10291 share
= share
->next
, tail
= XCDR (tail
))
10292 if (same_x_server (SDATA (XCAR (XCAR (tail
))),
10293 SDATA (display_name
)))
10296 device
->kboard
= share
->device
->kboard
;
10299 device
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
10300 init_kboard (device
->kboard
);
10301 if (!EQ (XSYMBOL (Qvendor_specific_keysyms
)->function
, Qunbound
))
10303 char *vendor
= ServerVendor (dpy
);
10305 device
->kboard
->Vsystem_key_alist
10306 = call1 (Qvendor_specific_keysyms
,
10307 build_string (vendor
? vendor
: ""));
10311 device
->kboard
->next_kboard
= all_kboards
;
10312 all_kboards
= device
->kboard
;
10313 /* Don't let the initial kboard remain current longer than necessary.
10314 That would cause problems if a file loaded on startup tries to
10315 prompt in the mini-buffer. */
10316 if (current_kboard
== initial_kboard
)
10317 current_kboard
= device
->kboard
;
10319 device
->kboard
->reference_count
++;
10323 /* Put this display on the chain. */
10324 dpyinfo
->next
= x_display_list
;
10325 x_display_list
= dpyinfo
;
10327 /* Put it on x_display_name_list as well, to keep them parallel. */
10328 x_display_name_list
= Fcons (Fcons (display_name
, Qnil
),
10329 x_display_name_list
);
10330 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
10332 dpyinfo
->display
= dpy
;
10334 /* Set the name of the device. */
10335 device
->name
= (char *) xmalloc (SBYTES (display_name
) + 1);
10336 strncpy (device
->name
, SDATA (display_name
), SBYTES (display_name
));
10337 device
->name
[SBYTES (display_name
)] = 0;
10340 XSetAfterFunction (x_current_display
, x_trace_wire
);
10344 = (char *) xmalloc (SBYTES (Vinvocation_name
)
10345 + SBYTES (Vsystem_name
)
10347 sprintf (dpyinfo
->x_id_name
, "%s@%s",
10348 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
10350 /* Figure out which modifier bits mean what. */
10351 x_find_modifier_meanings (dpyinfo
);
10353 /* Get the scroll bar cursor. */
10355 /* We must create a GTK cursor, it is required for GTK widgets. */
10356 dpyinfo
->xg_cursor
= xg_create_default_cursor (dpyinfo
->display
);
10357 #endif /* USE_GTK */
10359 dpyinfo
->vertical_scroll_bar_cursor
10360 = XCreateFontCursor (dpyinfo
->display
, XC_sb_v_double_arrow
);
10362 xrdb
= x_load_resources (dpyinfo
->display
, xrm_option
,
10363 resource_name
, EMACS_CLASS
);
10364 #ifdef HAVE_XRMSETDATABASE
10365 XrmSetDatabase (dpyinfo
->display
, xrdb
);
10367 dpyinfo
->display
->db
= xrdb
;
10369 /* Put the rdb where we can find it in a way that works on
10371 dpyinfo
->xrdb
= xrdb
;
10373 dpyinfo
->screen
= ScreenOfDisplay (dpyinfo
->display
,
10374 DefaultScreen (dpyinfo
->display
));
10375 select_visual (dpyinfo
);
10376 dpyinfo
->cmap
= DefaultColormapOfScreen (dpyinfo
->screen
);
10377 dpyinfo
->height
= HeightOfScreen (dpyinfo
->screen
);
10378 dpyinfo
->width
= WidthOfScreen (dpyinfo
->screen
);
10379 dpyinfo
->root_window
= RootWindowOfScreen (dpyinfo
->screen
);
10380 dpyinfo
->client_leader_window
= 0;
10381 dpyinfo
->grabbed
= 0;
10382 dpyinfo
->reference_count
= 0;
10383 dpyinfo
->icon_bitmap_id
= -1;
10384 dpyinfo
->font_table
= NULL
;
10385 dpyinfo
->n_fonts
= 0;
10386 dpyinfo
->font_table_size
= 0;
10387 dpyinfo
->bitmaps
= 0;
10388 dpyinfo
->bitmaps_size
= 0;
10389 dpyinfo
->bitmaps_last
= 0;
10390 dpyinfo
->scratch_cursor_gc
= 0;
10391 dpyinfo
->mouse_face_mouse_frame
= 0;
10392 dpyinfo
->mouse_face_deferred_gc
= 0;
10393 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
10394 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
10395 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
10396 dpyinfo
->mouse_face_window
= Qnil
;
10397 dpyinfo
->mouse_face_overlay
= Qnil
;
10398 dpyinfo
->mouse_face_mouse_x
= dpyinfo
->mouse_face_mouse_y
= 0;
10399 dpyinfo
->mouse_face_defer
= 0;
10400 dpyinfo
->mouse_face_hidden
= 0;
10401 dpyinfo
->x_focus_frame
= 0;
10402 dpyinfo
->x_focus_event_frame
= 0;
10403 dpyinfo
->x_highlight_frame
= 0;
10404 dpyinfo
->image_cache
= make_image_cache ();
10405 dpyinfo
->wm_type
= X_WMTYPE_UNKNOWN
;
10407 /* See if we can construct pixel values from RGB values. */
10408 dpyinfo
->red_bits
= dpyinfo
->blue_bits
= dpyinfo
->green_bits
= 0;
10409 dpyinfo
->red_offset
= dpyinfo
->blue_offset
= dpyinfo
->green_offset
= 0;
10411 if (dpyinfo
->visual
->class == TrueColor
)
10413 get_bits_and_offset (dpyinfo
->visual
->red_mask
,
10414 &dpyinfo
->red_bits
, &dpyinfo
->red_offset
);
10415 get_bits_and_offset (dpyinfo
->visual
->blue_mask
,
10416 &dpyinfo
->blue_bits
, &dpyinfo
->blue_offset
);
10417 get_bits_and_offset (dpyinfo
->visual
->green_mask
,
10418 &dpyinfo
->green_bits
, &dpyinfo
->green_offset
);
10421 /* See if a private colormap is requested. */
10422 if (dpyinfo
->visual
== DefaultVisualOfScreen (dpyinfo
->screen
))
10424 if (dpyinfo
->visual
->class == PseudoColor
)
10427 value
= display_x_get_resource (dpyinfo
,
10428 build_string ("privateColormap"),
10429 build_string ("PrivateColormap"),
10431 if (STRINGP (value
)
10432 && (!strcmp (SDATA (value
), "true")
10433 || !strcmp (SDATA (value
), "on")))
10434 dpyinfo
->cmap
= XCopyColormapAndFree (dpyinfo
->display
, dpyinfo
->cmap
);
10438 dpyinfo
->cmap
= XCreateColormap (dpyinfo
->display
, dpyinfo
->root_window
,
10439 dpyinfo
->visual
, AllocNone
);
10442 int screen_number
= XScreenNumberOfScreen (dpyinfo
->screen
);
10443 double pixels
= DisplayHeight (dpyinfo
->display
, screen_number
);
10444 double mm
= DisplayHeightMM (dpyinfo
->display
, screen_number
);
10445 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10446 dpyinfo
->resy
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10447 pixels
= DisplayWidth (dpyinfo
->display
, screen_number
);
10448 /* Mac OS X 10.3's Xserver sometimes reports 0.0mm. */
10449 mm
= DisplayWidthMM (dpyinfo
->display
, screen_number
);
10450 dpyinfo
->resx
= (mm
< 1) ? 100 : pixels
* 25.4 / mm
;
10453 dpyinfo
->Xatom_wm_protocols
10454 = XInternAtom (dpyinfo
->display
, "WM_PROTOCOLS", False
);
10455 dpyinfo
->Xatom_wm_take_focus
10456 = XInternAtom (dpyinfo
->display
, "WM_TAKE_FOCUS", False
);
10457 dpyinfo
->Xatom_wm_save_yourself
10458 = XInternAtom (dpyinfo
->display
, "WM_SAVE_YOURSELF", False
);
10459 dpyinfo
->Xatom_wm_delete_window
10460 = XInternAtom (dpyinfo
->display
, "WM_DELETE_WINDOW", False
);
10461 dpyinfo
->Xatom_wm_change_state
10462 = XInternAtom (dpyinfo
->display
, "WM_CHANGE_STATE", False
);
10463 dpyinfo
->Xatom_wm_configure_denied
10464 = XInternAtom (dpyinfo
->display
, "WM_CONFIGURE_DENIED", False
);
10465 dpyinfo
->Xatom_wm_window_moved
10466 = XInternAtom (dpyinfo
->display
, "WM_MOVED", False
);
10467 dpyinfo
->Xatom_wm_client_leader
10468 = XInternAtom (dpyinfo
->display
, "WM_CLIENT_LEADER", False
);
10469 dpyinfo
->Xatom_editres
10470 = XInternAtom (dpyinfo
->display
, "Editres", False
);
10471 dpyinfo
->Xatom_CLIPBOARD
10472 = XInternAtom (dpyinfo
->display
, "CLIPBOARD", False
);
10473 dpyinfo
->Xatom_TIMESTAMP
10474 = XInternAtom (dpyinfo
->display
, "TIMESTAMP", False
);
10475 dpyinfo
->Xatom_TEXT
10476 = XInternAtom (dpyinfo
->display
, "TEXT", False
);
10477 dpyinfo
->Xatom_COMPOUND_TEXT
10478 = XInternAtom (dpyinfo
->display
, "COMPOUND_TEXT", False
);
10479 dpyinfo
->Xatom_UTF8_STRING
10480 = XInternAtom (dpyinfo
->display
, "UTF8_STRING", False
);
10481 dpyinfo
->Xatom_DELETE
10482 = XInternAtom (dpyinfo
->display
, "DELETE", False
);
10483 dpyinfo
->Xatom_MULTIPLE
10484 = XInternAtom (dpyinfo
->display
, "MULTIPLE", False
);
10485 dpyinfo
->Xatom_INCR
10486 = XInternAtom (dpyinfo
->display
, "INCR", False
);
10487 dpyinfo
->Xatom_EMACS_TMP
10488 = XInternAtom (dpyinfo
->display
, "_EMACS_TMP_", False
);
10489 dpyinfo
->Xatom_TARGETS
10490 = XInternAtom (dpyinfo
->display
, "TARGETS", False
);
10491 dpyinfo
->Xatom_NULL
10492 = XInternAtom (dpyinfo
->display
, "NULL", False
);
10493 dpyinfo
->Xatom_ATOM_PAIR
10494 = XInternAtom (dpyinfo
->display
, "ATOM_PAIR", False
);
10495 /* For properties of font. */
10496 dpyinfo
->Xatom_PIXEL_SIZE
10497 = XInternAtom (dpyinfo
->display
, "PIXEL_SIZE", False
);
10498 dpyinfo
->Xatom_AVERAGE_WIDTH
10499 = XInternAtom (dpyinfo
->display
, "AVERAGE_WIDTH", False
);
10500 dpyinfo
->Xatom_MULE_BASELINE_OFFSET
10501 = XInternAtom (dpyinfo
->display
, "_MULE_BASELINE_OFFSET", False
);
10502 dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
10503 = XInternAtom (dpyinfo
->display
, "_MULE_RELATIVE_COMPOSE", False
);
10504 dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
10505 = XInternAtom (dpyinfo
->display
, "_MULE_DEFAULT_ASCENT", False
);
10507 /* Ghostscript support. */
10508 dpyinfo
->Xatom_PAGE
= XInternAtom (dpyinfo
->display
, "PAGE", False
);
10509 dpyinfo
->Xatom_DONE
= XInternAtom (dpyinfo
->display
, "DONE", False
);
10511 dpyinfo
->Xatom_Scrollbar
= XInternAtom (dpyinfo
->display
, "SCROLLBAR",
10514 dpyinfo
->cut_buffers_initialized
= 0;
10516 connection
= ConnectionNumber (dpyinfo
->display
);
10517 dpyinfo
->connection
= connection
;
10522 null_bits
[0] = 0x00;
10524 dpyinfo
->null_pixel
10525 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
10526 null_bits
, 1, 1, (long) 0, (long) 0,
10531 extern int gray_bitmap_width
, gray_bitmap_height
;
10532 extern char *gray_bitmap_bits
;
10534 = XCreatePixmapFromBitmapData (dpyinfo
->display
, dpyinfo
->root_window
,
10536 gray_bitmap_width
, gray_bitmap_height
,
10537 (unsigned long) 1, (unsigned long) 0, 1);
10541 xim_initialize (dpyinfo
, resource_name
);
10544 #ifdef subprocesses
10545 /* This is only needed for distinguishing keyboard and process input. */
10546 if (connection
!= 0)
10547 add_keyboard_wait_descriptor (connection
);
10550 #ifndef F_SETOWN_BUG
10552 #ifdef F_SETOWN_SOCK_NEG
10553 /* stdin is a socket here */
10554 fcntl (connection
, F_SETOWN
, -getpid ());
10555 #else /* ! defined (F_SETOWN_SOCK_NEG) */
10556 fcntl (connection
, F_SETOWN
, getpid ());
10557 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
10558 #endif /* ! defined (F_SETOWN) */
10559 #endif /* F_SETOWN_BUG */
10562 if (interrupt_input
)
10563 init_sigio (connection
);
10564 #endif /* ! defined (SIGIO) */
10567 #ifdef HAVE_X11R5 /* It seems X11R4 lacks XtCvtStringToFont, and XPointer. */
10568 /* Make sure that we have a valid font for dialog boxes
10569 so that Xt does not crash. */
10571 Display
*dpy
= dpyinfo
->display
;
10572 XrmValue d
, fr
, to
;
10576 d
.addr
= (XPointer
)&dpy
;
10577 d
.size
= sizeof (Display
*);
10578 fr
.addr
= XtDefaultFont
;
10579 fr
.size
= sizeof (XtDefaultFont
);
10580 to
.size
= sizeof (Font
*);
10581 to
.addr
= (XPointer
)&font
;
10582 count
= x_catch_errors (dpy
);
10583 if (!XtCallConverter (dpy
, XtCvtStringToFont
, &d
, 1, &fr
, &to
, NULL
))
10585 if (x_had_errors_p (dpy
) || !XQueryFont (dpy
, font
))
10586 XrmPutLineResource (&xrdb
, "Emacs.dialog.*.font: 9x15");
10587 x_uncatch_errors (dpy
, count
);
10592 /* See if we should run in synchronous mode. This is useful
10593 for debugging X code. */
10596 value
= display_x_get_resource (dpyinfo
,
10597 build_string ("synchronous"),
10598 build_string ("Synchronous"),
10600 if (STRINGP (value
)
10601 && (!strcmp (SDATA (value
), "true")
10602 || !strcmp (SDATA (value
), "on")))
10603 XSynchronize (dpyinfo
->display
, True
);
10608 value
= display_x_get_resource (dpyinfo
,
10609 build_string ("useXIM"),
10610 build_string ("UseXIM"),
10613 if (STRINGP (value
)
10614 && (!strcmp (XSTRING (value
)->data
, "false")
10615 || !strcmp (XSTRING (value
)->data
, "off")))
10618 if (STRINGP (value
)
10619 && (!strcmp (XSTRING (value
)->data
, "true")
10620 || !strcmp (XSTRING (value
)->data
, "on")))
10626 /* Only do this for the very first display in the Emacs session.
10627 Ignore X session management when Emacs was first started on a
10629 if (device
->id
== 1)
10630 x_session_initialize (dpyinfo
);
10638 /* Get rid of display DPYINFO, assuming all frames are already gone,
10639 and without sending any more commands to the X server. */
10642 x_delete_display (dpyinfo
)
10643 struct x_display_info
*dpyinfo
;
10648 /* Delete the generic struct device for this X display. */
10649 for (d
= device_list
; d
; d
= d
->next_device
)
10650 if (d
->type
== output_x_window
&& d
->display_info
.x
== dpyinfo
)
10652 /* Close X session management when we close its display. */
10653 if (d
->id
== 1 && x_session_have_connection ())
10660 delete_keyboard_wait_descriptor (dpyinfo
->connection
);
10662 /* Discard this display from x_display_name_list and x_display_list.
10663 We can't use Fdelq because that can quit. */
10664 if (! NILP (x_display_name_list
)
10665 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
10666 x_display_name_list
= XCDR (x_display_name_list
);
10671 tail
= x_display_name_list
;
10672 while (CONSP (tail
) && CONSP (XCDR (tail
)))
10674 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
10676 XSETCDR (tail
, XCDR (XCDR (tail
)));
10679 tail
= XCDR (tail
);
10683 if (next_noop_dpyinfo
== dpyinfo
)
10684 next_noop_dpyinfo
= dpyinfo
->next
;
10686 if (x_display_list
== dpyinfo
)
10687 x_display_list
= dpyinfo
->next
;
10690 struct x_display_info
*tail
;
10692 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
10693 if (tail
->next
== dpyinfo
)
10694 tail
->next
= tail
->next
->next
;
10697 #ifndef USE_X_TOOLKIT /* I'm told Xt does this itself. */
10698 #ifndef AIX /* On AIX, XCloseDisplay calls this. */
10699 XrmDestroyDatabase (dpyinfo
->xrdb
);
10704 xim_close_dpy (dpyinfo
);
10707 /* Free the font names in the font table. */
10708 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
10709 if (dpyinfo
->font_table
[i
].name
)
10711 if (dpyinfo
->font_table
[i
].name
!= dpyinfo
->font_table
[i
].full_name
)
10712 xfree (dpyinfo
->font_table
[i
].full_name
);
10713 xfree (dpyinfo
->font_table
[i
].name
);
10716 if (dpyinfo
->font_table
&& dpyinfo
->font_table
->font_encoder
)
10717 xfree (dpyinfo
->font_table
->font_encoder
);
10719 if (dpyinfo
->font_table
)
10720 xfree (dpyinfo
->font_table
);
10721 xfree (dpyinfo
->x_id_name
);
10722 xfree (dpyinfo
->color_cells
);
10726 #ifdef USE_X_TOOLKIT
10728 /* Atimer callback function for TIMER. Called every 0.1s to process
10729 Xt timeouts, if needed. We must avoid calling XtAppPending as
10730 much as possible because that function does an implicit XFlush
10731 that slows us down. */
10734 x_process_timeouts (timer
)
10735 struct atimer
*timer
;
10737 if (toolkit_scroll_bar_interaction
|| popup_activated ())
10740 while (XtAppPending (Xt_app_con
) & XtIMTimer
)
10741 XtAppProcessEvent (Xt_app_con
, XtIMTimer
);
10746 #endif /* USE_X_TOOLKIT */
10749 /* Set up use of X before we make the first connection. */
10751 extern frame_parm_handler x_frame_parm_handlers
[];
10753 static struct redisplay_interface x_redisplay_interface
=
10755 x_frame_parm_handlers
,
10759 x_clear_end_of_line
,
10761 x_after_update_window_line
,
10762 x_update_window_begin
,
10763 x_update_window_end
,
10769 0, /* flush_display_optional */
10771 x_clear_window_mouse_face
,
10772 x_get_glyph_overhangs
,
10773 x_fix_overlapping_area
,
10774 x_draw_fringe_bitmap
,
10775 0, /* define_fringe_bitmap */
10776 0, /* destroy_fringe_bitmap */
10779 x_compute_glyph_string_overhangs
,
10780 x_draw_glyph_string
,
10781 x_define_frame_cursor
,
10782 x_clear_frame_area
,
10783 x_draw_window_cursor
,
10784 x_draw_vertical_window_border
,
10785 x_shift_glyphs_for_insert
10789 /* This function is called when the last frame on a display is deleted. */
10791 x_delete_device (struct device
*device
)
10793 struct x_display_info
*dpyinfo
= device
->display_info
.x
;
10797 /* Free the fonts in the font table. */
10798 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
10799 if (dpyinfo
->font_table
[i
].name
)
10801 XFreeFont (dpyinfo
->display
, dpyinfo
->font_table
[i
].font
);
10804 x_destroy_all_bitmaps (dpyinfo
);
10805 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
10807 #ifdef USE_X_TOOLKIT
10808 XtCloseDisplay (dpyinfo
->display
);
10811 xg_display_close (dpyinfo
->display
);
10813 XCloseDisplay (dpyinfo
->display
);
10817 x_delete_display (dpyinfo
);
10823 x_create_device (struct x_display_info
*dpyinfo
)
10825 struct device
*device
;
10827 device
= create_device ();
10829 device
->type
= output_x_window
;
10830 device
->display_info
.x
= dpyinfo
;
10831 dpyinfo
->device
= device
;
10833 /* kboard is initialized in x_term_init. */
10835 device
->clear_frame_hook
= x_clear_frame
;
10836 device
->ins_del_lines_hook
= x_ins_del_lines
;
10837 device
->delete_glyphs_hook
= x_delete_glyphs
;
10838 device
->ring_bell_hook
= XTring_bell
;
10839 device
->reset_terminal_modes_hook
= XTreset_terminal_modes
;
10840 device
->set_terminal_modes_hook
= XTset_terminal_modes
;
10841 device
->update_begin_hook
= x_update_begin
;
10842 device
->update_end_hook
= x_update_end
;
10843 device
->set_terminal_window_hook
= XTset_terminal_window
;
10844 device
->read_socket_hook
= XTread_socket
;
10845 device
->frame_up_to_date_hook
= XTframe_up_to_date
;
10846 device
->mouse_position_hook
= XTmouse_position
;
10847 device
->frame_rehighlight_hook
= XTframe_rehighlight
;
10848 device
->frame_raise_lower_hook
= XTframe_raise_lower
;
10849 device
->set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
10850 device
->condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
10851 device
->redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
10852 device
->judge_scroll_bars_hook
= XTjudge_scroll_bars
;
10854 device
->delete_frame_hook
= x_destroy_window
;
10855 device
->delete_device_hook
= x_delete_device
;
10857 device
->rif
= &x_redisplay_interface
;
10858 device
->scroll_region_ok
= 1; /* We'll scroll partial frames. */
10859 device
->char_ins_del_ok
= 1;
10860 device
->line_ins_del_ok
= 1; /* We'll just blt 'em. */
10861 device
->fast_clear_end_of_line
= 1; /* X does this well. */
10862 device
->memory_below_frame
= 0; /* We don't remember what scrolls
10874 last_tool_bar_item
= -1;
10875 any_help_event_p
= 0;
10876 ignore_next_mouse_click_timeout
= 0;
10879 current_count
= -1;
10882 /* Try to use interrupt input; if we can't, then start polling. */
10883 Fset_input_mode (Qt
, Qnil
, Qt
, Qnil
);
10885 #ifdef USE_X_TOOLKIT
10886 XtToolkitInitialize ();
10888 Xt_app_con
= XtCreateApplicationContext ();
10890 /* Register a converter from strings to pixels, which uses
10891 Emacs' color allocation infrastructure. */
10892 XtAppSetTypeConverter (Xt_app_con
,
10893 XtRString
, XtRPixel
, cvt_string_to_pixel
,
10894 cvt_string_to_pixel_args
,
10895 XtNumber (cvt_string_to_pixel_args
),
10896 XtCacheByDisplay
, cvt_pixel_dtor
);
10898 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
10900 /* Install an asynchronous timer that processes Xt timeout events
10901 every 0.1s. This is necessary because some widget sets use
10902 timeouts internally, for example the LessTif menu bar, or the
10903 Xaw3d scroll bar. When Xt timouts aren't processed, these
10904 widgets don't behave normally. */
10906 EMACS_TIME interval
;
10907 EMACS_SET_SECS_USECS (interval
, 0, 100000);
10908 start_atimer (ATIMER_CONTINUOUS
, interval
, x_process_timeouts
, 0);
10912 #ifdef USE_TOOLKIT_SCROLL_BARS
10914 xaw3d_arrow_scroll
= False
;
10915 xaw3d_pick_top
= True
;
10919 /* Note that there is no real way portable across R3/R4 to get the
10920 original error handler. */
10921 XSetErrorHandler (x_error_handler
);
10922 XSetIOErrorHandler (x_io_error_quitter
);
10924 /* Disable Window Change signals; they are handled by X events. */
10925 #if 0 /* Don't. We may want to open tty frames later. */
10927 signal (SIGWINCH
, SIG_DFL
);
10928 #endif /* SIGWINCH */
10931 signal (SIGPIPE
, x_connection_signal
);
10938 staticpro (&x_error_message_string
);
10939 x_error_message_string
= Qnil
;
10941 staticpro (&x_display_name_list
);
10942 x_display_name_list
= Qnil
;
10944 staticpro (&last_mouse_scroll_bar
);
10945 last_mouse_scroll_bar
= Qnil
;
10947 staticpro (&Qvendor_specific_keysyms
);
10948 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
10950 staticpro (&Qutf_8
);
10951 Qutf_8
= intern ("utf-8");
10952 staticpro (&Qlatin_1
);
10953 Qlatin_1
= intern ("latin-1");
10955 staticpro (&last_mouse_press_frame
);
10956 last_mouse_press_frame
= Qnil
;
10958 DEFVAR_BOOL ("x-use-underline-position-properties",
10959 &x_use_underline_position_properties
,
10960 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
10961 nil means ignore them. If you encounter fonts with bogus
10962 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
10963 to 4.1, set this to nil. */);
10964 x_use_underline_position_properties
= 1;
10966 DEFVAR_BOOL ("x-mouse-click-focus-ignore-position",
10967 &x_mouse_click_focus_ignore_position
,
10968 doc
: /* Non-nil means that a mouse click to focus a frame does not move point.
10969 This variable is only used when the window manager requires that you
10970 click on a frame to select it (give it focus). In that case, a value
10971 of nil, means that the selected window and cursor position changes to
10972 reflect the mouse click position, while a non-nil value means that the
10973 selected window or cursor position is preserved. */);
10974 x_mouse_click_focus_ignore_position
= 0;
10976 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
10977 doc
: /* What X toolkit scroll bars Emacs uses.
10978 A value of nil means Emacs doesn't use X toolkit scroll bars.
10979 Otherwise, value is a symbol describing the X toolkit. */);
10980 #ifdef USE_TOOLKIT_SCROLL_BARS
10982 Vx_toolkit_scroll_bars
= intern ("motif");
10983 #elif defined HAVE_XAW3D
10984 Vx_toolkit_scroll_bars
= intern ("xaw3d");
10986 Vx_toolkit_scroll_bars
= intern ("gtk");
10988 Vx_toolkit_scroll_bars
= intern ("xaw");
10991 Vx_toolkit_scroll_bars
= Qnil
;
10994 staticpro (&last_mouse_motion_frame
);
10995 last_mouse_motion_frame
= Qnil
;
10997 Qmodifier_value
= intern ("modifier-value");
10998 Qalt
= intern ("alt");
10999 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
11000 Qhyper
= intern ("hyper");
11001 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
11002 Qmeta
= intern ("meta");
11003 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
11004 Qsuper
= intern ("super");
11005 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
11007 DEFVAR_LISP ("x-alt-keysym", &Vx_alt_keysym
,
11008 doc
: /* Which keys Emacs uses for the alt modifier.
11009 This should be one of the symbols `alt', `hyper', `meta', `super'.
11010 For example, `alt' means use the Alt_L and Alt_R keysyms. The default
11011 is nil, which is the same as `alt'. */);
11012 Vx_alt_keysym
= Qnil
;
11014 DEFVAR_LISP ("x-hyper-keysym", &Vx_hyper_keysym
,
11015 doc
: /* Which keys Emacs uses for the hyper modifier.
11016 This should be one of the symbols `alt', `hyper', `meta', `super'.
11017 For example, `hyper' means use the Hyper_L and Hyper_R keysyms. The
11018 default is nil, which is the same as `hyper'. */);
11019 Vx_hyper_keysym
= Qnil
;
11021 DEFVAR_LISP ("x-meta-keysym", &Vx_meta_keysym
,
11022 doc
: /* Which keys Emacs uses for the meta modifier.
11023 This should be one of the symbols `alt', `hyper', `meta', `super'.
11024 For example, `meta' means use the Meta_L and Meta_R keysyms. The
11025 default is nil, which is the same as `meta'. */);
11026 Vx_meta_keysym
= Qnil
;
11028 DEFVAR_LISP ("x-super-keysym", &Vx_super_keysym
,
11029 doc
: /* Which keys Emacs uses for the super modifier.
11030 This should be one of the symbols `alt', `hyper', `meta', `super'.
11031 For example, `super' means use the Super_L and Super_R keysyms. The
11032 default is nil, which is the same as `super'. */);
11033 Vx_super_keysym
= Qnil
;
11035 DEFVAR_LISP ("x-keysym-table", &Vx_keysym_table
,
11036 doc
: /* Hash table of character codes indexed by X keysym codes. */);
11037 Vx_keysym_table
= make_hash_table (Qeql
, make_number (900),
11038 make_float (DEFAULT_REHASH_SIZE
),
11039 make_float (DEFAULT_REHASH_THRESHOLD
),
11043 #endif /* HAVE_X_WINDOWS */
11045 /* arch-tag: 6d4e4cb7-abc1-4302-9585-d84dcfb09d0f
11046 (do not change this comment) */