]> code.delx.au - gnu-emacs/blob - src/xterm.c
* xterm.c (cvt_pixel_dtor): Call x_free_dpy_colors with the
[gnu-emacs] / src / xterm.c
1 /* X Communication module for terminals which understand the X protocol.
2 Copyright (C) 1989, 93, 94, 95, 96, 1997, 1998, 1999, 2000, 2001
3 Free Software Foundation, Inc.
4
5 This file is part of GNU Emacs.
6
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)
10 any later version.
11
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.
16
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., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22 /* New display code by Gerd Moellmann <gerd@gnu.org>. */
23 /* Xt features made by Fred Pierresteguy. */
24
25 #include <config.h>
26
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. */
29 #include <signal.h>
30
31 #include <stdio.h>
32
33 #ifdef HAVE_X_WINDOWS
34
35 #include "lisp.h"
36 #include "blockinput.h"
37
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"
41
42 /* This may include sys/types.h, and that somehow loses
43 if this is not done before the other system files. */
44 #include "xterm.h"
45 #include <X11/cursorfont.h>
46
47 /* Load sys/types.h if not already loaded.
48 In some systems loading it twice is suicidal. */
49 #ifndef makedev
50 #include <sys/types.h>
51 #endif /* makedev */
52
53 #ifdef BSD_SYSTEM
54 #include <sys/ioctl.h>
55 #endif /* ! defined (BSD_SYSTEM) */
56
57 #include "systty.h"
58 #include "systime.h"
59
60 #ifndef INCLUDED_FCNTL
61 #include <fcntl.h>
62 #endif
63 #include <ctype.h>
64 #include <errno.h>
65 #include <setjmp.h>
66 #include <sys/stat.h>
67 /* Caused redefinition of DBL_DIG on Netbsd; seems not to be needed. */
68 /* #include <sys/param.h> */
69
70 #include "charset.h"
71 #include "coding.h"
72 #include "ccl.h"
73 #include "frame.h"
74 #include "dispextern.h"
75 #include "fontset.h"
76 #include "termhooks.h"
77 #include "termopts.h"
78 #include "termchar.h"
79 #if 0
80 #include "sink.h"
81 #include "sinkmask.h"
82 #endif /* ! 0 */
83 #include "gnu.h"
84 #include "disptab.h"
85 #include "buffer.h"
86 #include "window.h"
87 #include "keyboard.h"
88 #include "intervals.h"
89 #include "process.h"
90 #include "atimer.h"
91
92 #ifdef USE_X_TOOLKIT
93 #include <X11/Shell.h>
94 #endif
95
96 #ifdef HAVE_SYS_TIME_H
97 #include <sys/time.h>
98 #endif
99 #ifdef HAVE_UNISTD_H
100 #include <unistd.h>
101 #endif
102
103 #ifdef USE_X_TOOLKIT
104
105 extern void free_frame_menubar P_ ((struct frame *));
106 extern struct frame *x_menubar_window_to_frame P_ ((struct x_display_info *,
107 int));
108
109 #if (XtSpecificationRelease >= 5) && !defined(NO_EDITRES)
110 #define HACK_EDITRES
111 extern void _XEditResCheckMessages ();
112 #endif /* not NO_EDITRES */
113
114 /* Include toolkit specific headers for the scroll bar widget. */
115
116 #ifdef USE_TOOLKIT_SCROLL_BARS
117 #if defined USE_MOTIF
118 #include <Xm/Xm.h> /* for LESSTIF_VERSION */
119 #include <Xm/ScrollBar.h>
120 #else /* !USE_MOTIF i.e. use Xaw */
121
122 #ifdef HAVE_XAW3D
123 #include <X11/Xaw3d/Simple.h>
124 #include <X11/Xaw3d/Scrollbar.h>
125 #define ARROW_SCROLLBAR
126 #include <X11/Xaw3d/ScrollbarP.h>
127 #else /* !HAVE_XAW3D */
128 #include <X11/Xaw/Simple.h>
129 #include <X11/Xaw/Scrollbar.h>
130 #endif /* !HAVE_XAW3D */
131 #ifndef XtNpickTop
132 #define XtNpickTop "pickTop"
133 #endif /* !XtNpickTop */
134 #endif /* !USE_MOTIF */
135 #endif /* USE_TOOLKIT_SCROLL_BARS */
136
137 #endif /* USE_X_TOOLKIT */
138
139 #ifndef USE_X_TOOLKIT
140 #define x_any_window_to_frame x_window_to_frame
141 #define x_top_window_to_frame x_window_to_frame
142 #endif
143
144 #ifdef USE_X_TOOLKIT
145 #include "widget.h"
146 #ifndef XtNinitialState
147 #define XtNinitialState "initialState"
148 #endif
149 #endif
150
151 #ifndef min
152 #define min(a,b) ((a) < (b) ? (a) : (b))
153 #endif
154 #ifndef max
155 #define max(a,b) ((a) > (b) ? (a) : (b))
156 #endif
157
158 #define abs(x) ((x) < 0 ? -(x) : (x))
159
160 #define BETWEEN(X, LOWER, UPPER) ((X) >= (LOWER) && (X) < (UPPER))
161
162 \f
163 /* Bitmaps for truncated lines. */
164
165 enum bitmap_type
166 {
167 NO_BITMAP,
168 LEFT_TRUNCATION_BITMAP,
169 RIGHT_TRUNCATION_BITMAP,
170 OVERLAY_ARROW_BITMAP,
171 CONTINUED_LINE_BITMAP,
172 CONTINUATION_LINE_BITMAP,
173 ZV_LINE_BITMAP
174 };
175
176 /* Bitmap drawn to indicate lines not displaying text if
177 `indicate-empty-lines' is non-nil. */
178
179 #define zv_width 8
180 #define zv_height 8
181 static unsigned char zv_bits[] = {
182 0x00, 0x00, 0x1e, 0x1e, 0x1e, 0x1e, 0x00, 0x00};
183
184 /* An arrow like this: `<-'. */
185
186 #define left_width 8
187 #define left_height 8
188 static unsigned char left_bits[] = {
189 0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
190
191 /* Right truncation arrow bitmap `->'. */
192
193 #define right_width 8
194 #define right_height 8
195 static unsigned char right_bits[] = {
196 0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
197
198 /* Marker for continued lines. */
199
200 #define continued_width 8
201 #define continued_height 8
202 static unsigned char continued_bits[] = {
203 0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
204
205 /* Marker for continuation lines. */
206
207 #define continuation_width 8
208 #define continuation_height 8
209 static unsigned char continuation_bits[] = {
210 0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
211
212 /* Overlay arrow bitmap. */
213
214 #if 0
215 /* A bomb. */
216 #define ov_width 8
217 #define ov_height 8
218 static unsigned char ov_bits[] = {
219 0x30, 0x08, 0x3c, 0x7e, 0x7a, 0x7a, 0x62, 0x3c};
220 #else
221 /* A triangular arrow. */
222 #define ov_width 8
223 #define ov_height 8
224 static unsigned char ov_bits[] = {
225 0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
226
227 #endif
228
229 extern Lisp_Object Qhelp_echo;
230
231 \f
232 /* Non-nil means Emacs uses toolkit scroll bars. */
233
234 Lisp_Object Vx_toolkit_scroll_bars;
235
236 /* If a string, XTread_socket generates an event to display that string.
237 (The display is done in read_char.) */
238
239 static Lisp_Object help_echo;
240 static Lisp_Object help_echo_window;
241 static Lisp_Object help_echo_object;
242 static int help_echo_pos;
243
244 /* Temporary variable for XTread_socket. */
245
246 static Lisp_Object previous_help_echo;
247
248 /* Non-zero means that a HELP_EVENT has been generated since Emacs
249 start. */
250
251 static int any_help_event_p;
252
253 /* Non-zero means draw block and hollow cursor as wide as the glyph
254 under it. For example, if a block cursor is over a tab, it will be
255 drawn as wide as that tab on the display. */
256
257 int x_stretch_cursor_p;
258
259 /* Non-zero means make use of UNDERLINE_POSITION font properties. */
260
261 int x_use_underline_position_properties;
262
263 /* This is a chain of structures for all the X displays currently in
264 use. */
265
266 struct x_display_info *x_display_list;
267
268 /* This is a list of cons cells, each of the form (NAME
269 . FONT-LIST-CACHE), one for each element of x_display_list and in
270 the same order. NAME is the name of the frame. FONT-LIST-CACHE
271 records previous values returned by x-list-fonts. */
272
273 Lisp_Object x_display_name_list;
274
275 /* Frame being updated by update_frame. This is declared in term.c.
276 This is set by update_begin and looked at by all the XT functions.
277 It is zero while not inside an update. In that case, the XT
278 functions assume that `selected_frame' is the frame to apply to. */
279
280 extern struct frame *updating_frame;
281
282 extern int waiting_for_input;
283
284 /* This is a frame waiting to be auto-raised, within XTread_socket. */
285
286 struct frame *pending_autoraise_frame;
287
288 #ifdef USE_X_TOOLKIT
289 /* The application context for Xt use. */
290 XtAppContext Xt_app_con;
291 static String Xt_default_resources[] = {0};
292 #endif /* USE_X_TOOLKIT */
293
294 /* Nominal cursor position -- where to draw output.
295 HPOS and VPOS are window relative glyph matrix coordinates.
296 X and Y are window relative pixel coordinates. */
297
298 struct cursor_pos output_cursor;
299
300 /* Non-zero means user is interacting with a toolkit scroll bar. */
301
302 static int toolkit_scroll_bar_interaction;
303
304 /* Mouse movement.
305
306 Formerly, we used PointerMotionHintMask (in standard_event_mask)
307 so that we would have to call XQueryPointer after each MotionNotify
308 event to ask for another such event. However, this made mouse tracking
309 slow, and there was a bug that made it eventually stop.
310
311 Simply asking for MotionNotify all the time seems to work better.
312
313 In order to avoid asking for motion events and then throwing most
314 of them away or busy-polling the server for mouse positions, we ask
315 the server for pointer motion hints. This means that we get only
316 one event per group of mouse movements. "Groups" are delimited by
317 other kinds of events (focus changes and button clicks, for
318 example), or by XQueryPointer calls; when one of these happens, we
319 get another MotionNotify event the next time the mouse moves. This
320 is at least as efficient as getting motion events when mouse
321 tracking is on, and I suspect only negligibly worse when tracking
322 is off. */
323
324 /* Where the mouse was last time we reported a mouse event. */
325
326 FRAME_PTR last_mouse_frame;
327 static XRectangle last_mouse_glyph;
328 static Lisp_Object last_mouse_press_frame;
329
330 /* The scroll bar in which the last X motion event occurred.
331
332 If the last X motion event occurred in a scroll bar, we set this so
333 XTmouse_position can know whether to report a scroll bar motion or
334 an ordinary motion.
335
336 If the last X motion event didn't occur in a scroll bar, we set
337 this to Qnil, to tell XTmouse_position to return an ordinary motion
338 event. */
339
340 static Lisp_Object last_mouse_scroll_bar;
341
342 /* This is a hack. We would really prefer that XTmouse_position would
343 return the time associated with the position it returns, but there
344 doesn't seem to be any way to wrest the time-stamp from the server
345 along with the position query. So, we just keep track of the time
346 of the last movement we received, and return that in hopes that
347 it's somewhat accurate. */
348
349 static Time last_mouse_movement_time;
350
351 /* Incremented by XTread_socket whenever it really tries to read
352 events. */
353
354 #ifdef __STDC__
355 static int volatile input_signal_count;
356 #else
357 static int input_signal_count;
358 #endif
359
360 /* Used locally within XTread_socket. */
361
362 static int x_noop_count;
363
364 /* Initial values of argv and argc. */
365
366 extern char **initial_argv;
367 extern int initial_argc;
368
369 extern Lisp_Object Vcommand_line_args, Vsystem_name;
370
371 /* Tells if a window manager is present or not. */
372
373 extern Lisp_Object Vx_no_window_manager;
374
375 extern Lisp_Object Qface, Qmouse_face;
376
377 extern int errno;
378
379 /* A mask of extra modifier bits to put into every keyboard char. */
380
381 extern int extra_keyboard_modifiers;
382
383 static Lisp_Object Qvendor_specific_keysyms;
384
385 extern XrmDatabase x_load_resources P_ ((Display *, char *, char *, char *));
386 extern Lisp_Object x_icon_type P_ ((struct frame *));
387
388
389 /* Enumeration for overriding/changing the face to use for drawing
390 glyphs in x_draw_glyphs. */
391
392 enum draw_glyphs_face
393 {
394 DRAW_NORMAL_TEXT,
395 DRAW_INVERSE_VIDEO,
396 DRAW_CURSOR,
397 DRAW_MOUSE_FACE,
398 DRAW_IMAGE_RAISED,
399 DRAW_IMAGE_SUNKEN
400 };
401
402 static int cursor_in_mouse_face_p P_ ((struct window *));
403 static int clear_mouse_face P_ ((struct x_display_info *));
404 static int x_alloc_nearest_color_1 P_ ((Display *, Colormap, XColor *));
405 static void x_set_window_size_1 P_ ((struct frame *, int, int, int));
406 static const XColor *x_color_cells P_ ((Display *, int *));
407 static void x_update_window_end P_ ((struct window *, int, int));
408 static void frame_to_window_pixel_xy P_ ((struct window *, int *, int *));
409 void x_delete_display P_ ((struct x_display_info *));
410 static unsigned int x_x_to_emacs_modifiers P_ ((struct x_display_info *,
411 unsigned));
412 static int fast_find_position P_ ((struct window *, int, int *, int *,
413 int *, int *));
414 static int fast_find_string_pos P_ ((struct window *, int, Lisp_Object,
415 int *, int *, int *, int *, int));
416 static void set_output_cursor P_ ((struct cursor_pos *));
417 static struct glyph *x_y_to_hpos_vpos P_ ((struct window *, int, int,
418 int *, int *, int *, int));
419 static void note_mode_line_highlight P_ ((struct window *, int, int));
420 static void note_mouse_highlight P_ ((struct frame *, int, int));
421 static void note_tool_bar_highlight P_ ((struct frame *f, int, int));
422 static void x_handle_tool_bar_click P_ ((struct frame *, XButtonEvent *));
423 static void show_mouse_face P_ ((struct x_display_info *,
424 enum draw_glyphs_face));
425 static int x_io_error_quitter P_ ((Display *));
426 int x_catch_errors P_ ((Display *));
427 void x_uncatch_errors P_ ((Display *, int));
428 void x_lower_frame P_ ((struct frame *));
429 void x_scroll_bar_clear P_ ((struct frame *));
430 int x_had_errors_p P_ ((Display *));
431 void x_wm_set_size_hint P_ ((struct frame *, long, int));
432 void x_raise_frame P_ ((struct frame *));
433 void x_set_window_size P_ ((struct frame *, int, int, int));
434 void x_wm_set_window_state P_ ((struct frame *, int));
435 void x_wm_set_icon_pixmap P_ ((struct frame *, int));
436 void x_initialize P_ ((void));
437 static void x_font_min_bounds P_ ((XFontStruct *, int *, int *));
438 static int x_compute_min_glyph_bounds P_ ((struct frame *));
439 static void x_draw_phys_cursor_glyph P_ ((struct window *,
440 struct glyph_row *,
441 enum draw_glyphs_face));
442 static void x_update_end P_ ((struct frame *));
443 static void XTframe_up_to_date P_ ((struct frame *));
444 static void XTreassert_line_highlight P_ ((int, int));
445 static void x_change_line_highlight P_ ((int, int, int, int));
446 static void XTset_terminal_modes P_ ((void));
447 static void XTreset_terminal_modes P_ ((void));
448 static void XTcursor_to P_ ((int, int, int, int));
449 static void x_write_glyphs P_ ((struct glyph *, int));
450 static void x_clear_end_of_line P_ ((int));
451 static void x_clear_frame P_ ((void));
452 static void x_clear_cursor P_ ((struct window *));
453 static void frame_highlight P_ ((struct frame *));
454 static void frame_unhighlight P_ ((struct frame *));
455 static void x_new_focus_frame P_ ((struct x_display_info *, struct frame *));
456 static void XTframe_rehighlight P_ ((struct frame *));
457 static void x_frame_rehighlight P_ ((struct x_display_info *));
458 static void x_draw_hollow_cursor P_ ((struct window *, struct glyph_row *));
459 static void x_draw_bar_cursor P_ ((struct window *, struct glyph_row *, int));
460 static int x_intersect_rectangles P_ ((XRectangle *, XRectangle *,
461 XRectangle *));
462 static void expose_frame P_ ((struct frame *, int, int, int, int));
463 static void expose_window_tree P_ ((struct window *, XRectangle *));
464 static int expose_window P_ ((struct window *, XRectangle *));
465 static void expose_area P_ ((struct window *, struct glyph_row *,
466 XRectangle *, enum glyph_row_area));
467 static void expose_line P_ ((struct window *, struct glyph_row *,
468 XRectangle *));
469 static void x_update_cursor_in_window_tree P_ ((struct window *, int));
470 static void x_update_window_cursor P_ ((struct window *, int));
471 static void x_erase_phys_cursor P_ ((struct window *));
472 void x_display_and_set_cursor P_ ((struct window *, int, int, int, int, int));
473 static void x_draw_bitmap P_ ((struct window *, struct glyph_row *,
474 enum bitmap_type));
475
476 static void x_clip_to_row P_ ((struct window *, struct glyph_row *,
477 GC, int));
478 static int x_phys_cursor_in_rect_p P_ ((struct window *, XRectangle *));
479 static void x_draw_row_bitmaps P_ ((struct window *, struct glyph_row *));
480 static void note_overwritten_text_cursor P_ ((struct window *, int, int));
481 static void x_flush P_ ((struct frame *f));
482 static void x_update_begin P_ ((struct frame *));
483 static void x_update_window_begin P_ ((struct window *));
484 static void x_draw_vertical_border P_ ((struct window *));
485 static void x_after_update_window_line P_ ((struct glyph_row *));
486 static INLINE void take_vertical_position_into_account P_ ((struct it *));
487 static void x_produce_stretch_glyph P_ ((struct it *));
488 static struct scroll_bar *x_window_to_scroll_bar P_ ((Window));
489 static void x_scroll_bar_report_motion P_ ((struct frame **, Lisp_Object *,
490 enum scroll_bar_part *,
491 Lisp_Object *, Lisp_Object *,
492 unsigned long *));
493
494 /* Flush display of frame F, or of all frames if F is null. */
495
496 static void
497 x_flush (f)
498 struct frame *f;
499 {
500 BLOCK_INPUT;
501 if (f == NULL)
502 {
503 Lisp_Object rest, frame;
504 FOR_EACH_FRAME (rest, frame)
505 x_flush (XFRAME (frame));
506 }
507 else if (FRAME_X_P (f))
508 XFlush (FRAME_X_DISPLAY (f));
509 UNBLOCK_INPUT;
510 }
511
512
513 /* Remove calls to XFlush by defining XFlush to an empty replacement.
514 Calls to XFlush should be unnecessary because the X output buffer
515 is flushed automatically as needed by calls to XPending,
516 XNextEvent, or XWindowEvent according to the XFlush man page.
517 XTread_socket calls XPending. Removing XFlush improves
518 performance. */
519
520 #define XFlush(DISPLAY) (void) 0
521
522 \f
523 /***********************************************************************
524 Debugging
525 ***********************************************************************/
526
527 #if 0
528
529 /* This is a function useful for recording debugging information about
530 the sequence of occurrences in this file. */
531
532 struct record
533 {
534 char *locus;
535 int type;
536 };
537
538 struct record event_record[100];
539
540 int event_record_index;
541
542 record_event (locus, type)
543 char *locus;
544 int type;
545 {
546 if (event_record_index == sizeof (event_record) / sizeof (struct record))
547 event_record_index = 0;
548
549 event_record[event_record_index].locus = locus;
550 event_record[event_record_index].type = type;
551 event_record_index++;
552 }
553
554 #endif /* 0 */
555
556
557 \f
558 /* Return the struct x_display_info corresponding to DPY. */
559
560 struct x_display_info *
561 x_display_info_for_display (dpy)
562 Display *dpy;
563 {
564 struct x_display_info *dpyinfo;
565
566 for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
567 if (dpyinfo->display == dpy)
568 return dpyinfo;
569
570 return 0;
571 }
572
573
574 \f
575 /***********************************************************************
576 Starting and ending an update
577 ***********************************************************************/
578
579 /* Start an update of frame F. This function is installed as a hook
580 for update_begin, i.e. it is called when update_begin is called.
581 This function is called prior to calls to x_update_window_begin for
582 each window being updated. Currently, there is nothing to do here
583 because all interesting stuff is done on a window basis. */
584
585 static void
586 x_update_begin (f)
587 struct frame *f;
588 {
589 /* Nothing to do. */
590 }
591
592
593 /* Start update of window W. Set the global variable updated_window
594 to the window being updated and set output_cursor to the cursor
595 position of W. */
596
597 static void
598 x_update_window_begin (w)
599 struct window *w;
600 {
601 struct frame *f = XFRAME (WINDOW_FRAME (w));
602 struct x_display_info *display_info = FRAME_X_DISPLAY_INFO (f);
603
604 updated_window = w;
605 set_output_cursor (&w->cursor);
606
607 BLOCK_INPUT;
608
609 if (f == display_info->mouse_face_mouse_frame)
610 {
611 /* Don't do highlighting for mouse motion during the update. */
612 display_info->mouse_face_defer = 1;
613
614 /* If F needs to be redrawn, simply forget about any prior mouse
615 highlighting. */
616 if (FRAME_GARBAGED_P (f))
617 display_info->mouse_face_window = Qnil;
618
619 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
620 their mouse_face_p flag set, which means that they are always
621 unequal to rows in a desired matrix which never have that
622 flag set. So, rows containing mouse-face glyphs are never
623 scrolled, and we don't have to switch the mouse highlight off
624 here to prevent it from being scrolled. */
625
626 /* Can we tell that this update does not affect the window
627 where the mouse highlight is? If so, no need to turn off.
628 Likewise, don't do anything if the frame is garbaged;
629 in that case, the frame's current matrix that we would use
630 is all wrong, and we will redisplay that line anyway. */
631 if (!NILP (display_info->mouse_face_window)
632 && w == XWINDOW (display_info->mouse_face_window))
633 {
634 int i;
635
636 for (i = 0; i < w->desired_matrix->nrows; ++i)
637 if (MATRIX_ROW_ENABLED_P (w->desired_matrix, i))
638 break;
639
640 if (i < w->desired_matrix->nrows)
641 clear_mouse_face (display_info);
642 }
643 #endif /* 0 */
644 }
645
646 UNBLOCK_INPUT;
647 }
648
649
650 /* Draw a vertical window border to the right of window W if W doesn't
651 have vertical scroll bars. */
652
653 static void
654 x_draw_vertical_border (w)
655 struct window *w;
656 {
657 struct frame *f = XFRAME (WINDOW_FRAME (w));
658
659 /* Redraw borders between horizontally adjacent windows. Don't
660 do it for frames with vertical scroll bars because either the
661 right scroll bar of a window, or the left scroll bar of its
662 neighbor will suffice as a border. */
663 if (!WINDOW_RIGHTMOST_P (w)
664 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f))
665 {
666 int x0, x1, y0, y1;
667
668 window_box_edges (w, -1, &x0, &y0, &x1, &y1);
669 x1 += FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f);
670 y1 -= 1;
671
672 XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
673 f->output_data.x->normal_gc, x1, y0, x1, y1);
674 }
675 }
676
677
678 /* End update of window W (which is equal to updated_window).
679
680 Draw vertical borders between horizontally adjacent windows, and
681 display W's cursor if CURSOR_ON_P is non-zero.
682
683 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
684 glyphs in mouse-face were overwritten. In that case we have to
685 make sure that the mouse-highlight is properly redrawn.
686
687 W may be a menu bar pseudo-window in case we don't have X toolkit
688 support. Such windows don't have a cursor, so don't display it
689 here. */
690
691 static void
692 x_update_window_end (w, cursor_on_p, mouse_face_overwritten_p)
693 struct window *w;
694 int cursor_on_p, mouse_face_overwritten_p;
695 {
696 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (XFRAME (w->frame));
697
698 if (!w->pseudo_window_p)
699 {
700 BLOCK_INPUT;
701
702 if (cursor_on_p)
703 x_display_and_set_cursor (w, 1, output_cursor.hpos,
704 output_cursor.vpos,
705 output_cursor.x, output_cursor.y);
706
707 x_draw_vertical_border (w);
708 UNBLOCK_INPUT;
709 }
710
711 /* If a row with mouse-face was overwritten, arrange for
712 XTframe_up_to_date to redisplay the mouse highlight. */
713 if (mouse_face_overwritten_p)
714 {
715 dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
716 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
717 dpyinfo->mouse_face_window = Qnil;
718 }
719
720 updated_window = NULL;
721 }
722
723
724 /* End update of frame F. This function is installed as a hook in
725 update_end. */
726
727 static void
728 x_update_end (f)
729 struct frame *f;
730 {
731 /* Mouse highlight may be displayed again. */
732 FRAME_X_DISPLAY_INFO (f)->mouse_face_defer = 0;
733
734 BLOCK_INPUT;
735 XFlush (FRAME_X_DISPLAY (f));
736 UNBLOCK_INPUT;
737 }
738
739
740 /* This function is called from various places in xdisp.c whenever a
741 complete update has been performed. The global variable
742 updated_window is not available here. */
743
744 static void
745 XTframe_up_to_date (f)
746 struct frame *f;
747 {
748 if (FRAME_X_P (f))
749 {
750 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
751
752 if (dpyinfo->mouse_face_deferred_gc
753 || f == dpyinfo->mouse_face_mouse_frame)
754 {
755 BLOCK_INPUT;
756 if (dpyinfo->mouse_face_mouse_frame)
757 note_mouse_highlight (dpyinfo->mouse_face_mouse_frame,
758 dpyinfo->mouse_face_mouse_x,
759 dpyinfo->mouse_face_mouse_y);
760 dpyinfo->mouse_face_deferred_gc = 0;
761 UNBLOCK_INPUT;
762 }
763 }
764 }
765
766
767 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
768 arrow bitmaps, or clear the areas where they would be displayed
769 before DESIRED_ROW is made current. The window being updated is
770 found in updated_window. This function It is called from
771 update_window_line only if it is known that there are differences
772 between bitmaps to be drawn between current row and DESIRED_ROW. */
773
774 static void
775 x_after_update_window_line (desired_row)
776 struct glyph_row *desired_row;
777 {
778 struct window *w = updated_window;
779
780 xassert (w);
781
782 if (!desired_row->mode_line_p && !w->pseudo_window_p)
783 {
784 struct frame *f;
785 int width;
786
787 BLOCK_INPUT;
788 x_draw_row_bitmaps (w, desired_row);
789
790 /* When a window has disappeared, make sure that no rest of
791 full-width rows stays visible in the internal border. */
792 if (windows_or_buffers_changed
793 && (f = XFRAME (w->frame),
794 width = FRAME_INTERNAL_BORDER_WIDTH (f),
795 width != 0))
796 {
797 int height = desired_row->visible_height;
798 int x = (window_box_right (w, -1)
799 + FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f));
800 int y = WINDOW_TO_FRAME_PIXEL_Y (w, max (0, desired_row->y));
801
802 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
803 x, y, width, height, False);
804 }
805
806 UNBLOCK_INPUT;
807 }
808 }
809
810
811 /* Draw the bitmap WHICH in one of the areas to the left or right of
812 window W. ROW is the glyph row for which to display the bitmap; it
813 determines the vertical position at which the bitmap has to be
814 drawn. */
815
816 static void
817 x_draw_bitmap (w, row, which)
818 struct window *w;
819 struct glyph_row *row;
820 enum bitmap_type which;
821 {
822 struct frame *f = XFRAME (WINDOW_FRAME (w));
823 Display *display = FRAME_X_DISPLAY (f);
824 Window window = FRAME_X_WINDOW (f);
825 int x, y, wd, h, dy;
826 unsigned char *bits;
827 Pixmap pixmap;
828 GC gc = f->output_data.x->normal_gc;
829 struct face *face;
830 int depth = DefaultDepthOfScreen (FRAME_X_SCREEN (f));
831
832 /* Must clip because of partially visible lines. */
833 x_clip_to_row (w, row, gc, 1);
834
835 switch (which)
836 {
837 case LEFT_TRUNCATION_BITMAP:
838 wd = left_width;
839 h = left_height;
840 bits = left_bits;
841 x = (WINDOW_TO_FRAME_PIXEL_X (w, 0)
842 - wd
843 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - wd) / 2);
844 break;
845
846 case OVERLAY_ARROW_BITMAP:
847 wd = left_width;
848 h = left_height;
849 bits = ov_bits;
850 x = (WINDOW_TO_FRAME_PIXEL_X (w, 0)
851 - wd
852 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - wd) / 2);
853 break;
854
855 case RIGHT_TRUNCATION_BITMAP:
856 wd = right_width;
857 h = right_height;
858 bits = right_bits;
859 x = window_box_right (w, -1);
860 x += (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f) - wd) / 2;
861 break;
862
863 case CONTINUED_LINE_BITMAP:
864 wd = right_width;
865 h = right_height;
866 bits = continued_bits;
867 x = window_box_right (w, -1);
868 x += (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f) - wd) / 2;
869 break;
870
871 case CONTINUATION_LINE_BITMAP:
872 wd = continuation_width;
873 h = continuation_height;
874 bits = continuation_bits;
875 x = (WINDOW_TO_FRAME_PIXEL_X (w, 0)
876 - wd
877 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - wd) / 2);
878 break;
879
880 case ZV_LINE_BITMAP:
881 wd = zv_width;
882 h = zv_height;
883 bits = zv_bits;
884 x = (WINDOW_TO_FRAME_PIXEL_X (w, 0)
885 - wd
886 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - wd) / 2);
887 break;
888
889 default:
890 abort ();
891 }
892
893 /* Convert to frame coordinates. Set dy to the offset in the row to
894 start drawing the bitmap. */
895 y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
896 dy = (row->height - h) / 2;
897
898 /* Draw the bitmap. I believe these small pixmaps can be cached
899 by the server. */
900 face = FACE_FROM_ID (f, BITMAP_AREA_FACE_ID);
901 pixmap = XCreatePixmapFromBitmapData (display, window, bits, wd, h,
902 face->foreground,
903 face->background, depth);
904 XCopyArea (display, pixmap, window, gc, 0, 0, wd, h, x, y + dy);
905 XFreePixmap (display, pixmap);
906 XSetClipMask (display, gc, None);
907 }
908
909
910 /* Draw flags bitmaps for glyph row ROW on window W. Call this
911 function with input blocked. */
912
913 static void
914 x_draw_row_bitmaps (w, row)
915 struct window *w;
916 struct glyph_row *row;
917 {
918 struct frame *f = XFRAME (w->frame);
919 enum bitmap_type bitmap;
920 struct face *face;
921 int header_line_height = -1;
922
923 xassert (interrupt_input_blocked);
924
925 /* If row is completely invisible, because of vscrolling, we
926 don't have to draw anything. */
927 if (row->visible_height <= 0)
928 return;
929
930 face = FACE_FROM_ID (f, BITMAP_AREA_FACE_ID);
931 PREPARE_FACE_FOR_DISPLAY (f, face);
932
933 /* Decide which bitmap to draw at the left side. */
934 if (row->overlay_arrow_p)
935 bitmap = OVERLAY_ARROW_BITMAP;
936 else if (row->truncated_on_left_p)
937 bitmap = LEFT_TRUNCATION_BITMAP;
938 else if (MATRIX_ROW_CONTINUATION_LINE_P (row))
939 bitmap = CONTINUATION_LINE_BITMAP;
940 else if (row->indicate_empty_line_p)
941 bitmap = ZV_LINE_BITMAP;
942 else
943 bitmap = NO_BITMAP;
944
945 /* Clear flags area if no bitmap to draw or if bitmap doesn't fill
946 the flags area. */
947 if (bitmap == NO_BITMAP
948 || FRAME_FLAGS_BITMAP_WIDTH (f) < FRAME_X_LEFT_FLAGS_AREA_WIDTH (f)
949 || row->height > FRAME_FLAGS_BITMAP_HEIGHT (f))
950 {
951 /* If W has a vertical border to its left, don't draw over it. */
952 int border = ((XFASTINT (w->left) > 0
953 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f))
954 ? 1 : 0);
955 int left = window_box_left (w, -1);
956
957 if (header_line_height < 0)
958 header_line_height = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
959
960 /* In case the same realized face is used for bitmap areas and
961 for something displayed in the text (e.g. face `region' on
962 mono-displays, the fill style may have been changed to
963 FillSolid in x_draw_glyph_string_background. */
964 if (face->stipple)
965 XSetFillStyle (FRAME_X_DISPLAY (f), face->gc, FillOpaqueStippled);
966 else
967 XSetForeground (FRAME_X_DISPLAY (f), face->gc, face->background);
968
969 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
970 face->gc,
971 (left
972 - FRAME_X_LEFT_FLAGS_AREA_WIDTH (f)
973 + border),
974 WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
975 row->y)),
976 FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - border,
977 row->visible_height);
978 if (!face->stipple)
979 XSetForeground (FRAME_X_DISPLAY (f), face->gc, face->foreground);
980 }
981
982 /* Draw the left bitmap. */
983 if (bitmap != NO_BITMAP)
984 x_draw_bitmap (w, row, bitmap);
985
986 /* Decide which bitmap to draw at the right side. */
987 if (row->truncated_on_right_p)
988 bitmap = RIGHT_TRUNCATION_BITMAP;
989 else if (row->continued_p)
990 bitmap = CONTINUED_LINE_BITMAP;
991 else
992 bitmap = NO_BITMAP;
993
994 /* Clear flags area if no bitmap to draw of if bitmap doesn't fill
995 the flags area. */
996 if (bitmap == NO_BITMAP
997 || FRAME_FLAGS_BITMAP_WIDTH (f) < FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f)
998 || row->height > FRAME_FLAGS_BITMAP_HEIGHT (f))
999 {
1000 int right = window_box_right (w, -1);
1001
1002 if (header_line_height < 0)
1003 header_line_height = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
1004
1005 /* In case the same realized face is used for bitmap areas and
1006 for something displayed in the text (e.g. face `region' on
1007 mono-displays, the fill style may have been changed to
1008 FillSolid in x_draw_glyph_string_background. */
1009 if (face->stipple)
1010 XSetFillStyle (FRAME_X_DISPLAY (f), face->gc, FillOpaqueStippled);
1011 else
1012 XSetForeground (FRAME_X_DISPLAY (f), face->gc, face->background);
1013 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1014 face->gc,
1015 right,
1016 WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
1017 row->y)),
1018 FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f),
1019 row->visible_height);
1020 if (!face->stipple)
1021 XSetForeground (FRAME_X_DISPLAY (f), face->gc, face->foreground);
1022 }
1023
1024 /* Draw the right bitmap. */
1025 if (bitmap != NO_BITMAP)
1026 x_draw_bitmap (w, row, bitmap);
1027 }
1028
1029 \f
1030 /***********************************************************************
1031 Line Highlighting
1032 ***********************************************************************/
1033
1034 /* External interface to control of standout mode. Not used for X
1035 frames. Aborts when called. */
1036
1037 static void
1038 XTreassert_line_highlight (new, vpos)
1039 int new, vpos;
1040 {
1041 abort ();
1042 }
1043
1044
1045 /* Call this when about to modify line at position VPOS and change
1046 whether it is highlighted. Not used for X frames. Aborts when
1047 called. */
1048
1049 static void
1050 x_change_line_highlight (new_highlight, vpos, y, first_unused_hpos)
1051 int new_highlight, vpos, y, first_unused_hpos;
1052 {
1053 abort ();
1054 }
1055
1056
1057 /* This is called when starting Emacs and when restarting after
1058 suspend. When starting Emacs, no X window is mapped. And nothing
1059 must be done to Emacs's own window if it is suspended (though that
1060 rarely happens). */
1061
1062 static void
1063 XTset_terminal_modes ()
1064 {
1065 }
1066
1067 /* This is called when exiting or suspending Emacs. Exiting will make
1068 the X-windows go away, and suspending requires no action. */
1069
1070 static void
1071 XTreset_terminal_modes ()
1072 {
1073 }
1074
1075
1076 \f
1077 /***********************************************************************
1078 Output Cursor
1079 ***********************************************************************/
1080
1081 /* Set the global variable output_cursor to CURSOR. All cursor
1082 positions are relative to updated_window. */
1083
1084 static void
1085 set_output_cursor (cursor)
1086 struct cursor_pos *cursor;
1087 {
1088 output_cursor.hpos = cursor->hpos;
1089 output_cursor.vpos = cursor->vpos;
1090 output_cursor.x = cursor->x;
1091 output_cursor.y = cursor->y;
1092 }
1093
1094
1095 /* Set a nominal cursor position.
1096
1097 HPOS and VPOS are column/row positions in a window glyph matrix. X
1098 and Y are window text area relative pixel positions.
1099
1100 If this is done during an update, updated_window will contain the
1101 window that is being updated and the position is the future output
1102 cursor position for that window. If updated_window is null, use
1103 selected_window and display the cursor at the given position. */
1104
1105 static void
1106 XTcursor_to (vpos, hpos, y, x)
1107 int vpos, hpos, y, x;
1108 {
1109 struct window *w;
1110
1111 /* If updated_window is not set, work on selected_window. */
1112 if (updated_window)
1113 w = updated_window;
1114 else
1115 w = XWINDOW (selected_window);
1116
1117 /* Set the output cursor. */
1118 output_cursor.hpos = hpos;
1119 output_cursor.vpos = vpos;
1120 output_cursor.x = x;
1121 output_cursor.y = y;
1122
1123 /* If not called as part of an update, really display the cursor.
1124 This will also set the cursor position of W. */
1125 if (updated_window == NULL)
1126 {
1127 BLOCK_INPUT;
1128 x_display_cursor (w, 1, hpos, vpos, x, y);
1129 XFlush (FRAME_X_DISPLAY (SELECTED_FRAME ()));
1130 UNBLOCK_INPUT;
1131 }
1132 }
1133
1134
1135 \f
1136 /***********************************************************************
1137 Display Iterator
1138 ***********************************************************************/
1139
1140 /* Function prototypes of this page. */
1141
1142 static struct face *x_get_glyph_face_and_encoding P_ ((struct frame *,
1143 struct glyph *,
1144 XChar2b *,
1145 int *));
1146 static struct face *x_get_char_face_and_encoding P_ ((struct frame *, int,
1147 int, XChar2b *, int));
1148 static XCharStruct *x_per_char_metric P_ ((XFontStruct *, XChar2b *));
1149 static void x_encode_char P_ ((int, XChar2b *, struct font_info *));
1150 static void x_append_glyph P_ ((struct it *));
1151 static void x_append_composite_glyph P_ ((struct it *));
1152 static void x_append_stretch_glyph P_ ((struct it *it, Lisp_Object,
1153 int, int, double));
1154 static void x_produce_glyphs P_ ((struct it *));
1155 static void x_produce_image_glyph P_ ((struct it *it));
1156
1157
1158 /* Get metrics of character CHAR2B in FONT. Value is null if CHAR2B
1159 is not contained in the font. */
1160
1161 static INLINE XCharStruct *
1162 x_per_char_metric (font, char2b)
1163 XFontStruct *font;
1164 XChar2b *char2b;
1165 {
1166 /* The result metric information. */
1167 XCharStruct *pcm = NULL;
1168
1169 xassert (font && char2b);
1170
1171 if (font->per_char != NULL)
1172 {
1173 if (font->min_byte1 == 0 && font->max_byte1 == 0)
1174 {
1175 /* min_char_or_byte2 specifies the linear character index
1176 corresponding to the first element of the per_char array,
1177 max_char_or_byte2 is the index of the last character. A
1178 character with non-zero CHAR2B->byte1 is not in the font.
1179 A character with byte2 less than min_char_or_byte2 or
1180 greater max_char_or_byte2 is not in the font. */
1181 if (char2b->byte1 == 0
1182 && char2b->byte2 >= font->min_char_or_byte2
1183 && char2b->byte2 <= font->max_char_or_byte2)
1184 pcm = font->per_char + char2b->byte2 - font->min_char_or_byte2;
1185 }
1186 else
1187 {
1188 /* If either min_byte1 or max_byte1 are nonzero, both
1189 min_char_or_byte2 and max_char_or_byte2 are less than
1190 256, and the 2-byte character index values corresponding
1191 to the per_char array element N (counting from 0) are:
1192
1193 byte1 = N/D + min_byte1
1194 byte2 = N\D + min_char_or_byte2
1195
1196 where:
1197
1198 D = max_char_or_byte2 - min_char_or_byte2 + 1
1199 / = integer division
1200 \ = integer modulus */
1201 if (char2b->byte1 >= font->min_byte1
1202 && char2b->byte1 <= font->max_byte1
1203 && char2b->byte2 >= font->min_char_or_byte2
1204 && char2b->byte2 <= font->max_char_or_byte2)
1205 {
1206 pcm = (font->per_char
1207 + ((font->max_char_or_byte2 - font->min_char_or_byte2 + 1)
1208 * (char2b->byte1 - font->min_byte1))
1209 + (char2b->byte2 - font->min_char_or_byte2));
1210 }
1211 }
1212 }
1213 else
1214 {
1215 /* If the per_char pointer is null, all glyphs between the first
1216 and last character indexes inclusive have the same
1217 information, as given by both min_bounds and max_bounds. */
1218 if (char2b->byte2 >= font->min_char_or_byte2
1219 && char2b->byte2 <= font->max_char_or_byte2)
1220 pcm = &font->max_bounds;
1221 }
1222
1223 return ((pcm == NULL
1224 || (pcm->width == 0 && (pcm->rbearing - pcm->lbearing) == 0))
1225 ? NULL : pcm);
1226 }
1227
1228
1229 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
1230 the two-byte form of C. Encoding is returned in *CHAR2B. */
1231
1232 static INLINE void
1233 x_encode_char (c, char2b, font_info)
1234 int c;
1235 XChar2b *char2b;
1236 struct font_info *font_info;
1237 {
1238 int charset = CHAR_CHARSET (c);
1239 XFontStruct *font = font_info->font;
1240
1241 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
1242 This may be either a program in a special encoder language or a
1243 fixed encoding. */
1244 if (font_info->font_encoder)
1245 {
1246 /* It's a program. */
1247 struct ccl_program *ccl = font_info->font_encoder;
1248
1249 if (CHARSET_DIMENSION (charset) == 1)
1250 {
1251 ccl->reg[0] = charset;
1252 ccl->reg[1] = char2b->byte2;
1253 }
1254 else
1255 {
1256 ccl->reg[0] = charset;
1257 ccl->reg[1] = char2b->byte1;
1258 ccl->reg[2] = char2b->byte2;
1259 }
1260
1261 ccl_driver (ccl, NULL, NULL, 0, 0, NULL);
1262
1263 /* We assume that MSBs are appropriately set/reset by CCL
1264 program. */
1265 if (font->max_byte1 == 0) /* 1-byte font */
1266 char2b->byte1 = 0, char2b->byte2 = ccl->reg[1];
1267 else
1268 char2b->byte1 = ccl->reg[1], char2b->byte2 = ccl->reg[2];
1269 }
1270 else if (font_info->encoding[charset])
1271 {
1272 /* Fixed encoding scheme. See fontset.h for the meaning of the
1273 encoding numbers. */
1274 int enc = font_info->encoding[charset];
1275
1276 if ((enc == 1 || enc == 2)
1277 && CHARSET_DIMENSION (charset) == 2)
1278 char2b->byte1 |= 0x80;
1279
1280 if (enc == 1 || enc == 3)
1281 char2b->byte2 |= 0x80;
1282 }
1283 }
1284
1285
1286 /* Get face and two-byte form of character C in face FACE_ID on frame
1287 F. The encoding of C is returned in *CHAR2B. MULTIBYTE_P non-zero
1288 means we want to display multibyte text. Value is a pointer to a
1289 realized face that is ready for display. */
1290
1291 static INLINE struct face *
1292 x_get_char_face_and_encoding (f, c, face_id, char2b, multibyte_p)
1293 struct frame *f;
1294 int c, face_id;
1295 XChar2b *char2b;
1296 int multibyte_p;
1297 {
1298 struct face *face = FACE_FROM_ID (f, face_id);
1299
1300 if (!multibyte_p)
1301 {
1302 /* Unibyte case. We don't have to encode, but we have to make
1303 sure to use a face suitable for unibyte. */
1304 char2b->byte1 = 0;
1305 char2b->byte2 = c;
1306 face_id = FACE_FOR_CHAR (f, face, c);
1307 face = FACE_FROM_ID (f, face_id);
1308 }
1309 else if (c < 128 && face_id < BASIC_FACE_ID_SENTINEL)
1310 {
1311 /* Case of ASCII in a face known to fit ASCII. */
1312 char2b->byte1 = 0;
1313 char2b->byte2 = c;
1314 }
1315 else
1316 {
1317 int c1, c2, charset;
1318
1319 /* Split characters into bytes. If c2 is -1 afterwards, C is
1320 really a one-byte character so that byte1 is zero. */
1321 SPLIT_CHAR (c, charset, c1, c2);
1322 if (c2 > 0)
1323 char2b->byte1 = c1, char2b->byte2 = c2;
1324 else
1325 char2b->byte1 = 0, char2b->byte2 = c1;
1326
1327 /* Maybe encode the character in *CHAR2B. */
1328 if (face->font != NULL)
1329 {
1330 struct font_info *font_info
1331 = FONT_INFO_FROM_ID (f, face->font_info_id);
1332 if (font_info)
1333 x_encode_char (c, char2b, font_info);
1334 }
1335 }
1336
1337 /* Make sure X resources of the face are allocated. */
1338 xassert (face != NULL);
1339 PREPARE_FACE_FOR_DISPLAY (f, face);
1340
1341 return face;
1342 }
1343
1344
1345 /* Get face and two-byte form of character glyph GLYPH on frame F.
1346 The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
1347 a pointer to a realized face that is ready for display. */
1348
1349 static INLINE struct face *
1350 x_get_glyph_face_and_encoding (f, glyph, char2b, two_byte_p)
1351 struct frame *f;
1352 struct glyph *glyph;
1353 XChar2b *char2b;
1354 int *two_byte_p;
1355 {
1356 struct face *face;
1357
1358 xassert (glyph->type == CHAR_GLYPH);
1359 face = FACE_FROM_ID (f, glyph->face_id);
1360
1361 if (two_byte_p)
1362 *two_byte_p = 0;
1363
1364 if (!glyph->multibyte_p)
1365 {
1366 /* Unibyte case. We don't have to encode, but we have to make
1367 sure to use a face suitable for unibyte. */
1368 char2b->byte1 = 0;
1369 char2b->byte2 = glyph->u.ch;
1370 }
1371 else if (glyph->u.ch < 128
1372 && glyph->face_id < BASIC_FACE_ID_SENTINEL)
1373 {
1374 /* Case of ASCII in a face known to fit ASCII. */
1375 char2b->byte1 = 0;
1376 char2b->byte2 = glyph->u.ch;
1377 }
1378 else
1379 {
1380 int c1, c2, charset;
1381
1382 /* Split characters into bytes. If c2 is -1 afterwards, C is
1383 really a one-byte character so that byte1 is zero. */
1384 SPLIT_CHAR (glyph->u.ch, charset, c1, c2);
1385 if (c2 > 0)
1386 char2b->byte1 = c1, char2b->byte2 = c2;
1387 else
1388 char2b->byte1 = 0, char2b->byte2 = c1;
1389
1390 /* Maybe encode the character in *CHAR2B. */
1391 if (charset != CHARSET_ASCII)
1392 {
1393 struct font_info *font_info
1394 = FONT_INFO_FROM_ID (f, face->font_info_id);
1395 if (font_info)
1396 {
1397 x_encode_char (glyph->u.ch, char2b, font_info);
1398 if (two_byte_p)
1399 *two_byte_p
1400 = ((XFontStruct *) (font_info->font))->max_byte1 > 0;
1401 }
1402 }
1403 }
1404
1405 /* Make sure X resources of the face are allocated. */
1406 xassert (face != NULL);
1407 PREPARE_FACE_FOR_DISPLAY (f, face);
1408 return face;
1409 }
1410
1411
1412 /* Store one glyph for IT->char_to_display in IT->glyph_row.
1413 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1414
1415 static INLINE void
1416 x_append_glyph (it)
1417 struct it *it;
1418 {
1419 struct glyph *glyph;
1420 enum glyph_row_area area = it->area;
1421
1422 xassert (it->glyph_row);
1423 xassert (it->char_to_display != '\n' && it->char_to_display != '\t');
1424
1425 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
1426 if (glyph < it->glyph_row->glyphs[area + 1])
1427 {
1428 glyph->charpos = CHARPOS (it->position);
1429 glyph->object = it->object;
1430 glyph->pixel_width = it->pixel_width;
1431 glyph->voffset = it->voffset;
1432 glyph->type = CHAR_GLYPH;
1433 glyph->multibyte_p = it->multibyte_p;
1434 glyph->left_box_line_p = it->start_of_box_run_p;
1435 glyph->right_box_line_p = it->end_of_box_run_p;
1436 glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
1437 || it->phys_descent > it->descent);
1438 glyph->padding_p = 0;
1439 glyph->glyph_not_available_p = it->glyph_not_available_p;
1440 glyph->face_id = it->face_id;
1441 glyph->u.ch = it->char_to_display;
1442 ++it->glyph_row->used[area];
1443 }
1444 }
1445
1446 /* Store one glyph for the composition IT->cmp_id in IT->glyph_row.
1447 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1448
1449 static INLINE void
1450 x_append_composite_glyph (it)
1451 struct it *it;
1452 {
1453 struct glyph *glyph;
1454 enum glyph_row_area area = it->area;
1455
1456 xassert (it->glyph_row);
1457
1458 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
1459 if (glyph < it->glyph_row->glyphs[area + 1])
1460 {
1461 glyph->charpos = CHARPOS (it->position);
1462 glyph->object = it->object;
1463 glyph->pixel_width = it->pixel_width;
1464 glyph->voffset = it->voffset;
1465 glyph->type = COMPOSITE_GLYPH;
1466 glyph->multibyte_p = it->multibyte_p;
1467 glyph->left_box_line_p = it->start_of_box_run_p;
1468 glyph->right_box_line_p = it->end_of_box_run_p;
1469 glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
1470 || it->phys_descent > it->descent);
1471 glyph->padding_p = 0;
1472 glyph->glyph_not_available_p = 0;
1473 glyph->face_id = it->face_id;
1474 glyph->u.cmp_id = it->cmp_id;
1475 ++it->glyph_row->used[area];
1476 }
1477 }
1478
1479
1480 /* Change IT->ascent and IT->height according to the setting of
1481 IT->voffset. */
1482
1483 static INLINE void
1484 take_vertical_position_into_account (it)
1485 struct it *it;
1486 {
1487 if (it->voffset)
1488 {
1489 if (it->voffset < 0)
1490 /* Increase the ascent so that we can display the text higher
1491 in the line. */
1492 it->ascent += abs (it->voffset);
1493 else
1494 /* Increase the descent so that we can display the text lower
1495 in the line. */
1496 it->descent += it->voffset;
1497 }
1498 }
1499
1500
1501 /* Produce glyphs/get display metrics for the image IT is loaded with.
1502 See the description of struct display_iterator in dispextern.h for
1503 an overview of struct display_iterator. */
1504
1505 static void
1506 x_produce_image_glyph (it)
1507 struct it *it;
1508 {
1509 struct image *img;
1510 struct face *face;
1511
1512 xassert (it->what == IT_IMAGE);
1513
1514 face = FACE_FROM_ID (it->f, it->face_id);
1515 img = IMAGE_FROM_ID (it->f, it->image_id);
1516 xassert (img);
1517
1518 /* Make sure X resources of the face and image are loaded. */
1519 PREPARE_FACE_FOR_DISPLAY (it->f, face);
1520 prepare_image_for_display (it->f, img);
1521
1522 it->ascent = it->phys_ascent = image_ascent (img, face);
1523 it->descent = it->phys_descent = img->height + 2 * img->vmargin - it->ascent;
1524 it->pixel_width = img->width + 2 * img->hmargin;
1525
1526 it->nglyphs = 1;
1527
1528 if (face->box != FACE_NO_BOX)
1529 {
1530 if (face->box_line_width > 0)
1531 {
1532 it->ascent += face->box_line_width;
1533 it->descent += face->box_line_width;
1534 }
1535
1536 if (it->start_of_box_run_p)
1537 it->pixel_width += abs (face->box_line_width);
1538 if (it->end_of_box_run_p)
1539 it->pixel_width += abs (face->box_line_width);
1540 }
1541
1542 take_vertical_position_into_account (it);
1543
1544 if (it->glyph_row)
1545 {
1546 struct glyph *glyph;
1547 enum glyph_row_area area = it->area;
1548
1549 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
1550 if (glyph < it->glyph_row->glyphs[area + 1])
1551 {
1552 glyph->charpos = CHARPOS (it->position);
1553 glyph->object = it->object;
1554 glyph->pixel_width = it->pixel_width;
1555 glyph->voffset = it->voffset;
1556 glyph->type = IMAGE_GLYPH;
1557 glyph->multibyte_p = it->multibyte_p;
1558 glyph->left_box_line_p = it->start_of_box_run_p;
1559 glyph->right_box_line_p = it->end_of_box_run_p;
1560 glyph->overlaps_vertically_p = 0;
1561 glyph->padding_p = 0;
1562 glyph->glyph_not_available_p = 0;
1563 glyph->face_id = it->face_id;
1564 glyph->u.img_id = img->id;
1565 ++it->glyph_row->used[area];
1566 }
1567 }
1568 }
1569
1570
1571 /* Append a stretch glyph to IT->glyph_row. OBJECT is the source
1572 of the glyph, WIDTH and HEIGHT are the width and height of the
1573 stretch. ASCENT is the percentage/100 of HEIGHT to use for the
1574 ascent of the glyph (0 <= ASCENT <= 1). */
1575
1576 static void
1577 x_append_stretch_glyph (it, object, width, height, ascent)
1578 struct it *it;
1579 Lisp_Object object;
1580 int width, height;
1581 double ascent;
1582 {
1583 struct glyph *glyph;
1584 enum glyph_row_area area = it->area;
1585
1586 xassert (ascent >= 0 && ascent <= 1);
1587
1588 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
1589 if (glyph < it->glyph_row->glyphs[area + 1])
1590 {
1591 glyph->charpos = CHARPOS (it->position);
1592 glyph->object = object;
1593 glyph->pixel_width = width;
1594 glyph->voffset = it->voffset;
1595 glyph->type = STRETCH_GLYPH;
1596 glyph->multibyte_p = it->multibyte_p;
1597 glyph->left_box_line_p = it->start_of_box_run_p;
1598 glyph->right_box_line_p = it->end_of_box_run_p;
1599 glyph->overlaps_vertically_p = 0;
1600 glyph->padding_p = 0;
1601 glyph->glyph_not_available_p = 0;
1602 glyph->face_id = it->face_id;
1603 glyph->u.stretch.ascent = height * ascent;
1604 glyph->u.stretch.height = height;
1605 ++it->glyph_row->used[area];
1606 }
1607 }
1608
1609
1610 /* Produce a stretch glyph for iterator IT. IT->object is the value
1611 of the glyph property displayed. The value must be a list
1612 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
1613 being recognized:
1614
1615 1. `:width WIDTH' specifies that the space should be WIDTH *
1616 canonical char width wide. WIDTH may be an integer or floating
1617 point number.
1618
1619 2. `:relative-width FACTOR' specifies that the width of the stretch
1620 should be computed from the width of the first character having the
1621 `glyph' property, and should be FACTOR times that width.
1622
1623 3. `:align-to HPOS' specifies that the space should be wide enough
1624 to reach HPOS, a value in canonical character units.
1625
1626 Exactly one of the above pairs must be present.
1627
1628 4. `:height HEIGHT' specifies that the height of the stretch produced
1629 should be HEIGHT, measured in canonical character units.
1630
1631 5. `:relative-height FACTOR' specifies that the height of the the
1632 stretch should be FACTOR times the height of the characters having
1633 the glyph property.
1634
1635 Either none or exactly one of 4 or 5 must be present.
1636
1637 6. `:ascent ASCENT' specifies that ASCENT percent of the height
1638 of the stretch should be used for the ascent of the stretch.
1639 ASCENT must be in the range 0 <= ASCENT <= 100. */
1640
1641 #define NUMVAL(X) \
1642 ((INTEGERP (X) || FLOATP (X)) \
1643 ? XFLOATINT (X) \
1644 : - 1)
1645
1646
1647 static void
1648 x_produce_stretch_glyph (it)
1649 struct it *it;
1650 {
1651 /* (space :width WIDTH :height HEIGHT. */
1652 #if GLYPH_DEBUG
1653 extern Lisp_Object Qspace;
1654 #endif
1655 extern Lisp_Object QCwidth, QCheight, QCascent;
1656 extern Lisp_Object QCrelative_width, QCrelative_height;
1657 extern Lisp_Object QCalign_to;
1658 Lisp_Object prop, plist;
1659 double width = 0, height = 0, ascent = 0;
1660 struct face *face = FACE_FROM_ID (it->f, it->face_id);
1661 XFontStruct *font = face->font ? face->font : FRAME_FONT (it->f);
1662
1663 PREPARE_FACE_FOR_DISPLAY (it->f, face);
1664
1665 /* List should start with `space'. */
1666 xassert (CONSP (it->object) && EQ (XCAR (it->object), Qspace));
1667 plist = XCDR (it->object);
1668
1669 /* Compute the width of the stretch. */
1670 if (prop = Fplist_get (plist, QCwidth),
1671 NUMVAL (prop) > 0)
1672 /* Absolute width `:width WIDTH' specified and valid. */
1673 width = NUMVAL (prop) * CANON_X_UNIT (it->f);
1674 else if (prop = Fplist_get (plist, QCrelative_width),
1675 NUMVAL (prop) > 0)
1676 {
1677 /* Relative width `:relative-width FACTOR' specified and valid.
1678 Compute the width of the characters having the `glyph'
1679 property. */
1680 struct it it2;
1681 unsigned char *p = BYTE_POS_ADDR (IT_BYTEPOS (*it));
1682
1683 it2 = *it;
1684 if (it->multibyte_p)
1685 {
1686 int maxlen = ((IT_BYTEPOS (*it) >= GPT ? ZV : GPT)
1687 - IT_BYTEPOS (*it));
1688 it2.c = STRING_CHAR_AND_LENGTH (p, maxlen, it2.len);
1689 }
1690 else
1691 it2.c = *p, it2.len = 1;
1692
1693 it2.glyph_row = NULL;
1694 it2.what = IT_CHARACTER;
1695 x_produce_glyphs (&it2);
1696 width = NUMVAL (prop) * it2.pixel_width;
1697 }
1698 else if (prop = Fplist_get (plist, QCalign_to),
1699 NUMVAL (prop) > 0)
1700 width = NUMVAL (prop) * CANON_X_UNIT (it->f) - it->current_x;
1701 else
1702 /* Nothing specified -> width defaults to canonical char width. */
1703 width = CANON_X_UNIT (it->f);
1704
1705 /* Compute height. */
1706 if (prop = Fplist_get (plist, QCheight),
1707 NUMVAL (prop) > 0)
1708 height = NUMVAL (prop) * CANON_Y_UNIT (it->f);
1709 else if (prop = Fplist_get (plist, QCrelative_height),
1710 NUMVAL (prop) > 0)
1711 height = FONT_HEIGHT (font) * NUMVAL (prop);
1712 else
1713 height = FONT_HEIGHT (font);
1714
1715 /* Compute percentage of height used for ascent. If
1716 `:ascent ASCENT' is present and valid, use that. Otherwise,
1717 derive the ascent from the font in use. */
1718 if (prop = Fplist_get (plist, QCascent),
1719 NUMVAL (prop) > 0 && NUMVAL (prop) <= 100)
1720 ascent = NUMVAL (prop) / 100.0;
1721 else
1722 ascent = (double) font->ascent / FONT_HEIGHT (font);
1723
1724 if (width <= 0)
1725 width = 1;
1726 if (height <= 0)
1727 height = 1;
1728
1729 if (it->glyph_row)
1730 {
1731 Lisp_Object object = it->stack[it->sp - 1].string;
1732 if (!STRINGP (object))
1733 object = it->w->buffer;
1734 x_append_stretch_glyph (it, object, width, height, ascent);
1735 }
1736
1737 it->pixel_width = width;
1738 it->ascent = it->phys_ascent = height * ascent;
1739 it->descent = it->phys_descent = height - it->ascent;
1740 it->nglyphs = 1;
1741
1742 if (face->box != FACE_NO_BOX)
1743 {
1744 if (face->box_line_width > 0)
1745 {
1746 it->ascent += face->box_line_width;
1747 it->descent += face->box_line_width;
1748 }
1749
1750 if (it->start_of_box_run_p)
1751 it->pixel_width += abs (face->box_line_width);
1752 if (it->end_of_box_run_p)
1753 it->pixel_width += abs (face->box_line_width);
1754 }
1755
1756 take_vertical_position_into_account (it);
1757 }
1758
1759 /* Return proper value to be used as baseline offset of font that has
1760 ASCENT and DESCENT to draw characters by the font at the vertical
1761 center of the line of frame F.
1762
1763 Here, out task is to find the value of BOFF in the following figure;
1764
1765 -------------------------+-----------+-
1766 -+-+---------+-+ | |
1767 | | | | | |
1768 | | | | F_ASCENT F_HEIGHT
1769 | | | ASCENT | |
1770 HEIGHT | | | | |
1771 | | |-|-+------+-----------|------- baseline
1772 | | | | BOFF | |
1773 | |---------|-+-+ | |
1774 | | | DESCENT | |
1775 -+-+---------+-+ F_DESCENT |
1776 -------------------------+-----------+-
1777
1778 -BOFF + DESCENT + (F_HEIGHT - HEIGHT) / 2 = F_DESCENT
1779 BOFF = DESCENT + (F_HEIGHT - HEIGHT) / 2 - F_DESCENT
1780 DESCENT = FONT->descent
1781 HEIGHT = FONT_HEIGHT (FONT)
1782 F_DESCENT = (F->output_data.x->font->descent
1783 - F->output_data.x->baseline_offset)
1784 F_HEIGHT = FRAME_LINE_HEIGHT (F)
1785 */
1786
1787 #define VCENTER_BASELINE_OFFSET(FONT, F) \
1788 ((FONT)->descent \
1789 + (FRAME_LINE_HEIGHT ((F)) - FONT_HEIGHT ((FONT)) \
1790 + (FRAME_LINE_HEIGHT ((F)) > FONT_HEIGHT ((FONT)))) / 2 \
1791 - ((F)->output_data.x->font->descent - (F)->output_data.x->baseline_offset))
1792
1793 /* Produce glyphs/get display metrics for the display element IT is
1794 loaded with. See the description of struct display_iterator in
1795 dispextern.h for an overview of struct display_iterator. */
1796
1797 static void
1798 x_produce_glyphs (it)
1799 struct it *it;
1800 {
1801 it->glyph_not_available_p = 0;
1802
1803 if (it->what == IT_CHARACTER)
1804 {
1805 XChar2b char2b;
1806 XFontStruct *font;
1807 struct face *face = FACE_FROM_ID (it->f, it->face_id);
1808 XCharStruct *pcm;
1809 int font_not_found_p;
1810 struct font_info *font_info;
1811 int boff; /* baseline offset */
1812 /* We may change it->multibyte_p upon unibyte<->multibyte
1813 conversion. So, save the current value now and restore it
1814 later.
1815
1816 Note: It seems that we don't have to record multibyte_p in
1817 struct glyph because the character code itself tells if or
1818 not the character is multibyte. Thus, in the future, we must
1819 consider eliminating the field `multibyte_p' in the struct
1820 glyph.
1821 */
1822 int saved_multibyte_p = it->multibyte_p;
1823
1824 /* Maybe translate single-byte characters to multibyte, or the
1825 other way. */
1826 it->char_to_display = it->c;
1827 if (!ASCII_BYTE_P (it->c))
1828 {
1829 if (unibyte_display_via_language_environment
1830 && SINGLE_BYTE_CHAR_P (it->c)
1831 && (it->c >= 0240
1832 || !NILP (Vnonascii_translation_table)))
1833 {
1834 it->char_to_display = unibyte_char_to_multibyte (it->c);
1835 it->multibyte_p = 1;
1836 it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display);
1837 face = FACE_FROM_ID (it->f, it->face_id);
1838 }
1839 else if (!SINGLE_BYTE_CHAR_P (it->c)
1840 && !it->multibyte_p)
1841 {
1842 it->char_to_display = multibyte_char_to_unibyte (it->c, Qnil);
1843 it->multibyte_p = 0;
1844 it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display);
1845 face = FACE_FROM_ID (it->f, it->face_id);
1846 }
1847 }
1848
1849 /* Get font to use. Encode IT->char_to_display. */
1850 x_get_char_face_and_encoding (it->f, it->char_to_display,
1851 it->face_id, &char2b,
1852 it->multibyte_p);
1853 font = face->font;
1854
1855 /* When no suitable font found, use the default font. */
1856 font_not_found_p = font == NULL;
1857 if (font_not_found_p)
1858 {
1859 font = FRAME_FONT (it->f);
1860 boff = it->f->output_data.x->baseline_offset;
1861 font_info = NULL;
1862 }
1863 else
1864 {
1865 font_info = FONT_INFO_FROM_ID (it->f, face->font_info_id);
1866 boff = font_info->baseline_offset;
1867 if (font_info->vertical_centering)
1868 boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
1869 }
1870
1871 if (it->char_to_display >= ' '
1872 && (!it->multibyte_p || it->char_to_display < 128))
1873 {
1874 /* Either unibyte or ASCII. */
1875 int stretched_p;
1876
1877 it->nglyphs = 1;
1878
1879 pcm = x_per_char_metric (font, &char2b);
1880 it->ascent = font->ascent + boff;
1881 it->descent = font->descent - boff;
1882
1883 if (pcm)
1884 {
1885 it->phys_ascent = pcm->ascent + boff;
1886 it->phys_descent = pcm->descent - boff;
1887 it->pixel_width = pcm->width;
1888 }
1889 else
1890 {
1891 it->glyph_not_available_p = 1;
1892 it->phys_ascent = font->ascent + boff;
1893 it->phys_descent = font->descent - boff;
1894 it->pixel_width = FONT_WIDTH (font);
1895 }
1896
1897 /* If this is a space inside a region of text with
1898 `space-width' property, change its width. */
1899 stretched_p = it->char_to_display == ' ' && !NILP (it->space_width);
1900 if (stretched_p)
1901 it->pixel_width *= XFLOATINT (it->space_width);
1902
1903 /* If face has a box, add the box thickness to the character
1904 height. If character has a box line to the left and/or
1905 right, add the box line width to the character's width. */
1906 if (face->box != FACE_NO_BOX)
1907 {
1908 int thick = face->box_line_width;
1909
1910 if (thick > 0)
1911 {
1912 it->ascent += thick;
1913 it->descent += thick;
1914 }
1915 else
1916 thick = -thick;
1917
1918 if (it->start_of_box_run_p)
1919 it->pixel_width += thick;
1920 if (it->end_of_box_run_p)
1921 it->pixel_width += thick;
1922 }
1923
1924 /* If face has an overline, add the height of the overline
1925 (1 pixel) and a 1 pixel margin to the character height. */
1926 if (face->overline_p)
1927 it->ascent += 2;
1928
1929 take_vertical_position_into_account (it);
1930
1931 /* If we have to actually produce glyphs, do it. */
1932 if (it->glyph_row)
1933 {
1934 if (stretched_p)
1935 {
1936 /* Translate a space with a `space-width' property
1937 into a stretch glyph. */
1938 double ascent = (double) font->ascent / FONT_HEIGHT (font);
1939 x_append_stretch_glyph (it, it->object, it->pixel_width,
1940 it->ascent + it->descent, ascent);
1941 }
1942 else
1943 x_append_glyph (it);
1944
1945 /* If characters with lbearing or rbearing are displayed
1946 in this line, record that fact in a flag of the
1947 glyph row. This is used to optimize X output code. */
1948 if (pcm && (pcm->lbearing < 0 || pcm->rbearing > pcm->width))
1949 it->glyph_row->contains_overlapping_glyphs_p = 1;
1950 }
1951 }
1952 else if (it->char_to_display == '\n')
1953 {
1954 /* A newline has no width but we need the height of the line. */
1955 it->pixel_width = 0;
1956 it->nglyphs = 0;
1957 it->ascent = it->phys_ascent = font->ascent + boff;
1958 it->descent = it->phys_descent = font->descent - boff;
1959
1960 if (face->box != FACE_NO_BOX
1961 && face->box_line_width > 0)
1962 {
1963 it->ascent += face->box_line_width;
1964 it->descent += face->box_line_width;
1965 }
1966 }
1967 else if (it->char_to_display == '\t')
1968 {
1969 int tab_width = it->tab_width * CANON_X_UNIT (it->f);
1970 int x = it->current_x + it->continuation_lines_width;
1971 int next_tab_x = ((1 + x + tab_width - 1) / tab_width) * tab_width;
1972
1973 /* If the distance from the current position to the next tab
1974 stop is less than a canonical character width, use the
1975 tab stop after that. */
1976 if (next_tab_x - x < CANON_X_UNIT (it->f))
1977 next_tab_x += tab_width;
1978
1979 it->pixel_width = next_tab_x - x;
1980 it->nglyphs = 1;
1981 it->ascent = it->phys_ascent = font->ascent + boff;
1982 it->descent = it->phys_descent = font->descent - boff;
1983
1984 if (it->glyph_row)
1985 {
1986 double ascent = (double) it->ascent / (it->ascent + it->descent);
1987 x_append_stretch_glyph (it, it->object, it->pixel_width,
1988 it->ascent + it->descent, ascent);
1989 }
1990 }
1991 else
1992 {
1993 /* A multi-byte character. Assume that the display width of the
1994 character is the width of the character multiplied by the
1995 width of the font. */
1996
1997 /* If we found a font, this font should give us the right
1998 metrics. If we didn't find a font, use the frame's
1999 default font and calculate the width of the character
2000 from the charset width; this is what old redisplay code
2001 did. */
2002 pcm = x_per_char_metric (font, &char2b);
2003 if (font_not_found_p || !pcm)
2004 {
2005 int charset = CHAR_CHARSET (it->char_to_display);
2006
2007 it->glyph_not_available_p = 1;
2008 it->pixel_width = (FONT_WIDTH (FRAME_FONT (it->f))
2009 * CHARSET_WIDTH (charset));
2010 it->phys_ascent = font->ascent + boff;
2011 it->phys_descent = font->descent - boff;
2012 }
2013 else
2014 {
2015 it->pixel_width = pcm->width;
2016 it->phys_ascent = pcm->ascent + boff;
2017 it->phys_descent = pcm->descent - boff;
2018 if (it->glyph_row
2019 && (pcm->lbearing < 0
2020 || pcm->rbearing > pcm->width))
2021 it->glyph_row->contains_overlapping_glyphs_p = 1;
2022 }
2023 it->nglyphs = 1;
2024 it->ascent = font->ascent + boff;
2025 it->descent = font->descent - boff;
2026 if (face->box != FACE_NO_BOX)
2027 {
2028 int thick = face->box_line_width;
2029
2030 if (thick > 0)
2031 {
2032 it->ascent += thick;
2033 it->descent += thick;
2034 }
2035 else
2036 thick = - thick;
2037
2038 if (it->start_of_box_run_p)
2039 it->pixel_width += thick;
2040 if (it->end_of_box_run_p)
2041 it->pixel_width += thick;
2042 }
2043
2044 /* If face has an overline, add the height of the overline
2045 (1 pixel) and a 1 pixel margin to the character height. */
2046 if (face->overline_p)
2047 it->ascent += 2;
2048
2049 take_vertical_position_into_account (it);
2050
2051 if (it->glyph_row)
2052 x_append_glyph (it);
2053 }
2054 it->multibyte_p = saved_multibyte_p;
2055 }
2056 else if (it->what == IT_COMPOSITION)
2057 {
2058 /* Note: A composition is represented as one glyph in the
2059 glyph matrix. There are no padding glyphs. */
2060 XChar2b char2b;
2061 XFontStruct *font;
2062 struct face *face = FACE_FROM_ID (it->f, it->face_id);
2063 XCharStruct *pcm;
2064 int font_not_found_p;
2065 struct font_info *font_info;
2066 int boff; /* baseline offset */
2067 struct composition *cmp = composition_table[it->cmp_id];
2068
2069 /* Maybe translate single-byte characters to multibyte. */
2070 it->char_to_display = it->c;
2071 if (unibyte_display_via_language_environment
2072 && SINGLE_BYTE_CHAR_P (it->c)
2073 && (it->c >= 0240
2074 || (it->c >= 0200
2075 && !NILP (Vnonascii_translation_table))))
2076 {
2077 it->char_to_display = unibyte_char_to_multibyte (it->c);
2078 }
2079
2080 /* Get face and font to use. Encode IT->char_to_display. */
2081 it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display);
2082 face = FACE_FROM_ID (it->f, it->face_id);
2083 x_get_char_face_and_encoding (it->f, it->char_to_display,
2084 it->face_id, &char2b, it->multibyte_p);
2085 font = face->font;
2086
2087 /* When no suitable font found, use the default font. */
2088 font_not_found_p = font == NULL;
2089 if (font_not_found_p)
2090 {
2091 font = FRAME_FONT (it->f);
2092 boff = it->f->output_data.x->baseline_offset;
2093 font_info = NULL;
2094 }
2095 else
2096 {
2097 font_info = FONT_INFO_FROM_ID (it->f, face->font_info_id);
2098 boff = font_info->baseline_offset;
2099 if (font_info->vertical_centering)
2100 boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
2101 }
2102
2103 /* There are no padding glyphs, so there is only one glyph to
2104 produce for the composition. Important is that pixel_width,
2105 ascent and descent are the values of what is drawn by
2106 draw_glyphs (i.e. the values of the overall glyphs composed). */
2107 it->nglyphs = 1;
2108
2109 /* If we have not yet calculated pixel size data of glyphs of
2110 the composition for the current face font, calculate them
2111 now. Theoretically, we have to check all fonts for the
2112 glyphs, but that requires much time and memory space. So,
2113 here we check only the font of the first glyph. This leads
2114 to incorrect display very rarely, and C-l (recenter) can
2115 correct the display anyway. */
2116 if (cmp->font != (void *) font)
2117 {
2118 /* Ascent and descent of the font of the first character of
2119 this composition (adjusted by baseline offset). Ascent
2120 and descent of overall glyphs should not be less than
2121 them respectively. */
2122 int font_ascent = font->ascent + boff;
2123 int font_descent = font->descent - boff;
2124 /* Bounding box of the overall glyphs. */
2125 int leftmost, rightmost, lowest, highest;
2126 int i, width, ascent, descent;
2127
2128 cmp->font = (void *) font;
2129
2130 /* Initialize the bounding box. */
2131 if (font_info
2132 && (pcm = x_per_char_metric (font, &char2b)))
2133 {
2134 width = pcm->width;
2135 ascent = pcm->ascent;
2136 descent = pcm->descent;
2137 }
2138 else
2139 {
2140 width = FONT_WIDTH (font);
2141 ascent = font->ascent;
2142 descent = font->descent;
2143 }
2144
2145 rightmost = width;
2146 lowest = - descent + boff;
2147 highest = ascent + boff;
2148 leftmost = 0;
2149
2150 if (font_info
2151 && font_info->default_ascent
2152 && CHAR_TABLE_P (Vuse_default_ascent)
2153 && !NILP (Faref (Vuse_default_ascent,
2154 make_number (it->char_to_display))))
2155 highest = font_info->default_ascent + boff;
2156
2157 /* Draw the first glyph at the normal position. It may be
2158 shifted to right later if some other glyphs are drawn at
2159 the left. */
2160 cmp->offsets[0] = 0;
2161 cmp->offsets[1] = boff;
2162
2163 /* Set cmp->offsets for the remaining glyphs. */
2164 for (i = 1; i < cmp->glyph_len; i++)
2165 {
2166 int left, right, btm, top;
2167 int ch = COMPOSITION_GLYPH (cmp, i);
2168 int face_id = FACE_FOR_CHAR (it->f, face, ch);
2169
2170 face = FACE_FROM_ID (it->f, face_id);
2171 x_get_char_face_and_encoding (it->f, ch, face->id, &char2b,
2172 it->multibyte_p);
2173 font = face->font;
2174 if (font == NULL)
2175 {
2176 font = FRAME_FONT (it->f);
2177 boff = it->f->output_data.x->baseline_offset;
2178 font_info = NULL;
2179 }
2180 else
2181 {
2182 font_info
2183 = FONT_INFO_FROM_ID (it->f, face->font_info_id);
2184 boff = font_info->baseline_offset;
2185 if (font_info->vertical_centering)
2186 boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
2187 }
2188
2189 if (font_info
2190 && (pcm = x_per_char_metric (font, &char2b)))
2191 {
2192 width = pcm->width;
2193 ascent = pcm->ascent;
2194 descent = pcm->descent;
2195 }
2196 else
2197 {
2198 width = FONT_WIDTH (font);
2199 ascent = 1;
2200 descent = 0;
2201 }
2202
2203 if (cmp->method != COMPOSITION_WITH_RULE_ALTCHARS)
2204 {
2205 /* Relative composition with or without
2206 alternate chars. */
2207 left = (leftmost + rightmost - width) / 2;
2208 btm = - descent + boff;
2209 if (font_info && font_info->relative_compose
2210 && (! CHAR_TABLE_P (Vignore_relative_composition)
2211 || NILP (Faref (Vignore_relative_composition,
2212 make_number (ch)))))
2213 {
2214
2215 if (- descent >= font_info->relative_compose)
2216 /* One extra pixel between two glyphs. */
2217 btm = highest + 1;
2218 else if (ascent <= 0)
2219 /* One extra pixel between two glyphs. */
2220 btm = lowest - 1 - ascent - descent;
2221 }
2222 }
2223 else
2224 {
2225 /* A composition rule is specified by an integer
2226 value that encodes global and new reference
2227 points (GREF and NREF). GREF and NREF are
2228 specified by numbers as below:
2229
2230 0---1---2 -- ascent
2231 | |
2232 | |
2233 | |
2234 9--10--11 -- center
2235 | |
2236 ---3---4---5--- baseline
2237 | |
2238 6---7---8 -- descent
2239 */
2240 int rule = COMPOSITION_RULE (cmp, i);
2241 int gref, nref, grefx, grefy, nrefx, nrefy;
2242
2243 COMPOSITION_DECODE_RULE (rule, gref, nref);
2244 grefx = gref % 3, nrefx = nref % 3;
2245 grefy = gref / 3, nrefy = nref / 3;
2246
2247 left = (leftmost
2248 + grefx * (rightmost - leftmost) / 2
2249 - nrefx * width / 2);
2250 btm = ((grefy == 0 ? highest
2251 : grefy == 1 ? 0
2252 : grefy == 2 ? lowest
2253 : (highest + lowest) / 2)
2254 - (nrefy == 0 ? ascent + descent
2255 : nrefy == 1 ? descent - boff
2256 : nrefy == 2 ? 0
2257 : (ascent + descent) / 2));
2258 }
2259
2260 cmp->offsets[i * 2] = left;
2261 cmp->offsets[i * 2 + 1] = btm + descent;
2262
2263 /* Update the bounding box of the overall glyphs. */
2264 right = left + width;
2265 top = btm + descent + ascent;
2266 if (left < leftmost)
2267 leftmost = left;
2268 if (right > rightmost)
2269 rightmost = right;
2270 if (top > highest)
2271 highest = top;
2272 if (btm < lowest)
2273 lowest = btm;
2274 }
2275
2276 /* If there are glyphs whose x-offsets are negative,
2277 shift all glyphs to the right and make all x-offsets
2278 non-negative. */
2279 if (leftmost < 0)
2280 {
2281 for (i = 0; i < cmp->glyph_len; i++)
2282 cmp->offsets[i * 2] -= leftmost;
2283 rightmost -= leftmost;
2284 }
2285
2286 cmp->pixel_width = rightmost;
2287 cmp->ascent = highest;
2288 cmp->descent = - lowest;
2289 if (cmp->ascent < font_ascent)
2290 cmp->ascent = font_ascent;
2291 if (cmp->descent < font_descent)
2292 cmp->descent = font_descent;
2293 }
2294
2295 it->pixel_width = cmp->pixel_width;
2296 it->ascent = it->phys_ascent = cmp->ascent;
2297 it->descent = it->phys_descent = cmp->descent;
2298
2299 if (face->box != FACE_NO_BOX)
2300 {
2301 int thick = face->box_line_width;
2302
2303 if (thick > 0)
2304 {
2305 it->ascent += thick;
2306 it->descent += thick;
2307 }
2308 else
2309 thick = - thick;
2310
2311 if (it->start_of_box_run_p)
2312 it->pixel_width += thick;
2313 if (it->end_of_box_run_p)
2314 it->pixel_width += thick;
2315 }
2316
2317 /* If face has an overline, add the height of the overline
2318 (1 pixel) and a 1 pixel margin to the character height. */
2319 if (face->overline_p)
2320 it->ascent += 2;
2321
2322 take_vertical_position_into_account (it);
2323
2324 if (it->glyph_row)
2325 x_append_composite_glyph (it);
2326 }
2327 else if (it->what == IT_IMAGE)
2328 x_produce_image_glyph (it);
2329 else if (it->what == IT_STRETCH)
2330 x_produce_stretch_glyph (it);
2331
2332 /* Accumulate dimensions. Note: can't assume that it->descent > 0
2333 because this isn't true for images with `:ascent 100'. */
2334 xassert (it->ascent >= 0 && it->descent >= 0);
2335 if (it->area == TEXT_AREA)
2336 it->current_x += it->pixel_width;
2337
2338 it->descent += it->extra_line_spacing;
2339
2340 it->max_ascent = max (it->max_ascent, it->ascent);
2341 it->max_descent = max (it->max_descent, it->descent);
2342 it->max_phys_ascent = max (it->max_phys_ascent, it->phys_ascent);
2343 it->max_phys_descent = max (it->max_phys_descent, it->phys_descent);
2344 }
2345
2346
2347 /* Estimate the pixel height of the mode or top line on frame F.
2348 FACE_ID specifies what line's height to estimate. */
2349
2350 int
2351 x_estimate_mode_line_height (f, face_id)
2352 struct frame *f;
2353 enum face_id face_id;
2354 {
2355 int height = FONT_HEIGHT (FRAME_FONT (f));
2356
2357 /* This function is called so early when Emacs starts that the face
2358 cache and mode line face are not yet initialized. */
2359 if (FRAME_FACE_CACHE (f))
2360 {
2361 struct face *face = FACE_FROM_ID (f, face_id);
2362 if (face)
2363 {
2364 if (face->font)
2365 height = FONT_HEIGHT (face->font);
2366 if (face->box_line_width > 0)
2367 height += 2 * face->box_line_width;
2368 }
2369 }
2370
2371 return height;
2372 }
2373
2374 \f
2375 /***********************************************************************
2376 Glyph display
2377 ***********************************************************************/
2378
2379 /* A sequence of glyphs to be drawn in the same face.
2380
2381 This data structure is not really completely X specific, so it
2382 could possibly, at least partially, be useful for other systems. It
2383 is currently not part of the external redisplay interface because
2384 it's not clear what other systems will need. */
2385
2386 struct glyph_string
2387 {
2388 /* X-origin of the string. */
2389 int x;
2390
2391 /* Y-origin and y-position of the base line of this string. */
2392 int y, ybase;
2393
2394 /* The width of the string, not including a face extension. */
2395 int width;
2396
2397 /* The width of the string, including a face extension. */
2398 int background_width;
2399
2400 /* The height of this string. This is the height of the line this
2401 string is drawn in, and can be different from the height of the
2402 font the string is drawn in. */
2403 int height;
2404
2405 /* Number of pixels this string overwrites in front of its x-origin.
2406 This number is zero if the string has an lbearing >= 0; it is
2407 -lbearing, if the string has an lbearing < 0. */
2408 int left_overhang;
2409
2410 /* Number of pixels this string overwrites past its right-most
2411 nominal x-position, i.e. x + width. Zero if the string's
2412 rbearing is <= its nominal width, rbearing - width otherwise. */
2413 int right_overhang;
2414
2415 /* The frame on which the glyph string is drawn. */
2416 struct frame *f;
2417
2418 /* The window on which the glyph string is drawn. */
2419 struct window *w;
2420
2421 /* X display and window for convenience. */
2422 Display *display;
2423 Window window;
2424
2425 /* The glyph row for which this string was built. It determines the
2426 y-origin and height of the string. */
2427 struct glyph_row *row;
2428
2429 /* The area within row. */
2430 enum glyph_row_area area;
2431
2432 /* Characters to be drawn, and number of characters. */
2433 XChar2b *char2b;
2434 int nchars;
2435
2436 /* A face-override for drawing cursors, mouse face and similar. */
2437 enum draw_glyphs_face hl;
2438
2439 /* Face in which this string is to be drawn. */
2440 struct face *face;
2441
2442 /* Font in which this string is to be drawn. */
2443 XFontStruct *font;
2444
2445 /* Font info for this string. */
2446 struct font_info *font_info;
2447
2448 /* Non-null means this string describes (part of) a composition.
2449 All characters from char2b are drawn composed. */
2450 struct composition *cmp;
2451
2452 /* Index of this glyph string's first character in the glyph
2453 definition of CMP. If this is zero, this glyph string describes
2454 the first character of a composition. */
2455 int gidx;
2456
2457 /* 1 means this glyph strings face has to be drawn to the right end
2458 of the window's drawing area. */
2459 unsigned extends_to_end_of_line_p : 1;
2460
2461 /* 1 means the background of this string has been drawn. */
2462 unsigned background_filled_p : 1;
2463
2464 /* 1 means glyph string must be drawn with 16-bit functions. */
2465 unsigned two_byte_p : 1;
2466
2467 /* 1 means that the original font determined for drawing this glyph
2468 string could not be loaded. The member `font' has been set to
2469 the frame's default font in this case. */
2470 unsigned font_not_found_p : 1;
2471
2472 /* 1 means that the face in which this glyph string is drawn has a
2473 stipple pattern. */
2474 unsigned stippled_p : 1;
2475
2476 /* 1 means only the foreground of this glyph string must be drawn,
2477 and we should use the physical height of the line this glyph
2478 string appears in as clip rect. */
2479 unsigned for_overlaps_p : 1;
2480
2481 /* The GC to use for drawing this glyph string. */
2482 GC gc;
2483
2484 /* A pointer to the first glyph in the string. This glyph
2485 corresponds to char2b[0]. Needed to draw rectangles if
2486 font_not_found_p is 1. */
2487 struct glyph *first_glyph;
2488
2489 /* Image, if any. */
2490 struct image *img;
2491
2492 struct glyph_string *next, *prev;
2493 };
2494
2495
2496 #if 1
2497
2498 static void
2499 x_dump_glyph_string (s)
2500 struct glyph_string *s;
2501 {
2502 fprintf (stderr, "glyph string\n");
2503 fprintf (stderr, " x, y, w, h = %d, %d, %d, %d\n",
2504 s->x, s->y, s->width, s->height);
2505 fprintf (stderr, " ybase = %d\n", s->ybase);
2506 fprintf (stderr, " hl = %d\n", s->hl);
2507 fprintf (stderr, " left overhang = %d, right = %d\n",
2508 s->left_overhang, s->right_overhang);
2509 fprintf (stderr, " nchars = %d\n", s->nchars);
2510 fprintf (stderr, " extends to end of line = %d\n",
2511 s->extends_to_end_of_line_p);
2512 fprintf (stderr, " font height = %d\n", FONT_HEIGHT (s->font));
2513 fprintf (stderr, " bg width = %d\n", s->background_width);
2514 }
2515
2516 #endif /* GLYPH_DEBUG */
2517
2518
2519
2520 static void x_append_glyph_string_lists P_ ((struct glyph_string **,
2521 struct glyph_string **,
2522 struct glyph_string *,
2523 struct glyph_string *));
2524 static void x_prepend_glyph_string_lists P_ ((struct glyph_string **,
2525 struct glyph_string **,
2526 struct glyph_string *,
2527 struct glyph_string *));
2528 static void x_append_glyph_string P_ ((struct glyph_string **,
2529 struct glyph_string **,
2530 struct glyph_string *));
2531 static int x_left_overwritten P_ ((struct glyph_string *));
2532 static int x_left_overwriting P_ ((struct glyph_string *));
2533 static int x_right_overwritten P_ ((struct glyph_string *));
2534 static int x_right_overwriting P_ ((struct glyph_string *));
2535 static int x_fill_glyph_string P_ ((struct glyph_string *, int, int, int,
2536 int));
2537 static void x_init_glyph_string P_ ((struct glyph_string *,
2538 XChar2b *, struct window *,
2539 struct glyph_row *,
2540 enum glyph_row_area, int,
2541 enum draw_glyphs_face));
2542 static int x_draw_glyphs P_ ((struct window *, int , struct glyph_row *,
2543 enum glyph_row_area, int, int,
2544 enum draw_glyphs_face, int *, int *, int));
2545 static void x_set_glyph_string_clipping P_ ((struct glyph_string *));
2546 static void x_set_glyph_string_gc P_ ((struct glyph_string *));
2547 static void x_draw_glyph_string_background P_ ((struct glyph_string *,
2548 int));
2549 static void x_draw_glyph_string_foreground P_ ((struct glyph_string *));
2550 static void x_draw_composite_glyph_string_foreground P_ ((struct glyph_string *));
2551 static void x_draw_glyph_string_box P_ ((struct glyph_string *));
2552 static void x_draw_glyph_string P_ ((struct glyph_string *));
2553 static void x_compute_glyph_string_overhangs P_ ((struct glyph_string *));
2554 static void x_set_cursor_gc P_ ((struct glyph_string *));
2555 static void x_set_mode_line_face_gc P_ ((struct glyph_string *));
2556 static void x_set_mouse_face_gc P_ ((struct glyph_string *));
2557 static void x_get_glyph_overhangs P_ ((struct glyph *, struct frame *,
2558 int *, int *));
2559 static void x_compute_overhangs_and_x P_ ((struct glyph_string *, int, int));
2560 static int x_alloc_lighter_color P_ ((struct frame *, Display *, Colormap,
2561 unsigned long *, double, int));
2562 static void x_setup_relief_color P_ ((struct frame *, struct relief *,
2563 double, int, unsigned long));
2564 static void x_setup_relief_colors P_ ((struct glyph_string *));
2565 static void x_draw_image_glyph_string P_ ((struct glyph_string *));
2566 static void x_draw_image_relief P_ ((struct glyph_string *));
2567 static void x_draw_image_foreground P_ ((struct glyph_string *));
2568 static void x_draw_image_foreground_1 P_ ((struct glyph_string *, Pixmap));
2569 static void x_fill_image_glyph_string P_ ((struct glyph_string *));
2570 static void x_clear_glyph_string_rect P_ ((struct glyph_string *, int,
2571 int, int, int));
2572 static void x_draw_relief_rect P_ ((struct frame *, int, int, int, int,
2573 int, int, int, int, XRectangle *));
2574 static void x_draw_box_rect P_ ((struct glyph_string *, int, int, int, int,
2575 int, int, int, XRectangle *));
2576 static void x_fix_overlapping_area P_ ((struct window *, struct glyph_row *,
2577 enum glyph_row_area));
2578 static int x_fill_stretch_glyph_string P_ ((struct glyph_string *,
2579 struct glyph_row *,
2580 enum glyph_row_area, int, int));
2581
2582 #if GLYPH_DEBUG
2583 static void x_check_font P_ ((struct frame *, XFontStruct *));
2584 #endif
2585
2586
2587 /* Append the list of glyph strings with head H and tail T to the list
2588 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
2589
2590 static INLINE void
2591 x_append_glyph_string_lists (head, tail, h, t)
2592 struct glyph_string **head, **tail;
2593 struct glyph_string *h, *t;
2594 {
2595 if (h)
2596 {
2597 if (*head)
2598 (*tail)->next = h;
2599 else
2600 *head = h;
2601 h->prev = *tail;
2602 *tail = t;
2603 }
2604 }
2605
2606
2607 /* Prepend the list of glyph strings with head H and tail T to the
2608 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
2609 result. */
2610
2611 static INLINE void
2612 x_prepend_glyph_string_lists (head, tail, h, t)
2613 struct glyph_string **head, **tail;
2614 struct glyph_string *h, *t;
2615 {
2616 if (h)
2617 {
2618 if (*head)
2619 (*head)->prev = t;
2620 else
2621 *tail = t;
2622 t->next = *head;
2623 *head = h;
2624 }
2625 }
2626
2627
2628 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
2629 Set *HEAD and *TAIL to the resulting list. */
2630
2631 static INLINE void
2632 x_append_glyph_string (head, tail, s)
2633 struct glyph_string **head, **tail;
2634 struct glyph_string *s;
2635 {
2636 s->next = s->prev = NULL;
2637 x_append_glyph_string_lists (head, tail, s, s);
2638 }
2639
2640
2641 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
2642 face. */
2643
2644 static void
2645 x_set_cursor_gc (s)
2646 struct glyph_string *s;
2647 {
2648 if (s->font == FRAME_FONT (s->f)
2649 && s->face->background == FRAME_BACKGROUND_PIXEL (s->f)
2650 && s->face->foreground == FRAME_FOREGROUND_PIXEL (s->f)
2651 && !s->cmp)
2652 s->gc = s->f->output_data.x->cursor_gc;
2653 else
2654 {
2655 /* Cursor on non-default face: must merge. */
2656 XGCValues xgcv;
2657 unsigned long mask;
2658
2659 xgcv.background = s->f->output_data.x->cursor_pixel;
2660 xgcv.foreground = s->face->background;
2661
2662 /* If the glyph would be invisible, try a different foreground. */
2663 if (xgcv.foreground == xgcv.background)
2664 xgcv.foreground = s->face->foreground;
2665 if (xgcv.foreground == xgcv.background)
2666 xgcv.foreground = s->f->output_data.x->cursor_foreground_pixel;
2667 if (xgcv.foreground == xgcv.background)
2668 xgcv.foreground = s->face->foreground;
2669
2670 /* Make sure the cursor is distinct from text in this face. */
2671 if (xgcv.background == s->face->background
2672 && xgcv.foreground == s->face->foreground)
2673 {
2674 xgcv.background = s->face->foreground;
2675 xgcv.foreground = s->face->background;
2676 }
2677
2678 IF_DEBUG (x_check_font (s->f, s->font));
2679 xgcv.font = s->font->fid;
2680 xgcv.graphics_exposures = False;
2681 mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
2682
2683 if (FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc)
2684 XChangeGC (s->display, FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc,
2685 mask, &xgcv);
2686 else
2687 FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc
2688 = XCreateGC (s->display, s->window, mask, &xgcv);
2689
2690 s->gc = FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc;
2691 }
2692 }
2693
2694
2695 /* Set up S->gc of glyph string S for drawing text in mouse face. */
2696
2697 static void
2698 x_set_mouse_face_gc (s)
2699 struct glyph_string *s;
2700 {
2701 int face_id;
2702 struct face *face;
2703
2704 /* What face has to be used last for the mouse face? */
2705 face_id = FRAME_X_DISPLAY_INFO (s->f)->mouse_face_face_id;
2706 face = FACE_FROM_ID (s->f, face_id);
2707 if (face == NULL)
2708 face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
2709
2710 if (s->first_glyph->type == CHAR_GLYPH)
2711 face_id = FACE_FOR_CHAR (s->f, face, s->first_glyph->u.ch);
2712 else
2713 face_id = FACE_FOR_CHAR (s->f, face, 0);
2714 s->face = FACE_FROM_ID (s->f, face_id);
2715 PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
2716
2717 /* If font in this face is same as S->font, use it. */
2718 if (s->font == s->face->font)
2719 s->gc = s->face->gc;
2720 else
2721 {
2722 /* Otherwise construct scratch_cursor_gc with values from FACE
2723 but font FONT. */
2724 XGCValues xgcv;
2725 unsigned long mask;
2726
2727 xgcv.background = s->face->background;
2728 xgcv.foreground = s->face->foreground;
2729 IF_DEBUG (x_check_font (s->f, s->font));
2730 xgcv.font = s->font->fid;
2731 xgcv.graphics_exposures = False;
2732 mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
2733
2734 if (FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc)
2735 XChangeGC (s->display, FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc,
2736 mask, &xgcv);
2737 else
2738 FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc
2739 = XCreateGC (s->display, s->window, mask, &xgcv);
2740
2741 s->gc = FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc;
2742 }
2743
2744 xassert (s->gc != 0);
2745 }
2746
2747
2748 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
2749 Faces to use in the mode line have already been computed when the
2750 matrix was built, so there isn't much to do, here. */
2751
2752 static INLINE void
2753 x_set_mode_line_face_gc (s)
2754 struct glyph_string *s;
2755 {
2756 s->gc = s->face->gc;
2757 }
2758
2759
2760 /* Set S->gc of glyph string S for drawing that glyph string. Set
2761 S->stippled_p to a non-zero value if the face of S has a stipple
2762 pattern. */
2763
2764 static INLINE void
2765 x_set_glyph_string_gc (s)
2766 struct glyph_string *s;
2767 {
2768 PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
2769
2770 if (s->hl == DRAW_NORMAL_TEXT)
2771 {
2772 s->gc = s->face->gc;
2773 s->stippled_p = s->face->stipple != 0;
2774 }
2775 else if (s->hl == DRAW_INVERSE_VIDEO)
2776 {
2777 x_set_mode_line_face_gc (s);
2778 s->stippled_p = s->face->stipple != 0;
2779 }
2780 else if (s->hl == DRAW_CURSOR)
2781 {
2782 x_set_cursor_gc (s);
2783 s->stippled_p = 0;
2784 }
2785 else if (s->hl == DRAW_MOUSE_FACE)
2786 {
2787 x_set_mouse_face_gc (s);
2788 s->stippled_p = s->face->stipple != 0;
2789 }
2790 else if (s->hl == DRAW_IMAGE_RAISED
2791 || s->hl == DRAW_IMAGE_SUNKEN)
2792 {
2793 s->gc = s->face->gc;
2794 s->stippled_p = s->face->stipple != 0;
2795 }
2796 else
2797 {
2798 s->gc = s->face->gc;
2799 s->stippled_p = s->face->stipple != 0;
2800 }
2801
2802 /* GC must have been set. */
2803 xassert (s->gc != 0);
2804 }
2805
2806
2807 /* Return in *R the clipping rectangle for glyph string S. */
2808
2809 static void
2810 x_get_glyph_string_clip_rect (s, r)
2811 struct glyph_string *s;
2812 XRectangle *r;
2813 {
2814 if (s->row->full_width_p)
2815 {
2816 /* Draw full-width. X coordinates are relative to S->w->left. */
2817 int canon_x = CANON_X_UNIT (s->f);
2818
2819 r->x = WINDOW_LEFT_MARGIN (s->w) * canon_x;
2820 r->width = XFASTINT (s->w->width) * canon_x;
2821
2822 if (FRAME_HAS_VERTICAL_SCROLL_BARS (s->f))
2823 {
2824 int width = FRAME_SCROLL_BAR_WIDTH (s->f) * canon_x;
2825 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (s->f))
2826 r->x -= width;
2827 }
2828
2829 r->x += FRAME_INTERNAL_BORDER_WIDTH (s->f);
2830
2831 /* Unless displaying a mode or menu bar line, which are always
2832 fully visible, clip to the visible part of the row. */
2833 if (s->w->pseudo_window_p)
2834 r->height = s->row->visible_height;
2835 else
2836 r->height = s->height;
2837 }
2838 else
2839 {
2840 /* This is a text line that may be partially visible. */
2841 r->x = WINDOW_AREA_TO_FRAME_PIXEL_X (s->w, s->area, 0);
2842 r->width = window_box_width (s->w, s->area);
2843 r->height = s->row->visible_height;
2844 }
2845
2846 /* Don't use S->y for clipping because it doesn't take partially
2847 visible lines into account. For example, it can be negative for
2848 partially visible lines at the top of a window. */
2849 if (!s->row->full_width_p
2850 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s->w, s->row))
2851 r->y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s->w);
2852 else
2853 r->y = max (0, s->row->y);
2854
2855 /* If drawing a tool-bar window, draw it over the internal border
2856 at the top of the window. */
2857 if (s->w == XWINDOW (s->f->tool_bar_window))
2858 r->y -= s->f->output_data.x->internal_border_width;
2859
2860 /* If S draws overlapping rows, it's sufficient to use the top and
2861 bottom of the window for clipping because this glyph string
2862 intentionally draws over other lines. */
2863 if (s->for_overlaps_p)
2864 {
2865 r->y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s->w);
2866 r->height = window_text_bottom_y (s->w) - r->y;
2867 }
2868
2869 r->y = WINDOW_TO_FRAME_PIXEL_Y (s->w, r->y);
2870 }
2871
2872
2873 /* Set clipping for output of glyph string S. S may be part of a mode
2874 line or menu if we don't have X toolkit support. */
2875
2876 static INLINE void
2877 x_set_glyph_string_clipping (s)
2878 struct glyph_string *s;
2879 {
2880 XRectangle r;
2881 x_get_glyph_string_clip_rect (s, &r);
2882 XSetClipRectangles (s->display, s->gc, 0, 0, &r, 1, Unsorted);
2883 }
2884
2885
2886 /* Compute left and right overhang of glyph string S. If S is a glyph
2887 string for a composition, assume overhangs don't exist. */
2888
2889 static INLINE void
2890 x_compute_glyph_string_overhangs (s)
2891 struct glyph_string *s;
2892 {
2893 if (s->cmp == NULL
2894 && s->first_glyph->type == CHAR_GLYPH)
2895 {
2896 XCharStruct cs;
2897 int direction, font_ascent, font_descent;
2898 XTextExtents16 (s->font, s->char2b, s->nchars, &direction,
2899 &font_ascent, &font_descent, &cs);
2900 s->right_overhang = cs.rbearing > cs.width ? cs.rbearing - cs.width : 0;
2901 s->left_overhang = cs.lbearing < 0 ? -cs.lbearing : 0;
2902 }
2903 }
2904
2905
2906 /* Compute overhangs and x-positions for glyph string S and its
2907 predecessors, or successors. X is the starting x-position for S.
2908 BACKWARD_P non-zero means process predecessors. */
2909
2910 static void
2911 x_compute_overhangs_and_x (s, x, backward_p)
2912 struct glyph_string *s;
2913 int x;
2914 int backward_p;
2915 {
2916 if (backward_p)
2917 {
2918 while (s)
2919 {
2920 x_compute_glyph_string_overhangs (s);
2921 x -= s->width;
2922 s->x = x;
2923 s = s->prev;
2924 }
2925 }
2926 else
2927 {
2928 while (s)
2929 {
2930 x_compute_glyph_string_overhangs (s);
2931 s->x = x;
2932 x += s->width;
2933 s = s->next;
2934 }
2935 }
2936 }
2937
2938
2939 /* Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
2940 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
2941 assumed to be zero. */
2942
2943 static void
2944 x_get_glyph_overhangs (glyph, f, left, right)
2945 struct glyph *glyph;
2946 struct frame *f;
2947 int *left, *right;
2948 {
2949 *left = *right = 0;
2950
2951 if (glyph->type == CHAR_GLYPH)
2952 {
2953 XFontStruct *font;
2954 struct face *face;
2955 struct font_info *font_info;
2956 XChar2b char2b;
2957 XCharStruct *pcm;
2958
2959 face = x_get_glyph_face_and_encoding (f, glyph, &char2b, NULL);
2960 font = face->font;
2961 font_info = FONT_INFO_FROM_ID (f, face->font_info_id);
2962 if (font
2963 && (pcm = x_per_char_metric (font, &char2b)))
2964 {
2965 if (pcm->rbearing > pcm->width)
2966 *right = pcm->rbearing - pcm->width;
2967 if (pcm->lbearing < 0)
2968 *left = -pcm->lbearing;
2969 }
2970 }
2971 }
2972
2973
2974 /* Return the index of the first glyph preceding glyph string S that
2975 is overwritten by S because of S's left overhang. Value is -1
2976 if no glyphs are overwritten. */
2977
2978 static int
2979 x_left_overwritten (s)
2980 struct glyph_string *s;
2981 {
2982 int k;
2983
2984 if (s->left_overhang)
2985 {
2986 int x = 0, i;
2987 struct glyph *glyphs = s->row->glyphs[s->area];
2988 int first = s->first_glyph - glyphs;
2989
2990 for (i = first - 1; i >= 0 && x > -s->left_overhang; --i)
2991 x -= glyphs[i].pixel_width;
2992
2993 k = i + 1;
2994 }
2995 else
2996 k = -1;
2997
2998 return k;
2999 }
3000
3001
3002 /* Return the index of the first glyph preceding glyph string S that
3003 is overwriting S because of its right overhang. Value is -1 if no
3004 glyph in front of S overwrites S. */
3005
3006 static int
3007 x_left_overwriting (s)
3008 struct glyph_string *s;
3009 {
3010 int i, k, x;
3011 struct glyph *glyphs = s->row->glyphs[s->area];
3012 int first = s->first_glyph - glyphs;
3013
3014 k = -1;
3015 x = 0;
3016 for (i = first - 1; i >= 0; --i)
3017 {
3018 int left, right;
3019 x_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
3020 if (x + right > 0)
3021 k = i;
3022 x -= glyphs[i].pixel_width;
3023 }
3024
3025 return k;
3026 }
3027
3028
3029 /* Return the index of the last glyph following glyph string S that is
3030 not overwritten by S because of S's right overhang. Value is -1 if
3031 no such glyph is found. */
3032
3033 static int
3034 x_right_overwritten (s)
3035 struct glyph_string *s;
3036 {
3037 int k = -1;
3038
3039 if (s->right_overhang)
3040 {
3041 int x = 0, i;
3042 struct glyph *glyphs = s->row->glyphs[s->area];
3043 int first = (s->first_glyph - glyphs) + (s->cmp ? 1 : s->nchars);
3044 int end = s->row->used[s->area];
3045
3046 for (i = first; i < end && s->right_overhang > x; ++i)
3047 x += glyphs[i].pixel_width;
3048
3049 k = i;
3050 }
3051
3052 return k;
3053 }
3054
3055
3056 /* Return the index of the last glyph following glyph string S that
3057 overwrites S because of its left overhang. Value is negative
3058 if no such glyph is found. */
3059
3060 static int
3061 x_right_overwriting (s)
3062 struct glyph_string *s;
3063 {
3064 int i, k, x;
3065 int end = s->row->used[s->area];
3066 struct glyph *glyphs = s->row->glyphs[s->area];
3067 int first = (s->first_glyph - glyphs) + (s->cmp ? 1 : s->nchars);
3068
3069 k = -1;
3070 x = 0;
3071 for (i = first; i < end; ++i)
3072 {
3073 int left, right;
3074 x_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
3075 if (x - left < 0)
3076 k = i;
3077 x += glyphs[i].pixel_width;
3078 }
3079
3080 return k;
3081 }
3082
3083
3084 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
3085
3086 static INLINE void
3087 x_clear_glyph_string_rect (s, x, y, w, h)
3088 struct glyph_string *s;
3089 int x, y, w, h;
3090 {
3091 XGCValues xgcv;
3092 XGetGCValues (s->display, s->gc, GCForeground | GCBackground, &xgcv);
3093 XSetForeground (s->display, s->gc, xgcv.background);
3094 XFillRectangle (s->display, s->window, s->gc, x, y, w, h);
3095 XSetForeground (s->display, s->gc, xgcv.foreground);
3096 }
3097
3098
3099 /* Draw the background of glyph_string S. If S->background_filled_p
3100 is non-zero don't draw it. FORCE_P non-zero means draw the
3101 background even if it wouldn't be drawn normally. This is used
3102 when a string preceding S draws into the background of S, or S
3103 contains the first component of a composition. */
3104
3105 static void
3106 x_draw_glyph_string_background (s, force_p)
3107 struct glyph_string *s;
3108 int force_p;
3109 {
3110 /* Nothing to do if background has already been drawn or if it
3111 shouldn't be drawn in the first place. */
3112 if (!s->background_filled_p)
3113 {
3114 int box_line_width = max (s->face->box_line_width, 0);
3115
3116 if (s->stippled_p)
3117 {
3118 /* Fill background with a stipple pattern. */
3119 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
3120 XFillRectangle (s->display, s->window, s->gc, s->x,
3121 s->y + box_line_width,
3122 s->background_width,
3123 s->height - 2 * box_line_width);
3124 XSetFillStyle (s->display, s->gc, FillSolid);
3125 s->background_filled_p = 1;
3126 }
3127 else if (FONT_HEIGHT (s->font) < s->height - 2 * box_line_width
3128 || s->font_not_found_p
3129 || s->extends_to_end_of_line_p
3130 || force_p)
3131 {
3132 x_clear_glyph_string_rect (s, s->x, s->y + box_line_width,
3133 s->background_width,
3134 s->height - 2 * box_line_width);
3135 s->background_filled_p = 1;
3136 }
3137 }
3138 }
3139
3140
3141 /* Draw the foreground of glyph string S. */
3142
3143 static void
3144 x_draw_glyph_string_foreground (s)
3145 struct glyph_string *s;
3146 {
3147 int i, x;
3148
3149 /* If first glyph of S has a left box line, start drawing the text
3150 of S to the right of that box line. */
3151 if (s->face->box != FACE_NO_BOX
3152 && s->first_glyph->left_box_line_p)
3153 x = s->x + abs (s->face->box_line_width);
3154 else
3155 x = s->x;
3156
3157 /* Draw characters of S as rectangles if S's font could not be
3158 loaded. */
3159 if (s->font_not_found_p)
3160 {
3161 for (i = 0; i < s->nchars; ++i)
3162 {
3163 struct glyph *g = s->first_glyph + i;
3164 XDrawRectangle (s->display, s->window,
3165 s->gc, x, s->y, g->pixel_width - 1,
3166 s->height - 1);
3167 x += g->pixel_width;
3168 }
3169 }
3170 else
3171 {
3172 char *char1b = (char *) s->char2b;
3173 int boff = s->font_info->baseline_offset;
3174
3175 if (s->font_info->vertical_centering)
3176 boff = VCENTER_BASELINE_OFFSET (s->font, s->f) - boff;
3177
3178 /* If we can use 8-bit functions, condense S->char2b. */
3179 if (!s->two_byte_p)
3180 for (i = 0; i < s->nchars; ++i)
3181 char1b[i] = s->char2b[i].byte2;
3182
3183 /* Draw text with XDrawString if background has already been
3184 filled. Otherwise, use XDrawImageString. (Note that
3185 XDrawImageString is usually faster than XDrawString.) Always
3186 use XDrawImageString when drawing the cursor so that there is
3187 no chance that characters under a box cursor are invisible. */
3188 if (s->for_overlaps_p
3189 || (s->background_filled_p && s->hl != DRAW_CURSOR))
3190 {
3191 /* Draw characters with 16-bit or 8-bit functions. */
3192 if (s->two_byte_p)
3193 XDrawString16 (s->display, s->window, s->gc, x,
3194 s->ybase - boff, s->char2b, s->nchars);
3195 else
3196 XDrawString (s->display, s->window, s->gc, x,
3197 s->ybase - boff, char1b, s->nchars);
3198 }
3199 else
3200 {
3201 if (s->two_byte_p)
3202 XDrawImageString16 (s->display, s->window, s->gc, x,
3203 s->ybase - boff, s->char2b, s->nchars);
3204 else
3205 XDrawImageString (s->display, s->window, s->gc, x,
3206 s->ybase - boff, char1b, s->nchars);
3207 }
3208 }
3209 }
3210
3211 /* Draw the foreground of composite glyph string S. */
3212
3213 static void
3214 x_draw_composite_glyph_string_foreground (s)
3215 struct glyph_string *s;
3216 {
3217 int i, x;
3218
3219 /* If first glyph of S has a left box line, start drawing the text
3220 of S to the right of that box line. */
3221 if (s->face->box != FACE_NO_BOX
3222 && s->first_glyph->left_box_line_p)
3223 x = s->x + abs (s->face->box_line_width);
3224 else
3225 x = s->x;
3226
3227 /* S is a glyph string for a composition. S->gidx is the index of
3228 the first character drawn for glyphs of this composition.
3229 S->gidx == 0 means we are drawing the very first character of
3230 this composition. */
3231
3232 /* Draw a rectangle for the composition if the font for the very
3233 first character of the composition could not be loaded. */
3234 if (s->font_not_found_p)
3235 {
3236 if (s->gidx == 0)
3237 XDrawRectangle (s->display, s->window, s->gc, x, s->y,
3238 s->width - 1, s->height - 1);
3239 }
3240 else
3241 {
3242 for (i = 0; i < s->nchars; i++, ++s->gidx)
3243 XDrawString16 (s->display, s->window, s->gc,
3244 x + s->cmp->offsets[s->gidx * 2],
3245 s->ybase - s->cmp->offsets[s->gidx * 2 + 1],
3246 s->char2b + i, 1);
3247 }
3248 }
3249
3250
3251 #ifdef USE_X_TOOLKIT
3252
3253 static struct frame *x_frame_of_widget P_ ((Widget));
3254 static Boolean cvt_string_to_pixel P_ ((Display *, XrmValue *, Cardinal *,
3255 XrmValue *, XrmValue *, XtPointer *));
3256 static void cvt_pixel_dtor P_ ((XtAppContext, XrmValue *, XtPointer,
3257 XrmValue *, Cardinal *));
3258
3259
3260 /* Return the frame on which widget WIDGET is used.. Abort if frame
3261 cannot be determined. */
3262
3263 static struct frame *
3264 x_frame_of_widget (widget)
3265 Widget widget;
3266 {
3267 struct x_display_info *dpyinfo;
3268 Lisp_Object tail;
3269 struct frame *f;
3270
3271 dpyinfo = x_display_info_for_display (XtDisplay (widget));
3272
3273 /* Find the top-level shell of the widget. Note that this function
3274 can be called when the widget is not yet realized, so XtWindow
3275 (widget) == 0. That's the reason we can't simply use
3276 x_any_window_to_frame. */
3277 while (!XtIsTopLevelShell (widget))
3278 widget = XtParent (widget);
3279
3280 /* Look for a frame with that top-level widget. Allocate the color
3281 on that frame to get the right gamma correction value. */
3282 for (tail = Vframe_list; GC_CONSP (tail); tail = XCDR (tail))
3283 if (GC_FRAMEP (XCAR (tail))
3284 && (f = XFRAME (XCAR (tail)),
3285 (f->output_data.nothing != 1
3286 && FRAME_X_DISPLAY_INFO (f) == dpyinfo))
3287 && f->output_data.x->widget == widget)
3288 return f;
3289
3290 abort ();
3291 }
3292
3293
3294 /* Allocate the color COLOR->pixel on the screen and display of
3295 widget WIDGET in colormap CMAP. If an exact match cannot be
3296 allocated, try the nearest color available. Value is non-zero
3297 if successful. This is called from lwlib. */
3298
3299 int
3300 x_alloc_nearest_color_for_widget (widget, cmap, color)
3301 Widget widget;
3302 Colormap cmap;
3303 XColor *color;
3304 {
3305 struct frame *f = x_frame_of_widget (widget);
3306 return x_alloc_nearest_color (f, cmap, color);
3307 }
3308
3309
3310 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
3311 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3312 If this produces the same color as PIXEL, try a color where all RGB
3313 values have DELTA added. Return the allocated color in *PIXEL.
3314 DISPLAY is the X display, CMAP is the colormap to operate on.
3315 Value is non-zero if successful. */
3316
3317 int
3318 x_alloc_lighter_color_for_widget (widget, display, cmap, pixel, factor, delta)
3319 Widget widget;
3320 Display *display;
3321 Colormap cmap;
3322 unsigned long *pixel;
3323 double factor;
3324 int delta;
3325 {
3326 struct frame *f = x_frame_of_widget (widget);
3327 return x_alloc_lighter_color (f, display, cmap, pixel, factor, delta);
3328 }
3329
3330
3331 /* Structure specifying which arguments should be passed by Xt to
3332 cvt_string_to_pixel. We want the widget's screen and colormap. */
3333
3334 static XtConvertArgRec cvt_string_to_pixel_args[] =
3335 {
3336 {XtWidgetBaseOffset, (XtPointer) XtOffset (Widget, core.screen),
3337 sizeof (Screen *)},
3338 {XtWidgetBaseOffset, (XtPointer) XtOffset (Widget, core.colormap),
3339 sizeof (Colormap)}
3340 };
3341
3342
3343 /* The address of this variable is returned by
3344 cvt_string_to_pixel. */
3345
3346 static Pixel cvt_string_to_pixel_value;
3347
3348
3349 /* Convert a color name to a pixel color.
3350
3351 DPY is the display we are working on.
3352
3353 ARGS is an array of *NARGS XrmValue structures holding additional
3354 information about the widget for which the conversion takes place.
3355 The contents of this array are determined by the specification
3356 in cvt_string_to_pixel_args.
3357
3358 FROM is a pointer to an XrmValue which points to the color name to
3359 convert. TO is an XrmValue in which to return the pixel color.
3360
3361 CLOSURE_RET is a pointer to user-data, in which we record if
3362 we allocated the color or not.
3363
3364 Value is True if successful, False otherwise. */
3365
3366 static Boolean
3367 cvt_string_to_pixel (dpy, args, nargs, from, to, closure_ret)
3368 Display *dpy;
3369 XrmValue *args;
3370 Cardinal *nargs;
3371 XrmValue *from, *to;
3372 XtPointer *closure_ret;
3373 {
3374 Screen *screen;
3375 Colormap cmap;
3376 Pixel pixel;
3377 String color_name;
3378 XColor color;
3379
3380 if (*nargs != 2)
3381 {
3382 XtAppWarningMsg (XtDisplayToApplicationContext (dpy),
3383 "wrongParameters", "cvt_string_to_pixel",
3384 "XtToolkitError",
3385 "Screen and colormap args required", NULL, NULL);
3386 return False;
3387 }
3388
3389 screen = *(Screen **) args[0].addr;
3390 cmap = *(Colormap *) args[1].addr;
3391 color_name = (String) from->addr;
3392
3393 if (strcmp (color_name, XtDefaultBackground) == 0)
3394 {
3395 *closure_ret = (XtPointer) False;
3396 pixel = WhitePixelOfScreen (screen);
3397 }
3398 else if (strcmp (color_name, XtDefaultForeground) == 0)
3399 {
3400 *closure_ret = (XtPointer) False;
3401 pixel = BlackPixelOfScreen (screen);
3402 }
3403 else if (XParseColor (dpy, cmap, color_name, &color)
3404 && x_alloc_nearest_color_1 (dpy, cmap, &color))
3405 {
3406 pixel = color.pixel;
3407 *closure_ret = (XtPointer) True;
3408 }
3409 else
3410 {
3411 String params[1];
3412 Cardinal nparams = 1;
3413
3414 params[0] = color_name;
3415 XtAppWarningMsg (XtDisplayToApplicationContext (dpy),
3416 "badValue", "cvt_string_to_pixel",
3417 "XtToolkitError", "Invalid color `%s'",
3418 params, &nparams);
3419 return False;
3420 }
3421
3422 if (to->addr != NULL)
3423 {
3424 if (to->size < sizeof (Pixel))
3425 {
3426 to->size = sizeof (Pixel);
3427 return False;
3428 }
3429
3430 *(Pixel *) to->addr = pixel;
3431 }
3432 else
3433 {
3434 cvt_string_to_pixel_value = pixel;
3435 to->addr = (XtPointer) &cvt_string_to_pixel_value;
3436 }
3437
3438 to->size = sizeof (Pixel);
3439 return True;
3440 }
3441
3442
3443 /* Free a pixel color which was previously allocated via
3444 cvt_string_to_pixel. This is registered as the destructor
3445 for this type of resource via XtSetTypeConverter.
3446
3447 APP is the application context in which we work.
3448
3449 TO is a pointer to an XrmValue holding the color to free.
3450 CLOSURE is the value we stored in CLOSURE_RET for this color
3451 in cvt_string_to_pixel.
3452
3453 ARGS and NARGS are like for cvt_string_to_pixel. */
3454
3455 static void
3456 cvt_pixel_dtor (app, to, closure, args, nargs)
3457 XtAppContext app;
3458 XrmValuePtr to;
3459 XtPointer closure;
3460 XrmValuePtr args;
3461 Cardinal *nargs;
3462 {
3463 if (*nargs != 2)
3464 {
3465 XtAppWarningMsg (app, "wrongParameters", "cvt_pixel_dtor",
3466 "XtToolkitError",
3467 "Screen and colormap arguments required",
3468 NULL, NULL);
3469 }
3470 else if (closure != NULL)
3471 {
3472 /* We did allocate the pixel, so free it. */
3473 Screen *screen = *(Screen **) args[0].addr;
3474 Colormap cmap = *(Colormap *) args[1].addr;
3475 x_free_dpy_colors (DisplayOfScreen (screen), screen, cmap,
3476 (Pixel *) to->addr, 1);
3477 }
3478 }
3479
3480
3481 #endif /* USE_X_TOOLKIT */
3482
3483
3484 /* Value is an array of XColor structures for the contents of the
3485 color map of display DPY. Set *NCELLS to the size of the array.
3486 Note that this probably shouldn't be called for large color maps,
3487 say a 24-bit TrueColor map. */
3488
3489 static const XColor *
3490 x_color_cells (dpy, ncells)
3491 Display *dpy;
3492 int *ncells;
3493 {
3494 struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
3495
3496 if (dpyinfo->color_cells == NULL)
3497 {
3498 Screen *screen = dpyinfo->screen;
3499 int i;
3500
3501 dpyinfo->ncolor_cells
3502 = XDisplayCells (dpy, XScreenNumberOfScreen (screen));
3503 dpyinfo->color_cells
3504 = (XColor *) xmalloc (dpyinfo->ncolor_cells
3505 * sizeof *dpyinfo->color_cells);
3506
3507 for (i = 0; i < dpyinfo->ncolor_cells; ++i)
3508 dpyinfo->color_cells[i].pixel = i;
3509
3510 XQueryColors (dpy, dpyinfo->cmap,
3511 dpyinfo->color_cells, dpyinfo->ncolor_cells);
3512 }
3513
3514 *ncells = dpyinfo->ncolor_cells;
3515 return dpyinfo->color_cells;
3516 }
3517
3518
3519 /* On frame F, translate pixel colors to RGB values for the NCOLORS
3520 colors in COLORS. Use cached information, if available. */
3521
3522 void
3523 x_query_colors (f, colors, ncolors)
3524 struct frame *f;
3525 XColor *colors;
3526 int ncolors;
3527 {
3528 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
3529
3530 if (dpyinfo->color_cells)
3531 {
3532 int i;
3533 for (i = 0; i < ncolors; ++i)
3534 {
3535 unsigned long pixel = colors[i].pixel;
3536 xassert (pixel < dpyinfo->ncolor_cells);
3537 xassert (dpyinfo->color_cells[pixel].pixel == pixel);
3538 colors[i] = dpyinfo->color_cells[pixel];
3539 }
3540 }
3541 else
3542 XQueryColors (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), colors, ncolors);
3543 }
3544
3545
3546 /* On frame F, translate pixel color to RGB values for the color in
3547 COLOR. Use cached information, if available. */
3548
3549 void
3550 x_query_color (f, color)
3551 struct frame *f;
3552 XColor *color;
3553 {
3554 x_query_colors (f, color, 1);
3555 }
3556
3557
3558 /* Allocate the color COLOR->pixel on DISPLAY, colormap CMAP. If an
3559 exact match can't be allocated, try the nearest color available.
3560 Value is non-zero if successful. Set *COLOR to the color
3561 allocated. */
3562
3563 static int
3564 x_alloc_nearest_color_1 (dpy, cmap, color)
3565 Display *dpy;
3566 Colormap cmap;
3567 XColor *color;
3568 {
3569 int rc;
3570
3571 rc = XAllocColor (dpy, cmap, color);
3572 if (rc == 0)
3573 {
3574 /* If we got to this point, the colormap is full, so we're going
3575 to try to get the next closest color. The algorithm used is
3576 a least-squares matching, which is what X uses for closest
3577 color matching with StaticColor visuals. */
3578 int nearest, i;
3579 unsigned long nearest_delta = ~0;
3580 int ncells;
3581 const XColor *cells = x_color_cells (dpy, &ncells);
3582
3583 for (nearest = i = 0; i < ncells; ++i)
3584 {
3585 long dred = (color->red >> 8) - (cells[i].red >> 8);
3586 long dgreen = (color->green >> 8) - (cells[i].green >> 8);
3587 long dblue = (color->blue >> 8) - (cells[i].blue >> 8);
3588 unsigned long delta = dred * dred + dgreen * dgreen + dblue * dblue;
3589
3590 if (delta < nearest_delta)
3591 {
3592 nearest = i;
3593 nearest_delta = delta;
3594 }
3595 }
3596
3597 color->red = cells[nearest].red;
3598 color->green = cells[nearest].green;
3599 color->blue = cells[nearest].blue;
3600 rc = XAllocColor (dpy, cmap, color);
3601 }
3602 else
3603 {
3604 /* If allocation succeeded, and the allocated pixel color is not
3605 equal to a cached pixel color recorded earlier, there was a
3606 change in the colormap, so clear the color cache. */
3607 struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
3608 XColor *cached_color;
3609
3610 if (dpyinfo->color_cells
3611 && (cached_color = &dpyinfo->color_cells[color->pixel],
3612 (cached_color->red != color->red
3613 || cached_color->blue != color->blue
3614 || cached_color->green != color->green)))
3615 {
3616 xfree (dpyinfo->color_cells);
3617 dpyinfo->color_cells = NULL;
3618 dpyinfo->ncolor_cells = 0;
3619 }
3620 }
3621
3622 #ifdef DEBUG_X_COLORS
3623 if (rc)
3624 register_color (color->pixel);
3625 #endif /* DEBUG_X_COLORS */
3626
3627 return rc;
3628 }
3629
3630
3631 /* Allocate the color COLOR->pixel on frame F, colormap CMAP. If an
3632 exact match can't be allocated, try the nearest color available.
3633 Value is non-zero if successful. Set *COLOR to the color
3634 allocated. */
3635
3636 int
3637 x_alloc_nearest_color (f, cmap, color)
3638 struct frame *f;
3639 Colormap cmap;
3640 XColor *color;
3641 {
3642 gamma_correct (f, color);
3643 return x_alloc_nearest_color_1 (FRAME_X_DISPLAY (f), cmap, color);
3644 }
3645
3646
3647 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
3648 It's necessary to do this instead of just using PIXEL directly to
3649 get color reference counts right. */
3650
3651 unsigned long
3652 x_copy_color (f, pixel)
3653 struct frame *f;
3654 unsigned long pixel;
3655 {
3656 XColor color;
3657
3658 color.pixel = pixel;
3659 BLOCK_INPUT;
3660 x_query_color (f, &color);
3661 XAllocColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), &color);
3662 UNBLOCK_INPUT;
3663 #ifdef DEBUG_X_COLORS
3664 register_color (pixel);
3665 #endif
3666 return color.pixel;
3667 }
3668
3669
3670 /* Allocate color PIXEL on display DPY. PIXEL must already be allocated.
3671 It's necessary to do this instead of just using PIXEL directly to
3672 get color reference counts right. */
3673
3674 unsigned long
3675 x_copy_dpy_color (dpy, cmap, pixel)
3676 Display *dpy;
3677 Colormap cmap;
3678 unsigned long pixel;
3679 {
3680 XColor color;
3681
3682 color.pixel = pixel;
3683 BLOCK_INPUT;
3684 XQueryColor (dpy, cmap, &color);
3685 XAllocColor (dpy, cmap, &color);
3686 UNBLOCK_INPUT;
3687 #ifdef DEBUG_X_COLORS
3688 register_color (pixel);
3689 #endif
3690 return color.pixel;
3691 }
3692
3693
3694 /* Brightness beyond which a color won't have its highlight brightness
3695 boosted.
3696
3697 Nominally, highlight colors for `3d' faces are calculated by
3698 brightening an object's color by a constant scale factor, but this
3699 doesn't yield good results for dark colors, so for colors who's
3700 brightness is less than this value (on a scale of 0-65535) have an
3701 use an additional additive factor.
3702
3703 The value here is set so that the default menu-bar/mode-line color
3704 (grey75) will not have its highlights changed at all. */
3705 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
3706
3707
3708 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
3709 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3710 If this produces the same color as PIXEL, try a color where all RGB
3711 values have DELTA added. Return the allocated color in *PIXEL.
3712 DISPLAY is the X display, CMAP is the colormap to operate on.
3713 Value is non-zero if successful. */
3714
3715 static int
3716 x_alloc_lighter_color (f, display, cmap, pixel, factor, delta)
3717 struct frame *f;
3718 Display *display;
3719 Colormap cmap;
3720 unsigned long *pixel;
3721 double factor;
3722 int delta;
3723 {
3724 XColor color, new;
3725 long bright;
3726 int success_p;
3727
3728 /* Get RGB color values. */
3729 color.pixel = *pixel;
3730 x_query_color (f, &color);
3731
3732 /* Change RGB values by specified FACTOR. Avoid overflow! */
3733 xassert (factor >= 0);
3734 new.red = min (0xffff, factor * color.red);
3735 new.green = min (0xffff, factor * color.green);
3736 new.blue = min (0xffff, factor * color.blue);
3737
3738 /* Calculate brightness of COLOR. */
3739 bright = (2 * color.red + 3 * color.green + color.blue) / 6;
3740
3741 /* We only boost colors that are darker than
3742 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
3743 if (bright < HIGHLIGHT_COLOR_DARK_BOOST_LIMIT)
3744 /* Make an additive adjustment to NEW, because it's dark enough so
3745 that scaling by FACTOR alone isn't enough. */
3746 {
3747 /* How far below the limit this color is (0 - 1, 1 being darker). */
3748 double dimness = 1 - (double)bright / HIGHLIGHT_COLOR_DARK_BOOST_LIMIT;
3749 /* The additive adjustment. */
3750 int min_delta = delta * dimness * factor / 2;
3751
3752 if (factor < 1)
3753 {
3754 new.red = max (0, new.red - min_delta);
3755 new.green = max (0, new.green - min_delta);
3756 new.blue = max (0, new.blue - min_delta);
3757 }
3758 else
3759 {
3760 new.red = min (0xffff, min_delta + new.red);
3761 new.green = min (0xffff, min_delta + new.green);
3762 new.blue = min (0xffff, min_delta + new.blue);
3763 }
3764 }
3765
3766 /* Try to allocate the color. */
3767 success_p = x_alloc_nearest_color (f, cmap, &new);
3768 if (success_p)
3769 {
3770 if (new.pixel == *pixel)
3771 {
3772 /* If we end up with the same color as before, try adding
3773 delta to the RGB values. */
3774 x_free_colors (f, &new.pixel, 1);
3775
3776 new.red = min (0xffff, delta + color.red);
3777 new.green = min (0xffff, delta + color.green);
3778 new.blue = min (0xffff, delta + color.blue);
3779 success_p = x_alloc_nearest_color (f, cmap, &new);
3780 }
3781 else
3782 success_p = 1;
3783 *pixel = new.pixel;
3784 }
3785
3786 return success_p;
3787 }
3788
3789
3790 /* Set up the foreground color for drawing relief lines of glyph
3791 string S. RELIEF is a pointer to a struct relief containing the GC
3792 with which lines will be drawn. Use a color that is FACTOR or
3793 DELTA lighter or darker than the relief's background which is found
3794 in S->f->output_data.x->relief_background. If such a color cannot
3795 be allocated, use DEFAULT_PIXEL, instead. */
3796
3797 static void
3798 x_setup_relief_color (f, relief, factor, delta, default_pixel)
3799 struct frame *f;
3800 struct relief *relief;
3801 double factor;
3802 int delta;
3803 unsigned long default_pixel;
3804 {
3805 XGCValues xgcv;
3806 struct x_output *di = f->output_data.x;
3807 unsigned long mask = GCForeground | GCLineWidth | GCGraphicsExposures;
3808 unsigned long pixel;
3809 unsigned long background = di->relief_background;
3810 Colormap cmap = FRAME_X_COLORMAP (f);
3811 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
3812 Display *dpy = FRAME_X_DISPLAY (f);
3813
3814 xgcv.graphics_exposures = False;
3815 xgcv.line_width = 1;
3816
3817 /* Free previously allocated color. The color cell will be reused
3818 when it has been freed as many times as it was allocated, so this
3819 doesn't affect faces using the same colors. */
3820 if (relief->gc
3821 && relief->allocated_p)
3822 {
3823 x_free_colors (f, &relief->pixel, 1);
3824 relief->allocated_p = 0;
3825 }
3826
3827 /* Allocate new color. */
3828 xgcv.foreground = default_pixel;
3829 pixel = background;
3830 if (dpyinfo->n_planes != 1
3831 && x_alloc_lighter_color (f, dpy, cmap, &pixel, factor, delta))
3832 {
3833 relief->allocated_p = 1;
3834 xgcv.foreground = relief->pixel = pixel;
3835 }
3836
3837 if (relief->gc == 0)
3838 {
3839 xgcv.stipple = dpyinfo->gray;
3840 mask |= GCStipple;
3841 relief->gc = XCreateGC (dpy, FRAME_X_WINDOW (f), mask, &xgcv);
3842 }
3843 else
3844 XChangeGC (dpy, relief->gc, mask, &xgcv);
3845 }
3846
3847
3848 /* Set up colors for the relief lines around glyph string S. */
3849
3850 static void
3851 x_setup_relief_colors (s)
3852 struct glyph_string *s;
3853 {
3854 struct x_output *di = s->f->output_data.x;
3855 unsigned long color;
3856
3857 if (s->face->use_box_color_for_shadows_p)
3858 color = s->face->box_color;
3859 else
3860 {
3861 XGCValues xgcv;
3862
3863 /* Get the background color of the face. */
3864 XGetGCValues (s->display, s->gc, GCBackground, &xgcv);
3865 color = xgcv.background;
3866 }
3867
3868 if (di->white_relief.gc == 0
3869 || color != di->relief_background)
3870 {
3871 di->relief_background = color;
3872 x_setup_relief_color (s->f, &di->white_relief, 1.2, 0x8000,
3873 WHITE_PIX_DEFAULT (s->f));
3874 x_setup_relief_color (s->f, &di->black_relief, 0.6, 0x4000,
3875 BLACK_PIX_DEFAULT (s->f));
3876 }
3877 }
3878
3879
3880 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
3881 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
3882 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
3883 relief. LEFT_P non-zero means draw a relief on the left side of
3884 the rectangle. RIGHT_P non-zero means draw a relief on the right
3885 side of the rectangle. CLIP_RECT is the clipping rectangle to use
3886 when drawing. */
3887
3888 static void
3889 x_draw_relief_rect (f, left_x, top_y, right_x, bottom_y, width,
3890 raised_p, left_p, right_p, clip_rect)
3891 struct frame *f;
3892 int left_x, top_y, right_x, bottom_y, left_p, right_p, raised_p;
3893 XRectangle *clip_rect;
3894 {
3895 int i;
3896 GC gc;
3897
3898 if (raised_p)
3899 gc = f->output_data.x->white_relief.gc;
3900 else
3901 gc = f->output_data.x->black_relief.gc;
3902 XSetClipRectangles (FRAME_X_DISPLAY (f), gc, 0, 0, clip_rect, 1, Unsorted);
3903
3904 /* Top. */
3905 for (i = 0; i < width; ++i)
3906 XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
3907 left_x + i * left_p, top_y + i,
3908 right_x + 1 - i * right_p, top_y + i);
3909
3910 /* Left. */
3911 if (left_p)
3912 for (i = 0; i < width; ++i)
3913 XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
3914 left_x + i, top_y + i, left_x + i, bottom_y - i + 1);
3915
3916 XSetClipMask (FRAME_X_DISPLAY (f), gc, None);
3917 if (raised_p)
3918 gc = f->output_data.x->black_relief.gc;
3919 else
3920 gc = f->output_data.x->white_relief.gc;
3921 XSetClipRectangles (FRAME_X_DISPLAY (f), gc, 0, 0, clip_rect, 1, Unsorted);
3922
3923 /* Bottom. */
3924 for (i = 0; i < width; ++i)
3925 XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
3926 left_x + i * left_p + 1, bottom_y - i,
3927 right_x + 1 - i * right_p, bottom_y - i);
3928
3929 /* Right. */
3930 if (right_p)
3931 for (i = 0; i < width; ++i)
3932 XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
3933 right_x - i, top_y + i + 1, right_x - i, bottom_y - i);
3934
3935 XSetClipMask (FRAME_X_DISPLAY (f), gc, None);
3936 }
3937
3938
3939 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
3940 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
3941 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
3942 left side of the rectangle. RIGHT_P non-zero means draw a line
3943 on the right side of the rectangle. CLIP_RECT is the clipping
3944 rectangle to use when drawing. */
3945
3946 static void
3947 x_draw_box_rect (s, left_x, top_y, right_x, bottom_y, width,
3948 left_p, right_p, clip_rect)
3949 struct glyph_string *s;
3950 int left_x, top_y, right_x, bottom_y, left_p, right_p;
3951 XRectangle *clip_rect;
3952 {
3953 XGCValues xgcv;
3954
3955 XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
3956 XSetForeground (s->display, s->gc, s->face->box_color);
3957 XSetClipRectangles (s->display, s->gc, 0, 0, clip_rect, 1, Unsorted);
3958
3959 /* Top. */
3960 XFillRectangle (s->display, s->window, s->gc,
3961 left_x, top_y, right_x - left_x + 1, width);
3962
3963 /* Left. */
3964 if (left_p)
3965 XFillRectangle (s->display, s->window, s->gc,
3966 left_x, top_y, width, bottom_y - top_y + 1);
3967
3968 /* Bottom. */
3969 XFillRectangle (s->display, s->window, s->gc,
3970 left_x, bottom_y - width + 1, right_x - left_x + 1, width);
3971
3972 /* Right. */
3973 if (right_p)
3974 XFillRectangle (s->display, s->window, s->gc,
3975 right_x - width + 1, top_y, width, bottom_y - top_y + 1);
3976
3977 XSetForeground (s->display, s->gc, xgcv.foreground);
3978 XSetClipMask (s->display, s->gc, None);
3979 }
3980
3981
3982 /* Draw a box around glyph string S. */
3983
3984 static void
3985 x_draw_glyph_string_box (s)
3986 struct glyph_string *s;
3987 {
3988 int width, left_x, right_x, top_y, bottom_y, last_x, raised_p;
3989 int left_p, right_p;
3990 struct glyph *last_glyph;
3991 XRectangle clip_rect;
3992
3993 last_x = window_box_right (s->w, s->area);
3994 if (s->row->full_width_p
3995 && !s->w->pseudo_window_p)
3996 {
3997 last_x += FRAME_X_RIGHT_FLAGS_AREA_WIDTH (s->f);
3998 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (s->f))
3999 last_x += FRAME_SCROLL_BAR_WIDTH (s->f) * CANON_X_UNIT (s->f);
4000 }
4001
4002 /* The glyph that may have a right box line. */
4003 last_glyph = (s->cmp || s->img
4004 ? s->first_glyph
4005 : s->first_glyph + s->nchars - 1);
4006
4007 width = abs (s->face->box_line_width);
4008 raised_p = s->face->box == FACE_RAISED_BOX;
4009 left_x = s->x;
4010 right_x = (s->row->full_width_p && s->extends_to_end_of_line_p
4011 ? last_x - 1
4012 : min (last_x, s->x + s->background_width) - 1);
4013 top_y = s->y;
4014 bottom_y = top_y + s->height - 1;
4015
4016 left_p = (s->first_glyph->left_box_line_p
4017 || (s->hl == DRAW_MOUSE_FACE
4018 && (s->prev == NULL
4019 || s->prev->hl != s->hl)));
4020 right_p = (last_glyph->right_box_line_p
4021 || (s->hl == DRAW_MOUSE_FACE
4022 && (s->next == NULL
4023 || s->next->hl != s->hl)));
4024
4025 x_get_glyph_string_clip_rect (s, &clip_rect);
4026
4027 if (s->face->box == FACE_SIMPLE_BOX)
4028 x_draw_box_rect (s, left_x, top_y, right_x, bottom_y, width,
4029 left_p, right_p, &clip_rect);
4030 else
4031 {
4032 x_setup_relief_colors (s);
4033 x_draw_relief_rect (s->f, left_x, top_y, right_x, bottom_y,
4034 width, raised_p, left_p, right_p, &clip_rect);
4035 }
4036 }
4037
4038
4039 /* Draw foreground of image glyph string S. */
4040
4041 static void
4042 x_draw_image_foreground (s)
4043 struct glyph_string *s;
4044 {
4045 int x;
4046 int y = s->ybase - image_ascent (s->img, s->face);
4047
4048 /* If first glyph of S has a left box line, start drawing it to the
4049 right of that line. */
4050 if (s->face->box != FACE_NO_BOX
4051 && s->first_glyph->left_box_line_p)
4052 x = s->x + abs (s->face->box_line_width);
4053 else
4054 x = s->x;
4055
4056 /* If there is a margin around the image, adjust x- and y-position
4057 by that margin. */
4058 x += s->img->hmargin;
4059 y += s->img->vmargin;
4060
4061 if (s->img->pixmap)
4062 {
4063 if (s->img->mask)
4064 {
4065 /* We can't set both a clip mask and use XSetClipRectangles
4066 because the latter also sets a clip mask. We also can't
4067 trust on the shape extension to be available
4068 (XShapeCombineRegion). So, compute the rectangle to draw
4069 manually. */
4070 unsigned long mask = (GCClipMask | GCClipXOrigin | GCClipYOrigin
4071 | GCFunction);
4072 XGCValues xgcv;
4073 XRectangle clip_rect, image_rect, r;
4074
4075 xgcv.clip_mask = s->img->mask;
4076 xgcv.clip_x_origin = x;
4077 xgcv.clip_y_origin = y;
4078 xgcv.function = GXcopy;
4079 XChangeGC (s->display, s->gc, mask, &xgcv);
4080
4081 x_get_glyph_string_clip_rect (s, &clip_rect);
4082 image_rect.x = x;
4083 image_rect.y = y;
4084 image_rect.width = s->img->width;
4085 image_rect.height = s->img->height;
4086 if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
4087 XCopyArea (s->display, s->img->pixmap, s->window, s->gc,
4088 r.x - x, r.y - y, r.width, r.height, r.x, r.y);
4089 }
4090 else
4091 {
4092 unsigned long mask = GCClipXOrigin | GCClipYOrigin | GCFunction;
4093 XGCValues xgcv;
4094 XRectangle clip_rect, image_rect, r;
4095
4096 x_get_glyph_string_clip_rect (s, &clip_rect);
4097 image_rect.x = x;
4098 image_rect.y = y;
4099 image_rect.width = s->img->width;
4100 image_rect.height = s->img->height;
4101 if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
4102 XCopyArea (s->display, s->img->pixmap, s->window, s->gc,
4103 r.x - x, r.y - y, r.width, r.height, r.x, r.y);
4104
4105 /* When the image has a mask, we can expect that at
4106 least part of a mouse highlight or a block cursor will
4107 be visible. If the image doesn't have a mask, make
4108 a block cursor visible by drawing a rectangle around
4109 the image. I believe it's looking better if we do
4110 nothing here for mouse-face. */
4111 if (s->hl == DRAW_CURSOR)
4112 XDrawRectangle (s->display, s->window, s->gc, x, y,
4113 s->img->width - 1, s->img->height - 1);
4114 }
4115 }
4116 else
4117 /* Draw a rectangle if image could not be loaded. */
4118 XDrawRectangle (s->display, s->window, s->gc, x, y,
4119 s->img->width - 1, s->img->height - 1);
4120 }
4121
4122
4123 /* Draw a relief around the image glyph string S. */
4124
4125 static void
4126 x_draw_image_relief (s)
4127 struct glyph_string *s;
4128 {
4129 int x0, y0, x1, y1, thick, raised_p;
4130 XRectangle r;
4131 int x;
4132 int y = s->ybase - image_ascent (s->img, s->face);
4133
4134 /* If first glyph of S has a left box line, start drawing it to the
4135 right of that line. */
4136 if (s->face->box != FACE_NO_BOX
4137 && s->first_glyph->left_box_line_p)
4138 x = s->x + abs (s->face->box_line_width);
4139 else
4140 x = s->x;
4141
4142 /* If there is a margin around the image, adjust x- and y-position
4143 by that margin. */
4144 x += s->img->hmargin;
4145 y += s->img->vmargin;
4146
4147 if (s->hl == DRAW_IMAGE_SUNKEN
4148 || s->hl == DRAW_IMAGE_RAISED)
4149 {
4150 thick = tool_bar_button_relief > 0 ? tool_bar_button_relief : 3;
4151 raised_p = s->hl == DRAW_IMAGE_RAISED;
4152 }
4153 else
4154 {
4155 thick = abs (s->img->relief);
4156 raised_p = s->img->relief > 0;
4157 }
4158
4159 x0 = x - thick;
4160 y0 = y - thick;
4161 x1 = x + s->img->width + thick - 1;
4162 y1 = y + s->img->height + thick - 1;
4163
4164 x_setup_relief_colors (s);
4165 x_get_glyph_string_clip_rect (s, &r);
4166 x_draw_relief_rect (s->f, x0, y0, x1, y1, thick, raised_p, 1, 1, &r);
4167 }
4168
4169
4170 /* Draw the foreground of image glyph string S to PIXMAP. */
4171
4172 static void
4173 x_draw_image_foreground_1 (s, pixmap)
4174 struct glyph_string *s;
4175 Pixmap pixmap;
4176 {
4177 int x;
4178 int y = s->ybase - s->y - image_ascent (s->img, s->face);
4179
4180 /* If first glyph of S has a left box line, start drawing it to the
4181 right of that line. */
4182 if (s->face->box != FACE_NO_BOX
4183 && s->first_glyph->left_box_line_p)
4184 x = abs (s->face->box_line_width);
4185 else
4186 x = 0;
4187
4188 /* If there is a margin around the image, adjust x- and y-position
4189 by that margin. */
4190 x += s->img->hmargin;
4191 y += s->img->vmargin;
4192
4193 if (s->img->pixmap)
4194 {
4195 if (s->img->mask)
4196 {
4197 /* We can't set both a clip mask and use XSetClipRectangles
4198 because the latter also sets a clip mask. We also can't
4199 trust on the shape extension to be available
4200 (XShapeCombineRegion). So, compute the rectangle to draw
4201 manually. */
4202 unsigned long mask = (GCClipMask | GCClipXOrigin | GCClipYOrigin
4203 | GCFunction);
4204 XGCValues xgcv;
4205
4206 xgcv.clip_mask = s->img->mask;
4207 xgcv.clip_x_origin = x;
4208 xgcv.clip_y_origin = y;
4209 xgcv.function = GXcopy;
4210 XChangeGC (s->display, s->gc, mask, &xgcv);
4211
4212 XCopyArea (s->display, s->img->pixmap, pixmap, s->gc,
4213 0, 0, s->img->width, s->img->height, x, y);
4214 XSetClipMask (s->display, s->gc, None);
4215 }
4216 else
4217 {
4218 XCopyArea (s->display, s->img->pixmap, pixmap, s->gc,
4219 0, 0, s->img->width, s->img->height, x, y);
4220
4221 /* When the image has a mask, we can expect that at
4222 least part of a mouse highlight or a block cursor will
4223 be visible. If the image doesn't have a mask, make
4224 a block cursor visible by drawing a rectangle around
4225 the image. I believe it's looking better if we do
4226 nothing here for mouse-face. */
4227 if (s->hl == DRAW_CURSOR)
4228 XDrawRectangle (s->display, pixmap, s->gc, x, y,
4229 s->img->width - 1, s->img->height - 1);
4230 }
4231 }
4232 else
4233 /* Draw a rectangle if image could not be loaded. */
4234 XDrawRectangle (s->display, pixmap, s->gc, x, y,
4235 s->img->width - 1, s->img->height - 1);
4236 }
4237
4238
4239 /* Draw part of the background of glyph string S. X, Y, W, and H
4240 give the rectangle to draw. */
4241
4242 static void
4243 x_draw_glyph_string_bg_rect (s, x, y, w, h)
4244 struct glyph_string *s;
4245 int x, y, w, h;
4246 {
4247 if (s->stippled_p)
4248 {
4249 /* Fill background with a stipple pattern. */
4250 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
4251 XFillRectangle (s->display, s->window, s->gc, x, y, w, h);
4252 XSetFillStyle (s->display, s->gc, FillSolid);
4253 }
4254 else
4255 x_clear_glyph_string_rect (s, x, y, w, h);
4256 }
4257
4258
4259 /* Draw image glyph string S.
4260
4261 s->y
4262 s->x +-------------------------
4263 | s->face->box
4264 |
4265 | +-------------------------
4266 | | s->img->margin
4267 | |
4268 | | +-------------------
4269 | | | the image
4270
4271 */
4272
4273 static void
4274 x_draw_image_glyph_string (s)
4275 struct glyph_string *s;
4276 {
4277 int x, y;
4278 int box_line_hwidth = abs (s->face->box_line_width);
4279 int box_line_vwidth = max (s->face->box_line_width, 0);
4280 int height;
4281 Pixmap pixmap = None;
4282
4283 height = s->height - 2 * box_line_vwidth;
4284
4285 /* Fill background with face under the image. Do it only if row is
4286 taller than image or if image has a clip mask to reduce
4287 flickering. */
4288 s->stippled_p = s->face->stipple != 0;
4289 if (height > s->img->height
4290 || s->img->hmargin
4291 || s->img->vmargin
4292 || s->img->mask
4293 || s->img->pixmap == 0
4294 || s->width != s->background_width)
4295 {
4296 if (box_line_hwidth && s->first_glyph->left_box_line_p)
4297 x = s->x + box_line_hwidth;
4298 else
4299 x = s->x;
4300
4301 y = s->y + box_line_vwidth;
4302
4303 if (s->img->mask)
4304 {
4305 /* Create a pixmap as large as the glyph string. Fill it
4306 with the background color. Copy the image to it, using
4307 its mask. Copy the temporary pixmap to the display. */
4308 Screen *screen = FRAME_X_SCREEN (s->f);
4309 int depth = DefaultDepthOfScreen (screen);
4310
4311 /* Create a pixmap as large as the glyph string. */
4312 pixmap = XCreatePixmap (s->display, s->window,
4313 s->background_width,
4314 s->height, depth);
4315
4316 /* Don't clip in the following because we're working on the
4317 pixmap. */
4318 XSetClipMask (s->display, s->gc, None);
4319
4320 /* Fill the pixmap with the background color/stipple. */
4321 if (s->stippled_p)
4322 {
4323 /* Fill background with a stipple pattern. */
4324 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
4325 XFillRectangle (s->display, pixmap, s->gc,
4326 0, 0, s->background_width, s->height);
4327 XSetFillStyle (s->display, s->gc, FillSolid);
4328 }
4329 else
4330 {
4331 XGCValues xgcv;
4332 XGetGCValues (s->display, s->gc, GCForeground | GCBackground,
4333 &xgcv);
4334 XSetForeground (s->display, s->gc, xgcv.background);
4335 XFillRectangle (s->display, pixmap, s->gc,
4336 0, 0, s->background_width, s->height);
4337 XSetForeground (s->display, s->gc, xgcv.foreground);
4338 }
4339 }
4340 else
4341 x_draw_glyph_string_bg_rect (s, x, y, s->background_width, height);
4342
4343 s->background_filled_p = 1;
4344 }
4345
4346 /* Draw the foreground. */
4347 if (pixmap != None)
4348 {
4349 x_draw_image_foreground_1 (s, pixmap);
4350 x_set_glyph_string_clipping (s);
4351 XCopyArea (s->display, pixmap, s->window, s->gc,
4352 0, 0, s->background_width, s->height, s->x, s->y);
4353 XFreePixmap (s->display, pixmap);
4354 }
4355 else
4356 x_draw_image_foreground (s);
4357
4358 /* If we must draw a relief around the image, do it. */
4359 if (s->img->relief
4360 || s->hl == DRAW_IMAGE_RAISED
4361 || s->hl == DRAW_IMAGE_SUNKEN)
4362 x_draw_image_relief (s);
4363 }
4364
4365
4366 /* Draw stretch glyph string S. */
4367
4368 static void
4369 x_draw_stretch_glyph_string (s)
4370 struct glyph_string *s;
4371 {
4372 xassert (s->first_glyph->type == STRETCH_GLYPH);
4373 s->stippled_p = s->face->stipple != 0;
4374
4375 if (s->hl == DRAW_CURSOR
4376 && !x_stretch_cursor_p)
4377 {
4378 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
4379 as wide as the stretch glyph. */
4380 int width = min (CANON_X_UNIT (s->f), s->background_width);
4381
4382 /* Draw cursor. */
4383 x_draw_glyph_string_bg_rect (s, s->x, s->y, width, s->height);
4384
4385 /* Clear rest using the GC of the original non-cursor face. */
4386 if (width < s->background_width)
4387 {
4388 int x = s->x + width, y = s->y;
4389 int w = s->background_width - width, h = s->height;
4390 XRectangle r;
4391 GC gc;
4392
4393 if (s->row->mouse_face_p
4394 && cursor_in_mouse_face_p (s->w))
4395 {
4396 x_set_mouse_face_gc (s);
4397 gc = s->gc;
4398 }
4399 else
4400 gc = s->face->gc;
4401
4402 x_get_glyph_string_clip_rect (s, &r);
4403 XSetClipRectangles (s->display, gc, 0, 0, &r, 1, Unsorted);
4404
4405 if (s->face->stipple)
4406 {
4407 /* Fill background with a stipple pattern. */
4408 XSetFillStyle (s->display, gc, FillOpaqueStippled);
4409 XFillRectangle (s->display, s->window, gc, x, y, w, h);
4410 XSetFillStyle (s->display, gc, FillSolid);
4411 }
4412 else
4413 {
4414 XGCValues xgcv;
4415 XGetGCValues (s->display, gc, GCForeground | GCBackground, &xgcv);
4416 XSetForeground (s->display, gc, xgcv.background);
4417 XFillRectangle (s->display, s->window, gc, x, y, w, h);
4418 XSetForeground (s->display, gc, xgcv.foreground);
4419 }
4420 }
4421 }
4422 else if (!s->background_filled_p)
4423 x_draw_glyph_string_bg_rect (s, s->x, s->y, s->background_width,
4424 s->height);
4425
4426 s->background_filled_p = 1;
4427 }
4428
4429
4430 /* Draw glyph string S. */
4431
4432 static void
4433 x_draw_glyph_string (s)
4434 struct glyph_string *s;
4435 {
4436 int relief_drawn_p = 0;
4437
4438 /* If S draws into the background of its successor, draw the
4439 background of the successor first so that S can draw into it.
4440 This makes S->next use XDrawString instead of XDrawImageString. */
4441 if (s->next && s->right_overhang && !s->for_overlaps_p)
4442 {
4443 xassert (s->next->img == NULL);
4444 x_set_glyph_string_gc (s->next);
4445 x_set_glyph_string_clipping (s->next);
4446 x_draw_glyph_string_background (s->next, 1);
4447 }
4448
4449 /* Set up S->gc, set clipping and draw S. */
4450 x_set_glyph_string_gc (s);
4451 x_set_glyph_string_clipping (s);
4452
4453 /* Draw relief (if any) in advance for char/composition so that the
4454 glyph string can be drawn over it. */
4455 if (!s->for_overlaps_p
4456 && s->face->box != FACE_NO_BOX
4457 && (s->first_glyph->type == CHAR_GLYPH
4458 || s->first_glyph->type == COMPOSITE_GLYPH))
4459
4460 {
4461 x_draw_glyph_string_background (s, 1);
4462 x_draw_glyph_string_box (s);
4463 relief_drawn_p = 1;
4464 }
4465
4466 switch (s->first_glyph->type)
4467 {
4468 case IMAGE_GLYPH:
4469 x_draw_image_glyph_string (s);
4470 break;
4471
4472 case STRETCH_GLYPH:
4473 x_draw_stretch_glyph_string (s);
4474 break;
4475
4476 case CHAR_GLYPH:
4477 if (s->for_overlaps_p)
4478 s->background_filled_p = 1;
4479 else
4480 x_draw_glyph_string_background (s, 0);
4481 x_draw_glyph_string_foreground (s);
4482 break;
4483
4484 case COMPOSITE_GLYPH:
4485 if (s->for_overlaps_p || s->gidx > 0)
4486 s->background_filled_p = 1;
4487 else
4488 x_draw_glyph_string_background (s, 1);
4489 x_draw_composite_glyph_string_foreground (s);
4490 break;
4491
4492 default:
4493 abort ();
4494 }
4495
4496 if (!s->for_overlaps_p)
4497 {
4498 /* Draw underline. */
4499 if (s->face->underline_p)
4500 {
4501 unsigned long tem, h;
4502 int y;
4503
4504 /* Get the underline thickness. Default is 1 pixel. */
4505 if (!XGetFontProperty (s->font, XA_UNDERLINE_THICKNESS, &h))
4506 h = 1;
4507
4508 /* Get the underline position. This is the recommended
4509 vertical offset in pixels from the baseline to the top of
4510 the underline. This is a signed value according to the
4511 specs, and its default is
4512
4513 ROUND ((maximum descent) / 2), with
4514 ROUND(x) = floor (x + 0.5) */
4515
4516 if (x_use_underline_position_properties
4517 && XGetFontProperty (s->font, XA_UNDERLINE_POSITION, &tem))
4518 y = s->ybase + (long) tem;
4519 else if (s->face->font)
4520 y = s->ybase + (s->face->font->max_bounds.descent + 1) / 2;
4521 else
4522 y = s->y + s->height - h;
4523
4524 if (s->face->underline_defaulted_p)
4525 XFillRectangle (s->display, s->window, s->gc,
4526 s->x, y, s->width, h);
4527 else
4528 {
4529 XGCValues xgcv;
4530 XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
4531 XSetForeground (s->display, s->gc, s->face->underline_color);
4532 XFillRectangle (s->display, s->window, s->gc,
4533 s->x, y, s->width, h);
4534 XSetForeground (s->display, s->gc, xgcv.foreground);
4535 }
4536 }
4537
4538 /* Draw overline. */
4539 if (s->face->overline_p)
4540 {
4541 unsigned long dy = 0, h = 1;
4542
4543 if (s->face->overline_color_defaulted_p)
4544 XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
4545 s->width, h);
4546 else
4547 {
4548 XGCValues xgcv;
4549 XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
4550 XSetForeground (s->display, s->gc, s->face->overline_color);
4551 XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
4552 s->width, h);
4553 XSetForeground (s->display, s->gc, xgcv.foreground);
4554 }
4555 }
4556
4557 /* Draw strike-through. */
4558 if (s->face->strike_through_p)
4559 {
4560 unsigned long h = 1;
4561 unsigned long dy = (s->height - h) / 2;
4562
4563 if (s->face->strike_through_color_defaulted_p)
4564 XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
4565 s->width, h);
4566 else
4567 {
4568 XGCValues xgcv;
4569 XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
4570 XSetForeground (s->display, s->gc, s->face->strike_through_color);
4571 XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
4572 s->width, h);
4573 XSetForeground (s->display, s->gc, xgcv.foreground);
4574 }
4575 }
4576
4577 /* Draw relief if not yet drawn. */
4578 if (!relief_drawn_p && s->face->box != FACE_NO_BOX)
4579 x_draw_glyph_string_box (s);
4580 }
4581
4582 /* Reset clipping. */
4583 XSetClipMask (s->display, s->gc, None);
4584 }
4585
4586
4587 static int x_fill_composite_glyph_string P_ ((struct glyph_string *,
4588 struct face **, int));
4589
4590
4591 /* Fill glyph string S with composition components specified by S->cmp.
4592
4593 FACES is an array of faces for all components of this composition.
4594 S->gidx is the index of the first component for S.
4595 OVERLAPS_P non-zero means S should draw the foreground only, and
4596 use its physical height for clipping.
4597
4598 Value is the index of a component not in S. */
4599
4600 static int
4601 x_fill_composite_glyph_string (s, faces, overlaps_p)
4602 struct glyph_string *s;
4603 struct face **faces;
4604 int overlaps_p;
4605 {
4606 int i;
4607
4608 xassert (s);
4609
4610 s->for_overlaps_p = overlaps_p;
4611
4612 s->face = faces[s->gidx];
4613 s->font = s->face->font;
4614 s->font_info = FONT_INFO_FROM_ID (s->f, s->face->font_info_id);
4615
4616 /* For all glyphs of this composition, starting at the offset
4617 S->gidx, until we reach the end of the definition or encounter a
4618 glyph that requires the different face, add it to S. */
4619 ++s->nchars;
4620 for (i = s->gidx + 1; i < s->cmp->glyph_len && faces[i] == s->face; ++i)
4621 ++s->nchars;
4622
4623 /* All glyph strings for the same composition has the same width,
4624 i.e. the width set for the first component of the composition. */
4625
4626 s->width = s->first_glyph->pixel_width;
4627
4628 /* If the specified font could not be loaded, use the frame's
4629 default font, but record the fact that we couldn't load it in
4630 the glyph string so that we can draw rectangles for the
4631 characters of the glyph string. */
4632 if (s->font == NULL)
4633 {
4634 s->font_not_found_p = 1;
4635 s->font = FRAME_FONT (s->f);
4636 }
4637
4638 /* Adjust base line for subscript/superscript text. */
4639 s->ybase += s->first_glyph->voffset;
4640
4641 xassert (s->face && s->face->gc);
4642
4643 /* This glyph string must always be drawn with 16-bit functions. */
4644 s->two_byte_p = 1;
4645
4646 return s->gidx + s->nchars;
4647 }
4648
4649
4650 /* Fill glyph string S from a sequence of character glyphs.
4651
4652 FACE_ID is the face id of the string. START is the index of the
4653 first glyph to consider, END is the index of the last + 1.
4654 OVERLAPS_P non-zero means S should draw the foreground only, and
4655 use its physical height for clipping.
4656
4657 Value is the index of the first glyph not in S. */
4658
4659 static int
4660 x_fill_glyph_string (s, face_id, start, end, overlaps_p)
4661 struct glyph_string *s;
4662 int face_id;
4663 int start, end, overlaps_p;
4664 {
4665 struct glyph *glyph, *last;
4666 int voffset;
4667 int glyph_not_available_p;
4668
4669 xassert (s->f == XFRAME (s->w->frame));
4670 xassert (s->nchars == 0);
4671 xassert (start >= 0 && end > start);
4672
4673 s->for_overlaps_p = overlaps_p,
4674 glyph = s->row->glyphs[s->area] + start;
4675 last = s->row->glyphs[s->area] + end;
4676 voffset = glyph->voffset;
4677
4678 glyph_not_available_p = glyph->glyph_not_available_p;
4679
4680 while (glyph < last
4681 && glyph->type == CHAR_GLYPH
4682 && glyph->voffset == voffset
4683 /* Same face id implies same font, nowadays. */
4684 && glyph->face_id == face_id
4685 && glyph->glyph_not_available_p == glyph_not_available_p)
4686 {
4687 int two_byte_p;
4688
4689 s->face = x_get_glyph_face_and_encoding (s->f, glyph,
4690 s->char2b + s->nchars,
4691 &two_byte_p);
4692 s->two_byte_p = two_byte_p;
4693 ++s->nchars;
4694 xassert (s->nchars <= end - start);
4695 s->width += glyph->pixel_width;
4696 ++glyph;
4697 }
4698
4699 s->font = s->face->font;
4700 s->font_info = FONT_INFO_FROM_ID (s->f, s->face->font_info_id);
4701
4702 /* If the specified font could not be loaded, use the frame's font,
4703 but record the fact that we couldn't load it in
4704 S->font_not_found_p so that we can draw rectangles for the
4705 characters of the glyph string. */
4706 if (s->font == NULL || glyph_not_available_p)
4707 {
4708 s->font_not_found_p = 1;
4709 s->font = FRAME_FONT (s->f);
4710 }
4711
4712 /* Adjust base line for subscript/superscript text. */
4713 s->ybase += voffset;
4714
4715 xassert (s->face && s->face->gc);
4716 return glyph - s->row->glyphs[s->area];
4717 }
4718
4719
4720 /* Fill glyph string S from image glyph S->first_glyph. */
4721
4722 static void
4723 x_fill_image_glyph_string (s)
4724 struct glyph_string *s;
4725 {
4726 xassert (s->first_glyph->type == IMAGE_GLYPH);
4727 s->img = IMAGE_FROM_ID (s->f, s->first_glyph->u.img_id);
4728 xassert (s->img);
4729 s->face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
4730 s->font = s->face->font;
4731 s->width = s->first_glyph->pixel_width;
4732
4733 /* Adjust base line for subscript/superscript text. */
4734 s->ybase += s->first_glyph->voffset;
4735 }
4736
4737
4738 /* Fill glyph string S from a sequence of stretch glyphs.
4739
4740 ROW is the glyph row in which the glyphs are found, AREA is the
4741 area within the row. START is the index of the first glyph to
4742 consider, END is the index of the last + 1.
4743
4744 Value is the index of the first glyph not in S. */
4745
4746 static int
4747 x_fill_stretch_glyph_string (s, row, area, start, end)
4748 struct glyph_string *s;
4749 struct glyph_row *row;
4750 enum glyph_row_area area;
4751 int start, end;
4752 {
4753 struct glyph *glyph, *last;
4754 int voffset, face_id;
4755
4756 xassert (s->first_glyph->type == STRETCH_GLYPH);
4757
4758 glyph = s->row->glyphs[s->area] + start;
4759 last = s->row->glyphs[s->area] + end;
4760 face_id = glyph->face_id;
4761 s->face = FACE_FROM_ID (s->f, face_id);
4762 s->font = s->face->font;
4763 s->font_info = FONT_INFO_FROM_ID (s->f, s->face->font_info_id);
4764 s->width = glyph->pixel_width;
4765 voffset = glyph->voffset;
4766
4767 for (++glyph;
4768 (glyph < last
4769 && glyph->type == STRETCH_GLYPH
4770 && glyph->voffset == voffset
4771 && glyph->face_id == face_id);
4772 ++glyph)
4773 s->width += glyph->pixel_width;
4774
4775 /* Adjust base line for subscript/superscript text. */
4776 s->ybase += voffset;
4777
4778 xassert (s->face && s->face->gc);
4779 return glyph - s->row->glyphs[s->area];
4780 }
4781
4782
4783 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
4784 of XChar2b structures for S; it can't be allocated in
4785 x_init_glyph_string because it must be allocated via `alloca'. W
4786 is the window on which S is drawn. ROW and AREA are the glyph row
4787 and area within the row from which S is constructed. START is the
4788 index of the first glyph structure covered by S. HL is a
4789 face-override for drawing S. */
4790
4791 static void
4792 x_init_glyph_string (s, char2b, w, row, area, start, hl)
4793 struct glyph_string *s;
4794 XChar2b *char2b;
4795 struct window *w;
4796 struct glyph_row *row;
4797 enum glyph_row_area area;
4798 int start;
4799 enum draw_glyphs_face hl;
4800 {
4801 bzero (s, sizeof *s);
4802 s->w = w;
4803 s->f = XFRAME (w->frame);
4804 s->display = FRAME_X_DISPLAY (s->f);
4805 s->window = FRAME_X_WINDOW (s->f);
4806 s->char2b = char2b;
4807 s->hl = hl;
4808 s->row = row;
4809 s->area = area;
4810 s->first_glyph = row->glyphs[area] + start;
4811 s->height = row->height;
4812 s->y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
4813
4814 /* Display the internal border below the tool-bar window. */
4815 if (s->w == XWINDOW (s->f->tool_bar_window))
4816 s->y -= s->f->output_data.x->internal_border_width;
4817
4818 s->ybase = s->y + row->ascent;
4819 }
4820
4821
4822 /* Set background width of glyph string S. START is the index of the
4823 first glyph following S. LAST_X is the right-most x-position + 1
4824 in the drawing area. */
4825
4826 static INLINE void
4827 x_set_glyph_string_background_width (s, start, last_x)
4828 struct glyph_string *s;
4829 int start;
4830 int last_x;
4831 {
4832 /* If the face of this glyph string has to be drawn to the end of
4833 the drawing area, set S->extends_to_end_of_line_p. */
4834 struct face *default_face = FACE_FROM_ID (s->f, DEFAULT_FACE_ID);
4835
4836 if (start == s->row->used[s->area]
4837 && s->hl == DRAW_NORMAL_TEXT
4838 && s->area == TEXT_AREA
4839 && (s->row->fill_line_p
4840 || s->face->background != default_face->background
4841 || s->face->stipple != default_face->stipple))
4842 s->extends_to_end_of_line_p = 1;
4843
4844 /* If S extends its face to the end of the line, set its
4845 background_width to the distance to the right edge of the drawing
4846 area. */
4847 if (s->extends_to_end_of_line_p)
4848 s->background_width = last_x - s->x + 1;
4849 else
4850 s->background_width = s->width;
4851 }
4852
4853
4854 /* Add a glyph string for a stretch glyph to the list of strings
4855 between HEAD and TAIL. START is the index of the stretch glyph in
4856 row area AREA of glyph row ROW. END is the index of the last glyph
4857 in that glyph row area. X is the current output position assigned
4858 to the new glyph string constructed. HL overrides that face of the
4859 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4860 is the right-most x-position of the drawing area. */
4861
4862 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
4863 and below -- keep them on one line. */
4864 #define BUILD_STRETCH_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4865 do \
4866 { \
4867 s = (struct glyph_string *) alloca (sizeof *s); \
4868 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
4869 START = x_fill_stretch_glyph_string (s, ROW, AREA, START, END); \
4870 x_append_glyph_string (&HEAD, &TAIL, s); \
4871 s->x = (X); \
4872 } \
4873 while (0)
4874
4875
4876 /* Add a glyph string for an image glyph to the list of strings
4877 between HEAD and TAIL. START is the index of the image glyph in
4878 row area AREA of glyph row ROW. END is the index of the last glyph
4879 in that glyph row area. X is the current output position assigned
4880 to the new glyph string constructed. HL overrides that face of the
4881 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4882 is the right-most x-position of the drawing area. */
4883
4884 #define BUILD_IMAGE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4885 do \
4886 { \
4887 s = (struct glyph_string *) alloca (sizeof *s); \
4888 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
4889 x_fill_image_glyph_string (s); \
4890 x_append_glyph_string (&HEAD, &TAIL, s); \
4891 ++START; \
4892 s->x = (X); \
4893 } \
4894 while (0)
4895
4896
4897 /* Add a glyph string for a sequence of character glyphs to the list
4898 of strings between HEAD and TAIL. START is the index of the first
4899 glyph in row area AREA of glyph row ROW that is part of the new
4900 glyph string. END is the index of the last glyph in that glyph row
4901 area. X is the current output position assigned to the new glyph
4902 string constructed. HL overrides that face of the glyph; e.g. it
4903 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
4904 right-most x-position of the drawing area. */
4905
4906 #define BUILD_CHAR_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4907 do \
4908 { \
4909 int c, face_id; \
4910 XChar2b *char2b; \
4911 \
4912 c = (ROW)->glyphs[AREA][START].u.ch; \
4913 face_id = (ROW)->glyphs[AREA][START].face_id; \
4914 \
4915 s = (struct glyph_string *) alloca (sizeof *s); \
4916 char2b = (XChar2b *) alloca ((END - START) * sizeof *char2b); \
4917 x_init_glyph_string (s, char2b, W, ROW, AREA, START, HL); \
4918 x_append_glyph_string (&HEAD, &TAIL, s); \
4919 s->x = (X); \
4920 START = x_fill_glyph_string (s, face_id, START, END, \
4921 OVERLAPS_P); \
4922 } \
4923 while (0)
4924
4925
4926 /* Add a glyph string for a composite sequence to the list of strings
4927 between HEAD and TAIL. START is the index of the first glyph in
4928 row area AREA of glyph row ROW that is part of the new glyph
4929 string. END is the index of the last glyph in that glyph row area.
4930 X is the current output position assigned to the new glyph string
4931 constructed. HL overrides that face of the glyph; e.g. it is
4932 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
4933 x-position of the drawing area. */
4934
4935 #define BUILD_COMPOSITE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4936 do { \
4937 int cmp_id = (ROW)->glyphs[AREA][START].u.cmp_id; \
4938 int face_id = (ROW)->glyphs[AREA][START].face_id; \
4939 struct face *base_face = FACE_FROM_ID (XFRAME (w->frame), face_id); \
4940 struct composition *cmp = composition_table[cmp_id]; \
4941 int glyph_len = cmp->glyph_len; \
4942 XChar2b *char2b; \
4943 struct face **faces; \
4944 struct glyph_string *first_s = NULL; \
4945 int n; \
4946 \
4947 base_face = base_face->ascii_face; \
4948 char2b = (XChar2b *) alloca ((sizeof *char2b) * glyph_len); \
4949 faces = (struct face **) alloca ((sizeof *faces) * glyph_len); \
4950 /* At first, fill in `char2b' and `faces'. */ \
4951 for (n = 0; n < glyph_len; n++) \
4952 { \
4953 int c = COMPOSITION_GLYPH (cmp, n); \
4954 int this_face_id = FACE_FOR_CHAR (XFRAME (w->frame), base_face, c); \
4955 faces[n] = FACE_FROM_ID (XFRAME (w->frame), this_face_id); \
4956 x_get_char_face_and_encoding (XFRAME (w->frame), c, \
4957 this_face_id, char2b + n, 1); \
4958 } \
4959 \
4960 /* Make glyph_strings for each glyph sequence that is drawable by \
4961 the same face, and append them to HEAD/TAIL. */ \
4962 for (n = 0; n < cmp->glyph_len;) \
4963 { \
4964 s = (struct glyph_string *) alloca (sizeof *s); \
4965 x_init_glyph_string (s, char2b + n, W, ROW, AREA, START, HL); \
4966 x_append_glyph_string (&(HEAD), &(TAIL), s); \
4967 s->cmp = cmp; \
4968 s->gidx = n; \
4969 s->x = (X); \
4970 \
4971 if (n == 0) \
4972 first_s = s; \
4973 \
4974 n = x_fill_composite_glyph_string (s, faces, OVERLAPS_P); \
4975 } \
4976 \
4977 ++START; \
4978 s = first_s; \
4979 } while (0)
4980
4981
4982 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
4983 of AREA of glyph row ROW on window W between indices START and END.
4984 HL overrides the face for drawing glyph strings, e.g. it is
4985 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
4986 x-positions of the drawing area.
4987
4988 This is an ugly monster macro construct because we must use alloca
4989 to allocate glyph strings (because x_draw_glyphs can be called
4990 asynchronously). */
4991
4992 #define BUILD_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4993 do \
4994 { \
4995 HEAD = TAIL = NULL; \
4996 while (START < END) \
4997 { \
4998 struct glyph *first_glyph = (ROW)->glyphs[AREA] + START; \
4999 switch (first_glyph->type) \
5000 { \
5001 case CHAR_GLYPH: \
5002 BUILD_CHAR_GLYPH_STRINGS (W, ROW, AREA, START, END, HEAD, \
5003 TAIL, HL, X, LAST_X, \
5004 OVERLAPS_P); \
5005 break; \
5006 \
5007 case COMPOSITE_GLYPH: \
5008 BUILD_COMPOSITE_GLYPH_STRING (W, ROW, AREA, START, END, \
5009 HEAD, TAIL, HL, X, LAST_X,\
5010 OVERLAPS_P); \
5011 break; \
5012 \
5013 case STRETCH_GLYPH: \
5014 BUILD_STRETCH_GLYPH_STRING (W, ROW, AREA, START, END, \
5015 HEAD, TAIL, HL, X, LAST_X); \
5016 break; \
5017 \
5018 case IMAGE_GLYPH: \
5019 BUILD_IMAGE_GLYPH_STRING (W, ROW, AREA, START, END, HEAD, \
5020 TAIL, HL, X, LAST_X); \
5021 break; \
5022 \
5023 default: \
5024 abort (); \
5025 } \
5026 \
5027 x_set_glyph_string_background_width (s, START, LAST_X); \
5028 (X) += s->width; \
5029 } \
5030 } \
5031 while (0)
5032
5033
5034 /* Draw glyphs between START and END in AREA of ROW on window W,
5035 starting at x-position X. X is relative to AREA in W. HL is a
5036 face-override with the following meaning:
5037
5038 DRAW_NORMAL_TEXT draw normally
5039 DRAW_CURSOR draw in cursor face
5040 DRAW_MOUSE_FACE draw in mouse face.
5041 DRAW_INVERSE_VIDEO draw in mode line face
5042 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
5043 DRAW_IMAGE_RAISED draw an image with a raised relief around it
5044
5045 If REAL_START is non-null, return in *REAL_START the real starting
5046 position for display. This can be different from START in case
5047 overlapping glyphs must be displayed. If REAL_END is non-null,
5048 return in *REAL_END the real end position for display. This can be
5049 different from END in case overlapping glyphs must be displayed.
5050
5051 If OVERLAPS_P is non-zero, draw only the foreground of characters
5052 and clip to the physical height of ROW.
5053
5054 Value is the x-position reached, relative to AREA of W. */
5055
5056 static int
5057 x_draw_glyphs (w, x, row, area, start, end, hl, real_start, real_end,
5058 overlaps_p)
5059 struct window *w;
5060 int x;
5061 struct glyph_row *row;
5062 enum glyph_row_area area;
5063 int start, end;
5064 enum draw_glyphs_face hl;
5065 int *real_start, *real_end;
5066 int overlaps_p;
5067 {
5068 struct glyph_string *head, *tail;
5069 struct glyph_string *s;
5070 int last_x, area_width;
5071 int x_reached;
5072 int i, j;
5073
5074 /* Let's rather be paranoid than getting a SEGV. */
5075 end = min (end, row->used[area]);
5076 start = max (0, start);
5077 start = min (end, start);
5078 if (real_start)
5079 *real_start = start;
5080 if (real_end)
5081 *real_end = end;
5082
5083 /* Translate X to frame coordinates. Set last_x to the right
5084 end of the drawing area. */
5085 if (row->full_width_p)
5086 {
5087 /* X is relative to the left edge of W, without scroll bars
5088 or flag areas. */
5089 struct frame *f = XFRAME (w->frame);
5090 /* int width = FRAME_FLAGS_AREA_WIDTH (f); */
5091 int window_left_x = WINDOW_LEFT_MARGIN (w) * CANON_X_UNIT (f);
5092
5093 x += window_left_x;
5094 area_width = XFASTINT (w->width) * CANON_X_UNIT (f);
5095 last_x = window_left_x + area_width;
5096
5097 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
5098 {
5099 int width = FRAME_SCROLL_BAR_WIDTH (f) * CANON_X_UNIT (f);
5100 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
5101 last_x += width;
5102 else
5103 x -= width;
5104 }
5105
5106 x += FRAME_INTERNAL_BORDER_WIDTH (f);
5107 last_x += FRAME_INTERNAL_BORDER_WIDTH (f);
5108 }
5109 else
5110 {
5111 x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, area, x);
5112 area_width = window_box_width (w, area);
5113 last_x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, area, area_width);
5114 }
5115
5116 /* Build a doubly-linked list of glyph_string structures between
5117 head and tail from what we have to draw. Note that the macro
5118 BUILD_GLYPH_STRINGS will modify its start parameter. That's
5119 the reason we use a separate variable `i'. */
5120 i = start;
5121 BUILD_GLYPH_STRINGS (w, row, area, i, end, head, tail, hl, x, last_x,
5122 overlaps_p);
5123 if (tail)
5124 x_reached = tail->x + tail->background_width;
5125 else
5126 x_reached = x;
5127
5128 /* If there are any glyphs with lbearing < 0 or rbearing > width in
5129 the row, redraw some glyphs in front or following the glyph
5130 strings built above. */
5131 if (head && !overlaps_p && row->contains_overlapping_glyphs_p)
5132 {
5133 int dummy_x = 0;
5134 struct glyph_string *h, *t;
5135
5136 /* Compute overhangs for all glyph strings. */
5137 for (s = head; s; s = s->next)
5138 x_compute_glyph_string_overhangs (s);
5139
5140 /* Prepend glyph strings for glyphs in front of the first glyph
5141 string that are overwritten because of the first glyph
5142 string's left overhang. The background of all strings
5143 prepended must be drawn because the first glyph string
5144 draws over it. */
5145 i = x_left_overwritten (head);
5146 if (i >= 0)
5147 {
5148 j = i;
5149 BUILD_GLYPH_STRINGS (w, row, area, j, start, h, t,
5150 DRAW_NORMAL_TEXT, dummy_x, last_x,
5151 overlaps_p);
5152 start = i;
5153 if (real_start)
5154 *real_start = start;
5155 x_compute_overhangs_and_x (t, head->x, 1);
5156 x_prepend_glyph_string_lists (&head, &tail, h, t);
5157 }
5158
5159 /* Prepend glyph strings for glyphs in front of the first glyph
5160 string that overwrite that glyph string because of their
5161 right overhang. For these strings, only the foreground must
5162 be drawn, because it draws over the glyph string at `head'.
5163 The background must not be drawn because this would overwrite
5164 right overhangs of preceding glyphs for which no glyph
5165 strings exist. */
5166 i = x_left_overwriting (head);
5167 if (i >= 0)
5168 {
5169 BUILD_GLYPH_STRINGS (w, row, area, i, start, h, t,
5170 DRAW_NORMAL_TEXT, dummy_x, last_x,
5171 overlaps_p);
5172 for (s = h; s; s = s->next)
5173 s->background_filled_p = 1;
5174 if (real_start)
5175 *real_start = i;
5176 x_compute_overhangs_and_x (t, head->x, 1);
5177 x_prepend_glyph_string_lists (&head, &tail, h, t);
5178 }
5179
5180 /* Append glyphs strings for glyphs following the last glyph
5181 string tail that are overwritten by tail. The background of
5182 these strings has to be drawn because tail's foreground draws
5183 over it. */
5184 i = x_right_overwritten (tail);
5185 if (i >= 0)
5186 {
5187 BUILD_GLYPH_STRINGS (w, row, area, end, i, h, t,
5188 DRAW_NORMAL_TEXT, x, last_x,
5189 overlaps_p);
5190 x_compute_overhangs_and_x (h, tail->x + tail->width, 0);
5191 x_append_glyph_string_lists (&head, &tail, h, t);
5192 if (real_end)
5193 *real_end = i;
5194 }
5195
5196 /* Append glyph strings for glyphs following the last glyph
5197 string tail that overwrite tail. The foreground of such
5198 glyphs has to be drawn because it writes into the background
5199 of tail. The background must not be drawn because it could
5200 paint over the foreground of following glyphs. */
5201 i = x_right_overwriting (tail);
5202 if (i >= 0)
5203 {
5204 BUILD_GLYPH_STRINGS (w, row, area, end, i, h, t,
5205 DRAW_NORMAL_TEXT, x, last_x,
5206 overlaps_p);
5207 for (s = h; s; s = s->next)
5208 s->background_filled_p = 1;
5209 x_compute_overhangs_and_x (h, tail->x + tail->width, 0);
5210 x_append_glyph_string_lists (&head, &tail, h, t);
5211 if (real_end)
5212 *real_end = i;
5213 }
5214 }
5215
5216 /* Draw all strings. */
5217 for (s = head; s; s = s->next)
5218 x_draw_glyph_string (s);
5219
5220 /* Value is the x-position up to which drawn, relative to AREA of W.
5221 This doesn't include parts drawn because of overhangs. */
5222 x_reached = FRAME_TO_WINDOW_PIXEL_X (w, x_reached);
5223 if (!row->full_width_p)
5224 {
5225 if (area > LEFT_MARGIN_AREA)
5226 x_reached -= window_box_width (w, LEFT_MARGIN_AREA);
5227 if (area > TEXT_AREA)
5228 x_reached -= window_box_width (w, TEXT_AREA);
5229 }
5230
5231 return x_reached;
5232 }
5233
5234
5235 /* Fix the display of area AREA of overlapping row ROW in window W. */
5236
5237 static void
5238 x_fix_overlapping_area (w, row, area)
5239 struct window *w;
5240 struct glyph_row *row;
5241 enum glyph_row_area area;
5242 {
5243 int i, x;
5244
5245 BLOCK_INPUT;
5246
5247 if (area == LEFT_MARGIN_AREA)
5248 x = 0;
5249 else if (area == TEXT_AREA)
5250 x = row->x + window_box_width (w, LEFT_MARGIN_AREA);
5251 else
5252 x = (window_box_width (w, LEFT_MARGIN_AREA)
5253 + window_box_width (w, TEXT_AREA));
5254
5255 for (i = 0; i < row->used[area];)
5256 {
5257 if (row->glyphs[area][i].overlaps_vertically_p)
5258 {
5259 int start = i, start_x = x;
5260
5261 do
5262 {
5263 x += row->glyphs[area][i].pixel_width;
5264 ++i;
5265 }
5266 while (i < row->used[area]
5267 && row->glyphs[area][i].overlaps_vertically_p);
5268
5269 x_draw_glyphs (w, start_x, row, area, start, i,
5270 (row->inverse_p
5271 ? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT),
5272 NULL, NULL, 1);
5273 }
5274 else
5275 {
5276 x += row->glyphs[area][i].pixel_width;
5277 ++i;
5278 }
5279 }
5280
5281 UNBLOCK_INPUT;
5282 }
5283
5284
5285 /* Output LEN glyphs starting at START at the nominal cursor position.
5286 Advance the nominal cursor over the text. The global variable
5287 updated_window contains the window being updated, updated_row is
5288 the glyph row being updated, and updated_area is the area of that
5289 row being updated. */
5290
5291 static void
5292 x_write_glyphs (start, len)
5293 struct glyph *start;
5294 int len;
5295 {
5296 int x, hpos, real_start, real_end;
5297
5298 xassert (updated_window && updated_row);
5299 BLOCK_INPUT;
5300
5301 /* Write glyphs. */
5302
5303 hpos = start - updated_row->glyphs[updated_area];
5304 x = x_draw_glyphs (updated_window, output_cursor.x,
5305 updated_row, updated_area,
5306 hpos, hpos + len,
5307 (updated_row->inverse_p
5308 ? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT),
5309 &real_start, &real_end, 0);
5310
5311 /* If we drew over the cursor, note that it is not visible any more. */
5312 note_overwritten_text_cursor (updated_window, real_start,
5313 real_end - real_start);
5314
5315 UNBLOCK_INPUT;
5316
5317 /* Advance the output cursor. */
5318 output_cursor.hpos += len;
5319 output_cursor.x = x;
5320 }
5321
5322
5323 /* Insert LEN glyphs from START at the nominal cursor position. */
5324
5325 static void
5326 x_insert_glyphs (start, len)
5327 struct glyph *start;
5328 register int len;
5329 {
5330 struct frame *f;
5331 struct window *w;
5332 int line_height, shift_by_width, shifted_region_width;
5333 struct glyph_row *row;
5334 struct glyph *glyph;
5335 int frame_x, frame_y, hpos, real_start, real_end;
5336
5337 xassert (updated_window && updated_row);
5338 BLOCK_INPUT;
5339 w = updated_window;
5340 f = XFRAME (WINDOW_FRAME (w));
5341
5342 /* Get the height of the line we are in. */
5343 row = updated_row;
5344 line_height = row->height;
5345
5346 /* Get the width of the glyphs to insert. */
5347 shift_by_width = 0;
5348 for (glyph = start; glyph < start + len; ++glyph)
5349 shift_by_width += glyph->pixel_width;
5350
5351 /* Get the width of the region to shift right. */
5352 shifted_region_width = (window_box_width (w, updated_area)
5353 - output_cursor.x
5354 - shift_by_width);
5355
5356 /* Shift right. */
5357 frame_x = window_box_left (w, updated_area) + output_cursor.x;
5358 frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, output_cursor.y);
5359 XCopyArea (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), FRAME_X_WINDOW (f),
5360 f->output_data.x->normal_gc,
5361 frame_x, frame_y,
5362 shifted_region_width, line_height,
5363 frame_x + shift_by_width, frame_y);
5364
5365 /* Write the glyphs. */
5366 hpos = start - row->glyphs[updated_area];
5367 x_draw_glyphs (w, output_cursor.x, row, updated_area, hpos, hpos + len,
5368 DRAW_NORMAL_TEXT, &real_start, &real_end, 0);
5369 note_overwritten_text_cursor (w, real_start, real_end - real_start);
5370
5371 /* Advance the output cursor. */
5372 output_cursor.hpos += len;
5373 output_cursor.x += shift_by_width;
5374 UNBLOCK_INPUT;
5375 }
5376
5377
5378 /* Delete N glyphs at the nominal cursor position. Not implemented
5379 for X frames. */
5380
5381 static void
5382 x_delete_glyphs (n)
5383 register int n;
5384 {
5385 abort ();
5386 }
5387
5388
5389 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
5390 If they are <= 0, this is probably an error. */
5391
5392 void
5393 x_clear_area (dpy, window, x, y, width, height, exposures)
5394 Display *dpy;
5395 Window window;
5396 int x, y;
5397 int width, height;
5398 int exposures;
5399 {
5400 xassert (width > 0 && height > 0);
5401 XClearArea (dpy, window, x, y, width, height, exposures);
5402 }
5403
5404
5405 /* Erase the current text line from the nominal cursor position
5406 (inclusive) to pixel column TO_X (exclusive). The idea is that
5407 everything from TO_X onward is already erased.
5408
5409 TO_X is a pixel position relative to updated_area of
5410 updated_window. TO_X == -1 means clear to the end of this area. */
5411
5412 static void
5413 x_clear_end_of_line (to_x)
5414 int to_x;
5415 {
5416 struct frame *f;
5417 struct window *w = updated_window;
5418 int max_x, min_y, max_y;
5419 int from_x, from_y, to_y;
5420
5421 xassert (updated_window && updated_row);
5422 f = XFRAME (w->frame);
5423
5424 if (updated_row->full_width_p)
5425 {
5426 max_x = XFASTINT (w->width) * CANON_X_UNIT (f);
5427 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f)
5428 && !w->pseudo_window_p)
5429 max_x += FRAME_SCROLL_BAR_WIDTH (f) * CANON_X_UNIT (f);
5430 }
5431 else
5432 max_x = window_box_width (w, updated_area);
5433 max_y = window_text_bottom_y (w);
5434
5435 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
5436 of window. For TO_X > 0, truncate to end of drawing area. */
5437 if (to_x == 0)
5438 return;
5439 else if (to_x < 0)
5440 to_x = max_x;
5441 else
5442 to_x = min (to_x, max_x);
5443
5444 to_y = min (max_y, output_cursor.y + updated_row->height);
5445
5446 /* Notice if the cursor will be cleared by this operation. */
5447 if (!updated_row->full_width_p)
5448 note_overwritten_text_cursor (w, output_cursor.hpos, -1);
5449
5450 from_x = output_cursor.x;
5451
5452 /* Translate to frame coordinates. */
5453 if (updated_row->full_width_p)
5454 {
5455 from_x = WINDOW_TO_FRAME_PIXEL_X (w, from_x);
5456 to_x = WINDOW_TO_FRAME_PIXEL_X (w, to_x);
5457 }
5458 else
5459 {
5460 from_x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, updated_area, from_x);
5461 to_x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, updated_area, to_x);
5462 }
5463
5464 min_y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
5465 from_y = WINDOW_TO_FRAME_PIXEL_Y (w, max (min_y, output_cursor.y));
5466 to_y = WINDOW_TO_FRAME_PIXEL_Y (w, to_y);
5467
5468 /* Prevent inadvertently clearing to end of the X window. */
5469 if (to_x > from_x && to_y > from_y)
5470 {
5471 BLOCK_INPUT;
5472 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
5473 from_x, from_y, to_x - from_x, to_y - from_y,
5474 False);
5475 UNBLOCK_INPUT;
5476 }
5477 }
5478
5479
5480 /* Clear entire frame. If updating_frame is non-null, clear that
5481 frame. Otherwise clear the selected frame. */
5482
5483 static void
5484 x_clear_frame ()
5485 {
5486 struct frame *f;
5487
5488 if (updating_frame)
5489 f = updating_frame;
5490 else
5491 f = SELECTED_FRAME ();
5492
5493 /* Clearing the frame will erase any cursor, so mark them all as no
5494 longer visible. */
5495 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
5496 output_cursor.hpos = output_cursor.vpos = 0;
5497 output_cursor.x = -1;
5498
5499 /* We don't set the output cursor here because there will always
5500 follow an explicit cursor_to. */
5501 BLOCK_INPUT;
5502 XClearWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
5503
5504 /* We have to clear the scroll bars, too. If we have changed
5505 colors or something like that, then they should be notified. */
5506 x_scroll_bar_clear (f);
5507
5508 XFlush (FRAME_X_DISPLAY (f));
5509 UNBLOCK_INPUT;
5510 }
5511
5512
5513 \f
5514 /* Invert the middle quarter of the frame for .15 sec. */
5515
5516 /* We use the select system call to do the waiting, so we have to make
5517 sure it's available. If it isn't, we just won't do visual bells. */
5518
5519 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
5520
5521
5522 /* Subtract the `struct timeval' values X and Y, storing the result in
5523 *RESULT. Return 1 if the difference is negative, otherwise 0. */
5524
5525 static int
5526 timeval_subtract (result, x, y)
5527 struct timeval *result, x, y;
5528 {
5529 /* Perform the carry for the later subtraction by updating y. This
5530 is safer because on some systems the tv_sec member is unsigned. */
5531 if (x.tv_usec < y.tv_usec)
5532 {
5533 int nsec = (y.tv_usec - x.tv_usec) / 1000000 + 1;
5534 y.tv_usec -= 1000000 * nsec;
5535 y.tv_sec += nsec;
5536 }
5537
5538 if (x.tv_usec - y.tv_usec > 1000000)
5539 {
5540 int nsec = (y.tv_usec - x.tv_usec) / 1000000;
5541 y.tv_usec += 1000000 * nsec;
5542 y.tv_sec -= nsec;
5543 }
5544
5545 /* Compute the time remaining to wait. tv_usec is certainly
5546 positive. */
5547 result->tv_sec = x.tv_sec - y.tv_sec;
5548 result->tv_usec = x.tv_usec - y.tv_usec;
5549
5550 /* Return indication of whether the result should be considered
5551 negative. */
5552 return x.tv_sec < y.tv_sec;
5553 }
5554
5555 void
5556 XTflash (f)
5557 struct frame *f;
5558 {
5559 BLOCK_INPUT;
5560
5561 {
5562 GC gc;
5563
5564 /* Create a GC that will use the GXxor function to flip foreground
5565 pixels into background pixels. */
5566 {
5567 XGCValues values;
5568
5569 values.function = GXxor;
5570 values.foreground = (f->output_data.x->foreground_pixel
5571 ^ f->output_data.x->background_pixel);
5572
5573 gc = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
5574 GCFunction | GCForeground, &values);
5575 }
5576
5577 {
5578 /* Get the height not including a menu bar widget. */
5579 int height = CHAR_TO_PIXEL_HEIGHT (f, FRAME_HEIGHT (f));
5580 /* Height of each line to flash. */
5581 int flash_height = FRAME_LINE_HEIGHT (f);
5582 /* These will be the left and right margins of the rectangles. */
5583 int flash_left = FRAME_INTERNAL_BORDER_WIDTH (f);
5584 int flash_right = PIXEL_WIDTH (f) - FRAME_INTERNAL_BORDER_WIDTH (f);
5585
5586 int width;
5587
5588 /* Don't flash the area between a scroll bar and the frame
5589 edge it is next to. */
5590 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f))
5591 {
5592 case vertical_scroll_bar_left:
5593 flash_left += VERTICAL_SCROLL_BAR_WIDTH_TRIM;
5594 break;
5595
5596 case vertical_scroll_bar_right:
5597 flash_right -= VERTICAL_SCROLL_BAR_WIDTH_TRIM;
5598 break;
5599
5600 default:
5601 break;
5602 }
5603
5604 width = flash_right - flash_left;
5605
5606 /* If window is tall, flash top and bottom line. */
5607 if (height > 3 * FRAME_LINE_HEIGHT (f))
5608 {
5609 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
5610 flash_left,
5611 (FRAME_INTERNAL_BORDER_WIDTH (f)
5612 + FRAME_TOOL_BAR_LINES (f) * CANON_Y_UNIT (f)),
5613 width, flash_height);
5614 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
5615 flash_left,
5616 (height - flash_height
5617 - FRAME_INTERNAL_BORDER_WIDTH (f)),
5618 width, flash_height);
5619 }
5620 else
5621 /* If it is short, flash it all. */
5622 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
5623 flash_left, FRAME_INTERNAL_BORDER_WIDTH (f),
5624 width, height - 2 * FRAME_INTERNAL_BORDER_WIDTH (f));
5625
5626 x_flush (f);
5627
5628 {
5629 struct timeval wakeup;
5630
5631 EMACS_GET_TIME (wakeup);
5632
5633 /* Compute time to wait until, propagating carry from usecs. */
5634 wakeup.tv_usec += 150000;
5635 wakeup.tv_sec += (wakeup.tv_usec / 1000000);
5636 wakeup.tv_usec %= 1000000;
5637
5638 /* Keep waiting until past the time wakeup or any input gets
5639 available. */
5640 while (! detect_input_pending ())
5641 {
5642 struct timeval current;
5643 struct timeval timeout;
5644
5645 EMACS_GET_TIME (current);
5646
5647 /* Break if result would be negative. */
5648 if (timeval_subtract (&current, wakeup, current))
5649 break;
5650
5651 /* How long `select' should wait. */
5652 timeout.tv_sec = 0;
5653 timeout.tv_usec = 10000;
5654
5655 /* Try to wait that long--but we might wake up sooner. */
5656 select (0, NULL, NULL, NULL, &timeout);
5657 }
5658 }
5659
5660 /* If window is tall, flash top and bottom line. */
5661 if (height > 3 * FRAME_LINE_HEIGHT (f))
5662 {
5663 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
5664 flash_left,
5665 (FRAME_INTERNAL_BORDER_WIDTH (f)
5666 + FRAME_TOOL_BAR_LINES (f) * CANON_Y_UNIT (f)),
5667 width, flash_height);
5668 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
5669 flash_left,
5670 (height - flash_height
5671 - FRAME_INTERNAL_BORDER_WIDTH (f)),
5672 width, flash_height);
5673 }
5674 else
5675 /* If it is short, flash it all. */
5676 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
5677 flash_left, FRAME_INTERNAL_BORDER_WIDTH (f),
5678 width, height - 2 * FRAME_INTERNAL_BORDER_WIDTH (f));
5679
5680 XFreeGC (FRAME_X_DISPLAY (f), gc);
5681 x_flush (f);
5682 }
5683 }
5684
5685 UNBLOCK_INPUT;
5686 }
5687
5688 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
5689
5690
5691 /* Make audible bell. */
5692
5693 void
5694 XTring_bell ()
5695 {
5696 struct frame *f = SELECTED_FRAME ();
5697
5698 if (FRAME_X_DISPLAY (f))
5699 {
5700 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
5701 if (visible_bell)
5702 XTflash (f);
5703 else
5704 #endif
5705 {
5706 BLOCK_INPUT;
5707 XBell (FRAME_X_DISPLAY (f), 0);
5708 XFlush (FRAME_X_DISPLAY (f));
5709 UNBLOCK_INPUT;
5710 }
5711 }
5712 }
5713
5714 \f
5715 /* Specify how many text lines, from the top of the window,
5716 should be affected by insert-lines and delete-lines operations.
5717 This, and those operations, are used only within an update
5718 that is bounded by calls to x_update_begin and x_update_end. */
5719
5720 static void
5721 XTset_terminal_window (n)
5722 register int n;
5723 {
5724 /* This function intentionally left blank. */
5725 }
5726
5727
5728 \f
5729 /***********************************************************************
5730 Line Dance
5731 ***********************************************************************/
5732
5733 /* Perform an insert-lines or delete-lines operation, inserting N
5734 lines or deleting -N lines at vertical position VPOS. */
5735
5736 static void
5737 x_ins_del_lines (vpos, n)
5738 int vpos, n;
5739 {
5740 abort ();
5741 }
5742
5743
5744 /* Scroll part of the display as described by RUN. */
5745
5746 static void
5747 x_scroll_run (w, run)
5748 struct window *w;
5749 struct run *run;
5750 {
5751 struct frame *f = XFRAME (w->frame);
5752 int x, y, width, height, from_y, to_y, bottom_y;
5753
5754 /* Get frame-relative bounding box of the text display area of W,
5755 without mode lines. Include in this box the flags areas to the
5756 left and right of W. */
5757 window_box (w, -1, &x, &y, &width, &height);
5758 width += FRAME_X_FLAGS_AREA_WIDTH (f);
5759 x -= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f);
5760
5761 from_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->current_y);
5762 to_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->desired_y);
5763 bottom_y = y + height;
5764
5765 if (to_y < from_y)
5766 {
5767 /* Scrolling up. Make sure we don't copy part of the mode
5768 line at the bottom. */
5769 if (from_y + run->height > bottom_y)
5770 height = bottom_y - from_y;
5771 else
5772 height = run->height;
5773 }
5774 else
5775 {
5776 /* Scolling down. Make sure we don't copy over the mode line.
5777 at the bottom. */
5778 if (to_y + run->height > bottom_y)
5779 height = bottom_y - to_y;
5780 else
5781 height = run->height;
5782 }
5783
5784 BLOCK_INPUT;
5785
5786 /* Cursor off. Will be switched on again in x_update_window_end. */
5787 updated_window = w;
5788 x_clear_cursor (w);
5789
5790 XCopyArea (FRAME_X_DISPLAY (f),
5791 FRAME_X_WINDOW (f), FRAME_X_WINDOW (f),
5792 f->output_data.x->normal_gc,
5793 x, from_y,
5794 width, height,
5795 x, to_y);
5796
5797 UNBLOCK_INPUT;
5798 }
5799
5800
5801 \f
5802 /***********************************************************************
5803 Exposure Events
5804 ***********************************************************************/
5805
5806 /* Redisplay an exposed area of frame F. X and Y are the upper-left
5807 corner of the exposed rectangle. W and H are width and height of
5808 the exposed area. All are pixel values. W or H zero means redraw
5809 the entire frame. */
5810
5811 static void
5812 expose_frame (f, x, y, w, h)
5813 struct frame *f;
5814 int x, y, w, h;
5815 {
5816 XRectangle r;
5817
5818 TRACE ((stderr, "expose_frame "));
5819
5820 /* No need to redraw if frame will be redrawn soon. */
5821 if (FRAME_GARBAGED_P (f))
5822 {
5823 TRACE ((stderr, " garbaged\n"));
5824 return;
5825 }
5826
5827 /* If basic faces haven't been realized yet, there is no point in
5828 trying to redraw anything. This can happen when we get an expose
5829 event while Emacs is starting, e.g. by moving another window. */
5830 if (FRAME_FACE_CACHE (f) == NULL
5831 || FRAME_FACE_CACHE (f)->used < BASIC_FACE_ID_SENTINEL)
5832 {
5833 TRACE ((stderr, " no faces\n"));
5834 return;
5835 }
5836
5837 if (w == 0 || h == 0)
5838 {
5839 r.x = r.y = 0;
5840 r.width = CANON_X_UNIT (f) * f->width;
5841 r.height = CANON_Y_UNIT (f) * f->height;
5842 }
5843 else
5844 {
5845 r.x = x;
5846 r.y = y;
5847 r.width = w;
5848 r.height = h;
5849 }
5850
5851 TRACE ((stderr, "(%d, %d, %d, %d)\n", r.x, r.y, r.width, r.height));
5852 expose_window_tree (XWINDOW (f->root_window), &r);
5853
5854 if (WINDOWP (f->tool_bar_window))
5855 expose_window (XWINDOW (f->tool_bar_window), &r);
5856
5857 #ifndef USE_X_TOOLKIT
5858 if (WINDOWP (f->menu_bar_window))
5859 expose_window (XWINDOW (f->menu_bar_window), &r);
5860 #endif /* not USE_X_TOOLKIT */
5861 }
5862
5863
5864 /* Redraw (parts) of all windows in the window tree rooted at W that
5865 intersect R. R contains frame pixel coordinates. */
5866
5867 static void
5868 expose_window_tree (w, r)
5869 struct window *w;
5870 XRectangle *r;
5871 {
5872 while (w)
5873 {
5874 if (!NILP (w->hchild))
5875 expose_window_tree (XWINDOW (w->hchild), r);
5876 else if (!NILP (w->vchild))
5877 expose_window_tree (XWINDOW (w->vchild), r);
5878 else if (expose_window (w, r) == 0)
5879 break;
5880 w = NILP (w->next) ? NULL : XWINDOW (w->next);
5881 }
5882 }
5883
5884
5885 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
5886 which intersects rectangle R. R is in window-relative coordinates. */
5887
5888 static void
5889 expose_area (w, row, r, area)
5890 struct window *w;
5891 struct glyph_row *row;
5892 XRectangle *r;
5893 enum glyph_row_area area;
5894 {
5895 struct glyph *first = row->glyphs[area];
5896 struct glyph *end = row->glyphs[area] + row->used[area];
5897 struct glyph *last;
5898 int first_x, start_x, x;
5899
5900 if (area == TEXT_AREA && row->fill_line_p)
5901 /* If row extends face to end of line write the whole line. */
5902 x_draw_glyphs (w, 0, row, area,
5903 0, row->used[area],
5904 row->inverse_p ? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT,
5905 NULL, NULL, 0);
5906 else
5907 {
5908 /* Set START_X to the window-relative start position for drawing glyphs of
5909 AREA. The first glyph of the text area can be partially visible.
5910 The first glyphs of other areas cannot. */
5911 if (area == LEFT_MARGIN_AREA)
5912 start_x = 0;
5913 else if (area == TEXT_AREA)
5914 start_x = row->x + window_box_width (w, LEFT_MARGIN_AREA);
5915 else
5916 start_x = (window_box_width (w, LEFT_MARGIN_AREA)
5917 + window_box_width (w, TEXT_AREA));
5918 x = start_x;
5919
5920 /* Find the first glyph that must be redrawn. */
5921 while (first < end
5922 && x + first->pixel_width < r->x)
5923 {
5924 x += first->pixel_width;
5925 ++first;
5926 }
5927
5928 /* Find the last one. */
5929 last = first;
5930 first_x = x;
5931 while (last < end
5932 && x < r->x + r->width)
5933 {
5934 x += last->pixel_width;
5935 ++last;
5936 }
5937
5938 /* Repaint. */
5939 if (last > first)
5940 x_draw_glyphs (w, first_x - start_x, row, area,
5941 first - row->glyphs[area],
5942 last - row->glyphs[area],
5943 row->inverse_p ? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT,
5944 NULL, NULL, 0);
5945 }
5946 }
5947
5948
5949 /* Redraw the parts of the glyph row ROW on window W intersecting
5950 rectangle R. R is in window-relative coordinates. */
5951
5952 static void
5953 expose_line (w, row, r)
5954 struct window *w;
5955 struct glyph_row *row;
5956 XRectangle *r;
5957 {
5958 xassert (row->enabled_p);
5959
5960 if (row->mode_line_p || w->pseudo_window_p)
5961 x_draw_glyphs (w, 0, row, TEXT_AREA, 0, row->used[TEXT_AREA],
5962 row->inverse_p ? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT,
5963 NULL, NULL, 0);
5964 else
5965 {
5966 if (row->used[LEFT_MARGIN_AREA])
5967 expose_area (w, row, r, LEFT_MARGIN_AREA);
5968 if (row->used[TEXT_AREA])
5969 expose_area (w, row, r, TEXT_AREA);
5970 if (row->used[RIGHT_MARGIN_AREA])
5971 expose_area (w, row, r, RIGHT_MARGIN_AREA);
5972 x_draw_row_bitmaps (w, row);
5973 }
5974 }
5975
5976
5977 /* Return non-zero if W's cursor intersects rectangle R. */
5978
5979 static int
5980 x_phys_cursor_in_rect_p (w, r)
5981 struct window *w;
5982 XRectangle *r;
5983 {
5984 XRectangle cr, result;
5985 struct glyph *cursor_glyph;
5986
5987 cursor_glyph = get_phys_cursor_glyph (w);
5988 if (cursor_glyph)
5989 {
5990 cr.x = w->phys_cursor.x;
5991 cr.y = w->phys_cursor.y;
5992 cr.width = cursor_glyph->pixel_width;
5993 cr.height = w->phys_cursor_height;
5994 return x_intersect_rectangles (&cr, r, &result);
5995 }
5996 else
5997 return 0;
5998 }
5999
6000
6001 /* Redraw the part of window W intersection rectangle FR. Pixel
6002 coordinates in FR are frame-relative. Call this function with
6003 input blocked. */
6004
6005 static int
6006 expose_window (w, fr)
6007 struct window *w;
6008 XRectangle *fr;
6009 {
6010 struct frame *f = XFRAME (w->frame);
6011 XRectangle wr, r;
6012
6013 /* If window is not yet fully initialized, do nothing. This can
6014 happen when toolkit scroll bars are used and a window is split.
6015 Reconfiguring the scroll bar will generate an expose for a newly
6016 created window. */
6017 if (w->current_matrix == NULL)
6018 return 1;
6019
6020 /* When we're currently updating the window, display and current
6021 matrix usually don't agree. Arrange for a thorough display
6022 later. */
6023 if (w == updated_window)
6024 {
6025 SET_FRAME_GARBAGED (f);
6026 return 0;
6027 }
6028
6029 /* Frame-relative pixel rectangle of W. */
6030 wr.x = XFASTINT (w->left) * CANON_X_UNIT (f);
6031 wr.y = XFASTINT (w->top) * CANON_Y_UNIT (f);
6032 wr.width = XFASTINT (w->width) * CANON_X_UNIT (f);
6033 wr.height = XFASTINT (w->height) * CANON_Y_UNIT (f);
6034
6035 if (x_intersect_rectangles (fr, &wr, &r))
6036 {
6037 int yb = window_text_bottom_y (w);
6038 struct glyph_row *row;
6039 int cursor_cleared_p;
6040
6041 TRACE ((stderr, "expose_window (%d, %d, %d, %d)\n",
6042 r.x, r.y, r.width, r.height));
6043
6044 /* Convert to window coordinates. */
6045 r.x = FRAME_TO_WINDOW_PIXEL_X (w, r.x);
6046 r.y = FRAME_TO_WINDOW_PIXEL_Y (w, r.y);
6047
6048 /* Turn off the cursor. */
6049 if (!w->pseudo_window_p
6050 && x_phys_cursor_in_rect_p (w, &r))
6051 {
6052 x_clear_cursor (w);
6053 cursor_cleared_p = 1;
6054 }
6055 else
6056 cursor_cleared_p = 0;
6057
6058 /* Find the first row intersecting the rectangle R. */
6059 for (row = w->current_matrix->rows;
6060 row->enabled_p;
6061 ++row)
6062 {
6063 int y0 = row->y;
6064 int y1 = MATRIX_ROW_BOTTOM_Y (row);
6065
6066 if ((y0 >= r.y && y0 < r.y + r.height)
6067 || (y1 > r.y && y1 < r.y + r.height)
6068 || (r.y >= y0 && r.y < y1)
6069 || (r.y + r.height > y0 && r.y + r.height < y1))
6070 expose_line (w, row, &r);
6071
6072 if (y1 >= yb)
6073 break;
6074 }
6075
6076 /* Display the mode line if there is one. */
6077 if (WINDOW_WANTS_MODELINE_P (w)
6078 && (row = MATRIX_MODE_LINE_ROW (w->current_matrix),
6079 row->enabled_p)
6080 && row->y < r.y + r.height)
6081 expose_line (w, row, &r);
6082
6083 if (!w->pseudo_window_p)
6084 {
6085 /* Draw border between windows. */
6086 x_draw_vertical_border (w);
6087
6088 /* Turn the cursor on again. */
6089 if (cursor_cleared_p)
6090 x_update_window_cursor (w, 1);
6091 }
6092 }
6093
6094 return 1;
6095 }
6096
6097
6098 /* Determine the intersection of two rectangles R1 and R2. Return
6099 the intersection in *RESULT. Value is non-zero if RESULT is not
6100 empty. */
6101
6102 static int
6103 x_intersect_rectangles (r1, r2, result)
6104 XRectangle *r1, *r2, *result;
6105 {
6106 XRectangle *left, *right;
6107 XRectangle *upper, *lower;
6108 int intersection_p = 0;
6109
6110 /* Rearrange so that R1 is the left-most rectangle. */
6111 if (r1->x < r2->x)
6112 left = r1, right = r2;
6113 else
6114 left = r2, right = r1;
6115
6116 /* X0 of the intersection is right.x0, if this is inside R1,
6117 otherwise there is no intersection. */
6118 if (right->x <= left->x + left->width)
6119 {
6120 result->x = right->x;
6121
6122 /* The right end of the intersection is the minimum of the
6123 the right ends of left and right. */
6124 result->width = (min (left->x + left->width, right->x + right->width)
6125 - result->x);
6126
6127 /* Same game for Y. */
6128 if (r1->y < r2->y)
6129 upper = r1, lower = r2;
6130 else
6131 upper = r2, lower = r1;
6132
6133 /* The upper end of the intersection is lower.y0, if this is inside
6134 of upper. Otherwise, there is no intersection. */
6135 if (lower->y <= upper->y + upper->height)
6136 {
6137 result->y = lower->y;
6138
6139 /* The lower end of the intersection is the minimum of the lower
6140 ends of upper and lower. */
6141 result->height = (min (lower->y + lower->height,
6142 upper->y + upper->height)
6143 - result->y);
6144 intersection_p = 1;
6145 }
6146 }
6147
6148 return intersection_p;
6149 }
6150
6151
6152
6153
6154 \f
6155 static void
6156 frame_highlight (f)
6157 struct frame *f;
6158 {
6159 /* We used to only do this if Vx_no_window_manager was non-nil, but
6160 the ICCCM (section 4.1.6) says that the window's border pixmap
6161 and border pixel are window attributes which are "private to the
6162 client", so we can always change it to whatever we want. */
6163 BLOCK_INPUT;
6164 XSetWindowBorder (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
6165 f->output_data.x->border_pixel);
6166 UNBLOCK_INPUT;
6167 x_update_cursor (f, 1);
6168 }
6169
6170 static void
6171 frame_unhighlight (f)
6172 struct frame *f;
6173 {
6174 /* We used to only do this if Vx_no_window_manager was non-nil, but
6175 the ICCCM (section 4.1.6) says that the window's border pixmap
6176 and border pixel are window attributes which are "private to the
6177 client", so we can always change it to whatever we want. */
6178 BLOCK_INPUT;
6179 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
6180 f->output_data.x->border_tile);
6181 UNBLOCK_INPUT;
6182 x_update_cursor (f, 1);
6183 }
6184
6185 /* The focus has changed. Update the frames as necessary to reflect
6186 the new situation. Note that we can't change the selected frame
6187 here, because the Lisp code we are interrupting might become confused.
6188 Each event gets marked with the frame in which it occurred, so the
6189 Lisp code can tell when the switch took place by examining the events. */
6190
6191 static void
6192 x_new_focus_frame (dpyinfo, frame)
6193 struct x_display_info *dpyinfo;
6194 struct frame *frame;
6195 {
6196 struct frame *old_focus = dpyinfo->x_focus_frame;
6197
6198 if (frame != dpyinfo->x_focus_frame)
6199 {
6200 /* Set this before calling other routines, so that they see
6201 the correct value of x_focus_frame. */
6202 dpyinfo->x_focus_frame = frame;
6203
6204 if (old_focus && old_focus->auto_lower)
6205 x_lower_frame (old_focus);
6206
6207 #if 0
6208 selected_frame = frame;
6209 XSETFRAME (XWINDOW (selected_frame->selected_window)->frame,
6210 selected_frame);
6211 Fselect_window (selected_frame->selected_window);
6212 choose_minibuf_frame ();
6213 #endif /* ! 0 */
6214
6215 if (dpyinfo->x_focus_frame && dpyinfo->x_focus_frame->auto_raise)
6216 pending_autoraise_frame = dpyinfo->x_focus_frame;
6217 else
6218 pending_autoraise_frame = 0;
6219 }
6220
6221 x_frame_rehighlight (dpyinfo);
6222 }
6223
6224 /* Handle an event saying the mouse has moved out of an Emacs frame. */
6225
6226 void
6227 x_mouse_leave (dpyinfo)
6228 struct x_display_info *dpyinfo;
6229 {
6230 x_new_focus_frame (dpyinfo, dpyinfo->x_focus_event_frame);
6231 }
6232
6233 /* The focus has changed, or we have redirected a frame's focus to
6234 another frame (this happens when a frame uses a surrogate
6235 mini-buffer frame). Shift the highlight as appropriate.
6236
6237 The FRAME argument doesn't necessarily have anything to do with which
6238 frame is being highlighted or un-highlighted; we only use it to find
6239 the appropriate X display info. */
6240
6241 static void
6242 XTframe_rehighlight (frame)
6243 struct frame *frame;
6244 {
6245 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame));
6246 }
6247
6248 static void
6249 x_frame_rehighlight (dpyinfo)
6250 struct x_display_info *dpyinfo;
6251 {
6252 struct frame *old_highlight = dpyinfo->x_highlight_frame;
6253
6254 if (dpyinfo->x_focus_frame)
6255 {
6256 dpyinfo->x_highlight_frame
6257 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame)))
6258 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame))
6259 : dpyinfo->x_focus_frame);
6260 if (! FRAME_LIVE_P (dpyinfo->x_highlight_frame))
6261 {
6262 FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame) = Qnil;
6263 dpyinfo->x_highlight_frame = dpyinfo->x_focus_frame;
6264 }
6265 }
6266 else
6267 dpyinfo->x_highlight_frame = 0;
6268
6269 if (dpyinfo->x_highlight_frame != old_highlight)
6270 {
6271 if (old_highlight)
6272 frame_unhighlight (old_highlight);
6273 if (dpyinfo->x_highlight_frame)
6274 frame_highlight (dpyinfo->x_highlight_frame);
6275 }
6276 }
6277
6278
6279 \f
6280 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
6281
6282 /* Initialize mode_switch_bit and modifier_meaning. */
6283 static void
6284 x_find_modifier_meanings (dpyinfo)
6285 struct x_display_info *dpyinfo;
6286 {
6287 int min_code, max_code;
6288 KeySym *syms;
6289 int syms_per_code;
6290 XModifierKeymap *mods;
6291
6292 dpyinfo->meta_mod_mask = 0;
6293 dpyinfo->shift_lock_mask = 0;
6294 dpyinfo->alt_mod_mask = 0;
6295 dpyinfo->super_mod_mask = 0;
6296 dpyinfo->hyper_mod_mask = 0;
6297
6298 #ifdef HAVE_X11R4
6299 XDisplayKeycodes (dpyinfo->display, &min_code, &max_code);
6300 #else
6301 min_code = dpyinfo->display->min_keycode;
6302 max_code = dpyinfo->display->max_keycode;
6303 #endif
6304
6305 syms = XGetKeyboardMapping (dpyinfo->display,
6306 min_code, max_code - min_code + 1,
6307 &syms_per_code);
6308 mods = XGetModifierMapping (dpyinfo->display);
6309
6310 /* Scan the modifier table to see which modifier bits the Meta and
6311 Alt keysyms are on. */
6312 {
6313 int row, col; /* The row and column in the modifier table. */
6314
6315 for (row = 3; row < 8; row++)
6316 for (col = 0; col < mods->max_keypermod; col++)
6317 {
6318 KeyCode code
6319 = mods->modifiermap[(row * mods->max_keypermod) + col];
6320
6321 /* Zeroes are used for filler. Skip them. */
6322 if (code == 0)
6323 continue;
6324
6325 /* Are any of this keycode's keysyms a meta key? */
6326 {
6327 int code_col;
6328
6329 for (code_col = 0; code_col < syms_per_code; code_col++)
6330 {
6331 int sym = syms[((code - min_code) * syms_per_code) + code_col];
6332
6333 switch (sym)
6334 {
6335 case XK_Meta_L:
6336 case XK_Meta_R:
6337 dpyinfo->meta_mod_mask |= (1 << row);
6338 break;
6339
6340 case XK_Alt_L:
6341 case XK_Alt_R:
6342 dpyinfo->alt_mod_mask |= (1 << row);
6343 break;
6344
6345 case XK_Hyper_L:
6346 case XK_Hyper_R:
6347 dpyinfo->hyper_mod_mask |= (1 << row);
6348 break;
6349
6350 case XK_Super_L:
6351 case XK_Super_R:
6352 dpyinfo->super_mod_mask |= (1 << row);
6353 break;
6354
6355 case XK_Shift_Lock:
6356 /* Ignore this if it's not on the lock modifier. */
6357 if ((1 << row) == LockMask)
6358 dpyinfo->shift_lock_mask = LockMask;
6359 break;
6360 }
6361 }
6362 }
6363 }
6364 }
6365
6366 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
6367 if (! dpyinfo->meta_mod_mask)
6368 {
6369 dpyinfo->meta_mod_mask = dpyinfo->alt_mod_mask;
6370 dpyinfo->alt_mod_mask = 0;
6371 }
6372
6373 /* If some keys are both alt and meta,
6374 make them just meta, not alt. */
6375 if (dpyinfo->alt_mod_mask & dpyinfo->meta_mod_mask)
6376 {
6377 dpyinfo->alt_mod_mask &= ~dpyinfo->meta_mod_mask;
6378 }
6379
6380 XFree ((char *) syms);
6381 XFreeModifiermap (mods);
6382 }
6383
6384 /* Convert between the modifier bits X uses and the modifier bits
6385 Emacs uses. */
6386
6387 static unsigned int
6388 x_x_to_emacs_modifiers (dpyinfo, state)
6389 struct x_display_info *dpyinfo;
6390 unsigned int state;
6391 {
6392 return ( ((state & (ShiftMask | dpyinfo->shift_lock_mask)) ? shift_modifier : 0)
6393 | ((state & ControlMask) ? ctrl_modifier : 0)
6394 | ((state & dpyinfo->meta_mod_mask) ? meta_modifier : 0)
6395 | ((state & dpyinfo->alt_mod_mask) ? alt_modifier : 0)
6396 | ((state & dpyinfo->super_mod_mask) ? super_modifier : 0)
6397 | ((state & dpyinfo->hyper_mod_mask) ? hyper_modifier : 0));
6398 }
6399
6400 static unsigned int
6401 x_emacs_to_x_modifiers (dpyinfo, state)
6402 struct x_display_info *dpyinfo;
6403 unsigned int state;
6404 {
6405 return ( ((state & alt_modifier) ? dpyinfo->alt_mod_mask : 0)
6406 | ((state & super_modifier) ? dpyinfo->super_mod_mask : 0)
6407 | ((state & hyper_modifier) ? dpyinfo->hyper_mod_mask : 0)
6408 | ((state & shift_modifier) ? ShiftMask : 0)
6409 | ((state & ctrl_modifier) ? ControlMask : 0)
6410 | ((state & meta_modifier) ? dpyinfo->meta_mod_mask : 0));
6411 }
6412
6413 /* Convert a keysym to its name. */
6414
6415 char *
6416 x_get_keysym_name (keysym)
6417 KeySym keysym;
6418 {
6419 char *value;
6420
6421 BLOCK_INPUT;
6422 value = XKeysymToString (keysym);
6423 UNBLOCK_INPUT;
6424
6425 return value;
6426 }
6427
6428
6429 \f
6430 /* Mouse clicks and mouse movement. Rah. */
6431
6432 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
6433 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
6434 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
6435 not force the value into range. */
6436
6437 void
6438 pixel_to_glyph_coords (f, pix_x, pix_y, x, y, bounds, noclip)
6439 FRAME_PTR f;
6440 register int pix_x, pix_y;
6441 register int *x, *y;
6442 XRectangle *bounds;
6443 int noclip;
6444 {
6445 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to round down
6446 even for negative values. */
6447 if (pix_x < 0)
6448 pix_x -= FONT_WIDTH ((f)->output_data.x->font) - 1;
6449 if (pix_y < 0)
6450 pix_y -= (f)->output_data.x->line_height - 1;
6451
6452 pix_x = PIXEL_TO_CHAR_COL (f, pix_x);
6453 pix_y = PIXEL_TO_CHAR_ROW (f, pix_y);
6454
6455 if (bounds)
6456 {
6457 bounds->width = FONT_WIDTH (f->output_data.x->font);
6458 bounds->height = f->output_data.x->line_height;
6459 bounds->x = CHAR_TO_PIXEL_COL (f, pix_x);
6460 bounds->y = CHAR_TO_PIXEL_ROW (f, pix_y);
6461 }
6462
6463 if (!noclip)
6464 {
6465 if (pix_x < 0)
6466 pix_x = 0;
6467 else if (pix_x > FRAME_WINDOW_WIDTH (f))
6468 pix_x = FRAME_WINDOW_WIDTH (f);
6469
6470 if (pix_y < 0)
6471 pix_y = 0;
6472 else if (pix_y > f->height)
6473 pix_y = f->height;
6474 }
6475
6476 *x = pix_x;
6477 *y = pix_y;
6478 }
6479
6480
6481 /* Given HPOS/VPOS in the current matrix of W, return corresponding
6482 frame-relative pixel positions in *FRAME_X and *FRAME_Y. If we
6483 can't tell the positions because W's display is not up to date,
6484 return 0. */
6485
6486 int
6487 glyph_to_pixel_coords (w, hpos, vpos, frame_x, frame_y)
6488 struct window *w;
6489 int hpos, vpos;
6490 int *frame_x, *frame_y;
6491 {
6492 int success_p;
6493
6494 xassert (hpos >= 0 && hpos < w->current_matrix->matrix_w);
6495 xassert (vpos >= 0 && vpos < w->current_matrix->matrix_h);
6496
6497 if (display_completed)
6498 {
6499 struct glyph_row *row = MATRIX_ROW (w->current_matrix, vpos);
6500 struct glyph *glyph = row->glyphs[TEXT_AREA];
6501 struct glyph *end = glyph + min (hpos, row->used[TEXT_AREA]);
6502
6503 *frame_y = row->y;
6504 *frame_x = row->x;
6505 while (glyph < end)
6506 {
6507 *frame_x += glyph->pixel_width;
6508 ++glyph;
6509 }
6510
6511 success_p = 1;
6512 }
6513 else
6514 {
6515 *frame_y = *frame_x = 0;
6516 success_p = 0;
6517 }
6518
6519 *frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, *frame_y);
6520 *frame_x = WINDOW_TO_FRAME_PIXEL_X (w, *frame_x);
6521 return success_p;
6522 }
6523
6524
6525 /* Prepare a mouse-event in *RESULT for placement in the input queue.
6526
6527 If the event is a button press, then note that we have grabbed
6528 the mouse. */
6529
6530 static Lisp_Object
6531 construct_mouse_click (result, event, f)
6532 struct input_event *result;
6533 XButtonEvent *event;
6534 struct frame *f;
6535 {
6536 /* Make the event type no_event; we'll change that when we decide
6537 otherwise. */
6538 result->kind = mouse_click;
6539 result->code = event->button - Button1;
6540 result->timestamp = event->time;
6541 result->modifiers = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
6542 event->state)
6543 | (event->type == ButtonRelease
6544 ? up_modifier
6545 : down_modifier));
6546
6547 XSETINT (result->x, event->x);
6548 XSETINT (result->y, event->y);
6549 XSETFRAME (result->frame_or_window, f);
6550 result->arg = Qnil;
6551 return Qnil;
6552 }
6553
6554 \f
6555 /* Function to report a mouse movement to the mainstream Emacs code.
6556 The input handler calls this.
6557
6558 We have received a mouse movement event, which is given in *event.
6559 If the mouse is over a different glyph than it was last time, tell
6560 the mainstream emacs code by setting mouse_moved. If not, ask for
6561 another motion event, so we can check again the next time it moves. */
6562
6563 static XMotionEvent last_mouse_motion_event;
6564 static Lisp_Object last_mouse_motion_frame;
6565
6566 static void
6567 note_mouse_movement (frame, event)
6568 FRAME_PTR frame;
6569 XMotionEvent *event;
6570 {
6571 last_mouse_movement_time = event->time;
6572 last_mouse_motion_event = *event;
6573 XSETFRAME (last_mouse_motion_frame, frame);
6574
6575 if (event->window != FRAME_X_WINDOW (frame))
6576 {
6577 frame->mouse_moved = 1;
6578 last_mouse_scroll_bar = Qnil;
6579 note_mouse_highlight (frame, -1, -1);
6580 }
6581
6582 /* Has the mouse moved off the glyph it was on at the last sighting? */
6583 else if (event->x < last_mouse_glyph.x
6584 || event->x >= last_mouse_glyph.x + last_mouse_glyph.width
6585 || event->y < last_mouse_glyph.y
6586 || event->y >= last_mouse_glyph.y + last_mouse_glyph.height)
6587 {
6588 frame->mouse_moved = 1;
6589 last_mouse_scroll_bar = Qnil;
6590 note_mouse_highlight (frame, event->x, event->y);
6591 }
6592 }
6593
6594 /* This is used for debugging, to turn off note_mouse_highlight. */
6595
6596 int disable_mouse_highlight;
6597
6598
6599 \f
6600 /************************************************************************
6601 Mouse Face
6602 ************************************************************************/
6603
6604 /* Find the glyph under window-relative coordinates X/Y in window W.
6605 Consider only glyphs from buffer text, i.e. no glyphs from overlay
6606 strings. Return in *HPOS and *VPOS the row and column number of
6607 the glyph found. Return in *AREA the glyph area containing X.
6608 Value is a pointer to the glyph found or null if X/Y is not on
6609 text, or we can't tell because W's current matrix is not up to
6610 date. */
6611
6612 static struct glyph *
6613 x_y_to_hpos_vpos (w, x, y, hpos, vpos, area, buffer_only_p)
6614 struct window *w;
6615 int x, y;
6616 int *hpos, *vpos, *area;
6617 int buffer_only_p;
6618 {
6619 struct glyph *glyph, *end;
6620 struct glyph_row *row = NULL;
6621 int x0, i, left_area_width;
6622
6623 /* Find row containing Y. Give up if some row is not enabled. */
6624 for (i = 0; i < w->current_matrix->nrows; ++i)
6625 {
6626 row = MATRIX_ROW (w->current_matrix, i);
6627 if (!row->enabled_p)
6628 return NULL;
6629 if (y >= row->y && y < MATRIX_ROW_BOTTOM_Y (row))
6630 break;
6631 }
6632
6633 *vpos = i;
6634 *hpos = 0;
6635
6636 /* Give up if Y is not in the window. */
6637 if (i == w->current_matrix->nrows)
6638 return NULL;
6639
6640 /* Get the glyph area containing X. */
6641 if (w->pseudo_window_p)
6642 {
6643 *area = TEXT_AREA;
6644 x0 = 0;
6645 }
6646 else
6647 {
6648 left_area_width = window_box_width (w, LEFT_MARGIN_AREA);
6649 if (x < left_area_width)
6650 {
6651 *area = LEFT_MARGIN_AREA;
6652 x0 = 0;
6653 }
6654 else if (x < left_area_width + window_box_width (w, TEXT_AREA))
6655 {
6656 *area = TEXT_AREA;
6657 x0 = row->x + left_area_width;
6658 }
6659 else
6660 {
6661 *area = RIGHT_MARGIN_AREA;
6662 x0 = left_area_width + window_box_width (w, TEXT_AREA);
6663 }
6664 }
6665
6666 /* Find glyph containing X. */
6667 glyph = row->glyphs[*area];
6668 end = glyph + row->used[*area];
6669 while (glyph < end)
6670 {
6671 if (x < x0 + glyph->pixel_width)
6672 {
6673 if (w->pseudo_window_p)
6674 break;
6675 else if (!buffer_only_p || BUFFERP (glyph->object))
6676 break;
6677 }
6678
6679 x0 += glyph->pixel_width;
6680 ++glyph;
6681 }
6682
6683 if (glyph == end)
6684 return NULL;
6685
6686 *hpos = glyph - row->glyphs[*area];
6687 return glyph;
6688 }
6689
6690
6691 /* Convert frame-relative x/y to coordinates relative to window W.
6692 Takes pseudo-windows into account. */
6693
6694 static void
6695 frame_to_window_pixel_xy (w, x, y)
6696 struct window *w;
6697 int *x, *y;
6698 {
6699 if (w->pseudo_window_p)
6700 {
6701 /* A pseudo-window is always full-width, and starts at the
6702 left edge of the frame, plus a frame border. */
6703 struct frame *f = XFRAME (w->frame);
6704 *x -= FRAME_INTERNAL_BORDER_WIDTH_SAFE (f);
6705 *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
6706 }
6707 else
6708 {
6709 *x = FRAME_TO_WINDOW_PIXEL_X (w, *x);
6710 *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
6711 }
6712 }
6713
6714
6715 /* Take proper action when mouse has moved to the mode or header line of
6716 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
6717 mode line. X is relative to the start of the text display area of
6718 W, so the width of bitmap areas and scroll bars must be subtracted
6719 to get a position relative to the start of the mode line. */
6720
6721 static void
6722 note_mode_line_highlight (w, x, mode_line_p)
6723 struct window *w;
6724 int x, mode_line_p;
6725 {
6726 struct frame *f = XFRAME (w->frame);
6727 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
6728 Cursor cursor = dpyinfo->vertical_scroll_bar_cursor;
6729 struct glyph_row *row;
6730
6731 if (mode_line_p)
6732 row = MATRIX_MODE_LINE_ROW (w->current_matrix);
6733 else
6734 row = MATRIX_HEADER_LINE_ROW (w->current_matrix);
6735
6736 if (row->enabled_p)
6737 {
6738 struct glyph *glyph, *end;
6739 Lisp_Object help, map;
6740 int x0;
6741
6742 /* Find the glyph under X. */
6743 glyph = row->glyphs[TEXT_AREA];
6744 end = glyph + row->used[TEXT_AREA];
6745 x0 = - (FRAME_LEFT_SCROLL_BAR_WIDTH (f) * CANON_X_UNIT (f)
6746 + FRAME_X_LEFT_FLAGS_AREA_WIDTH (f));
6747
6748 while (glyph < end
6749 && x >= x0 + glyph->pixel_width)
6750 {
6751 x0 += glyph->pixel_width;
6752 ++glyph;
6753 }
6754
6755 if (glyph < end
6756 && STRINGP (glyph->object)
6757 && XSTRING (glyph->object)->intervals
6758 && glyph->charpos >= 0
6759 && glyph->charpos < XSTRING (glyph->object)->size)
6760 {
6761 /* If we're on a string with `help-echo' text property,
6762 arrange for the help to be displayed. This is done by
6763 setting the global variable help_echo to the help string. */
6764 help = Fget_text_property (make_number (glyph->charpos),
6765 Qhelp_echo, glyph->object);
6766 if (!NILP (help))
6767 {
6768 help_echo = help;
6769 XSETWINDOW (help_echo_window, w);
6770 help_echo_object = glyph->object;
6771 help_echo_pos = glyph->charpos;
6772 }
6773
6774 /* Change the mouse pointer according to what is under X/Y. */
6775 map = Fget_text_property (make_number (glyph->charpos),
6776 Qlocal_map, glyph->object);
6777 if (KEYMAPP (map))
6778 cursor = f->output_data.x->nontext_cursor;
6779 else
6780 {
6781 map = Fget_text_property (make_number (glyph->charpos),
6782 Qkeymap, glyph->object);
6783 if (KEYMAPP (map))
6784 cursor = f->output_data.x->nontext_cursor;
6785 }
6786 }
6787 }
6788
6789 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), cursor);
6790 }
6791
6792
6793 /* Take proper action when the mouse has moved to position X, Y on
6794 frame F as regards highlighting characters that have mouse-face
6795 properties. Also de-highlighting chars where the mouse was before.
6796 X and Y can be negative or out of range. */
6797
6798 static void
6799 note_mouse_highlight (f, x, y)
6800 struct frame *f;
6801 int x, y;
6802 {
6803 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
6804 int portion;
6805 Lisp_Object window;
6806 struct window *w;
6807 Cursor cursor = None;
6808 struct buffer *b;
6809
6810 /* When a menu is active, don't highlight because this looks odd. */
6811 #ifdef USE_X_TOOLKIT
6812 if (popup_activated ())
6813 return;
6814 #endif
6815
6816 if (disable_mouse_highlight
6817 || !f->glyphs_initialized_p)
6818 return;
6819
6820 dpyinfo->mouse_face_mouse_x = x;
6821 dpyinfo->mouse_face_mouse_y = y;
6822 dpyinfo->mouse_face_mouse_frame = f;
6823
6824 if (dpyinfo->mouse_face_defer)
6825 return;
6826
6827 if (gc_in_progress)
6828 {
6829 dpyinfo->mouse_face_deferred_gc = 1;
6830 return;
6831 }
6832
6833 /* Which window is that in? */
6834 window = window_from_coordinates (f, x, y, &portion, 1);
6835
6836 /* If we were displaying active text in another window, clear that. */
6837 if (! EQ (window, dpyinfo->mouse_face_window))
6838 clear_mouse_face (dpyinfo);
6839
6840 /* Not on a window -> return. */
6841 if (!WINDOWP (window))
6842 return;
6843
6844 /* Convert to window-relative pixel coordinates. */
6845 w = XWINDOW (window);
6846 frame_to_window_pixel_xy (w, &x, &y);
6847
6848 /* Handle tool-bar window differently since it doesn't display a
6849 buffer. */
6850 if (EQ (window, f->tool_bar_window))
6851 {
6852 note_tool_bar_highlight (f, x, y);
6853 return;
6854 }
6855
6856 /* Mouse is on the mode or header line? */
6857 if (portion == 1 || portion == 3)
6858 {
6859 note_mode_line_highlight (w, x, portion == 1);
6860 return;
6861 }
6862
6863 if (portion == 2)
6864 cursor = f->output_data.x->horizontal_drag_cursor;
6865 else
6866 cursor = f->output_data.x->text_cursor;
6867
6868 /* Are we in a window whose display is up to date?
6869 And verify the buffer's text has not changed. */
6870 b = XBUFFER (w->buffer);
6871 if (/* Within text portion of the window. */
6872 portion == 0
6873 && EQ (w->window_end_valid, w->buffer)
6874 && XFASTINT (w->last_modified) == BUF_MODIFF (b)
6875 && XFASTINT (w->last_overlay_modified) == BUF_OVERLAY_MODIFF (b))
6876 {
6877 int hpos, vpos, pos, i, area;
6878 struct glyph *glyph;
6879 Lisp_Object object;
6880 Lisp_Object mouse_face = Qnil, overlay = Qnil, position;
6881 Lisp_Object *overlay_vec = NULL;
6882 int len, noverlays;
6883 struct buffer *obuf;
6884 int obegv, ozv, same_region;
6885
6886 /* Find the glyph under X/Y. */
6887 glyph = x_y_to_hpos_vpos (w, x, y, &hpos, &vpos, &area, 0);
6888
6889 /* Clear mouse face if X/Y not over text. */
6890 if (glyph == NULL
6891 || area != TEXT_AREA
6892 || !MATRIX_ROW (w->current_matrix, vpos)->displays_text_p)
6893 {
6894 if (clear_mouse_face (dpyinfo))
6895 cursor = None;
6896 goto set_cursor;
6897 }
6898
6899 pos = glyph->charpos;
6900 object = glyph->object;
6901 if (!STRINGP (object) && !BUFFERP (object))
6902 goto set_cursor;
6903
6904 /* If we get an out-of-range value, return now; avoid an error. */
6905 if (BUFFERP (object) && pos > BUF_Z (b))
6906 goto set_cursor;
6907
6908 /* Make the window's buffer temporarily current for
6909 overlays_at and compute_char_face. */
6910 obuf = current_buffer;
6911 current_buffer = b;
6912 obegv = BEGV;
6913 ozv = ZV;
6914 BEGV = BEG;
6915 ZV = Z;
6916
6917 /* Is this char mouse-active or does it have help-echo? */
6918 position = make_number (pos);
6919
6920 if (BUFFERP (object))
6921 {
6922 /* Put all the overlays we want in a vector in overlay_vec.
6923 Store the length in len. If there are more than 10, make
6924 enough space for all, and try again. */
6925 len = 10;
6926 overlay_vec = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
6927 noverlays = overlays_at (pos, 0, &overlay_vec, &len, NULL, NULL, 0);
6928 if (noverlays > len)
6929 {
6930 len = noverlays;
6931 overlay_vec = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
6932 noverlays = overlays_at (pos, 0, &overlay_vec, &len, NULL, NULL,0);
6933 }
6934
6935 /* Sort overlays into increasing priority order. */
6936 noverlays = sort_overlays (overlay_vec, noverlays, w);
6937 }
6938 else
6939 noverlays = 0;
6940
6941 same_region = (EQ (window, dpyinfo->mouse_face_window)
6942 && vpos >= dpyinfo->mouse_face_beg_row
6943 && vpos <= dpyinfo->mouse_face_end_row
6944 && (vpos > dpyinfo->mouse_face_beg_row
6945 || hpos >= dpyinfo->mouse_face_beg_col)
6946 && (vpos < dpyinfo->mouse_face_end_row
6947 || hpos < dpyinfo->mouse_face_end_col
6948 || dpyinfo->mouse_face_past_end));
6949
6950 if (same_region)
6951 cursor = None;
6952
6953 /* Check mouse-face highlighting. */
6954 if (! same_region
6955 /* If there exists an overlay with mouse-face overlapping
6956 the one we are currently highlighting, we have to
6957 check if we enter the overlapping overlay, and then
6958 highlight only that. */
6959 || (OVERLAYP (dpyinfo->mouse_face_overlay)
6960 && mouse_face_overlay_overlaps (dpyinfo->mouse_face_overlay)))
6961 {
6962 /* Find the highest priority overlay that has a mouse-face
6963 property. */
6964 overlay = Qnil;
6965 for (i = noverlays - 1; i >= 0 && NILP (overlay); --i)
6966 {
6967 mouse_face = Foverlay_get (overlay_vec[i], Qmouse_face);
6968 if (!NILP (mouse_face))
6969 overlay = overlay_vec[i];
6970 }
6971
6972 /* If we're actually highlighting the same overlay as
6973 before, there's no need to do that again. */
6974 if (!NILP (overlay)
6975 && EQ (overlay, dpyinfo->mouse_face_overlay))
6976 goto check_help_echo;
6977
6978 dpyinfo->mouse_face_overlay = overlay;
6979
6980 /* Clear the display of the old active region, if any. */
6981 if (clear_mouse_face (dpyinfo))
6982 cursor = None;
6983
6984 /* If no overlay applies, get a text property. */
6985 if (NILP (overlay))
6986 mouse_face = Fget_text_property (position, Qmouse_face, object);
6987
6988 /* Handle the overlay case. */
6989 if (!NILP (overlay))
6990 {
6991 /* Find the range of text around this char that
6992 should be active. */
6993 Lisp_Object before, after;
6994 int ignore;
6995
6996 before = Foverlay_start (overlay);
6997 after = Foverlay_end (overlay);
6998 /* Record this as the current active region. */
6999 fast_find_position (w, XFASTINT (before),
7000 &dpyinfo->mouse_face_beg_col,
7001 &dpyinfo->mouse_face_beg_row,
7002 &dpyinfo->mouse_face_beg_x,
7003 &dpyinfo->mouse_face_beg_y);
7004 dpyinfo->mouse_face_past_end
7005 = !fast_find_position (w, XFASTINT (after),
7006 &dpyinfo->mouse_face_end_col,
7007 &dpyinfo->mouse_face_end_row,
7008 &dpyinfo->mouse_face_end_x,
7009 &dpyinfo->mouse_face_end_y);
7010 dpyinfo->mouse_face_window = window;
7011 dpyinfo->mouse_face_face_id
7012 = face_at_buffer_position (w, pos, 0, 0,
7013 &ignore, pos + 1, 1);
7014
7015 /* Display it as active. */
7016 show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
7017 cursor = None;
7018 }
7019 /* Handle the text property case. */
7020 else if (!NILP (mouse_face) && BUFFERP (object))
7021 {
7022 /* Find the range of text around this char that
7023 should be active. */
7024 Lisp_Object before, after, beginning, end;
7025 int ignore;
7026
7027 beginning = Fmarker_position (w->start);
7028 end = make_number (BUF_Z (XBUFFER (object))
7029 - XFASTINT (w->window_end_pos));
7030 before
7031 = Fprevious_single_property_change (make_number (pos + 1),
7032 Qmouse_face,
7033 object, beginning);
7034 after
7035 = Fnext_single_property_change (position, Qmouse_face,
7036 object, end);
7037
7038 /* Record this as the current active region. */
7039 fast_find_position (w, XFASTINT (before),
7040 &dpyinfo->mouse_face_beg_col,
7041 &dpyinfo->mouse_face_beg_row,
7042 &dpyinfo->mouse_face_beg_x,
7043 &dpyinfo->mouse_face_beg_y);
7044 dpyinfo->mouse_face_past_end
7045 = !fast_find_position (w, XFASTINT (after),
7046 &dpyinfo->mouse_face_end_col,
7047 &dpyinfo->mouse_face_end_row,
7048 &dpyinfo->mouse_face_end_x,
7049 &dpyinfo->mouse_face_end_y);
7050 dpyinfo->mouse_face_window = window;
7051
7052 if (BUFFERP (object))
7053 dpyinfo->mouse_face_face_id
7054 = face_at_buffer_position (w, pos, 0, 0,
7055 &ignore, pos + 1, 1);
7056
7057 /* Display it as active. */
7058 show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
7059 cursor = None;
7060 }
7061 else if (!NILP (mouse_face) && STRINGP (object))
7062 {
7063 Lisp_Object b, e;
7064 int ignore;
7065
7066 b = Fprevious_single_property_change (make_number (pos + 1),
7067 Qmouse_face,
7068 object, Qnil);
7069 e = Fnext_single_property_change (position, Qmouse_face,
7070 object, Qnil);
7071 if (NILP (b))
7072 b = make_number (0);
7073 if (NILP (e))
7074 e = make_number (XSTRING (object)->size - 1);
7075 fast_find_string_pos (w, XINT (b), object,
7076 &dpyinfo->mouse_face_beg_col,
7077 &dpyinfo->mouse_face_beg_row,
7078 &dpyinfo->mouse_face_beg_x,
7079 &dpyinfo->mouse_face_beg_y, 0);
7080 fast_find_string_pos (w, XINT (e), object,
7081 &dpyinfo->mouse_face_end_col,
7082 &dpyinfo->mouse_face_end_row,
7083 &dpyinfo->mouse_face_end_x,
7084 &dpyinfo->mouse_face_end_y, 1);
7085 dpyinfo->mouse_face_past_end = 0;
7086 dpyinfo->mouse_face_window = window;
7087 dpyinfo->mouse_face_face_id
7088 = face_at_string_position (w, object, pos, 0, 0, 0, &ignore,
7089 glyph->face_id, 1);
7090 show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
7091 cursor = None;
7092 }
7093 }
7094
7095 check_help_echo:
7096
7097 /* Look for a `help-echo' property. */
7098 {
7099 Lisp_Object help, overlay;
7100
7101 /* Check overlays first. */
7102 help = overlay = Qnil;
7103 for (i = noverlays - 1; i >= 0 && NILP (help); --i)
7104 {
7105 overlay = overlay_vec[i];
7106 help = Foverlay_get (overlay, Qhelp_echo);
7107 }
7108
7109 if (!NILP (help))
7110 {
7111 help_echo = help;
7112 help_echo_window = window;
7113 help_echo_object = overlay;
7114 help_echo_pos = pos;
7115 }
7116 else
7117 {
7118 Lisp_Object object = glyph->object;
7119 int charpos = glyph->charpos;
7120
7121 /* Try text properties. */
7122 if (STRINGP (object)
7123 && charpos >= 0
7124 && charpos < XSTRING (object)->size)
7125 {
7126 help = Fget_text_property (make_number (charpos),
7127 Qhelp_echo, object);
7128 if (NILP (help))
7129 {
7130 /* If the string itself doesn't specify a help-echo,
7131 see if the buffer text ``under'' it does. */
7132 struct glyph_row *r
7133 = MATRIX_ROW (w->current_matrix, vpos);
7134 int start = MATRIX_ROW_START_CHARPOS (r);
7135 int pos = string_buffer_position (w, object, start);
7136 if (pos > 0)
7137 {
7138 help = Fget_text_property (make_number (pos),
7139 Qhelp_echo, w->buffer);
7140 if (!NILP (help))
7141 {
7142 charpos = pos;
7143 object = w->buffer;
7144 }
7145 }
7146 }
7147 }
7148 else if (BUFFERP (object)
7149 && charpos >= BEGV
7150 && charpos < ZV)
7151 help = Fget_text_property (make_number (charpos), Qhelp_echo,
7152 object);
7153
7154 if (!NILP (help))
7155 {
7156 help_echo = help;
7157 help_echo_window = window;
7158 help_echo_object = object;
7159 help_echo_pos = charpos;
7160 }
7161 }
7162 }
7163
7164 BEGV = obegv;
7165 ZV = ozv;
7166 current_buffer = obuf;
7167 }
7168
7169 set_cursor:
7170
7171 if (cursor != None)
7172 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), cursor);
7173 }
7174
7175 static void
7176 redo_mouse_highlight ()
7177 {
7178 if (!NILP (last_mouse_motion_frame)
7179 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame)))
7180 note_mouse_highlight (XFRAME (last_mouse_motion_frame),
7181 last_mouse_motion_event.x,
7182 last_mouse_motion_event.y);
7183 }
7184
7185
7186 \f
7187 /***********************************************************************
7188 Tool-bars
7189 ***********************************************************************/
7190
7191 static int x_tool_bar_item P_ ((struct frame *, int, int,
7192 struct glyph **, int *, int *, int *));
7193
7194 /* Tool-bar item index of the item on which a mouse button was pressed
7195 or -1. */
7196
7197 static int last_tool_bar_item;
7198
7199
7200 /* Get information about the tool-bar item at position X/Y on frame F.
7201 Return in *GLYPH a pointer to the glyph of the tool-bar item in
7202 the current matrix of the tool-bar window of F, or NULL if not
7203 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
7204 item in F->tool_bar_items. Value is
7205
7206 -1 if X/Y is not on a tool-bar item
7207 0 if X/Y is on the same item that was highlighted before.
7208 1 otherwise. */
7209
7210 static int
7211 x_tool_bar_item (f, x, y, glyph, hpos, vpos, prop_idx)
7212 struct frame *f;
7213 int x, y;
7214 struct glyph **glyph;
7215 int *hpos, *vpos, *prop_idx;
7216 {
7217 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
7218 struct window *w = XWINDOW (f->tool_bar_window);
7219 int area;
7220
7221 /* Find the glyph under X/Y. */
7222 *glyph = x_y_to_hpos_vpos (w, x, y, hpos, vpos, &area, 0);
7223 if (*glyph == NULL)
7224 return -1;
7225
7226 /* Get the start of this tool-bar item's properties in
7227 f->tool_bar_items. */
7228 if (!tool_bar_item_info (f, *glyph, prop_idx))
7229 return -1;
7230
7231 /* Is mouse on the highlighted item? */
7232 if (EQ (f->tool_bar_window, dpyinfo->mouse_face_window)
7233 && *vpos >= dpyinfo->mouse_face_beg_row
7234 && *vpos <= dpyinfo->mouse_face_end_row
7235 && (*vpos > dpyinfo->mouse_face_beg_row
7236 || *hpos >= dpyinfo->mouse_face_beg_col)
7237 && (*vpos < dpyinfo->mouse_face_end_row
7238 || *hpos < dpyinfo->mouse_face_end_col
7239 || dpyinfo->mouse_face_past_end))
7240 return 0;
7241
7242 return 1;
7243 }
7244
7245
7246 /* Handle mouse button event on the tool-bar of frame F, at
7247 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
7248 or ButtonRelase. */
7249
7250 static void
7251 x_handle_tool_bar_click (f, button_event)
7252 struct frame *f;
7253 XButtonEvent *button_event;
7254 {
7255 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
7256 struct window *w = XWINDOW (f->tool_bar_window);
7257 int hpos, vpos, prop_idx;
7258 struct glyph *glyph;
7259 Lisp_Object enabled_p;
7260 int x = button_event->x;
7261 int y = button_event->y;
7262
7263 /* If not on the highlighted tool-bar item, return. */
7264 frame_to_window_pixel_xy (w, &x, &y);
7265 if (x_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx) != 0)
7266 return;
7267
7268 /* If item is disabled, do nothing. */
7269 enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
7270 if (NILP (enabled_p))
7271 return;
7272
7273 if (button_event->type == ButtonPress)
7274 {
7275 /* Show item in pressed state. */
7276 show_mouse_face (dpyinfo, DRAW_IMAGE_SUNKEN);
7277 dpyinfo->mouse_face_image_state = DRAW_IMAGE_SUNKEN;
7278 last_tool_bar_item = prop_idx;
7279 }
7280 else
7281 {
7282 Lisp_Object key, frame;
7283 struct input_event event;
7284
7285 /* Show item in released state. */
7286 show_mouse_face (dpyinfo, DRAW_IMAGE_RAISED);
7287 dpyinfo->mouse_face_image_state = DRAW_IMAGE_RAISED;
7288
7289 key = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_KEY);
7290
7291 XSETFRAME (frame, f);
7292 event.kind = TOOL_BAR_EVENT;
7293 event.frame_or_window = frame;
7294 event.arg = frame;
7295 kbd_buffer_store_event (&event);
7296
7297 event.kind = TOOL_BAR_EVENT;
7298 event.frame_or_window = frame;
7299 event.arg = key;
7300 event.modifiers = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
7301 button_event->state);
7302 kbd_buffer_store_event (&event);
7303 last_tool_bar_item = -1;
7304 }
7305 }
7306
7307
7308 /* Possibly highlight a tool-bar item on frame F when mouse moves to
7309 tool-bar window-relative coordinates X/Y. Called from
7310 note_mouse_highlight. */
7311
7312 static void
7313 note_tool_bar_highlight (f, x, y)
7314 struct frame *f;
7315 int x, y;
7316 {
7317 Lisp_Object window = f->tool_bar_window;
7318 struct window *w = XWINDOW (window);
7319 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
7320 int hpos, vpos;
7321 struct glyph *glyph;
7322 struct glyph_row *row;
7323 int i;
7324 Lisp_Object enabled_p;
7325 int prop_idx;
7326 enum draw_glyphs_face draw;
7327 int mouse_down_p, rc;
7328
7329 /* Function note_mouse_highlight is called with negative x(y
7330 values when mouse moves outside of the frame. */
7331 if (x <= 0 || y <= 0)
7332 {
7333 clear_mouse_face (dpyinfo);
7334 return;
7335 }
7336
7337 rc = x_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx);
7338 if (rc < 0)
7339 {
7340 /* Not on tool-bar item. */
7341 clear_mouse_face (dpyinfo);
7342 return;
7343 }
7344 else if (rc == 0)
7345 goto set_help_echo;
7346
7347 clear_mouse_face (dpyinfo);
7348
7349 /* Mouse is down, but on different tool-bar item? */
7350 mouse_down_p = (dpyinfo->grabbed
7351 && f == last_mouse_frame
7352 && FRAME_LIVE_P (f));
7353 if (mouse_down_p
7354 && last_tool_bar_item != prop_idx)
7355 return;
7356
7357 dpyinfo->mouse_face_image_state = DRAW_NORMAL_TEXT;
7358 draw = mouse_down_p ? DRAW_IMAGE_SUNKEN : DRAW_IMAGE_RAISED;
7359
7360 /* If tool-bar item is not enabled, don't highlight it. */
7361 enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
7362 if (!NILP (enabled_p))
7363 {
7364 /* Compute the x-position of the glyph. In front and past the
7365 image is a space. We include this is the highlighted area. */
7366 row = MATRIX_ROW (w->current_matrix, vpos);
7367 for (i = x = 0; i < hpos; ++i)
7368 x += row->glyphs[TEXT_AREA][i].pixel_width;
7369
7370 /* Record this as the current active region. */
7371 dpyinfo->mouse_face_beg_col = hpos;
7372 dpyinfo->mouse_face_beg_row = vpos;
7373 dpyinfo->mouse_face_beg_x = x;
7374 dpyinfo->mouse_face_beg_y = row->y;
7375 dpyinfo->mouse_face_past_end = 0;
7376
7377 dpyinfo->mouse_face_end_col = hpos + 1;
7378 dpyinfo->mouse_face_end_row = vpos;
7379 dpyinfo->mouse_face_end_x = x + glyph->pixel_width;
7380 dpyinfo->mouse_face_end_y = row->y;
7381 dpyinfo->mouse_face_window = window;
7382 dpyinfo->mouse_face_face_id = TOOL_BAR_FACE_ID;
7383
7384 /* Display it as active. */
7385 show_mouse_face (dpyinfo, draw);
7386 dpyinfo->mouse_face_image_state = draw;
7387 }
7388
7389 set_help_echo:
7390
7391 /* Set help_echo to a help string.to display for this tool-bar item.
7392 XTread_socket does the rest. */
7393 help_echo_object = help_echo_window = Qnil;
7394 help_echo_pos = -1;
7395 help_echo = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_HELP);
7396 if (NILP (help_echo))
7397 help_echo = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_CAPTION);
7398 }
7399
7400
7401 \f
7402 /* Find the glyph matrix position of buffer position POS in window W.
7403 *HPOS, *VPOS, *X, and *Y are set to the positions found. W's
7404 current glyphs must be up to date. If POS is above window start
7405 return (0, 0, 0, 0). If POS is after end of W, return end of
7406 last line in W. */
7407
7408 static int
7409 fast_find_position (w, pos, hpos, vpos, x, y)
7410 struct window *w;
7411 int pos;
7412 int *hpos, *vpos, *x, *y;
7413 {
7414 int i;
7415 int lastcol;
7416 int maybe_next_line_p = 0;
7417 int line_start_position;
7418 int yb = window_text_bottom_y (w);
7419 struct glyph_row *row, *best_row;
7420 int row_vpos, best_row_vpos;
7421 int current_x;
7422
7423 row = best_row = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
7424 row_vpos = best_row_vpos = MATRIX_ROW_VPOS (row, w->current_matrix);
7425
7426 while (row->y < yb)
7427 {
7428 if (row->used[TEXT_AREA])
7429 line_start_position = row->glyphs[TEXT_AREA]->charpos;
7430 else
7431 line_start_position = 0;
7432
7433 if (line_start_position > pos)
7434 break;
7435 /* If the position sought is the end of the buffer,
7436 don't include the blank lines at the bottom of the window. */
7437 else if (line_start_position == pos
7438 && pos == BUF_ZV (XBUFFER (w->buffer)))
7439 {
7440 maybe_next_line_p = 1;
7441 break;
7442 }
7443 else if (line_start_position > 0)
7444 {
7445 best_row = row;
7446 best_row_vpos = row_vpos;
7447 }
7448
7449 if (row->y + row->height >= yb)
7450 break;
7451
7452 ++row;
7453 ++row_vpos;
7454 }
7455
7456 /* Find the right column within BEST_ROW. */
7457 lastcol = 0;
7458 current_x = best_row->x;
7459 for (i = 0; i < best_row->used[TEXT_AREA]; i++)
7460 {
7461 struct glyph *glyph = best_row->glyphs[TEXT_AREA] + i;
7462 int charpos;
7463
7464 charpos = glyph->charpos;
7465 if (charpos == pos)
7466 {
7467 *hpos = i;
7468 *vpos = best_row_vpos;
7469 *x = current_x;
7470 *y = best_row->y;
7471 return 1;
7472 }
7473 else if (charpos > pos)
7474 break;
7475 else if (charpos > 0)
7476 lastcol = i;
7477
7478 current_x += glyph->pixel_width;
7479 }
7480
7481 /* If we're looking for the end of the buffer,
7482 and we didn't find it in the line we scanned,
7483 use the start of the following line. */
7484 if (maybe_next_line_p)
7485 {
7486 ++best_row;
7487 ++best_row_vpos;
7488 lastcol = 0;
7489 current_x = best_row->x;
7490 }
7491
7492 *vpos = best_row_vpos;
7493 *hpos = lastcol + 1;
7494 *x = current_x;
7495 *y = best_row->y;
7496 return 0;
7497 }
7498
7499
7500 /* Find the position of the the glyph for position POS in OBJECT in
7501 window W's current matrix, and return in *X/*Y the pixel
7502 coordinates, and return in *HPOS/*VPOS the column/row of the glyph.
7503
7504 RIGHT_P non-zero means return the position of the right edge of the
7505 glyph, RIGHT_P zero means return the left edge position.
7506
7507 If no glyph for POS exists in the matrix, return the position of
7508 the glyph with the next smaller position that is in the matrix, if
7509 RIGHT_P is zero. If RIGHT_P is non-zero, and no glyph for POS
7510 exists in the matrix, return the position of the glyph with the
7511 next larger position in OBJECT.
7512
7513 Value is non-zero if a glyph was found. */
7514
7515 static int
7516 fast_find_string_pos (w, pos, object, hpos, vpos, x, y, right_p)
7517 struct window *w;
7518 int pos;
7519 Lisp_Object object;
7520 int *hpos, *vpos, *x, *y;
7521 int right_p;
7522 {
7523 int yb = window_text_bottom_y (w);
7524 struct glyph_row *r;
7525 struct glyph *best_glyph = NULL;
7526 struct glyph_row *best_row = NULL;
7527 int best_x = 0;
7528
7529 for (r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
7530 r->enabled_p && r->y < yb;
7531 ++r)
7532 {
7533 struct glyph *g = r->glyphs[TEXT_AREA];
7534 struct glyph *e = g + r->used[TEXT_AREA];
7535 int gx;
7536
7537 for (gx = r->x; g < e; gx += g->pixel_width, ++g)
7538 if (EQ (g->object, object))
7539 {
7540 if (g->charpos == pos)
7541 {
7542 best_glyph = g;
7543 best_x = gx;
7544 best_row = r;
7545 goto found;
7546 }
7547 else if (best_glyph == NULL
7548 || ((abs (g->charpos - pos)
7549 < abs (best_glyph->charpos - pos))
7550 && (right_p
7551 ? g->charpos < pos
7552 : g->charpos > pos)))
7553 {
7554 best_glyph = g;
7555 best_x = gx;
7556 best_row = r;
7557 }
7558 }
7559 }
7560
7561 found:
7562
7563 if (best_glyph)
7564 {
7565 *x = best_x;
7566 *hpos = best_glyph - best_row->glyphs[TEXT_AREA];
7567
7568 if (right_p)
7569 {
7570 *x += best_glyph->pixel_width;
7571 ++*hpos;
7572 }
7573
7574 *y = best_row->y;
7575 *vpos = best_row - w->current_matrix->rows;
7576 }
7577
7578 return best_glyph != NULL;
7579 }
7580
7581
7582 /* Display the active region described by mouse_face_*
7583 in its mouse-face if HL > 0, in its normal face if HL = 0. */
7584
7585 static void
7586 show_mouse_face (dpyinfo, draw)
7587 struct x_display_info *dpyinfo;
7588 enum draw_glyphs_face draw;
7589 {
7590 struct window *w = XWINDOW (dpyinfo->mouse_face_window);
7591 struct frame *f = XFRAME (WINDOW_FRAME (w));
7592 int i;
7593 int cursor_off_p = 0;
7594 struct cursor_pos saved_cursor;
7595
7596 saved_cursor = output_cursor;
7597
7598 /* If window is in the process of being destroyed, don't bother
7599 to do anything. */
7600 if (w->current_matrix == NULL)
7601 goto set_x_cursor;
7602
7603 /* Recognize when we are called to operate on rows that don't exist
7604 anymore. This can happen when a window is split. */
7605 if (dpyinfo->mouse_face_end_row >= w->current_matrix->nrows)
7606 goto set_x_cursor;
7607
7608 set_output_cursor (&w->phys_cursor);
7609
7610 /* Note that mouse_face_beg_row etc. are window relative. */
7611 for (i = dpyinfo->mouse_face_beg_row;
7612 i <= dpyinfo->mouse_face_end_row;
7613 i++)
7614 {
7615 int start_hpos, end_hpos, start_x;
7616 struct glyph_row *row = MATRIX_ROW (w->current_matrix, i);
7617
7618 /* Don't do anything if row doesn't have valid contents. */
7619 if (!row->enabled_p)
7620 continue;
7621
7622 /* For all but the first row, the highlight starts at column 0. */
7623 if (i == dpyinfo->mouse_face_beg_row)
7624 {
7625 start_hpos = dpyinfo->mouse_face_beg_col;
7626 start_x = dpyinfo->mouse_face_beg_x;
7627 }
7628 else
7629 {
7630 start_hpos = 0;
7631 start_x = 0;
7632 }
7633
7634 if (i == dpyinfo->mouse_face_end_row)
7635 end_hpos = dpyinfo->mouse_face_end_col;
7636 else
7637 end_hpos = row->used[TEXT_AREA];
7638
7639 /* If the cursor's in the text we are about to rewrite, turn the
7640 cursor off. */
7641 if (!w->pseudo_window_p
7642 && i == output_cursor.vpos
7643 && output_cursor.hpos >= start_hpos - 1
7644 && output_cursor.hpos <= end_hpos)
7645 {
7646 x_update_window_cursor (w, 0);
7647 cursor_off_p = 1;
7648 }
7649
7650 if (end_hpos > start_hpos)
7651 {
7652 row->mouse_face_p = draw == DRAW_MOUSE_FACE || DRAW_IMAGE_RAISED;
7653 x_draw_glyphs (w, start_x, row, TEXT_AREA,
7654 start_hpos, end_hpos, draw, NULL, NULL, 0);
7655 }
7656 }
7657
7658 /* If we turned the cursor off, turn it back on. */
7659 if (cursor_off_p)
7660 x_display_cursor (w, 1,
7661 output_cursor.hpos, output_cursor.vpos,
7662 output_cursor.x, output_cursor.y);
7663
7664 output_cursor = saved_cursor;
7665
7666 set_x_cursor:
7667
7668 /* Change the mouse cursor. */
7669 if (draw == DRAW_NORMAL_TEXT)
7670 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
7671 f->output_data.x->text_cursor);
7672 else if (draw == DRAW_MOUSE_FACE)
7673 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
7674 f->output_data.x->cross_cursor);
7675 else
7676 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
7677 f->output_data.x->nontext_cursor);
7678 }
7679
7680 /* Clear out the mouse-highlighted active region.
7681 Redraw it un-highlighted first. Value is non-zero if mouse
7682 face was actually drawn unhighlighted. */
7683
7684 static int
7685 clear_mouse_face (dpyinfo)
7686 struct x_display_info *dpyinfo;
7687 {
7688 int cleared = 0;
7689
7690 if (!NILP (dpyinfo->mouse_face_window))
7691 {
7692 show_mouse_face (dpyinfo, DRAW_NORMAL_TEXT);
7693 cleared = 1;
7694 }
7695
7696 dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
7697 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
7698 dpyinfo->mouse_face_window = Qnil;
7699 dpyinfo->mouse_face_overlay = Qnil;
7700 return cleared;
7701 }
7702
7703
7704 /* Clear any mouse-face on window W. This function is part of the
7705 redisplay interface, and is called from try_window_id and similar
7706 functions to ensure the mouse-highlight is off. */
7707
7708 static void
7709 x_clear_mouse_face (w)
7710 struct window *w;
7711 {
7712 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (XFRAME (w->frame));
7713 Lisp_Object window;
7714
7715 BLOCK_INPUT;
7716 XSETWINDOW (window, w);
7717 if (EQ (window, dpyinfo->mouse_face_window))
7718 clear_mouse_face (dpyinfo);
7719 UNBLOCK_INPUT;
7720 }
7721
7722
7723 /* Just discard the mouse face information for frame F, if any.
7724 This is used when the size of F is changed. */
7725
7726 void
7727 cancel_mouse_face (f)
7728 FRAME_PTR f;
7729 {
7730 Lisp_Object window;
7731 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
7732
7733 window = dpyinfo->mouse_face_window;
7734 if (! NILP (window) && XFRAME (XWINDOW (window)->frame) == f)
7735 {
7736 dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
7737 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
7738 dpyinfo->mouse_face_window = Qnil;
7739 }
7740 }
7741
7742 \f
7743 static int glyph_rect P_ ((struct frame *f, int, int, XRectangle *));
7744
7745
7746 /* Try to determine frame pixel position and size of the glyph under
7747 frame pixel coordinates X/Y on frame F . Return the position and
7748 size in *RECT. Value is non-zero if we could compute these
7749 values. */
7750
7751 static int
7752 glyph_rect (f, x, y, rect)
7753 struct frame *f;
7754 int x, y;
7755 XRectangle *rect;
7756 {
7757 Lisp_Object window;
7758 int part, found = 0;
7759
7760 window = window_from_coordinates (f, x, y, &part, 0);
7761 if (!NILP (window))
7762 {
7763 struct window *w = XWINDOW (window);
7764 struct glyph_row *r = MATRIX_FIRST_TEXT_ROW (w->current_matrix);
7765 struct glyph_row *end = r + w->current_matrix->nrows - 1;
7766 int area;
7767
7768 frame_to_window_pixel_xy (w, &x, &y);
7769
7770 for (; !found && r < end && r->enabled_p; ++r)
7771 if (r->y >= y)
7772 {
7773 struct glyph *g = r->glyphs[TEXT_AREA];
7774 struct glyph *end = g + r->used[TEXT_AREA];
7775 int gx;
7776
7777 for (gx = r->x; !found && g < end; gx += g->pixel_width, ++g)
7778 if (gx >= x)
7779 {
7780 rect->width = g->pixel_width;
7781 rect->height = r->height;
7782 rect->x = WINDOW_TO_FRAME_PIXEL_X (w, gx);
7783 rect->y = WINDOW_TO_FRAME_PIXEL_Y (w, r->y);
7784 found = 1;
7785 }
7786 }
7787 }
7788
7789 return found;
7790 }
7791
7792
7793 /* Return the current position of the mouse.
7794 *FP should be a frame which indicates which display to ask about.
7795
7796 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
7797 and *PART to the frame, window, and scroll bar part that the mouse
7798 is over. Set *X and *Y to the portion and whole of the mouse's
7799 position on the scroll bar.
7800
7801 If the mouse movement started elsewhere, set *FP to the frame the
7802 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
7803 the mouse is over.
7804
7805 Set *TIME to the server time-stamp for the time at which the mouse
7806 was at this position.
7807
7808 Don't store anything if we don't have a valid set of values to report.
7809
7810 This clears the mouse_moved flag, so we can wait for the next mouse
7811 movement. */
7812
7813 static void
7814 XTmouse_position (fp, insist, bar_window, part, x, y, time)
7815 FRAME_PTR *fp;
7816 int insist;
7817 Lisp_Object *bar_window;
7818 enum scroll_bar_part *part;
7819 Lisp_Object *x, *y;
7820 unsigned long *time;
7821 {
7822 FRAME_PTR f1;
7823
7824 BLOCK_INPUT;
7825
7826 if (! NILP (last_mouse_scroll_bar) && insist == 0)
7827 x_scroll_bar_report_motion (fp, bar_window, part, x, y, time);
7828 else
7829 {
7830 Window root;
7831 int root_x, root_y;
7832
7833 Window dummy_window;
7834 int dummy;
7835
7836 Lisp_Object frame, tail;
7837
7838 /* Clear the mouse-moved flag for every frame on this display. */
7839 FOR_EACH_FRAME (tail, frame)
7840 if (FRAME_X_DISPLAY (XFRAME (frame)) == FRAME_X_DISPLAY (*fp))
7841 XFRAME (frame)->mouse_moved = 0;
7842
7843 last_mouse_scroll_bar = Qnil;
7844
7845 /* Figure out which root window we're on. */
7846 XQueryPointer (FRAME_X_DISPLAY (*fp),
7847 DefaultRootWindow (FRAME_X_DISPLAY (*fp)),
7848
7849 /* The root window which contains the pointer. */
7850 &root,
7851
7852 /* Trash which we can't trust if the pointer is on
7853 a different screen. */
7854 &dummy_window,
7855
7856 /* The position on that root window. */
7857 &root_x, &root_y,
7858
7859 /* More trash we can't trust. */
7860 &dummy, &dummy,
7861
7862 /* Modifier keys and pointer buttons, about which
7863 we don't care. */
7864 (unsigned int *) &dummy);
7865
7866 /* Now we have a position on the root; find the innermost window
7867 containing the pointer. */
7868 {
7869 Window win, child;
7870 int win_x, win_y;
7871 int parent_x = 0, parent_y = 0;
7872 int count;
7873
7874 win = root;
7875
7876 /* XTranslateCoordinates can get errors if the window
7877 structure is changing at the same time this function
7878 is running. So at least we must not crash from them. */
7879
7880 count = x_catch_errors (FRAME_X_DISPLAY (*fp));
7881
7882 if (FRAME_X_DISPLAY_INFO (*fp)->grabbed && last_mouse_frame
7883 && FRAME_LIVE_P (last_mouse_frame))
7884 {
7885 /* If mouse was grabbed on a frame, give coords for that frame
7886 even if the mouse is now outside it. */
7887 XTranslateCoordinates (FRAME_X_DISPLAY (*fp),
7888
7889 /* From-window, to-window. */
7890 root, FRAME_X_WINDOW (last_mouse_frame),
7891
7892 /* From-position, to-position. */
7893 root_x, root_y, &win_x, &win_y,
7894
7895 /* Child of win. */
7896 &child);
7897 f1 = last_mouse_frame;
7898 }
7899 else
7900 {
7901 while (1)
7902 {
7903 XTranslateCoordinates (FRAME_X_DISPLAY (*fp),
7904
7905 /* From-window, to-window. */
7906 root, win,
7907
7908 /* From-position, to-position. */
7909 root_x, root_y, &win_x, &win_y,
7910
7911 /* Child of win. */
7912 &child);
7913
7914 if (child == None || child == win)
7915 break;
7916
7917 win = child;
7918 parent_x = win_x;
7919 parent_y = win_y;
7920 }
7921
7922 /* Now we know that:
7923 win is the innermost window containing the pointer
7924 (XTC says it has no child containing the pointer),
7925 win_x and win_y are the pointer's position in it
7926 (XTC did this the last time through), and
7927 parent_x and parent_y are the pointer's position in win's parent.
7928 (They are what win_x and win_y were when win was child.
7929 If win is the root window, it has no parent, and
7930 parent_{x,y} are invalid, but that's okay, because we'll
7931 never use them in that case.) */
7932
7933 /* Is win one of our frames? */
7934 f1 = x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp), win);
7935
7936 #ifdef USE_X_TOOLKIT
7937 /* If we end up with the menu bar window, say it's not
7938 on the frame. */
7939 if (f1 != NULL
7940 && f1->output_data.x->menubar_widget
7941 && win == XtWindow (f1->output_data.x->menubar_widget))
7942 f1 = NULL;
7943 #endif /* USE_X_TOOLKIT */
7944 }
7945
7946 if (x_had_errors_p (FRAME_X_DISPLAY (*fp)))
7947 f1 = 0;
7948
7949 x_uncatch_errors (FRAME_X_DISPLAY (*fp), count);
7950
7951 /* If not, is it one of our scroll bars? */
7952 if (! f1)
7953 {
7954 struct scroll_bar *bar = x_window_to_scroll_bar (win);
7955
7956 if (bar)
7957 {
7958 f1 = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
7959 win_x = parent_x;
7960 win_y = parent_y;
7961 }
7962 }
7963
7964 if (f1 == 0 && insist > 0)
7965 f1 = SELECTED_FRAME ();
7966
7967 if (f1)
7968 {
7969 /* Ok, we found a frame. Store all the values.
7970 last_mouse_glyph is a rectangle used to reduce the
7971 generation of mouse events. To not miss any motion
7972 events, we must divide the frame into rectangles of the
7973 size of the smallest character that could be displayed
7974 on it, i.e. into the same rectangles that matrices on
7975 the frame are divided into. */
7976
7977 int width, height, gx, gy;
7978 XRectangle rect;
7979
7980 if (glyph_rect (f1, win_x, win_y, &rect))
7981 last_mouse_glyph = rect;
7982 else
7983 {
7984 width = FRAME_SMALLEST_CHAR_WIDTH (f1);
7985 height = FRAME_SMALLEST_FONT_HEIGHT (f1);
7986 gx = win_x;
7987 gy = win_y;
7988
7989 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to
7990 round down even for negative values. */
7991 if (gx < 0)
7992 gx -= width - 1;
7993 if (gy < 0)
7994 gy -= height - 1;
7995 gx = (gx + width - 1) / width * width;
7996 gy = (gy + height - 1) / height * height;
7997
7998 last_mouse_glyph.width = width;
7999 last_mouse_glyph.height = height;
8000 last_mouse_glyph.x = gx;
8001 last_mouse_glyph.y = gy;
8002 }
8003
8004 *bar_window = Qnil;
8005 *part = 0;
8006 *fp = f1;
8007 XSETINT (*x, win_x);
8008 XSETINT (*y, win_y);
8009 *time = last_mouse_movement_time;
8010 }
8011 }
8012 }
8013
8014 UNBLOCK_INPUT;
8015 }
8016
8017
8018 #ifdef USE_X_TOOLKIT
8019
8020 /* Atimer callback function for TIMER. Called every 0.1s to process
8021 Xt timeouts, if needed. We must avoid calling XtAppPending as
8022 much as possible because that function does an implicit XFlush
8023 that slows us down. */
8024
8025 static void
8026 x_process_timeouts (timer)
8027 struct atimer *timer;
8028 {
8029 if (toolkit_scroll_bar_interaction || popup_activated_flag)
8030 {
8031 BLOCK_INPUT;
8032 while (XtAppPending (Xt_app_con) & XtIMTimer)
8033 XtAppProcessEvent (Xt_app_con, XtIMTimer);
8034 UNBLOCK_INPUT;
8035 }
8036 }
8037
8038 #endif /* USE_X_TOOLKIT */
8039
8040 \f
8041 /* Scroll bar support. */
8042
8043 /* Given an X window ID, find the struct scroll_bar which manages it.
8044 This can be called in GC, so we have to make sure to strip off mark
8045 bits. */
8046
8047 static struct scroll_bar *
8048 x_window_to_scroll_bar (window_id)
8049 Window window_id;
8050 {
8051 Lisp_Object tail;
8052
8053 for (tail = Vframe_list;
8054 XGCTYPE (tail) == Lisp_Cons;
8055 tail = XCDR (tail))
8056 {
8057 Lisp_Object frame, bar, condemned;
8058
8059 frame = XCAR (tail);
8060 /* All elements of Vframe_list should be frames. */
8061 if (! GC_FRAMEP (frame))
8062 abort ();
8063
8064 /* Scan this frame's scroll bar list for a scroll bar with the
8065 right window ID. */
8066 condemned = FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame));
8067 for (bar = FRAME_SCROLL_BARS (XFRAME (frame));
8068 /* This trick allows us to search both the ordinary and
8069 condemned scroll bar lists with one loop. */
8070 ! GC_NILP (bar) || (bar = condemned,
8071 condemned = Qnil,
8072 ! GC_NILP (bar));
8073 bar = XSCROLL_BAR (bar)->next)
8074 if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar)) == window_id)
8075 return XSCROLL_BAR (bar);
8076 }
8077
8078 return 0;
8079 }
8080
8081
8082 #if defined USE_X_TOOLKIT && defined USE_LUCID
8083
8084 /* Return the Lucid menu bar WINDOW is part of. Return null
8085 if WINDOW is not part of a menu bar. */
8086
8087 static Widget
8088 x_window_to_menu_bar (window)
8089 Window window;
8090 {
8091 Lisp_Object tail;
8092
8093 for (tail = Vframe_list;
8094 XGCTYPE (tail) == Lisp_Cons;
8095 tail = XCDR (tail))
8096 {
8097 Lisp_Object frame = XCAR (tail);
8098 Widget menu_bar = XFRAME (frame)->output_data.x->menubar_widget;
8099
8100 if (menu_bar && xlwmenu_window_p (menu_bar, window))
8101 return menu_bar;
8102 }
8103
8104 return NULL;
8105 }
8106
8107 #endif /* USE_X_TOOLKIT && USE_LUCID */
8108
8109 \f
8110 /************************************************************************
8111 Toolkit scroll bars
8112 ************************************************************************/
8113
8114 #ifdef USE_TOOLKIT_SCROLL_BARS
8115
8116 static void x_scroll_bar_to_input_event P_ ((XEvent *, struct input_event *));
8117 static void x_send_scroll_bar_event P_ ((Lisp_Object, int, int, int));
8118 static void x_create_toolkit_scroll_bar P_ ((struct frame *,
8119 struct scroll_bar *));
8120 static void x_set_toolkit_scroll_bar_thumb P_ ((struct scroll_bar *,
8121 int, int, int));
8122
8123
8124 /* Id of action hook installed for scroll bars. */
8125
8126 static XtActionHookId action_hook_id;
8127
8128 /* Lisp window being scrolled. Set when starting to interact with
8129 a toolkit scroll bar, reset to nil when ending the interaction. */
8130
8131 static Lisp_Object window_being_scrolled;
8132
8133 /* Last scroll bar part sent in xm_scroll_callback. */
8134
8135 static int last_scroll_bar_part;
8136
8137 /* Whether this is an Xaw with arrow-scrollbars. This should imply
8138 that movements of 1/20 of the screen size are mapped to up/down. */
8139
8140 static Boolean xaw3d_arrow_scroll;
8141
8142 /* Whether the drag scrolling maintains the mouse at the top of the
8143 thumb. If not, resizing the thumb needs to be done more carefully
8144 to avoid jerkyness. */
8145
8146 static Boolean xaw3d_pick_top;
8147
8148
8149 /* Action hook installed via XtAppAddActionHook when toolkit scroll
8150 bars are used.. The hook is responsible for detecting when
8151 the user ends an interaction with the scroll bar, and generates
8152 a `end-scroll' scroll_bar_click' event if so. */
8153
8154 static void
8155 xt_action_hook (widget, client_data, action_name, event, params,
8156 num_params)
8157 Widget widget;
8158 XtPointer client_data;
8159 String action_name;
8160 XEvent *event;
8161 String *params;
8162 Cardinal *num_params;
8163 {
8164 int scroll_bar_p;
8165 char *end_action;
8166
8167 #ifdef USE_MOTIF
8168 scroll_bar_p = XmIsScrollBar (widget);
8169 end_action = "Release";
8170 #else /* !USE_MOTIF i.e. use Xaw */
8171 scroll_bar_p = XtIsSubclass (widget, scrollbarWidgetClass);
8172 end_action = "EndScroll";
8173 #endif /* USE_MOTIF */
8174
8175 if (scroll_bar_p
8176 && strcmp (action_name, end_action) == 0
8177 && WINDOWP (window_being_scrolled))
8178 {
8179 struct window *w;
8180
8181 x_send_scroll_bar_event (window_being_scrolled,
8182 scroll_bar_end_scroll, 0, 0);
8183 w = XWINDOW (window_being_scrolled);
8184 XSCROLL_BAR (w->vertical_scroll_bar)->dragging = Qnil;
8185 window_being_scrolled = Qnil;
8186 last_scroll_bar_part = -1;
8187
8188 /* Xt timeouts no longer needed. */
8189 toolkit_scroll_bar_interaction = 0;
8190 }
8191 }
8192
8193 /* A vector of windows used for communication between
8194 x_send_scroll_bar_event and x_scroll_bar_to_input_event. */
8195
8196 static struct window **scroll_bar_windows;
8197 static int scroll_bar_windows_size;
8198
8199
8200 /* Send a client message with message type Xatom_Scrollbar for a
8201 scroll action to the frame of WINDOW. PART is a value identifying
8202 the part of the scroll bar that was clicked on. PORTION is the
8203 amount to scroll of a whole of WHOLE. */
8204
8205 static void
8206 x_send_scroll_bar_event (window, part, portion, whole)
8207 Lisp_Object window;
8208 int part, portion, whole;
8209 {
8210 XEvent event;
8211 XClientMessageEvent *ev = (XClientMessageEvent *) &event;
8212 struct window *w = XWINDOW (window);
8213 struct frame *f = XFRAME (w->frame);
8214 int i;
8215
8216 BLOCK_INPUT;
8217
8218 /* Construct a ClientMessage event to send to the frame. */
8219 ev->type = ClientMessage;
8220 ev->message_type = FRAME_X_DISPLAY_INFO (f)->Xatom_Scrollbar;
8221 ev->display = FRAME_X_DISPLAY (f);
8222 ev->window = FRAME_X_WINDOW (f);
8223 ev->format = 32;
8224
8225 /* We can only transfer 32 bits in the XClientMessageEvent, which is
8226 not enough to store a pointer or Lisp_Object on a 64 bit system.
8227 So, store the window in scroll_bar_windows and pass the index
8228 into that array in the event. */
8229 for (i = 0; i < scroll_bar_windows_size; ++i)
8230 if (scroll_bar_windows[i] == NULL)
8231 break;
8232
8233 if (i == scroll_bar_windows_size)
8234 {
8235 int new_size = max (10, 2 * scroll_bar_windows_size);
8236 size_t nbytes = new_size * sizeof *scroll_bar_windows;
8237 size_t old_nbytes = scroll_bar_windows_size * sizeof *scroll_bar_windows;
8238
8239 scroll_bar_windows = (struct window **) xrealloc (scroll_bar_windows,
8240 nbytes);
8241 bzero (&scroll_bar_windows[i], nbytes - old_nbytes);
8242 scroll_bar_windows_size = new_size;
8243 }
8244
8245 scroll_bar_windows[i] = w;
8246 ev->data.l[0] = (long) i;
8247 ev->data.l[1] = (long) part;
8248 ev->data.l[2] = (long) 0;
8249 ev->data.l[3] = (long) portion;
8250 ev->data.l[4] = (long) whole;
8251
8252 /* Make Xt timeouts work while the scroll bar is active. */
8253 toolkit_scroll_bar_interaction = 1;
8254
8255 /* Setting the event mask to zero means that the message will
8256 be sent to the client that created the window, and if that
8257 window no longer exists, no event will be sent. */
8258 XSendEvent (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), False, 0, &event);
8259 UNBLOCK_INPUT;
8260 }
8261
8262
8263 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
8264 in *IEVENT. */
8265
8266 static void
8267 x_scroll_bar_to_input_event (event, ievent)
8268 XEvent *event;
8269 struct input_event *ievent;
8270 {
8271 XClientMessageEvent *ev = (XClientMessageEvent *) event;
8272 Lisp_Object window;
8273 struct frame *f;
8274 struct window *w;
8275
8276 w = scroll_bar_windows[ev->data.l[0]];
8277 scroll_bar_windows[ev->data.l[0]] = NULL;
8278
8279 XSETWINDOW (window, w);
8280 f = XFRAME (w->frame);
8281
8282 ievent->kind = scroll_bar_click;
8283 ievent->frame_or_window = window;
8284 ievent->arg = Qnil;
8285 ievent->timestamp = XtLastTimestampProcessed (FRAME_X_DISPLAY (f));
8286 ievent->part = ev->data.l[1];
8287 ievent->code = ev->data.l[2];
8288 ievent->x = make_number ((int) ev->data.l[3]);
8289 ievent->y = make_number ((int) ev->data.l[4]);
8290 ievent->modifiers = 0;
8291 }
8292
8293
8294 #ifdef USE_MOTIF
8295
8296 /* Minimum and maximum values used for Motif scroll bars. */
8297
8298 #define XM_SB_MIN 1
8299 #define XM_SB_MAX 10000000
8300 #define XM_SB_RANGE (XM_SB_MAX - XM_SB_MIN)
8301
8302
8303 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
8304 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
8305 CALL_DATA is a pointer a a XmScrollBarCallbackStruct. */
8306
8307 static void
8308 xm_scroll_callback (widget, client_data, call_data)
8309 Widget widget;
8310 XtPointer client_data, call_data;
8311 {
8312 struct scroll_bar *bar = (struct scroll_bar *) client_data;
8313 XmScrollBarCallbackStruct *cs = (XmScrollBarCallbackStruct *) call_data;
8314 double percent;
8315 int part = -1, whole = 0, portion = 0;
8316
8317 switch (cs->reason)
8318 {
8319 case XmCR_DECREMENT:
8320 bar->dragging = Qnil;
8321 part = scroll_bar_up_arrow;
8322 break;
8323
8324 case XmCR_INCREMENT:
8325 bar->dragging = Qnil;
8326 part = scroll_bar_down_arrow;
8327 break;
8328
8329 case XmCR_PAGE_DECREMENT:
8330 bar->dragging = Qnil;
8331 part = scroll_bar_above_handle;
8332 break;
8333
8334 case XmCR_PAGE_INCREMENT:
8335 bar->dragging = Qnil;
8336 part = scroll_bar_below_handle;
8337 break;
8338
8339 case XmCR_TO_TOP:
8340 bar->dragging = Qnil;
8341 part = scroll_bar_to_top;
8342 break;
8343
8344 case XmCR_TO_BOTTOM:
8345 bar->dragging = Qnil;
8346 part = scroll_bar_to_bottom;
8347 break;
8348
8349 case XmCR_DRAG:
8350 {
8351 int slider_size;
8352 int dragging_down_p = (INTEGERP (bar->dragging)
8353 && XINT (bar->dragging) <= cs->value);
8354
8355 /* Get the slider size. */
8356 BLOCK_INPUT;
8357 XtVaGetValues (widget, XmNsliderSize, &slider_size, NULL);
8358 UNBLOCK_INPUT;
8359
8360 /* At the max position of the scroll bar, do a line-wise
8361 movement. Without doing anything, we would be called with
8362 the same cs->value again and again. If we want to make
8363 sure that we can reach the end of the buffer, we have to do
8364 something.
8365
8366 Implementation note: setting bar->dragging always to
8367 cs->value gives a smoother movement at the max position.
8368 Setting it to nil when doing line-wise movement gives
8369 a better slider behavior. */
8370
8371 if (cs->value + slider_size == XM_SB_MAX
8372 || (dragging_down_p
8373 && last_scroll_bar_part == scroll_bar_down_arrow))
8374 {
8375 part = scroll_bar_down_arrow;
8376 bar->dragging = Qnil;
8377 }
8378 else
8379 {
8380 whole = XM_SB_RANGE;
8381 portion = min (cs->value - XM_SB_MIN, XM_SB_MAX - slider_size);
8382 part = scroll_bar_handle;
8383 bar->dragging = make_number (cs->value);
8384 }
8385 }
8386 break;
8387
8388 case XmCR_VALUE_CHANGED:
8389 break;
8390 };
8391
8392 if (part >= 0)
8393 {
8394 window_being_scrolled = bar->window;
8395 last_scroll_bar_part = part;
8396 x_send_scroll_bar_event (bar->window, part, portion, whole);
8397 }
8398 }
8399
8400
8401 #else /* !USE_MOTIF, i.e. Xaw. */
8402
8403
8404 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
8405 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
8406 scroll bar struct. CALL_DATA is a pointer to a float saying where
8407 the thumb is. */
8408
8409 static void
8410 xaw_jump_callback (widget, client_data, call_data)
8411 Widget widget;
8412 XtPointer client_data, call_data;
8413 {
8414 struct scroll_bar *bar = (struct scroll_bar *) client_data;
8415 float top = *(float *) call_data;
8416 float shown;
8417 int whole, portion, height;
8418 int part;
8419
8420 /* Get the size of the thumb, a value between 0 and 1. */
8421 BLOCK_INPUT;
8422 XtVaGetValues (widget, XtNshown, &shown, XtNheight, &height, NULL);
8423 UNBLOCK_INPUT;
8424
8425 whole = 10000000;
8426 portion = shown < 1 ? top * whole : 0;
8427
8428 if (shown < 1 && (abs (top + shown - 1) < 1.0/height))
8429 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
8430 the bottom, so we force the scrolling whenever we see that we're
8431 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
8432 we try to ensure that we always stay two pixels away from the
8433 bottom). */
8434 part = scroll_bar_down_arrow;
8435 else
8436 part = scroll_bar_handle;
8437
8438 window_being_scrolled = bar->window;
8439 bar->dragging = make_number (portion);
8440 last_scroll_bar_part = part;
8441 x_send_scroll_bar_event (bar->window, part, portion, whole);
8442 }
8443
8444
8445 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
8446 i.e. line or page up or down. WIDGET is the Xaw scroll bar
8447 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
8448 the scroll bar. CALL_DATA is an integer specifying the action that
8449 has taken place. It's magnitude is in the range 0..height of the
8450 scroll bar. Negative values mean scroll towards buffer start.
8451 Values < height of scroll bar mean line-wise movement. */
8452
8453 static void
8454 xaw_scroll_callback (widget, client_data, call_data)
8455 Widget widget;
8456 XtPointer client_data, call_data;
8457 {
8458 struct scroll_bar *bar = (struct scroll_bar *) client_data;
8459 int position = (int) call_data;
8460 Dimension height;
8461 int part;
8462
8463 /* Get the height of the scroll bar. */
8464 BLOCK_INPUT;
8465 XtVaGetValues (widget, XtNheight, &height, NULL);
8466 UNBLOCK_INPUT;
8467
8468 if (abs (position) >= height)
8469 part = (position < 0) ? scroll_bar_above_handle : scroll_bar_below_handle;
8470
8471 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
8472 it maps line-movement to call_data = max(5, height/20). */
8473 else if (xaw3d_arrow_scroll && abs (position) <= max (5, height / 20))
8474 part = (position < 0) ? scroll_bar_up_arrow : scroll_bar_down_arrow;
8475 else
8476 part = scroll_bar_move_ratio;
8477
8478 window_being_scrolled = bar->window;
8479 bar->dragging = Qnil;
8480 last_scroll_bar_part = part;
8481 x_send_scroll_bar_event (bar->window, part, position, height);
8482 }
8483
8484
8485 #endif /* not USE_MOTIF */
8486
8487
8488 /* Create the widget for scroll bar BAR on frame F. Record the widget
8489 and X window of the scroll bar in BAR. */
8490
8491 static void
8492 x_create_toolkit_scroll_bar (f, bar)
8493 struct frame *f;
8494 struct scroll_bar *bar;
8495 {
8496 Window xwindow;
8497 Widget widget;
8498 Arg av[20];
8499 int ac = 0;
8500 char *scroll_bar_name = "verticalScrollBar";
8501 unsigned long pixel;
8502
8503 BLOCK_INPUT;
8504
8505 #ifdef USE_MOTIF
8506 /* Set resources. Create the widget. */
8507 XtSetArg (av[ac], XtNmappedWhenManaged, False); ++ac;
8508 XtSetArg (av[ac], XmNminimum, XM_SB_MIN); ++ac;
8509 XtSetArg (av[ac], XmNmaximum, XM_SB_MAX); ++ac;
8510 XtSetArg (av[ac], XmNorientation, XmVERTICAL); ++ac;
8511 XtSetArg (av[ac], XmNprocessingDirection, XmMAX_ON_BOTTOM), ++ac;
8512 XtSetArg (av[ac], XmNincrement, 1); ++ac;
8513 XtSetArg (av[ac], XmNpageIncrement, 1); ++ac;
8514
8515 pixel = f->output_data.x->scroll_bar_foreground_pixel;
8516 if (pixel != -1)
8517 {
8518 XtSetArg (av[ac], XmNforeground, pixel);
8519 ++ac;
8520 }
8521
8522 pixel = f->output_data.x->scroll_bar_background_pixel;
8523 if (pixel != -1)
8524 {
8525 XtSetArg (av[ac], XmNbackground, pixel);
8526 ++ac;
8527 }
8528
8529 widget = XmCreateScrollBar (f->output_data.x->edit_widget,
8530 scroll_bar_name, av, ac);
8531
8532 /* Add one callback for everything that can happen. */
8533 XtAddCallback (widget, XmNdecrementCallback, xm_scroll_callback,
8534 (XtPointer) bar);
8535 XtAddCallback (widget, XmNdragCallback, xm_scroll_callback,
8536 (XtPointer) bar);
8537 XtAddCallback (widget, XmNincrementCallback, xm_scroll_callback,
8538 (XtPointer) bar);
8539 XtAddCallback (widget, XmNpageDecrementCallback, xm_scroll_callback,
8540 (XtPointer) bar);
8541 XtAddCallback (widget, XmNpageIncrementCallback, xm_scroll_callback,
8542 (XtPointer) bar);
8543 XtAddCallback (widget, XmNtoBottomCallback, xm_scroll_callback,
8544 (XtPointer) bar);
8545 XtAddCallback (widget, XmNtoTopCallback, xm_scroll_callback,
8546 (XtPointer) bar);
8547
8548 /* Realize the widget. Only after that is the X window created. */
8549 XtRealizeWidget (widget);
8550
8551 /* Set the cursor to an arrow. I didn't find a resource to do that.
8552 And I'm wondering why it hasn't an arrow cursor by default. */
8553 XDefineCursor (XtDisplay (widget), XtWindow (widget),
8554 f->output_data.x->nontext_cursor);
8555
8556 #else /* !USE_MOTIF i.e. use Xaw */
8557
8558 /* Set resources. Create the widget. The background of the
8559 Xaw3d scroll bar widget is a little bit light for my taste.
8560 We don't alter it here to let users change it according
8561 to their taste with `emacs*verticalScrollBar.background: xxx'. */
8562 XtSetArg (av[ac], XtNmappedWhenManaged, False); ++ac;
8563 XtSetArg (av[ac], XtNorientation, XtorientVertical); ++ac;
8564 /* For smoother scrolling with Xaw3d -sm */
8565 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
8566 /* XtSetArg (av[ac], XtNbeNiceToColormap, True); ++ac; */
8567
8568 pixel = f->output_data.x->scroll_bar_foreground_pixel;
8569 if (pixel != -1)
8570 {
8571 XtSetArg (av[ac], XtNforeground, pixel);
8572 ++ac;
8573 }
8574
8575 pixel = f->output_data.x->scroll_bar_background_pixel;
8576 if (pixel != -1)
8577 {
8578 XtSetArg (av[ac], XtNbackground, pixel);
8579 ++ac;
8580 }
8581
8582 widget = XtCreateWidget (scroll_bar_name, scrollbarWidgetClass,
8583 f->output_data.x->edit_widget, av, ac);
8584
8585 {
8586 char *initial = "";
8587 char *val = initial;
8588 XtVaGetValues (widget, XtNscrollVCursor, (XtPointer) &val,
8589 XtNpickTop, (XtPointer) &xaw3d_pick_top, NULL);
8590 if (val == initial)
8591 { /* ARROW_SCROLL */
8592 xaw3d_arrow_scroll = True;
8593 /* Isn't that just a personal preference ? -sm */
8594 XtVaSetValues (widget, XtNcursorName, "top_left_arrow", NULL);
8595 }
8596 }
8597
8598 /* Define callbacks. */
8599 XtAddCallback (widget, XtNjumpProc, xaw_jump_callback, (XtPointer) bar);
8600 XtAddCallback (widget, XtNscrollProc, xaw_scroll_callback,
8601 (XtPointer) bar);
8602
8603 /* Realize the widget. Only after that is the X window created. */
8604 XtRealizeWidget (widget);
8605
8606 #endif /* !USE_MOTIF */
8607
8608 /* Install an action hook that let's us detect when the user
8609 finishes interacting with a scroll bar. */
8610 if (action_hook_id == 0)
8611 action_hook_id = XtAppAddActionHook (Xt_app_con, xt_action_hook, 0);
8612
8613 /* Remember X window and widget in the scroll bar vector. */
8614 SET_SCROLL_BAR_X_WIDGET (bar, widget);
8615 xwindow = XtWindow (widget);
8616 SET_SCROLL_BAR_X_WINDOW (bar, xwindow);
8617
8618 UNBLOCK_INPUT;
8619 }
8620
8621
8622 /* Set the thumb size and position of scroll bar BAR. We are currently
8623 displaying PORTION out of a whole WHOLE, and our position POSITION. */
8624
8625 static void
8626 x_set_toolkit_scroll_bar_thumb (bar, portion, position, whole)
8627 struct scroll_bar *bar;
8628 int portion, position, whole;
8629 {
8630 struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
8631 Widget widget = SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar);
8632 float top, shown;
8633
8634 if (whole == 0)
8635 top = 0, shown = 1;
8636 else
8637 {
8638 top = (float) position / whole;
8639 shown = (float) portion / whole;
8640 }
8641
8642 BLOCK_INPUT;
8643
8644 #ifdef USE_MOTIF
8645 {
8646 int size, value;
8647 XmScrollBarWidget sb;
8648
8649 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
8650 is the scroll bar's maximum and MIN is the scroll bar's minimum
8651 value. */
8652 size = shown * XM_SB_RANGE;
8653 size = min (size, XM_SB_RANGE);
8654 size = max (size, 1);
8655
8656 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
8657 value = top * XM_SB_RANGE;
8658 value = min (value, XM_SB_MAX - size);
8659 value = max (value, XM_SB_MIN);
8660
8661 if (NILP (bar->dragging))
8662 XmScrollBarSetValues (widget, value, size, 0, 0, False);
8663 else if (last_scroll_bar_part == scroll_bar_down_arrow)
8664 /* This has the negative side effect that the slider value is
8665 not what it would be if we scrolled here using line-wise or
8666 page-wise movement. */
8667 XmScrollBarSetValues (widget, value, XM_SB_RANGE - value, 0, 0, False);
8668 else
8669 {
8670 /* If currently dragging, only update the slider size.
8671 This reduces flicker effects. */
8672 int old_value, old_size, increment, page_increment;
8673
8674 XmScrollBarGetValues (widget, &old_value, &old_size,
8675 &increment, &page_increment);
8676 XmScrollBarSetValues (widget, old_value,
8677 min (size, XM_SB_RANGE - old_value),
8678 0, 0, False);
8679 }
8680 }
8681 #else /* !USE_MOTIF i.e. use Xaw */
8682 {
8683 float old_top, old_shown;
8684 Dimension height;
8685 XtVaGetValues (widget,
8686 XtNtopOfThumb, &old_top,
8687 XtNshown, &old_shown,
8688 XtNheight, &height,
8689 NULL);
8690
8691 /* Massage the top+shown values. */
8692 if (NILP (bar->dragging) || last_scroll_bar_part == scroll_bar_down_arrow)
8693 top = max (0, min (1, top));
8694 else
8695 top = old_top;
8696 /* Keep two pixels available for moving the thumb down. */
8697 shown = max (0, min (1 - top - (2.0 / height), shown));
8698
8699 /* If the call to XawScrollbarSetThumb below doesn't seem to work,
8700 check that your system's configuration file contains a define
8701 for `NARROWPROTO'. See s/freebsd.h for an example. */
8702 if (top != old_top || shown != old_shown)
8703 {
8704 if (NILP (bar->dragging))
8705 XawScrollbarSetThumb (widget, top, shown);
8706 else
8707 {
8708 #ifdef HAVE_XAW3D
8709 ScrollbarWidget sb = (ScrollbarWidget) widget;
8710 int scroll_mode = 0;
8711
8712 /* `scroll_mode' only exists with Xaw3d + ARROW_SCROLLBAR. */
8713 if (xaw3d_arrow_scroll)
8714 {
8715 /* Xaw3d stupidly ignores resize requests while dragging
8716 so we have to make it believe it's not in dragging mode. */
8717 scroll_mode = sb->scrollbar.scroll_mode;
8718 if (scroll_mode == 2)
8719 sb->scrollbar.scroll_mode = 0;
8720 }
8721 #endif
8722 /* Try to make the scrolling a tad smoother. */
8723 if (!xaw3d_pick_top)
8724 shown = min (shown, old_shown);
8725
8726 XawScrollbarSetThumb (widget, top, shown);
8727
8728 #ifdef HAVE_XAW3D
8729 if (xaw3d_arrow_scroll && scroll_mode == 2)
8730 sb->scrollbar.scroll_mode = scroll_mode;
8731 #endif
8732 }
8733 }
8734 }
8735 #endif /* !USE_MOTIF */
8736
8737 UNBLOCK_INPUT;
8738 }
8739
8740 #endif /* USE_TOOLKIT_SCROLL_BARS */
8741
8742
8743 \f
8744 /************************************************************************
8745 Scroll bars, general
8746 ************************************************************************/
8747
8748 /* Create a scroll bar and return the scroll bar vector for it. W is
8749 the Emacs window on which to create the scroll bar. TOP, LEFT,
8750 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
8751 scroll bar. */
8752
8753 static struct scroll_bar *
8754 x_scroll_bar_create (w, top, left, width, height)
8755 struct window *w;
8756 int top, left, width, height;
8757 {
8758 struct frame *f = XFRAME (w->frame);
8759 struct scroll_bar *bar
8760 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE), Qnil));
8761
8762 BLOCK_INPUT;
8763
8764 #ifdef USE_TOOLKIT_SCROLL_BARS
8765 x_create_toolkit_scroll_bar (f, bar);
8766 #else /* not USE_TOOLKIT_SCROLL_BARS */
8767 {
8768 XSetWindowAttributes a;
8769 unsigned long mask;
8770 Window window;
8771
8772 a.background_pixel = f->output_data.x->scroll_bar_background_pixel;
8773 if (a.background_pixel == -1)
8774 a.background_pixel = f->output_data.x->background_pixel;
8775
8776 a.event_mask = (ButtonPressMask | ButtonReleaseMask
8777 | ButtonMotionMask | PointerMotionHintMask
8778 | ExposureMask);
8779 a.cursor = FRAME_X_DISPLAY_INFO (f)->vertical_scroll_bar_cursor;
8780
8781 mask = (CWBackPixel | CWEventMask | CWCursor);
8782
8783 /* Clear the area of W that will serve as a scroll bar. This is
8784 for the case that a window has been split horizontally. In
8785 this case, no clear_frame is generated to reduce flickering. */
8786 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
8787 left, top, width,
8788 window_box_height (w), False);
8789
8790 window = XCreateWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
8791 /* Position and size of scroll bar. */
8792 left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
8793 top,
8794 width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
8795 height,
8796 /* Border width, depth, class, and visual. */
8797 0,
8798 CopyFromParent,
8799 CopyFromParent,
8800 CopyFromParent,
8801 /* Attributes. */
8802 mask, &a);
8803 SET_SCROLL_BAR_X_WINDOW (bar, window);
8804 }
8805 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8806
8807 XSETWINDOW (bar->window, w);
8808 XSETINT (bar->top, top);
8809 XSETINT (bar->left, left);
8810 XSETINT (bar->width, width);
8811 XSETINT (bar->height, height);
8812 XSETINT (bar->start, 0);
8813 XSETINT (bar->end, 0);
8814 bar->dragging = Qnil;
8815
8816 /* Add bar to its frame's list of scroll bars. */
8817 bar->next = FRAME_SCROLL_BARS (f);
8818 bar->prev = Qnil;
8819 XSETVECTOR (FRAME_SCROLL_BARS (f), bar);
8820 if (!NILP (bar->next))
8821 XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
8822
8823 /* Map the window/widget. */
8824 #ifdef USE_TOOLKIT_SCROLL_BARS
8825 {
8826 Widget scroll_bar = SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar);
8827 XtConfigureWidget (scroll_bar,
8828 left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
8829 top,
8830 width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
8831 max (height, 1), 0);
8832 XtMapWidget (scroll_bar);
8833 }
8834 #else /* not USE_TOOLKIT_SCROLL_BARS */
8835 XMapRaised (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (bar));
8836 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8837
8838 UNBLOCK_INPUT;
8839 return bar;
8840 }
8841
8842
8843 /* Draw BAR's handle in the proper position.
8844
8845 If the handle is already drawn from START to END, don't bother
8846 redrawing it, unless REBUILD is non-zero; in that case, always
8847 redraw it. (REBUILD is handy for drawing the handle after expose
8848 events.)
8849
8850 Normally, we want to constrain the start and end of the handle to
8851 fit inside its rectangle, but if the user is dragging the scroll
8852 bar handle, we want to let them drag it down all the way, so that
8853 the bar's top is as far down as it goes; otherwise, there's no way
8854 to move to the very end of the buffer. */
8855
8856 #ifndef USE_TOOLKIT_SCROLL_BARS
8857
8858 static void
8859 x_scroll_bar_set_handle (bar, start, end, rebuild)
8860 struct scroll_bar *bar;
8861 int start, end;
8862 int rebuild;
8863 {
8864 int dragging = ! NILP (bar->dragging);
8865 Window w = SCROLL_BAR_X_WINDOW (bar);
8866 FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
8867 GC gc = f->output_data.x->normal_gc;
8868
8869 /* If the display is already accurate, do nothing. */
8870 if (! rebuild
8871 && start == XINT (bar->start)
8872 && end == XINT (bar->end))
8873 return;
8874
8875 BLOCK_INPUT;
8876
8877 {
8878 int inside_width = VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f, XINT (bar->width));
8879 int inside_height = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f, XINT (bar->height));
8880 int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
8881
8882 /* Make sure the values are reasonable, and try to preserve
8883 the distance between start and end. */
8884 {
8885 int length = end - start;
8886
8887 if (start < 0)
8888 start = 0;
8889 else if (start > top_range)
8890 start = top_range;
8891 end = start + length;
8892
8893 if (end < start)
8894 end = start;
8895 else if (end > top_range && ! dragging)
8896 end = top_range;
8897 }
8898
8899 /* Store the adjusted setting in the scroll bar. */
8900 XSETINT (bar->start, start);
8901 XSETINT (bar->end, end);
8902
8903 /* Clip the end position, just for display. */
8904 if (end > top_range)
8905 end = top_range;
8906
8907 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
8908 below top positions, to make sure the handle is always at least
8909 that many pixels tall. */
8910 end += VERTICAL_SCROLL_BAR_MIN_HANDLE;
8911
8912 /* Draw the empty space above the handle. Note that we can't clear
8913 zero-height areas; that means "clear to end of window." */
8914 if (0 < start)
8915 x_clear_area (FRAME_X_DISPLAY (f), w,
8916 /* x, y, width, height, and exposures. */
8917 VERTICAL_SCROLL_BAR_LEFT_BORDER,
8918 VERTICAL_SCROLL_BAR_TOP_BORDER,
8919 inside_width, start,
8920 False);
8921
8922 /* Change to proper foreground color if one is specified. */
8923 if (f->output_data.x->scroll_bar_foreground_pixel != -1)
8924 XSetForeground (FRAME_X_DISPLAY (f), gc,
8925 f->output_data.x->scroll_bar_foreground_pixel);
8926
8927 /* Draw the handle itself. */
8928 XFillRectangle (FRAME_X_DISPLAY (f), w, gc,
8929 /* x, y, width, height */
8930 VERTICAL_SCROLL_BAR_LEFT_BORDER,
8931 VERTICAL_SCROLL_BAR_TOP_BORDER + start,
8932 inside_width, end - start);
8933
8934 /* Restore the foreground color of the GC if we changed it above. */
8935 if (f->output_data.x->scroll_bar_foreground_pixel != -1)
8936 XSetForeground (FRAME_X_DISPLAY (f), gc,
8937 f->output_data.x->foreground_pixel);
8938
8939 /* Draw the empty space below the handle. Note that we can't
8940 clear zero-height areas; that means "clear to end of window." */
8941 if (end < inside_height)
8942 x_clear_area (FRAME_X_DISPLAY (f), w,
8943 /* x, y, width, height, and exposures. */
8944 VERTICAL_SCROLL_BAR_LEFT_BORDER,
8945 VERTICAL_SCROLL_BAR_TOP_BORDER + end,
8946 inside_width, inside_height - end,
8947 False);
8948
8949 }
8950
8951 UNBLOCK_INPUT;
8952 }
8953
8954 #endif /* !USE_TOOLKIT_SCROLL_BARS */
8955
8956 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
8957 nil. */
8958
8959 static void
8960 x_scroll_bar_remove (bar)
8961 struct scroll_bar *bar;
8962 {
8963 struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
8964 BLOCK_INPUT;
8965
8966 #ifdef USE_TOOLKIT_SCROLL_BARS
8967 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar));
8968 #else
8969 XDestroyWindow (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (bar));
8970 #endif
8971
8972 /* Disassociate this scroll bar from its window. */
8973 XWINDOW (bar->window)->vertical_scroll_bar = Qnil;
8974
8975 UNBLOCK_INPUT;
8976 }
8977
8978
8979 /* Set the handle of the vertical scroll bar for WINDOW to indicate
8980 that we are displaying PORTION characters out of a total of WHOLE
8981 characters, starting at POSITION. If WINDOW has no scroll bar,
8982 create one. */
8983
8984 static void
8985 XTset_vertical_scroll_bar (w, portion, whole, position)
8986 struct window *w;
8987 int portion, whole, position;
8988 {
8989 struct frame *f = XFRAME (w->frame);
8990 struct scroll_bar *bar;
8991 int top, height, left, sb_left, width, sb_width;
8992 int window_x, window_y, window_width, window_height;
8993
8994 /* Get window dimensions. */
8995 window_box (w, -1, &window_x, &window_y, &window_width, &window_height);
8996 top = window_y;
8997 width = FRAME_SCROLL_BAR_COLS (f) * CANON_X_UNIT (f);
8998 height = window_height;
8999
9000 /* Compute the left edge of the scroll bar area. */
9001 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
9002 left = XINT (w->left) + XINT (w->width) - FRAME_SCROLL_BAR_COLS (f);
9003 else
9004 left = XFASTINT (w->left);
9005 left *= CANON_X_UNIT (f);
9006 left += FRAME_INTERNAL_BORDER_WIDTH (f);
9007
9008 /* Compute the width of the scroll bar which might be less than
9009 the width of the area reserved for the scroll bar. */
9010 if (FRAME_SCROLL_BAR_PIXEL_WIDTH (f) > 0)
9011 sb_width = FRAME_SCROLL_BAR_PIXEL_WIDTH (f);
9012 else
9013 sb_width = width;
9014
9015 /* Compute the left edge of the scroll bar. */
9016 #ifdef USE_TOOLKIT_SCROLL_BARS
9017 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
9018 sb_left = left + width - sb_width - (width - sb_width) / 2;
9019 else
9020 sb_left = left + (width - sb_width) / 2;
9021 #else
9022 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
9023 sb_left = left + width - sb_width;
9024 else
9025 sb_left = left;
9026 #endif
9027
9028 /* Does the scroll bar exist yet? */
9029 if (NILP (w->vertical_scroll_bar))
9030 {
9031 BLOCK_INPUT;
9032 if (width && height)
9033 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
9034 left, top, width, height, False);
9035 UNBLOCK_INPUT;
9036 bar = x_scroll_bar_create (w, top, sb_left, sb_width, height);
9037 }
9038 else
9039 {
9040 /* It may just need to be moved and resized. */
9041 unsigned int mask = 0;
9042
9043 bar = XSCROLL_BAR (w->vertical_scroll_bar);
9044
9045 BLOCK_INPUT;
9046
9047 if (sb_left != XINT (bar->left))
9048 mask |= CWX;
9049 if (top != XINT (bar->top))
9050 mask |= CWY;
9051 if (sb_width != XINT (bar->width))
9052 mask |= CWWidth;
9053 if (height != XINT (bar->height))
9054 mask |= CWHeight;
9055
9056 #ifdef USE_TOOLKIT_SCROLL_BARS
9057
9058 /* Since toolkit scroll bars are smaller than the space reserved
9059 for them on the frame, we have to clear "under" them. */
9060 if (width && height)
9061 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
9062 left, top, width, height, False);
9063
9064 /* Move/size the scroll bar widget. */
9065 if (mask)
9066 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar),
9067 sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
9068 top,
9069 sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
9070 max (height, 1), 0);
9071
9072 #else /* not USE_TOOLKIT_SCROLL_BARS */
9073
9074 /* Clear areas not covered by the scroll bar because of
9075 VERTICAL_SCROLL_BAR_WIDTH_TRIM. */
9076 if (VERTICAL_SCROLL_BAR_WIDTH_TRIM)
9077 {
9078 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
9079 left, top, VERTICAL_SCROLL_BAR_WIDTH_TRIM,
9080 height, False);
9081 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
9082 left + width - VERTICAL_SCROLL_BAR_WIDTH_TRIM,
9083 top, VERTICAL_SCROLL_BAR_WIDTH_TRIM,
9084 height, False);
9085 }
9086
9087 /* Clear areas not covered by the scroll bar because it's not as
9088 wide as the area reserved for it . This makes sure a
9089 previous mode line display is cleared after C-x 2 C-x 1, for
9090 example. */
9091 {
9092 int area_width = FRAME_SCROLL_BAR_COLS (f) * CANON_X_UNIT (f);
9093 int rest = area_width - sb_width;
9094 if (rest > 0)
9095 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
9096 left + area_width - rest, 0,
9097 rest, max (height, 1), False);
9098 }
9099
9100 /* Move/size the scroll bar window. */
9101 if (mask)
9102 {
9103 XWindowChanges wc;
9104
9105 wc.x = sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM;
9106 wc.y = top;
9107 wc.width = sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2;
9108 wc.height = height;
9109 XConfigureWindow (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (bar),
9110 mask, &wc);
9111 }
9112
9113 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9114
9115 /* Remember new settings. */
9116 XSETINT (bar->left, sb_left);
9117 XSETINT (bar->top, top);
9118 XSETINT (bar->width, sb_width);
9119 XSETINT (bar->height, height);
9120
9121 UNBLOCK_INPUT;
9122 }
9123
9124 #ifdef USE_TOOLKIT_SCROLL_BARS
9125 x_set_toolkit_scroll_bar_thumb (bar, portion, position, whole);
9126 #else /* not USE_TOOLKIT_SCROLL_BARS */
9127 /* Set the scroll bar's current state, unless we're currently being
9128 dragged. */
9129 if (NILP (bar->dragging))
9130 {
9131 int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height);
9132
9133 if (whole == 0)
9134 x_scroll_bar_set_handle (bar, 0, top_range, 0);
9135 else
9136 {
9137 int start = ((double) position * top_range) / whole;
9138 int end = ((double) (position + portion) * top_range) / whole;
9139 x_scroll_bar_set_handle (bar, start, end, 0);
9140 }
9141 }
9142 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9143
9144 XSETVECTOR (w->vertical_scroll_bar, bar);
9145 }
9146
9147
9148 /* The following three hooks are used when we're doing a thorough
9149 redisplay of the frame. We don't explicitly know which scroll bars
9150 are going to be deleted, because keeping track of when windows go
9151 away is a real pain - "Can you say set-window-configuration, boys
9152 and girls?" Instead, we just assert at the beginning of redisplay
9153 that *all* scroll bars are to be removed, and then save a scroll bar
9154 from the fiery pit when we actually redisplay its window. */
9155
9156 /* Arrange for all scroll bars on FRAME to be removed at the next call
9157 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
9158 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
9159
9160 static void
9161 XTcondemn_scroll_bars (frame)
9162 FRAME_PTR frame;
9163 {
9164 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
9165 while (! NILP (FRAME_SCROLL_BARS (frame)))
9166 {
9167 Lisp_Object bar;
9168 bar = FRAME_SCROLL_BARS (frame);
9169 FRAME_SCROLL_BARS (frame) = XSCROLL_BAR (bar)->next;
9170 XSCROLL_BAR (bar)->next = FRAME_CONDEMNED_SCROLL_BARS (frame);
9171 XSCROLL_BAR (bar)->prev = Qnil;
9172 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame)))
9173 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame))->prev = bar;
9174 FRAME_CONDEMNED_SCROLL_BARS (frame) = bar;
9175 }
9176 }
9177
9178
9179 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
9180 Note that WINDOW isn't necessarily condemned at all. */
9181
9182 static void
9183 XTredeem_scroll_bar (window)
9184 struct window *window;
9185 {
9186 struct scroll_bar *bar;
9187 struct frame *f;
9188
9189 /* We can't redeem this window's scroll bar if it doesn't have one. */
9190 if (NILP (window->vertical_scroll_bar))
9191 abort ();
9192
9193 bar = XSCROLL_BAR (window->vertical_scroll_bar);
9194
9195 /* Unlink it from the condemned list. */
9196 f = XFRAME (WINDOW_FRAME (window));
9197 if (NILP (bar->prev))
9198 {
9199 /* If the prev pointer is nil, it must be the first in one of
9200 the lists. */
9201 if (EQ (FRAME_SCROLL_BARS (f), window->vertical_scroll_bar))
9202 /* It's not condemned. Everything's fine. */
9203 return;
9204 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f),
9205 window->vertical_scroll_bar))
9206 FRAME_CONDEMNED_SCROLL_BARS (f) = bar->next;
9207 else
9208 /* If its prev pointer is nil, it must be at the front of
9209 one or the other! */
9210 abort ();
9211 }
9212 else
9213 XSCROLL_BAR (bar->prev)->next = bar->next;
9214
9215 if (! NILP (bar->next))
9216 XSCROLL_BAR (bar->next)->prev = bar->prev;
9217
9218 bar->next = FRAME_SCROLL_BARS (f);
9219 bar->prev = Qnil;
9220 XSETVECTOR (FRAME_SCROLL_BARS (f), bar);
9221 if (! NILP (bar->next))
9222 XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
9223 }
9224
9225 /* Remove all scroll bars on FRAME that haven't been saved since the
9226 last call to `*condemn_scroll_bars_hook'. */
9227
9228 static void
9229 XTjudge_scroll_bars (f)
9230 FRAME_PTR f;
9231 {
9232 Lisp_Object bar, next;
9233
9234 bar = FRAME_CONDEMNED_SCROLL_BARS (f);
9235
9236 /* Clear out the condemned list now so we won't try to process any
9237 more events on the hapless scroll bars. */
9238 FRAME_CONDEMNED_SCROLL_BARS (f) = Qnil;
9239
9240 for (; ! NILP (bar); bar = next)
9241 {
9242 struct scroll_bar *b = XSCROLL_BAR (bar);
9243
9244 x_scroll_bar_remove (b);
9245
9246 next = b->next;
9247 b->next = b->prev = Qnil;
9248 }
9249
9250 /* Now there should be no references to the condemned scroll bars,
9251 and they should get garbage-collected. */
9252 }
9253
9254
9255 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
9256 is a no-op when using toolkit scroll bars.
9257
9258 This may be called from a signal handler, so we have to ignore GC
9259 mark bits. */
9260
9261 static void
9262 x_scroll_bar_expose (bar, event)
9263 struct scroll_bar *bar;
9264 XEvent *event;
9265 {
9266 #ifndef USE_TOOLKIT_SCROLL_BARS
9267
9268 Window w = SCROLL_BAR_X_WINDOW (bar);
9269 FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
9270 GC gc = f->output_data.x->normal_gc;
9271 int width_trim = VERTICAL_SCROLL_BAR_WIDTH_TRIM;
9272
9273 BLOCK_INPUT;
9274
9275 x_scroll_bar_set_handle (bar, XINT (bar->start), XINT (bar->end), 1);
9276
9277 /* Draw a one-pixel border just inside the edges of the scroll bar. */
9278 XDrawRectangle (FRAME_X_DISPLAY (f), w, gc,
9279
9280 /* x, y, width, height */
9281 0, 0,
9282 XINT (bar->width) - 1 - width_trim - width_trim,
9283 XINT (bar->height) - 1);
9284
9285 UNBLOCK_INPUT;
9286
9287 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9288 }
9289
9290 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
9291 is set to something other than no_event, it is enqueued.
9292
9293 This may be called from a signal handler, so we have to ignore GC
9294 mark bits. */
9295
9296 #ifndef USE_TOOLKIT_SCROLL_BARS
9297
9298 static void
9299 x_scroll_bar_handle_click (bar, event, emacs_event)
9300 struct scroll_bar *bar;
9301 XEvent *event;
9302 struct input_event *emacs_event;
9303 {
9304 if (! GC_WINDOWP (bar->window))
9305 abort ();
9306
9307 emacs_event->kind = scroll_bar_click;
9308 emacs_event->code = event->xbutton.button - Button1;
9309 emacs_event->modifiers
9310 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
9311 (XFRAME (WINDOW_FRAME (XWINDOW (bar->window)))),
9312 event->xbutton.state)
9313 | (event->type == ButtonRelease
9314 ? up_modifier
9315 : down_modifier));
9316 emacs_event->frame_or_window = bar->window;
9317 emacs_event->arg = Qnil;
9318 emacs_event->timestamp = event->xbutton.time;
9319 {
9320 #if 0
9321 FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
9322 int internal_height
9323 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f, XINT (bar->height));
9324 #endif
9325 int top_range
9326 = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
9327 int y = event->xbutton.y - VERTICAL_SCROLL_BAR_TOP_BORDER;
9328
9329 if (y < 0) y = 0;
9330 if (y > top_range) y = top_range;
9331
9332 if (y < XINT (bar->start))
9333 emacs_event->part = scroll_bar_above_handle;
9334 else if (y < XINT (bar->end) + VERTICAL_SCROLL_BAR_MIN_HANDLE)
9335 emacs_event->part = scroll_bar_handle;
9336 else
9337 emacs_event->part = scroll_bar_below_handle;
9338
9339 /* Just because the user has clicked on the handle doesn't mean
9340 they want to drag it. Lisp code needs to be able to decide
9341 whether or not we're dragging. */
9342 #if 0
9343 /* If the user has just clicked on the handle, record where they're
9344 holding it. */
9345 if (event->type == ButtonPress
9346 && emacs_event->part == scroll_bar_handle)
9347 XSETINT (bar->dragging, y - XINT (bar->start));
9348 #endif
9349
9350 /* If the user has released the handle, set it to its final position. */
9351 if (event->type == ButtonRelease
9352 && ! NILP (bar->dragging))
9353 {
9354 int new_start = y - XINT (bar->dragging);
9355 int new_end = new_start + (XINT (bar->end) - XINT (bar->start));
9356
9357 x_scroll_bar_set_handle (bar, new_start, new_end, 0);
9358 bar->dragging = Qnil;
9359 }
9360
9361 /* Same deal here as the other #if 0. */
9362 #if 0
9363 /* Clicks on the handle are always reported as occurring at the top of
9364 the handle. */
9365 if (emacs_event->part == scroll_bar_handle)
9366 emacs_event->x = bar->start;
9367 else
9368 XSETINT (emacs_event->x, y);
9369 #else
9370 XSETINT (emacs_event->x, y);
9371 #endif
9372
9373 XSETINT (emacs_event->y, top_range);
9374 }
9375 }
9376
9377 /* Handle some mouse motion while someone is dragging the scroll bar.
9378
9379 This may be called from a signal handler, so we have to ignore GC
9380 mark bits. */
9381
9382 static void
9383 x_scroll_bar_note_movement (bar, event)
9384 struct scroll_bar *bar;
9385 XEvent *event;
9386 {
9387 FRAME_PTR f = XFRAME (XWINDOW (bar->window)->frame);
9388
9389 last_mouse_movement_time = event->xmotion.time;
9390
9391 f->mouse_moved = 1;
9392 XSETVECTOR (last_mouse_scroll_bar, bar);
9393
9394 /* If we're dragging the bar, display it. */
9395 if (! GC_NILP (bar->dragging))
9396 {
9397 /* Where should the handle be now? */
9398 int new_start = event->xmotion.y - XINT (bar->dragging);
9399
9400 if (new_start != XINT (bar->start))
9401 {
9402 int new_end = new_start + (XINT (bar->end) - XINT (bar->start));
9403
9404 x_scroll_bar_set_handle (bar, new_start, new_end, 0);
9405 }
9406 }
9407 }
9408
9409 #endif /* !USE_TOOLKIT_SCROLL_BARS */
9410
9411 /* Return information to the user about the current position of the mouse
9412 on the scroll bar. */
9413
9414 static void
9415 x_scroll_bar_report_motion (fp, bar_window, part, x, y, time)
9416 FRAME_PTR *fp;
9417 Lisp_Object *bar_window;
9418 enum scroll_bar_part *part;
9419 Lisp_Object *x, *y;
9420 unsigned long *time;
9421 {
9422 struct scroll_bar *bar = XSCROLL_BAR (last_mouse_scroll_bar);
9423 Window w = SCROLL_BAR_X_WINDOW (bar);
9424 FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
9425 int win_x, win_y;
9426 Window dummy_window;
9427 int dummy_coord;
9428 unsigned int dummy_mask;
9429
9430 BLOCK_INPUT;
9431
9432 /* Get the mouse's position relative to the scroll bar window, and
9433 report that. */
9434 if (! XQueryPointer (FRAME_X_DISPLAY (f), w,
9435
9436 /* Root, child, root x and root y. */
9437 &dummy_window, &dummy_window,
9438 &dummy_coord, &dummy_coord,
9439
9440 /* Position relative to scroll bar. */
9441 &win_x, &win_y,
9442
9443 /* Mouse buttons and modifier keys. */
9444 &dummy_mask))
9445 ;
9446 else
9447 {
9448 #if 0
9449 int inside_height
9450 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f, XINT (bar->height));
9451 #endif
9452 int top_range
9453 = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
9454
9455 win_y -= VERTICAL_SCROLL_BAR_TOP_BORDER;
9456
9457 if (! NILP (bar->dragging))
9458 win_y -= XINT (bar->dragging);
9459
9460 if (win_y < 0)
9461 win_y = 0;
9462 if (win_y > top_range)
9463 win_y = top_range;
9464
9465 *fp = f;
9466 *bar_window = bar->window;
9467
9468 if (! NILP (bar->dragging))
9469 *part = scroll_bar_handle;
9470 else if (win_y < XINT (bar->start))
9471 *part = scroll_bar_above_handle;
9472 else if (win_y < XINT (bar->end) + VERTICAL_SCROLL_BAR_MIN_HANDLE)
9473 *part = scroll_bar_handle;
9474 else
9475 *part = scroll_bar_below_handle;
9476
9477 XSETINT (*x, win_y);
9478 XSETINT (*y, top_range);
9479
9480 f->mouse_moved = 0;
9481 last_mouse_scroll_bar = Qnil;
9482 }
9483
9484 *time = last_mouse_movement_time;
9485
9486 UNBLOCK_INPUT;
9487 }
9488
9489
9490 /* The screen has been cleared so we may have changed foreground or
9491 background colors, and the scroll bars may need to be redrawn.
9492 Clear out the scroll bars, and ask for expose events, so we can
9493 redraw them. */
9494
9495 void
9496 x_scroll_bar_clear (f)
9497 FRAME_PTR f;
9498 {
9499 #ifndef USE_TOOLKIT_SCROLL_BARS
9500 Lisp_Object bar;
9501
9502 /* We can have scroll bars even if this is 0,
9503 if we just turned off scroll bar mode.
9504 But in that case we should not clear them. */
9505 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
9506 for (bar = FRAME_SCROLL_BARS (f); VECTORP (bar);
9507 bar = XSCROLL_BAR (bar)->next)
9508 XClearArea (FRAME_X_DISPLAY (f),
9509 SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar)),
9510 0, 0, 0, 0, True);
9511 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9512 }
9513
9514 /* This processes Expose events from the menu-bar specific X event
9515 loop in xmenu.c. This allows to redisplay the frame if necessary
9516 when handling menu-bar or pop-up items. */
9517
9518 int
9519 process_expose_from_menu (event)
9520 XEvent event;
9521 {
9522 FRAME_PTR f;
9523 struct x_display_info *dpyinfo;
9524 int frame_exposed_p = 0;
9525
9526 BLOCK_INPUT;
9527
9528 dpyinfo = x_display_info_for_display (event.xexpose.display);
9529 f = x_window_to_frame (dpyinfo, event.xexpose.window);
9530 if (f)
9531 {
9532 if (f->async_visible == 0)
9533 {
9534 f->async_visible = 1;
9535 f->async_iconified = 0;
9536 f->output_data.x->has_been_visible = 1;
9537 SET_FRAME_GARBAGED (f);
9538 }
9539 else
9540 {
9541 expose_frame (x_window_to_frame (dpyinfo, event.xexpose.window),
9542 event.xexpose.x, event.xexpose.y,
9543 event.xexpose.width, event.xexpose.height);
9544 frame_exposed_p = 1;
9545 }
9546 }
9547 else
9548 {
9549 struct scroll_bar *bar
9550 = x_window_to_scroll_bar (event.xexpose.window);
9551
9552 if (bar)
9553 x_scroll_bar_expose (bar, &event);
9554 }
9555
9556 UNBLOCK_INPUT;
9557 return frame_exposed_p;
9558 }
9559 \f
9560 /* Define a queue to save up SelectionRequest events for later handling. */
9561
9562 struct selection_event_queue
9563 {
9564 XEvent event;
9565 struct selection_event_queue *next;
9566 };
9567
9568 static struct selection_event_queue *queue;
9569
9570 /* Nonzero means queue up certain events--don't process them yet. */
9571
9572 static int x_queue_selection_requests;
9573
9574 /* Queue up an X event *EVENT, to be processed later. */
9575
9576 static void
9577 x_queue_event (f, event)
9578 FRAME_PTR f;
9579 XEvent *event;
9580 {
9581 struct selection_event_queue *queue_tmp
9582 = (struct selection_event_queue *) xmalloc (sizeof (struct selection_event_queue));
9583
9584 if (queue_tmp != NULL)
9585 {
9586 queue_tmp->event = *event;
9587 queue_tmp->next = queue;
9588 queue = queue_tmp;
9589 }
9590 }
9591
9592 /* Take all the queued events and put them back
9593 so that they get processed afresh. */
9594
9595 static void
9596 x_unqueue_events (display)
9597 Display *display;
9598 {
9599 while (queue != NULL)
9600 {
9601 struct selection_event_queue *queue_tmp = queue;
9602 XPutBackEvent (display, &queue_tmp->event);
9603 queue = queue_tmp->next;
9604 xfree ((char *)queue_tmp);
9605 }
9606 }
9607
9608 /* Start queuing SelectionRequest events. */
9609
9610 void
9611 x_start_queuing_selection_requests (display)
9612 Display *display;
9613 {
9614 x_queue_selection_requests++;
9615 }
9616
9617 /* Stop queuing SelectionRequest events. */
9618
9619 void
9620 x_stop_queuing_selection_requests (display)
9621 Display *display;
9622 {
9623 x_queue_selection_requests--;
9624 x_unqueue_events (display);
9625 }
9626 \f
9627 /* The main X event-reading loop - XTread_socket. */
9628
9629 /* Time stamp of enter window event. This is only used by XTread_socket,
9630 but we have to put it out here, since static variables within functions
9631 sometimes don't work. */
9632
9633 static Time enter_timestamp;
9634
9635 /* This holds the state XLookupString needs to implement dead keys
9636 and other tricks known as "compose processing". _X Window System_
9637 says that a portable program can't use this, but Stephen Gildea assures
9638 me that letting the compiler initialize it to zeros will work okay.
9639
9640 This must be defined outside of XTread_socket, for the same reasons
9641 given for enter_time stamp, above. */
9642
9643 static XComposeStatus compose_status;
9644
9645 /* Record the last 100 characters stored
9646 to help debug the loss-of-chars-during-GC problem. */
9647
9648 static int temp_index;
9649 static short temp_buffer[100];
9650
9651 /* Set this to nonzero to fake an "X I/O error"
9652 on a particular display. */
9653
9654 struct x_display_info *XTread_socket_fake_io_error;
9655
9656 /* When we find no input here, we occasionally do a no-op command
9657 to verify that the X server is still running and we can still talk with it.
9658 We try all the open displays, one by one.
9659 This variable is used for cycling thru the displays. */
9660
9661 static struct x_display_info *next_noop_dpyinfo;
9662
9663 #define SET_SAVED_MENU_EVENT(size) \
9664 do \
9665 { \
9666 if (f->output_data.x->saved_menu_event == 0) \
9667 f->output_data.x->saved_menu_event \
9668 = (XEvent *) xmalloc (sizeof (XEvent)); \
9669 bcopy (&event, f->output_data.x->saved_menu_event, size); \
9670 if (numchars >= 1) \
9671 { \
9672 bufp->kind = menu_bar_activate_event; \
9673 XSETFRAME (bufp->frame_or_window, f); \
9674 bufp->arg = Qnil; \
9675 bufp++; \
9676 count++; \
9677 numchars--; \
9678 } \
9679 } \
9680 while (0)
9681
9682 #define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
9683 #define SET_SAVED_KEY_EVENT SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
9684
9685 /* Read events coming from the X server.
9686 This routine is called by the SIGIO handler.
9687 We return as soon as there are no more events to be read.
9688
9689 Events representing keys are stored in buffer BUFP,
9690 which can hold up to NUMCHARS characters.
9691 We return the number of characters stored into the buffer,
9692 thus pretending to be `read'.
9693
9694 EXPECTED is nonzero if the caller knows input is available. */
9695
9696 int
9697 XTread_socket (sd, bufp, numchars, expected)
9698 register int sd;
9699 /* register */ struct input_event *bufp;
9700 /* register */ int numchars;
9701 int expected;
9702 {
9703 int count = 0;
9704 int nbytes = 0;
9705 XEvent event;
9706 struct frame *f;
9707 int event_found = 0;
9708 struct x_display_info *dpyinfo;
9709 struct coding_system coding;
9710
9711 if (interrupt_input_blocked)
9712 {
9713 interrupt_input_pending = 1;
9714 return -1;
9715 }
9716
9717 interrupt_input_pending = 0;
9718 BLOCK_INPUT;
9719
9720 /* So people can tell when we have read the available input. */
9721 input_signal_count++;
9722
9723 if (numchars <= 0)
9724 abort (); /* Don't think this happens. */
9725
9726 ++handling_signal;
9727
9728 /* The input should be decoded if it is from XIM. Currently the
9729 locale of XIM is the same as that of the system. So, we can use
9730 Vlocale_coding_system which is initialized properly at Emacs
9731 startup time. */
9732 setup_coding_system (Vlocale_coding_system, &coding);
9733 coding.src_multibyte = 0;
9734 coding.dst_multibyte = 1;
9735 /* The input is converted to events, thus we can't handle
9736 composition. Anyway, there's no XIM that gives us composition
9737 information. */
9738 coding.composing = COMPOSITION_DISABLED;
9739
9740 /* Find the display we are supposed to read input for.
9741 It's the one communicating on descriptor SD. */
9742 for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
9743 {
9744 #if 0 /* This ought to be unnecessary; let's verify it. */
9745 #ifdef FIOSNBIO
9746 /* If available, Xlib uses FIOSNBIO to make the socket
9747 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
9748 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
9749 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
9750 fcntl (dpyinfo->connection, F_SETFL, 0);
9751 #endif /* ! defined (FIOSNBIO) */
9752 #endif
9753
9754 #if 0 /* This code can't be made to work, with multiple displays,
9755 and appears not to be used on any system any more.
9756 Also keyboard.c doesn't turn O_NDELAY on and off
9757 for X connections. */
9758 #ifndef SIGIO
9759 #ifndef HAVE_SELECT
9760 if (! (fcntl (dpyinfo->connection, F_GETFL, 0) & O_NDELAY))
9761 {
9762 extern int read_alarm_should_throw;
9763 read_alarm_should_throw = 1;
9764 XPeekEvent (dpyinfo->display, &event);
9765 read_alarm_should_throw = 0;
9766 }
9767 #endif /* HAVE_SELECT */
9768 #endif /* SIGIO */
9769 #endif
9770
9771 /* For debugging, this gives a way to fake an I/O error. */
9772 if (dpyinfo == XTread_socket_fake_io_error)
9773 {
9774 XTread_socket_fake_io_error = 0;
9775 x_io_error_quitter (dpyinfo->display);
9776 }
9777
9778 while (XPending (dpyinfo->display))
9779 {
9780 XNextEvent (dpyinfo->display, &event);
9781
9782 #ifdef HAVE_X_I18N
9783 {
9784 /* Filter events for the current X input method.
9785 XFilterEvent returns non-zero if the input method has
9786 consumed the event. We pass the frame's X window to
9787 XFilterEvent because that's the one for which the IC
9788 was created. */
9789 struct frame *f1 = x_any_window_to_frame (dpyinfo,
9790 event.xclient.window);
9791 if (XFilterEvent (&event, f1 ? FRAME_X_WINDOW (f1) : None))
9792 break;
9793 }
9794 #endif
9795 event_found = 1;
9796
9797 switch (event.type)
9798 {
9799 case ClientMessage:
9800 {
9801 if (event.xclient.message_type
9802 == dpyinfo->Xatom_wm_protocols
9803 && event.xclient.format == 32)
9804 {
9805 if (event.xclient.data.l[0]
9806 == dpyinfo->Xatom_wm_take_focus)
9807 {
9808 /* Use x_any_window_to_frame because this
9809 could be the shell widget window
9810 if the frame has no title bar. */
9811 f = x_any_window_to_frame (dpyinfo, event.xclient.window);
9812 #ifdef HAVE_X_I18N
9813 /* Not quite sure this is needed -pd */
9814 if (f && FRAME_XIC (f))
9815 XSetICFocus (FRAME_XIC (f));
9816 #endif
9817 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
9818 instructs the WM to set the input focus automatically for
9819 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
9820 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
9821 it has set the focus. So, XSetInputFocus below is not
9822 needed.
9823
9824 The call to XSetInputFocus below has also caused trouble. In
9825 cases where the XSetInputFocus done by the WM and the one
9826 below are temporally close (on a fast machine), the call
9827 below can generate additional FocusIn events which confuse
9828 Emacs. */
9829
9830 /* Since we set WM_TAKE_FOCUS, we must call
9831 XSetInputFocus explicitly. But not if f is null,
9832 since that might be an event for a deleted frame. */
9833 if (f)
9834 {
9835 Display *d = event.xclient.display;
9836 /* Catch and ignore errors, in case window has been
9837 iconified by a window manager such as GWM. */
9838 int count = x_catch_errors (d);
9839 XSetInputFocus (d, event.xclient.window,
9840 /* The ICCCM says this is
9841 the only valid choice. */
9842 RevertToParent,
9843 event.xclient.data.l[1]);
9844 /* This is needed to detect the error
9845 if there is an error. */
9846 XSync (d, False);
9847 x_uncatch_errors (d, count);
9848 }
9849 /* Not certain about handling scroll bars here */
9850 #endif /* 0 */
9851 }
9852 else if (event.xclient.data.l[0]
9853 == dpyinfo->Xatom_wm_save_yourself)
9854 {
9855 /* Save state modify the WM_COMMAND property to
9856 something which can reinstate us. This notifies
9857 the session manager, who's looking for such a
9858 PropertyNotify. Can restart processing when
9859 a keyboard or mouse event arrives. */
9860 if (numchars > 0)
9861 {
9862 f = x_top_window_to_frame (dpyinfo,
9863 event.xclient.window);
9864
9865 /* This is just so we only give real data once
9866 for a single Emacs process. */
9867 if (f == SELECTED_FRAME ())
9868 XSetCommand (FRAME_X_DISPLAY (f),
9869 event.xclient.window,
9870 initial_argv, initial_argc);
9871 else if (f)
9872 XSetCommand (FRAME_X_DISPLAY (f),
9873 event.xclient.window,
9874 0, 0);
9875 }
9876 }
9877 else if (event.xclient.data.l[0]
9878 == dpyinfo->Xatom_wm_delete_window)
9879 {
9880 struct frame *f
9881 = x_any_window_to_frame (dpyinfo,
9882 event.xclient.window);
9883
9884 if (f)
9885 {
9886 if (numchars == 0)
9887 abort ();
9888
9889 bufp->kind = delete_window_event;
9890 XSETFRAME (bufp->frame_or_window, f);
9891 bufp->arg = Qnil;
9892 bufp++;
9893
9894 count += 1;
9895 numchars -= 1;
9896 }
9897 }
9898 }
9899 else if (event.xclient.message_type
9900 == dpyinfo->Xatom_wm_configure_denied)
9901 {
9902 }
9903 else if (event.xclient.message_type
9904 == dpyinfo->Xatom_wm_window_moved)
9905 {
9906 int new_x, new_y;
9907 struct frame *f
9908 = x_window_to_frame (dpyinfo, event.xclient.window);
9909
9910 new_x = event.xclient.data.s[0];
9911 new_y = event.xclient.data.s[1];
9912
9913 if (f)
9914 {
9915 f->output_data.x->left_pos = new_x;
9916 f->output_data.x->top_pos = new_y;
9917 }
9918 }
9919 #ifdef HACK_EDITRES
9920 else if (event.xclient.message_type
9921 == dpyinfo->Xatom_editres)
9922 {
9923 struct frame *f
9924 = x_any_window_to_frame (dpyinfo, event.xclient.window);
9925 _XEditResCheckMessages (f->output_data.x->widget, NULL,
9926 &event, NULL);
9927 }
9928 #endif /* HACK_EDITRES */
9929 else if ((event.xclient.message_type
9930 == dpyinfo->Xatom_DONE)
9931 || (event.xclient.message_type
9932 == dpyinfo->Xatom_PAGE))
9933 {
9934 /* Ghostview job completed. Kill it. We could
9935 reply with "Next" if we received "Page", but we
9936 currently never do because we are interested in
9937 images, only, which should have 1 page. */
9938 Pixmap pixmap = (Pixmap) event.xclient.data.l[1];
9939 struct frame *f
9940 = x_window_to_frame (dpyinfo, event.xclient.window);
9941 x_kill_gs_process (pixmap, f);
9942 expose_frame (f, 0, 0, 0, 0);
9943 }
9944 #ifdef USE_TOOLKIT_SCROLL_BARS
9945 /* Scroll bar callbacks send a ClientMessage from which
9946 we construct an input_event. */
9947 else if (event.xclient.message_type
9948 == dpyinfo->Xatom_Scrollbar)
9949 {
9950 x_scroll_bar_to_input_event (&event, bufp);
9951 ++bufp, ++count, --numchars;
9952 goto out;
9953 }
9954 #endif /* USE_TOOLKIT_SCROLL_BARS */
9955 else
9956 goto OTHER;
9957 }
9958 break;
9959
9960 case SelectionNotify:
9961 #ifdef USE_X_TOOLKIT
9962 if (! x_window_to_frame (dpyinfo, event.xselection.requestor))
9963 goto OTHER;
9964 #endif /* not USE_X_TOOLKIT */
9965 x_handle_selection_notify (&event.xselection);
9966 break;
9967
9968 case SelectionClear: /* Someone has grabbed ownership. */
9969 #ifdef USE_X_TOOLKIT
9970 if (! x_window_to_frame (dpyinfo, event.xselectionclear.window))
9971 goto OTHER;
9972 #endif /* USE_X_TOOLKIT */
9973 {
9974 XSelectionClearEvent *eventp = (XSelectionClearEvent *) &event;
9975
9976 if (numchars == 0)
9977 abort ();
9978
9979 bufp->kind = selection_clear_event;
9980 SELECTION_EVENT_DISPLAY (bufp) = eventp->display;
9981 SELECTION_EVENT_SELECTION (bufp) = eventp->selection;
9982 SELECTION_EVENT_TIME (bufp) = eventp->time;
9983 bufp->frame_or_window = Qnil;
9984 bufp->arg = Qnil;
9985 bufp++;
9986
9987 count += 1;
9988 numchars -= 1;
9989 }
9990 break;
9991
9992 case SelectionRequest: /* Someone wants our selection. */
9993 #ifdef USE_X_TOOLKIT
9994 if (!x_window_to_frame (dpyinfo, event.xselectionrequest.owner))
9995 goto OTHER;
9996 #endif /* USE_X_TOOLKIT */
9997 if (x_queue_selection_requests)
9998 x_queue_event (x_window_to_frame (dpyinfo, event.xselectionrequest.owner),
9999 &event);
10000 else
10001 {
10002 XSelectionRequestEvent *eventp = (XSelectionRequestEvent *) &event;
10003
10004 if (numchars == 0)
10005 abort ();
10006
10007 bufp->kind = selection_request_event;
10008 SELECTION_EVENT_DISPLAY (bufp) = eventp->display;
10009 SELECTION_EVENT_REQUESTOR (bufp) = eventp->requestor;
10010 SELECTION_EVENT_SELECTION (bufp) = eventp->selection;
10011 SELECTION_EVENT_TARGET (bufp) = eventp->target;
10012 SELECTION_EVENT_PROPERTY (bufp) = eventp->property;
10013 SELECTION_EVENT_TIME (bufp) = eventp->time;
10014 bufp->frame_or_window = Qnil;
10015 bufp->arg = Qnil;
10016 bufp++;
10017
10018 count += 1;
10019 numchars -= 1;
10020 }
10021 break;
10022
10023 case PropertyNotify:
10024 #ifdef USE_X_TOOLKIT
10025 if (!x_any_window_to_frame (dpyinfo, event.xproperty.window))
10026 goto OTHER;
10027 #endif /* not USE_X_TOOLKIT */
10028 x_handle_property_notify (&event.xproperty);
10029 break;
10030
10031 case ReparentNotify:
10032 f = x_top_window_to_frame (dpyinfo, event.xreparent.window);
10033 if (f)
10034 {
10035 int x, y;
10036 f->output_data.x->parent_desc = event.xreparent.parent;
10037 x_real_positions (f, &x, &y);
10038 f->output_data.x->left_pos = x;
10039 f->output_data.x->top_pos = y;
10040 }
10041 break;
10042
10043 case Expose:
10044 f = x_window_to_frame (dpyinfo, event.xexpose.window);
10045 if (f)
10046 {
10047 if (f->async_visible == 0)
10048 {
10049 f->async_visible = 1;
10050 f->async_iconified = 0;
10051 f->output_data.x->has_been_visible = 1;
10052 SET_FRAME_GARBAGED (f);
10053 }
10054 else
10055 expose_frame (x_window_to_frame (dpyinfo,
10056 event.xexpose.window),
10057 event.xexpose.x, event.xexpose.y,
10058 event.xexpose.width, event.xexpose.height);
10059 }
10060 else
10061 {
10062 #ifndef USE_TOOLKIT_SCROLL_BARS
10063 struct scroll_bar *bar;
10064 #endif
10065 #if defined USE_X_TOOLKIT && defined USE_LUCID
10066 /* Submenus of the Lucid menu bar aren't widgets
10067 themselves, so there's no way to dispatch events
10068 to them. Recognize this case separately. */
10069 {
10070 Widget widget
10071 = x_window_to_menu_bar (event.xexpose.window);
10072 if (widget)
10073 xlwmenu_redisplay (widget);
10074 }
10075 #endif /* USE_X_TOOLKIT && USE_LUCID */
10076
10077 #ifdef USE_TOOLKIT_SCROLL_BARS
10078 /* Dispatch event to the widget. */
10079 goto OTHER;
10080 #else /* not USE_TOOLKIT_SCROLL_BARS */
10081 bar = x_window_to_scroll_bar (event.xexpose.window);
10082
10083 if (bar)
10084 x_scroll_bar_expose (bar, &event);
10085 #ifdef USE_X_TOOLKIT
10086 else
10087 goto OTHER;
10088 #endif /* USE_X_TOOLKIT */
10089 #endif /* not USE_TOOLKIT_SCROLL_BARS */
10090 }
10091 break;
10092
10093 case GraphicsExpose: /* This occurs when an XCopyArea's
10094 source area was obscured or not
10095 available.*/
10096 f = x_window_to_frame (dpyinfo, event.xgraphicsexpose.drawable);
10097 if (f)
10098 {
10099 expose_frame (f,
10100 event.xgraphicsexpose.x, event.xgraphicsexpose.y,
10101 event.xgraphicsexpose.width,
10102 event.xgraphicsexpose.height);
10103 }
10104 #ifdef USE_X_TOOLKIT
10105 else
10106 goto OTHER;
10107 #endif /* USE_X_TOOLKIT */
10108 break;
10109
10110 case NoExpose: /* This occurs when an XCopyArea's
10111 source area was completely
10112 available */
10113 break;
10114
10115 case UnmapNotify:
10116 /* Redo the mouse-highlight after the tooltip has gone. */
10117 if (event.xmap.window == tip_window)
10118 {
10119 tip_window = 0;
10120 redo_mouse_highlight ();
10121 }
10122
10123 f = x_top_window_to_frame (dpyinfo, event.xunmap.window);
10124 if (f) /* F may no longer exist if
10125 the frame was deleted. */
10126 {
10127 /* While a frame is unmapped, display generation is
10128 disabled; you don't want to spend time updating a
10129 display that won't ever be seen. */
10130 f->async_visible = 0;
10131 /* We can't distinguish, from the event, whether the window
10132 has become iconified or invisible. So assume, if it
10133 was previously visible, than now it is iconified.
10134 But x_make_frame_invisible clears both
10135 the visible flag and the iconified flag;
10136 and that way, we know the window is not iconified now. */
10137 if (FRAME_VISIBLE_P (f) || FRAME_ICONIFIED_P (f))
10138 {
10139 f->async_iconified = 1;
10140
10141 bufp->kind = iconify_event;
10142 XSETFRAME (bufp->frame_or_window, f);
10143 bufp->arg = Qnil;
10144 bufp++;
10145 count++;
10146 numchars--;
10147 }
10148 }
10149 goto OTHER;
10150
10151 case MapNotify:
10152 if (event.xmap.window == tip_window)
10153 /* The tooltip has been drawn already. Avoid
10154 the SET_FRAME_GARBAGED below. */
10155 goto OTHER;
10156
10157 /* We use x_top_window_to_frame because map events can
10158 come for sub-windows and they don't mean that the
10159 frame is visible. */
10160 f = x_top_window_to_frame (dpyinfo, event.xmap.window);
10161 if (f)
10162 {
10163 f->async_visible = 1;
10164 f->async_iconified = 0;
10165 f->output_data.x->has_been_visible = 1;
10166
10167 /* wait_reading_process_input will notice this and update
10168 the frame's display structures. */
10169 SET_FRAME_GARBAGED (f);
10170
10171 if (f->iconified)
10172 {
10173 bufp->kind = deiconify_event;
10174 XSETFRAME (bufp->frame_or_window, f);
10175 bufp->arg = Qnil;
10176 bufp++;
10177 count++;
10178 numchars--;
10179 }
10180 else if (! NILP (Vframe_list)
10181 && ! NILP (XCDR (Vframe_list)))
10182 /* Force a redisplay sooner or later
10183 to update the frame titles
10184 in case this is the second frame. */
10185 record_asynch_buffer_change ();
10186 }
10187 goto OTHER;
10188
10189 case KeyPress:
10190 f = x_any_window_to_frame (dpyinfo, event.xkey.window);
10191
10192 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
10193 if (f == 0)
10194 {
10195 /* Scroll bars consume key events, but we want
10196 the keys to go to the scroll bar's frame. */
10197 Widget widget = XtWindowToWidget (dpyinfo->display,
10198 event.xkey.window);
10199 if (widget && XmIsScrollBar (widget))
10200 {
10201 widget = XtParent (widget);
10202 f = x_any_window_to_frame (dpyinfo, XtWindow (widget));
10203 }
10204 }
10205 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
10206
10207 if (f != 0)
10208 {
10209 KeySym keysym, orig_keysym;
10210 /* al%imercury@uunet.uu.net says that making this 81
10211 instead of 80 fixed a bug whereby meta chars made
10212 his Emacs hang.
10213
10214 It seems that some version of XmbLookupString has
10215 a bug of not returning XBufferOverflow in
10216 status_return even if the input is too long to
10217 fit in 81 bytes. So, we must prepare sufficient
10218 bytes for copy_buffer. 513 bytes (256 chars for
10219 two-byte character set) seems to be a faily good
10220 approximation. -- 2000.8.10 handa@etl.go.jp */
10221 unsigned char copy_buffer[513];
10222 unsigned char *copy_bufptr = copy_buffer;
10223 int copy_bufsiz = sizeof (copy_buffer);
10224 int modifiers;
10225
10226 event.xkey.state
10227 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f),
10228 extra_keyboard_modifiers);
10229 modifiers = event.xkey.state;
10230
10231 /* This will have to go some day... */
10232
10233 /* make_lispy_event turns chars into control chars.
10234 Don't do it here because XLookupString is too eager. */
10235 event.xkey.state &= ~ControlMask;
10236 event.xkey.state &= ~(dpyinfo->meta_mod_mask
10237 | dpyinfo->super_mod_mask
10238 | dpyinfo->hyper_mod_mask
10239 | dpyinfo->alt_mod_mask);
10240
10241 /* In case Meta is ComposeCharacter,
10242 clear its status. According to Markus Ehrnsperger
10243 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
10244 this enables ComposeCharacter to work whether or
10245 not it is combined with Meta. */
10246 if (modifiers & dpyinfo->meta_mod_mask)
10247 bzero (&compose_status, sizeof (compose_status));
10248
10249 #ifdef HAVE_X_I18N
10250 if (FRAME_XIC (f))
10251 {
10252 Status status_return;
10253
10254 nbytes = XmbLookupString (FRAME_XIC (f),
10255 &event.xkey, copy_bufptr,
10256 copy_bufsiz, &keysym,
10257 &status_return);
10258 if (status_return == XBufferOverflow)
10259 {
10260 copy_bufsiz = nbytes + 1;
10261 copy_bufptr = (char *) alloca (copy_bufsiz);
10262 nbytes = XmbLookupString (FRAME_XIC (f),
10263 &event.xkey, copy_bufptr,
10264 copy_bufsiz, &keysym,
10265 &status_return);
10266 }
10267
10268 if (status_return == XLookupNone)
10269 break;
10270 else if (status_return == XLookupChars)
10271 {
10272 keysym = NoSymbol;
10273 modifiers = 0;
10274 }
10275 else if (status_return != XLookupKeySym
10276 && status_return != XLookupBoth)
10277 abort ();
10278 }
10279 else
10280 nbytes = XLookupString (&event.xkey, copy_bufptr,
10281 copy_bufsiz, &keysym,
10282 &compose_status);
10283 #else
10284 nbytes = XLookupString (&event.xkey, copy_bufptr,
10285 copy_bufsiz, &keysym,
10286 &compose_status);
10287 #endif
10288
10289 orig_keysym = keysym;
10290
10291 if (numchars > 1)
10292 {
10293 if (((keysym >= XK_BackSpace && keysym <= XK_Escape)
10294 || keysym == XK_Delete
10295 #ifdef XK_ISO_Left_Tab
10296 || (keysym >= XK_ISO_Left_Tab && keysym <= XK_ISO_Enter)
10297 #endif
10298 || (keysym >= XK_Kanji && keysym <= XK_Eisu_toggle)
10299 || IsCursorKey (keysym) /* 0xff50 <= x < 0xff60 */
10300 || IsMiscFunctionKey (keysym) /* 0xff60 <= x < VARIES */
10301 #ifdef HPUX
10302 /* This recognizes the "extended function keys".
10303 It seems there's no cleaner way.
10304 Test IsModifierKey to avoid handling mode_switch
10305 incorrectly. */
10306 || ((unsigned) (keysym) >= XK_Select
10307 && (unsigned)(keysym) < XK_KP_Space)
10308 #endif
10309 #ifdef XK_dead_circumflex
10310 || orig_keysym == XK_dead_circumflex
10311 #endif
10312 #ifdef XK_dead_grave
10313 || orig_keysym == XK_dead_grave
10314 #endif
10315 #ifdef XK_dead_tilde
10316 || orig_keysym == XK_dead_tilde
10317 #endif
10318 #ifdef XK_dead_diaeresis
10319 || orig_keysym == XK_dead_diaeresis
10320 #endif
10321 #ifdef XK_dead_macron
10322 || orig_keysym == XK_dead_macron
10323 #endif
10324 #ifdef XK_dead_degree
10325 || orig_keysym == XK_dead_degree
10326 #endif
10327 #ifdef XK_dead_acute
10328 || orig_keysym == XK_dead_acute
10329 #endif
10330 #ifdef XK_dead_cedilla
10331 || orig_keysym == XK_dead_cedilla
10332 #endif
10333 #ifdef XK_dead_breve
10334 || orig_keysym == XK_dead_breve
10335 #endif
10336 #ifdef XK_dead_ogonek
10337 || orig_keysym == XK_dead_ogonek
10338 #endif
10339 #ifdef XK_dead_caron
10340 || orig_keysym == XK_dead_caron
10341 #endif
10342 #ifdef XK_dead_doubleacute
10343 || orig_keysym == XK_dead_doubleacute
10344 #endif
10345 #ifdef XK_dead_abovedot
10346 || orig_keysym == XK_dead_abovedot
10347 #endif
10348 || IsKeypadKey (keysym) /* 0xff80 <= x < 0xffbe */
10349 || IsFunctionKey (keysym) /* 0xffbe <= x < 0xffe1 */
10350 /* Any "vendor-specific" key is ok. */
10351 || (orig_keysym & (1 << 28)))
10352 && ! (IsModifierKey (orig_keysym)
10353 #ifndef HAVE_X11R5
10354 #ifdef XK_Mode_switch
10355 || ((unsigned)(orig_keysym) == XK_Mode_switch)
10356 #endif
10357 #ifdef XK_Num_Lock
10358 || ((unsigned)(orig_keysym) == XK_Num_Lock)
10359 #endif
10360 #endif /* not HAVE_X11R5 */
10361 ))
10362 {
10363 if (temp_index == sizeof temp_buffer / sizeof (short))
10364 temp_index = 0;
10365 temp_buffer[temp_index++] = keysym;
10366 bufp->kind = non_ascii_keystroke;
10367 bufp->code = keysym;
10368 XSETFRAME (bufp->frame_or_window, f);
10369 bufp->arg = Qnil;
10370 bufp->modifiers
10371 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
10372 modifiers);
10373 bufp->timestamp = event.xkey.time;
10374 bufp++;
10375 count++;
10376 numchars--;
10377 }
10378 else if (numchars > nbytes)
10379 {
10380 register int i;
10381 register int c;
10382 int nchars, len;
10383
10384 for (i = 0; i < nbytes; i++)
10385 {
10386 if (temp_index == (sizeof temp_buffer
10387 / sizeof (short)))
10388 temp_index = 0;
10389 temp_buffer[temp_index++] = copy_bufptr[i];
10390 }
10391
10392 if (/* If the event is not from XIM, */
10393 event.xkey.keycode != 0
10394 /* or the current locale doesn't request
10395 decoding of the intup data, ... */
10396 || coding.type == coding_type_raw_text
10397 || coding.type == coding_type_no_conversion)
10398 {
10399 /* ... we can use the input data as is. */
10400 nchars = nbytes;
10401 }
10402 else
10403 {
10404 /* We have to decode the input data. */
10405 int require;
10406 unsigned char *p;
10407
10408 require = decoding_buffer_size (&coding, nbytes);
10409 p = (unsigned char *) alloca (require);
10410 coding.mode |= CODING_MODE_LAST_BLOCK;
10411 decode_coding (&coding, copy_bufptr, p,
10412 nbytes, require);
10413 nbytes = coding.produced;
10414 nchars = coding.produced_char;
10415 copy_bufptr = p;
10416 }
10417
10418 /* Convert the input data to a sequence of
10419 character events. */
10420 for (i = 0; i < nbytes; i += len)
10421 {
10422 c = STRING_CHAR_AND_LENGTH (copy_bufptr + i,
10423 nbytes - i, len);
10424 bufp->kind = (SINGLE_BYTE_CHAR_P (c)
10425 ? ascii_keystroke
10426 : multibyte_char_keystroke);
10427 bufp->code = c;
10428 XSETFRAME (bufp->frame_or_window, f);
10429 bufp->arg = Qnil;
10430 bufp->modifiers
10431 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
10432 modifiers);
10433 bufp->timestamp = event.xkey.time;
10434 bufp++;
10435 }
10436
10437 count += nchars;
10438 numchars -= nchars;
10439
10440 if (keysym == NoSymbol)
10441 break;
10442 }
10443 else
10444 abort ();
10445 }
10446 else
10447 abort ();
10448 }
10449 #ifdef HAVE_X_I18N
10450 /* Don't dispatch this event since XtDispatchEvent calls
10451 XFilterEvent, and two calls in a row may freeze the
10452 client. */
10453 break;
10454 #else
10455 goto OTHER;
10456 #endif
10457
10458 case KeyRelease:
10459 #ifdef HAVE_X_I18N
10460 /* Don't dispatch this event since XtDispatchEvent calls
10461 XFilterEvent, and two calls in a row may freeze the
10462 client. */
10463 break;
10464 #else
10465 goto OTHER;
10466 #endif
10467
10468 /* Here's a possible interpretation of the whole
10469 FocusIn-EnterNotify FocusOut-LeaveNotify mess. If
10470 you get a FocusIn event, you have to get a FocusOut
10471 event before you relinquish the focus. If you
10472 haven't received a FocusIn event, then a mere
10473 LeaveNotify is enough to free you. */
10474
10475 case EnterNotify:
10476 {
10477 f = x_any_window_to_frame (dpyinfo, event.xcrossing.window);
10478
10479 if (event.xcrossing.focus)
10480 {
10481 /* Avoid nasty pop/raise loops. */
10482 if (f && (!(f->auto_raise)
10483 || !(f->auto_lower)
10484 || (event.xcrossing.time - enter_timestamp) > 500))
10485 {
10486 x_new_focus_frame (dpyinfo, f);
10487 enter_timestamp = event.xcrossing.time;
10488 }
10489 }
10490 else if (f == dpyinfo->x_focus_frame)
10491 x_new_focus_frame (dpyinfo, 0);
10492
10493 /* EnterNotify counts as mouse movement,
10494 so update things that depend on mouse position. */
10495 if (f && !f->output_data.x->hourglass_p)
10496 note_mouse_movement (f, &event.xmotion);
10497 goto OTHER;
10498 }
10499
10500 case FocusIn:
10501 f = x_any_window_to_frame (dpyinfo, event.xfocus.window);
10502 if (event.xfocus.detail != NotifyPointer)
10503 dpyinfo->x_focus_event_frame = f;
10504 if (f)
10505 {
10506 x_new_focus_frame (dpyinfo, f);
10507
10508 /* Don't stop displaying the initial startup message
10509 for a switch-frame event we don't need. */
10510 if (GC_NILP (Vterminal_frame)
10511 && GC_CONSP (Vframe_list)
10512 && !GC_NILP (XCDR (Vframe_list)))
10513 {
10514 bufp->kind = FOCUS_IN_EVENT;
10515 XSETFRAME (bufp->frame_or_window, f);
10516 bufp->arg = Qnil;
10517 ++bufp, ++count, --numchars;
10518 }
10519 }
10520
10521 #ifdef HAVE_X_I18N
10522 if (f && FRAME_XIC (f))
10523 XSetICFocus (FRAME_XIC (f));
10524 #endif
10525
10526 goto OTHER;
10527
10528 case LeaveNotify:
10529 f = x_top_window_to_frame (dpyinfo, event.xcrossing.window);
10530 if (f)
10531 {
10532 if (f == dpyinfo->mouse_face_mouse_frame)
10533 {
10534 /* If we move outside the frame, then we're
10535 certainly no longer on any text in the frame. */
10536 clear_mouse_face (dpyinfo);
10537 dpyinfo->mouse_face_mouse_frame = 0;
10538 }
10539
10540 /* Generate a nil HELP_EVENT to cancel a help-echo.
10541 Do it only if there's something to cancel.
10542 Otherwise, the startup message is cleared when
10543 the mouse leaves the frame. */
10544 if (any_help_event_p)
10545 {
10546 Lisp_Object frame;
10547 int n;
10548
10549 XSETFRAME (frame, f);
10550 help_echo = Qnil;
10551 n = gen_help_event (bufp, numchars,
10552 Qnil, frame, Qnil, Qnil, 0);
10553 bufp += n, count += n, numchars -= n;
10554 }
10555
10556 if (event.xcrossing.focus)
10557 x_mouse_leave (dpyinfo);
10558 else
10559 {
10560 if (f == dpyinfo->x_focus_event_frame)
10561 dpyinfo->x_focus_event_frame = 0;
10562 if (f == dpyinfo->x_focus_frame)
10563 x_new_focus_frame (dpyinfo, 0);
10564 }
10565 }
10566 goto OTHER;
10567
10568 case FocusOut:
10569 f = x_any_window_to_frame (dpyinfo, event.xfocus.window);
10570 if (event.xfocus.detail != NotifyPointer
10571 && f == dpyinfo->x_focus_event_frame)
10572 dpyinfo->x_focus_event_frame = 0;
10573 if (f && f == dpyinfo->x_focus_frame)
10574 x_new_focus_frame (dpyinfo, 0);
10575
10576 #ifdef HAVE_X_I18N
10577 if (f && FRAME_XIC (f))
10578 XUnsetICFocus (FRAME_XIC (f));
10579 #endif
10580
10581 goto OTHER;
10582
10583 case MotionNotify:
10584 {
10585 previous_help_echo = help_echo;
10586 help_echo = help_echo_object = help_echo_window = Qnil;
10587 help_echo_pos = -1;
10588
10589 if (dpyinfo->grabbed && last_mouse_frame
10590 && FRAME_LIVE_P (last_mouse_frame))
10591 f = last_mouse_frame;
10592 else
10593 f = x_window_to_frame (dpyinfo, event.xmotion.window);
10594
10595 if (f)
10596 note_mouse_movement (f, &event.xmotion);
10597 else
10598 {
10599 #ifndef USE_TOOLKIT_SCROLL_BARS
10600 struct scroll_bar *bar
10601 = x_window_to_scroll_bar (event.xmotion.window);
10602
10603 if (bar)
10604 x_scroll_bar_note_movement (bar, &event);
10605 #endif /* USE_TOOLKIT_SCROLL_BARS */
10606
10607 /* If we move outside the frame, then we're
10608 certainly no longer on any text in the frame. */
10609 clear_mouse_face (dpyinfo);
10610 }
10611
10612 /* If the contents of the global variable help_echo
10613 has changed, generate a HELP_EVENT. */
10614 if (!NILP (help_echo)
10615 || !NILP (previous_help_echo))
10616 {
10617 Lisp_Object frame;
10618 int n;
10619
10620 if (f)
10621 XSETFRAME (frame, f);
10622 else
10623 frame = Qnil;
10624
10625 any_help_event_p = 1;
10626 n = gen_help_event (bufp, numchars, help_echo, frame,
10627 help_echo_window, help_echo_object,
10628 help_echo_pos);
10629 bufp += n, count += n, numchars -= n;
10630 }
10631
10632 goto OTHER;
10633 }
10634
10635 case ConfigureNotify:
10636 f = x_top_window_to_frame (dpyinfo, event.xconfigure.window);
10637 if (f)
10638 {
10639 #ifndef USE_X_TOOLKIT
10640 int rows = PIXEL_TO_CHAR_HEIGHT (f, event.xconfigure.height);
10641 int columns = PIXEL_TO_CHAR_WIDTH (f, event.xconfigure.width);
10642
10643 /* In the toolkit version, change_frame_size
10644 is called by the code that handles resizing
10645 of the EmacsFrame widget. */
10646
10647 /* Even if the number of character rows and columns has
10648 not changed, the font size may have changed, so we need
10649 to check the pixel dimensions as well. */
10650 if (columns != f->width
10651 || rows != f->height
10652 || event.xconfigure.width != f->output_data.x->pixel_width
10653 || event.xconfigure.height != f->output_data.x->pixel_height)
10654 {
10655 change_frame_size (f, rows, columns, 0, 1, 0);
10656 SET_FRAME_GARBAGED (f);
10657 cancel_mouse_face (f);
10658 }
10659 #endif
10660
10661 f->output_data.x->pixel_width = event.xconfigure.width;
10662 f->output_data.x->pixel_height = event.xconfigure.height;
10663
10664 /* What we have now is the position of Emacs's own window.
10665 Convert that to the position of the window manager window. */
10666 x_real_positions (f, &f->output_data.x->left_pos,
10667 &f->output_data.x->top_pos);
10668
10669 #ifdef HAVE_X_I18N
10670 if (FRAME_XIC (f) && (FRAME_XIC_STYLE (f) & XIMStatusArea))
10671 xic_set_statusarea (f);
10672 #endif
10673
10674 if (f->output_data.x->parent_desc != FRAME_X_DISPLAY_INFO (f)->root_window)
10675 {
10676 /* Since the WM decorations come below top_pos now,
10677 we must put them below top_pos in the future. */
10678 f->output_data.x->win_gravity = NorthWestGravity;
10679 x_wm_set_size_hint (f, (long) 0, 0);
10680 }
10681 #ifdef USE_MOTIF
10682 /* Some window managers pass (0,0) as the location of
10683 the window, and the Motif event handler stores it
10684 in the emacs widget, which messes up Motif menus. */
10685 if (event.xconfigure.x == 0 && event.xconfigure.y == 0)
10686 {
10687 event.xconfigure.x = f->output_data.x->widget->core.x;
10688 event.xconfigure.y = f->output_data.x->widget->core.y;
10689 }
10690 #endif /* USE_MOTIF */
10691 }
10692 goto OTHER;
10693
10694 case ButtonPress:
10695 case ButtonRelease:
10696 {
10697 /* If we decide we want to generate an event to be seen
10698 by the rest of Emacs, we put it here. */
10699 struct input_event emacs_event;
10700 int tool_bar_p = 0;
10701
10702 emacs_event.kind = no_event;
10703 bzero (&compose_status, sizeof (compose_status));
10704
10705 if (dpyinfo->grabbed
10706 && last_mouse_frame
10707 && FRAME_LIVE_P (last_mouse_frame))
10708 f = last_mouse_frame;
10709 else
10710 f = x_window_to_frame (dpyinfo, event.xbutton.window);
10711
10712 if (f)
10713 {
10714 /* Is this in the tool-bar? */
10715 if (WINDOWP (f->tool_bar_window)
10716 && XFASTINT (XWINDOW (f->tool_bar_window)->height))
10717 {
10718 Lisp_Object window;
10719 int p, x, y;
10720
10721 x = event.xbutton.x;
10722 y = event.xbutton.y;
10723
10724 /* Set x and y. */
10725 window = window_from_coordinates (f, x, y, &p, 1);
10726 if (EQ (window, f->tool_bar_window))
10727 {
10728 x_handle_tool_bar_click (f, &event.xbutton);
10729 tool_bar_p = 1;
10730 }
10731 }
10732
10733 if (!tool_bar_p)
10734 if (!dpyinfo->x_focus_frame
10735 || f == dpyinfo->x_focus_frame)
10736 construct_mouse_click (&emacs_event, &event, f);
10737 }
10738 else
10739 {
10740 #ifndef USE_TOOLKIT_SCROLL_BARS
10741 struct scroll_bar *bar
10742 = x_window_to_scroll_bar (event.xbutton.window);
10743
10744 if (bar)
10745 x_scroll_bar_handle_click (bar, &event, &emacs_event);
10746 #endif /* not USE_TOOLKIT_SCROLL_BARS */
10747 }
10748
10749 if (event.type == ButtonPress)
10750 {
10751 dpyinfo->grabbed |= (1 << event.xbutton.button);
10752 last_mouse_frame = f;
10753 /* Ignore any mouse motion that happened
10754 before this event; any subsequent mouse-movement
10755 Emacs events should reflect only motion after
10756 the ButtonPress. */
10757 if (f != 0)
10758 f->mouse_moved = 0;
10759
10760 if (!tool_bar_p)
10761 last_tool_bar_item = -1;
10762 }
10763 else
10764 {
10765 dpyinfo->grabbed &= ~(1 << event.xbutton.button);
10766 }
10767
10768 if (numchars >= 1 && emacs_event.kind != no_event)
10769 {
10770 bcopy (&emacs_event, bufp, sizeof (struct input_event));
10771 bufp++;
10772 count++;
10773 numchars--;
10774 }
10775
10776 #ifdef USE_X_TOOLKIT
10777 f = x_menubar_window_to_frame (dpyinfo, event.xbutton.window);
10778 /* For a down-event in the menu bar,
10779 don't pass it to Xt right now.
10780 Instead, save it away
10781 and we will pass it to Xt from kbd_buffer_get_event.
10782 That way, we can run some Lisp code first. */
10783 if (f && event.type == ButtonPress
10784 /* Verify the event is really within the menu bar
10785 and not just sent to it due to grabbing. */
10786 && event.xbutton.x >= 0
10787 && event.xbutton.x < f->output_data.x->pixel_width
10788 && event.xbutton.y >= 0
10789 && event.xbutton.y < f->output_data.x->menubar_height
10790 && event.xbutton.same_screen)
10791 {
10792 SET_SAVED_BUTTON_EVENT;
10793 XSETFRAME (last_mouse_press_frame, f);
10794 }
10795 else if (event.type == ButtonPress)
10796 {
10797 last_mouse_press_frame = Qnil;
10798 goto OTHER;
10799 }
10800
10801 #ifdef USE_MOTIF /* This should do not harm for Lucid,
10802 but I am trying to be cautious. */
10803 else if (event.type == ButtonRelease)
10804 {
10805 if (!NILP (last_mouse_press_frame))
10806 {
10807 f = XFRAME (last_mouse_press_frame);
10808 if (f->output_data.x)
10809 SET_SAVED_BUTTON_EVENT;
10810 }
10811 else
10812 goto OTHER;
10813 }
10814 #endif /* USE_MOTIF */
10815 else
10816 goto OTHER;
10817 #endif /* USE_X_TOOLKIT */
10818 }
10819 break;
10820
10821 case CirculateNotify:
10822 goto OTHER;
10823
10824 case CirculateRequest:
10825 goto OTHER;
10826
10827 case VisibilityNotify:
10828 goto OTHER;
10829
10830 case MappingNotify:
10831 /* Someone has changed the keyboard mapping - update the
10832 local cache. */
10833 switch (event.xmapping.request)
10834 {
10835 case MappingModifier:
10836 x_find_modifier_meanings (dpyinfo);
10837 /* This is meant to fall through. */
10838 case MappingKeyboard:
10839 XRefreshKeyboardMapping (&event.xmapping);
10840 }
10841 goto OTHER;
10842
10843 default:
10844 OTHER:
10845 #ifdef USE_X_TOOLKIT
10846 BLOCK_INPUT;
10847 XtDispatchEvent (&event);
10848 UNBLOCK_INPUT;
10849 #endif /* USE_X_TOOLKIT */
10850 break;
10851 }
10852 }
10853 }
10854
10855 out:;
10856
10857 /* On some systems, an X bug causes Emacs to get no more events
10858 when the window is destroyed. Detect that. (1994.) */
10859 if (! event_found)
10860 {
10861 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
10862 One XNOOP in 100 loops will make Emacs terminate.
10863 B. Bretthauer, 1994 */
10864 x_noop_count++;
10865 if (x_noop_count >= 100)
10866 {
10867 x_noop_count=0;
10868
10869 if (next_noop_dpyinfo == 0)
10870 next_noop_dpyinfo = x_display_list;
10871
10872 XNoOp (next_noop_dpyinfo->display);
10873
10874 /* Each time we get here, cycle through the displays now open. */
10875 next_noop_dpyinfo = next_noop_dpyinfo->next;
10876 }
10877 }
10878
10879 /* If the focus was just given to an auto-raising frame,
10880 raise it now. */
10881 /* ??? This ought to be able to handle more than one such frame. */
10882 if (pending_autoraise_frame)
10883 {
10884 x_raise_frame (pending_autoraise_frame);
10885 pending_autoraise_frame = 0;
10886 }
10887
10888 UNBLOCK_INPUT;
10889 --handling_signal;
10890 return count;
10891 }
10892
10893
10894
10895 \f
10896 /***********************************************************************
10897 Text Cursor
10898 ***********************************************************************/
10899
10900 /* Note if the text cursor of window W has been overwritten by a
10901 drawing operation that outputs N glyphs starting at HPOS in the
10902 line given by output_cursor.vpos. N < 0 means all the rest of the
10903 line after HPOS has been written. */
10904
10905 static void
10906 note_overwritten_text_cursor (w, hpos, n)
10907 struct window *w;
10908 int hpos, n;
10909 {
10910 if (updated_area == TEXT_AREA
10911 && output_cursor.vpos == w->phys_cursor.vpos
10912 && hpos <= w->phys_cursor.hpos
10913 && (n < 0
10914 || hpos + n > w->phys_cursor.hpos))
10915 w->phys_cursor_on_p = 0;
10916 }
10917
10918
10919 /* Set clipping for output in glyph row ROW. W is the window in which
10920 we operate. GC is the graphics context to set clipping in.
10921 WHOLE_LINE_P non-zero means include the areas used for truncation
10922 mark display and alike in the clipping rectangle.
10923
10924 ROW may be a text row or, e.g., a mode line. Text rows must be
10925 clipped to the interior of the window dedicated to text display,
10926 mode lines must be clipped to the whole window. */
10927
10928 static void
10929 x_clip_to_row (w, row, gc, whole_line_p)
10930 struct window *w;
10931 struct glyph_row *row;
10932 GC gc;
10933 int whole_line_p;
10934 {
10935 struct frame *f = XFRAME (WINDOW_FRAME (w));
10936 XRectangle clip_rect;
10937 int window_x, window_y, window_width, window_height;
10938
10939 window_box (w, -1, &window_x, &window_y, &window_width, &window_height);
10940
10941 clip_rect.x = WINDOW_TO_FRAME_PIXEL_X (w, 0);
10942 clip_rect.y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
10943 clip_rect.y = max (clip_rect.y, window_y);
10944 clip_rect.width = window_width;
10945 clip_rect.height = row->visible_height;
10946
10947 /* If clipping to the whole line, including trunc marks, extend
10948 the rectangle to the left and increase its width. */
10949 if (whole_line_p)
10950 {
10951 clip_rect.x -= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f);
10952 clip_rect.width += FRAME_X_FLAGS_AREA_WIDTH (f);
10953 }
10954
10955 XSetClipRectangles (FRAME_X_DISPLAY (f), gc, 0, 0, &clip_rect, 1, Unsorted);
10956 }
10957
10958
10959 /* Draw a hollow box cursor on window W in glyph row ROW. */
10960
10961 static void
10962 x_draw_hollow_cursor (w, row)
10963 struct window *w;
10964 struct glyph_row *row;
10965 {
10966 struct frame *f = XFRAME (WINDOW_FRAME (w));
10967 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
10968 Display *dpy = FRAME_X_DISPLAY (f);
10969 int x, y, wd, h;
10970 XGCValues xgcv;
10971 struct glyph *cursor_glyph;
10972 GC gc;
10973
10974 /* Compute frame-relative coordinates from window-relative
10975 coordinates. */
10976 x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
10977 y = (WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y)
10978 + row->ascent - w->phys_cursor_ascent);
10979 h = row->height - 1;
10980
10981 /* Get the glyph the cursor is on. If we can't tell because
10982 the current matrix is invalid or such, give up. */
10983 cursor_glyph = get_phys_cursor_glyph (w);
10984 if (cursor_glyph == NULL)
10985 return;
10986
10987 /* Compute the width of the rectangle to draw. If on a stretch
10988 glyph, and `x-stretch-block-cursor' is nil, don't draw a
10989 rectangle as wide as the glyph, but use a canonical character
10990 width instead. */
10991 wd = cursor_glyph->pixel_width - 1;
10992 if (cursor_glyph->type == STRETCH_GLYPH
10993 && !x_stretch_cursor_p)
10994 wd = min (CANON_X_UNIT (f), wd);
10995
10996 /* The foreground of cursor_gc is typically the same as the normal
10997 background color, which can cause the cursor box to be invisible. */
10998 xgcv.foreground = f->output_data.x->cursor_pixel;
10999 if (dpyinfo->scratch_cursor_gc)
11000 XChangeGC (dpy, dpyinfo->scratch_cursor_gc, GCForeground, &xgcv);
11001 else
11002 dpyinfo->scratch_cursor_gc = XCreateGC (dpy, FRAME_X_WINDOW (f),
11003 GCForeground, &xgcv);
11004 gc = dpyinfo->scratch_cursor_gc;
11005
11006 /* Set clipping, draw the rectangle, and reset clipping again. */
11007 x_clip_to_row (w, row, gc, 0);
11008 XDrawRectangle (dpy, FRAME_X_WINDOW (f), gc, x, y, wd, h);
11009 XSetClipMask (dpy, gc, None);
11010 }
11011
11012
11013 /* Draw a bar cursor on window W in glyph row ROW.
11014
11015 Implementation note: One would like to draw a bar cursor with an
11016 angle equal to the one given by the font property XA_ITALIC_ANGLE.
11017 Unfortunately, I didn't find a font yet that has this property set.
11018 --gerd. */
11019
11020 static void
11021 x_draw_bar_cursor (w, row, width)
11022 struct window *w;
11023 struct glyph_row *row;
11024 int width;
11025 {
11026 struct frame *f = XFRAME (w->frame);
11027 struct glyph *cursor_glyph;
11028 GC gc;
11029 int x;
11030 unsigned long mask;
11031 XGCValues xgcv;
11032 Display *dpy;
11033 Window window;
11034
11035 /* If cursor is out of bounds, don't draw garbage. This can happen
11036 in mini-buffer windows when switching between echo area glyphs
11037 and mini-buffer. */
11038 cursor_glyph = get_phys_cursor_glyph (w);
11039 if (cursor_glyph == NULL)
11040 return;
11041
11042 /* If on an image, draw like a normal cursor. That's usually better
11043 visible than drawing a bar, esp. if the image is large so that
11044 the bar might not be in the window. */
11045 if (cursor_glyph->type == IMAGE_GLYPH)
11046 {
11047 struct glyph_row *row;
11048 row = MATRIX_ROW (w->current_matrix, w->phys_cursor.vpos);
11049 x_draw_phys_cursor_glyph (w, row, DRAW_CURSOR);
11050 }
11051 else
11052 {
11053 xgcv.background = f->output_data.x->cursor_pixel;
11054 xgcv.foreground = f->output_data.x->cursor_pixel;
11055 xgcv.graphics_exposures = 0;
11056 mask = GCForeground | GCBackground | GCGraphicsExposures;
11057 dpy = FRAME_X_DISPLAY (f);
11058 window = FRAME_X_WINDOW (f);
11059 gc = FRAME_X_DISPLAY_INFO (f)->scratch_cursor_gc;
11060
11061 if (gc)
11062 XChangeGC (dpy, gc, mask, &xgcv);
11063 else
11064 {
11065 gc = XCreateGC (dpy, window, mask, &xgcv);
11066 FRAME_X_DISPLAY_INFO (f)->scratch_cursor_gc = gc;
11067 }
11068
11069 if (width < 0)
11070 width = f->output_data.x->cursor_width;
11071
11072 x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
11073 x_clip_to_row (w, row, gc, 0);
11074 XFillRectangle (dpy, window, gc,
11075 x,
11076 WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y),
11077 min (cursor_glyph->pixel_width, width),
11078 row->height);
11079 XSetClipMask (dpy, gc, None);
11080 }
11081 }
11082
11083
11084 /* Clear the cursor of window W to background color, and mark the
11085 cursor as not shown. This is used when the text where the cursor
11086 is is about to be rewritten. */
11087
11088 static void
11089 x_clear_cursor (w)
11090 struct window *w;
11091 {
11092 if (FRAME_VISIBLE_P (XFRAME (w->frame)) && w->phys_cursor_on_p)
11093 x_update_window_cursor (w, 0);
11094 }
11095
11096
11097 /* Draw the cursor glyph of window W in glyph row ROW. See the
11098 comment of x_draw_glyphs for the meaning of HL. */
11099
11100 static void
11101 x_draw_phys_cursor_glyph (w, row, hl)
11102 struct window *w;
11103 struct glyph_row *row;
11104 enum draw_glyphs_face hl;
11105 {
11106 /* If cursor hpos is out of bounds, don't draw garbage. This can
11107 happen in mini-buffer windows when switching between echo area
11108 glyphs and mini-buffer. */
11109 if (w->phys_cursor.hpos < row->used[TEXT_AREA])
11110 {
11111 x_draw_glyphs (w, w->phys_cursor.x, row, TEXT_AREA,
11112 w->phys_cursor.hpos, w->phys_cursor.hpos + 1,
11113 hl, 0, 0, 0);
11114
11115 /* When we erase the cursor, and ROW is overlapped by other
11116 rows, make sure that these overlapping parts of other rows
11117 are redrawn. */
11118 if (hl == DRAW_NORMAL_TEXT && row->overlapped_p)
11119 {
11120 if (row > w->current_matrix->rows
11121 && MATRIX_ROW_OVERLAPS_SUCC_P (row - 1))
11122 x_fix_overlapping_area (w, row - 1, TEXT_AREA);
11123
11124 if (MATRIX_ROW_BOTTOM_Y (row) < window_text_bottom_y (w)
11125 && MATRIX_ROW_OVERLAPS_PRED_P (row + 1))
11126 x_fix_overlapping_area (w, row + 1, TEXT_AREA);
11127 }
11128 }
11129 }
11130
11131
11132 /* Erase the image of a cursor of window W from the screen. */
11133
11134 static void
11135 x_erase_phys_cursor (w)
11136 struct window *w;
11137 {
11138 struct frame *f = XFRAME (w->frame);
11139 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
11140 int hpos = w->phys_cursor.hpos;
11141 int vpos = w->phys_cursor.vpos;
11142 int mouse_face_here_p = 0;
11143 struct glyph_matrix *active_glyphs = w->current_matrix;
11144 struct glyph_row *cursor_row;
11145 struct glyph *cursor_glyph;
11146 enum draw_glyphs_face hl;
11147
11148 /* No cursor displayed or row invalidated => nothing to do on the
11149 screen. */
11150 if (w->phys_cursor_type == NO_CURSOR)
11151 goto mark_cursor_off;
11152
11153 /* VPOS >= active_glyphs->nrows means that window has been resized.
11154 Don't bother to erase the cursor. */
11155 if (vpos >= active_glyphs->nrows)
11156 goto mark_cursor_off;
11157
11158 /* If row containing cursor is marked invalid, there is nothing we
11159 can do. */
11160 cursor_row = MATRIX_ROW (active_glyphs, vpos);
11161 if (!cursor_row->enabled_p)
11162 goto mark_cursor_off;
11163
11164 /* This can happen when the new row is shorter than the old one.
11165 In this case, either x_draw_glyphs or clear_end_of_line
11166 should have cleared the cursor. Note that we wouldn't be
11167 able to erase the cursor in this case because we don't have a
11168 cursor glyph at hand. */
11169 if (w->phys_cursor.hpos >= cursor_row->used[TEXT_AREA])
11170 goto mark_cursor_off;
11171
11172 /* If the cursor is in the mouse face area, redisplay that when
11173 we clear the cursor. */
11174 if (! NILP (dpyinfo->mouse_face_window)
11175 && w == XWINDOW (dpyinfo->mouse_face_window)
11176 && (vpos > dpyinfo->mouse_face_beg_row
11177 || (vpos == dpyinfo->mouse_face_beg_row
11178 && hpos >= dpyinfo->mouse_face_beg_col))
11179 && (vpos < dpyinfo->mouse_face_end_row
11180 || (vpos == dpyinfo->mouse_face_end_row
11181 && hpos < dpyinfo->mouse_face_end_col))
11182 /* Don't redraw the cursor's spot in mouse face if it is at the
11183 end of a line (on a newline). The cursor appears there, but
11184 mouse highlighting does not. */
11185 && cursor_row->used[TEXT_AREA] > hpos)
11186 mouse_face_here_p = 1;
11187
11188 /* Maybe clear the display under the cursor. */
11189 if (w->phys_cursor_type == HOLLOW_BOX_CURSOR)
11190 {
11191 int x;
11192 int header_line_height = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
11193
11194 cursor_glyph = get_phys_cursor_glyph (w);
11195 if (cursor_glyph == NULL)
11196 goto mark_cursor_off;
11197
11198 x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x),
11199
11200 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
11201 x,
11202 WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
11203 cursor_row->y)),
11204 cursor_glyph->pixel_width,
11205 cursor_row->visible_height,
11206 False);
11207 }
11208
11209 /* Erase the cursor by redrawing the character underneath it. */
11210 if (mouse_face_here_p)
11211 hl = DRAW_MOUSE_FACE;
11212 else if (cursor_row->inverse_p)
11213 hl = DRAW_INVERSE_VIDEO;
11214 else
11215 hl = DRAW_NORMAL_TEXT;
11216 x_draw_phys_cursor_glyph (w, cursor_row, hl);
11217
11218 mark_cursor_off:
11219 w->phys_cursor_on_p = 0;
11220 w->phys_cursor_type = NO_CURSOR;
11221 }
11222
11223
11224 /* Non-zero if physical cursor of window W is within mouse face. */
11225
11226 static int
11227 cursor_in_mouse_face_p (w)
11228 struct window *w;
11229 {
11230 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (XFRAME (w->frame));
11231 int in_mouse_face = 0;
11232
11233 if (WINDOWP (dpyinfo->mouse_face_window)
11234 && XWINDOW (dpyinfo->mouse_face_window) == w)
11235 {
11236 int hpos = w->phys_cursor.hpos;
11237 int vpos = w->phys_cursor.vpos;
11238
11239 if (vpos >= dpyinfo->mouse_face_beg_row
11240 && vpos <= dpyinfo->mouse_face_end_row
11241 && (vpos > dpyinfo->mouse_face_beg_row
11242 || hpos >= dpyinfo->mouse_face_beg_col)
11243 && (vpos < dpyinfo->mouse_face_end_row
11244 || hpos < dpyinfo->mouse_face_end_col
11245 || dpyinfo->mouse_face_past_end))
11246 in_mouse_face = 1;
11247 }
11248
11249 return in_mouse_face;
11250 }
11251
11252
11253 /* Display or clear cursor of window W. If ON is zero, clear the
11254 cursor. If it is non-zero, display the cursor. If ON is nonzero,
11255 where to put the cursor is specified by HPOS, VPOS, X and Y. */
11256
11257 void
11258 x_display_and_set_cursor (w, on, hpos, vpos, x, y)
11259 struct window *w;
11260 int on, hpos, vpos, x, y;
11261 {
11262 struct frame *f = XFRAME (w->frame);
11263 int new_cursor_type;
11264 int new_cursor_width;
11265 struct glyph_matrix *current_glyphs;
11266 struct glyph_row *glyph_row;
11267 struct glyph *glyph;
11268
11269 /* This is pointless on invisible frames, and dangerous on garbaged
11270 windows and frames; in the latter case, the frame or window may
11271 be in the midst of changing its size, and x and y may be off the
11272 window. */
11273 if (! FRAME_VISIBLE_P (f)
11274 || FRAME_GARBAGED_P (f)
11275 || vpos >= w->current_matrix->nrows
11276 || hpos >= w->current_matrix->matrix_w)
11277 return;
11278
11279 /* If cursor is off and we want it off, return quickly. */
11280 if (!on && !w->phys_cursor_on_p)
11281 return;
11282
11283 current_glyphs = w->current_matrix;
11284 glyph_row = MATRIX_ROW (current_glyphs, vpos);
11285 glyph = glyph_row->glyphs[TEXT_AREA] + hpos;
11286
11287 /* If cursor row is not enabled, we don't really know where to
11288 display the cursor. */
11289 if (!glyph_row->enabled_p)
11290 {
11291 w->phys_cursor_on_p = 0;
11292 return;
11293 }
11294
11295 xassert (interrupt_input_blocked);
11296
11297 /* Set new_cursor_type to the cursor we want to be displayed. In a
11298 mini-buffer window, we want the cursor only to appear if we are
11299 reading input from this window. For the selected window, we want
11300 the cursor type given by the frame parameter. If explicitly
11301 marked off, draw no cursor. In all other cases, we want a hollow
11302 box cursor. */
11303 new_cursor_width = -1;
11304 if (cursor_in_echo_area
11305 && FRAME_HAS_MINIBUF_P (f)
11306 && EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
11307 {
11308 if (w == XWINDOW (echo_area_window))
11309 new_cursor_type = FRAME_DESIRED_CURSOR (f);
11310 else
11311 new_cursor_type = HOLLOW_BOX_CURSOR;
11312 }
11313 else
11314 {
11315 if (f != FRAME_X_DISPLAY_INFO (f)->x_highlight_frame
11316 || w != XWINDOW (f->selected_window))
11317 {
11318 extern int cursor_in_non_selected_windows;
11319
11320 if (MINI_WINDOW_P (w)
11321 || !cursor_in_non_selected_windows
11322 || NILP (XBUFFER (w->buffer)->cursor_type))
11323 new_cursor_type = NO_CURSOR;
11324 else
11325 new_cursor_type = HOLLOW_BOX_CURSOR;
11326 }
11327 else if (w->cursor_off_p)
11328 new_cursor_type = NO_CURSOR;
11329 else
11330 {
11331 struct buffer *b = XBUFFER (w->buffer);
11332
11333 if (EQ (b->cursor_type, Qt))
11334 new_cursor_type = FRAME_DESIRED_CURSOR (f);
11335 else
11336 new_cursor_type = x_specified_cursor_type (b->cursor_type,
11337 &new_cursor_width);
11338 }
11339 }
11340
11341 /* If cursor is currently being shown and we don't want it to be or
11342 it is in the wrong place, or the cursor type is not what we want,
11343 erase it. */
11344 if (w->phys_cursor_on_p
11345 && (!on
11346 || w->phys_cursor.x != x
11347 || w->phys_cursor.y != y
11348 || new_cursor_type != w->phys_cursor_type))
11349 x_erase_phys_cursor (w);
11350
11351 /* If the cursor is now invisible and we want it to be visible,
11352 display it. */
11353 if (on && !w->phys_cursor_on_p)
11354 {
11355 w->phys_cursor_ascent = glyph_row->ascent;
11356 w->phys_cursor_height = glyph_row->height;
11357
11358 /* Set phys_cursor_.* before x_draw_.* is called because some
11359 of them may need the information. */
11360 w->phys_cursor.x = x;
11361 w->phys_cursor.y = glyph_row->y;
11362 w->phys_cursor.hpos = hpos;
11363 w->phys_cursor.vpos = vpos;
11364 w->phys_cursor_type = new_cursor_type;
11365 w->phys_cursor_on_p = 1;
11366
11367 switch (new_cursor_type)
11368 {
11369 case HOLLOW_BOX_CURSOR:
11370 x_draw_hollow_cursor (w, glyph_row);
11371 break;
11372
11373 case FILLED_BOX_CURSOR:
11374 x_draw_phys_cursor_glyph (w, glyph_row, DRAW_CURSOR);
11375 break;
11376
11377 case BAR_CURSOR:
11378 x_draw_bar_cursor (w, glyph_row, new_cursor_width);
11379 break;
11380
11381 case NO_CURSOR:
11382 break;
11383
11384 default:
11385 abort ();
11386 }
11387
11388 #ifdef HAVE_X_I18N
11389 if (w == XWINDOW (f->selected_window))
11390 if (FRAME_XIC (f) && (FRAME_XIC_STYLE (f) & XIMPreeditPosition))
11391 xic_set_preeditarea (w, x, y);
11392 #endif
11393 }
11394
11395 #ifndef XFlush
11396 if (updating_frame != f)
11397 XFlush (FRAME_X_DISPLAY (f));
11398 #endif
11399 }
11400
11401
11402 /* Display the cursor on window W, or clear it. X and Y are window
11403 relative pixel coordinates. HPOS and VPOS are glyph matrix
11404 positions. If W is not the selected window, display a hollow
11405 cursor. ON non-zero means display the cursor at X, Y which
11406 correspond to HPOS, VPOS, otherwise it is cleared. */
11407
11408 void
11409 x_display_cursor (w, on, hpos, vpos, x, y)
11410 struct window *w;
11411 int on, hpos, vpos, x, y;
11412 {
11413 BLOCK_INPUT;
11414 x_display_and_set_cursor (w, on, hpos, vpos, x, y);
11415 UNBLOCK_INPUT;
11416 }
11417
11418
11419 /* Display the cursor on window W, or clear it, according to ON_P.
11420 Don't change the cursor's position. */
11421
11422 void
11423 x_update_cursor (f, on_p)
11424 struct frame *f;
11425 {
11426 x_update_cursor_in_window_tree (XWINDOW (f->root_window), on_p);
11427 }
11428
11429
11430 /* Call x_update_window_cursor with parameter ON_P on all leaf windows
11431 in the window tree rooted at W. */
11432
11433 static void
11434 x_update_cursor_in_window_tree (w, on_p)
11435 struct window *w;
11436 int on_p;
11437 {
11438 while (w)
11439 {
11440 if (!NILP (w->hchild))
11441 x_update_cursor_in_window_tree (XWINDOW (w->hchild), on_p);
11442 else if (!NILP (w->vchild))
11443 x_update_cursor_in_window_tree (XWINDOW (w->vchild), on_p);
11444 else
11445 x_update_window_cursor (w, on_p);
11446
11447 w = NILP (w->next) ? 0 : XWINDOW (w->next);
11448 }
11449 }
11450
11451
11452 /* Switch the display of W's cursor on or off, according to the value
11453 of ON. */
11454
11455 static void
11456 x_update_window_cursor (w, on)
11457 struct window *w;
11458 int on;
11459 {
11460 /* Don't update cursor in windows whose frame is in the process
11461 of being deleted. */
11462 if (w->current_matrix)
11463 {
11464 BLOCK_INPUT;
11465 x_display_and_set_cursor (w, on, w->phys_cursor.hpos, w->phys_cursor.vpos,
11466 w->phys_cursor.x, w->phys_cursor.y);
11467 UNBLOCK_INPUT;
11468 }
11469 }
11470
11471
11472
11473 \f
11474 /* Icons. */
11475
11476 /* Refresh bitmap kitchen sink icon for frame F
11477 when we get an expose event for it. */
11478
11479 void
11480 refreshicon (f)
11481 struct frame *f;
11482 {
11483 /* Normally, the window manager handles this function. */
11484 }
11485
11486 /* Make the x-window of frame F use the gnu icon bitmap. */
11487
11488 int
11489 x_bitmap_icon (f, file)
11490 struct frame *f;
11491 Lisp_Object file;
11492 {
11493 int bitmap_id;
11494
11495 if (FRAME_X_WINDOW (f) == 0)
11496 return 1;
11497
11498 /* Free up our existing icon bitmap if any. */
11499 if (f->output_data.x->icon_bitmap > 0)
11500 x_destroy_bitmap (f, f->output_data.x->icon_bitmap);
11501 f->output_data.x->icon_bitmap = 0;
11502
11503 if (STRINGP (file))
11504 bitmap_id = x_create_bitmap_from_file (f, file);
11505 else
11506 {
11507 /* Create the GNU bitmap if necessary. */
11508 if (FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id < 0)
11509 FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id
11510 = x_create_bitmap_from_data (f, gnu_bits,
11511 gnu_width, gnu_height);
11512
11513 /* The first time we create the GNU bitmap,
11514 this increments the ref-count one extra time.
11515 As a result, the GNU bitmap is never freed.
11516 That way, we don't have to worry about allocating it again. */
11517 x_reference_bitmap (f, FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id);
11518
11519 bitmap_id = FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id;
11520 }
11521
11522 x_wm_set_icon_pixmap (f, bitmap_id);
11523 f->output_data.x->icon_bitmap = bitmap_id;
11524
11525 return 0;
11526 }
11527
11528
11529 /* Make the x-window of frame F use a rectangle with text.
11530 Use ICON_NAME as the text. */
11531
11532 int
11533 x_text_icon (f, icon_name)
11534 struct frame *f;
11535 char *icon_name;
11536 {
11537 if (FRAME_X_WINDOW (f) == 0)
11538 return 1;
11539
11540 #ifdef HAVE_X11R4
11541 {
11542 XTextProperty text;
11543 text.value = (unsigned char *) icon_name;
11544 text.encoding = XA_STRING;
11545 text.format = 8;
11546 text.nitems = strlen (icon_name);
11547 #ifdef USE_X_TOOLKIT
11548 XSetWMIconName (FRAME_X_DISPLAY (f), XtWindow (f->output_data.x->widget),
11549 &text);
11550 #else /* not USE_X_TOOLKIT */
11551 XSetWMIconName (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), &text);
11552 #endif /* not USE_X_TOOLKIT */
11553 }
11554 #else /* not HAVE_X11R4 */
11555 XSetIconName (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), icon_name);
11556 #endif /* not HAVE_X11R4 */
11557
11558 if (f->output_data.x->icon_bitmap > 0)
11559 x_destroy_bitmap (f, f->output_data.x->icon_bitmap);
11560 f->output_data.x->icon_bitmap = 0;
11561 x_wm_set_icon_pixmap (f, 0);
11562
11563 return 0;
11564 }
11565 \f
11566 #define X_ERROR_MESSAGE_SIZE 200
11567
11568 /* If non-nil, this should be a string.
11569 It means catch X errors and store the error message in this string. */
11570
11571 static Lisp_Object x_error_message_string;
11572
11573 /* An X error handler which stores the error message in
11574 x_error_message_string. This is called from x_error_handler if
11575 x_catch_errors is in effect. */
11576
11577 static void
11578 x_error_catcher (display, error)
11579 Display *display;
11580 XErrorEvent *error;
11581 {
11582 XGetErrorText (display, error->error_code,
11583 XSTRING (x_error_message_string)->data,
11584 X_ERROR_MESSAGE_SIZE);
11585 }
11586
11587 /* Begin trapping X errors for display DPY. Actually we trap X errors
11588 for all displays, but DPY should be the display you are actually
11589 operating on.
11590
11591 After calling this function, X protocol errors no longer cause
11592 Emacs to exit; instead, they are recorded in the string
11593 stored in x_error_message_string.
11594
11595 Calling x_check_errors signals an Emacs error if an X error has
11596 occurred since the last call to x_catch_errors or x_check_errors.
11597
11598 Calling x_uncatch_errors resumes the normal error handling. */
11599
11600 void x_check_errors ();
11601 static Lisp_Object x_catch_errors_unwind ();
11602
11603 int
11604 x_catch_errors (dpy)
11605 Display *dpy;
11606 {
11607 int count = specpdl_ptr - specpdl;
11608
11609 /* Make sure any errors from previous requests have been dealt with. */
11610 XSync (dpy, False);
11611
11612 record_unwind_protect (x_catch_errors_unwind, x_error_message_string);
11613
11614 x_error_message_string = make_uninit_string (X_ERROR_MESSAGE_SIZE);
11615 XSTRING (x_error_message_string)->data[0] = 0;
11616
11617 return count;
11618 }
11619
11620 /* Unbind the binding that we made to check for X errors. */
11621
11622 static Lisp_Object
11623 x_catch_errors_unwind (old_val)
11624 Lisp_Object old_val;
11625 {
11626 x_error_message_string = old_val;
11627 return Qnil;
11628 }
11629
11630 /* If any X protocol errors have arrived since the last call to
11631 x_catch_errors or x_check_errors, signal an Emacs error using
11632 sprintf (a buffer, FORMAT, the x error message text) as the text. */
11633
11634 void
11635 x_check_errors (dpy, format)
11636 Display *dpy;
11637 char *format;
11638 {
11639 /* Make sure to catch any errors incurred so far. */
11640 XSync (dpy, False);
11641
11642 if (XSTRING (x_error_message_string)->data[0])
11643 error (format, XSTRING (x_error_message_string)->data);
11644 }
11645
11646 /* Nonzero if we had any X protocol errors
11647 since we did x_catch_errors on DPY. */
11648
11649 int
11650 x_had_errors_p (dpy)
11651 Display *dpy;
11652 {
11653 /* Make sure to catch any errors incurred so far. */
11654 XSync (dpy, False);
11655
11656 return XSTRING (x_error_message_string)->data[0] != 0;
11657 }
11658
11659 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
11660
11661 void
11662 x_clear_errors (dpy)
11663 Display *dpy;
11664 {
11665 XSTRING (x_error_message_string)->data[0] = 0;
11666 }
11667
11668 /* Stop catching X protocol errors and let them make Emacs die.
11669 DPY should be the display that was passed to x_catch_errors.
11670 COUNT should be the value that was returned by
11671 the corresponding call to x_catch_errors. */
11672
11673 void
11674 x_uncatch_errors (dpy, count)
11675 Display *dpy;
11676 int count;
11677 {
11678 unbind_to (count, Qnil);
11679 }
11680
11681 #if 0
11682 static unsigned int x_wire_count;
11683 x_trace_wire ()
11684 {
11685 fprintf (stderr, "Lib call: %d\n", ++x_wire_count);
11686 }
11687 #endif /* ! 0 */
11688
11689 \f
11690 /* Handle SIGPIPE, which can happen when the connection to a server
11691 simply goes away. SIGPIPE is handled by x_connection_signal.
11692 Don't need to do anything, because the write which caused the
11693 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
11694 which will do the appropriate cleanup for us. */
11695
11696 static SIGTYPE
11697 x_connection_signal (signalnum) /* If we don't have an argument, */
11698 int signalnum; /* some compilers complain in signal calls. */
11699 {
11700 #ifdef USG
11701 /* USG systems forget handlers when they are used;
11702 must reestablish each time */
11703 signal (signalnum, x_connection_signal);
11704 #endif /* USG */
11705 }
11706
11707 \f
11708 /************************************************************************
11709 Handling X errors
11710 ************************************************************************/
11711
11712 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
11713 the text of an error message that lead to the connection loss. */
11714
11715 static SIGTYPE
11716 x_connection_closed (dpy, error_message)
11717 Display *dpy;
11718 char *error_message;
11719 {
11720 struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
11721 Lisp_Object frame, tail;
11722 int count;
11723 char *msg;
11724
11725 msg = (char *) alloca (strlen (error_message) + 1);
11726 strcpy (msg, error_message);
11727 handling_signal = 0;
11728
11729 /* Prevent being called recursively because of an error condition
11730 below. Otherwise, we might end up with printing ``can't find per
11731 display information'' in the recursive call instead of printing
11732 the original message here. */
11733 count = x_catch_errors (dpy);
11734
11735 /* We have to close the display to inform Xt that it doesn't
11736 exist anymore. If we don't, Xt will continue to wait for
11737 events from the display. As a consequence, a sequence of
11738
11739 M-x make-frame-on-display RET :1 RET
11740 ...kill the new frame, so that we get an IO error...
11741 M-x make-frame-on-display RET :1 RET
11742
11743 will indefinitely wait in Xt for events for display `:1', opened
11744 in the first class to make-frame-on-display.
11745
11746 Closing the display is reported to lead to a bus error on
11747 OpenWindows in certain situations. I suspect that is a bug
11748 in OpenWindows. I don't know how to cicumvent it here. */
11749
11750 #ifdef USE_X_TOOLKIT
11751 /* If DPYINFO is null, this means we didn't open the display
11752 in the first place, so don't try to close it. */
11753 if (dpyinfo)
11754 XtCloseDisplay (dpy);
11755 #endif
11756
11757 /* Indicate that this display is dead. */
11758 if (dpyinfo)
11759 dpyinfo->display = 0;
11760
11761 /* First delete frames whose mini-buffers are on frames
11762 that are on the dead display. */
11763 FOR_EACH_FRAME (tail, frame)
11764 {
11765 Lisp_Object minibuf_frame;
11766 minibuf_frame
11767 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame))));
11768 if (FRAME_X_P (XFRAME (frame))
11769 && FRAME_X_P (XFRAME (minibuf_frame))
11770 && ! EQ (frame, minibuf_frame)
11771 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame)) == dpyinfo)
11772 Fdelete_frame (frame, Qt);
11773 }
11774
11775 /* Now delete all remaining frames on the dead display.
11776 We are now sure none of these is used as the mini-buffer
11777 for another frame that we need to delete. */
11778 FOR_EACH_FRAME (tail, frame)
11779 if (FRAME_X_P (XFRAME (frame))
11780 && FRAME_X_DISPLAY_INFO (XFRAME (frame)) == dpyinfo)
11781 {
11782 /* Set this to t so that Fdelete_frame won't get confused
11783 trying to find a replacement. */
11784 FRAME_KBOARD (XFRAME (frame))->Vdefault_minibuffer_frame = Qt;
11785 Fdelete_frame (frame, Qt);
11786 }
11787
11788 if (dpyinfo)
11789 x_delete_display (dpyinfo);
11790
11791 x_uncatch_errors (dpy, count);
11792
11793 if (x_display_list == 0)
11794 {
11795 fprintf (stderr, "%s\n", msg);
11796 shut_down_emacs (0, 0, Qnil);
11797 exit (70);
11798 }
11799
11800 /* Ordinary stack unwind doesn't deal with these. */
11801 #ifdef SIGIO
11802 sigunblock (sigmask (SIGIO));
11803 #endif
11804 sigunblock (sigmask (SIGALRM));
11805 TOTALLY_UNBLOCK_INPUT;
11806
11807 clear_waiting_for_input ();
11808 error ("%s", msg);
11809 }
11810
11811
11812 /* This is the usual handler for X protocol errors.
11813 It kills all frames on the display that we got the error for.
11814 If that was the only one, it prints an error message and kills Emacs. */
11815
11816 static void
11817 x_error_quitter (display, error)
11818 Display *display;
11819 XErrorEvent *error;
11820 {
11821 char buf[256], buf1[356];
11822
11823 /* Note that there is no real way portable across R3/R4 to get the
11824 original error handler. */
11825
11826 XGetErrorText (display, error->error_code, buf, sizeof (buf));
11827 sprintf (buf1, "X protocol error: %s on protocol request %d",
11828 buf, error->request_code);
11829 x_connection_closed (display, buf1);
11830 }
11831
11832
11833 /* This is the first-level handler for X protocol errors.
11834 It calls x_error_quitter or x_error_catcher. */
11835
11836 static int
11837 x_error_handler (display, error)
11838 Display *display;
11839 XErrorEvent *error;
11840 {
11841 if (! NILP (x_error_message_string))
11842 x_error_catcher (display, error);
11843 else
11844 x_error_quitter (display, error);
11845 return 0;
11846 }
11847
11848 /* This is the handler for X IO errors, always.
11849 It kills all frames on the display that we lost touch with.
11850 If that was the only one, it prints an error message and kills Emacs. */
11851
11852 static int
11853 x_io_error_quitter (display)
11854 Display *display;
11855 {
11856 char buf[256];
11857
11858 sprintf (buf, "Connection lost to X server `%s'", DisplayString (display));
11859 x_connection_closed (display, buf);
11860 return 0;
11861 }
11862 \f
11863 /* Changing the font of the frame. */
11864
11865 /* Give frame F the font named FONTNAME as its default font, and
11866 return the full name of that font. FONTNAME may be a wildcard
11867 pattern; in that case, we choose some font that fits the pattern.
11868 The return value shows which font we chose. */
11869
11870 Lisp_Object
11871 x_new_font (f, fontname)
11872 struct frame *f;
11873 register char *fontname;
11874 {
11875 struct font_info *fontp
11876 = FS_LOAD_FONT (f, 0, fontname, -1);
11877
11878 if (!fontp)
11879 return Qnil;
11880
11881 f->output_data.x->font = (XFontStruct *) (fontp->font);
11882 f->output_data.x->baseline_offset = fontp->baseline_offset;
11883 f->output_data.x->fontset = -1;
11884
11885 /* Compute the scroll bar width in character columns. */
11886 if (f->scroll_bar_pixel_width > 0)
11887 {
11888 int wid = FONT_WIDTH (f->output_data.x->font);
11889 f->scroll_bar_cols = (f->scroll_bar_pixel_width + wid-1) / wid;
11890 }
11891 else
11892 {
11893 int wid = FONT_WIDTH (f->output_data.x->font);
11894 f->scroll_bar_cols = (14 + wid - 1) / wid;
11895 }
11896
11897 /* Now make the frame display the given font. */
11898 if (FRAME_X_WINDOW (f) != 0)
11899 {
11900 XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->normal_gc,
11901 f->output_data.x->font->fid);
11902 XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->reverse_gc,
11903 f->output_data.x->font->fid);
11904 XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->cursor_gc,
11905 f->output_data.x->font->fid);
11906
11907 frame_update_line_height (f);
11908
11909 /* Don't change the size of a tip frame; there's no point in
11910 doing it because it's done in Fx_show_tip, and it leads to
11911 problems because the tip frame has no widget. */
11912 if (NILP (tip_frame) || XFRAME (tip_frame) != f)
11913 x_set_window_size (f, 0, f->width, f->height);
11914 }
11915 else
11916 /* If we are setting a new frame's font for the first time,
11917 there are no faces yet, so this font's height is the line height. */
11918 f->output_data.x->line_height = FONT_HEIGHT (f->output_data.x->font);
11919
11920 return build_string (fontp->full_name);
11921 }
11922
11923 /* Give frame F the fontset named FONTSETNAME as its default font, and
11924 return the full name of that fontset. FONTSETNAME may be a wildcard
11925 pattern; in that case, we choose some fontset that fits the pattern.
11926 The return value shows which fontset we chose. */
11927
11928 Lisp_Object
11929 x_new_fontset (f, fontsetname)
11930 struct frame *f;
11931 char *fontsetname;
11932 {
11933 int fontset = fs_query_fontset (build_string (fontsetname), 0);
11934 Lisp_Object result;
11935
11936 if (fontset < 0)
11937 return Qnil;
11938
11939 if (f->output_data.x->fontset == fontset)
11940 /* This fontset is already set in frame F. There's nothing more
11941 to do. */
11942 return fontset_name (fontset);
11943
11944 result = x_new_font (f, (XSTRING (fontset_ascii (fontset))->data));
11945
11946 if (!STRINGP (result))
11947 /* Can't load ASCII font. */
11948 return Qnil;
11949
11950 /* Since x_new_font doesn't update any fontset information, do it now. */
11951 f->output_data.x->fontset = fontset;
11952
11953 #ifdef HAVE_X_I18N
11954 if (FRAME_XIC (f)
11955 && (FRAME_XIC_STYLE (f) & (XIMPreeditPosition | XIMStatusArea)))
11956 xic_set_xfontset (f, XSTRING (fontset_ascii (fontset))->data);
11957 #endif
11958
11959 return build_string (fontsetname);
11960 }
11961
11962 \f
11963 /***********************************************************************
11964 X Input Methods
11965 ***********************************************************************/
11966
11967 #ifdef HAVE_X_I18N
11968
11969 #ifdef HAVE_X11R6
11970
11971 /* XIM destroy callback function, which is called whenever the
11972 connection to input method XIM dies. CLIENT_DATA contains a
11973 pointer to the x_display_info structure corresponding to XIM. */
11974
11975 static void
11976 xim_destroy_callback (xim, client_data, call_data)
11977 XIM xim;
11978 XPointer client_data;
11979 XPointer call_data;
11980 {
11981 struct x_display_info *dpyinfo = (struct x_display_info *) client_data;
11982 Lisp_Object frame, tail;
11983
11984 BLOCK_INPUT;
11985
11986 /* No need to call XDestroyIC.. */
11987 FOR_EACH_FRAME (tail, frame)
11988 {
11989 struct frame *f = XFRAME (frame);
11990 if (FRAME_X_DISPLAY_INFO (f) == dpyinfo)
11991 {
11992 FRAME_XIC (f) = NULL;
11993 if (FRAME_XIC_FONTSET (f))
11994 {
11995 XFreeFontSet (FRAME_X_DISPLAY (f), FRAME_XIC_FONTSET (f));
11996 FRAME_XIC_FONTSET (f) = NULL;
11997 }
11998 }
11999 }
12000
12001 /* No need to call XCloseIM. */
12002 dpyinfo->xim = NULL;
12003 XFree (dpyinfo->xim_styles);
12004 UNBLOCK_INPUT;
12005 }
12006
12007 #endif /* HAVE_X11R6 */
12008
12009 /* Open the connection to the XIM server on display DPYINFO.
12010 RESOURCE_NAME is the resource name Emacs uses. */
12011
12012 static void
12013 xim_open_dpy (dpyinfo, resource_name)
12014 struct x_display_info *dpyinfo;
12015 char *resource_name;
12016 {
12017 #ifdef USE_XIM
12018 XIM xim;
12019
12020 xim = XOpenIM (dpyinfo->display, dpyinfo->xrdb, resource_name, EMACS_CLASS);
12021 dpyinfo->xim = xim;
12022
12023 if (xim)
12024 {
12025 #ifdef HAVE_X11R6
12026 XIMCallback destroy;
12027 #endif
12028
12029 /* Get supported styles and XIM values. */
12030 XGetIMValues (xim, XNQueryInputStyle, &dpyinfo->xim_styles, NULL);
12031
12032 #ifdef HAVE_X11R6
12033 destroy.callback = xim_destroy_callback;
12034 destroy.client_data = (XPointer)dpyinfo;
12035 /* This isn't prototyped in OSF 5.0. */
12036 XSetIMValues (xim, XNDestroyCallback, &destroy, NULL);
12037 #endif
12038 }
12039
12040 #else /* not USE_XIM */
12041 dpyinfo->xim = NULL;
12042 #endif /* not USE_XIM */
12043 }
12044
12045
12046 #ifdef HAVE_X11R6_XIM
12047
12048 struct xim_inst_t
12049 {
12050 struct x_display_info *dpyinfo;
12051 char *resource_name;
12052 };
12053
12054 /* XIM instantiate callback function, which is called whenever an XIM
12055 server is available. DISPLAY is teh display of the XIM.
12056 CLIENT_DATA contains a pointer to an xim_inst_t structure created
12057 when the callback was registered. */
12058
12059 static void
12060 xim_instantiate_callback (display, client_data, call_data)
12061 Display *display;
12062 XPointer client_data;
12063 XPointer call_data;
12064 {
12065 struct xim_inst_t *xim_inst = (struct xim_inst_t *) client_data;
12066 struct x_display_info *dpyinfo = xim_inst->dpyinfo;
12067
12068 /* We don't support multiple XIM connections. */
12069 if (dpyinfo->xim)
12070 return;
12071
12072 xim_open_dpy (dpyinfo, xim_inst->resource_name);
12073
12074 /* Create XIC for the existing frames on the same display, as long
12075 as they have no XIC. */
12076 if (dpyinfo->xim && dpyinfo->reference_count > 0)
12077 {
12078 Lisp_Object tail, frame;
12079
12080 BLOCK_INPUT;
12081 FOR_EACH_FRAME (tail, frame)
12082 {
12083 struct frame *f = XFRAME (frame);
12084
12085 if (FRAME_X_DISPLAY_INFO (f) == xim_inst->dpyinfo)
12086 if (FRAME_XIC (f) == NULL)
12087 {
12088 create_frame_xic (f);
12089 if (FRAME_XIC_STYLE (f) & XIMStatusArea)
12090 xic_set_statusarea (f);
12091 if (FRAME_XIC_STYLE (f) & XIMPreeditPosition)
12092 {
12093 struct window *w = XWINDOW (f->selected_window);
12094 xic_set_preeditarea (w, w->cursor.x, w->cursor.y);
12095 }
12096 }
12097 }
12098
12099 UNBLOCK_INPUT;
12100 }
12101 }
12102
12103 #endif /* HAVE_X11R6_XIM */
12104
12105
12106 /* Open a connection to the XIM server on display DPYINFO.
12107 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
12108 connection only at the first time. On X11R6, open the connection
12109 in the XIM instantiate callback function. */
12110
12111 static void
12112 xim_initialize (dpyinfo, resource_name)
12113 struct x_display_info *dpyinfo;
12114 char *resource_name;
12115 {
12116 #ifdef USE_XIM
12117 #ifdef HAVE_X11R6_XIM
12118 struct xim_inst_t *xim_inst;
12119 int len;
12120
12121 dpyinfo->xim = NULL;
12122 xim_inst = (struct xim_inst_t *) xmalloc (sizeof (struct xim_inst_t));
12123 xim_inst->dpyinfo = dpyinfo;
12124 len = strlen (resource_name);
12125 xim_inst->resource_name = (char *) xmalloc (len + 1);
12126 bcopy (resource_name, xim_inst->resource_name, len + 1);
12127 XRegisterIMInstantiateCallback (dpyinfo->display, dpyinfo->xrdb,
12128 resource_name, EMACS_CLASS,
12129 xim_instantiate_callback,
12130 /* Fixme: This is XPointer in
12131 XFree86 but (XPointer *) on
12132 Tru64, at least. */
12133 (XPointer) xim_inst);
12134 #else /* not HAVE_X11R6_XIM */
12135 dpyinfo->xim = NULL;
12136 xim_open_dpy (dpyinfo, resource_name);
12137 #endif /* not HAVE_X11R6_XIM */
12138
12139 #else /* not USE_XIM */
12140 dpyinfo->xim = NULL;
12141 #endif /* not USE_XIM */
12142 }
12143
12144
12145 /* Close the connection to the XIM server on display DPYINFO. */
12146
12147 static void
12148 xim_close_dpy (dpyinfo)
12149 struct x_display_info *dpyinfo;
12150 {
12151 #ifdef USE_XIM
12152 #ifdef HAVE_X11R6_XIM
12153 if (dpyinfo->display)
12154 XUnregisterIMInstantiateCallback (dpyinfo->display, dpyinfo->xrdb,
12155 NULL, EMACS_CLASS,
12156 xim_instantiate_callback, NULL);
12157 #endif /* not HAVE_X11R6_XIM */
12158 if (dpyinfo->display)
12159 XCloseIM (dpyinfo->xim);
12160 dpyinfo->xim = NULL;
12161 XFree (dpyinfo->xim_styles);
12162 #endif /* USE_XIM */
12163 }
12164
12165 #endif /* not HAVE_X11R6_XIM */
12166
12167
12168 \f
12169 /* Calculate the absolute position in frame F
12170 from its current recorded position values and gravity. */
12171
12172 void
12173 x_calc_absolute_position (f)
12174 struct frame *f;
12175 {
12176 Window child;
12177 int win_x = 0, win_y = 0;
12178 int flags = f->output_data.x->size_hint_flags;
12179 int this_window;
12180
12181 /* We have nothing to do if the current position
12182 is already for the top-left corner. */
12183 if (! ((flags & XNegative) || (flags & YNegative)))
12184 return;
12185
12186 #ifdef USE_X_TOOLKIT
12187 this_window = XtWindow (f->output_data.x->widget);
12188 #else
12189 this_window = FRAME_X_WINDOW (f);
12190 #endif
12191
12192 /* Find the position of the outside upper-left corner of
12193 the inner window, with respect to the outer window.
12194 But do this only if we will need the results. */
12195 if (f->output_data.x->parent_desc != FRAME_X_DISPLAY_INFO (f)->root_window)
12196 {
12197 int count;
12198
12199 BLOCK_INPUT;
12200 count = x_catch_errors (FRAME_X_DISPLAY (f));
12201 while (1)
12202 {
12203 x_clear_errors (FRAME_X_DISPLAY (f));
12204 XTranslateCoordinates (FRAME_X_DISPLAY (f),
12205
12206 /* From-window, to-window. */
12207 this_window,
12208 f->output_data.x->parent_desc,
12209
12210 /* From-position, to-position. */
12211 0, 0, &win_x, &win_y,
12212
12213 /* Child of win. */
12214 &child);
12215 if (x_had_errors_p (FRAME_X_DISPLAY (f)))
12216 {
12217 Window newroot, newparent = 0xdeadbeef;
12218 Window *newchildren;
12219 unsigned int nchildren;
12220
12221 if (! XQueryTree (FRAME_X_DISPLAY (f), this_window, &newroot,
12222 &newparent, &newchildren, &nchildren))
12223 break;
12224
12225 XFree ((char *) newchildren);
12226
12227 f->output_data.x->parent_desc = newparent;
12228 }
12229 else
12230 break;
12231 }
12232
12233 x_uncatch_errors (FRAME_X_DISPLAY (f), count);
12234 UNBLOCK_INPUT;
12235 }
12236
12237 /* Treat negative positions as relative to the leftmost bottommost
12238 position that fits on the screen. */
12239 if (flags & XNegative)
12240 f->output_data.x->left_pos = (FRAME_X_DISPLAY_INFO (f)->width
12241 - 2 * f->output_data.x->border_width - win_x
12242 - PIXEL_WIDTH (f)
12243 + f->output_data.x->left_pos);
12244
12245 {
12246 int height = PIXEL_HEIGHT (f);
12247
12248 #if defined USE_X_TOOLKIT && defined USE_MOTIF
12249 /* Something is fishy here. When using Motif, starting Emacs with
12250 `-g -0-0', the frame appears too low by a few pixels.
12251
12252 This seems to be so because initially, while Emacs is starting,
12253 the column widget's height and the frame's pixel height are
12254 different. The column widget's height is the right one. In
12255 later invocations, when Emacs is up, the frame's pixel height
12256 is right, though.
12257
12258 It's not obvious where the initial small difference comes from.
12259 2000-12-01, gerd. */
12260
12261 XtVaGetValues (f->output_data.x->column_widget, XtNheight, &height, NULL);
12262 #endif
12263
12264 if (flags & YNegative)
12265 f->output_data.x->top_pos = (FRAME_X_DISPLAY_INFO (f)->height
12266 - 2 * f->output_data.x->border_width
12267 - win_y
12268 - height
12269 + f->output_data.x->top_pos);
12270 }
12271
12272 /* The left_pos and top_pos
12273 are now relative to the top and left screen edges,
12274 so the flags should correspond. */
12275 f->output_data.x->size_hint_flags &= ~ (XNegative | YNegative);
12276 }
12277
12278 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
12279 to really change the position, and 0 when calling from
12280 x_make_frame_visible (in that case, XOFF and YOFF are the current
12281 position values). It is -1 when calling from x_set_frame_parameters,
12282 which means, do adjust for borders but don't change the gravity. */
12283
12284 void
12285 x_set_offset (f, xoff, yoff, change_gravity)
12286 struct frame *f;
12287 register int xoff, yoff;
12288 int change_gravity;
12289 {
12290 int modified_top, modified_left;
12291
12292 if (change_gravity > 0)
12293 {
12294 f->output_data.x->top_pos = yoff;
12295 f->output_data.x->left_pos = xoff;
12296 f->output_data.x->size_hint_flags &= ~ (XNegative | YNegative);
12297 if (xoff < 0)
12298 f->output_data.x->size_hint_flags |= XNegative;
12299 if (yoff < 0)
12300 f->output_data.x->size_hint_flags |= YNegative;
12301 f->output_data.x->win_gravity = NorthWestGravity;
12302 }
12303 x_calc_absolute_position (f);
12304
12305 BLOCK_INPUT;
12306 x_wm_set_size_hint (f, (long) 0, 0);
12307
12308 modified_left = f->output_data.x->left_pos;
12309 modified_top = f->output_data.x->top_pos;
12310 #if 0 /* Running on psilocin (Debian), and displaying on the NCD X-terminal,
12311 this seems to be unnecessary and incorrect. rms, 4/17/97. */
12312 /* It is a mystery why we need to add the border_width here
12313 when the frame is already visible, but experiment says we do. */
12314 if (change_gravity != 0)
12315 {
12316 modified_left += f->output_data.x->border_width;
12317 modified_top += f->output_data.x->border_width;
12318 }
12319 #endif
12320
12321 #ifdef USE_X_TOOLKIT
12322 XMoveWindow (FRAME_X_DISPLAY (f), XtWindow (f->output_data.x->widget),
12323 modified_left, modified_top);
12324 #else /* not USE_X_TOOLKIT */
12325 XMoveWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
12326 modified_left, modified_top);
12327 #endif /* not USE_X_TOOLKIT */
12328 UNBLOCK_INPUT;
12329 }
12330
12331
12332 /* Change the size of frame F's X window to COLS/ROWS in the case F
12333 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
12334 top-left-corner window gravity for this size change and subsequent
12335 size changes. Otherwise we leave the window gravity unchanged. */
12336
12337 static void
12338 x_set_window_size_1 (f, change_gravity, cols, rows)
12339 struct frame *f;
12340 int change_gravity;
12341 int cols, rows;
12342 {
12343 int pixelwidth, pixelheight;
12344
12345 check_frame_size (f, &rows, &cols);
12346 f->output_data.x->vertical_scroll_bar_extra
12347 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f)
12348 ? 0
12349 : FRAME_SCROLL_BAR_PIXEL_WIDTH (f) > 0
12350 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f)
12351 : (FRAME_SCROLL_BAR_COLS (f) * FONT_WIDTH (f->output_data.x->font)));
12352 f->output_data.x->flags_areas_extra
12353 = FRAME_FLAGS_AREA_WIDTH (f);
12354 pixelwidth = CHAR_TO_PIXEL_WIDTH (f, cols);
12355 pixelheight = CHAR_TO_PIXEL_HEIGHT (f, rows);
12356
12357 f->output_data.x->win_gravity = NorthWestGravity;
12358 x_wm_set_size_hint (f, (long) 0, 0);
12359
12360 XSync (FRAME_X_DISPLAY (f), False);
12361 XResizeWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
12362 pixelwidth, pixelheight);
12363
12364 /* Now, strictly speaking, we can't be sure that this is accurate,
12365 but the window manager will get around to dealing with the size
12366 change request eventually, and we'll hear how it went when the
12367 ConfigureNotify event gets here.
12368
12369 We could just not bother storing any of this information here,
12370 and let the ConfigureNotify event set everything up, but that
12371 might be kind of confusing to the Lisp code, since size changes
12372 wouldn't be reported in the frame parameters until some random
12373 point in the future when the ConfigureNotify event arrives.
12374
12375 We pass 1 for DELAY since we can't run Lisp code inside of
12376 a BLOCK_INPUT. */
12377 change_frame_size (f, rows, cols, 0, 1, 0);
12378 PIXEL_WIDTH (f) = pixelwidth;
12379 PIXEL_HEIGHT (f) = pixelheight;
12380
12381 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
12382 receive in the ConfigureNotify event; if we get what we asked
12383 for, then the event won't cause the screen to become garbaged, so
12384 we have to make sure to do it here. */
12385 SET_FRAME_GARBAGED (f);
12386
12387 XFlush (FRAME_X_DISPLAY (f));
12388 }
12389
12390
12391 /* Call this to change the size of frame F's x-window.
12392 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
12393 for this size change and subsequent size changes.
12394 Otherwise we leave the window gravity unchanged. */
12395
12396 void
12397 x_set_window_size (f, change_gravity, cols, rows)
12398 struct frame *f;
12399 int change_gravity;
12400 int cols, rows;
12401 {
12402 BLOCK_INPUT;
12403
12404 #ifdef USE_X_TOOLKIT
12405
12406 if (f->output_data.x->widget != NULL)
12407 {
12408 /* The x and y position of the widget is clobbered by the
12409 call to XtSetValues within EmacsFrameSetCharSize.
12410 This is a real kludge, but I don't understand Xt so I can't
12411 figure out a correct fix. Can anyone else tell me? -- rms. */
12412 int xpos = f->output_data.x->widget->core.x;
12413 int ypos = f->output_data.x->widget->core.y;
12414 EmacsFrameSetCharSize (f->output_data.x->edit_widget, cols, rows);
12415 f->output_data.x->widget->core.x = xpos;
12416 f->output_data.x->widget->core.y = ypos;
12417 }
12418 else
12419 x_set_window_size_1 (f, change_gravity, cols, rows);
12420
12421 #else /* not USE_X_TOOLKIT */
12422
12423 x_set_window_size_1 (f, change_gravity, cols, rows);
12424
12425 #endif /* not USE_X_TOOLKIT */
12426
12427 /* If cursor was outside the new size, mark it as off. */
12428 mark_window_cursors_off (XWINDOW (f->root_window));
12429
12430 /* Clear out any recollection of where the mouse highlighting was,
12431 since it might be in a place that's outside the new frame size.
12432 Actually checking whether it is outside is a pain in the neck,
12433 so don't try--just let the highlighting be done afresh with new size. */
12434 cancel_mouse_face (f);
12435
12436 UNBLOCK_INPUT;
12437 }
12438 \f
12439 /* Mouse warping. */
12440
12441 void
12442 x_set_mouse_position (f, x, y)
12443 struct frame *f;
12444 int x, y;
12445 {
12446 int pix_x, pix_y;
12447
12448 pix_x = CHAR_TO_PIXEL_COL (f, x) + FONT_WIDTH (f->output_data.x->font) / 2;
12449 pix_y = CHAR_TO_PIXEL_ROW (f, y) + f->output_data.x->line_height / 2;
12450
12451 if (pix_x < 0) pix_x = 0;
12452 if (pix_x > PIXEL_WIDTH (f)) pix_x = PIXEL_WIDTH (f);
12453
12454 if (pix_y < 0) pix_y = 0;
12455 if (pix_y > PIXEL_HEIGHT (f)) pix_y = PIXEL_HEIGHT (f);
12456
12457 BLOCK_INPUT;
12458
12459 XWarpPointer (FRAME_X_DISPLAY (f), None, FRAME_X_WINDOW (f),
12460 0, 0, 0, 0, pix_x, pix_y);
12461 UNBLOCK_INPUT;
12462 }
12463
12464 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
12465
12466 void
12467 x_set_mouse_pixel_position (f, pix_x, pix_y)
12468 struct frame *f;
12469 int pix_x, pix_y;
12470 {
12471 BLOCK_INPUT;
12472
12473 XWarpPointer (FRAME_X_DISPLAY (f), None, FRAME_X_WINDOW (f),
12474 0, 0, 0, 0, pix_x, pix_y);
12475 UNBLOCK_INPUT;
12476 }
12477 \f
12478 /* focus shifting, raising and lowering. */
12479
12480 void
12481 x_focus_on_frame (f)
12482 struct frame *f;
12483 {
12484 #if 0 /* This proves to be unpleasant. */
12485 x_raise_frame (f);
12486 #endif
12487 #if 0
12488 /* I don't think that the ICCCM allows programs to do things like this
12489 without the interaction of the window manager. Whatever you end up
12490 doing with this code, do it to x_unfocus_frame too. */
12491 XSetInputFocus (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
12492 RevertToPointerRoot, CurrentTime);
12493 #endif /* ! 0 */
12494 }
12495
12496 void
12497 x_unfocus_frame (f)
12498 struct frame *f;
12499 {
12500 #if 0
12501 /* Look at the remarks in x_focus_on_frame. */
12502 if (FRAME_X_DISPLAY_INFO (f)->x_focus_frame == f)
12503 XSetInputFocus (FRAME_X_DISPLAY (f), PointerRoot,
12504 RevertToPointerRoot, CurrentTime);
12505 #endif /* ! 0 */
12506 }
12507
12508 /* Raise frame F. */
12509
12510 void
12511 x_raise_frame (f)
12512 struct frame *f;
12513 {
12514 if (f->async_visible)
12515 {
12516 BLOCK_INPUT;
12517 #ifdef USE_X_TOOLKIT
12518 XRaiseWindow (FRAME_X_DISPLAY (f), XtWindow (f->output_data.x->widget));
12519 #else /* not USE_X_TOOLKIT */
12520 XRaiseWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
12521 #endif /* not USE_X_TOOLKIT */
12522 XFlush (FRAME_X_DISPLAY (f));
12523 UNBLOCK_INPUT;
12524 }
12525 }
12526
12527 /* Lower frame F. */
12528
12529 void
12530 x_lower_frame (f)
12531 struct frame *f;
12532 {
12533 if (f->async_visible)
12534 {
12535 BLOCK_INPUT;
12536 #ifdef USE_X_TOOLKIT
12537 XLowerWindow (FRAME_X_DISPLAY (f), XtWindow (f->output_data.x->widget));
12538 #else /* not USE_X_TOOLKIT */
12539 XLowerWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
12540 #endif /* not USE_X_TOOLKIT */
12541 XFlush (FRAME_X_DISPLAY (f));
12542 UNBLOCK_INPUT;
12543 }
12544 }
12545
12546 static void
12547 XTframe_raise_lower (f, raise_flag)
12548 FRAME_PTR f;
12549 int raise_flag;
12550 {
12551 if (raise_flag)
12552 x_raise_frame (f);
12553 else
12554 x_lower_frame (f);
12555 }
12556 \f
12557 /* Change of visibility. */
12558
12559 /* This tries to wait until the frame is really visible.
12560 However, if the window manager asks the user where to position
12561 the frame, this will return before the user finishes doing that.
12562 The frame will not actually be visible at that time,
12563 but it will become visible later when the window manager
12564 finishes with it. */
12565
12566 void
12567 x_make_frame_visible (f)
12568 struct frame *f;
12569 {
12570 Lisp_Object type;
12571 int original_top, original_left;
12572 int retry_count = 2;
12573
12574 retry:
12575
12576 BLOCK_INPUT;
12577
12578 type = x_icon_type (f);
12579 if (!NILP (type))
12580 x_bitmap_icon (f, type);
12581
12582 if (! FRAME_VISIBLE_P (f))
12583 {
12584 /* We test FRAME_GARBAGED_P here to make sure we don't
12585 call x_set_offset a second time
12586 if we get to x_make_frame_visible a second time
12587 before the window gets really visible. */
12588 if (! FRAME_ICONIFIED_P (f)
12589 && ! f->output_data.x->asked_for_visible)
12590 x_set_offset (f, f->output_data.x->left_pos, f->output_data.x->top_pos, 0);
12591
12592 f->output_data.x->asked_for_visible = 1;
12593
12594 if (! EQ (Vx_no_window_manager, Qt))
12595 x_wm_set_window_state (f, NormalState);
12596 #ifdef USE_X_TOOLKIT
12597 /* This was XtPopup, but that did nothing for an iconified frame. */
12598 XtMapWidget (f->output_data.x->widget);
12599 #else /* not USE_X_TOOLKIT */
12600 XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
12601 #endif /* not USE_X_TOOLKIT */
12602 #if 0 /* This seems to bring back scroll bars in the wrong places
12603 if the window configuration has changed. They seem
12604 to come back ok without this. */
12605 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
12606 XMapSubwindows (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
12607 #endif
12608 }
12609
12610 XFlush (FRAME_X_DISPLAY (f));
12611
12612 /* Synchronize to ensure Emacs knows the frame is visible
12613 before we do anything else. We do this loop with input not blocked
12614 so that incoming events are handled. */
12615 {
12616 Lisp_Object frame;
12617 int count;
12618 /* This must be before UNBLOCK_INPUT
12619 since events that arrive in response to the actions above
12620 will set it when they are handled. */
12621 int previously_visible = f->output_data.x->has_been_visible;
12622
12623 original_left = f->output_data.x->left_pos;
12624 original_top = f->output_data.x->top_pos;
12625
12626 /* This must come after we set COUNT. */
12627 UNBLOCK_INPUT;
12628
12629 /* We unblock here so that arriving X events are processed. */
12630
12631 /* Now move the window back to where it was "supposed to be".
12632 But don't do it if the gravity is negative.
12633 When the gravity is negative, this uses a position
12634 that is 3 pixels too low. Perhaps that's really the border width.
12635
12636 Don't do this if the window has never been visible before,
12637 because the window manager may choose the position
12638 and we don't want to override it. */
12639
12640 if (! FRAME_VISIBLE_P (f) && ! FRAME_ICONIFIED_P (f)
12641 && f->output_data.x->win_gravity == NorthWestGravity
12642 && previously_visible)
12643 {
12644 Drawable rootw;
12645 int x, y;
12646 unsigned int width, height, border, depth;
12647
12648 BLOCK_INPUT;
12649
12650 /* On some window managers (such as FVWM) moving an existing
12651 window, even to the same place, causes the window manager
12652 to introduce an offset. This can cause the window to move
12653 to an unexpected location. Check the geometry (a little
12654 slow here) and then verify that the window is in the right
12655 place. If the window is not in the right place, move it
12656 there, and take the potential window manager hit. */
12657 XGetGeometry (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
12658 &rootw, &x, &y, &width, &height, &border, &depth);
12659
12660 if (original_left != x || original_top != y)
12661 XMoveWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
12662 original_left, original_top);
12663
12664 UNBLOCK_INPUT;
12665 }
12666
12667 XSETFRAME (frame, f);
12668
12669 /* Wait until the frame is visible. Process X events until a
12670 MapNotify event has been seen, or until we think we won't get a
12671 MapNotify at all.. */
12672 for (count = input_signal_count + 10;
12673 input_signal_count < count && !FRAME_VISIBLE_P (f);)
12674 {
12675 /* Force processing of queued events. */
12676 x_sync (f);
12677
12678 /* Machines that do polling rather than SIGIO have been
12679 observed to go into a busy-wait here. So we'll fake an
12680 alarm signal to let the handler know that there's something
12681 to be read. We used to raise a real alarm, but it seems
12682 that the handler isn't always enabled here. This is
12683 probably a bug. */
12684 if (input_polling_used ())
12685 {
12686 /* It could be confusing if a real alarm arrives while
12687 processing the fake one. Turn it off and let the
12688 handler reset it. */
12689 extern void poll_for_input_1 P_ ((void));
12690 int old_poll_suppress_count = poll_suppress_count;
12691 poll_suppress_count = 1;
12692 poll_for_input_1 ();
12693 poll_suppress_count = old_poll_suppress_count;
12694 }
12695
12696 /* See if a MapNotify event has been processed. */
12697 FRAME_SAMPLE_VISIBILITY (f);
12698 }
12699
12700 /* 2000-09-28: In
12701
12702 (let ((f (selected-frame)))
12703 (iconify-frame f)
12704 (raise-frame f))
12705
12706 the frame is not raised with various window managers on
12707 FreeBSD, Linux and Solaris. It turns out that, for some
12708 unknown reason, the call to XtMapWidget is completely ignored.
12709 Mapping the widget a second time works. */
12710
12711 if (!FRAME_VISIBLE_P (f) && --retry_count > 0)
12712 goto retry;
12713 }
12714 }
12715
12716 /* Change from mapped state to withdrawn state. */
12717
12718 /* Make the frame visible (mapped and not iconified). */
12719
12720 void
12721 x_make_frame_invisible (f)
12722 struct frame *f;
12723 {
12724 Window window;
12725
12726 #ifdef USE_X_TOOLKIT
12727 /* Use the frame's outermost window, not the one we normally draw on. */
12728 window = XtWindow (f->output_data.x->widget);
12729 #else /* not USE_X_TOOLKIT */
12730 window = FRAME_X_WINDOW (f);
12731 #endif /* not USE_X_TOOLKIT */
12732
12733 /* Don't keep the highlight on an invisible frame. */
12734 if (FRAME_X_DISPLAY_INFO (f)->x_highlight_frame == f)
12735 FRAME_X_DISPLAY_INFO (f)->x_highlight_frame = 0;
12736
12737 #if 0/* This might add unreliability; I don't trust it -- rms. */
12738 if (! f->async_visible && ! f->async_iconified)
12739 return;
12740 #endif
12741
12742 BLOCK_INPUT;
12743
12744 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
12745 that the current position of the window is user-specified, rather than
12746 program-specified, so that when the window is mapped again, it will be
12747 placed at the same location, without forcing the user to position it
12748 by hand again (they have already done that once for this window.) */
12749 x_wm_set_size_hint (f, (long) 0, 1);
12750
12751 #ifdef HAVE_X11R4
12752
12753 if (! XWithdrawWindow (FRAME_X_DISPLAY (f), window,
12754 DefaultScreen (FRAME_X_DISPLAY (f))))
12755 {
12756 UNBLOCK_INPUT_RESIGNAL;
12757 error ("Can't notify window manager of window withdrawal");
12758 }
12759 #else /* ! defined (HAVE_X11R4) */
12760
12761 /* Tell the window manager what we're going to do. */
12762 if (! EQ (Vx_no_window_manager, Qt))
12763 {
12764 XEvent unmap;
12765
12766 unmap.xunmap.type = UnmapNotify;
12767 unmap.xunmap.window = window;
12768 unmap.xunmap.event = DefaultRootWindow (FRAME_X_DISPLAY (f));
12769 unmap.xunmap.from_configure = False;
12770 if (! XSendEvent (FRAME_X_DISPLAY (f),
12771 DefaultRootWindow (FRAME_X_DISPLAY (f)),
12772 False,
12773 SubstructureRedirectMaskSubstructureNotifyMask,
12774 &unmap))
12775 {
12776 UNBLOCK_INPUT_RESIGNAL;
12777 error ("Can't notify window manager of withdrawal");
12778 }
12779 }
12780
12781 /* Unmap the window ourselves. Cheeky! */
12782 XUnmapWindow (FRAME_X_DISPLAY (f), window);
12783 #endif /* ! defined (HAVE_X11R4) */
12784
12785 /* We can't distinguish this from iconification
12786 just by the event that we get from the server.
12787 So we can't win using the usual strategy of letting
12788 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
12789 and synchronize with the server to make sure we agree. */
12790 f->visible = 0;
12791 FRAME_ICONIFIED_P (f) = 0;
12792 f->async_visible = 0;
12793 f->async_iconified = 0;
12794
12795 x_sync (f);
12796
12797 UNBLOCK_INPUT;
12798 }
12799
12800 /* Change window state from mapped to iconified. */
12801
12802 void
12803 x_iconify_frame (f)
12804 struct frame *f;
12805 {
12806 int result;
12807 Lisp_Object type;
12808
12809 /* Don't keep the highlight on an invisible frame. */
12810 if (FRAME_X_DISPLAY_INFO (f)->x_highlight_frame == f)
12811 FRAME_X_DISPLAY_INFO (f)->x_highlight_frame = 0;
12812
12813 if (f->async_iconified)
12814 return;
12815
12816 BLOCK_INPUT;
12817
12818 FRAME_SAMPLE_VISIBILITY (f);
12819
12820 type = x_icon_type (f);
12821 if (!NILP (type))
12822 x_bitmap_icon (f, type);
12823
12824 #ifdef USE_X_TOOLKIT
12825
12826 if (! FRAME_VISIBLE_P (f))
12827 {
12828 if (! EQ (Vx_no_window_manager, Qt))
12829 x_wm_set_window_state (f, IconicState);
12830 /* This was XtPopup, but that did nothing for an iconified frame. */
12831 XtMapWidget (f->output_data.x->widget);
12832 /* The server won't give us any event to indicate
12833 that an invisible frame was changed to an icon,
12834 so we have to record it here. */
12835 f->iconified = 1;
12836 f->visible = 1;
12837 f->async_iconified = 1;
12838 f->async_visible = 0;
12839 UNBLOCK_INPUT;
12840 return;
12841 }
12842
12843 result = XIconifyWindow (FRAME_X_DISPLAY (f),
12844 XtWindow (f->output_data.x->widget),
12845 DefaultScreen (FRAME_X_DISPLAY (f)));
12846 UNBLOCK_INPUT;
12847
12848 if (!result)
12849 error ("Can't notify window manager of iconification");
12850
12851 f->async_iconified = 1;
12852 f->async_visible = 0;
12853
12854
12855 BLOCK_INPUT;
12856 XFlush (FRAME_X_DISPLAY (f));
12857 UNBLOCK_INPUT;
12858 #else /* not USE_X_TOOLKIT */
12859
12860 /* Make sure the X server knows where the window should be positioned,
12861 in case the user deiconifies with the window manager. */
12862 if (! FRAME_VISIBLE_P (f) && !FRAME_ICONIFIED_P (f))
12863 x_set_offset (f, f->output_data.x->left_pos, f->output_data.x->top_pos, 0);
12864
12865 /* Since we don't know which revision of X we're running, we'll use both
12866 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
12867
12868 /* X11R4: send a ClientMessage to the window manager using the
12869 WM_CHANGE_STATE type. */
12870 {
12871 XEvent message;
12872
12873 message.xclient.window = FRAME_X_WINDOW (f);
12874 message.xclient.type = ClientMessage;
12875 message.xclient.message_type = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_change_state;
12876 message.xclient.format = 32;
12877 message.xclient.data.l[0] = IconicState;
12878
12879 if (! XSendEvent (FRAME_X_DISPLAY (f),
12880 DefaultRootWindow (FRAME_X_DISPLAY (f)),
12881 False,
12882 SubstructureRedirectMask | SubstructureNotifyMask,
12883 &message))
12884 {
12885 UNBLOCK_INPUT_RESIGNAL;
12886 error ("Can't notify window manager of iconification");
12887 }
12888 }
12889
12890 /* X11R3: set the initial_state field of the window manager hints to
12891 IconicState. */
12892 x_wm_set_window_state (f, IconicState);
12893
12894 if (!FRAME_VISIBLE_P (f))
12895 {
12896 /* If the frame was withdrawn, before, we must map it. */
12897 XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
12898 }
12899
12900 f->async_iconified = 1;
12901 f->async_visible = 0;
12902
12903 XFlush (FRAME_X_DISPLAY (f));
12904 UNBLOCK_INPUT;
12905 #endif /* not USE_X_TOOLKIT */
12906 }
12907
12908 \f
12909 /* Free X resources of frame F. */
12910
12911 void
12912 x_free_frame_resources (f)
12913 struct frame *f;
12914 {
12915 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
12916
12917 BLOCK_INPUT;
12918
12919 /* If a display connection is dead, don't try sending more
12920 commands to the X server. */
12921 if (dpyinfo->display)
12922 {
12923 if (f->output_data.x->icon_desc)
12924 XDestroyWindow (FRAME_X_DISPLAY (f), f->output_data.x->icon_desc);
12925
12926 #ifdef HAVE_X_I18N
12927 if (FRAME_XIC (f))
12928 free_frame_xic (f);
12929 #endif
12930
12931 if (FRAME_X_WINDOW (f))
12932 XDestroyWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
12933
12934 #ifdef USE_X_TOOLKIT
12935 if (f->output_data.x->widget)
12936 {
12937 XtDestroyWidget (f->output_data.x->widget);
12938 f->output_data.x->widget = NULL;
12939 }
12940 free_frame_menubar (f);
12941 #endif /* USE_X_TOOLKIT */
12942
12943 unload_color (f, f->output_data.x->foreground_pixel);
12944 unload_color (f, f->output_data.x->background_pixel);
12945 unload_color (f, f->output_data.x->cursor_pixel);
12946 unload_color (f, f->output_data.x->cursor_foreground_pixel);
12947 unload_color (f, f->output_data.x->border_pixel);
12948 unload_color (f, f->output_data.x->mouse_pixel);
12949
12950 if (f->output_data.x->scroll_bar_background_pixel != -1)
12951 unload_color (f, f->output_data.x->scroll_bar_background_pixel);
12952 if (f->output_data.x->scroll_bar_foreground_pixel != -1)
12953 unload_color (f, f->output_data.x->scroll_bar_foreground_pixel);
12954 if (f->output_data.x->white_relief.allocated_p)
12955 unload_color (f, f->output_data.x->white_relief.pixel);
12956 if (f->output_data.x->black_relief.allocated_p)
12957 unload_color (f, f->output_data.x->black_relief.pixel);
12958
12959 if (FRAME_FACE_CACHE (f))
12960 free_frame_faces (f);
12961
12962 x_free_gcs (f);
12963 XFlush (FRAME_X_DISPLAY (f));
12964 }
12965
12966 if (f->output_data.x->saved_menu_event)
12967 xfree (f->output_data.x->saved_menu_event);
12968
12969 xfree (f->output_data.x);
12970 f->output_data.x = NULL;
12971
12972 if (f == dpyinfo->x_focus_frame)
12973 dpyinfo->x_focus_frame = 0;
12974 if (f == dpyinfo->x_focus_event_frame)
12975 dpyinfo->x_focus_event_frame = 0;
12976 if (f == dpyinfo->x_highlight_frame)
12977 dpyinfo->x_highlight_frame = 0;
12978
12979 if (f == dpyinfo->mouse_face_mouse_frame)
12980 {
12981 dpyinfo->mouse_face_beg_row
12982 = dpyinfo->mouse_face_beg_col = -1;
12983 dpyinfo->mouse_face_end_row
12984 = dpyinfo->mouse_face_end_col = -1;
12985 dpyinfo->mouse_face_window = Qnil;
12986 dpyinfo->mouse_face_deferred_gc = 0;
12987 dpyinfo->mouse_face_mouse_frame = 0;
12988 }
12989
12990 UNBLOCK_INPUT;
12991 }
12992
12993
12994 /* Destroy the X window of frame F. */
12995
12996 void
12997 x_destroy_window (f)
12998 struct frame *f;
12999 {
13000 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
13001
13002 /* If a display connection is dead, don't try sending more
13003 commands to the X server. */
13004 if (dpyinfo->display != 0)
13005 x_free_frame_resources (f);
13006
13007 dpyinfo->reference_count--;
13008 }
13009
13010 \f
13011 /* Setting window manager hints. */
13012
13013 /* Set the normal size hints for the window manager, for frame F.
13014 FLAGS is the flags word to use--or 0 meaning preserve the flags
13015 that the window now has.
13016 If USER_POSITION is nonzero, we set the USPosition
13017 flag (this is useful when FLAGS is 0). */
13018
13019 void
13020 x_wm_set_size_hint (f, flags, user_position)
13021 struct frame *f;
13022 long flags;
13023 int user_position;
13024 {
13025 XSizeHints size_hints;
13026
13027 #ifdef USE_X_TOOLKIT
13028 Arg al[2];
13029 int ac = 0;
13030 Dimension widget_width, widget_height;
13031 Window window = XtWindow (f->output_data.x->widget);
13032 #else /* not USE_X_TOOLKIT */
13033 Window window = FRAME_X_WINDOW (f);
13034 #endif /* not USE_X_TOOLKIT */
13035
13036 /* Setting PMaxSize caused various problems. */
13037 size_hints.flags = PResizeInc | PMinSize /* | PMaxSize */;
13038
13039 size_hints.x = f->output_data.x->left_pos;
13040 size_hints.y = f->output_data.x->top_pos;
13041
13042 #ifdef USE_X_TOOLKIT
13043 XtSetArg (al[ac], XtNwidth, &widget_width); ac++;
13044 XtSetArg (al[ac], XtNheight, &widget_height); ac++;
13045 XtGetValues (f->output_data.x->widget, al, ac);
13046 size_hints.height = widget_height;
13047 size_hints.width = widget_width;
13048 #else /* not USE_X_TOOLKIT */
13049 size_hints.height = PIXEL_HEIGHT (f);
13050 size_hints.width = PIXEL_WIDTH (f);
13051 #endif /* not USE_X_TOOLKIT */
13052
13053 size_hints.width_inc = FONT_WIDTH (f->output_data.x->font);
13054 size_hints.height_inc = f->output_data.x->line_height;
13055 size_hints.max_width
13056 = FRAME_X_DISPLAY_INFO (f)->width - CHAR_TO_PIXEL_WIDTH (f, 0);
13057 size_hints.max_height
13058 = FRAME_X_DISPLAY_INFO (f)->height - CHAR_TO_PIXEL_HEIGHT (f, 0);
13059
13060 /* Calculate the base and minimum sizes.
13061
13062 (When we use the X toolkit, we don't do it here.
13063 Instead we copy the values that the widgets are using, below.) */
13064 #ifndef USE_X_TOOLKIT
13065 {
13066 int base_width, base_height;
13067 int min_rows = 0, min_cols = 0;
13068
13069 base_width = CHAR_TO_PIXEL_WIDTH (f, 0);
13070 base_height = CHAR_TO_PIXEL_HEIGHT (f, 0);
13071
13072 check_frame_size (f, &min_rows, &min_cols);
13073
13074 /* The window manager uses the base width hints to calculate the
13075 current number of rows and columns in the frame while
13076 resizing; min_width and min_height aren't useful for this
13077 purpose, since they might not give the dimensions for a
13078 zero-row, zero-column frame.
13079
13080 We use the base_width and base_height members if we have
13081 them; otherwise, we set the min_width and min_height members
13082 to the size for a zero x zero frame. */
13083
13084 #ifdef HAVE_X11R4
13085 size_hints.flags |= PBaseSize;
13086 size_hints.base_width = base_width;
13087 size_hints.base_height = base_height;
13088 size_hints.min_width = base_width + min_cols * size_hints.width_inc;
13089 size_hints.min_height = base_height + min_rows * size_hints.height_inc;
13090 #else
13091 size_hints.min_width = base_width;
13092 size_hints.min_height = base_height;
13093 #endif
13094 }
13095
13096 /* If we don't need the old flags, we don't need the old hint at all. */
13097 if (flags)
13098 {
13099 size_hints.flags |= flags;
13100 goto no_read;
13101 }
13102 #endif /* not USE_X_TOOLKIT */
13103
13104 {
13105 XSizeHints hints; /* Sometimes I hate X Windows... */
13106 long supplied_return;
13107 int value;
13108
13109 #ifdef HAVE_X11R4
13110 value = XGetWMNormalHints (FRAME_X_DISPLAY (f), window, &hints,
13111 &supplied_return);
13112 #else
13113 value = XGetNormalHints (FRAME_X_DISPLAY (f), window, &hints);
13114 #endif
13115
13116 #ifdef USE_X_TOOLKIT
13117 size_hints.base_height = hints.base_height;
13118 size_hints.base_width = hints.base_width;
13119 size_hints.min_height = hints.min_height;
13120 size_hints.min_width = hints.min_width;
13121 #endif
13122
13123 if (flags)
13124 size_hints.flags |= flags;
13125 else
13126 {
13127 if (value == 0)
13128 hints.flags = 0;
13129 if (hints.flags & PSize)
13130 size_hints.flags |= PSize;
13131 if (hints.flags & PPosition)
13132 size_hints.flags |= PPosition;
13133 if (hints.flags & USPosition)
13134 size_hints.flags |= USPosition;
13135 if (hints.flags & USSize)
13136 size_hints.flags |= USSize;
13137 }
13138 }
13139
13140 #ifndef USE_X_TOOLKIT
13141 no_read:
13142 #endif
13143
13144 #ifdef PWinGravity
13145 size_hints.win_gravity = f->output_data.x->win_gravity;
13146 size_hints.flags |= PWinGravity;
13147
13148 if (user_position)
13149 {
13150 size_hints.flags &= ~ PPosition;
13151 size_hints.flags |= USPosition;
13152 }
13153 #endif /* PWinGravity */
13154
13155 #ifdef HAVE_X11R4
13156 XSetWMNormalHints (FRAME_X_DISPLAY (f), window, &size_hints);
13157 #else
13158 XSetNormalHints (FRAME_X_DISPLAY (f), window, &size_hints);
13159 #endif
13160 }
13161
13162 /* Used for IconicState or NormalState */
13163
13164 void
13165 x_wm_set_window_state (f, state)
13166 struct frame *f;
13167 int state;
13168 {
13169 #ifdef USE_X_TOOLKIT
13170 Arg al[1];
13171
13172 XtSetArg (al[0], XtNinitialState, state);
13173 XtSetValues (f->output_data.x->widget, al, 1);
13174 #else /* not USE_X_TOOLKIT */
13175 Window window = FRAME_X_WINDOW (f);
13176
13177 f->output_data.x->wm_hints.flags |= StateHint;
13178 f->output_data.x->wm_hints.initial_state = state;
13179
13180 XSetWMHints (FRAME_X_DISPLAY (f), window, &f->output_data.x->wm_hints);
13181 #endif /* not USE_X_TOOLKIT */
13182 }
13183
13184 void
13185 x_wm_set_icon_pixmap (f, pixmap_id)
13186 struct frame *f;
13187 int pixmap_id;
13188 {
13189 Pixmap icon_pixmap;
13190
13191 #ifndef USE_X_TOOLKIT
13192 Window window = FRAME_X_WINDOW (f);
13193 #endif
13194
13195 if (pixmap_id > 0)
13196 {
13197 icon_pixmap = x_bitmap_pixmap (f, pixmap_id);
13198 f->output_data.x->wm_hints.icon_pixmap = icon_pixmap;
13199 }
13200 else
13201 {
13202 /* It seems there is no way to turn off use of an icon pixmap.
13203 The following line does it, only if no icon has yet been created,
13204 for some window managers. But with mwm it crashes.
13205 Some people say it should clear the IconPixmapHint bit in this case,
13206 but that doesn't work, and the X consortium said it isn't the
13207 right thing at all. Since there is no way to win,
13208 best to explicitly give up. */
13209 #if 0
13210 f->output_data.x->wm_hints.icon_pixmap = None;
13211 #else
13212 return;
13213 #endif
13214 }
13215
13216 #ifdef USE_X_TOOLKIT /* same as in x_wm_set_window_state. */
13217
13218 {
13219 Arg al[1];
13220 XtSetArg (al[0], XtNiconPixmap, icon_pixmap);
13221 XtSetValues (f->output_data.x->widget, al, 1);
13222 }
13223
13224 #else /* not USE_X_TOOLKIT */
13225
13226 f->output_data.x->wm_hints.flags |= IconPixmapHint;
13227 XSetWMHints (FRAME_X_DISPLAY (f), window, &f->output_data.x->wm_hints);
13228
13229 #endif /* not USE_X_TOOLKIT */
13230 }
13231
13232 void
13233 x_wm_set_icon_position (f, icon_x, icon_y)
13234 struct frame *f;
13235 int icon_x, icon_y;
13236 {
13237 #ifdef USE_X_TOOLKIT
13238 Window window = XtWindow (f->output_data.x->widget);
13239 #else
13240 Window window = FRAME_X_WINDOW (f);
13241 #endif
13242
13243 f->output_data.x->wm_hints.flags |= IconPositionHint;
13244 f->output_data.x->wm_hints.icon_x = icon_x;
13245 f->output_data.x->wm_hints.icon_y = icon_y;
13246
13247 XSetWMHints (FRAME_X_DISPLAY (f), window, &f->output_data.x->wm_hints);
13248 }
13249
13250 \f
13251 /***********************************************************************
13252 Fonts
13253 ***********************************************************************/
13254
13255 /* Return a pointer to struct font_info of font FONT_IDX of frame F. */
13256
13257 struct font_info *
13258 x_get_font_info (f, font_idx)
13259 FRAME_PTR f;
13260 int font_idx;
13261 {
13262 return (FRAME_X_FONT_TABLE (f) + font_idx);
13263 }
13264
13265
13266 /* Return a list of names of available fonts matching PATTERN on frame F.
13267
13268 If SIZE is > 0, it is the size (maximum bounds width) of fonts
13269 to be listed.
13270
13271 SIZE < 0 means include scalable fonts.
13272
13273 Frame F null means we have not yet created any frame on X, and
13274 consult the first display in x_display_list. MAXNAMES sets a limit
13275 on how many fonts to match. */
13276
13277 Lisp_Object
13278 x_list_fonts (f, pattern, size, maxnames)
13279 struct frame *f;
13280 Lisp_Object pattern;
13281 int size;
13282 int maxnames;
13283 {
13284 Lisp_Object list = Qnil, patterns, newlist = Qnil, key = Qnil;
13285 Lisp_Object tem, second_best;
13286 struct x_display_info *dpyinfo
13287 = f ? FRAME_X_DISPLAY_INFO (f) : x_display_list;
13288 Display *dpy = dpyinfo->display;
13289 int try_XLoadQueryFont = 0;
13290 int count;
13291 int allow_scalable_fonts_p = 0;
13292
13293 if (size < 0)
13294 {
13295 allow_scalable_fonts_p = 1;
13296 size = 0;
13297 }
13298
13299 patterns = Fassoc (pattern, Valternate_fontname_alist);
13300 if (NILP (patterns))
13301 patterns = Fcons (pattern, Qnil);
13302
13303 if (maxnames == 1 && !size)
13304 /* We can return any single font matching PATTERN. */
13305 try_XLoadQueryFont = 1;
13306
13307 for (; CONSP (patterns); patterns = XCDR (patterns))
13308 {
13309 int num_fonts;
13310 char **names = NULL;
13311
13312 pattern = XCAR (patterns);
13313 /* See if we cached the result for this particular query.
13314 The cache is an alist of the form:
13315 ((((PATTERN . MAXNAMES) . SCALABLE) (FONTNAME . WIDTH) ...) ...) */
13316 tem = XCDR (dpyinfo->name_list_element);
13317 key = Fcons (Fcons (pattern, make_number (maxnames)),
13318 allow_scalable_fonts_p ? Qt : Qnil);
13319 list = Fassoc (key, tem);
13320 if (!NILP (list))
13321 {
13322 list = Fcdr_safe (list);
13323 /* We have a cashed list. Don't have to get the list again. */
13324 goto label_cached;
13325 }
13326
13327 /* At first, put PATTERN in the cache. */
13328
13329 BLOCK_INPUT;
13330 count = x_catch_errors (dpy);
13331
13332 if (try_XLoadQueryFont)
13333 {
13334 XFontStruct *font;
13335 unsigned long value;
13336
13337 font = XLoadQueryFont (dpy, XSTRING (pattern)->data);
13338 if (x_had_errors_p (dpy))
13339 {
13340 /* This error is perhaps due to insufficient memory on X
13341 server. Let's just ignore it. */
13342 font = NULL;
13343 x_clear_errors (dpy);
13344 }
13345
13346 if (font
13347 && XGetFontProperty (font, XA_FONT, &value))
13348 {
13349 char *name = (char *) XGetAtomName (dpy, (Atom) value);
13350 int len = strlen (name);
13351 char *tmp;
13352
13353 /* If DXPC (a Differential X Protocol Compressor)
13354 Ver.3.7 is running, XGetAtomName will return null
13355 string. We must avoid such a name. */
13356 if (len == 0)
13357 try_XLoadQueryFont = 0;
13358 else
13359 {
13360 num_fonts = 1;
13361 names = (char **) alloca (sizeof (char *));
13362 /* Some systems only allow alloca assigned to a
13363 simple var. */
13364 tmp = (char *) alloca (len + 1); names[0] = tmp;
13365 bcopy (name, names[0], len + 1);
13366 XFree (name);
13367 }
13368 }
13369 else
13370 try_XLoadQueryFont = 0;
13371
13372 if (font)
13373 XFreeFont (dpy, font);
13374 }
13375
13376 if (!try_XLoadQueryFont)
13377 {
13378 /* We try at least 10 fonts because XListFonts will return
13379 auto-scaled fonts at the head. */
13380 names = XListFonts (dpy, XSTRING (pattern)->data, max (maxnames, 10),
13381 &num_fonts);
13382 if (x_had_errors_p (dpy))
13383 {
13384 /* This error is perhaps due to insufficient memory on X
13385 server. Let's just ignore it. */
13386 names = NULL;
13387 x_clear_errors (dpy);
13388 }
13389 }
13390
13391 x_uncatch_errors (dpy, count);
13392 UNBLOCK_INPUT;
13393
13394 if (names)
13395 {
13396 int i;
13397
13398 /* Make a list of all the fonts we got back.
13399 Store that in the font cache for the display. */
13400 for (i = 0; i < num_fonts; i++)
13401 {
13402 int width = 0;
13403 char *p = names[i];
13404 int average_width = -1, dashes = 0;
13405
13406 /* Count the number of dashes in NAMES[I]. If there are
13407 14 dashes, and the field value following 12th dash
13408 (AVERAGE_WIDTH) is 0, this is a auto-scaled font which
13409 is usually too ugly to be used for editing. Let's
13410 ignore it. */
13411 while (*p)
13412 if (*p++ == '-')
13413 {
13414 dashes++;
13415 if (dashes == 7) /* PIXEL_SIZE field */
13416 width = atoi (p);
13417 else if (dashes == 12) /* AVERAGE_WIDTH field */
13418 average_width = atoi (p);
13419 }
13420
13421 if (allow_scalable_fonts_p
13422 || dashes < 14 || average_width != 0)
13423 {
13424 tem = build_string (names[i]);
13425 if (NILP (Fassoc (tem, list)))
13426 {
13427 if (STRINGP (Vx_pixel_size_width_font_regexp)
13428 && ((fast_c_string_match_ignore_case
13429 (Vx_pixel_size_width_font_regexp, names[i]))
13430 >= 0))
13431 /* We can set the value of PIXEL_SIZE to the
13432 width of this font. */
13433 list = Fcons (Fcons (tem, make_number (width)), list);
13434 else
13435 /* For the moment, width is not known. */
13436 list = Fcons (Fcons (tem, Qnil), list);
13437 }
13438 }
13439 }
13440
13441 if (!try_XLoadQueryFont)
13442 {
13443 BLOCK_INPUT;
13444 XFreeFontNames (names);
13445 UNBLOCK_INPUT;
13446 }
13447 }
13448
13449 /* Now store the result in the cache. */
13450 XCDR (dpyinfo->name_list_element)
13451 = Fcons (Fcons (key, list), XCDR (dpyinfo->name_list_element));
13452
13453 label_cached:
13454 if (NILP (list)) continue; /* Try the remaining alternatives. */
13455
13456 newlist = second_best = Qnil;
13457 /* Make a list of the fonts that have the right width. */
13458 for (; CONSP (list); list = XCDR (list))
13459 {
13460 int found_size;
13461
13462 tem = XCAR (list);
13463
13464 if (!CONSP (tem) || NILP (XCAR (tem)))
13465 continue;
13466 if (!size)
13467 {
13468 newlist = Fcons (XCAR (tem), newlist);
13469 continue;
13470 }
13471
13472 if (!INTEGERP (XCDR (tem)))
13473 {
13474 /* Since we have not yet known the size of this font, we
13475 must try slow function call XLoadQueryFont. */
13476 XFontStruct *thisinfo;
13477
13478 BLOCK_INPUT;
13479 count = x_catch_errors (dpy);
13480 thisinfo = XLoadQueryFont (dpy,
13481 XSTRING (XCAR (tem))->data);
13482 if (x_had_errors_p (dpy))
13483 {
13484 /* This error is perhaps due to insufficient memory on X
13485 server. Let's just ignore it. */
13486 thisinfo = NULL;
13487 x_clear_errors (dpy);
13488 }
13489 x_uncatch_errors (dpy, count);
13490 UNBLOCK_INPUT;
13491
13492 if (thisinfo)
13493 {
13494 XCDR (tem)
13495 = (thisinfo->min_bounds.width == 0
13496 ? make_number (0)
13497 : make_number (thisinfo->max_bounds.width));
13498 BLOCK_INPUT;
13499 XFreeFont (dpy, thisinfo);
13500 UNBLOCK_INPUT;
13501 }
13502 else
13503 /* For unknown reason, the previous call of XListFont had
13504 returned a font which can't be opened. Record the size
13505 as 0 not to try to open it again. */
13506 XCDR (tem) = make_number (0);
13507 }
13508
13509 found_size = XINT (XCDR (tem));
13510 if (found_size == size)
13511 newlist = Fcons (XCAR (tem), newlist);
13512 else if (found_size > 0)
13513 {
13514 if (NILP (second_best))
13515 second_best = tem;
13516 else if (found_size < size)
13517 {
13518 if (XINT (XCDR (second_best)) > size
13519 || XINT (XCDR (second_best)) < found_size)
13520 second_best = tem;
13521 }
13522 else
13523 {
13524 if (XINT (XCDR (second_best)) > size
13525 && XINT (XCDR (second_best)) > found_size)
13526 second_best = tem;
13527 }
13528 }
13529 }
13530 if (!NILP (newlist))
13531 break;
13532 else if (!NILP (second_best))
13533 {
13534 newlist = Fcons (XCAR (second_best), Qnil);
13535 break;
13536 }
13537 }
13538
13539 return newlist;
13540 }
13541
13542
13543 #if GLYPH_DEBUG
13544
13545 /* Check that FONT is valid on frame F. It is if it can be found in F's
13546 font table. */
13547
13548 static void
13549 x_check_font (f, font)
13550 struct frame *f;
13551 XFontStruct *font;
13552 {
13553 int i;
13554 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
13555
13556 xassert (font != NULL);
13557
13558 for (i = 0; i < dpyinfo->n_fonts; i++)
13559 if (dpyinfo->font_table[i].name
13560 && font == dpyinfo->font_table[i].font)
13561 break;
13562
13563 xassert (i < dpyinfo->n_fonts);
13564 }
13565
13566 #endif /* GLYPH_DEBUG != 0 */
13567
13568 /* Set *W to the minimum width, *H to the minimum font height of FONT.
13569 Note: There are (broken) X fonts out there with invalid XFontStruct
13570 min_bounds contents. For example, handa@etl.go.jp reports that
13571 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
13572 have font->min_bounds.width == 0. */
13573
13574 static INLINE void
13575 x_font_min_bounds (font, w, h)
13576 XFontStruct *font;
13577 int *w, *h;
13578 {
13579 *h = FONT_HEIGHT (font);
13580 *w = font->min_bounds.width;
13581
13582 /* Try to handle the case where FONT->min_bounds has invalid
13583 contents. Since the only font known to have invalid min_bounds
13584 is fixed-width, use max_bounds if min_bounds seems to be invalid. */
13585 if (*w <= 0)
13586 *w = font->max_bounds.width;
13587 }
13588
13589
13590 /* Compute the smallest character width and smallest font height over
13591 all fonts available on frame F. Set the members smallest_char_width
13592 and smallest_font_height in F's x_display_info structure to
13593 the values computed. Value is non-zero if smallest_font_height or
13594 smallest_char_width become smaller than they were before. */
13595
13596 static int
13597 x_compute_min_glyph_bounds (f)
13598 struct frame *f;
13599 {
13600 int i;
13601 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
13602 XFontStruct *font;
13603 int old_width = dpyinfo->smallest_char_width;
13604 int old_height = dpyinfo->smallest_font_height;
13605
13606 dpyinfo->smallest_font_height = 100000;
13607 dpyinfo->smallest_char_width = 100000;
13608
13609 for (i = 0; i < dpyinfo->n_fonts; ++i)
13610 if (dpyinfo->font_table[i].name)
13611 {
13612 struct font_info *fontp = dpyinfo->font_table + i;
13613 int w, h;
13614
13615 font = (XFontStruct *) fontp->font;
13616 xassert (font != (XFontStruct *) ~0);
13617 x_font_min_bounds (font, &w, &h);
13618
13619 dpyinfo->smallest_font_height = min (dpyinfo->smallest_font_height, h);
13620 dpyinfo->smallest_char_width = min (dpyinfo->smallest_char_width, w);
13621 }
13622
13623 xassert (dpyinfo->smallest_char_width > 0
13624 && dpyinfo->smallest_font_height > 0);
13625
13626 return (dpyinfo->n_fonts == 1
13627 || dpyinfo->smallest_char_width < old_width
13628 || dpyinfo->smallest_font_height < old_height);
13629 }
13630
13631
13632 /* Load font named FONTNAME of the size SIZE for frame F, and return a
13633 pointer to the structure font_info while allocating it dynamically.
13634 If SIZE is 0, load any size of font.
13635 If loading is failed, return NULL. */
13636
13637 struct font_info *
13638 x_load_font (f, fontname, size)
13639 struct frame *f;
13640 register char *fontname;
13641 int size;
13642 {
13643 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
13644 Lisp_Object font_names;
13645 int count;
13646
13647 /* Get a list of all the fonts that match this name. Once we
13648 have a list of matching fonts, we compare them against the fonts
13649 we already have by comparing names. */
13650 font_names = x_list_fonts (f, build_string (fontname), size, 1);
13651
13652 if (!NILP (font_names))
13653 {
13654 Lisp_Object tail;
13655 int i;
13656
13657 for (i = 0; i < dpyinfo->n_fonts; i++)
13658 for (tail = font_names; CONSP (tail); tail = XCDR (tail))
13659 if (dpyinfo->font_table[i].name
13660 && (!strcmp (dpyinfo->font_table[i].name,
13661 XSTRING (XCAR (tail))->data)
13662 || !strcmp (dpyinfo->font_table[i].full_name,
13663 XSTRING (XCAR (tail))->data)))
13664 return (dpyinfo->font_table + i);
13665 }
13666
13667 /* Load the font and add it to the table. */
13668 {
13669 char *full_name;
13670 XFontStruct *font;
13671 struct font_info *fontp;
13672 unsigned long value;
13673 int i;
13674
13675 /* If we have found fonts by x_list_font, load one of them. If
13676 not, we still try to load a font by the name given as FONTNAME
13677 because XListFonts (called in x_list_font) of some X server has
13678 a bug of not finding a font even if the font surely exists and
13679 is loadable by XLoadQueryFont. */
13680 if (size > 0 && !NILP (font_names))
13681 fontname = (char *) XSTRING (XCAR (font_names))->data;
13682
13683 BLOCK_INPUT;
13684 count = x_catch_errors (FRAME_X_DISPLAY (f));
13685 font = (XFontStruct *) XLoadQueryFont (FRAME_X_DISPLAY (f), fontname);
13686 if (x_had_errors_p (FRAME_X_DISPLAY (f)))
13687 {
13688 /* This error is perhaps due to insufficient memory on X
13689 server. Let's just ignore it. */
13690 font = NULL;
13691 x_clear_errors (FRAME_X_DISPLAY (f));
13692 }
13693 x_uncatch_errors (FRAME_X_DISPLAY (f), count);
13694 UNBLOCK_INPUT;
13695 if (!font)
13696 return NULL;
13697
13698 /* Find a free slot in the font table. */
13699 for (i = 0; i < dpyinfo->n_fonts; ++i)
13700 if (dpyinfo->font_table[i].name == NULL)
13701 break;
13702
13703 /* If no free slot found, maybe enlarge the font table. */
13704 if (i == dpyinfo->n_fonts
13705 && dpyinfo->n_fonts == dpyinfo->font_table_size)
13706 {
13707 int sz;
13708 dpyinfo->font_table_size = max (16, 2 * dpyinfo->font_table_size);
13709 sz = dpyinfo->font_table_size * sizeof *dpyinfo->font_table;
13710 dpyinfo->font_table
13711 = (struct font_info *) xrealloc (dpyinfo->font_table, sz);
13712 }
13713
13714 fontp = dpyinfo->font_table + i;
13715 if (i == dpyinfo->n_fonts)
13716 ++dpyinfo->n_fonts;
13717
13718 /* Now fill in the slots of *FONTP. */
13719 BLOCK_INPUT;
13720 fontp->font = font;
13721 fontp->font_idx = i;
13722 fontp->name = (char *) xmalloc (strlen (fontname) + 1);
13723 bcopy (fontname, fontp->name, strlen (fontname) + 1);
13724
13725 /* Try to get the full name of FONT. Put it in FULL_NAME. */
13726 full_name = 0;
13727 if (XGetFontProperty (font, XA_FONT, &value))
13728 {
13729 char *name = (char *) XGetAtomName (FRAME_X_DISPLAY (f), (Atom) value);
13730 char *p = name;
13731 int dashes = 0;
13732
13733 /* Count the number of dashes in the "full name".
13734 If it is too few, this isn't really the font's full name,
13735 so don't use it.
13736 In X11R4, the fonts did not come with their canonical names
13737 stored in them. */
13738 while (*p)
13739 {
13740 if (*p == '-')
13741 dashes++;
13742 p++;
13743 }
13744
13745 if (dashes >= 13)
13746 {
13747 full_name = (char *) xmalloc (p - name + 1);
13748 bcopy (name, full_name, p - name + 1);
13749 }
13750
13751 XFree (name);
13752 }
13753
13754 if (full_name != 0)
13755 fontp->full_name = full_name;
13756 else
13757 fontp->full_name = fontp->name;
13758
13759 fontp->size = font->max_bounds.width;
13760 fontp->height = FONT_HEIGHT (font);
13761
13762 if (NILP (font_names))
13763 {
13764 /* We come here because of a bug of XListFonts mentioned at
13765 the head of this block. Let's store this information in
13766 the cache for x_list_fonts. */
13767 Lisp_Object lispy_name = build_string (fontname);
13768 Lisp_Object lispy_full_name = build_string (fontp->full_name);
13769 Lisp_Object key = Fcons (Fcons (lispy_name, make_number (256)),
13770 Qnil);
13771
13772 XCDR (dpyinfo->name_list_element)
13773 = Fcons (Fcons (key,
13774 Fcons (Fcons (lispy_full_name,
13775 make_number (fontp->size)),
13776 Qnil)),
13777 XCDR (dpyinfo->name_list_element));
13778 if (full_name)
13779 {
13780 key = Fcons (Fcons (lispy_full_name, make_number (256)),
13781 Qnil);
13782 XCDR (dpyinfo->name_list_element)
13783 = Fcons (Fcons (key,
13784 Fcons (Fcons (lispy_full_name,
13785 make_number (fontp->size)),
13786 Qnil)),
13787 XCDR (dpyinfo->name_list_element));
13788 }
13789 }
13790
13791 /* The slot `encoding' specifies how to map a character
13792 code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
13793 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
13794 (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
13795 2:0xA020..0xFF7F). For the moment, we don't know which charset
13796 uses this font. So, we set information in fontp->encoding[1]
13797 which is never used by any charset. If mapping can't be
13798 decided, set FONT_ENCODING_NOT_DECIDED. */
13799 fontp->encoding[1]
13800 = (font->max_byte1 == 0
13801 /* 1-byte font */
13802 ? (font->min_char_or_byte2 < 0x80
13803 ? (font->max_char_or_byte2 < 0x80
13804 ? 0 /* 0x20..0x7F */
13805 : FONT_ENCODING_NOT_DECIDED) /* 0x20..0xFF */
13806 : 1) /* 0xA0..0xFF */
13807 /* 2-byte font */
13808 : (font->min_byte1 < 0x80
13809 ? (font->max_byte1 < 0x80
13810 ? (font->min_char_or_byte2 < 0x80
13811 ? (font->max_char_or_byte2 < 0x80
13812 ? 0 /* 0x2020..0x7F7F */
13813 : FONT_ENCODING_NOT_DECIDED) /* 0x2020..0x7FFF */
13814 : 3) /* 0x20A0..0x7FFF */
13815 : FONT_ENCODING_NOT_DECIDED) /* 0x20??..0xA0?? */
13816 : (font->min_char_or_byte2 < 0x80
13817 ? (font->max_char_or_byte2 < 0x80
13818 ? 2 /* 0xA020..0xFF7F */
13819 : FONT_ENCODING_NOT_DECIDED) /* 0xA020..0xFFFF */
13820 : 1))); /* 0xA0A0..0xFFFF */
13821
13822 fontp->baseline_offset
13823 = (XGetFontProperty (font, dpyinfo->Xatom_MULE_BASELINE_OFFSET, &value)
13824 ? (long) value : 0);
13825 fontp->relative_compose
13826 = (XGetFontProperty (font, dpyinfo->Xatom_MULE_RELATIVE_COMPOSE, &value)
13827 ? (long) value : 0);
13828 fontp->default_ascent
13829 = (XGetFontProperty (font, dpyinfo->Xatom_MULE_DEFAULT_ASCENT, &value)
13830 ? (long) value : 0);
13831
13832 /* Set global flag fonts_changed_p to non-zero if the font loaded
13833 has a character with a smaller width than any other character
13834 before, or if the font loaded has a smalle>r height than any
13835 other font loaded before. If this happens, it will make a
13836 glyph matrix reallocation necessary. */
13837 fonts_changed_p = x_compute_min_glyph_bounds (f);
13838 UNBLOCK_INPUT;
13839 return fontp;
13840 }
13841 }
13842
13843
13844 /* Return a pointer to struct font_info of a font named FONTNAME for
13845 frame F. If no such font is loaded, return NULL. */
13846
13847 struct font_info *
13848 x_query_font (f, fontname)
13849 struct frame *f;
13850 register char *fontname;
13851 {
13852 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
13853 int i;
13854
13855 for (i = 0; i < dpyinfo->n_fonts; i++)
13856 if (dpyinfo->font_table[i].name
13857 && (!strcmp (dpyinfo->font_table[i].name, fontname)
13858 || !strcmp (dpyinfo->font_table[i].full_name, fontname)))
13859 return (dpyinfo->font_table + i);
13860 return NULL;
13861 }
13862
13863
13864 /* Find a CCL program for a font specified by FONTP, and set the member
13865 `encoder' of the structure. */
13866
13867 void
13868 x_find_ccl_program (fontp)
13869 struct font_info *fontp;
13870 {
13871 Lisp_Object list, elt;
13872
13873 elt = Qnil;
13874 for (list = Vfont_ccl_encoder_alist; CONSP (list); list = XCDR (list))
13875 {
13876 elt = XCAR (list);
13877 if (CONSP (elt)
13878 && STRINGP (XCAR (elt))
13879 && ((fast_c_string_match_ignore_case (XCAR (elt), fontp->name)
13880 >= 0)
13881 || (fast_c_string_match_ignore_case (XCAR (elt), fontp->full_name)
13882 >= 0)))
13883 break;
13884 }
13885
13886 if (! NILP (list))
13887 {
13888 struct ccl_program *ccl
13889 = (struct ccl_program *) xmalloc (sizeof (struct ccl_program));
13890
13891 if (setup_ccl_program (ccl, XCDR (elt)) < 0)
13892 xfree (ccl);
13893 else
13894 fontp->font_encoder = ccl;
13895 }
13896 }
13897
13898
13899 \f
13900 /***********************************************************************
13901 Initialization
13902 ***********************************************************************/
13903
13904 #ifdef USE_X_TOOLKIT
13905 static XrmOptionDescRec emacs_options[] = {
13906 {"-geometry", ".geometry", XrmoptionSepArg, NULL},
13907 {"-iconic", ".iconic", XrmoptionNoArg, (XtPointer) "yes"},
13908
13909 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
13910 XrmoptionSepArg, NULL},
13911 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg, NULL},
13912
13913 {"-T", "*EmacsShell.title", XrmoptionSepArg, (XtPointer) NULL},
13914 {"-wn", "*EmacsShell.title", XrmoptionSepArg, (XtPointer) NULL},
13915 {"-title", "*EmacsShell.title", XrmoptionSepArg, (XtPointer) NULL},
13916 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg, (XtPointer) NULL},
13917 {"-in", "*EmacsShell.iconName", XrmoptionSepArg, (XtPointer) NULL},
13918 {"-mc", "*pointerColor", XrmoptionSepArg, (XtPointer) NULL},
13919 {"-cr", "*cursorColor", XrmoptionSepArg, (XtPointer) NULL}
13920 };
13921 #endif /* USE_X_TOOLKIT */
13922
13923 static int x_initialized;
13924
13925 #ifdef MULTI_KBOARD
13926 /* Test whether two display-name strings agree up to the dot that separates
13927 the screen number from the server number. */
13928 static int
13929 same_x_server (name1, name2)
13930 char *name1, *name2;
13931 {
13932 int seen_colon = 0;
13933 unsigned char *system_name = XSTRING (Vsystem_name)->data;
13934 int system_name_length = strlen (system_name);
13935 int length_until_period = 0;
13936
13937 while (system_name[length_until_period] != 0
13938 && system_name[length_until_period] != '.')
13939 length_until_period++;
13940
13941 /* Treat `unix' like an empty host name. */
13942 if (! strncmp (name1, "unix:", 5))
13943 name1 += 4;
13944 if (! strncmp (name2, "unix:", 5))
13945 name2 += 4;
13946 /* Treat this host's name like an empty host name. */
13947 if (! strncmp (name1, system_name, system_name_length)
13948 && name1[system_name_length] == ':')
13949 name1 += system_name_length;
13950 if (! strncmp (name2, system_name, system_name_length)
13951 && name2[system_name_length] == ':')
13952 name2 += system_name_length;
13953 /* Treat this host's domainless name like an empty host name. */
13954 if (! strncmp (name1, system_name, length_until_period)
13955 && name1[length_until_period] == ':')
13956 name1 += length_until_period;
13957 if (! strncmp (name2, system_name, length_until_period)
13958 && name2[length_until_period] == ':')
13959 name2 += length_until_period;
13960
13961 for (; *name1 != '\0' && *name1 == *name2; name1++, name2++)
13962 {
13963 if (*name1 == ':')
13964 seen_colon++;
13965 if (seen_colon && *name1 == '.')
13966 return 1;
13967 }
13968 return (seen_colon
13969 && (*name1 == '.' || *name1 == '\0')
13970 && (*name2 == '.' || *name2 == '\0'));
13971 }
13972 #endif
13973
13974 struct x_display_info *
13975 x_term_init (display_name, xrm_option, resource_name)
13976 Lisp_Object display_name;
13977 char *xrm_option;
13978 char *resource_name;
13979 {
13980 int connection;
13981 Display *dpy;
13982 struct x_display_info *dpyinfo;
13983 XrmDatabase xrdb;
13984
13985 BLOCK_INPUT;
13986
13987 if (!x_initialized)
13988 {
13989 x_initialize ();
13990 x_initialized = 1;
13991 }
13992
13993 #ifdef USE_X_TOOLKIT
13994 /* weiner@footloose.sps.mot.com reports that this causes
13995 errors with X11R5:
13996 X protocol error: BadAtom (invalid Atom parameter)
13997 on protocol request 18skiloaf.
13998 So let's not use it until R6. */
13999 #ifdef HAVE_X11XTR6
14000 XtSetLanguageProc (NULL, NULL, NULL);
14001 #endif
14002
14003 {
14004 int argc = 0;
14005 char *argv[3];
14006
14007 argv[0] = "";
14008 argc = 1;
14009 if (xrm_option)
14010 {
14011 argv[argc++] = "-xrm";
14012 argv[argc++] = xrm_option;
14013 }
14014 dpy = XtOpenDisplay (Xt_app_con, XSTRING (display_name)->data,
14015 resource_name, EMACS_CLASS,
14016 emacs_options, XtNumber (emacs_options),
14017 &argc, argv);
14018
14019 #ifdef HAVE_X11XTR6
14020 /* I think this is to compensate for XtSetLanguageProc. */
14021 fixup_locale ();
14022 #endif
14023 }
14024
14025 #else /* not USE_X_TOOLKIT */
14026 #ifdef HAVE_X11R5
14027 XSetLocaleModifiers ("");
14028 #endif
14029 dpy = XOpenDisplay (XSTRING (display_name)->data);
14030 #endif /* not USE_X_TOOLKIT */
14031
14032 /* Detect failure. */
14033 if (dpy == 0)
14034 {
14035 UNBLOCK_INPUT;
14036 return 0;
14037 }
14038
14039 /* We have definitely succeeded. Record the new connection. */
14040
14041 dpyinfo = (struct x_display_info *) xmalloc (sizeof (struct x_display_info));
14042 bzero (dpyinfo, sizeof *dpyinfo);
14043
14044 #ifdef MULTI_KBOARD
14045 {
14046 struct x_display_info *share;
14047 Lisp_Object tail;
14048
14049 for (share = x_display_list, tail = x_display_name_list; share;
14050 share = share->next, tail = XCDR (tail))
14051 if (same_x_server (XSTRING (XCAR (XCAR (tail)))->data,
14052 XSTRING (display_name)->data))
14053 break;
14054 if (share)
14055 dpyinfo->kboard = share->kboard;
14056 else
14057 {
14058 dpyinfo->kboard = (KBOARD *) xmalloc (sizeof (KBOARD));
14059 init_kboard (dpyinfo->kboard);
14060 if (!EQ (XSYMBOL (Qvendor_specific_keysyms)->function, Qunbound))
14061 {
14062 char *vendor = ServerVendor (dpy);
14063 UNBLOCK_INPUT;
14064 dpyinfo->kboard->Vsystem_key_alist
14065 = call1 (Qvendor_specific_keysyms,
14066 build_string (vendor ? vendor : ""));
14067 BLOCK_INPUT;
14068 }
14069
14070 dpyinfo->kboard->next_kboard = all_kboards;
14071 all_kboards = dpyinfo->kboard;
14072 /* Don't let the initial kboard remain current longer than necessary.
14073 That would cause problems if a file loaded on startup tries to
14074 prompt in the mini-buffer. */
14075 if (current_kboard == initial_kboard)
14076 current_kboard = dpyinfo->kboard;
14077 }
14078 dpyinfo->kboard->reference_count++;
14079 }
14080 #endif
14081
14082 /* Put this display on the chain. */
14083 dpyinfo->next = x_display_list;
14084 x_display_list = dpyinfo;
14085
14086 /* Put it on x_display_name_list as well, to keep them parallel. */
14087 x_display_name_list = Fcons (Fcons (display_name, Qnil),
14088 x_display_name_list);
14089 dpyinfo->name_list_element = XCAR (x_display_name_list);
14090
14091 dpyinfo->display = dpy;
14092
14093 #if 0
14094 XSetAfterFunction (x_current_display, x_trace_wire);
14095 #endif /* ! 0 */
14096
14097 dpyinfo->x_id_name
14098 = (char *) xmalloc (STRING_BYTES (XSTRING (Vinvocation_name))
14099 + STRING_BYTES (XSTRING (Vsystem_name))
14100 + 2);
14101 sprintf (dpyinfo->x_id_name, "%s@%s",
14102 XSTRING (Vinvocation_name)->data, XSTRING (Vsystem_name)->data);
14103
14104 /* Figure out which modifier bits mean what. */
14105 x_find_modifier_meanings (dpyinfo);
14106
14107 /* Get the scroll bar cursor. */
14108 dpyinfo->vertical_scroll_bar_cursor
14109 = XCreateFontCursor (dpyinfo->display, XC_sb_v_double_arrow);
14110
14111 xrdb = x_load_resources (dpyinfo->display, xrm_option,
14112 resource_name, EMACS_CLASS);
14113 #ifdef HAVE_XRMSETDATABASE
14114 XrmSetDatabase (dpyinfo->display, xrdb);
14115 #else
14116 dpyinfo->display->db = xrdb;
14117 #endif
14118 /* Put the rdb where we can find it in a way that works on
14119 all versions. */
14120 dpyinfo->xrdb = xrdb;
14121
14122 dpyinfo->screen = ScreenOfDisplay (dpyinfo->display,
14123 DefaultScreen (dpyinfo->display));
14124 select_visual (dpyinfo);
14125 dpyinfo->cmap = DefaultColormapOfScreen (dpyinfo->screen);
14126 dpyinfo->height = HeightOfScreen (dpyinfo->screen);
14127 dpyinfo->width = WidthOfScreen (dpyinfo->screen);
14128 dpyinfo->root_window = RootWindowOfScreen (dpyinfo->screen);
14129 dpyinfo->grabbed = 0;
14130 dpyinfo->reference_count = 0;
14131 dpyinfo->icon_bitmap_id = -1;
14132 dpyinfo->font_table = NULL;
14133 dpyinfo->n_fonts = 0;
14134 dpyinfo->font_table_size = 0;
14135 dpyinfo->bitmaps = 0;
14136 dpyinfo->bitmaps_size = 0;
14137 dpyinfo->bitmaps_last = 0;
14138 dpyinfo->scratch_cursor_gc = 0;
14139 dpyinfo->mouse_face_mouse_frame = 0;
14140 dpyinfo->mouse_face_deferred_gc = 0;
14141 dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
14142 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
14143 dpyinfo->mouse_face_face_id = DEFAULT_FACE_ID;
14144 dpyinfo->mouse_face_window = Qnil;
14145 dpyinfo->mouse_face_overlay = Qnil;
14146 dpyinfo->mouse_face_mouse_x = dpyinfo->mouse_face_mouse_y = 0;
14147 dpyinfo->mouse_face_defer = 0;
14148 dpyinfo->x_focus_frame = 0;
14149 dpyinfo->x_focus_event_frame = 0;
14150 dpyinfo->x_highlight_frame = 0;
14151 dpyinfo->image_cache = make_image_cache ();
14152
14153 /* See if a private colormap is requested. */
14154 if (dpyinfo->visual == DefaultVisualOfScreen (dpyinfo->screen))
14155 {
14156 if (dpyinfo->visual->class == PseudoColor)
14157 {
14158 Lisp_Object value;
14159 value = display_x_get_resource (dpyinfo,
14160 build_string ("privateColormap"),
14161 build_string ("PrivateColormap"),
14162 Qnil, Qnil);
14163 if (STRINGP (value)
14164 && (!strcmp (XSTRING (value)->data, "true")
14165 || !strcmp (XSTRING (value)->data, "on")))
14166 dpyinfo->cmap = XCopyColormapAndFree (dpyinfo->display, dpyinfo->cmap);
14167 }
14168 }
14169 else
14170 dpyinfo->cmap = XCreateColormap (dpyinfo->display, dpyinfo->root_window,
14171 dpyinfo->visual, AllocNone);
14172
14173 {
14174 int screen_number = XScreenNumberOfScreen (dpyinfo->screen);
14175 double pixels = DisplayHeight (dpyinfo->display, screen_number);
14176 double mm = DisplayHeightMM (dpyinfo->display, screen_number);
14177 dpyinfo->resy = pixels * 25.4 / mm;
14178 pixels = DisplayWidth (dpyinfo->display, screen_number);
14179 mm = DisplayWidthMM (dpyinfo->display, screen_number);
14180 dpyinfo->resx = pixels * 25.4 / mm;
14181 }
14182
14183 dpyinfo->Xatom_wm_protocols
14184 = XInternAtom (dpyinfo->display, "WM_PROTOCOLS", False);
14185 dpyinfo->Xatom_wm_take_focus
14186 = XInternAtom (dpyinfo->display, "WM_TAKE_FOCUS", False);
14187 dpyinfo->Xatom_wm_save_yourself
14188 = XInternAtom (dpyinfo->display, "WM_SAVE_YOURSELF", False);
14189 dpyinfo->Xatom_wm_delete_window
14190 = XInternAtom (dpyinfo->display, "WM_DELETE_WINDOW", False);
14191 dpyinfo->Xatom_wm_change_state
14192 = XInternAtom (dpyinfo->display, "WM_CHANGE_STATE", False);
14193 dpyinfo->Xatom_wm_configure_denied
14194 = XInternAtom (dpyinfo->display, "WM_CONFIGURE_DENIED", False);
14195 dpyinfo->Xatom_wm_window_moved
14196 = XInternAtom (dpyinfo->display, "WM_MOVED", False);
14197 dpyinfo->Xatom_editres
14198 = XInternAtom (dpyinfo->display, "Editres", False);
14199 dpyinfo->Xatom_CLIPBOARD
14200 = XInternAtom (dpyinfo->display, "CLIPBOARD", False);
14201 dpyinfo->Xatom_TIMESTAMP
14202 = XInternAtom (dpyinfo->display, "TIMESTAMP", False);
14203 dpyinfo->Xatom_TEXT
14204 = XInternAtom (dpyinfo->display, "TEXT", False);
14205 dpyinfo->Xatom_COMPOUND_TEXT
14206 = XInternAtom (dpyinfo->display, "COMPOUND_TEXT", False);
14207 dpyinfo->Xatom_DELETE
14208 = XInternAtom (dpyinfo->display, "DELETE", False);
14209 dpyinfo->Xatom_MULTIPLE
14210 = XInternAtom (dpyinfo->display, "MULTIPLE", False);
14211 dpyinfo->Xatom_INCR
14212 = XInternAtom (dpyinfo->display, "INCR", False);
14213 dpyinfo->Xatom_EMACS_TMP
14214 = XInternAtom (dpyinfo->display, "_EMACS_TMP_", False);
14215 dpyinfo->Xatom_TARGETS
14216 = XInternAtom (dpyinfo->display, "TARGETS", False);
14217 dpyinfo->Xatom_NULL
14218 = XInternAtom (dpyinfo->display, "NULL", False);
14219 dpyinfo->Xatom_ATOM_PAIR
14220 = XInternAtom (dpyinfo->display, "ATOM_PAIR", False);
14221 /* For properties of font. */
14222 dpyinfo->Xatom_PIXEL_SIZE
14223 = XInternAtom (dpyinfo->display, "PIXEL_SIZE", False);
14224 dpyinfo->Xatom_MULE_BASELINE_OFFSET
14225 = XInternAtom (dpyinfo->display, "_MULE_BASELINE_OFFSET", False);
14226 dpyinfo->Xatom_MULE_RELATIVE_COMPOSE
14227 = XInternAtom (dpyinfo->display, "_MULE_RELATIVE_COMPOSE", False);
14228 dpyinfo->Xatom_MULE_DEFAULT_ASCENT
14229 = XInternAtom (dpyinfo->display, "_MULE_DEFAULT_ASCENT", False);
14230
14231 /* Ghostscript support. */
14232 dpyinfo->Xatom_PAGE = XInternAtom (dpyinfo->display, "PAGE", False);
14233 dpyinfo->Xatom_DONE = XInternAtom (dpyinfo->display, "DONE", False);
14234
14235 dpyinfo->Xatom_Scrollbar = XInternAtom (dpyinfo->display, "SCROLLBAR",
14236 False);
14237
14238 dpyinfo->cut_buffers_initialized = 0;
14239
14240 connection = ConnectionNumber (dpyinfo->display);
14241 dpyinfo->connection = connection;
14242
14243 {
14244 char null_bits[1];
14245
14246 null_bits[0] = 0x00;
14247
14248 dpyinfo->null_pixel
14249 = XCreatePixmapFromBitmapData (dpyinfo->display, dpyinfo->root_window,
14250 null_bits, 1, 1, (long) 0, (long) 0,
14251 1);
14252 }
14253
14254 {
14255 extern int gray_bitmap_width, gray_bitmap_height;
14256 extern char *gray_bitmap_bits;
14257 dpyinfo->gray
14258 = XCreatePixmapFromBitmapData (dpyinfo->display, dpyinfo->root_window,
14259 gray_bitmap_bits,
14260 gray_bitmap_width, gray_bitmap_height,
14261 (unsigned long) 1, (unsigned long) 0, 1);
14262 }
14263
14264 #ifdef HAVE_X_I18N
14265 xim_initialize (dpyinfo, resource_name);
14266 #endif
14267
14268 #ifdef subprocesses
14269 /* This is only needed for distinguishing keyboard and process input. */
14270 if (connection != 0)
14271 add_keyboard_wait_descriptor (connection);
14272 #endif
14273
14274 #ifndef F_SETOWN_BUG
14275 #ifdef F_SETOWN
14276 #ifdef F_SETOWN_SOCK_NEG
14277 /* stdin is a socket here */
14278 fcntl (connection, F_SETOWN, -getpid ());
14279 #else /* ! defined (F_SETOWN_SOCK_NEG) */
14280 fcntl (connection, F_SETOWN, getpid ());
14281 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
14282 #endif /* ! defined (F_SETOWN) */
14283 #endif /* F_SETOWN_BUG */
14284
14285 #ifdef SIGIO
14286 if (interrupt_input)
14287 init_sigio (connection);
14288 #endif /* ! defined (SIGIO) */
14289
14290 #ifdef USE_LUCID
14291 #ifdef HAVE_X11R5 /* It seems X11R4 lacks XtCvtStringToFont, and XPointer. */
14292 /* Make sure that we have a valid font for dialog boxes
14293 so that Xt does not crash. */
14294 {
14295 Display *dpy = dpyinfo->display;
14296 XrmValue d, fr, to;
14297 Font font;
14298 int count;
14299
14300 d.addr = (XPointer)&dpy;
14301 d.size = sizeof (Display *);
14302 fr.addr = XtDefaultFont;
14303 fr.size = sizeof (XtDefaultFont);
14304 to.size = sizeof (Font *);
14305 to.addr = (XPointer)&font;
14306 count = x_catch_errors (dpy);
14307 if (!XtCallConverter (dpy, XtCvtStringToFont, &d, 1, &fr, &to, NULL))
14308 abort ();
14309 if (x_had_errors_p (dpy) || !XQueryFont (dpy, font))
14310 XrmPutLineResource (&xrdb, "Emacs.dialog.*.font: 9x15");
14311 x_uncatch_errors (dpy, count);
14312 }
14313 #endif
14314 #endif
14315
14316 /* See if we should run in synchronous mode. This is useful
14317 for debugging X code. */
14318 {
14319 Lisp_Object value;
14320 value = display_x_get_resource (dpyinfo,
14321 build_string ("synchronous"),
14322 build_string ("Synchronous"),
14323 Qnil, Qnil);
14324 if (STRINGP (value)
14325 && (!strcmp (XSTRING (value)->data, "true")
14326 || !strcmp (XSTRING (value)->data, "on")))
14327 XSynchronize (dpyinfo->display, True);
14328 }
14329
14330 UNBLOCK_INPUT;
14331
14332 return dpyinfo;
14333 }
14334 \f
14335 /* Get rid of display DPYINFO, assuming all frames are already gone,
14336 and without sending any more commands to the X server. */
14337
14338 void
14339 x_delete_display (dpyinfo)
14340 struct x_display_info *dpyinfo;
14341 {
14342 delete_keyboard_wait_descriptor (dpyinfo->connection);
14343
14344 /* Discard this display from x_display_name_list and x_display_list.
14345 We can't use Fdelq because that can quit. */
14346 if (! NILP (x_display_name_list)
14347 && EQ (XCAR (x_display_name_list), dpyinfo->name_list_element))
14348 x_display_name_list = XCDR (x_display_name_list);
14349 else
14350 {
14351 Lisp_Object tail;
14352
14353 tail = x_display_name_list;
14354 while (CONSP (tail) && CONSP (XCDR (tail)))
14355 {
14356 if (EQ (XCAR (XCDR (tail)), dpyinfo->name_list_element))
14357 {
14358 XCDR (tail) = XCDR (XCDR (tail));
14359 break;
14360 }
14361 tail = XCDR (tail);
14362 }
14363 }
14364
14365 if (next_noop_dpyinfo == dpyinfo)
14366 next_noop_dpyinfo = dpyinfo->next;
14367
14368 if (x_display_list == dpyinfo)
14369 x_display_list = dpyinfo->next;
14370 else
14371 {
14372 struct x_display_info *tail;
14373
14374 for (tail = x_display_list; tail; tail = tail->next)
14375 if (tail->next == dpyinfo)
14376 tail->next = tail->next->next;
14377 }
14378
14379 #ifndef USE_X_TOOLKIT /* I'm told Xt does this itself. */
14380 #ifndef AIX /* On AIX, XCloseDisplay calls this. */
14381 XrmDestroyDatabase (dpyinfo->xrdb);
14382 #endif
14383 #endif
14384 #ifdef MULTI_KBOARD
14385 if (--dpyinfo->kboard->reference_count == 0)
14386 delete_kboard (dpyinfo->kboard);
14387 #endif
14388 #ifdef HAVE_X_I18N
14389 if (dpyinfo->xim)
14390 xim_close_dpy (dpyinfo);
14391 #endif
14392
14393 xfree (dpyinfo->font_table);
14394 xfree (dpyinfo->x_id_name);
14395 xfree (dpyinfo->color_cells);
14396 xfree (dpyinfo);
14397 }
14398
14399 \f
14400 /* Set up use of X before we make the first connection. */
14401
14402 static struct redisplay_interface x_redisplay_interface =
14403 {
14404 x_produce_glyphs,
14405 x_write_glyphs,
14406 x_insert_glyphs,
14407 x_clear_end_of_line,
14408 x_scroll_run,
14409 x_after_update_window_line,
14410 x_update_window_begin,
14411 x_update_window_end,
14412 XTcursor_to,
14413 x_flush,
14414 x_clear_mouse_face,
14415 x_get_glyph_overhangs,
14416 x_fix_overlapping_area
14417 };
14418
14419 void
14420 x_initialize ()
14421 {
14422 rif = &x_redisplay_interface;
14423
14424 clear_frame_hook = x_clear_frame;
14425 ins_del_lines_hook = x_ins_del_lines;
14426 change_line_highlight_hook = x_change_line_highlight;
14427 delete_glyphs_hook = x_delete_glyphs;
14428 ring_bell_hook = XTring_bell;
14429 reset_terminal_modes_hook = XTreset_terminal_modes;
14430 set_terminal_modes_hook = XTset_terminal_modes;
14431 update_begin_hook = x_update_begin;
14432 update_end_hook = x_update_end;
14433 set_terminal_window_hook = XTset_terminal_window;
14434 read_socket_hook = XTread_socket;
14435 frame_up_to_date_hook = XTframe_up_to_date;
14436 reassert_line_highlight_hook = XTreassert_line_highlight;
14437 mouse_position_hook = XTmouse_position;
14438 frame_rehighlight_hook = XTframe_rehighlight;
14439 frame_raise_lower_hook = XTframe_raise_lower;
14440 set_vertical_scroll_bar_hook = XTset_vertical_scroll_bar;
14441 condemn_scroll_bars_hook = XTcondemn_scroll_bars;
14442 redeem_scroll_bar_hook = XTredeem_scroll_bar;
14443 judge_scroll_bars_hook = XTjudge_scroll_bars;
14444 estimate_mode_line_height_hook = x_estimate_mode_line_height;
14445
14446 scroll_region_ok = 1; /* we'll scroll partial frames */
14447 char_ins_del_ok = 1;
14448 line_ins_del_ok = 1; /* we'll just blt 'em */
14449 fast_clear_end_of_line = 1; /* X does this well */
14450 memory_below_frame = 0; /* we don't remember what scrolls
14451 off the bottom */
14452 baud_rate = 19200;
14453
14454 x_noop_count = 0;
14455 last_tool_bar_item = -1;
14456 any_help_event_p = 0;
14457
14458 /* Try to use interrupt input; if we can't, then start polling. */
14459 Fset_input_mode (Qt, Qnil, Qt, Qnil);
14460
14461 #ifdef USE_X_TOOLKIT
14462 XtToolkitInitialize ();
14463
14464 Xt_app_con = XtCreateApplicationContext ();
14465
14466 /* Register a converter from strings to pixels, which uses
14467 Emacs' color allocation infrastructure. */
14468 XtAppSetTypeConverter (Xt_app_con,
14469 XtRString, XtRPixel, cvt_string_to_pixel,
14470 cvt_string_to_pixel_args,
14471 XtNumber (cvt_string_to_pixel_args),
14472 XtCacheByDisplay, cvt_pixel_dtor);
14473
14474 XtAppSetFallbackResources (Xt_app_con, Xt_default_resources);
14475
14476 /* Install an asynchronous timer that processes Xt timeout events
14477 every 0.1s. This is necessary because some widget sets use
14478 timeouts internally, for example the LessTif menu bar, or the
14479 Xaw3d scroll bar. When Xt timouts aren't processed, these
14480 widgets don't behave normally. */
14481 {
14482 EMACS_TIME interval;
14483 EMACS_SET_SECS_USECS (interval, 0, 100000);
14484 start_atimer (ATIMER_CONTINUOUS, interval, x_process_timeouts, 0);
14485 }
14486 #endif
14487
14488 #ifdef USE_TOOLKIT_SCROLL_BARS
14489 xaw3d_arrow_scroll = False;
14490 xaw3d_pick_top = True;
14491 #endif
14492
14493 /* Note that there is no real way portable across R3/R4 to get the
14494 original error handler. */
14495 XSetErrorHandler (x_error_handler);
14496 XSetIOErrorHandler (x_io_error_quitter);
14497
14498 /* Disable Window Change signals; they are handled by X events. */
14499 #ifdef SIGWINCH
14500 signal (SIGWINCH, SIG_DFL);
14501 #endif /* ! defined (SIGWINCH) */
14502
14503 signal (SIGPIPE, x_connection_signal);
14504 }
14505
14506
14507 void
14508 syms_of_xterm ()
14509 {
14510 staticpro (&x_error_message_string);
14511 x_error_message_string = Qnil;
14512
14513 staticpro (&x_display_name_list);
14514 x_display_name_list = Qnil;
14515
14516 staticpro (&last_mouse_scroll_bar);
14517 last_mouse_scroll_bar = Qnil;
14518
14519 staticpro (&Qvendor_specific_keysyms);
14520 Qvendor_specific_keysyms = intern ("vendor-specific-keysyms");
14521
14522 staticpro (&last_mouse_press_frame);
14523 last_mouse_press_frame = Qnil;
14524
14525 help_echo = Qnil;
14526 staticpro (&help_echo);
14527 help_echo_object = Qnil;
14528 staticpro (&help_echo_object);
14529 help_echo_window = Qnil;
14530 staticpro (&help_echo_window);
14531 previous_help_echo = Qnil;
14532 staticpro (&previous_help_echo);
14533 help_echo_pos = -1;
14534
14535 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p,
14536 "*Non-nil means draw block cursor as wide as the glyph under it.\n\
14537 For example, if a block cursor is over a tab, it will be drawn as\n\
14538 wide as that tab on the display.");
14539 x_stretch_cursor_p = 0;
14540
14541 DEFVAR_BOOL ("x-use-underline-position-properties",
14542 &x_use_underline_position_properties,
14543 "*Non-nil means make use of UNDERLINE_POSITION font properties.\n\
14544 Nil means ignore them. If you encounter fonts with bogus\n\
14545 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior\n\
14546 to 4.1, set this to nil.");
14547 x_use_underline_position_properties = 1;
14548
14549 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars,
14550 "What X toolkit scroll bars Emacs uses.\n\
14551 A value of nil means Emacs doesn't use X toolkit scroll bars.\n\
14552 Otherwise, value is a symbol describing the X toolkit.");
14553 #ifdef USE_TOOLKIT_SCROLL_BARS
14554 #ifdef USE_MOTIF
14555 Vx_toolkit_scroll_bars = intern ("motif");
14556 #elif defined HAVE_XAW3D
14557 Vx_toolkit_scroll_bars = intern ("xaw3d");
14558 #else
14559 Vx_toolkit_scroll_bars = intern ("xaw");
14560 #endif
14561 #else
14562 Vx_toolkit_scroll_bars = Qnil;
14563 #endif
14564
14565 staticpro (&last_mouse_motion_frame);
14566 last_mouse_motion_frame = Qnil;
14567 }
14568
14569 #endif /* not HAVE_X_WINDOWS */