(start_hourglass, cancel_hourglass)
[bpt/emacs.git] / 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 #include <Xm/ScrollBarP.h>
121 #else /* !USE_MOTIF i.e. use Xaw */
122
123 #ifdef HAVE_XAW3D
124 #include <X11/Xaw3d/Simple.h>
125 #include <X11/Xaw3d/Scrollbar.h>
126 #define ARROW_SCROLLBAR
127 #include <X11/Xaw3d/ScrollbarP.h>
128 #else /* !HAVE_XAW3D */
129 #include <X11/Xaw/Simple.h>
130 #include <X11/Xaw/Scrollbar.h>
131 #endif /* !HAVE_XAW3D */
132 #ifndef XtNpickTop
133 #define XtNpickTop "pickTop"
134 #endif /* !XtNpickTop */
135 #endif /* !USE_MOTIF */
136 #endif /* USE_TOOLKIT_SCROLL_BARS */
137
138 #endif /* USE_X_TOOLKIT */
139
140 #ifndef USE_X_TOOLKIT
141 #define x_any_window_to_frame x_window_to_frame
142 #define x_top_window_to_frame x_window_to_frame
143 #endif
144
145 #ifdef USE_X_TOOLKIT
146 #include "widget.h"
147 #ifndef XtNinitialState
148 #define XtNinitialState "initialState"
149 #endif
150 #endif
151
152 #ifndef min
153 #define min(a,b) ((a) < (b) ? (a) : (b))
154 #endif
155 #ifndef max
156 #define max(a,b) ((a) > (b) ? (a) : (b))
157 #endif
158
159 #define abs(x) ((x) < 0 ? -(x) : (x))
160
161 #define BETWEEN(X, LOWER, UPPER) ((X) >= (LOWER) && (X) < (UPPER))
162
163 \f
164 /* Bitmaps for truncated lines. */
165
166 enum bitmap_type
167 {
168 NO_BITMAP,
169 LEFT_TRUNCATION_BITMAP,
170 RIGHT_TRUNCATION_BITMAP,
171 OVERLAY_ARROW_BITMAP,
172 CONTINUED_LINE_BITMAP,
173 CONTINUATION_LINE_BITMAP,
174 ZV_LINE_BITMAP
175 };
176
177 /* Bitmap drawn to indicate lines not displaying text if
178 `indicate-empty-lines' is non-nil. */
179
180 #define zv_width 8
181 #define zv_height 8
182 static unsigned char zv_bits[] = {
183 0x00, 0x00, 0x1e, 0x1e, 0x1e, 0x1e, 0x00, 0x00};
184
185 /* An arrow like this: `<-'. */
186
187 #define left_width 8
188 #define left_height 8
189 static unsigned char left_bits[] = {
190 0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
191
192 /* Right truncation arrow bitmap `->'. */
193
194 #define right_width 8
195 #define right_height 8
196 static unsigned char right_bits[] = {
197 0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
198
199 /* Marker for continued lines. */
200
201 #define continued_width 8
202 #define continued_height 8
203 static unsigned char continued_bits[] = {
204 0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
205
206 /* Marker for continuation lines. */
207
208 #define continuation_width 8
209 #define continuation_height 8
210 static unsigned char continuation_bits[] = {
211 0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
212
213 /* Overlay arrow bitmap. */
214
215 #if 0
216 /* A bomb. */
217 #define ov_width 8
218 #define ov_height 8
219 static unsigned char ov_bits[] = {
220 0x30, 0x08, 0x3c, 0x7e, 0x7a, 0x7a, 0x62, 0x3c};
221 #else
222 /* A triangular arrow. */
223 #define ov_width 8
224 #define ov_height 8
225 static unsigned char ov_bits[] = {
226 0x03, 0x0f, 0x1f, 0x3f, 0x3f, 0x1f, 0x0f, 0x03};
227
228 #endif
229
230 extern Lisp_Object Qhelp_echo;
231
232 \f
233 /* Non-nil means Emacs uses toolkit scroll bars. */
234
235 Lisp_Object Vx_toolkit_scroll_bars;
236
237 /* If a string, XTread_socket generates an event to display that string.
238 (The display is done in read_char.) */
239
240 static Lisp_Object help_echo;
241 static Lisp_Object help_echo_window;
242 static Lisp_Object help_echo_object;
243 static int help_echo_pos;
244
245 /* Temporary variable for XTread_socket. */
246
247 static Lisp_Object previous_help_echo;
248
249 /* Non-zero means that a HELP_EVENT has been generated since Emacs
250 start. */
251
252 static int any_help_event_p;
253
254 /* Non-zero means draw block and hollow cursor as wide as the glyph
255 under it. For example, if a block cursor is over a tab, it will be
256 drawn as wide as that tab on the display. */
257
258 int x_stretch_cursor_p;
259
260 /* This is a chain of structures for all the X displays currently in
261 use. */
262
263 struct x_display_info *x_display_list;
264
265 /* This is a list of cons cells, each of the form (NAME
266 . FONT-LIST-CACHE), one for each element of x_display_list and in
267 the same order. NAME is the name of the frame. FONT-LIST-CACHE
268 records previous values returned by x-list-fonts. */
269
270 Lisp_Object x_display_name_list;
271
272 /* Frame being updated by update_frame. This is declared in term.c.
273 This is set by update_begin and looked at by all the XT functions.
274 It is zero while not inside an update. In that case, the XT
275 functions assume that `selected_frame' is the frame to apply to. */
276
277 extern struct frame *updating_frame;
278
279 extern int waiting_for_input;
280
281 /* This is a frame waiting to be auto-raised, within XTread_socket. */
282
283 struct frame *pending_autoraise_frame;
284
285 #ifdef USE_X_TOOLKIT
286 /* The application context for Xt use. */
287 XtAppContext Xt_app_con;
288 static String Xt_default_resources[] = {0};
289 #endif /* USE_X_TOOLKIT */
290
291 /* Nominal cursor position -- where to draw output.
292 HPOS and VPOS are window relative glyph matrix coordinates.
293 X and Y are window relative pixel coordinates. */
294
295 struct cursor_pos output_cursor;
296
297 /* Non-zero means user is interacting with a toolkit scroll bar. */
298
299 static int toolkit_scroll_bar_interaction;
300
301 /* Mouse movement.
302
303 Formerly, we used PointerMotionHintMask (in standard_event_mask)
304 so that we would have to call XQueryPointer after each MotionNotify
305 event to ask for another such event. However, this made mouse tracking
306 slow, and there was a bug that made it eventually stop.
307
308 Simply asking for MotionNotify all the time seems to work better.
309
310 In order to avoid asking for motion events and then throwing most
311 of them away or busy-polling the server for mouse positions, we ask
312 the server for pointer motion hints. This means that we get only
313 one event per group of mouse movements. "Groups" are delimited by
314 other kinds of events (focus changes and button clicks, for
315 example), or by XQueryPointer calls; when one of these happens, we
316 get another MotionNotify event the next time the mouse moves. This
317 is at least as efficient as getting motion events when mouse
318 tracking is on, and I suspect only negligibly worse when tracking
319 is off. */
320
321 /* Where the mouse was last time we reported a mouse event. */
322
323 FRAME_PTR last_mouse_frame;
324 static XRectangle last_mouse_glyph;
325 static Lisp_Object last_mouse_press_frame;
326
327 /* The scroll bar in which the last X motion event occurred.
328
329 If the last X motion event occurred in a scroll bar, we set this so
330 XTmouse_position can know whether to report a scroll bar motion or
331 an ordinary motion.
332
333 If the last X motion event didn't occur in a scroll bar, we set
334 this to Qnil, to tell XTmouse_position to return an ordinary motion
335 event. */
336
337 static Lisp_Object last_mouse_scroll_bar;
338
339 /* This is a hack. We would really prefer that XTmouse_position would
340 return the time associated with the position it returns, but there
341 doesn't seem to be any way to wrest the time-stamp from the server
342 along with the position query. So, we just keep track of the time
343 of the last movement we received, and return that in hopes that
344 it's somewhat accurate. */
345
346 static Time last_mouse_movement_time;
347
348 /* Incremented by XTread_socket whenever it really tries to read
349 events. */
350
351 #ifdef __STDC__
352 static int volatile input_signal_count;
353 #else
354 static int input_signal_count;
355 #endif
356
357 /* Used locally within XTread_socket. */
358
359 static int x_noop_count;
360
361 /* Initial values of argv and argc. */
362
363 extern char **initial_argv;
364 extern int initial_argc;
365
366 extern Lisp_Object Vcommand_line_args, Vsystem_name;
367
368 /* Tells if a window manager is present or not. */
369
370 extern Lisp_Object Vx_no_window_manager;
371
372 extern Lisp_Object Qface, Qmouse_face;
373
374 extern int errno;
375
376 /* A mask of extra modifier bits to put into every keyboard char. */
377
378 extern int extra_keyboard_modifiers;
379
380 static Lisp_Object Qvendor_specific_keysyms;
381
382 extern XrmDatabase x_load_resources P_ ((Display *, char *, char *, char *));
383 extern Lisp_Object x_icon_type P_ ((struct frame *));
384
385
386 /* Enumeration for overriding/changing the face to use for drawing
387 glyphs in x_draw_glyphs. */
388
389 enum draw_glyphs_face
390 {
391 DRAW_NORMAL_TEXT,
392 DRAW_INVERSE_VIDEO,
393 DRAW_CURSOR,
394 DRAW_MOUSE_FACE,
395 DRAW_IMAGE_RAISED,
396 DRAW_IMAGE_SUNKEN
397 };
398
399 static void x_set_window_size_1 P_ ((struct frame *, int, int, int));
400 static const XColor *x_color_cells P_ ((struct frame *, int *));
401 static void x_update_window_end P_ ((struct window *, int, int));
402 static void frame_to_window_pixel_xy P_ ((struct window *, int *, int *));
403 void x_delete_display P_ ((struct x_display_info *));
404 static unsigned int x_x_to_emacs_modifiers P_ ((struct x_display_info *,
405 unsigned));
406 static int fast_find_position P_ ((struct window *, int, int *, int *,
407 int *, int *));
408 static void set_output_cursor P_ ((struct cursor_pos *));
409 static struct glyph *x_y_to_hpos_vpos P_ ((struct window *, int, int,
410 int *, int *, int *));
411 static void note_mode_line_highlight P_ ((struct window *, int, int));
412 static void note_mouse_highlight P_ ((struct frame *, int, int));
413 static void note_tool_bar_highlight P_ ((struct frame *f, int, int));
414 static void x_handle_tool_bar_click P_ ((struct frame *, XButtonEvent *));
415 static void show_mouse_face P_ ((struct x_display_info *,
416 enum draw_glyphs_face));
417 static int x_io_error_quitter P_ ((Display *));
418 int x_catch_errors P_ ((Display *));
419 void x_uncatch_errors P_ ((Display *, int));
420 void x_lower_frame P_ ((struct frame *));
421 void x_scroll_bar_clear P_ ((struct frame *));
422 int x_had_errors_p P_ ((Display *));
423 void x_wm_set_size_hint P_ ((struct frame *, long, int));
424 void x_raise_frame P_ ((struct frame *));
425 void x_set_window_size P_ ((struct frame *, int, int, int));
426 void x_wm_set_window_state P_ ((struct frame *, int));
427 void x_wm_set_icon_pixmap P_ ((struct frame *, int));
428 void x_initialize P_ ((void));
429 static void x_font_min_bounds P_ ((XFontStruct *, int *, int *));
430 static int x_compute_min_glyph_bounds P_ ((struct frame *));
431 static void x_draw_phys_cursor_glyph P_ ((struct window *,
432 struct glyph_row *,
433 enum draw_glyphs_face));
434 static void x_update_end P_ ((struct frame *));
435 static void XTframe_up_to_date P_ ((struct frame *));
436 static void XTreassert_line_highlight P_ ((int, int));
437 static void x_change_line_highlight P_ ((int, int, int, int));
438 static void XTset_terminal_modes P_ ((void));
439 static void XTreset_terminal_modes P_ ((void));
440 static void XTcursor_to P_ ((int, int, int, int));
441 static void x_write_glyphs P_ ((struct glyph *, int));
442 static void x_clear_end_of_line P_ ((int));
443 static void x_clear_frame P_ ((void));
444 static void x_clear_cursor P_ ((struct window *));
445 static void frame_highlight P_ ((struct frame *));
446 static void frame_unhighlight P_ ((struct frame *));
447 static void x_new_focus_frame P_ ((struct x_display_info *, struct frame *));
448 static void XTframe_rehighlight P_ ((struct frame *));
449 static void x_frame_rehighlight P_ ((struct x_display_info *));
450 static void x_draw_hollow_cursor P_ ((struct window *, struct glyph_row *));
451 static void x_draw_bar_cursor P_ ((struct window *, struct glyph_row *, int));
452 static int x_intersect_rectangles P_ ((XRectangle *, XRectangle *,
453 XRectangle *));
454 static void expose_frame P_ ((struct frame *, int, int, int, int));
455 static void expose_window_tree P_ ((struct window *, XRectangle *));
456 static void expose_window P_ ((struct window *, XRectangle *));
457 static void expose_area P_ ((struct window *, struct glyph_row *,
458 XRectangle *, enum glyph_row_area));
459 static void expose_line P_ ((struct window *, struct glyph_row *,
460 XRectangle *));
461 static void x_update_cursor_in_window_tree P_ ((struct window *, int));
462 static void x_update_window_cursor P_ ((struct window *, int));
463 static void x_erase_phys_cursor P_ ((struct window *));
464 void x_display_and_set_cursor P_ ((struct window *, int, int, int, int, int));
465 static void x_draw_bitmap P_ ((struct window *, struct glyph_row *,
466 enum bitmap_type));
467
468 static void x_clip_to_row P_ ((struct window *, struct glyph_row *,
469 GC, int));
470 static int x_phys_cursor_in_rect_p P_ ((struct window *, XRectangle *));
471 static void x_draw_row_bitmaps P_ ((struct window *, struct glyph_row *));
472 static void note_overwritten_text_cursor P_ ((struct window *, int, int));
473 static void x_flush P_ ((struct frame *f));
474 static void x_update_begin P_ ((struct frame *));
475 static void x_update_window_begin P_ ((struct window *));
476 static void x_draw_vertical_border P_ ((struct window *));
477 static void x_after_update_window_line P_ ((struct glyph_row *));
478 static INLINE void take_vertical_position_into_account P_ ((struct it *));
479 static void x_produce_stretch_glyph P_ ((struct it *));
480
481
482 /* Flush display of frame F, or of all frames if F is null. */
483
484 static void
485 x_flush (f)
486 struct frame *f;
487 {
488 BLOCK_INPUT;
489 if (f == NULL)
490 {
491 Lisp_Object rest, frame;
492 FOR_EACH_FRAME (rest, frame)
493 x_flush (XFRAME (frame));
494 }
495 else if (FRAME_X_P (f))
496 XFlush (FRAME_X_DISPLAY (f));
497 UNBLOCK_INPUT;
498 }
499
500
501 /* Remove calls to XFlush by defining XFlush to an empty replacement.
502 Calls to XFlush should be unnecessary because the X output buffer
503 is flushed automatically as needed by calls to XPending,
504 XNextEvent, or XWindowEvent according to the XFlush man page.
505 XTread_socket calls XPending. Removing XFlush improves
506 performance. */
507
508 #define XFlush(DISPLAY) (void) 0
509
510 \f
511 /***********************************************************************
512 Debugging
513 ***********************************************************************/
514
515 #if 0
516
517 /* This is a function useful for recording debugging information about
518 the sequence of occurrences in this file. */
519
520 struct record
521 {
522 char *locus;
523 int type;
524 };
525
526 struct record event_record[100];
527
528 int event_record_index;
529
530 record_event (locus, type)
531 char *locus;
532 int type;
533 {
534 if (event_record_index == sizeof (event_record) / sizeof (struct record))
535 event_record_index = 0;
536
537 event_record[event_record_index].locus = locus;
538 event_record[event_record_index].type = type;
539 event_record_index++;
540 }
541
542 #endif /* 0 */
543
544
545 \f
546 /* Return the struct x_display_info corresponding to DPY. */
547
548 struct x_display_info *
549 x_display_info_for_display (dpy)
550 Display *dpy;
551 {
552 struct x_display_info *dpyinfo;
553
554 for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
555 if (dpyinfo->display == dpy)
556 return dpyinfo;
557
558 return 0;
559 }
560
561
562 \f
563 /***********************************************************************
564 Starting and ending an update
565 ***********************************************************************/
566
567 /* Start an update of frame F. This function is installed as a hook
568 for update_begin, i.e. it is called when update_begin is called.
569 This function is called prior to calls to x_update_window_begin for
570 each window being updated. Currently, there is nothing to do here
571 because all interesting stuff is done on a window basis. */
572
573 static void
574 x_update_begin (f)
575 struct frame *f;
576 {
577 /* Nothing to do. */
578 }
579
580
581 /* Start update of window W. Set the global variable updated_window
582 to the window being updated and set output_cursor to the cursor
583 position of W. */
584
585 static void
586 x_update_window_begin (w)
587 struct window *w;
588 {
589 struct frame *f = XFRAME (WINDOW_FRAME (w));
590 struct x_display_info *display_info = FRAME_X_DISPLAY_INFO (f);
591
592 updated_window = w;
593 set_output_cursor (&w->cursor);
594
595 BLOCK_INPUT;
596
597 if (f == display_info->mouse_face_mouse_frame)
598 {
599 /* Don't do highlighting for mouse motion during the update. */
600 display_info->mouse_face_defer = 1;
601
602 /* If F needs to be redrawn, simply forget about any prior mouse
603 highlighting. */
604 if (FRAME_GARBAGED_P (f))
605 display_info->mouse_face_window = Qnil;
606
607 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
608 their mouse_face_p flag set, which means that they are always
609 unequal to rows in a desired matrix which never have that
610 flag set. So, rows containing mouse-face glyphs are never
611 scrolled, and we don't have to switch the mouse highlight off
612 here to prevent it from being scrolled. */
613
614 /* Can we tell that this update does not affect the window
615 where the mouse highlight is? If so, no need to turn off.
616 Likewise, don't do anything if the frame is garbaged;
617 in that case, the frame's current matrix that we would use
618 is all wrong, and we will redisplay that line anyway. */
619 if (!NILP (display_info->mouse_face_window)
620 && w == XWINDOW (display_info->mouse_face_window))
621 {
622 int i;
623
624 for (i = 0; i < w->desired_matrix->nrows; ++i)
625 if (MATRIX_ROW_ENABLED_P (w->desired_matrix, i))
626 break;
627
628 if (i < w->desired_matrix->nrows)
629 clear_mouse_face (display_info);
630 }
631 #endif /* 0 */
632 }
633
634 UNBLOCK_INPUT;
635 }
636
637
638 /* Draw a vertical window border to the right of window W if W doesn't
639 have vertical scroll bars. */
640
641 static void
642 x_draw_vertical_border (w)
643 struct window *w;
644 {
645 struct frame *f = XFRAME (WINDOW_FRAME (w));
646
647 /* Redraw borders between horizontally adjacent windows. Don't
648 do it for frames with vertical scroll bars because either the
649 right scroll bar of a window, or the left scroll bar of its
650 neighbor will suffice as a border. */
651 if (!WINDOW_RIGHTMOST_P (w)
652 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f))
653 {
654 int x0, x1, y0, y1;
655
656 window_box_edges (w, -1, &x0, &y0, &x1, &y1);
657 x1 += FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f);
658 y1 -= 1;
659
660 XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
661 f->output_data.x->normal_gc, x1, y0, x1, y1);
662 }
663 }
664
665
666 /* End update of window W (which is equal to updated_window).
667
668 Draw vertical borders between horizontally adjacent windows, and
669 display W's cursor if CURSOR_ON_P is non-zero.
670
671 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
672 glyphs in mouse-face were overwritten. In that case we have to
673 make sure that the mouse-highlight is properly redrawn.
674
675 W may be a menu bar pseudo-window in case we don't have X toolkit
676 support. Such windows don't have a cursor, so don't display it
677 here. */
678
679 static void
680 x_update_window_end (w, cursor_on_p, mouse_face_overwritten_p)
681 struct window *w;
682 int cursor_on_p, mouse_face_overwritten_p;
683 {
684 if (!w->pseudo_window_p)
685 {
686 struct x_display_info *dpyinfo
687 = FRAME_X_DISPLAY_INFO (XFRAME (w->frame));
688
689 BLOCK_INPUT;
690
691 /* If a row with mouse-face was overwritten, arrange for
692 XTframe_up_to_date to redisplay the mouse highlight. */
693 if (mouse_face_overwritten_p)
694 {
695 dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
696 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
697 dpyinfo->mouse_face_window = Qnil;
698 }
699
700 if (cursor_on_p)
701 x_display_and_set_cursor (w, 1, output_cursor.hpos,
702 output_cursor.vpos,
703 output_cursor.x, output_cursor.y);
704
705 x_draw_vertical_border (w);
706 UNBLOCK_INPUT;
707 }
708
709 updated_window = NULL;
710 }
711
712
713 /* End update of frame F. This function is installed as a hook in
714 update_end. */
715
716 static void
717 x_update_end (f)
718 struct frame *f;
719 {
720 /* Mouse highlight may be displayed again. */
721 FRAME_X_DISPLAY_INFO (f)->mouse_face_defer = 0;
722
723 BLOCK_INPUT;
724 XFlush (FRAME_X_DISPLAY (f));
725 UNBLOCK_INPUT;
726 }
727
728
729 /* This function is called from various places in xdisp.c whenever a
730 complete update has been performed. The global variable
731 updated_window is not available here. */
732
733 static void
734 XTframe_up_to_date (f)
735 struct frame *f;
736 {
737 if (FRAME_X_P (f))
738 {
739 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
740
741 if (dpyinfo->mouse_face_deferred_gc
742 || f == dpyinfo->mouse_face_mouse_frame)
743 {
744 BLOCK_INPUT;
745 if (dpyinfo->mouse_face_mouse_frame)
746 note_mouse_highlight (dpyinfo->mouse_face_mouse_frame,
747 dpyinfo->mouse_face_mouse_x,
748 dpyinfo->mouse_face_mouse_y);
749 dpyinfo->mouse_face_deferred_gc = 0;
750 UNBLOCK_INPUT;
751 }
752 }
753 }
754
755
756 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
757 arrow bitmaps, or clear the areas where they would be displayed
758 before DESIRED_ROW is made current. The window being updated is
759 found in updated_window. This function It is called from
760 update_window_line only if it is known that there are differences
761 between bitmaps to be drawn between current row and DESIRED_ROW. */
762
763 static void
764 x_after_update_window_line (desired_row)
765 struct glyph_row *desired_row;
766 {
767 struct window *w = updated_window;
768
769 xassert (w);
770
771 if (!desired_row->mode_line_p && !w->pseudo_window_p)
772 {
773 struct frame *f;
774 int width;
775
776 BLOCK_INPUT;
777 x_draw_row_bitmaps (w, desired_row);
778
779 /* When a window has disappeared, make sure that no rest of
780 full-width rows stays visible in the internal border. */
781 if (windows_or_buffers_changed
782 && (f = XFRAME (w->frame),
783 width = FRAME_INTERNAL_BORDER_WIDTH (f),
784 width != 0))
785 {
786 int height = desired_row->visible_height;
787 int x = (window_box_right (w, -1)
788 + FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f));
789 int y = WINDOW_TO_FRAME_PIXEL_Y (w, max (0, desired_row->y));
790
791 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
792 x, y, width, height, False);
793 }
794
795 UNBLOCK_INPUT;
796 }
797 }
798
799
800 /* Draw the bitmap WHICH in one of the areas to the left or right of
801 window W. ROW is the glyph row for which to display the bitmap; it
802 determines the vertical position at which the bitmap has to be
803 drawn. */
804
805 static void
806 x_draw_bitmap (w, row, which)
807 struct window *w;
808 struct glyph_row *row;
809 enum bitmap_type which;
810 {
811 struct frame *f = XFRAME (WINDOW_FRAME (w));
812 Display *display = FRAME_X_DISPLAY (f);
813 Window window = FRAME_X_WINDOW (f);
814 int x, y, wd, h, dy;
815 unsigned char *bits;
816 Pixmap pixmap;
817 GC gc = f->output_data.x->normal_gc;
818 struct face *face;
819 int depth = DefaultDepthOfScreen (FRAME_X_SCREEN (f));
820
821 /* Must clip because of partially visible lines. */
822 x_clip_to_row (w, row, gc, 1);
823
824 switch (which)
825 {
826 case LEFT_TRUNCATION_BITMAP:
827 wd = left_width;
828 h = left_height;
829 bits = left_bits;
830 x = (WINDOW_TO_FRAME_PIXEL_X (w, 0)
831 - wd
832 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - wd) / 2);
833 break;
834
835 case OVERLAY_ARROW_BITMAP:
836 wd = left_width;
837 h = left_height;
838 bits = ov_bits;
839 x = (WINDOW_TO_FRAME_PIXEL_X (w, 0)
840 - wd
841 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - wd) / 2);
842 break;
843
844 case RIGHT_TRUNCATION_BITMAP:
845 wd = right_width;
846 h = right_height;
847 bits = right_bits;
848 x = window_box_right (w, -1);
849 x += (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f) - wd) / 2;
850 break;
851
852 case CONTINUED_LINE_BITMAP:
853 wd = right_width;
854 h = right_height;
855 bits = continued_bits;
856 x = window_box_right (w, -1);
857 x += (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f) - wd) / 2;
858 break;
859
860 case CONTINUATION_LINE_BITMAP:
861 wd = continuation_width;
862 h = continuation_height;
863 bits = continuation_bits;
864 x = (WINDOW_TO_FRAME_PIXEL_X (w, 0)
865 - wd
866 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - wd) / 2);
867 break;
868
869 case ZV_LINE_BITMAP:
870 wd = zv_width;
871 h = zv_height;
872 bits = zv_bits;
873 x = (WINDOW_TO_FRAME_PIXEL_X (w, 0)
874 - wd
875 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - wd) / 2);
876 break;
877
878 default:
879 abort ();
880 }
881
882 /* Convert to frame coordinates. Set dy to the offset in the row to
883 start drawing the bitmap. */
884 y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
885 dy = (row->height - h) / 2;
886
887 /* Draw the bitmap. I believe these small pixmaps can be cached
888 by the server. */
889 face = FACE_FROM_ID (f, BITMAP_AREA_FACE_ID);
890 pixmap = XCreatePixmapFromBitmapData (display, window, bits, wd, h,
891 face->foreground,
892 face->background, depth);
893 XCopyArea (display, pixmap, window, gc, 0, 0, wd, h, x, y + dy);
894 XFreePixmap (display, pixmap);
895 XSetClipMask (display, gc, None);
896 }
897
898
899 /* Draw flags bitmaps for glyph row ROW on window W. Call this
900 function with input blocked. */
901
902 static void
903 x_draw_row_bitmaps (w, row)
904 struct window *w;
905 struct glyph_row *row;
906 {
907 struct frame *f = XFRAME (w->frame);
908 enum bitmap_type bitmap;
909 struct face *face;
910 int header_line_height = -1;
911
912 xassert (interrupt_input_blocked);
913
914 /* If row is completely invisible, because of vscrolling, we
915 don't have to draw anything. */
916 if (row->visible_height <= 0)
917 return;
918
919 face = FACE_FROM_ID (f, BITMAP_AREA_FACE_ID);
920 PREPARE_FACE_FOR_DISPLAY (f, face);
921
922 /* Decide which bitmap to draw at the left side. */
923 if (row->overlay_arrow_p)
924 bitmap = OVERLAY_ARROW_BITMAP;
925 else if (row->truncated_on_left_p)
926 bitmap = LEFT_TRUNCATION_BITMAP;
927 else if (MATRIX_ROW_CONTINUATION_LINE_P (row))
928 bitmap = CONTINUATION_LINE_BITMAP;
929 else if (row->indicate_empty_line_p)
930 bitmap = ZV_LINE_BITMAP;
931 else
932 bitmap = NO_BITMAP;
933
934 /* Clear flags area if no bitmap to draw or if bitmap doesn't fill
935 the flags area. */
936 if (bitmap == NO_BITMAP
937 || FRAME_FLAGS_BITMAP_WIDTH (f) < FRAME_X_LEFT_FLAGS_AREA_WIDTH (f)
938 || row->height > FRAME_FLAGS_BITMAP_HEIGHT (f))
939 {
940 /* If W has a vertical border to its left, don't draw over it. */
941 int border = ((XFASTINT (w->left) > 0
942 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f))
943 ? 1 : 0);
944 int left = window_box_left (w, -1);
945
946 if (header_line_height < 0)
947 header_line_height = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
948
949 /* In case the same realized face is used for bitmap areas and
950 for something displayed in the text (e.g. face `region' on
951 mono-displays, the fill style may have been changed to
952 FillSolid in x_draw_glyph_string_background. */
953 if (face->stipple)
954 XSetFillStyle (FRAME_X_DISPLAY (f), face->gc, FillOpaqueStippled);
955 else
956 XSetForeground (FRAME_X_DISPLAY (f), face->gc, face->background);
957
958 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
959 face->gc,
960 (left
961 - FRAME_X_LEFT_FLAGS_AREA_WIDTH (f)
962 + border),
963 WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
964 row->y)),
965 FRAME_X_LEFT_FLAGS_AREA_WIDTH (f) - border,
966 row->visible_height);
967 if (!face->stipple)
968 XSetForeground (FRAME_X_DISPLAY (f), face->gc, face->foreground);
969 }
970
971 /* Draw the left bitmap. */
972 if (bitmap != NO_BITMAP)
973 x_draw_bitmap (w, row, bitmap);
974
975 /* Decide which bitmap to draw at the right side. */
976 if (row->truncated_on_right_p)
977 bitmap = RIGHT_TRUNCATION_BITMAP;
978 else if (row->continued_p)
979 bitmap = CONTINUED_LINE_BITMAP;
980 else
981 bitmap = NO_BITMAP;
982
983 /* Clear flags area if no bitmap to draw of if bitmap doesn't fill
984 the flags area. */
985 if (bitmap == NO_BITMAP
986 || FRAME_FLAGS_BITMAP_WIDTH (f) < FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f)
987 || row->height > FRAME_FLAGS_BITMAP_HEIGHT (f))
988 {
989 int right = window_box_right (w, -1);
990
991 if (header_line_height < 0)
992 header_line_height = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
993
994 /* In case the same realized face is used for bitmap areas and
995 for something displayed in the text (e.g. face `region' on
996 mono-displays, the fill style may have been changed to
997 FillSolid in x_draw_glyph_string_background. */
998 if (face->stipple)
999 XSetFillStyle (FRAME_X_DISPLAY (f), face->gc, FillOpaqueStippled);
1000 else
1001 XSetForeground (FRAME_X_DISPLAY (f), face->gc, face->background);
1002 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1003 face->gc,
1004 right,
1005 WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
1006 row->y)),
1007 FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f),
1008 row->visible_height);
1009 if (!face->stipple)
1010 XSetForeground (FRAME_X_DISPLAY (f), face->gc, face->foreground);
1011 }
1012
1013 /* Draw the right bitmap. */
1014 if (bitmap != NO_BITMAP)
1015 x_draw_bitmap (w, row, bitmap);
1016 }
1017
1018 \f
1019 /***********************************************************************
1020 Line Highlighting
1021 ***********************************************************************/
1022
1023 /* External interface to control of standout mode. Not used for X
1024 frames. Aborts when called. */
1025
1026 static void
1027 XTreassert_line_highlight (new, vpos)
1028 int new, vpos;
1029 {
1030 abort ();
1031 }
1032
1033
1034 /* Call this when about to modify line at position VPOS and change
1035 whether it is highlighted. Not used for X frames. Aborts when
1036 called. */
1037
1038 static void
1039 x_change_line_highlight (new_highlight, vpos, y, first_unused_hpos)
1040 int new_highlight, vpos, y, first_unused_hpos;
1041 {
1042 abort ();
1043 }
1044
1045
1046 /* This is called when starting Emacs and when restarting after
1047 suspend. When starting Emacs, no X window is mapped. And nothing
1048 must be done to Emacs's own window if it is suspended (though that
1049 rarely happens). */
1050
1051 static void
1052 XTset_terminal_modes ()
1053 {
1054 }
1055
1056 /* This is called when exiting or suspending Emacs. Exiting will make
1057 the X-windows go away, and suspending requires no action. */
1058
1059 static void
1060 XTreset_terminal_modes ()
1061 {
1062 }
1063
1064
1065 \f
1066 /***********************************************************************
1067 Output Cursor
1068 ***********************************************************************/
1069
1070 /* Set the global variable output_cursor to CURSOR. All cursor
1071 positions are relative to updated_window. */
1072
1073 static void
1074 set_output_cursor (cursor)
1075 struct cursor_pos *cursor;
1076 {
1077 output_cursor.hpos = cursor->hpos;
1078 output_cursor.vpos = cursor->vpos;
1079 output_cursor.x = cursor->x;
1080 output_cursor.y = cursor->y;
1081 }
1082
1083
1084 /* Set a nominal cursor position.
1085
1086 HPOS and VPOS are column/row positions in a window glyph matrix. X
1087 and Y are window text area relative pixel positions.
1088
1089 If this is done during an update, updated_window will contain the
1090 window that is being updated and the position is the future output
1091 cursor position for that window. If updated_window is null, use
1092 selected_window and display the cursor at the given position. */
1093
1094 static void
1095 XTcursor_to (vpos, hpos, y, x)
1096 int vpos, hpos, y, x;
1097 {
1098 struct window *w;
1099
1100 /* If updated_window is not set, work on selected_window. */
1101 if (updated_window)
1102 w = updated_window;
1103 else
1104 w = XWINDOW (selected_window);
1105
1106 /* Set the output cursor. */
1107 output_cursor.hpos = hpos;
1108 output_cursor.vpos = vpos;
1109 output_cursor.x = x;
1110 output_cursor.y = y;
1111
1112 /* If not called as part of an update, really display the cursor.
1113 This will also set the cursor position of W. */
1114 if (updated_window == NULL)
1115 {
1116 BLOCK_INPUT;
1117 x_display_cursor (w, 1, hpos, vpos, x, y);
1118 XFlush (FRAME_X_DISPLAY (SELECTED_FRAME ()));
1119 UNBLOCK_INPUT;
1120 }
1121 }
1122
1123
1124 \f
1125 /***********************************************************************
1126 Display Iterator
1127 ***********************************************************************/
1128
1129 /* Function prototypes of this page. */
1130
1131 static struct face *x_get_glyph_face_and_encoding P_ ((struct frame *,
1132 struct glyph *,
1133 XChar2b *,
1134 int *));
1135 static struct face *x_get_char_face_and_encoding P_ ((struct frame *, int,
1136 int, XChar2b *, int));
1137 static XCharStruct *x_per_char_metric P_ ((XFontStruct *, XChar2b *));
1138 static void x_encode_char P_ ((int, XChar2b *, struct font_info *));
1139 static void x_append_glyph P_ ((struct it *));
1140 static void x_append_composite_glyph P_ ((struct it *));
1141 static void x_append_stretch_glyph P_ ((struct it *it, Lisp_Object,
1142 int, int, double));
1143 static void x_produce_glyphs P_ ((struct it *));
1144 static void x_produce_image_glyph P_ ((struct it *it));
1145
1146
1147 /* Get metrics of character CHAR2B in FONT. Value is null if CHAR2B
1148 is not contained in the font. */
1149
1150 static INLINE XCharStruct *
1151 x_per_char_metric (font, char2b)
1152 XFontStruct *font;
1153 XChar2b *char2b;
1154 {
1155 /* The result metric information. */
1156 XCharStruct *pcm = NULL;
1157
1158 xassert (font && char2b);
1159
1160 if (font->per_char != NULL)
1161 {
1162 if (font->min_byte1 == 0 && font->max_byte1 == 0)
1163 {
1164 /* min_char_or_byte2 specifies the linear character index
1165 corresponding to the first element of the per_char array,
1166 max_char_or_byte2 is the index of the last character. A
1167 character with non-zero CHAR2B->byte1 is not in the font.
1168 A character with byte2 less than min_char_or_byte2 or
1169 greater max_char_or_byte2 is not in the font. */
1170 if (char2b->byte1 == 0
1171 && char2b->byte2 >= font->min_char_or_byte2
1172 && char2b->byte2 <= font->max_char_or_byte2)
1173 pcm = font->per_char + char2b->byte2 - font->min_char_or_byte2;
1174 }
1175 else
1176 {
1177 /* If either min_byte1 or max_byte1 are nonzero, both
1178 min_char_or_byte2 and max_char_or_byte2 are less than
1179 256, and the 2-byte character index values corresponding
1180 to the per_char array element N (counting from 0) are:
1181
1182 byte1 = N/D + min_byte1
1183 byte2 = N\D + min_char_or_byte2
1184
1185 where:
1186
1187 D = max_char_or_byte2 - min_char_or_byte2 + 1
1188 / = integer division
1189 \ = integer modulus */
1190 if (char2b->byte1 >= font->min_byte1
1191 && char2b->byte1 <= font->max_byte1
1192 && char2b->byte2 >= font->min_char_or_byte2
1193 && char2b->byte2 <= font->max_char_or_byte2)
1194 {
1195 pcm = (font->per_char
1196 + ((font->max_char_or_byte2 - font->min_char_or_byte2 + 1)
1197 * (char2b->byte1 - font->min_byte1))
1198 + (char2b->byte2 - font->min_char_or_byte2));
1199 }
1200 }
1201 }
1202 else
1203 {
1204 /* If the per_char pointer is null, all glyphs between the first
1205 and last character indexes inclusive have the same
1206 information, as given by both min_bounds and max_bounds. */
1207 if (char2b->byte2 >= font->min_char_or_byte2
1208 && char2b->byte2 <= font->max_char_or_byte2)
1209 pcm = &font->max_bounds;
1210 }
1211
1212 return ((pcm == NULL
1213 || (pcm->width == 0 && (pcm->rbearing - pcm->lbearing) == 0))
1214 ? NULL : pcm);
1215 }
1216
1217
1218 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
1219 the two-byte form of C. Encoding is returned in *CHAR2B. */
1220
1221 static INLINE void
1222 x_encode_char (c, char2b, font_info)
1223 int c;
1224 XChar2b *char2b;
1225 struct font_info *font_info;
1226 {
1227 int charset = CHAR_CHARSET (c);
1228 XFontStruct *font = font_info->font;
1229
1230 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
1231 This may be either a program in a special encoder language or a
1232 fixed encoding. */
1233 if (font_info->font_encoder)
1234 {
1235 /* It's a program. */
1236 struct ccl_program *ccl = font_info->font_encoder;
1237
1238 if (CHARSET_DIMENSION (charset) == 1)
1239 {
1240 ccl->reg[0] = charset;
1241 ccl->reg[1] = char2b->byte2;
1242 }
1243 else
1244 {
1245 ccl->reg[0] = charset;
1246 ccl->reg[1] = char2b->byte1;
1247 ccl->reg[2] = char2b->byte2;
1248 }
1249
1250 ccl_driver (ccl, NULL, NULL, 0, 0, NULL);
1251
1252 /* We assume that MSBs are appropriately set/reset by CCL
1253 program. */
1254 if (font->max_byte1 == 0) /* 1-byte font */
1255 char2b->byte1 = 0, char2b->byte2 = ccl->reg[1];
1256 else
1257 char2b->byte1 = ccl->reg[1], char2b->byte2 = ccl->reg[2];
1258 }
1259 else if (font_info->encoding[charset])
1260 {
1261 /* Fixed encoding scheme. See fontset.h for the meaning of the
1262 encoding numbers. */
1263 int enc = font_info->encoding[charset];
1264
1265 if ((enc == 1 || enc == 2)
1266 && CHARSET_DIMENSION (charset) == 2)
1267 char2b->byte1 |= 0x80;
1268
1269 if (enc == 1 || enc == 3)
1270 char2b->byte2 |= 0x80;
1271 }
1272 }
1273
1274
1275 /* Get face and two-byte form of character C in face FACE_ID on frame
1276 F. The encoding of C is returned in *CHAR2B. MULTIBYTE_P non-zero
1277 means we want to display multibyte text. Value is a pointer to a
1278 realized face that is ready for display. */
1279
1280 static INLINE struct face *
1281 x_get_char_face_and_encoding (f, c, face_id, char2b, multibyte_p)
1282 struct frame *f;
1283 int c, face_id;
1284 XChar2b *char2b;
1285 int multibyte_p;
1286 {
1287 struct face *face = FACE_FROM_ID (f, face_id);
1288
1289 if (!multibyte_p)
1290 {
1291 /* Unibyte case. We don't have to encode, but we have to make
1292 sure to use a face suitable for unibyte. */
1293 char2b->byte1 = 0;
1294 char2b->byte2 = c;
1295 face_id = FACE_FOR_CHAR (f, face, c);
1296 face = FACE_FROM_ID (f, face_id);
1297 }
1298 else if (c < 128 && face_id < BASIC_FACE_ID_SENTINEL)
1299 {
1300 /* Case of ASCII in a face known to fit ASCII. */
1301 char2b->byte1 = 0;
1302 char2b->byte2 = c;
1303 }
1304 else
1305 {
1306 int c1, c2, charset;
1307
1308 /* Split characters into bytes. If c2 is -1 afterwards, C is
1309 really a one-byte character so that byte1 is zero. */
1310 SPLIT_CHAR (c, charset, c1, c2);
1311 if (c2 > 0)
1312 char2b->byte1 = c1, char2b->byte2 = c2;
1313 else
1314 char2b->byte1 = 0, char2b->byte2 = c1;
1315
1316 /* Maybe encode the character in *CHAR2B. */
1317 if (face->font != NULL)
1318 {
1319 struct font_info *font_info
1320 = FONT_INFO_FROM_ID (f, face->font_info_id);
1321 if (font_info)
1322 x_encode_char (c, char2b, font_info);
1323 }
1324 }
1325
1326 /* Make sure X resources of the face are allocated. */
1327 xassert (face != NULL);
1328 PREPARE_FACE_FOR_DISPLAY (f, face);
1329
1330 return face;
1331 }
1332
1333
1334 /* Get face and two-byte form of character glyph GLYPH on frame F.
1335 The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
1336 a pointer to a realized face that is ready for display. */
1337
1338 static INLINE struct face *
1339 x_get_glyph_face_and_encoding (f, glyph, char2b, two_byte_p)
1340 struct frame *f;
1341 struct glyph *glyph;
1342 XChar2b *char2b;
1343 int *two_byte_p;
1344 {
1345 struct face *face;
1346
1347 xassert (glyph->type == CHAR_GLYPH);
1348 face = FACE_FROM_ID (f, glyph->face_id);
1349
1350 if (two_byte_p)
1351 *two_byte_p = 0;
1352
1353 if (!glyph->multibyte_p)
1354 {
1355 /* Unibyte case. We don't have to encode, but we have to make
1356 sure to use a face suitable for unibyte. */
1357 char2b->byte1 = 0;
1358 char2b->byte2 = glyph->u.ch;
1359 }
1360 else if (glyph->u.ch < 128
1361 && glyph->face_id < BASIC_FACE_ID_SENTINEL)
1362 {
1363 /* Case of ASCII in a face known to fit ASCII. */
1364 char2b->byte1 = 0;
1365 char2b->byte2 = glyph->u.ch;
1366 }
1367 else
1368 {
1369 int c1, c2, charset;
1370
1371 /* Split characters into bytes. If c2 is -1 afterwards, C is
1372 really a one-byte character so that byte1 is zero. */
1373 SPLIT_CHAR (glyph->u.ch, charset, c1, c2);
1374 if (c2 > 0)
1375 char2b->byte1 = c1, char2b->byte2 = c2;
1376 else
1377 char2b->byte1 = 0, char2b->byte2 = c1;
1378
1379 /* Maybe encode the character in *CHAR2B. */
1380 if (charset != CHARSET_ASCII)
1381 {
1382 struct font_info *font_info
1383 = FONT_INFO_FROM_ID (f, face->font_info_id);
1384 if (font_info)
1385 {
1386 x_encode_char (glyph->u.ch, char2b, font_info);
1387 if (two_byte_p)
1388 *two_byte_p
1389 = ((XFontStruct *) (font_info->font))->max_byte1 > 0;
1390 }
1391 }
1392 }
1393
1394 /* Make sure X resources of the face are allocated. */
1395 xassert (face != NULL);
1396 PREPARE_FACE_FOR_DISPLAY (f, face);
1397 return face;
1398 }
1399
1400
1401 /* Store one glyph for IT->char_to_display in IT->glyph_row.
1402 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1403
1404 static INLINE void
1405 x_append_glyph (it)
1406 struct it *it;
1407 {
1408 struct glyph *glyph;
1409 enum glyph_row_area area = it->area;
1410
1411 xassert (it->glyph_row);
1412 xassert (it->char_to_display != '\n' && it->char_to_display != '\t');
1413
1414 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
1415 if (glyph < it->glyph_row->glyphs[area + 1])
1416 {
1417 glyph->charpos = CHARPOS (it->position);
1418 glyph->object = it->object;
1419 glyph->pixel_width = it->pixel_width;
1420 glyph->voffset = it->voffset;
1421 glyph->type = CHAR_GLYPH;
1422 glyph->multibyte_p = it->multibyte_p;
1423 glyph->left_box_line_p = it->start_of_box_run_p;
1424 glyph->right_box_line_p = it->end_of_box_run_p;
1425 glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
1426 || it->phys_descent > it->descent);
1427 glyph->padding_p = 0;
1428 glyph->glyph_not_available_p = it->glyph_not_available_p;
1429 glyph->face_id = it->face_id;
1430 glyph->u.ch = it->char_to_display;
1431 ++it->glyph_row->used[area];
1432 }
1433 }
1434
1435 /* Store one glyph for the composition IT->cmp_id in IT->glyph_row.
1436 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1437
1438 static INLINE void
1439 x_append_composite_glyph (it)
1440 struct it *it;
1441 {
1442 struct glyph *glyph;
1443 enum glyph_row_area area = it->area;
1444
1445 xassert (it->glyph_row);
1446
1447 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
1448 if (glyph < it->glyph_row->glyphs[area + 1])
1449 {
1450 glyph->charpos = CHARPOS (it->position);
1451 glyph->object = it->object;
1452 glyph->pixel_width = it->pixel_width;
1453 glyph->voffset = it->voffset;
1454 glyph->type = COMPOSITE_GLYPH;
1455 glyph->multibyte_p = it->multibyte_p;
1456 glyph->left_box_line_p = it->start_of_box_run_p;
1457 glyph->right_box_line_p = it->end_of_box_run_p;
1458 glyph->overlaps_vertically_p = (it->phys_ascent > it->ascent
1459 || it->phys_descent > it->descent);
1460 glyph->padding_p = 0;
1461 glyph->glyph_not_available_p = 0;
1462 glyph->face_id = it->face_id;
1463 glyph->u.cmp_id = it->cmp_id;
1464 ++it->glyph_row->used[area];
1465 }
1466 }
1467
1468
1469 /* Change IT->ascent and IT->height according to the setting of
1470 IT->voffset. */
1471
1472 static INLINE void
1473 take_vertical_position_into_account (it)
1474 struct it *it;
1475 {
1476 if (it->voffset)
1477 {
1478 if (it->voffset < 0)
1479 /* Increase the ascent so that we can display the text higher
1480 in the line. */
1481 it->ascent += abs (it->voffset);
1482 else
1483 /* Increase the descent so that we can display the text lower
1484 in the line. */
1485 it->descent += it->voffset;
1486 }
1487 }
1488
1489
1490 /* Produce glyphs/get display metrics for the image IT is loaded with.
1491 See the description of struct display_iterator in dispextern.h for
1492 an overview of struct display_iterator. */
1493
1494 static void
1495 x_produce_image_glyph (it)
1496 struct it *it;
1497 {
1498 struct image *img;
1499 struct face *face;
1500
1501 xassert (it->what == IT_IMAGE);
1502
1503 face = FACE_FROM_ID (it->f, it->face_id);
1504 img = IMAGE_FROM_ID (it->f, it->image_id);
1505 xassert (img);
1506
1507 /* Make sure X resources of the face and image are loaded. */
1508 PREPARE_FACE_FOR_DISPLAY (it->f, face);
1509 prepare_image_for_display (it->f, img);
1510
1511 it->ascent = it->phys_ascent = image_ascent (img, face);
1512 it->descent = it->phys_descent = img->height + 2 * img->vmargin - it->ascent;
1513 it->pixel_width = img->width + 2 * img->hmargin;
1514
1515 it->nglyphs = 1;
1516
1517 if (face->box != FACE_NO_BOX)
1518 {
1519 if (face->box_line_width > 0)
1520 {
1521 it->ascent += face->box_line_width;
1522 it->descent += face->box_line_width;
1523 }
1524
1525 if (it->start_of_box_run_p)
1526 it->pixel_width += abs (face->box_line_width);
1527 if (it->end_of_box_run_p)
1528 it->pixel_width += abs (face->box_line_width);
1529 }
1530
1531 take_vertical_position_into_account (it);
1532
1533 if (it->glyph_row)
1534 {
1535 struct glyph *glyph;
1536 enum glyph_row_area area = it->area;
1537
1538 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
1539 if (glyph < it->glyph_row->glyphs[area + 1])
1540 {
1541 glyph->charpos = CHARPOS (it->position);
1542 glyph->object = it->object;
1543 glyph->pixel_width = it->pixel_width;
1544 glyph->voffset = it->voffset;
1545 glyph->type = IMAGE_GLYPH;
1546 glyph->multibyte_p = it->multibyte_p;
1547 glyph->left_box_line_p = it->start_of_box_run_p;
1548 glyph->right_box_line_p = it->end_of_box_run_p;
1549 glyph->overlaps_vertically_p = 0;
1550 glyph->padding_p = 0;
1551 glyph->glyph_not_available_p = 0;
1552 glyph->face_id = it->face_id;
1553 glyph->u.img_id = img->id;
1554 ++it->glyph_row->used[area];
1555 }
1556 }
1557 }
1558
1559
1560 /* Append a stretch glyph to IT->glyph_row. OBJECT is the source
1561 of the glyph, WIDTH and HEIGHT are the width and height of the
1562 stretch. ASCENT is the percentage/100 of HEIGHT to use for the
1563 ascent of the glyph (0 <= ASCENT <= 1). */
1564
1565 static void
1566 x_append_stretch_glyph (it, object, width, height, ascent)
1567 struct it *it;
1568 Lisp_Object object;
1569 int width, height;
1570 double ascent;
1571 {
1572 struct glyph *glyph;
1573 enum glyph_row_area area = it->area;
1574
1575 xassert (ascent >= 0 && ascent <= 1);
1576
1577 glyph = it->glyph_row->glyphs[area] + it->glyph_row->used[area];
1578 if (glyph < it->glyph_row->glyphs[area + 1])
1579 {
1580 glyph->charpos = CHARPOS (it->position);
1581 glyph->object = object;
1582 glyph->pixel_width = width;
1583 glyph->voffset = it->voffset;
1584 glyph->type = STRETCH_GLYPH;
1585 glyph->multibyte_p = it->multibyte_p;
1586 glyph->left_box_line_p = it->start_of_box_run_p;
1587 glyph->right_box_line_p = it->end_of_box_run_p;
1588 glyph->overlaps_vertically_p = 0;
1589 glyph->padding_p = 0;
1590 glyph->glyph_not_available_p = 0;
1591 glyph->face_id = it->face_id;
1592 glyph->u.stretch.ascent = height * ascent;
1593 glyph->u.stretch.height = height;
1594 ++it->glyph_row->used[area];
1595 }
1596 }
1597
1598
1599 /* Produce a stretch glyph for iterator IT. IT->object is the value
1600 of the glyph property displayed. The value must be a list
1601 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
1602 being recognized:
1603
1604 1. `:width WIDTH' specifies that the space should be WIDTH *
1605 canonical char width wide. WIDTH may be an integer or floating
1606 point number.
1607
1608 2. `:relative-width FACTOR' specifies that the width of the stretch
1609 should be computed from the width of the first character having the
1610 `glyph' property, and should be FACTOR times that width.
1611
1612 3. `:align-to HPOS' specifies that the space should be wide enough
1613 to reach HPOS, a value in canonical character units.
1614
1615 Exactly one of the above pairs must be present.
1616
1617 4. `:height HEIGHT' specifies that the height of the stretch produced
1618 should be HEIGHT, measured in canonical character units.
1619
1620 5. `:relative-height FACTOR' specifies that the height of the the
1621 stretch should be FACTOR times the height of the characters having
1622 the glyph property.
1623
1624 Either none or exactly one of 4 or 5 must be present.
1625
1626 6. `:ascent ASCENT' specifies that ASCENT percent of the height
1627 of the stretch should be used for the ascent of the stretch.
1628 ASCENT must be in the range 0 <= ASCENT <= 100. */
1629
1630 #define NUMVAL(X) \
1631 ((INTEGERP (X) || FLOATP (X)) \
1632 ? XFLOATINT (X) \
1633 : - 1)
1634
1635
1636 static void
1637 x_produce_stretch_glyph (it)
1638 struct it *it;
1639 {
1640 /* (space :width WIDTH :height HEIGHT. */
1641 #if GLYPH_DEBUG
1642 extern Lisp_Object Qspace;
1643 #endif
1644 extern Lisp_Object QCwidth, QCheight, QCascent;
1645 extern Lisp_Object QCrelative_width, QCrelative_height;
1646 extern Lisp_Object QCalign_to;
1647 Lisp_Object prop, plist;
1648 double width = 0, height = 0, ascent = 0;
1649 struct face *face = FACE_FROM_ID (it->f, it->face_id);
1650 XFontStruct *font = face->font ? face->font : FRAME_FONT (it->f);
1651
1652 PREPARE_FACE_FOR_DISPLAY (it->f, face);
1653
1654 /* List should start with `space'. */
1655 xassert (CONSP (it->object) && EQ (XCAR (it->object), Qspace));
1656 plist = XCDR (it->object);
1657
1658 /* Compute the width of the stretch. */
1659 if (prop = Fplist_get (plist, QCwidth),
1660 NUMVAL (prop) > 0)
1661 /* Absolute width `:width WIDTH' specified and valid. */
1662 width = NUMVAL (prop) * CANON_X_UNIT (it->f);
1663 else if (prop = Fplist_get (plist, QCrelative_width),
1664 NUMVAL (prop) > 0)
1665 {
1666 /* Relative width `:relative-width FACTOR' specified and valid.
1667 Compute the width of the characters having the `glyph'
1668 property. */
1669 struct it it2;
1670 unsigned char *p = BYTE_POS_ADDR (IT_BYTEPOS (*it));
1671
1672 it2 = *it;
1673 if (it->multibyte_p)
1674 {
1675 int maxlen = ((IT_BYTEPOS (*it) >= GPT ? ZV : GPT)
1676 - IT_BYTEPOS (*it));
1677 it2.c = STRING_CHAR_AND_LENGTH (p, maxlen, it2.len);
1678 }
1679 else
1680 it2.c = *p, it2.len = 1;
1681
1682 it2.glyph_row = NULL;
1683 it2.what = IT_CHARACTER;
1684 x_produce_glyphs (&it2);
1685 width = NUMVAL (prop) * it2.pixel_width;
1686 }
1687 else if (prop = Fplist_get (plist, QCalign_to),
1688 NUMVAL (prop) > 0)
1689 width = NUMVAL (prop) * CANON_X_UNIT (it->f) - it->current_x;
1690 else
1691 /* Nothing specified -> width defaults to canonical char width. */
1692 width = CANON_X_UNIT (it->f);
1693
1694 /* Compute height. */
1695 if (prop = Fplist_get (plist, QCheight),
1696 NUMVAL (prop) > 0)
1697 height = NUMVAL (prop) * CANON_Y_UNIT (it->f);
1698 else if (prop = Fplist_get (plist, QCrelative_height),
1699 NUMVAL (prop) > 0)
1700 height = FONT_HEIGHT (font) * NUMVAL (prop);
1701 else
1702 height = FONT_HEIGHT (font);
1703
1704 /* Compute percentage of height used for ascent. If
1705 `:ascent ASCENT' is present and valid, use that. Otherwise,
1706 derive the ascent from the font in use. */
1707 if (prop = Fplist_get (plist, QCascent),
1708 NUMVAL (prop) > 0 && NUMVAL (prop) <= 100)
1709 ascent = NUMVAL (prop) / 100.0;
1710 else
1711 ascent = (double) font->ascent / FONT_HEIGHT (font);
1712
1713 if (width <= 0)
1714 width = 1;
1715 if (height <= 0)
1716 height = 1;
1717
1718 if (it->glyph_row)
1719 {
1720 Lisp_Object object = it->stack[it->sp - 1].string;
1721 if (!STRINGP (object))
1722 object = it->w->buffer;
1723 x_append_stretch_glyph (it, object, width, height, ascent);
1724 }
1725
1726 it->pixel_width = width;
1727 it->ascent = it->phys_ascent = height * ascent;
1728 it->descent = it->phys_descent = height - it->ascent;
1729 it->nglyphs = 1;
1730
1731 if (face->box != FACE_NO_BOX)
1732 {
1733 if (face->box_line_width > 0)
1734 {
1735 it->ascent += face->box_line_width;
1736 it->descent += face->box_line_width;
1737 }
1738
1739 if (it->start_of_box_run_p)
1740 it->pixel_width += abs (face->box_line_width);
1741 if (it->end_of_box_run_p)
1742 it->pixel_width += abs (face->box_line_width);
1743 }
1744
1745 take_vertical_position_into_account (it);
1746 }
1747
1748 /* Return proper value to be used as baseline offset of font that has
1749 ASCENT and DESCENT to draw characters by the font at the vertical
1750 center of the line of frame F.
1751
1752 Here, out task is to find the value of BOFF in the following figure;
1753
1754 -------------------------+-----------+-
1755 -+-+---------+-+ | |
1756 | | | | | |
1757 | | | | F_ASCENT F_HEIGHT
1758 | | | ASCENT | |
1759 HEIGHT | | | | |
1760 | | |-|-+------+-----------|------- baseline
1761 | | | | BOFF | |
1762 | |---------|-+-+ | |
1763 | | | DESCENT | |
1764 -+-+---------+-+ F_DESCENT |
1765 -------------------------+-----------+-
1766
1767 -BOFF + DESCENT + (F_HEIGHT - HEIGHT) / 2 = F_DESCENT
1768 BOFF = DESCENT + (F_HEIGHT - HEIGHT) / 2 - F_DESCENT
1769 DESCENT = FONT->descent
1770 HEIGHT = FONT_HEIGHT (FONT)
1771 F_DESCENT = (F->output_data.x->font->descent
1772 - F->output_data.x->baseline_offset)
1773 F_HEIGHT = FRAME_LINE_HEIGHT (F)
1774 */
1775
1776 #define VCENTER_BASELINE_OFFSET(FONT, F) \
1777 ((FONT)->descent \
1778 + (FRAME_LINE_HEIGHT ((F)) - FONT_HEIGHT ((FONT)) \
1779 + (FRAME_LINE_HEIGHT ((F)) > FONT_HEIGHT ((FONT)))) / 2 \
1780 - ((F)->output_data.x->font->descent - (F)->output_data.x->baseline_offset))
1781
1782 /* Produce glyphs/get display metrics for the display element IT is
1783 loaded with. See the description of struct display_iterator in
1784 dispextern.h for an overview of struct display_iterator. */
1785
1786 static void
1787 x_produce_glyphs (it)
1788 struct it *it;
1789 {
1790 it->glyph_not_available_p = 0;
1791
1792 if (it->what == IT_CHARACTER)
1793 {
1794 XChar2b char2b;
1795 XFontStruct *font;
1796 struct face *face = FACE_FROM_ID (it->f, it->face_id);
1797 XCharStruct *pcm;
1798 int font_not_found_p;
1799 struct font_info *font_info;
1800 int boff; /* baseline offset */
1801 /* We may change it->multibyte_p upon unibyte<->multibyte
1802 conversion. So, save the current value now and restore it
1803 later.
1804
1805 Note: It seems that we don't have to record multibyte_p in
1806 struct glyph because the character code itself tells if or
1807 not the character is multibyte. Thus, in the future, we must
1808 consider eliminating the field `multibyte_p' in the struct
1809 glyph.
1810 */
1811 int saved_multibyte_p = it->multibyte_p;
1812
1813 /* Maybe translate single-byte characters to multibyte, or the
1814 other way. */
1815 it->char_to_display = it->c;
1816 if (!ASCII_BYTE_P (it->c))
1817 {
1818 if (unibyte_display_via_language_environment
1819 && SINGLE_BYTE_CHAR_P (it->c)
1820 && (it->c >= 0240
1821 || !NILP (Vnonascii_translation_table)))
1822 {
1823 it->char_to_display = unibyte_char_to_multibyte (it->c);
1824 it->multibyte_p = 1;
1825 it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display);
1826 face = FACE_FROM_ID (it->f, it->face_id);
1827 }
1828 else if (!SINGLE_BYTE_CHAR_P (it->c)
1829 && !it->multibyte_p)
1830 {
1831 it->char_to_display = multibyte_char_to_unibyte (it->c, Qnil);
1832 it->multibyte_p = 0;
1833 it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display);
1834 face = FACE_FROM_ID (it->f, it->face_id);
1835 }
1836 }
1837
1838 /* Get font to use. Encode IT->char_to_display. */
1839 x_get_char_face_and_encoding (it->f, it->char_to_display,
1840 it->face_id, &char2b,
1841 it->multibyte_p);
1842 font = face->font;
1843
1844 /* When no suitable font found, use the default font. */
1845 font_not_found_p = font == NULL;
1846 if (font_not_found_p)
1847 {
1848 font = FRAME_FONT (it->f);
1849 boff = it->f->output_data.x->baseline_offset;
1850 font_info = NULL;
1851 }
1852 else
1853 {
1854 font_info = FONT_INFO_FROM_ID (it->f, face->font_info_id);
1855 boff = font_info->baseline_offset;
1856 if (font_info->vertical_centering)
1857 boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
1858 }
1859
1860 if (it->char_to_display >= ' '
1861 && (!it->multibyte_p || it->char_to_display < 128))
1862 {
1863 /* Either unibyte or ASCII. */
1864 int stretched_p;
1865
1866 it->nglyphs = 1;
1867
1868 pcm = x_per_char_metric (font, &char2b);
1869 it->ascent = font->ascent + boff;
1870 it->descent = font->descent - boff;
1871
1872 if (pcm)
1873 {
1874 it->phys_ascent = pcm->ascent + boff;
1875 it->phys_descent = pcm->descent - boff;
1876 it->pixel_width = pcm->width;
1877 }
1878 else
1879 {
1880 it->glyph_not_available_p = 1;
1881 it->phys_ascent = font->ascent + boff;
1882 it->phys_descent = font->descent - boff;
1883 it->pixel_width = FONT_WIDTH (font);
1884 }
1885
1886 /* If this is a space inside a region of text with
1887 `space-width' property, change its width. */
1888 stretched_p = it->char_to_display == ' ' && !NILP (it->space_width);
1889 if (stretched_p)
1890 it->pixel_width *= XFLOATINT (it->space_width);
1891
1892 /* If face has a box, add the box thickness to the character
1893 height. If character has a box line to the left and/or
1894 right, add the box line width to the character's width. */
1895 if (face->box != FACE_NO_BOX)
1896 {
1897 int thick = face->box_line_width;
1898
1899 if (thick > 0)
1900 {
1901 it->ascent += thick;
1902 it->descent += thick;
1903 }
1904 else
1905 thick = -thick;
1906
1907 if (it->start_of_box_run_p)
1908 it->pixel_width += thick;
1909 if (it->end_of_box_run_p)
1910 it->pixel_width += thick;
1911 }
1912
1913 /* If face has an overline, add the height of the overline
1914 (1 pixel) and a 1 pixel margin to the character height. */
1915 if (face->overline_p)
1916 it->ascent += 2;
1917
1918 take_vertical_position_into_account (it);
1919
1920 /* If we have to actually produce glyphs, do it. */
1921 if (it->glyph_row)
1922 {
1923 if (stretched_p)
1924 {
1925 /* Translate a space with a `space-width' property
1926 into a stretch glyph. */
1927 double ascent = (double) font->ascent / FONT_HEIGHT (font);
1928 x_append_stretch_glyph (it, it->object, it->pixel_width,
1929 it->ascent + it->descent, ascent);
1930 }
1931 else
1932 x_append_glyph (it);
1933
1934 /* If characters with lbearing or rbearing are displayed
1935 in this line, record that fact in a flag of the
1936 glyph row. This is used to optimize X output code. */
1937 if (pcm && (pcm->lbearing < 0 || pcm->rbearing > pcm->width))
1938 it->glyph_row->contains_overlapping_glyphs_p = 1;
1939 }
1940 }
1941 else if (it->char_to_display == '\n')
1942 {
1943 /* A newline has no width but we need the height of the line. */
1944 it->pixel_width = 0;
1945 it->nglyphs = 0;
1946 it->ascent = it->phys_ascent = font->ascent + boff;
1947 it->descent = it->phys_descent = font->descent - boff;
1948
1949 if (face->box != FACE_NO_BOX
1950 && face->box_line_width > 0)
1951 {
1952 it->ascent += face->box_line_width;
1953 it->descent += face->box_line_width;
1954 }
1955 }
1956 else if (it->char_to_display == '\t')
1957 {
1958 int tab_width = it->tab_width * CANON_X_UNIT (it->f);
1959 int x = it->current_x + it->continuation_lines_width;
1960 int next_tab_x = ((1 + x + tab_width - 1) / tab_width) * tab_width;
1961
1962 /* If the distance from the current position to the next tab
1963 stop is less than a canonical character width, use the
1964 tab stop after that. */
1965 if (next_tab_x - x < CANON_X_UNIT (it->f))
1966 next_tab_x += tab_width;
1967
1968 it->pixel_width = next_tab_x - x;
1969 it->nglyphs = 1;
1970 it->ascent = it->phys_ascent = font->ascent + boff;
1971 it->descent = it->phys_descent = font->descent - boff;
1972
1973 if (it->glyph_row)
1974 {
1975 double ascent = (double) it->ascent / (it->ascent + it->descent);
1976 x_append_stretch_glyph (it, it->object, it->pixel_width,
1977 it->ascent + it->descent, ascent);
1978 }
1979 }
1980 else
1981 {
1982 /* A multi-byte character. Assume that the display width of the
1983 character is the width of the character multiplied by the
1984 width of the font. */
1985
1986 /* If we found a font, this font should give us the right
1987 metrics. If we didn't find a font, use the frame's
1988 default font and calculate the width of the character
1989 from the charset width; this is what old redisplay code
1990 did. */
1991 pcm = x_per_char_metric (font, &char2b);
1992 if (font_not_found_p || !pcm)
1993 {
1994 int charset = CHAR_CHARSET (it->char_to_display);
1995
1996 it->glyph_not_available_p = 1;
1997 it->pixel_width = (FONT_WIDTH (FRAME_FONT (it->f))
1998 * CHARSET_WIDTH (charset));
1999 it->phys_ascent = font->ascent + boff;
2000 it->phys_descent = font->descent - boff;
2001 }
2002 else
2003 {
2004 it->pixel_width = pcm->width;
2005 it->phys_ascent = pcm->ascent + boff;
2006 it->phys_descent = pcm->descent - boff;
2007 if (it->glyph_row
2008 && (pcm->lbearing < 0
2009 || pcm->rbearing > pcm->width))
2010 it->glyph_row->contains_overlapping_glyphs_p = 1;
2011 }
2012 it->nglyphs = 1;
2013 it->ascent = font->ascent + boff;
2014 it->descent = font->descent - boff;
2015 if (face->box != FACE_NO_BOX)
2016 {
2017 int thick = face->box_line_width;
2018
2019 if (thick > 0)
2020 {
2021 it->ascent += thick;
2022 it->descent += thick;
2023 }
2024 else
2025 thick = - thick;
2026
2027 if (it->start_of_box_run_p)
2028 it->pixel_width += thick;
2029 if (it->end_of_box_run_p)
2030 it->pixel_width += thick;
2031 }
2032
2033 /* If face has an overline, add the height of the overline
2034 (1 pixel) and a 1 pixel margin to the character height. */
2035 if (face->overline_p)
2036 it->ascent += 2;
2037
2038 take_vertical_position_into_account (it);
2039
2040 if (it->glyph_row)
2041 x_append_glyph (it);
2042 }
2043 it->multibyte_p = saved_multibyte_p;
2044 }
2045 else if (it->what == IT_COMPOSITION)
2046 {
2047 /* Note: A composition is represented as one glyph in the
2048 glyph matrix. There are no padding glyphs. */
2049 XChar2b char2b;
2050 XFontStruct *font;
2051 struct face *face = FACE_FROM_ID (it->f, it->face_id);
2052 XCharStruct *pcm;
2053 int font_not_found_p;
2054 struct font_info *font_info;
2055 int boff; /* baseline offset */
2056 struct composition *cmp = composition_table[it->cmp_id];
2057
2058 /* Maybe translate single-byte characters to multibyte. */
2059 it->char_to_display = it->c;
2060 if (unibyte_display_via_language_environment
2061 && SINGLE_BYTE_CHAR_P (it->c)
2062 && (it->c >= 0240
2063 || (it->c >= 0200
2064 && !NILP (Vnonascii_translation_table))))
2065 {
2066 it->char_to_display = unibyte_char_to_multibyte (it->c);
2067 }
2068
2069 /* Get face and font to use. Encode IT->char_to_display. */
2070 it->face_id = FACE_FOR_CHAR (it->f, face, it->char_to_display);
2071 face = FACE_FROM_ID (it->f, it->face_id);
2072 x_get_char_face_and_encoding (it->f, it->char_to_display,
2073 it->face_id, &char2b, it->multibyte_p);
2074 font = face->font;
2075
2076 /* When no suitable font found, use the default font. */
2077 font_not_found_p = font == NULL;
2078 if (font_not_found_p)
2079 {
2080 font = FRAME_FONT (it->f);
2081 boff = it->f->output_data.x->baseline_offset;
2082 font_info = NULL;
2083 }
2084 else
2085 {
2086 font_info = FONT_INFO_FROM_ID (it->f, face->font_info_id);
2087 boff = font_info->baseline_offset;
2088 if (font_info->vertical_centering)
2089 boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
2090 }
2091
2092 /* There are no padding glyphs, so there is only one glyph to
2093 produce for the composition. Important is that pixel_width,
2094 ascent and descent are the values of what is drawn by
2095 draw_glyphs (i.e. the values of the overall glyphs composed). */
2096 it->nglyphs = 1;
2097
2098 /* If we have not yet calculated pixel size data of glyphs of
2099 the composition for the current face font, calculate them
2100 now. Theoretically, we have to check all fonts for the
2101 glyphs, but that requires much time and memory space. So,
2102 here we check only the font of the first glyph. This leads
2103 to incorrect display very rarely, and C-l (recenter) can
2104 correct the display anyway. */
2105 if (cmp->font != (void *) font)
2106 {
2107 /* Ascent and descent of the font of the first character of
2108 this composition (adjusted by baseline offset). Ascent
2109 and descent of overall glyphs should not be less than
2110 them respectively. */
2111 int font_ascent = font->ascent + boff;
2112 int font_descent = font->descent - boff;
2113 /* Bounding box of the overall glyphs. */
2114 int leftmost, rightmost, lowest, highest;
2115 int i, width, ascent, descent;
2116
2117 cmp->font = (void *) font;
2118
2119 /* Initialize the bounding box. */
2120 if (font_info
2121 && (pcm = x_per_char_metric (font, &char2b)))
2122 {
2123 width = pcm->width;
2124 ascent = pcm->ascent;
2125 descent = pcm->descent;
2126 }
2127 else
2128 {
2129 width = FONT_WIDTH (font);
2130 ascent = font->ascent;
2131 descent = font->descent;
2132 }
2133
2134 rightmost = width;
2135 lowest = - descent + boff;
2136 highest = ascent + boff;
2137 leftmost = 0;
2138
2139 if (font_info
2140 && font_info->default_ascent
2141 && CHAR_TABLE_P (Vuse_default_ascent)
2142 && !NILP (Faref (Vuse_default_ascent,
2143 make_number (it->char_to_display))))
2144 highest = font_info->default_ascent + boff;
2145
2146 /* Draw the first glyph at the normal position. It may be
2147 shifted to right later if some other glyphs are drawn at
2148 the left. */
2149 cmp->offsets[0] = 0;
2150 cmp->offsets[1] = boff;
2151
2152 /* Set cmp->offsets for the remaining glyphs. */
2153 for (i = 1; i < cmp->glyph_len; i++)
2154 {
2155 int left, right, btm, top;
2156 int ch = COMPOSITION_GLYPH (cmp, i);
2157 int face_id = FACE_FOR_CHAR (it->f, face, ch);
2158
2159 face = FACE_FROM_ID (it->f, face_id);
2160 x_get_char_face_and_encoding (it->f, ch, face->id, &char2b,
2161 it->multibyte_p);
2162 font = face->font;
2163 if (font == NULL)
2164 {
2165 font = FRAME_FONT (it->f);
2166 boff = it->f->output_data.x->baseline_offset;
2167 font_info = NULL;
2168 }
2169 else
2170 {
2171 font_info
2172 = FONT_INFO_FROM_ID (it->f, face->font_info_id);
2173 boff = font_info->baseline_offset;
2174 if (font_info->vertical_centering)
2175 boff = VCENTER_BASELINE_OFFSET (font, it->f) - boff;
2176 }
2177
2178 if (font_info
2179 && (pcm = x_per_char_metric (font, &char2b)))
2180 {
2181 width = pcm->width;
2182 ascent = pcm->ascent;
2183 descent = pcm->descent;
2184 }
2185 else
2186 {
2187 width = FONT_WIDTH (font);
2188 ascent = 1;
2189 descent = 0;
2190 }
2191
2192 if (cmp->method != COMPOSITION_WITH_RULE_ALTCHARS)
2193 {
2194 /* Relative composition with or without
2195 alternate chars. */
2196 left = (leftmost + rightmost - width) / 2;
2197 btm = - descent + boff;
2198 if (font_info && font_info->relative_compose
2199 && (! CHAR_TABLE_P (Vignore_relative_composition)
2200 || NILP (Faref (Vignore_relative_composition,
2201 make_number (ch)))))
2202 {
2203
2204 if (- descent >= font_info->relative_compose)
2205 /* One extra pixel between two glyphs. */
2206 btm = highest + 1;
2207 else if (ascent <= 0)
2208 /* One extra pixel between two glyphs. */
2209 btm = lowest - 1 - ascent - descent;
2210 }
2211 }
2212 else
2213 {
2214 /* A composition rule is specified by an integer
2215 value that encodes global and new reference
2216 points (GREF and NREF). GREF and NREF are
2217 specified by numbers as below:
2218
2219 0---1---2 -- ascent
2220 | |
2221 | |
2222 | |
2223 9--10--11 -- center
2224 | |
2225 ---3---4---5--- baseline
2226 | |
2227 6---7---8 -- descent
2228 */
2229 int rule = COMPOSITION_RULE (cmp, i);
2230 int gref, nref, grefx, grefy, nrefx, nrefy;
2231
2232 COMPOSITION_DECODE_RULE (rule, gref, nref);
2233 grefx = gref % 3, nrefx = nref % 3;
2234 grefy = gref / 3, nrefy = nref / 3;
2235
2236 left = (leftmost
2237 + grefx * (rightmost - leftmost) / 2
2238 - nrefx * width / 2);
2239 btm = ((grefy == 0 ? highest
2240 : grefy == 1 ? 0
2241 : grefy == 2 ? lowest
2242 : (highest + lowest) / 2)
2243 - (nrefy == 0 ? ascent + descent
2244 : nrefy == 1 ? descent - boff
2245 : nrefy == 2 ? 0
2246 : (ascent + descent) / 2));
2247 }
2248
2249 cmp->offsets[i * 2] = left;
2250 cmp->offsets[i * 2 + 1] = btm + descent;
2251
2252 /* Update the bounding box of the overall glyphs. */
2253 right = left + width;
2254 top = btm + descent + ascent;
2255 if (left < leftmost)
2256 leftmost = left;
2257 if (right > rightmost)
2258 rightmost = right;
2259 if (top > highest)
2260 highest = top;
2261 if (btm < lowest)
2262 lowest = btm;
2263 }
2264
2265 /* If there are glyphs whose x-offsets are negative,
2266 shift all glyphs to the right and make all x-offsets
2267 non-negative. */
2268 if (leftmost < 0)
2269 {
2270 for (i = 0; i < cmp->glyph_len; i++)
2271 cmp->offsets[i * 2] -= leftmost;
2272 rightmost -= leftmost;
2273 }
2274
2275 cmp->pixel_width = rightmost;
2276 cmp->ascent = highest;
2277 cmp->descent = - lowest;
2278 if (cmp->ascent < font_ascent)
2279 cmp->ascent = font_ascent;
2280 if (cmp->descent < font_descent)
2281 cmp->descent = font_descent;
2282 }
2283
2284 it->pixel_width = cmp->pixel_width;
2285 it->ascent = it->phys_ascent = cmp->ascent;
2286 it->descent = it->phys_descent = cmp->descent;
2287
2288 if (face->box != FACE_NO_BOX)
2289 {
2290 int thick = face->box_line_width;
2291
2292 if (thick > 0)
2293 {
2294 it->ascent += thick;
2295 it->descent += thick;
2296 }
2297 else
2298 thick = - thick;
2299
2300 if (it->start_of_box_run_p)
2301 it->pixel_width += thick;
2302 if (it->end_of_box_run_p)
2303 it->pixel_width += thick;
2304 }
2305
2306 /* If face has an overline, add the height of the overline
2307 (1 pixel) and a 1 pixel margin to the character height. */
2308 if (face->overline_p)
2309 it->ascent += 2;
2310
2311 take_vertical_position_into_account (it);
2312
2313 if (it->glyph_row)
2314 x_append_composite_glyph (it);
2315 }
2316 else if (it->what == IT_IMAGE)
2317 x_produce_image_glyph (it);
2318 else if (it->what == IT_STRETCH)
2319 x_produce_stretch_glyph (it);
2320
2321 /* Accumulate dimensions. Note: can't assume that it->descent > 0
2322 because this isn't true for images with `:ascent 100'. */
2323 xassert (it->ascent >= 0 && it->descent >= 0);
2324 if (it->area == TEXT_AREA)
2325 it->current_x += it->pixel_width;
2326
2327 it->descent += it->extra_line_spacing;
2328
2329 it->max_ascent = max (it->max_ascent, it->ascent);
2330 it->max_descent = max (it->max_descent, it->descent);
2331 it->max_phys_ascent = max (it->max_phys_ascent, it->phys_ascent);
2332 it->max_phys_descent = max (it->max_phys_descent, it->phys_descent);
2333 }
2334
2335
2336 /* Estimate the pixel height of the mode or top line on frame F.
2337 FACE_ID specifies what line's height to estimate. */
2338
2339 int
2340 x_estimate_mode_line_height (f, face_id)
2341 struct frame *f;
2342 enum face_id face_id;
2343 {
2344 int height = FONT_HEIGHT (FRAME_FONT (f));
2345
2346 /* This function is called so early when Emacs starts that the face
2347 cache and mode line face are not yet initialized. */
2348 if (FRAME_FACE_CACHE (f))
2349 {
2350 struct face *face = FACE_FROM_ID (f, face_id);
2351 if (face)
2352 {
2353 if (face->font)
2354 height = FONT_HEIGHT (face->font);
2355 if (face->box_line_width > 0)
2356 height += 2 * face->box_line_width;
2357 }
2358 }
2359
2360 return height;
2361 }
2362
2363 \f
2364 /***********************************************************************
2365 Glyph display
2366 ***********************************************************************/
2367
2368 /* A sequence of glyphs to be drawn in the same face.
2369
2370 This data structure is not really completely X specific, so it
2371 could possibly, at least partially, be useful for other systems. It
2372 is currently not part of the external redisplay interface because
2373 it's not clear what other systems will need. */
2374
2375 struct glyph_string
2376 {
2377 /* X-origin of the string. */
2378 int x;
2379
2380 /* Y-origin and y-position of the base line of this string. */
2381 int y, ybase;
2382
2383 /* The width of the string, not including a face extension. */
2384 int width;
2385
2386 /* The width of the string, including a face extension. */
2387 int background_width;
2388
2389 /* The height of this string. This is the height of the line this
2390 string is drawn in, and can be different from the height of the
2391 font the string is drawn in. */
2392 int height;
2393
2394 /* Number of pixels this string overwrites in front of its x-origin.
2395 This number is zero if the string has an lbearing >= 0; it is
2396 -lbearing, if the string has an lbearing < 0. */
2397 int left_overhang;
2398
2399 /* Number of pixels this string overwrites past its right-most
2400 nominal x-position, i.e. x + width. Zero if the string's
2401 rbearing is <= its nominal width, rbearing - width otherwise. */
2402 int right_overhang;
2403
2404 /* The frame on which the glyph string is drawn. */
2405 struct frame *f;
2406
2407 /* The window on which the glyph string is drawn. */
2408 struct window *w;
2409
2410 /* X display and window for convenience. */
2411 Display *display;
2412 Window window;
2413
2414 /* The glyph row for which this string was built. It determines the
2415 y-origin and height of the string. */
2416 struct glyph_row *row;
2417
2418 /* The area within row. */
2419 enum glyph_row_area area;
2420
2421 /* Characters to be drawn, and number of characters. */
2422 XChar2b *char2b;
2423 int nchars;
2424
2425 /* A face-override for drawing cursors, mouse face and similar. */
2426 enum draw_glyphs_face hl;
2427
2428 /* Face in which this string is to be drawn. */
2429 struct face *face;
2430
2431 /* Font in which this string is to be drawn. */
2432 XFontStruct *font;
2433
2434 /* Font info for this string. */
2435 struct font_info *font_info;
2436
2437 /* Non-null means this string describes (part of) a composition.
2438 All characters from char2b are drawn composed. */
2439 struct composition *cmp;
2440
2441 /* Index of this glyph string's first character in the glyph
2442 definition of CMP. If this is zero, this glyph string describes
2443 the first character of a composition. */
2444 int gidx;
2445
2446 /* 1 means this glyph strings face has to be drawn to the right end
2447 of the window's drawing area. */
2448 unsigned extends_to_end_of_line_p : 1;
2449
2450 /* 1 means the background of this string has been drawn. */
2451 unsigned background_filled_p : 1;
2452
2453 /* 1 means glyph string must be drawn with 16-bit functions. */
2454 unsigned two_byte_p : 1;
2455
2456 /* 1 means that the original font determined for drawing this glyph
2457 string could not be loaded. The member `font' has been set to
2458 the frame's default font in this case. */
2459 unsigned font_not_found_p : 1;
2460
2461 /* 1 means that the face in which this glyph string is drawn has a
2462 stipple pattern. */
2463 unsigned stippled_p : 1;
2464
2465 /* 1 means only the foreground of this glyph string must be drawn,
2466 and we should use the physical height of the line this glyph
2467 string appears in as clip rect. */
2468 unsigned for_overlaps_p : 1;
2469
2470 /* The GC to use for drawing this glyph string. */
2471 GC gc;
2472
2473 /* A pointer to the first glyph in the string. This glyph
2474 corresponds to char2b[0]. Needed to draw rectangles if
2475 font_not_found_p is 1. */
2476 struct glyph *first_glyph;
2477
2478 /* Image, if any. */
2479 struct image *img;
2480
2481 struct glyph_string *next, *prev;
2482 };
2483
2484
2485 #if 0
2486
2487 static void
2488 x_dump_glyph_string (s)
2489 struct glyph_string *s;
2490 {
2491 fprintf (stderr, "glyph string\n");
2492 fprintf (stderr, " x, y, w, h = %d, %d, %d, %d\n",
2493 s->x, s->y, s->width, s->height);
2494 fprintf (stderr, " ybase = %d\n", s->ybase);
2495 fprintf (stderr, " hl = %d\n", s->hl);
2496 fprintf (stderr, " left overhang = %d, right = %d\n",
2497 s->left_overhang, s->right_overhang);
2498 fprintf (stderr, " nchars = %d\n", s->nchars);
2499 fprintf (stderr, " extends to end of line = %d\n",
2500 s->extends_to_end_of_line_p);
2501 fprintf (stderr, " font height = %d\n", FONT_HEIGHT (s->font));
2502 fprintf (stderr, " bg width = %d\n", s->background_width);
2503 }
2504
2505 #endif /* GLYPH_DEBUG */
2506
2507
2508
2509 static void x_append_glyph_string_lists P_ ((struct glyph_string **,
2510 struct glyph_string **,
2511 struct glyph_string *,
2512 struct glyph_string *));
2513 static void x_prepend_glyph_string_lists P_ ((struct glyph_string **,
2514 struct glyph_string **,
2515 struct glyph_string *,
2516 struct glyph_string *));
2517 static void x_append_glyph_string P_ ((struct glyph_string **,
2518 struct glyph_string **,
2519 struct glyph_string *));
2520 static int x_left_overwritten P_ ((struct glyph_string *));
2521 static int x_left_overwriting P_ ((struct glyph_string *));
2522 static int x_right_overwritten P_ ((struct glyph_string *));
2523 static int x_right_overwriting P_ ((struct glyph_string *));
2524 static int x_fill_glyph_string P_ ((struct glyph_string *, int, int, int,
2525 int));
2526 static void x_init_glyph_string P_ ((struct glyph_string *,
2527 XChar2b *, struct window *,
2528 struct glyph_row *,
2529 enum glyph_row_area, int,
2530 enum draw_glyphs_face));
2531 static int x_draw_glyphs P_ ((struct window *, int , struct glyph_row *,
2532 enum glyph_row_area, int, int,
2533 enum draw_glyphs_face, int *, int *, int));
2534 static void x_set_glyph_string_clipping P_ ((struct glyph_string *));
2535 static void x_set_glyph_string_gc P_ ((struct glyph_string *));
2536 static void x_draw_glyph_string_background P_ ((struct glyph_string *,
2537 int));
2538 static void x_draw_glyph_string_foreground P_ ((struct glyph_string *));
2539 static void x_draw_composite_glyph_string_foreground P_ ((struct glyph_string *));
2540 static void x_draw_glyph_string_box P_ ((struct glyph_string *));
2541 static void x_draw_glyph_string P_ ((struct glyph_string *));
2542 static void x_compute_glyph_string_overhangs P_ ((struct glyph_string *));
2543 static void x_set_cursor_gc P_ ((struct glyph_string *));
2544 static void x_set_mode_line_face_gc P_ ((struct glyph_string *));
2545 static void x_set_mouse_face_gc P_ ((struct glyph_string *));
2546 static void x_get_glyph_overhangs P_ ((struct glyph *, struct frame *,
2547 int *, int *));
2548 static void x_compute_overhangs_and_x P_ ((struct glyph_string *, int, int));
2549 static int x_alloc_lighter_color P_ ((struct frame *, Display *, Colormap,
2550 unsigned long *, double, int));
2551 static void x_setup_relief_color P_ ((struct frame *, struct relief *,
2552 double, int, unsigned long));
2553 static void x_setup_relief_colors P_ ((struct glyph_string *));
2554 static void x_draw_image_glyph_string P_ ((struct glyph_string *));
2555 static void x_draw_image_relief P_ ((struct glyph_string *));
2556 static void x_draw_image_foreground P_ ((struct glyph_string *));
2557 static void x_draw_image_foreground_1 P_ ((struct glyph_string *, Pixmap));
2558 static void x_fill_image_glyph_string P_ ((struct glyph_string *));
2559 static void x_clear_glyph_string_rect P_ ((struct glyph_string *, int,
2560 int, int, int));
2561 static void x_draw_relief_rect P_ ((struct frame *, int, int, int, int,
2562 int, int, int, int, XRectangle *));
2563 static void x_draw_box_rect P_ ((struct glyph_string *, int, int, int, int,
2564 int, int, int, XRectangle *));
2565 static void x_fix_overlapping_area P_ ((struct window *, struct glyph_row *,
2566 enum glyph_row_area));
2567 static int x_fill_stretch_glyph_string P_ ((struct glyph_string *,
2568 struct glyph_row *,
2569 enum glyph_row_area, int, int));
2570
2571 #if GLYPH_DEBUG
2572 static void x_check_font P_ ((struct frame *, XFontStruct *));
2573 #endif
2574
2575
2576 /* Append the list of glyph strings with head H and tail T to the list
2577 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
2578
2579 static INLINE void
2580 x_append_glyph_string_lists (head, tail, h, t)
2581 struct glyph_string **head, **tail;
2582 struct glyph_string *h, *t;
2583 {
2584 if (h)
2585 {
2586 if (*head)
2587 (*tail)->next = h;
2588 else
2589 *head = h;
2590 h->prev = *tail;
2591 *tail = t;
2592 }
2593 }
2594
2595
2596 /* Prepend the list of glyph strings with head H and tail T to the
2597 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
2598 result. */
2599
2600 static INLINE void
2601 x_prepend_glyph_string_lists (head, tail, h, t)
2602 struct glyph_string **head, **tail;
2603 struct glyph_string *h, *t;
2604 {
2605 if (h)
2606 {
2607 if (*head)
2608 (*head)->prev = t;
2609 else
2610 *tail = t;
2611 t->next = *head;
2612 *head = h;
2613 }
2614 }
2615
2616
2617 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
2618 Set *HEAD and *TAIL to the resulting list. */
2619
2620 static INLINE void
2621 x_append_glyph_string (head, tail, s)
2622 struct glyph_string **head, **tail;
2623 struct glyph_string *s;
2624 {
2625 s->next = s->prev = NULL;
2626 x_append_glyph_string_lists (head, tail, s, s);
2627 }
2628
2629
2630 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
2631 face. */
2632
2633 static void
2634 x_set_cursor_gc (s)
2635 struct glyph_string *s;
2636 {
2637 if (s->font == FRAME_FONT (s->f)
2638 && s->face->background == FRAME_BACKGROUND_PIXEL (s->f)
2639 && s->face->foreground == FRAME_FOREGROUND_PIXEL (s->f)
2640 && !s->cmp)
2641 s->gc = s->f->output_data.x->cursor_gc;
2642 else
2643 {
2644 /* Cursor on non-default face: must merge. */
2645 XGCValues xgcv;
2646 unsigned long mask;
2647
2648 xgcv.background = s->f->output_data.x->cursor_pixel;
2649 xgcv.foreground = s->face->background;
2650
2651 /* If the glyph would be invisible, try a different foreground. */
2652 if (xgcv.foreground == xgcv.background)
2653 xgcv.foreground = s->face->foreground;
2654 if (xgcv.foreground == xgcv.background)
2655 xgcv.foreground = s->f->output_data.x->cursor_foreground_pixel;
2656 if (xgcv.foreground == xgcv.background)
2657 xgcv.foreground = s->face->foreground;
2658
2659 /* Make sure the cursor is distinct from text in this face. */
2660 if (xgcv.background == s->face->background
2661 && xgcv.foreground == s->face->foreground)
2662 {
2663 xgcv.background = s->face->foreground;
2664 xgcv.foreground = s->face->background;
2665 }
2666
2667 IF_DEBUG (x_check_font (s->f, s->font));
2668 xgcv.font = s->font->fid;
2669 xgcv.graphics_exposures = False;
2670 mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
2671
2672 if (FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc)
2673 XChangeGC (s->display, FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc,
2674 mask, &xgcv);
2675 else
2676 FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc
2677 = XCreateGC (s->display, s->window, mask, &xgcv);
2678
2679 s->gc = FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc;
2680 }
2681 }
2682
2683
2684 /* Set up S->gc of glyph string S for drawing text in mouse face. */
2685
2686 static void
2687 x_set_mouse_face_gc (s)
2688 struct glyph_string *s;
2689 {
2690 int face_id;
2691 struct face *face;
2692
2693 /* What face has to be used last for the mouse face? */
2694 face_id = FRAME_X_DISPLAY_INFO (s->f)->mouse_face_face_id;
2695 face = FACE_FROM_ID (s->f, face_id);
2696 if (face == NULL)
2697 face = FACE_FROM_ID (s->f, MOUSE_FACE_ID);
2698
2699 if (s->first_glyph->type == CHAR_GLYPH)
2700 face_id = FACE_FOR_CHAR (s->f, face, s->first_glyph->u.ch);
2701 else
2702 face_id = FACE_FOR_CHAR (s->f, face, 0);
2703 s->face = FACE_FROM_ID (s->f, face_id);
2704 PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
2705
2706 /* If font in this face is same as S->font, use it. */
2707 if (s->font == s->face->font)
2708 s->gc = s->face->gc;
2709 else
2710 {
2711 /* Otherwise construct scratch_cursor_gc with values from FACE
2712 but font FONT. */
2713 XGCValues xgcv;
2714 unsigned long mask;
2715
2716 xgcv.background = s->face->background;
2717 xgcv.foreground = s->face->foreground;
2718 IF_DEBUG (x_check_font (s->f, s->font));
2719 xgcv.font = s->font->fid;
2720 xgcv.graphics_exposures = False;
2721 mask = GCForeground | GCBackground | GCFont | GCGraphicsExposures;
2722
2723 if (FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc)
2724 XChangeGC (s->display, FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc,
2725 mask, &xgcv);
2726 else
2727 FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc
2728 = XCreateGC (s->display, s->window, mask, &xgcv);
2729
2730 s->gc = FRAME_X_DISPLAY_INFO (s->f)->scratch_cursor_gc;
2731 }
2732
2733 xassert (s->gc != 0);
2734 }
2735
2736
2737 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
2738 Faces to use in the mode line have already been computed when the
2739 matrix was built, so there isn't much to do, here. */
2740
2741 static INLINE void
2742 x_set_mode_line_face_gc (s)
2743 struct glyph_string *s;
2744 {
2745 s->gc = s->face->gc;
2746 }
2747
2748
2749 /* Set S->gc of glyph string S for drawing that glyph string. Set
2750 S->stippled_p to a non-zero value if the face of S has a stipple
2751 pattern. */
2752
2753 static INLINE void
2754 x_set_glyph_string_gc (s)
2755 struct glyph_string *s;
2756 {
2757 PREPARE_FACE_FOR_DISPLAY (s->f, s->face);
2758
2759 if (s->hl == DRAW_NORMAL_TEXT)
2760 {
2761 s->gc = s->face->gc;
2762 s->stippled_p = s->face->stipple != 0;
2763 }
2764 else if (s->hl == DRAW_INVERSE_VIDEO)
2765 {
2766 x_set_mode_line_face_gc (s);
2767 s->stippled_p = s->face->stipple != 0;
2768 }
2769 else if (s->hl == DRAW_CURSOR)
2770 {
2771 x_set_cursor_gc (s);
2772 s->stippled_p = 0;
2773 }
2774 else if (s->hl == DRAW_MOUSE_FACE)
2775 {
2776 x_set_mouse_face_gc (s);
2777 s->stippled_p = s->face->stipple != 0;
2778 }
2779 else if (s->hl == DRAW_IMAGE_RAISED
2780 || s->hl == DRAW_IMAGE_SUNKEN)
2781 {
2782 s->gc = s->face->gc;
2783 s->stippled_p = s->face->stipple != 0;
2784 }
2785 else
2786 {
2787 s->gc = s->face->gc;
2788 s->stippled_p = s->face->stipple != 0;
2789 }
2790
2791 /* GC must have been set. */
2792 xassert (s->gc != 0);
2793 }
2794
2795
2796 /* Return in *R the clipping rectangle for glyph string S. */
2797
2798 static void
2799 x_get_glyph_string_clip_rect (s, r)
2800 struct glyph_string *s;
2801 XRectangle *r;
2802 {
2803 if (s->row->full_width_p)
2804 {
2805 /* Draw full-width. X coordinates are relative to S->w->left. */
2806 int canon_x = CANON_X_UNIT (s->f);
2807
2808 r->x = WINDOW_LEFT_MARGIN (s->w) * canon_x;
2809 r->width = XFASTINT (s->w->width) * canon_x;
2810
2811 if (FRAME_HAS_VERTICAL_SCROLL_BARS (s->f))
2812 {
2813 int width = FRAME_SCROLL_BAR_WIDTH (s->f) * canon_x;
2814 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (s->f))
2815 r->x -= width;
2816 }
2817
2818 r->x += FRAME_INTERNAL_BORDER_WIDTH (s->f);
2819
2820 /* Unless displaying a mode or menu bar line, which are always
2821 fully visible, clip to the visible part of the row. */
2822 if (s->w->pseudo_window_p)
2823 r->height = s->row->visible_height;
2824 else
2825 r->height = s->height;
2826 }
2827 else
2828 {
2829 /* This is a text line that may be partially visible. */
2830 r->x = WINDOW_AREA_TO_FRAME_PIXEL_X (s->w, s->area, 0);
2831 r->width = window_box_width (s->w, s->area);
2832 r->height = s->row->visible_height;
2833 }
2834
2835 /* Don't use S->y for clipping because it doesn't take partially
2836 visible lines into account. For example, it can be negative for
2837 partially visible lines at the top of a window. */
2838 if (!s->row->full_width_p
2839 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s->w, s->row))
2840 r->y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s->w);
2841 else
2842 r->y = max (0, s->row->y);
2843
2844 /* If drawing a tool-bar window, draw it over the internal border
2845 at the top of the window. */
2846 if (s->w == XWINDOW (s->f->tool_bar_window))
2847 r->y -= s->f->output_data.x->internal_border_width;
2848
2849 /* If S draws overlapping rows, it's sufficient to use the top and
2850 bottom of the window for clipping because this glyph string
2851 intentionally draws over other lines. */
2852 if (s->for_overlaps_p)
2853 {
2854 r->y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s->w);
2855 r->height = window_text_bottom_y (s->w) - r->y;
2856 }
2857
2858 r->y = WINDOW_TO_FRAME_PIXEL_Y (s->w, r->y);
2859 }
2860
2861
2862 /* Set clipping for output of glyph string S. S may be part of a mode
2863 line or menu if we don't have X toolkit support. */
2864
2865 static INLINE void
2866 x_set_glyph_string_clipping (s)
2867 struct glyph_string *s;
2868 {
2869 XRectangle r;
2870 x_get_glyph_string_clip_rect (s, &r);
2871 XSetClipRectangles (s->display, s->gc, 0, 0, &r, 1, Unsorted);
2872 }
2873
2874
2875 /* Compute left and right overhang of glyph string S. If S is a glyph
2876 string for a composition, assume overhangs don't exist. */
2877
2878 static INLINE void
2879 x_compute_glyph_string_overhangs (s)
2880 struct glyph_string *s;
2881 {
2882 if (s->cmp == NULL
2883 && s->first_glyph->type == CHAR_GLYPH)
2884 {
2885 XCharStruct cs;
2886 int direction, font_ascent, font_descent;
2887 XTextExtents16 (s->font, s->char2b, s->nchars, &direction,
2888 &font_ascent, &font_descent, &cs);
2889 s->right_overhang = cs.rbearing > cs.width ? cs.rbearing - cs.width : 0;
2890 s->left_overhang = cs.lbearing < 0 ? -cs.lbearing : 0;
2891 }
2892 }
2893
2894
2895 /* Compute overhangs and x-positions for glyph string S and its
2896 predecessors, or successors. X is the starting x-position for S.
2897 BACKWARD_P non-zero means process predecessors. */
2898
2899 static void
2900 x_compute_overhangs_and_x (s, x, backward_p)
2901 struct glyph_string *s;
2902 int x;
2903 int backward_p;
2904 {
2905 if (backward_p)
2906 {
2907 while (s)
2908 {
2909 x_compute_glyph_string_overhangs (s);
2910 x -= s->width;
2911 s->x = x;
2912 s = s->prev;
2913 }
2914 }
2915 else
2916 {
2917 while (s)
2918 {
2919 x_compute_glyph_string_overhangs (s);
2920 s->x = x;
2921 x += s->width;
2922 s = s->next;
2923 }
2924 }
2925 }
2926
2927
2928 /* Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
2929 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
2930 assumed to be zero. */
2931
2932 static void
2933 x_get_glyph_overhangs (glyph, f, left, right)
2934 struct glyph *glyph;
2935 struct frame *f;
2936 int *left, *right;
2937 {
2938 *left = *right = 0;
2939
2940 if (glyph->type == CHAR_GLYPH)
2941 {
2942 XFontStruct *font;
2943 struct face *face;
2944 struct font_info *font_info;
2945 XChar2b char2b;
2946 XCharStruct *pcm;
2947
2948 face = x_get_glyph_face_and_encoding (f, glyph, &char2b, NULL);
2949 font = face->font;
2950 font_info = FONT_INFO_FROM_ID (f, face->font_info_id);
2951 if (font
2952 && (pcm = x_per_char_metric (font, &char2b)))
2953 {
2954 if (pcm->rbearing > pcm->width)
2955 *right = pcm->rbearing - pcm->width;
2956 if (pcm->lbearing < 0)
2957 *left = -pcm->lbearing;
2958 }
2959 }
2960 }
2961
2962
2963 /* Return the index of the first glyph preceding glyph string S that
2964 is overwritten by S because of S's left overhang. Value is -1
2965 if no glyphs are overwritten. */
2966
2967 static int
2968 x_left_overwritten (s)
2969 struct glyph_string *s;
2970 {
2971 int k;
2972
2973 if (s->left_overhang)
2974 {
2975 int x = 0, i;
2976 struct glyph *glyphs = s->row->glyphs[s->area];
2977 int first = s->first_glyph - glyphs;
2978
2979 for (i = first - 1; i >= 0 && x > -s->left_overhang; --i)
2980 x -= glyphs[i].pixel_width;
2981
2982 k = i + 1;
2983 }
2984 else
2985 k = -1;
2986
2987 return k;
2988 }
2989
2990
2991 /* Return the index of the first glyph preceding glyph string S that
2992 is overwriting S because of its right overhang. Value is -1 if no
2993 glyph in front of S overwrites S. */
2994
2995 static int
2996 x_left_overwriting (s)
2997 struct glyph_string *s;
2998 {
2999 int i, k, x;
3000 struct glyph *glyphs = s->row->glyphs[s->area];
3001 int first = s->first_glyph - glyphs;
3002
3003 k = -1;
3004 x = 0;
3005 for (i = first - 1; i >= 0; --i)
3006 {
3007 int left, right;
3008 x_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
3009 if (x + right > 0)
3010 k = i;
3011 x -= glyphs[i].pixel_width;
3012 }
3013
3014 return k;
3015 }
3016
3017
3018 /* Return the index of the last glyph following glyph string S that is
3019 not overwritten by S because of S's right overhang. Value is -1 if
3020 no such glyph is found. */
3021
3022 static int
3023 x_right_overwritten (s)
3024 struct glyph_string *s;
3025 {
3026 int k = -1;
3027
3028 if (s->right_overhang)
3029 {
3030 int x = 0, i;
3031 struct glyph *glyphs = s->row->glyphs[s->area];
3032 int first = (s->first_glyph - glyphs) + (s->cmp ? 1 : s->nchars);
3033 int end = s->row->used[s->area];
3034
3035 for (i = first; i < end && s->right_overhang > x; ++i)
3036 x += glyphs[i].pixel_width;
3037
3038 k = i;
3039 }
3040
3041 return k;
3042 }
3043
3044
3045 /* Return the index of the last glyph following glyph string S that
3046 overwrites S because of its left overhang. Value is negative
3047 if no such glyph is found. */
3048
3049 static int
3050 x_right_overwriting (s)
3051 struct glyph_string *s;
3052 {
3053 int i, k, x;
3054 int end = s->row->used[s->area];
3055 struct glyph *glyphs = s->row->glyphs[s->area];
3056 int first = (s->first_glyph - glyphs) + (s->cmp ? 1 : s->nchars);
3057
3058 k = -1;
3059 x = 0;
3060 for (i = first; i < end; ++i)
3061 {
3062 int left, right;
3063 x_get_glyph_overhangs (glyphs + i, s->f, &left, &right);
3064 if (x - left < 0)
3065 k = i;
3066 x += glyphs[i].pixel_width;
3067 }
3068
3069 return k;
3070 }
3071
3072
3073 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
3074
3075 static INLINE void
3076 x_clear_glyph_string_rect (s, x, y, w, h)
3077 struct glyph_string *s;
3078 int x, y, w, h;
3079 {
3080 XGCValues xgcv;
3081 XGetGCValues (s->display, s->gc, GCForeground | GCBackground, &xgcv);
3082 XSetForeground (s->display, s->gc, xgcv.background);
3083 XFillRectangle (s->display, s->window, s->gc, x, y, w, h);
3084 XSetForeground (s->display, s->gc, xgcv.foreground);
3085 }
3086
3087
3088 /* Draw the background of glyph_string S. If S->background_filled_p
3089 is non-zero don't draw it. FORCE_P non-zero means draw the
3090 background even if it wouldn't be drawn normally. This is used
3091 when a string preceding S draws into the background of S, or S
3092 contains the first component of a composition. */
3093
3094 static void
3095 x_draw_glyph_string_background (s, force_p)
3096 struct glyph_string *s;
3097 int force_p;
3098 {
3099 /* Nothing to do if background has already been drawn or if it
3100 shouldn't be drawn in the first place. */
3101 if (!s->background_filled_p)
3102 {
3103 int box_line_width = max (s->face->box_line_width, 0);
3104
3105 if (s->stippled_p)
3106 {
3107 /* Fill background with a stipple pattern. */
3108 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
3109 XFillRectangle (s->display, s->window, s->gc, s->x,
3110 s->y + box_line_width,
3111 s->background_width,
3112 s->height - 2 * box_line_width);
3113 XSetFillStyle (s->display, s->gc, FillSolid);
3114 s->background_filled_p = 1;
3115 }
3116 else if (FONT_HEIGHT (s->font) < s->height - 2 * box_line_width
3117 || s->font_not_found_p
3118 || s->extends_to_end_of_line_p
3119 || force_p)
3120 {
3121 x_clear_glyph_string_rect (s, s->x, s->y + box_line_width,
3122 s->background_width,
3123 s->height - 2 * box_line_width);
3124 s->background_filled_p = 1;
3125 }
3126 }
3127 }
3128
3129
3130 /* Draw the foreground of glyph string S. */
3131
3132 static void
3133 x_draw_glyph_string_foreground (s)
3134 struct glyph_string *s;
3135 {
3136 int i, x;
3137
3138 /* If first glyph of S has a left box line, start drawing the text
3139 of S to the right of that box line. */
3140 if (s->face->box != FACE_NO_BOX
3141 && s->first_glyph->left_box_line_p)
3142 x = s->x + abs (s->face->box_line_width);
3143 else
3144 x = s->x;
3145
3146 /* Draw characters of S as rectangles if S's font could not be
3147 loaded. */
3148 if (s->font_not_found_p)
3149 {
3150 for (i = 0; i < s->nchars; ++i)
3151 {
3152 struct glyph *g = s->first_glyph + i;
3153 XDrawRectangle (s->display, s->window,
3154 s->gc, x, s->y, g->pixel_width - 1,
3155 s->height - 1);
3156 x += g->pixel_width;
3157 }
3158 }
3159 else
3160 {
3161 char *char1b = (char *) s->char2b;
3162 int boff = s->font_info->baseline_offset;
3163
3164 if (s->font_info->vertical_centering)
3165 boff = VCENTER_BASELINE_OFFSET (s->font, s->f) - boff;
3166
3167 /* If we can use 8-bit functions, condense S->char2b. */
3168 if (!s->two_byte_p)
3169 for (i = 0; i < s->nchars; ++i)
3170 char1b[i] = s->char2b[i].byte2;
3171
3172 /* Draw text with XDrawString if background has already been
3173 filled. Otherwise, use XDrawImageString. (Note that
3174 XDrawImageString is usually faster than XDrawString.) Always
3175 use XDrawImageString when drawing the cursor so that there is
3176 no chance that characters under a box cursor are invisible. */
3177 if (s->for_overlaps_p
3178 || (s->background_filled_p && s->hl != DRAW_CURSOR))
3179 {
3180 /* Draw characters with 16-bit or 8-bit functions. */
3181 if (s->two_byte_p)
3182 XDrawString16 (s->display, s->window, s->gc, x,
3183 s->ybase - boff, s->char2b, s->nchars);
3184 else
3185 XDrawString (s->display, s->window, s->gc, x,
3186 s->ybase - boff, char1b, s->nchars);
3187 }
3188 else
3189 {
3190 if (s->two_byte_p)
3191 XDrawImageString16 (s->display, s->window, s->gc, x,
3192 s->ybase - boff, s->char2b, s->nchars);
3193 else
3194 XDrawImageString (s->display, s->window, s->gc, x,
3195 s->ybase - boff, char1b, s->nchars);
3196 }
3197 }
3198 }
3199
3200 /* Draw the foreground of composite glyph string S. */
3201
3202 static void
3203 x_draw_composite_glyph_string_foreground (s)
3204 struct glyph_string *s;
3205 {
3206 int i, x;
3207
3208 /* If first glyph of S has a left box line, start drawing the text
3209 of S to the right of that box line. */
3210 if (s->face->box != FACE_NO_BOX
3211 && s->first_glyph->left_box_line_p)
3212 x = s->x + abs (s->face->box_line_width);
3213 else
3214 x = s->x;
3215
3216 /* S is a glyph string for a composition. S->gidx is the index of
3217 the first character drawn for glyphs of this composition.
3218 S->gidx == 0 means we are drawing the very first character of
3219 this composition. */
3220
3221 /* Draw a rectangle for the composition if the font for the very
3222 first character of the composition could not be loaded. */
3223 if (s->font_not_found_p)
3224 {
3225 if (s->gidx == 0)
3226 XDrawRectangle (s->display, s->window, s->gc, x, s->y,
3227 s->width - 1, s->height - 1);
3228 }
3229 else
3230 {
3231 for (i = 0; i < s->nchars; i++, ++s->gidx)
3232 XDrawString16 (s->display, s->window, s->gc,
3233 x + s->cmp->offsets[s->gidx * 2],
3234 s->ybase - s->cmp->offsets[s->gidx * 2 + 1],
3235 s->char2b + i, 1);
3236 }
3237 }
3238
3239
3240 #ifdef USE_X_TOOLKIT
3241
3242 static struct frame *x_frame_of_widget P_ ((Widget));
3243
3244
3245 /* Return the frame on which widget WIDGET is used.. Abort if frame
3246 cannot be determined. */
3247
3248 static struct frame *
3249 x_frame_of_widget (widget)
3250 Widget widget;
3251 {
3252 struct x_display_info *dpyinfo;
3253 Lisp_Object tail;
3254 struct frame *f;
3255
3256 dpyinfo = x_display_info_for_display (XtDisplay (widget));
3257
3258 /* Find the top-level shell of the widget. Note that this function
3259 can be called when the widget is not yet realized, so XtWindow
3260 (widget) == 0. That's the reason we can't simply use
3261 x_any_window_to_frame. */
3262 while (!XtIsTopLevelShell (widget))
3263 widget = XtParent (widget);
3264
3265 /* Look for a frame with that top-level widget. Allocate the color
3266 on that frame to get the right gamma correction value. */
3267 for (tail = Vframe_list; GC_CONSP (tail); tail = XCDR (tail))
3268 if (GC_FRAMEP (XCAR (tail))
3269 && (f = XFRAME (XCAR (tail)),
3270 (f->output_data.nothing != 1
3271 && FRAME_X_DISPLAY_INFO (f) == dpyinfo))
3272 && f->output_data.x->widget == widget)
3273 return f;
3274
3275 abort ();
3276 }
3277
3278
3279 /* Allocate the color COLOR->pixel on the screen and display of
3280 widget WIDGET in colormap CMAP. If an exact match cannot be
3281 allocated, try the nearest color available. Value is non-zero
3282 if successful. This is called from lwlib. */
3283
3284 int
3285 x_alloc_nearest_color_for_widget (widget, cmap, color)
3286 Widget widget;
3287 Colormap cmap;
3288 XColor *color;
3289 {
3290 struct frame *f = x_frame_of_widget (widget);
3291 return x_alloc_nearest_color (f, cmap, color);
3292 }
3293
3294
3295 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
3296 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3297 If this produces the same color as PIXEL, try a color where all RGB
3298 values have DELTA added. Return the allocated color in *PIXEL.
3299 DISPLAY is the X display, CMAP is the colormap to operate on.
3300 Value is non-zero if successful. */
3301
3302 int
3303 x_alloc_lighter_color_for_widget (widget, display, cmap, pixel, factor, delta)
3304 Widget widget;
3305 Display *display;
3306 Colormap cmap;
3307 unsigned long *pixel;
3308 double factor;
3309 int delta;
3310 {
3311 struct frame *f = x_frame_of_widget (widget);
3312 return x_alloc_lighter_color (f, display, cmap, pixel, factor, delta);
3313 }
3314
3315
3316 #endif /* USE_X_TOOLKIT */
3317
3318
3319 /* Value is an array of XColor structures for the contents of the
3320 color map of frame F. Set *NCELLS to the size of the array.
3321 Note that this probably shouldn't be called for large color maps,
3322 say a 24-bit TrueColor map. */
3323
3324 static const XColor *
3325 x_color_cells (f, ncells)
3326 struct frame *f;
3327 int *ncells;
3328 {
3329 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
3330
3331 if (dpyinfo->color_cells == NULL)
3332 {
3333 Display *display = FRAME_X_DISPLAY (f);
3334 Screen *screen = FRAME_X_SCREEN (f);
3335 int i;
3336
3337 dpyinfo->ncolor_cells
3338 = XDisplayCells (display, XScreenNumberOfScreen (screen));
3339 dpyinfo->color_cells
3340 = (XColor *) xmalloc (dpyinfo->ncolor_cells
3341 * sizeof *dpyinfo->color_cells);
3342
3343 for (i = 0; i < dpyinfo->ncolor_cells; ++i)
3344 dpyinfo->color_cells[i].pixel = i;
3345
3346 XQueryColors (display, FRAME_X_COLORMAP (f),
3347 dpyinfo->color_cells, dpyinfo->ncolor_cells);
3348 }
3349
3350 *ncells = dpyinfo->ncolor_cells;
3351 return dpyinfo->color_cells;
3352 }
3353
3354
3355 /* On frame F, translate pixel colors to RGB values for the NCOLORS
3356 colors in COLORS. Use cached information, if available. */
3357
3358 void
3359 x_query_colors (f, colors, ncolors)
3360 struct frame *f;
3361 XColor *colors;
3362 int ncolors;
3363 {
3364 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
3365
3366 if (dpyinfo->color_cells)
3367 {
3368 int i;
3369 for (i = 0; i < ncolors; ++i)
3370 {
3371 unsigned long pixel = colors[i].pixel;
3372 xassert (pixel < dpyinfo->ncolor_cells);
3373 xassert (dpyinfo->color_cells[pixel].pixel == pixel);
3374 colors[i] = dpyinfo->color_cells[pixel];
3375 }
3376 }
3377 else
3378 XQueryColors (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), colors, ncolors);
3379 }
3380
3381
3382 /* On frame F, translate pixel color to RGB values for the color in
3383 COLOR. Use cached information, if available. */
3384
3385 void
3386 x_query_color (f, color)
3387 struct frame *f;
3388 XColor *color;
3389 {
3390 x_query_colors (f, color, 1);
3391 }
3392
3393
3394 /* Allocate the color COLOR->pixel on SCREEN of DISPLAY, colormap
3395 CMAP. If an exact match can't be allocated, try the nearest color
3396 available. Value is non-zero if successful. Set *COLOR to the
3397 color allocated. */
3398
3399 int
3400 x_alloc_nearest_color (f, cmap, color)
3401 struct frame *f;
3402 Colormap cmap;
3403 XColor *color;
3404 {
3405 Display *display = FRAME_X_DISPLAY (f);
3406 Screen *screen = FRAME_X_SCREEN (f);
3407 int rc;
3408
3409 gamma_correct (f, color);
3410 rc = XAllocColor (display, cmap, color);
3411 if (rc == 0)
3412 {
3413 /* If we got to this point, the colormap is full, so we're going
3414 to try to get the next closest color. The algorithm used is
3415 a least-squares matching, which is what X uses for closest
3416 color matching with StaticColor visuals. */
3417 int nearest, i;
3418 unsigned long nearest_delta = ~0;
3419 int ncells;
3420 const XColor *cells = x_color_cells (f, &ncells);
3421
3422 for (nearest = i = 0; i < ncells; ++i)
3423 {
3424 long dred = (color->red >> 8) - (cells[i].red >> 8);
3425 long dgreen = (color->green >> 8) - (cells[i].green >> 8);
3426 long dblue = (color->blue >> 8) - (cells[i].blue >> 8);
3427 unsigned long delta = dred * dred + dgreen * dgreen + dblue * dblue;
3428
3429 if (delta < nearest_delta)
3430 {
3431 nearest = i;
3432 nearest_delta = delta;
3433 }
3434 }
3435
3436 color->red = cells[nearest].red;
3437 color->green = cells[nearest].green;
3438 color->blue = cells[nearest].blue;
3439 rc = XAllocColor (display, cmap, color);
3440 }
3441 else
3442 {
3443 /* If allocation succeeded, and the allocated pixel color is not
3444 equal to a cached pixel color recorded earlier, there was a
3445 change in the colormap, so clear the color cache. */
3446 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
3447 XColor *cached_color;
3448
3449 if (dpyinfo->color_cells
3450 && (cached_color = &dpyinfo->color_cells[color->pixel],
3451 (cached_color->red != color->red
3452 || cached_color->blue != color->blue
3453 || cached_color->green != color->green)))
3454 {
3455 xfree (dpyinfo->color_cells);
3456 dpyinfo->color_cells = NULL;
3457 dpyinfo->ncolor_cells = 0;
3458 }
3459 }
3460
3461 #ifdef DEBUG_X_COLORS
3462 if (rc)
3463 register_color (color->pixel);
3464 #endif /* DEBUG_X_COLORS */
3465
3466 return rc;
3467 }
3468
3469
3470 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
3471 It's necessary to do this instead of just using PIXEL directly to
3472 get color reference counts right. */
3473
3474 unsigned long
3475 x_copy_color (f, pixel)
3476 struct frame *f;
3477 unsigned long pixel;
3478 {
3479 XColor color;
3480
3481 color.pixel = pixel;
3482 BLOCK_INPUT;
3483 x_query_color (f, &color);
3484 XAllocColor (FRAME_X_DISPLAY (f), FRAME_X_COLORMAP (f), &color);
3485 UNBLOCK_INPUT;
3486 #ifdef DEBUG_X_COLORS
3487 register_color (pixel);
3488 #endif
3489 return color.pixel;
3490 }
3491
3492
3493 /* Allocate color PIXEL on display DPY. PIXEL must already be allocated.
3494 It's necessary to do this instead of just using PIXEL directly to
3495 get color reference counts right. */
3496
3497 unsigned long
3498 x_copy_dpy_color (dpy, cmap, pixel)
3499 Display *dpy;
3500 Colormap cmap;
3501 unsigned long pixel;
3502 {
3503 XColor color;
3504
3505 color.pixel = pixel;
3506 BLOCK_INPUT;
3507 XQueryColor (dpy, cmap, &color);
3508 XAllocColor (dpy, cmap, &color);
3509 UNBLOCK_INPUT;
3510 #ifdef DEBUG_X_COLORS
3511 register_color (pixel);
3512 #endif
3513 return color.pixel;
3514 }
3515
3516
3517 /* Brightness beyond which a color won't have its highlight brightness
3518 boosted.
3519
3520 Nominally, highlight colors for `3d' faces are calculated by
3521 brightening an object's color by a constant scale factor, but this
3522 doesn't yield good results for dark colors, so for colors who's
3523 brightness is less than this value (on a scale of 0-65535) have an
3524 use an additional additive factor.
3525
3526 The value here is set so that the default menu-bar/mode-line color
3527 (grey75) will not have its highlights changed at all. */
3528 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 48000
3529
3530
3531 /* Allocate a color which is lighter or darker than *PIXEL by FACTOR
3532 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3533 If this produces the same color as PIXEL, try a color where all RGB
3534 values have DELTA added. Return the allocated color in *PIXEL.
3535 DISPLAY is the X display, CMAP is the colormap to operate on.
3536 Value is non-zero if successful. */
3537
3538 static int
3539 x_alloc_lighter_color (f, display, cmap, pixel, factor, delta)
3540 struct frame *f;
3541 Display *display;
3542 Colormap cmap;
3543 unsigned long *pixel;
3544 double factor;
3545 int delta;
3546 {
3547 XColor color, new;
3548 long bright;
3549 int success_p;
3550
3551 /* Get RGB color values. */
3552 color.pixel = *pixel;
3553 x_query_color (f, &color);
3554
3555 /* Change RGB values by specified FACTOR. Avoid overflow! */
3556 xassert (factor >= 0);
3557 new.red = min (0xffff, factor * color.red);
3558 new.green = min (0xffff, factor * color.green);
3559 new.blue = min (0xffff, factor * color.blue);
3560
3561 /* Calculate brightness of COLOR. */
3562 bright = (2 * color.red + 3 * color.green + color.blue) / 6;
3563
3564 /* We only boost colors that are darker than
3565 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
3566 if (bright < HIGHLIGHT_COLOR_DARK_BOOST_LIMIT)
3567 /* Make an additive adjustment to NEW, because it's dark enough so
3568 that scaling by FACTOR alone isn't enough. */
3569 {
3570 /* How far below the limit this color is (0 - 1, 1 being darker). */
3571 double dimness = 1 - (double)bright / HIGHLIGHT_COLOR_DARK_BOOST_LIMIT;
3572 /* The additive adjustment. */
3573 int min_delta = delta * dimness * factor / 2;
3574
3575 if (factor < 1)
3576 {
3577 new.red = max (0, new.red - min_delta);
3578 new.green = max (0, new.green - min_delta);
3579 new.blue = max (0, new.blue - min_delta);
3580 }
3581 else
3582 {
3583 new.red = min (0xffff, min_delta + new.red);
3584 new.green = min (0xffff, min_delta + new.green);
3585 new.blue = min (0xffff, min_delta + new.blue);
3586 }
3587 }
3588
3589 /* Try to allocate the color. */
3590 success_p = x_alloc_nearest_color (f, cmap, &new);
3591 if (success_p)
3592 {
3593 if (new.pixel == *pixel)
3594 {
3595 /* If we end up with the same color as before, try adding
3596 delta to the RGB values. */
3597 x_free_colors (f, &new.pixel, 1);
3598
3599 new.red = min (0xffff, delta + color.red);
3600 new.green = min (0xffff, delta + color.green);
3601 new.blue = min (0xffff, delta + color.blue);
3602 success_p = x_alloc_nearest_color (f, cmap, &new);
3603 }
3604 else
3605 success_p = 1;
3606 *pixel = new.pixel;
3607 }
3608
3609 return success_p;
3610 }
3611
3612
3613 /* Set up the foreground color for drawing relief lines of glyph
3614 string S. RELIEF is a pointer to a struct relief containing the GC
3615 with which lines will be drawn. Use a color that is FACTOR or
3616 DELTA lighter or darker than the relief's background which is found
3617 in S->f->output_data.x->relief_background. If such a color cannot
3618 be allocated, use DEFAULT_PIXEL, instead. */
3619
3620 static void
3621 x_setup_relief_color (f, relief, factor, delta, default_pixel)
3622 struct frame *f;
3623 struct relief *relief;
3624 double factor;
3625 int delta;
3626 unsigned long default_pixel;
3627 {
3628 XGCValues xgcv;
3629 struct x_output *di = f->output_data.x;
3630 unsigned long mask = GCForeground | GCLineWidth | GCGraphicsExposures;
3631 unsigned long pixel;
3632 unsigned long background = di->relief_background;
3633 Colormap cmap = FRAME_X_COLORMAP (f);
3634 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
3635 Display *dpy = FRAME_X_DISPLAY (f);
3636
3637 xgcv.graphics_exposures = False;
3638 xgcv.line_width = 1;
3639
3640 /* Free previously allocated color. The color cell will be reused
3641 when it has been freed as many times as it was allocated, so this
3642 doesn't affect faces using the same colors. */
3643 if (relief->gc
3644 && relief->allocated_p)
3645 {
3646 x_free_colors (f, &relief->pixel, 1);
3647 relief->allocated_p = 0;
3648 }
3649
3650 /* Allocate new color. */
3651 xgcv.foreground = default_pixel;
3652 pixel = background;
3653 if (dpyinfo->n_planes != 1
3654 && x_alloc_lighter_color (f, dpy, cmap, &pixel, factor, delta))
3655 {
3656 relief->allocated_p = 1;
3657 xgcv.foreground = relief->pixel = pixel;
3658 }
3659
3660 if (relief->gc == 0)
3661 {
3662 xgcv.stipple = dpyinfo->gray;
3663 mask |= GCStipple;
3664 relief->gc = XCreateGC (dpy, FRAME_X_WINDOW (f), mask, &xgcv);
3665 }
3666 else
3667 XChangeGC (dpy, relief->gc, mask, &xgcv);
3668 }
3669
3670
3671 /* Set up colors for the relief lines around glyph string S. */
3672
3673 static void
3674 x_setup_relief_colors (s)
3675 struct glyph_string *s;
3676 {
3677 struct x_output *di = s->f->output_data.x;
3678 unsigned long color;
3679
3680 if (s->face->use_box_color_for_shadows_p)
3681 color = s->face->box_color;
3682 else
3683 {
3684 XGCValues xgcv;
3685
3686 /* Get the background color of the face. */
3687 XGetGCValues (s->display, s->gc, GCBackground, &xgcv);
3688 color = xgcv.background;
3689 }
3690
3691 if (di->white_relief.gc == 0
3692 || color != di->relief_background)
3693 {
3694 di->relief_background = color;
3695 x_setup_relief_color (s->f, &di->white_relief, 1.2, 0x8000,
3696 WHITE_PIX_DEFAULT (s->f));
3697 x_setup_relief_color (s->f, &di->black_relief, 0.6, 0x4000,
3698 BLACK_PIX_DEFAULT (s->f));
3699 }
3700 }
3701
3702
3703 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
3704 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
3705 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
3706 relief. LEFT_P non-zero means draw a relief on the left side of
3707 the rectangle. RIGHT_P non-zero means draw a relief on the right
3708 side of the rectangle. CLIP_RECT is the clipping rectangle to use
3709 when drawing. */
3710
3711 static void
3712 x_draw_relief_rect (f, left_x, top_y, right_x, bottom_y, width,
3713 raised_p, left_p, right_p, clip_rect)
3714 struct frame *f;
3715 int left_x, top_y, right_x, bottom_y, left_p, right_p, raised_p;
3716 XRectangle *clip_rect;
3717 {
3718 int i;
3719 GC gc;
3720
3721 if (raised_p)
3722 gc = f->output_data.x->white_relief.gc;
3723 else
3724 gc = f->output_data.x->black_relief.gc;
3725 XSetClipRectangles (FRAME_X_DISPLAY (f), gc, 0, 0, clip_rect, 1, Unsorted);
3726
3727 /* Top. */
3728 for (i = 0; i < width; ++i)
3729 XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
3730 left_x + i * left_p, top_y + i,
3731 right_x + 1 - i * right_p, top_y + i);
3732
3733 /* Left. */
3734 if (left_p)
3735 for (i = 0; i < width; ++i)
3736 XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
3737 left_x + i, top_y + i, left_x + i, bottom_y - i);
3738
3739 XSetClipMask (FRAME_X_DISPLAY (f), gc, None);
3740 if (raised_p)
3741 gc = f->output_data.x->black_relief.gc;
3742 else
3743 gc = f->output_data.x->white_relief.gc;
3744 XSetClipRectangles (FRAME_X_DISPLAY (f), gc, 0, 0, clip_rect, 1, Unsorted);
3745
3746 /* Bottom. */
3747 for (i = 0; i < width; ++i)
3748 XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
3749 left_x + i * left_p, bottom_y - i,
3750 right_x + 1 - i * right_p, bottom_y - i);
3751
3752 /* Right. */
3753 if (right_p)
3754 for (i = 0; i < width; ++i)
3755 XDrawLine (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
3756 right_x - i, top_y + i + 1, right_x - i, bottom_y - i);
3757
3758 XSetClipMask (FRAME_X_DISPLAY (f), gc, None);
3759 }
3760
3761
3762 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
3763 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
3764 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
3765 left side of the rectangle. RIGHT_P non-zero means draw a line
3766 on the right side of the rectangle. CLIP_RECT is the clipping
3767 rectangle to use when drawing. */
3768
3769 static void
3770 x_draw_box_rect (s, left_x, top_y, right_x, bottom_y, width,
3771 left_p, right_p, clip_rect)
3772 struct glyph_string *s;
3773 int left_x, top_y, right_x, bottom_y, left_p, right_p;
3774 XRectangle *clip_rect;
3775 {
3776 XGCValues xgcv;
3777
3778 XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
3779 XSetForeground (s->display, s->gc, s->face->box_color);
3780 XSetClipRectangles (s->display, s->gc, 0, 0, clip_rect, 1, Unsorted);
3781
3782 /* Top. */
3783 XFillRectangle (s->display, s->window, s->gc,
3784 left_x, top_y, right_x - left_x + 1, width);
3785
3786 /* Left. */
3787 if (left_p)
3788 XFillRectangle (s->display, s->window, s->gc,
3789 left_x, top_y, width, bottom_y - top_y + 1);
3790
3791 /* Bottom. */
3792 XFillRectangle (s->display, s->window, s->gc,
3793 left_x, bottom_y - width + 1, right_x - left_x + 1, width);
3794
3795 /* Right. */
3796 if (right_p)
3797 XFillRectangle (s->display, s->window, s->gc,
3798 right_x - width + 1, top_y, width, bottom_y - top_y + 1);
3799
3800 XSetForeground (s->display, s->gc, xgcv.foreground);
3801 XSetClipMask (s->display, s->gc, None);
3802 }
3803
3804
3805 /* Draw a box around glyph string S. */
3806
3807 static void
3808 x_draw_glyph_string_box (s)
3809 struct glyph_string *s;
3810 {
3811 int width, left_x, right_x, top_y, bottom_y, last_x, raised_p;
3812 int left_p, right_p;
3813 struct glyph *last_glyph;
3814 XRectangle clip_rect;
3815
3816 last_x = window_box_right (s->w, s->area);
3817 if (s->row->full_width_p
3818 && !s->w->pseudo_window_p)
3819 {
3820 last_x += FRAME_X_RIGHT_FLAGS_AREA_WIDTH (s->f);
3821 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (s->f))
3822 last_x += FRAME_SCROLL_BAR_WIDTH (s->f) * CANON_X_UNIT (s->f);
3823 }
3824
3825 /* The glyph that may have a right box line. */
3826 last_glyph = (s->cmp || s->img
3827 ? s->first_glyph
3828 : s->first_glyph + s->nchars - 1);
3829
3830 width = abs (s->face->box_line_width);
3831 raised_p = s->face->box == FACE_RAISED_BOX;
3832 left_x = s->x;
3833 right_x = ((s->row->full_width_p
3834 ? last_x - 1
3835 : min (last_x, s->x + s->background_width) - 1));
3836 top_y = s->y;
3837 bottom_y = top_y + s->height - 1;
3838
3839 left_p = (s->first_glyph->left_box_line_p
3840 || (s->hl == DRAW_MOUSE_FACE
3841 && (s->prev == NULL
3842 || s->prev->hl != s->hl)));
3843 right_p = (last_glyph->right_box_line_p
3844 || (s->hl == DRAW_MOUSE_FACE
3845 && (s->next == NULL
3846 || s->next->hl != s->hl)));
3847
3848 x_get_glyph_string_clip_rect (s, &clip_rect);
3849
3850 if (s->face->box == FACE_SIMPLE_BOX)
3851 x_draw_box_rect (s, left_x, top_y, right_x, bottom_y, width,
3852 left_p, right_p, &clip_rect);
3853 else
3854 {
3855 x_setup_relief_colors (s);
3856 x_draw_relief_rect (s->f, left_x, top_y, right_x, bottom_y,
3857 width, raised_p, left_p, right_p, &clip_rect);
3858 }
3859 }
3860
3861
3862 /* Draw foreground of image glyph string S. */
3863
3864 static void
3865 x_draw_image_foreground (s)
3866 struct glyph_string *s;
3867 {
3868 int x;
3869 int y = s->ybase - image_ascent (s->img, s->face);
3870
3871 /* If first glyph of S has a left box line, start drawing it to the
3872 right of that line. */
3873 if (s->face->box != FACE_NO_BOX
3874 && s->first_glyph->left_box_line_p)
3875 x = s->x + abs (s->face->box_line_width);
3876 else
3877 x = s->x;
3878
3879 /* If there is a margin around the image, adjust x- and y-position
3880 by that margin. */
3881 x += s->img->hmargin;
3882 y += s->img->vmargin;
3883
3884 if (s->img->pixmap)
3885 {
3886 if (s->img->mask)
3887 {
3888 /* We can't set both a clip mask and use XSetClipRectangles
3889 because the latter also sets a clip mask. We also can't
3890 trust on the shape extension to be available
3891 (XShapeCombineRegion). So, compute the rectangle to draw
3892 manually. */
3893 unsigned long mask = (GCClipMask | GCClipXOrigin | GCClipYOrigin
3894 | GCFunction);
3895 XGCValues xgcv;
3896 XRectangle clip_rect, image_rect, r;
3897
3898 xgcv.clip_mask = s->img->mask;
3899 xgcv.clip_x_origin = x;
3900 xgcv.clip_y_origin = y;
3901 xgcv.function = GXcopy;
3902 XChangeGC (s->display, s->gc, mask, &xgcv);
3903
3904 x_get_glyph_string_clip_rect (s, &clip_rect);
3905 image_rect.x = x;
3906 image_rect.y = y;
3907 image_rect.width = s->img->width;
3908 image_rect.height = s->img->height;
3909 if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
3910 XCopyArea (s->display, s->img->pixmap, s->window, s->gc,
3911 r.x - x, r.y - y, r.width, r.height, r.x, r.y);
3912 }
3913 else
3914 {
3915 unsigned long mask = GCClipXOrigin | GCClipYOrigin | GCFunction;
3916 XGCValues xgcv;
3917 XRectangle clip_rect, image_rect, r;
3918
3919 x_get_glyph_string_clip_rect (s, &clip_rect);
3920 image_rect.x = x;
3921 image_rect.y = y;
3922 image_rect.width = s->img->width;
3923 image_rect.height = s->img->height;
3924 if (x_intersect_rectangles (&clip_rect, &image_rect, &r))
3925 XCopyArea (s->display, s->img->pixmap, s->window, s->gc,
3926 r.x - x, r.y - y, r.width, r.height, r.x, r.y);
3927
3928 /* When the image has a mask, we can expect that at
3929 least part of a mouse highlight or a block cursor will
3930 be visible. If the image doesn't have a mask, make
3931 a block cursor visible by drawing a rectangle around
3932 the image. I believe it's looking better if we do
3933 nothing here for mouse-face. */
3934 if (s->hl == DRAW_CURSOR)
3935 XDrawRectangle (s->display, s->window, s->gc, x, y,
3936 s->img->width - 1, s->img->height - 1);
3937 }
3938 }
3939 else
3940 /* Draw a rectangle if image could not be loaded. */
3941 XDrawRectangle (s->display, s->window, s->gc, x, y,
3942 s->img->width - 1, s->img->height - 1);
3943 }
3944
3945
3946 /* Draw a relief around the image glyph string S. */
3947
3948 static void
3949 x_draw_image_relief (s)
3950 struct glyph_string *s;
3951 {
3952 int x0, y0, x1, y1, thick, raised_p;
3953 XRectangle r;
3954 int x;
3955 int y = s->ybase - image_ascent (s->img, s->face);
3956
3957 /* If first glyph of S has a left box line, start drawing it to the
3958 right of that line. */
3959 if (s->face->box != FACE_NO_BOX
3960 && s->first_glyph->left_box_line_p)
3961 x = s->x + abs (s->face->box_line_width);
3962 else
3963 x = s->x;
3964
3965 /* If there is a margin around the image, adjust x- and y-position
3966 by that margin. */
3967 x += s->img->hmargin;
3968 y += s->img->vmargin;
3969
3970 if (s->hl == DRAW_IMAGE_SUNKEN
3971 || s->hl == DRAW_IMAGE_RAISED)
3972 {
3973 thick = tool_bar_button_relief > 0 ? tool_bar_button_relief : 3;
3974 raised_p = s->hl == DRAW_IMAGE_RAISED;
3975 }
3976 else
3977 {
3978 thick = abs (s->img->relief);
3979 raised_p = s->img->relief > 0;
3980 }
3981
3982 x0 = x - thick;
3983 y0 = y - thick;
3984 x1 = x + s->img->width + thick - 1;
3985 y1 = y + s->img->height + thick - 1;
3986
3987 x_setup_relief_colors (s);
3988 x_get_glyph_string_clip_rect (s, &r);
3989 x_draw_relief_rect (s->f, x0, y0, x1, y1, thick, raised_p, 1, 1, &r);
3990 }
3991
3992
3993 /* Draw the foreground of image glyph string S to PIXMAP. */
3994
3995 static void
3996 x_draw_image_foreground_1 (s, pixmap)
3997 struct glyph_string *s;
3998 Pixmap pixmap;
3999 {
4000 int x;
4001 int y = s->ybase - s->y - image_ascent (s->img, s->face);
4002
4003 /* If first glyph of S has a left box line, start drawing it to the
4004 right of that line. */
4005 if (s->face->box != FACE_NO_BOX
4006 && s->first_glyph->left_box_line_p)
4007 x = abs (s->face->box_line_width);
4008 else
4009 x = 0;
4010
4011 /* If there is a margin around the image, adjust x- and y-position
4012 by that margin. */
4013 x += s->img->hmargin;
4014 y += s->img->vmargin;
4015
4016 if (s->img->pixmap)
4017 {
4018 if (s->img->mask)
4019 {
4020 /* We can't set both a clip mask and use XSetClipRectangles
4021 because the latter also sets a clip mask. We also can't
4022 trust on the shape extension to be available
4023 (XShapeCombineRegion). So, compute the rectangle to draw
4024 manually. */
4025 unsigned long mask = (GCClipMask | GCClipXOrigin | GCClipYOrigin
4026 | GCFunction);
4027 XGCValues xgcv;
4028
4029 xgcv.clip_mask = s->img->mask;
4030 xgcv.clip_x_origin = x;
4031 xgcv.clip_y_origin = y;
4032 xgcv.function = GXcopy;
4033 XChangeGC (s->display, s->gc, mask, &xgcv);
4034
4035 XCopyArea (s->display, s->img->pixmap, pixmap, s->gc,
4036 0, 0, s->img->width, s->img->height, x, y);
4037 XSetClipMask (s->display, s->gc, None);
4038 }
4039 else
4040 {
4041 XCopyArea (s->display, s->img->pixmap, pixmap, s->gc,
4042 0, 0, s->img->width, s->img->height, x, y);
4043
4044 /* When the image has a mask, we can expect that at
4045 least part of a mouse highlight or a block cursor will
4046 be visible. If the image doesn't have a mask, make
4047 a block cursor visible by drawing a rectangle around
4048 the image. I believe it's looking better if we do
4049 nothing here for mouse-face. */
4050 if (s->hl == DRAW_CURSOR)
4051 XDrawRectangle (s->display, pixmap, s->gc, x, y,
4052 s->img->width - 1, s->img->height - 1);
4053 }
4054 }
4055 else
4056 /* Draw a rectangle if image could not be loaded. */
4057 XDrawRectangle (s->display, pixmap, s->gc, x, y,
4058 s->img->width - 1, s->img->height - 1);
4059 }
4060
4061
4062 /* Draw part of the background of glyph string S. X, Y, W, and H
4063 give the rectangle to draw. */
4064
4065 static void
4066 x_draw_glyph_string_bg_rect (s, x, y, w, h)
4067 struct glyph_string *s;
4068 int x, y, w, h;
4069 {
4070 if (s->stippled_p)
4071 {
4072 /* Fill background with a stipple pattern. */
4073 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
4074 XFillRectangle (s->display, s->window, s->gc, x, y, w, h);
4075 XSetFillStyle (s->display, s->gc, FillSolid);
4076 }
4077 else
4078 x_clear_glyph_string_rect (s, x, y, w, h);
4079 }
4080
4081
4082 /* Draw image glyph string S.
4083
4084 s->y
4085 s->x +-------------------------
4086 | s->face->box
4087 |
4088 | +-------------------------
4089 | | s->img->margin
4090 | |
4091 | | +-------------------
4092 | | | the image
4093
4094 */
4095
4096 static void
4097 x_draw_image_glyph_string (s)
4098 struct glyph_string *s;
4099 {
4100 int x, y;
4101 int box_line_hwidth = abs (s->face->box_line_width);
4102 int box_line_vwidth = max (s->face->box_line_width, 0);
4103 int height;
4104 Pixmap pixmap = None;
4105
4106 height = s->height - 2 * box_line_vwidth;
4107
4108 /* Fill background with face under the image. Do it only if row is
4109 taller than image or if image has a clip mask to reduce
4110 flickering. */
4111 s->stippled_p = s->face->stipple != 0;
4112 if (height > s->img->height
4113 || s->img->hmargin
4114 || s->img->vmargin
4115 || s->img->mask
4116 || s->img->pixmap == 0
4117 || s->width != s->background_width)
4118 {
4119 if (box_line_hwidth && s->first_glyph->left_box_line_p)
4120 x = s->x + box_line_hwidth;
4121 else
4122 x = s->x;
4123
4124 y = s->y + box_line_vwidth;
4125
4126 if (s->img->mask)
4127 {
4128 /* Create a pixmap as large as the glyph string. Fill it
4129 with the background color. Copy the image to it, using
4130 its mask. Copy the temporary pixmap to the display. */
4131 Screen *screen = FRAME_X_SCREEN (s->f);
4132 int depth = DefaultDepthOfScreen (screen);
4133
4134 /* Create a pixmap as large as the glyph string. */
4135 pixmap = XCreatePixmap (s->display, s->window,
4136 s->background_width,
4137 s->height, depth);
4138
4139 /* Don't clip in the following because we're working on the
4140 pixmap. */
4141 XSetClipMask (s->display, s->gc, None);
4142
4143 /* Fill the pixmap with the background color/stipple. */
4144 if (s->stippled_p)
4145 {
4146 /* Fill background with a stipple pattern. */
4147 XSetFillStyle (s->display, s->gc, FillOpaqueStippled);
4148 XFillRectangle (s->display, pixmap, s->gc,
4149 0, 0, s->background_width, s->height);
4150 XSetFillStyle (s->display, s->gc, FillSolid);
4151 }
4152 else
4153 {
4154 XGCValues xgcv;
4155 XGetGCValues (s->display, s->gc, GCForeground | GCBackground,
4156 &xgcv);
4157 XSetForeground (s->display, s->gc, xgcv.background);
4158 XFillRectangle (s->display, pixmap, s->gc,
4159 0, 0, s->background_width, s->height);
4160 XSetForeground (s->display, s->gc, xgcv.foreground);
4161 }
4162 }
4163 else
4164 x_draw_glyph_string_bg_rect (s, x, y, s->background_width, height);
4165
4166 s->background_filled_p = 1;
4167 }
4168
4169 /* Draw the foreground. */
4170 if (pixmap != None)
4171 {
4172 x_draw_image_foreground_1 (s, pixmap);
4173 x_set_glyph_string_clipping (s);
4174 XCopyArea (s->display, pixmap, s->window, s->gc,
4175 0, 0, s->background_width, s->height, s->x, s->y);
4176 XFreePixmap (s->display, pixmap);
4177 }
4178 else
4179 x_draw_image_foreground (s);
4180
4181 /* If we must draw a relief around the image, do it. */
4182 if (s->img->relief
4183 || s->hl == DRAW_IMAGE_RAISED
4184 || s->hl == DRAW_IMAGE_SUNKEN)
4185 x_draw_image_relief (s);
4186 }
4187
4188
4189 /* Draw stretch glyph string S. */
4190
4191 static void
4192 x_draw_stretch_glyph_string (s)
4193 struct glyph_string *s;
4194 {
4195 xassert (s->first_glyph->type == STRETCH_GLYPH);
4196 s->stippled_p = s->face->stipple != 0;
4197
4198 if (s->hl == DRAW_CURSOR
4199 && !x_stretch_cursor_p)
4200 {
4201 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
4202 as wide as the stretch glyph. */
4203 int width = min (CANON_X_UNIT (s->f), s->background_width);
4204
4205 /* Draw cursor. */
4206 x_draw_glyph_string_bg_rect (s, s->x, s->y, width, s->height);
4207
4208 /* Clear rest using the GC of the original non-cursor face. */
4209 if (width < s->background_width)
4210 {
4211 GC gc = s->face->gc;
4212 int x = s->x + width, y = s->y;
4213 int w = s->background_width - width, h = s->height;
4214 XRectangle r;
4215
4216 x_get_glyph_string_clip_rect (s, &r);
4217 XSetClipRectangles (s->display, gc, 0, 0, &r, 1, Unsorted);
4218
4219 if (s->face->stipple)
4220 {
4221 /* Fill background with a stipple pattern. */
4222 XSetFillStyle (s->display, gc, FillOpaqueStippled);
4223 XFillRectangle (s->display, s->window, gc, x, y, w, h);
4224 XSetFillStyle (s->display, gc, FillSolid);
4225 }
4226 else
4227 {
4228 XGCValues xgcv;
4229 XGetGCValues (s->display, gc, GCForeground | GCBackground, &xgcv);
4230 XSetForeground (s->display, gc, xgcv.background);
4231 XFillRectangle (s->display, s->window, gc, x, y, w, h);
4232 XSetForeground (s->display, gc, xgcv.foreground);
4233 }
4234 }
4235 }
4236 else
4237 x_draw_glyph_string_bg_rect (s, s->x, s->y, s->background_width,
4238 s->height);
4239
4240 s->background_filled_p = 1;
4241 }
4242
4243
4244 /* Draw glyph string S. */
4245
4246 static void
4247 x_draw_glyph_string (s)
4248 struct glyph_string *s;
4249 {
4250 /* If S draws into the background of its successor, draw the
4251 background of the successor first so that S can draw into it.
4252 This makes S->next use XDrawString instead of XDrawImageString. */
4253 if (s->next && s->right_overhang && !s->for_overlaps_p)
4254 {
4255 xassert (s->next->img == NULL);
4256 x_set_glyph_string_gc (s->next);
4257 x_set_glyph_string_clipping (s->next);
4258 x_draw_glyph_string_background (s->next, 1);
4259 }
4260
4261 /* Set up S->gc, set clipping and draw S. */
4262 x_set_glyph_string_gc (s);
4263 x_set_glyph_string_clipping (s);
4264
4265 switch (s->first_glyph->type)
4266 {
4267 case IMAGE_GLYPH:
4268 x_draw_image_glyph_string (s);
4269 break;
4270
4271 case STRETCH_GLYPH:
4272 x_draw_stretch_glyph_string (s);
4273 break;
4274
4275 case CHAR_GLYPH:
4276 if (s->for_overlaps_p)
4277 s->background_filled_p = 1;
4278 else
4279 x_draw_glyph_string_background (s, 0);
4280 x_draw_glyph_string_foreground (s);
4281 break;
4282
4283 case COMPOSITE_GLYPH:
4284 if (s->for_overlaps_p || s->gidx > 0)
4285 s->background_filled_p = 1;
4286 else
4287 x_draw_glyph_string_background (s, 1);
4288 x_draw_composite_glyph_string_foreground (s);
4289 break;
4290
4291 default:
4292 abort ();
4293 }
4294
4295 if (!s->for_overlaps_p)
4296 {
4297 /* Draw underline. */
4298 if (s->face->underline_p)
4299 {
4300 unsigned long tem, h;
4301 int y;
4302
4303 /* Get the underline thickness. Default is 1 pixel. */
4304 if (!XGetFontProperty (s->font, XA_UNDERLINE_THICKNESS, &h))
4305 h = 1;
4306
4307 /* Get the underline position. This is the recommended
4308 vertical offset in pixels from the baseline to the top of
4309 the underline. This is a signed value according to the
4310 specs, and its default is
4311
4312 ROUND ((maximum descent) / 2), with
4313 ROUND(x) = floor (x + 0.5) */
4314
4315 if (XGetFontProperty (s->font, XA_UNDERLINE_POSITION, &tem))
4316 y = s->ybase + (long) tem;
4317 else if (s->face->font)
4318 y = s->ybase + (s->face->font->max_bounds.descent + 1) / 2;
4319 else
4320 y = s->height - h;
4321
4322 if (s->face->underline_defaulted_p)
4323 XFillRectangle (s->display, s->window, s->gc,
4324 s->x, y, s->width, h);
4325 else
4326 {
4327 XGCValues xgcv;
4328 XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
4329 XSetForeground (s->display, s->gc, s->face->underline_color);
4330 XFillRectangle (s->display, s->window, s->gc,
4331 s->x, y, s->width, h);
4332 XSetForeground (s->display, s->gc, xgcv.foreground);
4333 }
4334 }
4335
4336 /* Draw overline. */
4337 if (s->face->overline_p)
4338 {
4339 unsigned long dy = 0, h = 1;
4340
4341 if (s->face->overline_color_defaulted_p)
4342 XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
4343 s->width, h);
4344 else
4345 {
4346 XGCValues xgcv;
4347 XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
4348 XSetForeground (s->display, s->gc, s->face->overline_color);
4349 XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
4350 s->width, h);
4351 XSetForeground (s->display, s->gc, xgcv.foreground);
4352 }
4353 }
4354
4355 /* Draw strike-through. */
4356 if (s->face->strike_through_p)
4357 {
4358 unsigned long h = 1;
4359 unsigned long dy = (s->height - h) / 2;
4360
4361 if (s->face->strike_through_color_defaulted_p)
4362 XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
4363 s->width, h);
4364 else
4365 {
4366 XGCValues xgcv;
4367 XGetGCValues (s->display, s->gc, GCForeground, &xgcv);
4368 XSetForeground (s->display, s->gc, s->face->strike_through_color);
4369 XFillRectangle (s->display, s->window, s->gc, s->x, s->y + dy,
4370 s->width, h);
4371 XSetForeground (s->display, s->gc, xgcv.foreground);
4372 }
4373 }
4374
4375 /* Draw relief. */
4376 if (s->face->box != FACE_NO_BOX)
4377 x_draw_glyph_string_box (s);
4378 }
4379
4380 /* Reset clipping. */
4381 XSetClipMask (s->display, s->gc, None);
4382 }
4383
4384
4385 static int x_fill_composite_glyph_string P_ ((struct glyph_string *,
4386 struct face **, int));
4387
4388
4389 /* Fill glyph string S with composition components specified by S->cmp.
4390
4391 FACES is an array of faces for all components of this composition.
4392 S->gidx is the index of the first component for S.
4393 OVERLAPS_P non-zero means S should draw the foreground only, and
4394 use its physical height for clipping.
4395
4396 Value is the index of a component not in S. */
4397
4398 static int
4399 x_fill_composite_glyph_string (s, faces, overlaps_p)
4400 struct glyph_string *s;
4401 struct face **faces;
4402 int overlaps_p;
4403 {
4404 int i;
4405
4406 xassert (s);
4407
4408 s->for_overlaps_p = overlaps_p;
4409
4410 s->face = faces[s->gidx];
4411 s->font = s->face->font;
4412 s->font_info = FONT_INFO_FROM_ID (s->f, s->face->font_info_id);
4413
4414 /* For all glyphs of this composition, starting at the offset
4415 S->gidx, until we reach the end of the definition or encounter a
4416 glyph that requires the different face, add it to S. */
4417 ++s->nchars;
4418 for (i = s->gidx + 1; i < s->cmp->glyph_len && faces[i] == s->face; ++i)
4419 ++s->nchars;
4420
4421 /* All glyph strings for the same composition has the same width,
4422 i.e. the width set for the first component of the composition. */
4423
4424 s->width = s->first_glyph->pixel_width;
4425
4426 /* If the specified font could not be loaded, use the frame's
4427 default font, but record the fact that we couldn't load it in
4428 the glyph string so that we can draw rectangles for the
4429 characters of the glyph string. */
4430 if (s->font == NULL)
4431 {
4432 s->font_not_found_p = 1;
4433 s->font = FRAME_FONT (s->f);
4434 }
4435
4436 /* Adjust base line for subscript/superscript text. */
4437 s->ybase += s->first_glyph->voffset;
4438
4439 xassert (s->face && s->face->gc);
4440
4441 /* This glyph string must always be drawn with 16-bit functions. */
4442 s->two_byte_p = 1;
4443
4444 return s->gidx + s->nchars;
4445 }
4446
4447
4448 /* Fill glyph string S from a sequence of character glyphs.
4449
4450 FACE_ID is the face id of the string. START is the index of the
4451 first glyph to consider, END is the index of the last + 1.
4452 OVERLAPS_P non-zero means S should draw the foreground only, and
4453 use its physical height for clipping.
4454
4455 Value is the index of the first glyph not in S. */
4456
4457 static int
4458 x_fill_glyph_string (s, face_id, start, end, overlaps_p)
4459 struct glyph_string *s;
4460 int face_id;
4461 int start, end, overlaps_p;
4462 {
4463 struct glyph *glyph, *last;
4464 int voffset;
4465 int glyph_not_available_p;
4466
4467 xassert (s->f == XFRAME (s->w->frame));
4468 xassert (s->nchars == 0);
4469 xassert (start >= 0 && end > start);
4470
4471 s->for_overlaps_p = overlaps_p,
4472 glyph = s->row->glyphs[s->area] + start;
4473 last = s->row->glyphs[s->area] + end;
4474 voffset = glyph->voffset;
4475
4476 glyph_not_available_p = glyph->glyph_not_available_p;
4477
4478 while (glyph < last
4479 && glyph->type == CHAR_GLYPH
4480 && glyph->voffset == voffset
4481 /* Same face id implies same font, nowadays. */
4482 && glyph->face_id == face_id
4483 && glyph->glyph_not_available_p == glyph_not_available_p)
4484 {
4485 int two_byte_p;
4486
4487 s->face = x_get_glyph_face_and_encoding (s->f, glyph,
4488 s->char2b + s->nchars,
4489 &two_byte_p);
4490 s->two_byte_p = two_byte_p;
4491 ++s->nchars;
4492 xassert (s->nchars <= end - start);
4493 s->width += glyph->pixel_width;
4494 ++glyph;
4495 }
4496
4497 s->font = s->face->font;
4498 s->font_info = FONT_INFO_FROM_ID (s->f, s->face->font_info_id);
4499
4500 /* If the specified font could not be loaded, use the frame's font,
4501 but record the fact that we couldn't load it in
4502 S->font_not_found_p so that we can draw rectangles for the
4503 characters of the glyph string. */
4504 if (s->font == NULL || glyph_not_available_p)
4505 {
4506 s->font_not_found_p = 1;
4507 s->font = FRAME_FONT (s->f);
4508 }
4509
4510 /* Adjust base line for subscript/superscript text. */
4511 s->ybase += voffset;
4512
4513 xassert (s->face && s->face->gc);
4514 return glyph - s->row->glyphs[s->area];
4515 }
4516
4517
4518 /* Fill glyph string S from image glyph S->first_glyph. */
4519
4520 static void
4521 x_fill_image_glyph_string (s)
4522 struct glyph_string *s;
4523 {
4524 xassert (s->first_glyph->type == IMAGE_GLYPH);
4525 s->img = IMAGE_FROM_ID (s->f, s->first_glyph->u.img_id);
4526 xassert (s->img);
4527 s->face = FACE_FROM_ID (s->f, s->first_glyph->face_id);
4528 s->font = s->face->font;
4529 s->width = s->first_glyph->pixel_width;
4530
4531 /* Adjust base line for subscript/superscript text. */
4532 s->ybase += s->first_glyph->voffset;
4533 }
4534
4535
4536 /* Fill glyph string S from a sequence of stretch glyphs.
4537
4538 ROW is the glyph row in which the glyphs are found, AREA is the
4539 area within the row. START is the index of the first glyph to
4540 consider, END is the index of the last + 1.
4541
4542 Value is the index of the first glyph not in S. */
4543
4544 static int
4545 x_fill_stretch_glyph_string (s, row, area, start, end)
4546 struct glyph_string *s;
4547 struct glyph_row *row;
4548 enum glyph_row_area area;
4549 int start, end;
4550 {
4551 struct glyph *glyph, *last;
4552 int voffset, face_id;
4553
4554 xassert (s->first_glyph->type == STRETCH_GLYPH);
4555
4556 glyph = s->row->glyphs[s->area] + start;
4557 last = s->row->glyphs[s->area] + end;
4558 face_id = glyph->face_id;
4559 s->face = FACE_FROM_ID (s->f, face_id);
4560 s->font = s->face->font;
4561 s->font_info = FONT_INFO_FROM_ID (s->f, s->face->font_info_id);
4562 s->width = glyph->pixel_width;
4563 voffset = glyph->voffset;
4564
4565 for (++glyph;
4566 (glyph < last
4567 && glyph->type == STRETCH_GLYPH
4568 && glyph->voffset == voffset
4569 && glyph->face_id == face_id);
4570 ++glyph)
4571 s->width += glyph->pixel_width;
4572
4573 /* Adjust base line for subscript/superscript text. */
4574 s->ybase += voffset;
4575
4576 xassert (s->face && s->face->gc);
4577 return glyph - s->row->glyphs[s->area];
4578 }
4579
4580
4581 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
4582 of XChar2b structures for S; it can't be allocated in
4583 x_init_glyph_string because it must be allocated via `alloca'. W
4584 is the window on which S is drawn. ROW and AREA are the glyph row
4585 and area within the row from which S is constructed. START is the
4586 index of the first glyph structure covered by S. HL is a
4587 face-override for drawing S. */
4588
4589 static void
4590 x_init_glyph_string (s, char2b, w, row, area, start, hl)
4591 struct glyph_string *s;
4592 XChar2b *char2b;
4593 struct window *w;
4594 struct glyph_row *row;
4595 enum glyph_row_area area;
4596 int start;
4597 enum draw_glyphs_face hl;
4598 {
4599 bzero (s, sizeof *s);
4600 s->w = w;
4601 s->f = XFRAME (w->frame);
4602 s->display = FRAME_X_DISPLAY (s->f);
4603 s->window = FRAME_X_WINDOW (s->f);
4604 s->char2b = char2b;
4605 s->hl = hl;
4606 s->row = row;
4607 s->area = area;
4608 s->first_glyph = row->glyphs[area] + start;
4609 s->height = row->height;
4610 s->y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
4611
4612 /* Display the internal border below the tool-bar window. */
4613 if (s->w == XWINDOW (s->f->tool_bar_window))
4614 s->y -= s->f->output_data.x->internal_border_width;
4615
4616 s->ybase = s->y + row->ascent;
4617 }
4618
4619
4620 /* Set background width of glyph string S. START is the index of the
4621 first glyph following S. LAST_X is the right-most x-position + 1
4622 in the drawing area. */
4623
4624 static INLINE void
4625 x_set_glyph_string_background_width (s, start, last_x)
4626 struct glyph_string *s;
4627 int start;
4628 int last_x;
4629 {
4630 /* If the face of this glyph string has to be drawn to the end of
4631 the drawing area, set S->extends_to_end_of_line_p. */
4632 struct face *default_face = FACE_FROM_ID (s->f, DEFAULT_FACE_ID);
4633
4634 if (start == s->row->used[s->area]
4635 && s->hl == DRAW_NORMAL_TEXT
4636 && s->area == TEXT_AREA
4637 && (s->row->fill_line_p
4638 || s->face->background != default_face->background
4639 || s->face->stipple != default_face->stipple))
4640 s->extends_to_end_of_line_p = 1;
4641
4642 /* If S extends its face to the end of the line, set its
4643 background_width to the distance to the right edge of the drawing
4644 area. */
4645 if (s->extends_to_end_of_line_p)
4646 s->background_width = last_x - s->x + 1;
4647 else
4648 s->background_width = s->width;
4649 }
4650
4651
4652 /* Add a glyph string for a stretch glyph to the list of strings
4653 between HEAD and TAIL. START is the index of the stretch glyph in
4654 row area AREA of glyph row ROW. END is the index of the last glyph
4655 in that glyph row area. X is the current output position assigned
4656 to the new glyph string constructed. HL overrides that face of the
4657 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4658 is the right-most x-position of the drawing area. */
4659
4660 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
4661 and below -- keep them on one line. */
4662 #define BUILD_STRETCH_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4663 do \
4664 { \
4665 s = (struct glyph_string *) alloca (sizeof *s); \
4666 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
4667 START = x_fill_stretch_glyph_string (s, ROW, AREA, START, END); \
4668 x_append_glyph_string (&HEAD, &TAIL, s); \
4669 s->x = (X); \
4670 } \
4671 while (0)
4672
4673
4674 /* Add a glyph string for an image glyph to the list of strings
4675 between HEAD and TAIL. START is the index of the image glyph in
4676 row area AREA of glyph row ROW. END is the index of the last glyph
4677 in that glyph row area. X is the current output position assigned
4678 to the new glyph string constructed. HL overrides that face of the
4679 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4680 is the right-most x-position of the drawing area. */
4681
4682 #define BUILD_IMAGE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4683 do \
4684 { \
4685 s = (struct glyph_string *) alloca (sizeof *s); \
4686 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
4687 x_fill_image_glyph_string (s); \
4688 x_append_glyph_string (&HEAD, &TAIL, s); \
4689 ++START; \
4690 s->x = (X); \
4691 } \
4692 while (0)
4693
4694
4695 /* Add a glyph string for a sequence of character glyphs to the list
4696 of strings between HEAD and TAIL. START is the index of the first
4697 glyph in row area AREA of glyph row ROW that is part of the new
4698 glyph string. END is the index of the last glyph in that glyph row
4699 area. X is the current output position assigned to the new glyph
4700 string constructed. HL overrides that face of the glyph; e.g. it
4701 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
4702 right-most x-position of the drawing area. */
4703
4704 #define BUILD_CHAR_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4705 do \
4706 { \
4707 int c, face_id; \
4708 XChar2b *char2b; \
4709 \
4710 c = (ROW)->glyphs[AREA][START].u.ch; \
4711 face_id = (ROW)->glyphs[AREA][START].face_id; \
4712 \
4713 s = (struct glyph_string *) alloca (sizeof *s); \
4714 char2b = (XChar2b *) alloca ((END - START) * sizeof *char2b); \
4715 x_init_glyph_string (s, char2b, W, ROW, AREA, START, HL); \
4716 x_append_glyph_string (&HEAD, &TAIL, s); \
4717 s->x = (X); \
4718 START = x_fill_glyph_string (s, face_id, START, END, \
4719 OVERLAPS_P); \
4720 } \
4721 while (0)
4722
4723
4724 /* Add a glyph string for a composite sequence to the list of strings
4725 between HEAD and TAIL. START is the index of the first glyph in
4726 row area AREA of glyph row ROW that is part of the new glyph
4727 string. END is the index of the last glyph in that glyph row area.
4728 X is the current output position assigned to the new glyph string
4729 constructed. HL overrides that face of the glyph; e.g. it is
4730 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
4731 x-position of the drawing area. */
4732
4733 #define BUILD_COMPOSITE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4734 do { \
4735 int cmp_id = (ROW)->glyphs[AREA][START].u.cmp_id; \
4736 int face_id = (ROW)->glyphs[AREA][START].face_id; \
4737 struct face *base_face = FACE_FROM_ID (XFRAME (w->frame), face_id); \
4738 struct composition *cmp = composition_table[cmp_id]; \
4739 int glyph_len = cmp->glyph_len; \
4740 XChar2b *char2b; \
4741 struct face **faces; \
4742 struct glyph_string *first_s = NULL; \
4743 int n; \
4744 \
4745 base_face = base_face->ascii_face; \
4746 char2b = (XChar2b *) alloca ((sizeof *char2b) * glyph_len); \
4747 faces = (struct face **) alloca ((sizeof *faces) * glyph_len); \
4748 /* At first, fill in `char2b' and `faces'. */ \
4749 for (n = 0; n < glyph_len; n++) \
4750 { \
4751 int c = COMPOSITION_GLYPH (cmp, n); \
4752 int this_face_id = FACE_FOR_CHAR (XFRAME (w->frame), base_face, c); \
4753 faces[n] = FACE_FROM_ID (XFRAME (w->frame), this_face_id); \
4754 x_get_char_face_and_encoding (XFRAME (w->frame), c, \
4755 this_face_id, char2b + n, 1); \
4756 } \
4757 \
4758 /* Make glyph_strings for each glyph sequence that is drawable by \
4759 the same face, and append them to HEAD/TAIL. */ \
4760 for (n = 0; n < cmp->glyph_len;) \
4761 { \
4762 s = (struct glyph_string *) alloca (sizeof *s); \
4763 x_init_glyph_string (s, char2b + n, W, ROW, AREA, START, HL); \
4764 x_append_glyph_string (&(HEAD), &(TAIL), s); \
4765 s->cmp = cmp; \
4766 s->gidx = n; \
4767 s->x = (X); \
4768 \
4769 if (n == 0) \
4770 first_s = s; \
4771 \
4772 n = x_fill_composite_glyph_string (s, faces, OVERLAPS_P); \
4773 } \
4774 \
4775 ++START; \
4776 s = first_s; \
4777 } while (0)
4778
4779
4780 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
4781 of AREA of glyph row ROW on window W between indices START and END.
4782 HL overrides the face for drawing glyph strings, e.g. it is
4783 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
4784 x-positions of the drawing area.
4785
4786 This is an ugly monster macro construct because we must use alloca
4787 to allocate glyph strings (because x_draw_glyphs can be called
4788 asynchronously). */
4789
4790 #define BUILD_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
4791 do \
4792 { \
4793 HEAD = TAIL = NULL; \
4794 while (START < END) \
4795 { \
4796 struct glyph *first_glyph = (ROW)->glyphs[AREA] + START; \
4797 switch (first_glyph->type) \
4798 { \
4799 case CHAR_GLYPH: \
4800 BUILD_CHAR_GLYPH_STRINGS (W, ROW, AREA, START, END, HEAD, \
4801 TAIL, HL, X, LAST_X, \
4802 OVERLAPS_P); \
4803 break; \
4804 \
4805 case COMPOSITE_GLYPH: \
4806 BUILD_COMPOSITE_GLYPH_STRING (W, ROW, AREA, START, END, \
4807 HEAD, TAIL, HL, X, LAST_X,\
4808 OVERLAPS_P); \
4809 break; \
4810 \
4811 case STRETCH_GLYPH: \
4812 BUILD_STRETCH_GLYPH_STRING (W, ROW, AREA, START, END, \
4813 HEAD, TAIL, HL, X, LAST_X); \
4814 break; \
4815 \
4816 case IMAGE_GLYPH: \
4817 BUILD_IMAGE_GLYPH_STRING (W, ROW, AREA, START, END, HEAD, \
4818 TAIL, HL, X, LAST_X); \
4819 break; \
4820 \
4821 default: \
4822 abort (); \
4823 } \
4824 \
4825 x_set_glyph_string_background_width (s, START, LAST_X); \
4826 (X) += s->width; \
4827 } \
4828 } \
4829 while (0)
4830
4831
4832 /* Draw glyphs between START and END in AREA of ROW on window W,
4833 starting at x-position X. X is relative to AREA in W. HL is a
4834 face-override with the following meaning:
4835
4836 DRAW_NORMAL_TEXT draw normally
4837 DRAW_CURSOR draw in cursor face
4838 DRAW_MOUSE_FACE draw in mouse face.
4839 DRAW_INVERSE_VIDEO draw in mode line face
4840 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
4841 DRAW_IMAGE_RAISED draw an image with a raised relief around it
4842
4843 If REAL_START is non-null, return in *REAL_START the real starting
4844 position for display. This can be different from START in case
4845 overlapping glyphs must be displayed. If REAL_END is non-null,
4846 return in *REAL_END the real end position for display. This can be
4847 different from END in case overlapping glyphs must be displayed.
4848
4849 If OVERLAPS_P is non-zero, draw only the foreground of characters
4850 and clip to the physical height of ROW.
4851
4852 Value is the x-position reached, relative to AREA of W. */
4853
4854 static int
4855 x_draw_glyphs (w, x, row, area, start, end, hl, real_start, real_end,
4856 overlaps_p)
4857 struct window *w;
4858 int x;
4859 struct glyph_row *row;
4860 enum glyph_row_area area;
4861 int start, end;
4862 enum draw_glyphs_face hl;
4863 int *real_start, *real_end;
4864 int overlaps_p;
4865 {
4866 struct glyph_string *head, *tail;
4867 struct glyph_string *s;
4868 int last_x, area_width;
4869 int x_reached;
4870 int i, j;
4871
4872 /* Let's rather be paranoid than getting a SEGV. */
4873 end = min (end, row->used[area]);
4874 start = max (0, start);
4875 start = min (end, start);
4876 if (real_start)
4877 *real_start = start;
4878 if (real_end)
4879 *real_end = end;
4880
4881 /* Translate X to frame coordinates. Set last_x to the right
4882 end of the drawing area. */
4883 if (row->full_width_p)
4884 {
4885 /* X is relative to the left edge of W, without scroll bars
4886 or flag areas. */
4887 struct frame *f = XFRAME (w->frame);
4888 /* int width = FRAME_FLAGS_AREA_WIDTH (f); */
4889 int window_left_x = WINDOW_LEFT_MARGIN (w) * CANON_X_UNIT (f);
4890
4891 x += window_left_x;
4892 area_width = XFASTINT (w->width) * CANON_X_UNIT (f);
4893 last_x = window_left_x + area_width;
4894
4895 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
4896 {
4897 int width = FRAME_SCROLL_BAR_WIDTH (f) * CANON_X_UNIT (f);
4898 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
4899 last_x += width;
4900 else
4901 x -= width;
4902 }
4903
4904 x += FRAME_INTERNAL_BORDER_WIDTH (f);
4905 last_x -= FRAME_INTERNAL_BORDER_WIDTH (f);
4906 }
4907 else
4908 {
4909 x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, area, x);
4910 area_width = window_box_width (w, area);
4911 last_x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, area, area_width);
4912 }
4913
4914 /* Build a doubly-linked list of glyph_string structures between
4915 head and tail from what we have to draw. Note that the macro
4916 BUILD_GLYPH_STRINGS will modify its start parameter. That's
4917 the reason we use a separate variable `i'. */
4918 i = start;
4919 BUILD_GLYPH_STRINGS (w, row, area, i, end, head, tail, hl, x, last_x,
4920 overlaps_p);
4921 if (tail)
4922 x_reached = tail->x + tail->background_width;
4923 else
4924 x_reached = x;
4925
4926 /* If there are any glyphs with lbearing < 0 or rbearing > width in
4927 the row, redraw some glyphs in front or following the glyph
4928 strings built above. */
4929 if (head && !overlaps_p && row->contains_overlapping_glyphs_p)
4930 {
4931 int dummy_x = 0;
4932 struct glyph_string *h, *t;
4933
4934 /* Compute overhangs for all glyph strings. */
4935 for (s = head; s; s = s->next)
4936 x_compute_glyph_string_overhangs (s);
4937
4938 /* Prepend glyph strings for glyphs in front of the first glyph
4939 string that are overwritten because of the first glyph
4940 string's left overhang. The background of all strings
4941 prepended must be drawn because the first glyph string
4942 draws over it. */
4943 i = x_left_overwritten (head);
4944 if (i >= 0)
4945 {
4946 j = i;
4947 BUILD_GLYPH_STRINGS (w, row, area, j, start, h, t,
4948 DRAW_NORMAL_TEXT, dummy_x, last_x,
4949 overlaps_p);
4950 start = i;
4951 if (real_start)
4952 *real_start = start;
4953 x_compute_overhangs_and_x (t, head->x, 1);
4954 x_prepend_glyph_string_lists (&head, &tail, h, t);
4955 }
4956
4957 /* Prepend glyph strings for glyphs in front of the first glyph
4958 string that overwrite that glyph string because of their
4959 right overhang. For these strings, only the foreground must
4960 be drawn, because it draws over the glyph string at `head'.
4961 The background must not be drawn because this would overwrite
4962 right overhangs of preceding glyphs for which no glyph
4963 strings exist. */
4964 i = x_left_overwriting (head);
4965 if (i >= 0)
4966 {
4967 BUILD_GLYPH_STRINGS (w, row, area, i, start, h, t,
4968 DRAW_NORMAL_TEXT, dummy_x, last_x,
4969 overlaps_p);
4970 for (s = h; s; s = s->next)
4971 s->background_filled_p = 1;
4972 if (real_start)
4973 *real_start = i;
4974 x_compute_overhangs_and_x (t, head->x, 1);
4975 x_prepend_glyph_string_lists (&head, &tail, h, t);
4976 }
4977
4978 /* Append glyphs strings for glyphs following the last glyph
4979 string tail that are overwritten by tail. The background of
4980 these strings has to be drawn because tail's foreground draws
4981 over it. */
4982 i = x_right_overwritten (tail);
4983 if (i >= 0)
4984 {
4985 BUILD_GLYPH_STRINGS (w, row, area, end, i, h, t,
4986 DRAW_NORMAL_TEXT, x, last_x,
4987 overlaps_p);
4988 x_compute_overhangs_and_x (h, tail->x + tail->width, 0);
4989 x_append_glyph_string_lists (&head, &tail, h, t);
4990 if (real_end)
4991 *real_end = i;
4992 }
4993
4994 /* Append glyph strings for glyphs following the last glyph
4995 string tail that overwrite tail. The foreground of such
4996 glyphs has to be drawn because it writes into the background
4997 of tail. The background must not be drawn because it could
4998 paint over the foreground of following glyphs. */
4999 i = x_right_overwriting (tail);
5000 if (i >= 0)
5001 {
5002 BUILD_GLYPH_STRINGS (w, row, area, end, i, h, t,
5003 DRAW_NORMAL_TEXT, x, last_x,
5004 overlaps_p);
5005 for (s = h; s; s = s->next)
5006 s->background_filled_p = 1;
5007 x_compute_overhangs_and_x (h, tail->x + tail->width, 0);
5008 x_append_glyph_string_lists (&head, &tail, h, t);
5009 if (real_end)
5010 *real_end = i;
5011 }
5012 }
5013
5014 /* Draw all strings. */
5015 for (s = head; s; s = s->next)
5016 x_draw_glyph_string (s);
5017
5018 /* Value is the x-position up to which drawn, relative to AREA of W.
5019 This doesn't include parts drawn because of overhangs. */
5020 x_reached = FRAME_TO_WINDOW_PIXEL_X (w, x_reached);
5021 if (!row->full_width_p)
5022 {
5023 if (area > LEFT_MARGIN_AREA)
5024 x_reached -= window_box_width (w, LEFT_MARGIN_AREA);
5025 if (area > TEXT_AREA)
5026 x_reached -= window_box_width (w, TEXT_AREA);
5027 }
5028
5029 return x_reached;
5030 }
5031
5032
5033 /* Fix the display of area AREA of overlapping row ROW in window W. */
5034
5035 static void
5036 x_fix_overlapping_area (w, row, area)
5037 struct window *w;
5038 struct glyph_row *row;
5039 enum glyph_row_area area;
5040 {
5041 int i, x;
5042
5043 BLOCK_INPUT;
5044
5045 if (area == LEFT_MARGIN_AREA)
5046 x = 0;
5047 else if (area == TEXT_AREA)
5048 x = row->x + window_box_width (w, LEFT_MARGIN_AREA);
5049 else
5050 x = (window_box_width (w, LEFT_MARGIN_AREA)
5051 + window_box_width (w, TEXT_AREA));
5052
5053 for (i = 0; i < row->used[area];)
5054 {
5055 if (row->glyphs[area][i].overlaps_vertically_p)
5056 {
5057 int start = i, start_x = x;
5058
5059 do
5060 {
5061 x += row->glyphs[area][i].pixel_width;
5062 ++i;
5063 }
5064 while (i < row->used[area]
5065 && row->glyphs[area][i].overlaps_vertically_p);
5066
5067 x_draw_glyphs (w, start_x, row, area, start, i,
5068 (row->inverse_p
5069 ? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT),
5070 NULL, NULL, 1);
5071 }
5072 else
5073 {
5074 x += row->glyphs[area][i].pixel_width;
5075 ++i;
5076 }
5077 }
5078
5079 UNBLOCK_INPUT;
5080 }
5081
5082
5083 /* Output LEN glyphs starting at START at the nominal cursor position.
5084 Advance the nominal cursor over the text. The global variable
5085 updated_window contains the window being updated, updated_row is
5086 the glyph row being updated, and updated_area is the area of that
5087 row being updated. */
5088
5089 static void
5090 x_write_glyphs (start, len)
5091 struct glyph *start;
5092 int len;
5093 {
5094 int x, hpos, real_start, real_end;
5095
5096 xassert (updated_window && updated_row);
5097 BLOCK_INPUT;
5098
5099 /* Write glyphs. */
5100
5101 hpos = start - updated_row->glyphs[updated_area];
5102 x = x_draw_glyphs (updated_window, output_cursor.x,
5103 updated_row, updated_area,
5104 hpos, hpos + len,
5105 (updated_row->inverse_p
5106 ? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT),
5107 &real_start, &real_end, 0);
5108
5109 /* If we drew over the cursor, note that it is not visible any more. */
5110 note_overwritten_text_cursor (updated_window, real_start,
5111 real_end - real_start);
5112
5113 UNBLOCK_INPUT;
5114
5115 /* Advance the output cursor. */
5116 output_cursor.hpos += len;
5117 output_cursor.x = x;
5118 }
5119
5120
5121 /* Insert LEN glyphs from START at the nominal cursor position. */
5122
5123 static void
5124 x_insert_glyphs (start, len)
5125 struct glyph *start;
5126 register int len;
5127 {
5128 struct frame *f;
5129 struct window *w;
5130 int line_height, shift_by_width, shifted_region_width;
5131 struct glyph_row *row;
5132 struct glyph *glyph;
5133 int frame_x, frame_y, hpos, real_start, real_end;
5134
5135 xassert (updated_window && updated_row);
5136 BLOCK_INPUT;
5137 w = updated_window;
5138 f = XFRAME (WINDOW_FRAME (w));
5139
5140 /* Get the height of the line we are in. */
5141 row = updated_row;
5142 line_height = row->height;
5143
5144 /* Get the width of the glyphs to insert. */
5145 shift_by_width = 0;
5146 for (glyph = start; glyph < start + len; ++glyph)
5147 shift_by_width += glyph->pixel_width;
5148
5149 /* Get the width of the region to shift right. */
5150 shifted_region_width = (window_box_width (w, updated_area)
5151 - output_cursor.x
5152 - shift_by_width);
5153
5154 /* Shift right. */
5155 frame_x = window_box_left (w, updated_area) + output_cursor.x;
5156 frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, output_cursor.y);
5157 XCopyArea (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), FRAME_X_WINDOW (f),
5158 f->output_data.x->normal_gc,
5159 frame_x, frame_y,
5160 shifted_region_width, line_height,
5161 frame_x + shift_by_width, frame_y);
5162
5163 /* Write the glyphs. */
5164 hpos = start - row->glyphs[updated_area];
5165 x_draw_glyphs (w, output_cursor.x, row, updated_area, hpos, hpos + len,
5166 DRAW_NORMAL_TEXT, &real_start, &real_end, 0);
5167 note_overwritten_text_cursor (w, real_start, real_end - real_start);
5168
5169 /* Advance the output cursor. */
5170 output_cursor.hpos += len;
5171 output_cursor.x += shift_by_width;
5172 UNBLOCK_INPUT;
5173 }
5174
5175
5176 /* Delete N glyphs at the nominal cursor position. Not implemented
5177 for X frames. */
5178
5179 static void
5180 x_delete_glyphs (n)
5181 register int n;
5182 {
5183 abort ();
5184 }
5185
5186
5187 /* Like XClearArea, but check that WIDTH and HEIGHT are reasonable.
5188 If they are <= 0, this is probably an error. */
5189
5190 void
5191 x_clear_area (dpy, window, x, y, width, height, exposures)
5192 Display *dpy;
5193 Window window;
5194 int x, y;
5195 int width, height;
5196 int exposures;
5197 {
5198 xassert (width > 0 && height > 0);
5199 XClearArea (dpy, window, x, y, width, height, exposures);
5200 }
5201
5202
5203 /* Erase the current text line from the nominal cursor position
5204 (inclusive) to pixel column TO_X (exclusive). The idea is that
5205 everything from TO_X onward is already erased.
5206
5207 TO_X is a pixel position relative to updated_area of
5208 updated_window. TO_X == -1 means clear to the end of this area. */
5209
5210 static void
5211 x_clear_end_of_line (to_x)
5212 int to_x;
5213 {
5214 struct frame *f;
5215 struct window *w = updated_window;
5216 int max_x, min_y, max_y;
5217 int from_x, from_y, to_y;
5218
5219 xassert (updated_window && updated_row);
5220 f = XFRAME (w->frame);
5221
5222 if (updated_row->full_width_p)
5223 {
5224 max_x = XFASTINT (w->width) * CANON_X_UNIT (f);
5225 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f)
5226 && !w->pseudo_window_p)
5227 max_x += FRAME_SCROLL_BAR_WIDTH (f) * CANON_X_UNIT (f);
5228 }
5229 else
5230 max_x = window_box_width (w, updated_area);
5231 max_y = window_text_bottom_y (w);
5232
5233 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
5234 of window. For TO_X > 0, truncate to end of drawing area. */
5235 if (to_x == 0)
5236 return;
5237 else if (to_x < 0)
5238 to_x = max_x;
5239 else
5240 to_x = min (to_x, max_x);
5241
5242 to_y = min (max_y, output_cursor.y + updated_row->height);
5243
5244 /* Notice if the cursor will be cleared by this operation. */
5245 if (!updated_row->full_width_p)
5246 note_overwritten_text_cursor (w, output_cursor.hpos, -1);
5247
5248 from_x = output_cursor.x;
5249
5250 /* Translate to frame coordinates. */
5251 if (updated_row->full_width_p)
5252 {
5253 from_x = WINDOW_TO_FRAME_PIXEL_X (w, from_x);
5254 to_x = WINDOW_TO_FRAME_PIXEL_X (w, to_x);
5255 }
5256 else
5257 {
5258 from_x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, updated_area, from_x);
5259 to_x = WINDOW_AREA_TO_FRAME_PIXEL_X (w, updated_area, to_x);
5260 }
5261
5262 min_y = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
5263 from_y = WINDOW_TO_FRAME_PIXEL_Y (w, max (min_y, output_cursor.y));
5264 to_y = WINDOW_TO_FRAME_PIXEL_Y (w, to_y);
5265
5266 /* Prevent inadvertently clearing to end of the X window. */
5267 if (to_x > from_x && to_y > from_y)
5268 {
5269 BLOCK_INPUT;
5270 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
5271 from_x, from_y, to_x - from_x, to_y - from_y,
5272 False);
5273 UNBLOCK_INPUT;
5274 }
5275 }
5276
5277
5278 /* Clear entire frame. If updating_frame is non-null, clear that
5279 frame. Otherwise clear the selected frame. */
5280
5281 static void
5282 x_clear_frame ()
5283 {
5284 struct frame *f;
5285
5286 if (updating_frame)
5287 f = updating_frame;
5288 else
5289 f = SELECTED_FRAME ();
5290
5291 /* Clearing the frame will erase any cursor, so mark them all as no
5292 longer visible. */
5293 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f)));
5294 output_cursor.hpos = output_cursor.vpos = 0;
5295 output_cursor.x = -1;
5296
5297 /* We don't set the output cursor here because there will always
5298 follow an explicit cursor_to. */
5299 BLOCK_INPUT;
5300 XClearWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
5301
5302 /* We have to clear the scroll bars, too. If we have changed
5303 colors or something like that, then they should be notified. */
5304 x_scroll_bar_clear (f);
5305
5306 XFlush (FRAME_X_DISPLAY (f));
5307 UNBLOCK_INPUT;
5308 }
5309
5310
5311 \f
5312 /* Invert the middle quarter of the frame for .15 sec. */
5313
5314 /* We use the select system call to do the waiting, so we have to make
5315 sure it's available. If it isn't, we just won't do visual bells. */
5316
5317 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
5318
5319
5320 /* Subtract the `struct timeval' values X and Y, storing the result in
5321 *RESULT. Return 1 if the difference is negative, otherwise 0. */
5322
5323 static int
5324 timeval_subtract (result, x, y)
5325 struct timeval *result, x, y;
5326 {
5327 /* Perform the carry for the later subtraction by updating y. This
5328 is safer because on some systems the tv_sec member is unsigned. */
5329 if (x.tv_usec < y.tv_usec)
5330 {
5331 int nsec = (y.tv_usec - x.tv_usec) / 1000000 + 1;
5332 y.tv_usec -= 1000000 * nsec;
5333 y.tv_sec += nsec;
5334 }
5335
5336 if (x.tv_usec - y.tv_usec > 1000000)
5337 {
5338 int nsec = (y.tv_usec - x.tv_usec) / 1000000;
5339 y.tv_usec += 1000000 * nsec;
5340 y.tv_sec -= nsec;
5341 }
5342
5343 /* Compute the time remaining to wait. tv_usec is certainly
5344 positive. */
5345 result->tv_sec = x.tv_sec - y.tv_sec;
5346 result->tv_usec = x.tv_usec - y.tv_usec;
5347
5348 /* Return indication of whether the result should be considered
5349 negative. */
5350 return x.tv_sec < y.tv_sec;
5351 }
5352
5353 void
5354 XTflash (f)
5355 struct frame *f;
5356 {
5357 BLOCK_INPUT;
5358
5359 {
5360 GC gc;
5361
5362 /* Create a GC that will use the GXxor function to flip foreground
5363 pixels into background pixels. */
5364 {
5365 XGCValues values;
5366
5367 values.function = GXxor;
5368 values.foreground = (f->output_data.x->foreground_pixel
5369 ^ f->output_data.x->background_pixel);
5370
5371 gc = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
5372 GCFunction | GCForeground, &values);
5373 }
5374
5375 {
5376 /* Get the height not including a menu bar widget. */
5377 int height = CHAR_TO_PIXEL_HEIGHT (f, FRAME_HEIGHT (f));
5378 /* Height of each line to flash. */
5379 int flash_height = FRAME_LINE_HEIGHT (f);
5380 /* These will be the left and right margins of the rectangles. */
5381 int flash_left = FRAME_INTERNAL_BORDER_WIDTH (f);
5382 int flash_right = PIXEL_WIDTH (f) - FRAME_INTERNAL_BORDER_WIDTH (f);
5383
5384 int width;
5385
5386 /* Don't flash the area between a scroll bar and the frame
5387 edge it is next to. */
5388 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f))
5389 {
5390 case vertical_scroll_bar_left:
5391 flash_left += VERTICAL_SCROLL_BAR_WIDTH_TRIM;
5392 break;
5393
5394 case vertical_scroll_bar_right:
5395 flash_right -= VERTICAL_SCROLL_BAR_WIDTH_TRIM;
5396 break;
5397
5398 default:
5399 break;
5400 }
5401
5402 width = flash_right - flash_left;
5403
5404 /* If window is tall, flash top and bottom line. */
5405 if (height > 3 * FRAME_LINE_HEIGHT (f))
5406 {
5407 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
5408 flash_left,
5409 (FRAME_INTERNAL_BORDER_WIDTH (f)
5410 + FRAME_TOOL_BAR_LINES (f) * CANON_Y_UNIT (f)),
5411 width, flash_height);
5412 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
5413 flash_left,
5414 (height - flash_height
5415 - FRAME_INTERNAL_BORDER_WIDTH (f)),
5416 width, flash_height);
5417 }
5418 else
5419 /* If it is short, flash it all. */
5420 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
5421 flash_left, FRAME_INTERNAL_BORDER_WIDTH (f),
5422 width, height - 2 * FRAME_INTERNAL_BORDER_WIDTH (f));
5423
5424 x_flush (f);
5425
5426 {
5427 struct timeval wakeup;
5428
5429 EMACS_GET_TIME (wakeup);
5430
5431 /* Compute time to wait until, propagating carry from usecs. */
5432 wakeup.tv_usec += 150000;
5433 wakeup.tv_sec += (wakeup.tv_usec / 1000000);
5434 wakeup.tv_usec %= 1000000;
5435
5436 /* Keep waiting until past the time wakeup. */
5437 while (1)
5438 {
5439 struct timeval timeout;
5440
5441 EMACS_GET_TIME (timeout);
5442
5443 /* In effect, timeout = wakeup - timeout.
5444 Break if result would be negative. */
5445 if (timeval_subtract (&timeout, wakeup, timeout))
5446 break;
5447
5448 /* Try to wait that long--but we might wake up sooner. */
5449 select (0, NULL, NULL, NULL, &timeout);
5450 }
5451 }
5452
5453 /* If window is tall, flash top and bottom line. */
5454 if (height > 3 * FRAME_LINE_HEIGHT (f))
5455 {
5456 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
5457 flash_left,
5458 (FRAME_INTERNAL_BORDER_WIDTH (f)
5459 + FRAME_TOOL_BAR_LINES (f) * CANON_Y_UNIT (f)),
5460 width, flash_height);
5461 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
5462 flash_left,
5463 (height - flash_height
5464 - FRAME_INTERNAL_BORDER_WIDTH (f)),
5465 width, flash_height);
5466 }
5467 else
5468 /* If it is short, flash it all. */
5469 XFillRectangle (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), gc,
5470 flash_left, FRAME_INTERNAL_BORDER_WIDTH (f),
5471 width, height - 2 * FRAME_INTERNAL_BORDER_WIDTH (f));
5472
5473 XFreeGC (FRAME_X_DISPLAY (f), gc);
5474 x_flush (f);
5475 }
5476 }
5477
5478 UNBLOCK_INPUT;
5479 }
5480
5481 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
5482
5483
5484 /* Make audible bell. */
5485
5486 void
5487 XTring_bell ()
5488 {
5489 struct frame *f = SELECTED_FRAME ();
5490
5491 if (FRAME_X_DISPLAY (f))
5492 {
5493 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
5494 if (visible_bell)
5495 XTflash (f);
5496 else
5497 #endif
5498 {
5499 BLOCK_INPUT;
5500 XBell (FRAME_X_DISPLAY (f), 0);
5501 XFlush (FRAME_X_DISPLAY (f));
5502 UNBLOCK_INPUT;
5503 }
5504 }
5505 }
5506
5507 \f
5508 /* Specify how many text lines, from the top of the window,
5509 should be affected by insert-lines and delete-lines operations.
5510 This, and those operations, are used only within an update
5511 that is bounded by calls to x_update_begin and x_update_end. */
5512
5513 static void
5514 XTset_terminal_window (n)
5515 register int n;
5516 {
5517 /* This function intentionally left blank. */
5518 }
5519
5520
5521 \f
5522 /***********************************************************************
5523 Line Dance
5524 ***********************************************************************/
5525
5526 /* Perform an insert-lines or delete-lines operation, inserting N
5527 lines or deleting -N lines at vertical position VPOS. */
5528
5529 static void
5530 x_ins_del_lines (vpos, n)
5531 int vpos, n;
5532 {
5533 abort ();
5534 }
5535
5536
5537 /* Scroll part of the display as described by RUN. */
5538
5539 static void
5540 x_scroll_run (w, run)
5541 struct window *w;
5542 struct run *run;
5543 {
5544 struct frame *f = XFRAME (w->frame);
5545 int x, y, width, height, from_y, to_y, bottom_y;
5546
5547 /* Get frame-relative bounding box of the text display area of W,
5548 without mode lines. Include in this box the flags areas to the
5549 left and right of W. */
5550 window_box (w, -1, &x, &y, &width, &height);
5551 width += FRAME_X_FLAGS_AREA_WIDTH (f);
5552 x -= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f);
5553
5554 from_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->current_y);
5555 to_y = WINDOW_TO_FRAME_PIXEL_Y (w, run->desired_y);
5556 bottom_y = y + height;
5557
5558 if (to_y < from_y)
5559 {
5560 /* Scrolling up. Make sure we don't copy part of the mode
5561 line at the bottom. */
5562 if (from_y + run->height > bottom_y)
5563 height = bottom_y - from_y;
5564 else
5565 height = run->height;
5566 }
5567 else
5568 {
5569 /* Scolling down. Make sure we don't copy over the mode line.
5570 at the bottom. */
5571 if (to_y + run->height > bottom_y)
5572 height = bottom_y - to_y;
5573 else
5574 height = run->height;
5575 }
5576
5577 BLOCK_INPUT;
5578
5579 /* Cursor off. Will be switched on again in x_update_window_end. */
5580 updated_window = w;
5581 x_clear_cursor (w);
5582
5583 XCopyArea (FRAME_X_DISPLAY (f),
5584 FRAME_X_WINDOW (f), FRAME_X_WINDOW (f),
5585 f->output_data.x->normal_gc,
5586 x, from_y,
5587 width, height,
5588 x, to_y);
5589
5590 UNBLOCK_INPUT;
5591 }
5592
5593
5594 \f
5595 /***********************************************************************
5596 Exposure Events
5597 ***********************************************************************/
5598
5599 /* Redisplay an exposed area of frame F. X and Y are the upper-left
5600 corner of the exposed rectangle. W and H are width and height of
5601 the exposed area. All are pixel values. W or H zero means redraw
5602 the entire frame. */
5603
5604 static void
5605 expose_frame (f, x, y, w, h)
5606 struct frame *f;
5607 int x, y, w, h;
5608 {
5609 XRectangle r;
5610
5611 TRACE ((stderr, "expose_frame "));
5612
5613 /* No need to redraw if frame will be redrawn soon. */
5614 if (FRAME_GARBAGED_P (f))
5615 {
5616 TRACE ((stderr, " garbaged\n"));
5617 return;
5618 }
5619
5620 /* If basic faces haven't been realized yet, there is no point in
5621 trying to redraw anything. This can happen when we get an expose
5622 event while Emacs is starting, e.g. by moving another window. */
5623 if (FRAME_FACE_CACHE (f) == NULL
5624 || FRAME_FACE_CACHE (f)->used < BASIC_FACE_ID_SENTINEL)
5625 {
5626 TRACE ((stderr, " no faces\n"));
5627 return;
5628 }
5629
5630 if (w == 0 || h == 0)
5631 {
5632 r.x = r.y = 0;
5633 r.width = CANON_X_UNIT (f) * f->width;
5634 r.height = CANON_Y_UNIT (f) * f->height;
5635 }
5636 else
5637 {
5638 r.x = x;
5639 r.y = y;
5640 r.width = w;
5641 r.height = h;
5642 }
5643
5644 TRACE ((stderr, "(%d, %d, %d, %d)\n", r.x, r.y, r.width, r.height));
5645 expose_window_tree (XWINDOW (f->root_window), &r);
5646
5647 if (WINDOWP (f->tool_bar_window))
5648 {
5649 struct window *w = XWINDOW (f->tool_bar_window);
5650 XRectangle window_rect;
5651 XRectangle intersection_rect;
5652 int window_x, window_y, window_width, window_height;
5653
5654
5655 window_box (w, -1, &window_x, &window_y, &window_width, &window_height);
5656 window_rect.x = window_x;
5657 window_rect.y = window_y;
5658 window_rect.width = window_width;
5659 window_rect.height = window_height;
5660
5661 if (x_intersect_rectangles (&r, &window_rect, &intersection_rect))
5662 expose_window (w, &intersection_rect);
5663 }
5664
5665 #ifndef USE_X_TOOLKIT
5666 if (WINDOWP (f->menu_bar_window))
5667 {
5668 struct window *w = XWINDOW (f->menu_bar_window);
5669 XRectangle window_rect;
5670 XRectangle intersection_rect;
5671 int window_x, window_y, window_width, window_height;
5672
5673
5674 window_box (w, -1, &window_x, &window_y, &window_width, &window_height);
5675 window_rect.x = window_x;
5676 window_rect.y = window_y;
5677 window_rect.width = window_width;
5678 window_rect.height = window_height;
5679
5680 if (x_intersect_rectangles (&r, &window_rect, &intersection_rect))
5681 expose_window (w, &intersection_rect);
5682 }
5683 #endif /* not USE_X_TOOLKIT */
5684 }
5685
5686
5687 /* Redraw (parts) of all windows in the window tree rooted at W that
5688 intersect R. R contains frame pixel coordinates. */
5689
5690 static void
5691 expose_window_tree (w, r)
5692 struct window *w;
5693 XRectangle *r;
5694 {
5695 while (w)
5696 {
5697 if (!NILP (w->hchild))
5698 expose_window_tree (XWINDOW (w->hchild), r);
5699 else if (!NILP (w->vchild))
5700 expose_window_tree (XWINDOW (w->vchild), r);
5701 else
5702 {
5703 XRectangle window_rect;
5704 XRectangle intersection_rect;
5705 struct frame *f = XFRAME (w->frame);
5706 int window_x, window_y, window_width, window_height;
5707
5708 /* Frame-relative pixel rectangle of W. */
5709 window_box (w, -1, &window_x, &window_y, &window_width,
5710 &window_height);
5711 window_rect.x
5712 = (window_x
5713 - FRAME_X_LEFT_FLAGS_AREA_WIDTH (f)
5714 - FRAME_LEFT_SCROLL_BAR_WIDTH (f) * CANON_X_UNIT (f));
5715 window_rect.y = window_y;
5716 window_rect.width
5717 = (window_width
5718 + FRAME_X_FLAGS_AREA_WIDTH (f)
5719 + FRAME_SCROLL_BAR_WIDTH (f) * CANON_X_UNIT (f));
5720 window_rect.height
5721 = window_height + CURRENT_MODE_LINE_HEIGHT (w);
5722
5723 if (x_intersect_rectangles (r, &window_rect, &intersection_rect))
5724 expose_window (w, &intersection_rect);
5725 }
5726
5727 w = NILP (w->next) ? 0 : XWINDOW (w->next);
5728 }
5729 }
5730
5731
5732 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
5733 which intersects rectangle R. R is in window-relative coordinates. */
5734
5735 static void
5736 expose_area (w, row, r, area)
5737 struct window *w;
5738 struct glyph_row *row;
5739 XRectangle *r;
5740 enum glyph_row_area area;
5741 {
5742 struct glyph *first = row->glyphs[area];
5743 struct glyph *end = row->glyphs[area] + row->used[area];
5744 struct glyph *last;
5745 int first_x, start_x, x;
5746
5747 if (area == TEXT_AREA && row->fill_line_p)
5748 /* If row extends face to end of line write the whole line. */
5749 x_draw_glyphs (w, 0, row, area,
5750 0, row->used[area],
5751 row->inverse_p ? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT,
5752 NULL, NULL, 0);
5753 else
5754 {
5755 /* Set START_X to the window-relative start position for drawing glyphs of
5756 AREA. The first glyph of the text area can be partially visible.
5757 The first glyphs of other areas cannot. */
5758 if (area == LEFT_MARGIN_AREA)
5759 start_x = 0;
5760 else if (area == TEXT_AREA)
5761 start_x = row->x + window_box_width (w, LEFT_MARGIN_AREA);
5762 else
5763 start_x = (window_box_width (w, LEFT_MARGIN_AREA)
5764 + window_box_width (w, TEXT_AREA));
5765 x = start_x;
5766
5767 /* Find the first glyph that must be redrawn. */
5768 while (first < end
5769 && x + first->pixel_width < r->x)
5770 {
5771 x += first->pixel_width;
5772 ++first;
5773 }
5774
5775 /* Find the last one. */
5776 last = first;
5777 first_x = x;
5778 while (last < end
5779 && x < r->x + r->width)
5780 {
5781 x += last->pixel_width;
5782 ++last;
5783 }
5784
5785 /* Repaint. */
5786 if (last > first)
5787 x_draw_glyphs (w, first_x - start_x, row, area,
5788 first - row->glyphs[area],
5789 last - row->glyphs[area],
5790 row->inverse_p ? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT,
5791 NULL, NULL, 0);
5792 }
5793 }
5794
5795
5796 /* Redraw the parts of the glyph row ROW on window W intersecting
5797 rectangle R. R is in window-relative coordinates. */
5798
5799 static void
5800 expose_line (w, row, r)
5801 struct window *w;
5802 struct glyph_row *row;
5803 XRectangle *r;
5804 {
5805 xassert (row->enabled_p);
5806
5807 if (row->mode_line_p || w->pseudo_window_p)
5808 x_draw_glyphs (w, 0, row, TEXT_AREA, 0, row->used[TEXT_AREA],
5809 row->inverse_p ? DRAW_INVERSE_VIDEO : DRAW_NORMAL_TEXT,
5810 NULL, NULL, 0);
5811 else
5812 {
5813 if (row->used[LEFT_MARGIN_AREA])
5814 expose_area (w, row, r, LEFT_MARGIN_AREA);
5815 if (row->used[TEXT_AREA])
5816 expose_area (w, row, r, TEXT_AREA);
5817 if (row->used[RIGHT_MARGIN_AREA])
5818 expose_area (w, row, r, RIGHT_MARGIN_AREA);
5819 x_draw_row_bitmaps (w, row);
5820 }
5821 }
5822
5823
5824 /* Return non-zero if W's cursor intersects rectangle R. */
5825
5826 static int
5827 x_phys_cursor_in_rect_p (w, r)
5828 struct window *w;
5829 XRectangle *r;
5830 {
5831 XRectangle cr, result;
5832 struct glyph *cursor_glyph;
5833
5834 cursor_glyph = get_phys_cursor_glyph (w);
5835 if (cursor_glyph)
5836 {
5837 cr.x = w->phys_cursor.x;
5838 cr.y = w->phys_cursor.y;
5839 cr.width = cursor_glyph->pixel_width;
5840 cr.height = w->phys_cursor_height;
5841 return x_intersect_rectangles (&cr, r, &result);
5842 }
5843 else
5844 return 0;
5845 }
5846
5847
5848 /* Redraw a rectangle of window W. R is a rectangle in window
5849 relative coordinates. Call this function with input blocked. */
5850
5851 static void
5852 expose_window (w, r)
5853 struct window *w;
5854 XRectangle *r;
5855 {
5856 struct glyph_row *row;
5857 int y;
5858 int yb = window_text_bottom_y (w);
5859 int cursor_cleared_p;
5860
5861 /* If window is not yet fully initialized, do nothing. This can
5862 happen when toolkit scroll bars are used and a window is split.
5863 Reconfiguring the scroll bar will generate an expose for a newly
5864 created window. */
5865 if (w->current_matrix == NULL || w == updated_window)
5866 return;
5867
5868 TRACE ((stderr, "expose_window (%d, %d, %d, %d)\n",
5869 r->x, r->y, r->width, r->height));
5870
5871 /* Convert to window coordinates. */
5872 r->x = FRAME_TO_WINDOW_PIXEL_X (w, r->x);
5873 r->y = FRAME_TO_WINDOW_PIXEL_Y (w, r->y);
5874
5875 /* Turn off the cursor. */
5876 if (!w->pseudo_window_p
5877 && x_phys_cursor_in_rect_p (w, r))
5878 {
5879 x_clear_cursor (w);
5880 cursor_cleared_p = 1;
5881 }
5882 else
5883 cursor_cleared_p = 0;
5884
5885 /* Find the first row intersecting the rectangle R. */
5886 row = w->current_matrix->rows;
5887 y = 0;
5888 while (row->enabled_p
5889 && y < yb
5890 && y + row->height < r->y)
5891 {
5892 y += row->height;
5893 ++row;
5894 }
5895
5896 /* Display the text in the rectangle, one text line at a time. */
5897 while (row->enabled_p
5898 && y < yb
5899 && y < r->y + r->height)
5900 {
5901 expose_line (w, row, r);
5902 y += row->height;
5903 ++row;
5904 }
5905
5906 /* Display the mode line if there is one. */
5907 if (WINDOW_WANTS_MODELINE_P (w)
5908 && (row = MATRIX_MODE_LINE_ROW (w->current_matrix),
5909 row->enabled_p)
5910 && row->y < r->y + r->height)
5911 expose_line (w, row, r);
5912
5913 if (!w->pseudo_window_p)
5914 {
5915 /* Draw border between windows. */
5916 x_draw_vertical_border (w);
5917
5918 /* Turn the cursor on again. */
5919 if (cursor_cleared_p)
5920 x_update_window_cursor (w, 1);
5921 }
5922 }
5923
5924
5925 /* Determine the intersection of two rectangles R1 and R2. Return
5926 the intersection in *RESULT. Value is non-zero if RESULT is not
5927 empty. */
5928
5929 static int
5930 x_intersect_rectangles (r1, r2, result)
5931 XRectangle *r1, *r2, *result;
5932 {
5933 XRectangle *left, *right;
5934 XRectangle *upper, *lower;
5935 int intersection_p = 0;
5936
5937 /* Rearrange so that R1 is the left-most rectangle. */
5938 if (r1->x < r2->x)
5939 left = r1, right = r2;
5940 else
5941 left = r2, right = r1;
5942
5943 /* X0 of the intersection is right.x0, if this is inside R1,
5944 otherwise there is no intersection. */
5945 if (right->x <= left->x + left->width)
5946 {
5947 result->x = right->x;
5948
5949 /* The right end of the intersection is the minimum of the
5950 the right ends of left and right. */
5951 result->width = (min (left->x + left->width, right->x + right->width)
5952 - result->x);
5953
5954 /* Same game for Y. */
5955 if (r1->y < r2->y)
5956 upper = r1, lower = r2;
5957 else
5958 upper = r2, lower = r1;
5959
5960 /* The upper end of the intersection is lower.y0, if this is inside
5961 of upper. Otherwise, there is no intersection. */
5962 if (lower->y <= upper->y + upper->height)
5963 {
5964 result->y = lower->y;
5965
5966 /* The lower end of the intersection is the minimum of the lower
5967 ends of upper and lower. */
5968 result->height = (min (lower->y + lower->height,
5969 upper->y + upper->height)
5970 - result->y);
5971 intersection_p = 1;
5972 }
5973 }
5974
5975 return intersection_p;
5976 }
5977
5978
5979
5980
5981 \f
5982 static void
5983 frame_highlight (f)
5984 struct frame *f;
5985 {
5986 /* We used to only do this if Vx_no_window_manager was non-nil, but
5987 the ICCCM (section 4.1.6) says that the window's border pixmap
5988 and border pixel are window attributes which are "private to the
5989 client", so we can always change it to whatever we want. */
5990 BLOCK_INPUT;
5991 XSetWindowBorder (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
5992 f->output_data.x->border_pixel);
5993 UNBLOCK_INPUT;
5994 x_update_cursor (f, 1);
5995 }
5996
5997 static void
5998 frame_unhighlight (f)
5999 struct frame *f;
6000 {
6001 /* We used to only do this if Vx_no_window_manager was non-nil, but
6002 the ICCCM (section 4.1.6) says that the window's border pixmap
6003 and border pixel are window attributes which are "private to the
6004 client", so we can always change it to whatever we want. */
6005 BLOCK_INPUT;
6006 XSetWindowBorderPixmap (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
6007 f->output_data.x->border_tile);
6008 UNBLOCK_INPUT;
6009 x_update_cursor (f, 1);
6010 }
6011
6012 /* The focus has changed. Update the frames as necessary to reflect
6013 the new situation. Note that we can't change the selected frame
6014 here, because the Lisp code we are interrupting might become confused.
6015 Each event gets marked with the frame in which it occurred, so the
6016 Lisp code can tell when the switch took place by examining the events. */
6017
6018 static void
6019 x_new_focus_frame (dpyinfo, frame)
6020 struct x_display_info *dpyinfo;
6021 struct frame *frame;
6022 {
6023 struct frame *old_focus = dpyinfo->x_focus_frame;
6024
6025 if (frame != dpyinfo->x_focus_frame)
6026 {
6027 /* Set this before calling other routines, so that they see
6028 the correct value of x_focus_frame. */
6029 dpyinfo->x_focus_frame = frame;
6030
6031 if (old_focus && old_focus->auto_lower)
6032 x_lower_frame (old_focus);
6033
6034 #if 0
6035 selected_frame = frame;
6036 XSETFRAME (XWINDOW (selected_frame->selected_window)->frame,
6037 selected_frame);
6038 Fselect_window (selected_frame->selected_window);
6039 choose_minibuf_frame ();
6040 #endif /* ! 0 */
6041
6042 if (dpyinfo->x_focus_frame && dpyinfo->x_focus_frame->auto_raise)
6043 pending_autoraise_frame = dpyinfo->x_focus_frame;
6044 else
6045 pending_autoraise_frame = 0;
6046 }
6047
6048 x_frame_rehighlight (dpyinfo);
6049 }
6050
6051 /* Handle an event saying the mouse has moved out of an Emacs frame. */
6052
6053 void
6054 x_mouse_leave (dpyinfo)
6055 struct x_display_info *dpyinfo;
6056 {
6057 x_new_focus_frame (dpyinfo, dpyinfo->x_focus_event_frame);
6058 }
6059
6060 /* The focus has changed, or we have redirected a frame's focus to
6061 another frame (this happens when a frame uses a surrogate
6062 mini-buffer frame). Shift the highlight as appropriate.
6063
6064 The FRAME argument doesn't necessarily have anything to do with which
6065 frame is being highlighted or un-highlighted; we only use it to find
6066 the appropriate X display info. */
6067
6068 static void
6069 XTframe_rehighlight (frame)
6070 struct frame *frame;
6071 {
6072 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame));
6073 }
6074
6075 static void
6076 x_frame_rehighlight (dpyinfo)
6077 struct x_display_info *dpyinfo;
6078 {
6079 struct frame *old_highlight = dpyinfo->x_highlight_frame;
6080
6081 if (dpyinfo->x_focus_frame)
6082 {
6083 dpyinfo->x_highlight_frame
6084 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame)))
6085 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame))
6086 : dpyinfo->x_focus_frame);
6087 if (! FRAME_LIVE_P (dpyinfo->x_highlight_frame))
6088 {
6089 FRAME_FOCUS_FRAME (dpyinfo->x_focus_frame) = Qnil;
6090 dpyinfo->x_highlight_frame = dpyinfo->x_focus_frame;
6091 }
6092 }
6093 else
6094 dpyinfo->x_highlight_frame = 0;
6095
6096 if (dpyinfo->x_highlight_frame != old_highlight)
6097 {
6098 if (old_highlight)
6099 frame_unhighlight (old_highlight);
6100 if (dpyinfo->x_highlight_frame)
6101 frame_highlight (dpyinfo->x_highlight_frame);
6102 }
6103 }
6104
6105
6106 \f
6107 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
6108
6109 /* Initialize mode_switch_bit and modifier_meaning. */
6110 static void
6111 x_find_modifier_meanings (dpyinfo)
6112 struct x_display_info *dpyinfo;
6113 {
6114 int min_code, max_code;
6115 KeySym *syms;
6116 int syms_per_code;
6117 XModifierKeymap *mods;
6118
6119 dpyinfo->meta_mod_mask = 0;
6120 dpyinfo->shift_lock_mask = 0;
6121 dpyinfo->alt_mod_mask = 0;
6122 dpyinfo->super_mod_mask = 0;
6123 dpyinfo->hyper_mod_mask = 0;
6124
6125 #ifdef HAVE_X11R4
6126 XDisplayKeycodes (dpyinfo->display, &min_code, &max_code);
6127 #else
6128 min_code = dpyinfo->display->min_keycode;
6129 max_code = dpyinfo->display->max_keycode;
6130 #endif
6131
6132 syms = XGetKeyboardMapping (dpyinfo->display,
6133 min_code, max_code - min_code + 1,
6134 &syms_per_code);
6135 mods = XGetModifierMapping (dpyinfo->display);
6136
6137 /* Scan the modifier table to see which modifier bits the Meta and
6138 Alt keysyms are on. */
6139 {
6140 int row, col; /* The row and column in the modifier table. */
6141
6142 for (row = 3; row < 8; row++)
6143 for (col = 0; col < mods->max_keypermod; col++)
6144 {
6145 KeyCode code
6146 = mods->modifiermap[(row * mods->max_keypermod) + col];
6147
6148 /* Zeroes are used for filler. Skip them. */
6149 if (code == 0)
6150 continue;
6151
6152 /* Are any of this keycode's keysyms a meta key? */
6153 {
6154 int code_col;
6155
6156 for (code_col = 0; code_col < syms_per_code; code_col++)
6157 {
6158 int sym = syms[((code - min_code) * syms_per_code) + code_col];
6159
6160 switch (sym)
6161 {
6162 case XK_Meta_L:
6163 case XK_Meta_R:
6164 dpyinfo->meta_mod_mask |= (1 << row);
6165 break;
6166
6167 case XK_Alt_L:
6168 case XK_Alt_R:
6169 dpyinfo->alt_mod_mask |= (1 << row);
6170 break;
6171
6172 case XK_Hyper_L:
6173 case XK_Hyper_R:
6174 dpyinfo->hyper_mod_mask |= (1 << row);
6175 break;
6176
6177 case XK_Super_L:
6178 case XK_Super_R:
6179 dpyinfo->super_mod_mask |= (1 << row);
6180 break;
6181
6182 case XK_Shift_Lock:
6183 /* Ignore this if it's not on the lock modifier. */
6184 if ((1 << row) == LockMask)
6185 dpyinfo->shift_lock_mask = LockMask;
6186 break;
6187 }
6188 }
6189 }
6190 }
6191 }
6192
6193 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
6194 if (! dpyinfo->meta_mod_mask)
6195 {
6196 dpyinfo->meta_mod_mask = dpyinfo->alt_mod_mask;
6197 dpyinfo->alt_mod_mask = 0;
6198 }
6199
6200 /* If some keys are both alt and meta,
6201 make them just meta, not alt. */
6202 if (dpyinfo->alt_mod_mask & dpyinfo->meta_mod_mask)
6203 {
6204 dpyinfo->alt_mod_mask &= ~dpyinfo->meta_mod_mask;
6205 }
6206
6207 XFree ((char *) syms);
6208 XFreeModifiermap (mods);
6209 }
6210
6211 /* Convert between the modifier bits X uses and the modifier bits
6212 Emacs uses. */
6213
6214 static unsigned int
6215 x_x_to_emacs_modifiers (dpyinfo, state)
6216 struct x_display_info *dpyinfo;
6217 unsigned int state;
6218 {
6219 return ( ((state & (ShiftMask | dpyinfo->shift_lock_mask)) ? shift_modifier : 0)
6220 | ((state & ControlMask) ? ctrl_modifier : 0)
6221 | ((state & dpyinfo->meta_mod_mask) ? meta_modifier : 0)
6222 | ((state & dpyinfo->alt_mod_mask) ? alt_modifier : 0)
6223 | ((state & dpyinfo->super_mod_mask) ? super_modifier : 0)
6224 | ((state & dpyinfo->hyper_mod_mask) ? hyper_modifier : 0));
6225 }
6226
6227 static unsigned int
6228 x_emacs_to_x_modifiers (dpyinfo, state)
6229 struct x_display_info *dpyinfo;
6230 unsigned int state;
6231 {
6232 return ( ((state & alt_modifier) ? dpyinfo->alt_mod_mask : 0)
6233 | ((state & super_modifier) ? dpyinfo->super_mod_mask : 0)
6234 | ((state & hyper_modifier) ? dpyinfo->hyper_mod_mask : 0)
6235 | ((state & shift_modifier) ? ShiftMask : 0)
6236 | ((state & ctrl_modifier) ? ControlMask : 0)
6237 | ((state & meta_modifier) ? dpyinfo->meta_mod_mask : 0));
6238 }
6239
6240 /* Convert a keysym to its name. */
6241
6242 char *
6243 x_get_keysym_name (keysym)
6244 KeySym keysym;
6245 {
6246 char *value;
6247
6248 BLOCK_INPUT;
6249 value = XKeysymToString (keysym);
6250 UNBLOCK_INPUT;
6251
6252 return value;
6253 }
6254
6255
6256 \f
6257 /* Mouse clicks and mouse movement. Rah. */
6258
6259 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
6260 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
6261 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
6262 not force the value into range. */
6263
6264 void
6265 pixel_to_glyph_coords (f, pix_x, pix_y, x, y, bounds, noclip)
6266 FRAME_PTR f;
6267 register int pix_x, pix_y;
6268 register int *x, *y;
6269 XRectangle *bounds;
6270 int noclip;
6271 {
6272 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to round down
6273 even for negative values. */
6274 if (pix_x < 0)
6275 pix_x -= FONT_WIDTH ((f)->output_data.x->font) - 1;
6276 if (pix_y < 0)
6277 pix_y -= (f)->output_data.x->line_height - 1;
6278
6279 pix_x = PIXEL_TO_CHAR_COL (f, pix_x);
6280 pix_y = PIXEL_TO_CHAR_ROW (f, pix_y);
6281
6282 if (bounds)
6283 {
6284 bounds->width = FONT_WIDTH (f->output_data.x->font);
6285 bounds->height = f->output_data.x->line_height;
6286 bounds->x = CHAR_TO_PIXEL_COL (f, pix_x);
6287 bounds->y = CHAR_TO_PIXEL_ROW (f, pix_y);
6288 }
6289
6290 if (!noclip)
6291 {
6292 if (pix_x < 0)
6293 pix_x = 0;
6294 else if (pix_x > FRAME_WINDOW_WIDTH (f))
6295 pix_x = FRAME_WINDOW_WIDTH (f);
6296
6297 if (pix_y < 0)
6298 pix_y = 0;
6299 else if (pix_y > f->height)
6300 pix_y = f->height;
6301 }
6302
6303 *x = pix_x;
6304 *y = pix_y;
6305 }
6306
6307
6308 /* Given HPOS/VPOS in the current matrix of W, return corresponding
6309 frame-relative pixel positions in *FRAME_X and *FRAME_Y. If we
6310 can't tell the positions because W's display is not up to date,
6311 return 0. */
6312
6313 int
6314 glyph_to_pixel_coords (w, hpos, vpos, frame_x, frame_y)
6315 struct window *w;
6316 int hpos, vpos;
6317 int *frame_x, *frame_y;
6318 {
6319 int success_p;
6320
6321 xassert (hpos >= 0 && hpos < w->current_matrix->matrix_w);
6322 xassert (vpos >= 0 && vpos < w->current_matrix->matrix_h);
6323
6324 if (display_completed)
6325 {
6326 struct glyph_row *row = MATRIX_ROW (w->current_matrix, vpos);
6327 struct glyph *glyph = row->glyphs[TEXT_AREA];
6328 struct glyph *end = glyph + min (hpos, row->used[TEXT_AREA]);
6329
6330 *frame_y = row->y;
6331 *frame_x = row->x;
6332 while (glyph < end)
6333 {
6334 *frame_x += glyph->pixel_width;
6335 ++glyph;
6336 }
6337
6338 success_p = 1;
6339 }
6340 else
6341 {
6342 *frame_y = *frame_x = 0;
6343 success_p = 0;
6344 }
6345
6346 *frame_y = WINDOW_TO_FRAME_PIXEL_Y (w, *frame_y);
6347 *frame_x = WINDOW_TO_FRAME_PIXEL_X (w, *frame_x);
6348 return success_p;
6349 }
6350
6351
6352 /* Prepare a mouse-event in *RESULT for placement in the input queue.
6353
6354 If the event is a button press, then note that we have grabbed
6355 the mouse. */
6356
6357 static Lisp_Object
6358 construct_mouse_click (result, event, f)
6359 struct input_event *result;
6360 XButtonEvent *event;
6361 struct frame *f;
6362 {
6363 /* Make the event type no_event; we'll change that when we decide
6364 otherwise. */
6365 result->kind = mouse_click;
6366 result->code = event->button - Button1;
6367 result->timestamp = event->time;
6368 result->modifiers = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
6369 event->state)
6370 | (event->type == ButtonRelease
6371 ? up_modifier
6372 : down_modifier));
6373
6374 XSETINT (result->x, event->x);
6375 XSETINT (result->y, event->y);
6376 XSETFRAME (result->frame_or_window, f);
6377 result->arg = Qnil;
6378 return Qnil;
6379 }
6380
6381 \f
6382 /* Function to report a mouse movement to the mainstream Emacs code.
6383 The input handler calls this.
6384
6385 We have received a mouse movement event, which is given in *event.
6386 If the mouse is over a different glyph than it was last time, tell
6387 the mainstream emacs code by setting mouse_moved. If not, ask for
6388 another motion event, so we can check again the next time it moves. */
6389
6390 static XMotionEvent last_mouse_motion_event;
6391 static Lisp_Object last_mouse_motion_frame;
6392
6393 static void
6394 note_mouse_movement (frame, event)
6395 FRAME_PTR frame;
6396 XMotionEvent *event;
6397 {
6398 last_mouse_movement_time = event->time;
6399 last_mouse_motion_event = *event;
6400 XSETFRAME (last_mouse_motion_frame, frame);
6401
6402 if (event->window != FRAME_X_WINDOW (frame))
6403 {
6404 frame->mouse_moved = 1;
6405 last_mouse_scroll_bar = Qnil;
6406 note_mouse_highlight (frame, -1, -1);
6407 }
6408
6409 /* Has the mouse moved off the glyph it was on at the last sighting? */
6410 else if (event->x < last_mouse_glyph.x
6411 || event->x >= last_mouse_glyph.x + last_mouse_glyph.width
6412 || event->y < last_mouse_glyph.y
6413 || event->y >= last_mouse_glyph.y + last_mouse_glyph.height)
6414 {
6415 frame->mouse_moved = 1;
6416 last_mouse_scroll_bar = Qnil;
6417 note_mouse_highlight (frame, event->x, event->y);
6418 }
6419 }
6420
6421 /* This is used for debugging, to turn off note_mouse_highlight. */
6422
6423 int disable_mouse_highlight;
6424
6425
6426 \f
6427 /************************************************************************
6428 Mouse Face
6429 ************************************************************************/
6430
6431 /* Find the glyph under window-relative coordinates X/Y in window W.
6432 Consider only glyphs from buffer text, i.e. no glyphs from overlay
6433 strings. Return in *HPOS and *VPOS the row and column number of
6434 the glyph found. Return in *AREA the glyph area containing X.
6435 Value is a pointer to the glyph found or null if X/Y is not on
6436 text, or we can't tell because W's current matrix is not up to
6437 date. */
6438
6439 static struct glyph *
6440 x_y_to_hpos_vpos (w, x, y, hpos, vpos, area)
6441 struct window *w;
6442 int x, y;
6443 int *hpos, *vpos, *area;
6444 {
6445 struct glyph *glyph, *end;
6446 struct glyph_row *row = NULL;
6447 int x0, i, left_area_width;
6448
6449 /* Find row containing Y. Give up if some row is not enabled. */
6450 for (i = 0; i < w->current_matrix->nrows; ++i)
6451 {
6452 row = MATRIX_ROW (w->current_matrix, i);
6453 if (!row->enabled_p)
6454 return NULL;
6455 if (y >= row->y && y < MATRIX_ROW_BOTTOM_Y (row))
6456 break;
6457 }
6458
6459 *vpos = i;
6460 *hpos = 0;
6461
6462 /* Give up if Y is not in the window. */
6463 if (i == w->current_matrix->nrows)
6464 return NULL;
6465
6466 /* Get the glyph area containing X. */
6467 if (w->pseudo_window_p)
6468 {
6469 *area = TEXT_AREA;
6470 x0 = 0;
6471 }
6472 else
6473 {
6474 left_area_width = window_box_width (w, LEFT_MARGIN_AREA);
6475 if (x < left_area_width)
6476 {
6477 *area = LEFT_MARGIN_AREA;
6478 x0 = 0;
6479 }
6480 else if (x < left_area_width + window_box_width (w, TEXT_AREA))
6481 {
6482 *area = TEXT_AREA;
6483 x0 = row->x + left_area_width;
6484 }
6485 else
6486 {
6487 *area = RIGHT_MARGIN_AREA;
6488 x0 = left_area_width + window_box_width (w, TEXT_AREA);
6489 }
6490 }
6491
6492 /* Find glyph containing X. */
6493 glyph = row->glyphs[*area];
6494 end = glyph + row->used[*area];
6495 while (glyph < end)
6496 {
6497 if (x < x0 + glyph->pixel_width)
6498 {
6499 if (w->pseudo_window_p)
6500 break;
6501 else if (BUFFERP (glyph->object))
6502 break;
6503 }
6504
6505 x0 += glyph->pixel_width;
6506 ++glyph;
6507 }
6508
6509 if (glyph == end)
6510 return NULL;
6511
6512 *hpos = glyph - row->glyphs[*area];
6513 return glyph;
6514 }
6515
6516
6517 /* Convert frame-relative x/y to coordinates relative to window W.
6518 Takes pseudo-windows into account. */
6519
6520 static void
6521 frame_to_window_pixel_xy (w, x, y)
6522 struct window *w;
6523 int *x, *y;
6524 {
6525 if (w->pseudo_window_p)
6526 {
6527 /* A pseudo-window is always full-width, and starts at the
6528 left edge of the frame, plus a frame border. */
6529 struct frame *f = XFRAME (w->frame);
6530 *x -= FRAME_INTERNAL_BORDER_WIDTH_SAFE (f);
6531 *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
6532 }
6533 else
6534 {
6535 *x = FRAME_TO_WINDOW_PIXEL_X (w, *x);
6536 *y = FRAME_TO_WINDOW_PIXEL_Y (w, *y);
6537 }
6538 }
6539
6540
6541 /* Take proper action when mouse has moved to the mode or header line of
6542 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
6543 mode line. X is relative to the start of the text display area of
6544 W, so the width of bitmap areas and scroll bars must be subtracted
6545 to get a position relative to the start of the mode line. */
6546
6547 static void
6548 note_mode_line_highlight (w, x, mode_line_p)
6549 struct window *w;
6550 int x, mode_line_p;
6551 {
6552 struct frame *f = XFRAME (w->frame);
6553 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
6554 Cursor cursor = dpyinfo->vertical_scroll_bar_cursor;
6555 struct glyph_row *row;
6556
6557 if (mode_line_p)
6558 row = MATRIX_MODE_LINE_ROW (w->current_matrix);
6559 else
6560 row = MATRIX_HEADER_LINE_ROW (w->current_matrix);
6561
6562 if (row->enabled_p)
6563 {
6564 struct glyph *glyph, *end;
6565 Lisp_Object help, map;
6566 int x0;
6567
6568 /* Find the glyph under X. */
6569 glyph = row->glyphs[TEXT_AREA];
6570 end = glyph + row->used[TEXT_AREA];
6571 x0 = - (FRAME_LEFT_SCROLL_BAR_WIDTH (f) * CANON_X_UNIT (f)
6572 + FRAME_X_LEFT_FLAGS_AREA_WIDTH (f));
6573
6574 while (glyph < end
6575 && x >= x0 + glyph->pixel_width)
6576 {
6577 x0 += glyph->pixel_width;
6578 ++glyph;
6579 }
6580
6581 if (glyph < end
6582 && STRINGP (glyph->object)
6583 && XSTRING (glyph->object)->intervals
6584 && glyph->charpos >= 0
6585 && glyph->charpos < XSTRING (glyph->object)->size)
6586 {
6587 /* If we're on a string with `help-echo' text property,
6588 arrange for the help to be displayed. This is done by
6589 setting the global variable help_echo to the help string. */
6590 help = Fget_text_property (make_number (glyph->charpos),
6591 Qhelp_echo, glyph->object);
6592 if (!NILP (help))
6593 {
6594 help_echo = help;
6595 XSETWINDOW (help_echo_window, w);
6596 help_echo_object = glyph->object;
6597 help_echo_pos = glyph->charpos;
6598 }
6599
6600 /* Change the mouse pointer according to what is under X/Y. */
6601 map = Fget_text_property (make_number (glyph->charpos),
6602 Qlocal_map, glyph->object);
6603 if (KEYMAPP (map))
6604 cursor = f->output_data.x->nontext_cursor;
6605 else
6606 {
6607 map = Fget_text_property (make_number (glyph->charpos),
6608 Qkeymap, glyph->object);
6609 if (KEYMAPP (map))
6610 cursor = f->output_data.x->nontext_cursor;
6611 }
6612 }
6613 }
6614
6615 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), cursor);
6616 }
6617
6618
6619 /* Take proper action when the mouse has moved to position X, Y on
6620 frame F as regards highlighting characters that have mouse-face
6621 properties. Also de-highlighting chars where the mouse was before.
6622 X and Y can be negative or out of range. */
6623
6624 static void
6625 note_mouse_highlight (f, x, y)
6626 struct frame *f;
6627 int x, y;
6628 {
6629 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
6630 int portion;
6631 Lisp_Object window;
6632 struct window *w;
6633
6634 /* When a menu is active, don't highlight because this looks odd. */
6635 #ifdef USE_X_TOOLKIT
6636 if (popup_activated ())
6637 return;
6638 #endif
6639
6640 if (disable_mouse_highlight
6641 || !f->glyphs_initialized_p)
6642 return;
6643
6644 dpyinfo->mouse_face_mouse_x = x;
6645 dpyinfo->mouse_face_mouse_y = y;
6646 dpyinfo->mouse_face_mouse_frame = f;
6647
6648 if (dpyinfo->mouse_face_defer)
6649 return;
6650
6651 if (gc_in_progress)
6652 {
6653 dpyinfo->mouse_face_deferred_gc = 1;
6654 return;
6655 }
6656
6657 /* Which window is that in? */
6658 window = window_from_coordinates (f, x, y, &portion, 1);
6659
6660 /* If we were displaying active text in another window, clear that. */
6661 if (! EQ (window, dpyinfo->mouse_face_window))
6662 clear_mouse_face (dpyinfo);
6663
6664 /* Not on a window -> return. */
6665 if (!WINDOWP (window))
6666 return;
6667
6668 /* Convert to window-relative pixel coordinates. */
6669 w = XWINDOW (window);
6670 frame_to_window_pixel_xy (w, &x, &y);
6671
6672 /* Handle tool-bar window differently since it doesn't display a
6673 buffer. */
6674 if (EQ (window, f->tool_bar_window))
6675 {
6676 note_tool_bar_highlight (f, x, y);
6677 return;
6678 }
6679
6680 if (portion == 1 || portion == 3)
6681 {
6682 /* Mouse is on the mode or top line. */
6683 note_mode_line_highlight (w, x, portion == 1);
6684 return;
6685 }
6686 else if (portion == 2)
6687 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
6688 f->output_data.x->horizontal_drag_cursor);
6689 else
6690 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
6691 f->output_data.x->text_cursor);
6692
6693 /* Are we in a window whose display is up to date?
6694 And verify the buffer's text has not changed. */
6695 if (/* Within text portion of the window. */
6696 portion == 0
6697 && EQ (w->window_end_valid, w->buffer)
6698 && XFASTINT (w->last_modified) == BUF_MODIFF (XBUFFER (w->buffer))
6699 && (XFASTINT (w->last_overlay_modified)
6700 == BUF_OVERLAY_MODIFF (XBUFFER (w->buffer))))
6701 {
6702 int hpos, vpos, pos, i, area;
6703 struct glyph *glyph;
6704
6705 /* Find the glyph under X/Y. */
6706 glyph = x_y_to_hpos_vpos (w, x, y, &hpos, &vpos, &area);
6707
6708 /* Clear mouse face if X/Y not over text. */
6709 if (glyph == NULL
6710 || area != TEXT_AREA
6711 || !MATRIX_ROW (w->current_matrix, vpos)->displays_text_p)
6712 {
6713 clear_mouse_face (dpyinfo);
6714 return;
6715 }
6716
6717 pos = glyph->charpos;
6718 xassert (w->pseudo_window_p || BUFFERP (glyph->object));
6719
6720 /* Check for mouse-face and help-echo. */
6721 {
6722 Lisp_Object mouse_face, overlay, position;
6723 Lisp_Object *overlay_vec;
6724 int len, noverlays;
6725 struct buffer *obuf;
6726 int obegv, ozv;
6727
6728 /* If we get an out-of-range value, return now; avoid an error. */
6729 if (pos > BUF_Z (XBUFFER (w->buffer)))
6730 return;
6731
6732 /* Make the window's buffer temporarily current for
6733 overlays_at and compute_char_face. */
6734 obuf = current_buffer;
6735 current_buffer = XBUFFER (w->buffer);
6736 obegv = BEGV;
6737 ozv = ZV;
6738 BEGV = BEG;
6739 ZV = Z;
6740
6741 /* Is this char mouse-active or does it have help-echo? */
6742 XSETINT (position, pos);
6743
6744 /* Put all the overlays we want in a vector in overlay_vec.
6745 Store the length in len. If there are more than 10, make
6746 enough space for all, and try again. */
6747 len = 10;
6748 overlay_vec = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
6749 noverlays = overlays_at (pos, 0, &overlay_vec, &len, NULL, NULL, 0);
6750 if (noverlays > len)
6751 {
6752 len = noverlays;
6753 overlay_vec = (Lisp_Object *) alloca (len * sizeof (Lisp_Object));
6754 noverlays = overlays_at (pos, 0, &overlay_vec, &len, NULL, NULL,0);
6755 }
6756
6757 /* Sort overlays into increasing priority order. */
6758 noverlays = sort_overlays (overlay_vec, noverlays, w);
6759
6760 /* Check mouse-face highlighting. */
6761 if (! (EQ (window, dpyinfo->mouse_face_window)
6762 && vpos >= dpyinfo->mouse_face_beg_row
6763 && vpos <= dpyinfo->mouse_face_end_row
6764 && (vpos > dpyinfo->mouse_face_beg_row
6765 || hpos >= dpyinfo->mouse_face_beg_col)
6766 && (vpos < dpyinfo->mouse_face_end_row
6767 || hpos < dpyinfo->mouse_face_end_col
6768 || dpyinfo->mouse_face_past_end)))
6769 {
6770 /* Clear the display of the old active region, if any. */
6771 clear_mouse_face (dpyinfo);
6772
6773 /* Find the highest priority overlay that has a mouse-face prop. */
6774 overlay = Qnil;
6775 for (i = noverlays - 1; i >= 0; --i)
6776 {
6777 mouse_face = Foverlay_get (overlay_vec[i], Qmouse_face);
6778 if (!NILP (mouse_face))
6779 {
6780 overlay = overlay_vec[i];
6781 break;
6782 }
6783 }
6784
6785 /* If no overlay applies, get a text property. */
6786 if (NILP (overlay))
6787 mouse_face = Fget_text_property (position, Qmouse_face, w->buffer);
6788
6789 /* Handle the overlay case. */
6790 if (! NILP (overlay))
6791 {
6792 /* Find the range of text around this char that
6793 should be active. */
6794 Lisp_Object before, after;
6795 int ignore;
6796
6797 before = Foverlay_start (overlay);
6798 after = Foverlay_end (overlay);
6799 /* Record this as the current active region. */
6800 fast_find_position (w, XFASTINT (before),
6801 &dpyinfo->mouse_face_beg_col,
6802 &dpyinfo->mouse_face_beg_row,
6803 &dpyinfo->mouse_face_beg_x,
6804 &dpyinfo->mouse_face_beg_y);
6805 dpyinfo->mouse_face_past_end
6806 = !fast_find_position (w, XFASTINT (after),
6807 &dpyinfo->mouse_face_end_col,
6808 &dpyinfo->mouse_face_end_row,
6809 &dpyinfo->mouse_face_end_x,
6810 &dpyinfo->mouse_face_end_y);
6811 dpyinfo->mouse_face_window = window;
6812 dpyinfo->mouse_face_face_id
6813 = face_at_buffer_position (w, pos, 0, 0,
6814 &ignore, pos + 1, 1);
6815
6816 /* Display it as active. */
6817 show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
6818 }
6819 /* Handle the text property case. */
6820 else if (! NILP (mouse_face))
6821 {
6822 /* Find the range of text around this char that
6823 should be active. */
6824 Lisp_Object before, after, beginning, end;
6825 int ignore;
6826
6827 beginning = Fmarker_position (w->start);
6828 XSETINT (end, (BUF_Z (XBUFFER (w->buffer))
6829 - XFASTINT (w->window_end_pos)));
6830 before
6831 = Fprevious_single_property_change (make_number (pos + 1),
6832 Qmouse_face,
6833 w->buffer, beginning);
6834 after
6835 = Fnext_single_property_change (position, Qmouse_face,
6836 w->buffer, end);
6837 /* Record this as the current active region. */
6838 fast_find_position (w, XFASTINT (before),
6839 &dpyinfo->mouse_face_beg_col,
6840 &dpyinfo->mouse_face_beg_row,
6841 &dpyinfo->mouse_face_beg_x,
6842 &dpyinfo->mouse_face_beg_y);
6843 dpyinfo->mouse_face_past_end
6844 = !fast_find_position (w, XFASTINT (after),
6845 &dpyinfo->mouse_face_end_col,
6846 &dpyinfo->mouse_face_end_row,
6847 &dpyinfo->mouse_face_end_x,
6848 &dpyinfo->mouse_face_end_y);
6849 dpyinfo->mouse_face_window = window;
6850 dpyinfo->mouse_face_face_id
6851 = face_at_buffer_position (w, pos, 0, 0,
6852 &ignore, pos + 1, 1);
6853
6854 /* Display it as active. */
6855 show_mouse_face (dpyinfo, DRAW_MOUSE_FACE);
6856 }
6857 }
6858
6859 /* Look for a `help-echo' property. */
6860 {
6861 Lisp_Object help, overlay;
6862
6863 /* Check overlays first. */
6864 help = overlay = Qnil;
6865 for (i = noverlays - 1; i >= 0 && NILP (help); --i)
6866 {
6867 overlay = overlay_vec[i];
6868 help = Foverlay_get (overlay, Qhelp_echo);
6869 }
6870
6871 if (!NILP (help))
6872 {
6873 help_echo = help;
6874 help_echo_window = window;
6875 help_echo_object = overlay;
6876 help_echo_pos = pos;
6877 }
6878 else
6879 {
6880 /* Try text properties. */
6881 if ((STRINGP (glyph->object)
6882 && glyph->charpos >= 0
6883 && glyph->charpos < XSTRING (glyph->object)->size)
6884 || (BUFFERP (glyph->object)
6885 && glyph->charpos >= BEGV
6886 && glyph->charpos < ZV))
6887 help = Fget_text_property (make_number (glyph->charpos),
6888 Qhelp_echo, glyph->object);
6889
6890 if (!NILP (help))
6891 {
6892 help_echo = help;
6893 help_echo_window = window;
6894 help_echo_object = glyph->object;
6895 help_echo_pos = glyph->charpos;
6896 }
6897 }
6898 }
6899
6900 BEGV = obegv;
6901 ZV = ozv;
6902 current_buffer = obuf;
6903 }
6904 }
6905 }
6906
6907 static void
6908 redo_mouse_highlight ()
6909 {
6910 if (!NILP (last_mouse_motion_frame)
6911 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame)))
6912 note_mouse_highlight (XFRAME (last_mouse_motion_frame),
6913 last_mouse_motion_event.x,
6914 last_mouse_motion_event.y);
6915 }
6916
6917
6918 \f
6919 /***********************************************************************
6920 Tool-bars
6921 ***********************************************************************/
6922
6923 static int x_tool_bar_item P_ ((struct frame *, int, int,
6924 struct glyph **, int *, int *, int *));
6925
6926 /* Tool-bar item index of the item on which a mouse button was pressed
6927 or -1. */
6928
6929 static int last_tool_bar_item;
6930
6931
6932 /* Get information about the tool-bar item at position X/Y on frame F.
6933 Return in *GLYPH a pointer to the glyph of the tool-bar item in
6934 the current matrix of the tool-bar window of F, or NULL if not
6935 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
6936 item in F->tool_bar_items. Value is
6937
6938 -1 if X/Y is not on a tool-bar item
6939 0 if X/Y is on the same item that was highlighted before.
6940 1 otherwise. */
6941
6942 static int
6943 x_tool_bar_item (f, x, y, glyph, hpos, vpos, prop_idx)
6944 struct frame *f;
6945 int x, y;
6946 struct glyph **glyph;
6947 int *hpos, *vpos, *prop_idx;
6948 {
6949 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
6950 struct window *w = XWINDOW (f->tool_bar_window);
6951 int area;
6952
6953 /* Find the glyph under X/Y. */
6954 *glyph = x_y_to_hpos_vpos (w, x, y, hpos, vpos, &area);
6955 if (*glyph == NULL)
6956 return -1;
6957
6958 /* Get the start of this tool-bar item's properties in
6959 f->tool_bar_items. */
6960 if (!tool_bar_item_info (f, *glyph, prop_idx))
6961 return -1;
6962
6963 /* Is mouse on the highlighted item? */
6964 if (EQ (f->tool_bar_window, dpyinfo->mouse_face_window)
6965 && *vpos >= dpyinfo->mouse_face_beg_row
6966 && *vpos <= dpyinfo->mouse_face_end_row
6967 && (*vpos > dpyinfo->mouse_face_beg_row
6968 || *hpos >= dpyinfo->mouse_face_beg_col)
6969 && (*vpos < dpyinfo->mouse_face_end_row
6970 || *hpos < dpyinfo->mouse_face_end_col
6971 || dpyinfo->mouse_face_past_end))
6972 return 0;
6973
6974 return 1;
6975 }
6976
6977
6978 /* Handle mouse button event on the tool-bar of frame F, at
6979 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
6980 or ButtonRelase. */
6981
6982 static void
6983 x_handle_tool_bar_click (f, button_event)
6984 struct frame *f;
6985 XButtonEvent *button_event;
6986 {
6987 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
6988 struct window *w = XWINDOW (f->tool_bar_window);
6989 int hpos, vpos, prop_idx;
6990 struct glyph *glyph;
6991 Lisp_Object enabled_p;
6992 int x = button_event->x;
6993 int y = button_event->y;
6994
6995 /* If not on the highlighted tool-bar item, return. */
6996 frame_to_window_pixel_xy (w, &x, &y);
6997 if (x_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx) != 0)
6998 return;
6999
7000 /* If item is disabled, do nothing. */
7001 enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
7002 if (NILP (enabled_p))
7003 return;
7004
7005 if (button_event->type == ButtonPress)
7006 {
7007 /* Show item in pressed state. */
7008 show_mouse_face (dpyinfo, DRAW_IMAGE_SUNKEN);
7009 dpyinfo->mouse_face_image_state = DRAW_IMAGE_SUNKEN;
7010 last_tool_bar_item = prop_idx;
7011 }
7012 else
7013 {
7014 Lisp_Object key, frame;
7015 struct input_event event;
7016
7017 /* Show item in released state. */
7018 show_mouse_face (dpyinfo, DRAW_IMAGE_RAISED);
7019 dpyinfo->mouse_face_image_state = DRAW_IMAGE_RAISED;
7020
7021 key = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_KEY);
7022
7023 XSETFRAME (frame, f);
7024 event.kind = TOOL_BAR_EVENT;
7025 event.frame_or_window = frame;
7026 event.arg = frame;
7027 kbd_buffer_store_event (&event);
7028
7029 event.kind = TOOL_BAR_EVENT;
7030 event.frame_or_window = frame;
7031 event.arg = key;
7032 event.modifiers = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
7033 button_event->state);
7034 kbd_buffer_store_event (&event);
7035 last_tool_bar_item = -1;
7036 }
7037 }
7038
7039
7040 /* Possibly highlight a tool-bar item on frame F when mouse moves to
7041 tool-bar window-relative coordinates X/Y. Called from
7042 note_mouse_highlight. */
7043
7044 static void
7045 note_tool_bar_highlight (f, x, y)
7046 struct frame *f;
7047 int x, y;
7048 {
7049 Lisp_Object window = f->tool_bar_window;
7050 struct window *w = XWINDOW (window);
7051 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
7052 int hpos, vpos;
7053 struct glyph *glyph;
7054 struct glyph_row *row;
7055 int i;
7056 Lisp_Object enabled_p;
7057 int prop_idx;
7058 enum draw_glyphs_face draw = DRAW_IMAGE_RAISED;
7059 int mouse_down_p, rc;
7060
7061 /* Function note_mouse_highlight is called with negative x(y
7062 values when mouse moves outside of the frame. */
7063 if (x <= 0 || y <= 0)
7064 {
7065 clear_mouse_face (dpyinfo);
7066 return;
7067 }
7068
7069 rc = x_tool_bar_item (f, x, y, &glyph, &hpos, &vpos, &prop_idx);
7070 if (rc < 0)
7071 {
7072 /* Not on tool-bar item. */
7073 clear_mouse_face (dpyinfo);
7074 return;
7075 }
7076 else if (rc == 0)
7077 /* On same tool-bar item as before. */
7078 goto set_help_echo;
7079
7080 clear_mouse_face (dpyinfo);
7081
7082 /* Mouse is down, but on different tool-bar item? */
7083 mouse_down_p = (dpyinfo->grabbed
7084 && f == last_mouse_frame
7085 && FRAME_LIVE_P (f));
7086 if (mouse_down_p
7087 && last_tool_bar_item != prop_idx)
7088 return;
7089
7090 dpyinfo->mouse_face_image_state = DRAW_NORMAL_TEXT;
7091 draw = mouse_down_p ? DRAW_IMAGE_SUNKEN : DRAW_IMAGE_RAISED;
7092
7093 /* If tool-bar item is not enabled, don't highlight it. */
7094 enabled_p = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_ENABLED_P);
7095 if (!NILP (enabled_p))
7096 {
7097 /* Compute the x-position of the glyph. In front and past the
7098 image is a space. We include this is the highlighted area. */
7099 row = MATRIX_ROW (w->current_matrix, vpos);
7100 for (i = x = 0; i < hpos; ++i)
7101 x += row->glyphs[TEXT_AREA][i].pixel_width;
7102
7103 /* Record this as the current active region. */
7104 dpyinfo->mouse_face_beg_col = hpos;
7105 dpyinfo->mouse_face_beg_row = vpos;
7106 dpyinfo->mouse_face_beg_x = x;
7107 dpyinfo->mouse_face_beg_y = row->y;
7108 dpyinfo->mouse_face_past_end = 0;
7109
7110 dpyinfo->mouse_face_end_col = hpos + 1;
7111 dpyinfo->mouse_face_end_row = vpos;
7112 dpyinfo->mouse_face_end_x = x + glyph->pixel_width;
7113 dpyinfo->mouse_face_end_y = row->y;
7114 dpyinfo->mouse_face_window = window;
7115 dpyinfo->mouse_face_face_id = TOOL_BAR_FACE_ID;
7116
7117 /* Display it as active. */
7118 show_mouse_face (dpyinfo, draw);
7119 dpyinfo->mouse_face_image_state = draw;
7120 }
7121
7122 set_help_echo:
7123
7124 /* Set help_echo to a help string.to display for this tool-bar item.
7125 XTread_socket does the rest. */
7126 help_echo_object = help_echo_window = Qnil;
7127 help_echo_pos = -1;
7128 help_echo = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_HELP);
7129 if (NILP (help_echo))
7130 help_echo = AREF (f->tool_bar_items, prop_idx + TOOL_BAR_ITEM_CAPTION);
7131 }
7132
7133
7134 \f
7135 /* Find the glyph matrix position of buffer position POS in window W.
7136 *HPOS, *VPOS, *X, and *Y are set to the positions found. W's
7137 current glyphs must be up to date. If POS is above window start
7138 return (0, 0, 0, 0). If POS is after end of W, return end of
7139 last line in W. */
7140
7141 static int
7142 fast_find_position (w, pos, hpos, vpos, x, y)
7143 struct window *w;
7144 int pos;
7145 int *hpos, *vpos, *x, *y;
7146 {
7147 int i;
7148 int lastcol;
7149 int maybe_next_line_p = 0;
7150 int line_start_position;
7151 int yb = window_text_bottom_y (w);
7152 struct glyph_row *row = MATRIX_ROW (w->current_matrix, 0);
7153 struct glyph_row *best_row = row;
7154 int row_vpos = 0, best_row_vpos = 0;
7155 int current_x;
7156
7157 while (row->y < yb)
7158 {
7159 if (row->used[TEXT_AREA])
7160 line_start_position = row->glyphs[TEXT_AREA]->charpos;
7161 else
7162 line_start_position = 0;
7163
7164 if (line_start_position > pos)
7165 break;
7166 /* If the position sought is the end of the buffer,
7167 don't include the blank lines at the bottom of the window. */
7168 else if (line_start_position == pos
7169 && pos == BUF_ZV (XBUFFER (w->buffer)))
7170 {
7171 maybe_next_line_p = 1;
7172 break;
7173 }
7174 else if (line_start_position > 0)
7175 {
7176 best_row = row;
7177 best_row_vpos = row_vpos;
7178 }
7179
7180 if (row->y + row->height >= yb)
7181 break;
7182
7183 ++row;
7184 ++row_vpos;
7185 }
7186
7187 /* Find the right column within BEST_ROW. */
7188 lastcol = 0;
7189 current_x = best_row->x;
7190 for (i = 0; i < best_row->used[TEXT_AREA]; i++)
7191 {
7192 struct glyph *glyph = best_row->glyphs[TEXT_AREA] + i;
7193 int charpos;
7194
7195 charpos = glyph->charpos;
7196 if (charpos == pos)
7197 {
7198 *hpos = i;
7199 *vpos = best_row_vpos;
7200 *x = current_x;
7201 *y = best_row->y;
7202 return 1;
7203 }
7204 else if (charpos > pos)
7205 break;
7206 else if (charpos > 0)
7207 lastcol = i;
7208
7209 current_x += glyph->pixel_width;
7210 }
7211
7212 /* If we're looking for the end of the buffer,
7213 and we didn't find it in the line we scanned,
7214 use the start of the following line. */
7215 if (maybe_next_line_p)
7216 {
7217 ++best_row;
7218 ++best_row_vpos;
7219 lastcol = 0;
7220 current_x = best_row->x;
7221 }
7222
7223 *vpos = best_row_vpos;
7224 *hpos = lastcol + 1;
7225 *x = current_x;
7226 *y = best_row->y;
7227 return 0;
7228 }
7229
7230
7231 /* Display the active region described by mouse_face_*
7232 in its mouse-face if HL > 0, in its normal face if HL = 0. */
7233
7234 static void
7235 show_mouse_face (dpyinfo, draw)
7236 struct x_display_info *dpyinfo;
7237 enum draw_glyphs_face draw;
7238 {
7239 struct window *w = XWINDOW (dpyinfo->mouse_face_window);
7240 struct frame *f = XFRAME (WINDOW_FRAME (w));
7241 int i;
7242 int cursor_off_p = 0;
7243 struct cursor_pos saved_cursor;
7244
7245 saved_cursor = output_cursor;
7246
7247 /* If window is in the process of being destroyed, don't bother
7248 to do anything. */
7249 if (w->current_matrix == NULL)
7250 goto set_x_cursor;
7251
7252 /* Recognize when we are called to operate on rows that don't exist
7253 anymore. This can happen when a window is split. */
7254 if (dpyinfo->mouse_face_end_row >= w->current_matrix->nrows)
7255 goto set_x_cursor;
7256
7257 set_output_cursor (&w->phys_cursor);
7258
7259 /* Note that mouse_face_beg_row etc. are window relative. */
7260 for (i = dpyinfo->mouse_face_beg_row;
7261 i <= dpyinfo->mouse_face_end_row;
7262 i++)
7263 {
7264 int start_hpos, end_hpos, start_x;
7265 struct glyph_row *row = MATRIX_ROW (w->current_matrix, i);
7266
7267 /* Don't do anything if row doesn't have valid contents. */
7268 if (!row->enabled_p)
7269 continue;
7270
7271 /* For all but the first row, the highlight starts at column 0. */
7272 if (i == dpyinfo->mouse_face_beg_row)
7273 {
7274 start_hpos = dpyinfo->mouse_face_beg_col;
7275 start_x = dpyinfo->mouse_face_beg_x;
7276 }
7277 else
7278 {
7279 start_hpos = 0;
7280 start_x = 0;
7281 }
7282
7283 if (i == dpyinfo->mouse_face_end_row)
7284 end_hpos = dpyinfo->mouse_face_end_col;
7285 else
7286 end_hpos = row->used[TEXT_AREA];
7287
7288 /* If the cursor's in the text we are about to rewrite, turn the
7289 cursor off. */
7290 if (!w->pseudo_window_p
7291 && i == output_cursor.vpos
7292 && output_cursor.hpos >= start_hpos - 1
7293 && output_cursor.hpos <= end_hpos)
7294 {
7295 x_update_window_cursor (w, 0);
7296 cursor_off_p = 1;
7297 }
7298
7299 if (end_hpos > start_hpos)
7300 {
7301 row->mouse_face_p = draw == DRAW_MOUSE_FACE;
7302 x_draw_glyphs (w, start_x, row, TEXT_AREA,
7303 start_hpos, end_hpos, draw, NULL, NULL, 0);
7304 }
7305 }
7306
7307 /* If we turned the cursor off, turn it back on. */
7308 if (cursor_off_p)
7309 x_display_cursor (w, 1,
7310 output_cursor.hpos, output_cursor.vpos,
7311 output_cursor.x, output_cursor.y);
7312
7313 output_cursor = saved_cursor;
7314
7315 set_x_cursor:
7316
7317 /* Change the mouse cursor. */
7318 if (draw == DRAW_NORMAL_TEXT)
7319 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
7320 f->output_data.x->text_cursor);
7321 else if (draw == DRAW_MOUSE_FACE)
7322 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
7323 f->output_data.x->cross_cursor);
7324 else
7325 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
7326 f->output_data.x->nontext_cursor);
7327 }
7328
7329 /* Clear out the mouse-highlighted active region.
7330 Redraw it un-highlighted first. */
7331
7332 void
7333 clear_mouse_face (dpyinfo)
7334 struct x_display_info *dpyinfo;
7335 {
7336 #if 0 /* This prevents redrawing tool bar items when changing from one
7337 to another while a tooltip is open, so don't do it. */
7338 if (!NILP (tip_frame))
7339 return;
7340 #endif
7341
7342 if (! NILP (dpyinfo->mouse_face_window))
7343 show_mouse_face (dpyinfo, DRAW_NORMAL_TEXT);
7344
7345 dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
7346 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
7347 dpyinfo->mouse_face_window = Qnil;
7348 }
7349
7350
7351 /* Clear any mouse-face on window W. This function is part of the
7352 redisplay interface, and is called from try_window_id and similar
7353 functions to ensure the mouse-highlight is off. */
7354
7355 static void
7356 x_clear_mouse_face (w)
7357 struct window *w;
7358 {
7359 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (XFRAME (w->frame));
7360 Lisp_Object window;
7361
7362 BLOCK_INPUT;
7363 XSETWINDOW (window, w);
7364 if (EQ (window, dpyinfo->mouse_face_window))
7365 clear_mouse_face (dpyinfo);
7366 UNBLOCK_INPUT;
7367 }
7368
7369
7370 /* Just discard the mouse face information for frame F, if any.
7371 This is used when the size of F is changed. */
7372
7373 void
7374 cancel_mouse_face (f)
7375 FRAME_PTR f;
7376 {
7377 Lisp_Object window;
7378 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
7379
7380 window = dpyinfo->mouse_face_window;
7381 if (! NILP (window) && XFRAME (XWINDOW (window)->frame) == f)
7382 {
7383 dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
7384 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
7385 dpyinfo->mouse_face_window = Qnil;
7386 }
7387 }
7388 \f
7389 static struct scroll_bar *x_window_to_scroll_bar ();
7390 static void x_scroll_bar_report_motion ();
7391
7392 /* Return the current position of the mouse.
7393 *fp should be a frame which indicates which display to ask about.
7394
7395 If the mouse movement started in a scroll bar, set *fp, *bar_window,
7396 and *part to the frame, window, and scroll bar part that the mouse
7397 is over. Set *x and *y to the portion and whole of the mouse's
7398 position on the scroll bar.
7399
7400 If the mouse movement started elsewhere, set *fp to the frame the
7401 mouse is on, *bar_window to nil, and *x and *y to the character cell
7402 the mouse is over.
7403
7404 Set *time to the server time-stamp for the time at which the mouse
7405 was at this position.
7406
7407 Don't store anything if we don't have a valid set of values to report.
7408
7409 This clears the mouse_moved flag, so we can wait for the next mouse
7410 movement. */
7411
7412 static void
7413 XTmouse_position (fp, insist, bar_window, part, x, y, time)
7414 FRAME_PTR *fp;
7415 int insist;
7416 Lisp_Object *bar_window;
7417 enum scroll_bar_part *part;
7418 Lisp_Object *x, *y;
7419 unsigned long *time;
7420 {
7421 FRAME_PTR f1;
7422
7423 BLOCK_INPUT;
7424
7425 if (! NILP (last_mouse_scroll_bar) && insist == 0)
7426 x_scroll_bar_report_motion (fp, bar_window, part, x, y, time);
7427 else
7428 {
7429 Window root;
7430 int root_x, root_y;
7431
7432 Window dummy_window;
7433 int dummy;
7434
7435 Lisp_Object frame, tail;
7436
7437 /* Clear the mouse-moved flag for every frame on this display. */
7438 FOR_EACH_FRAME (tail, frame)
7439 if (FRAME_X_DISPLAY (XFRAME (frame)) == FRAME_X_DISPLAY (*fp))
7440 XFRAME (frame)->mouse_moved = 0;
7441
7442 last_mouse_scroll_bar = Qnil;
7443
7444 /* Figure out which root window we're on. */
7445 XQueryPointer (FRAME_X_DISPLAY (*fp),
7446 DefaultRootWindow (FRAME_X_DISPLAY (*fp)),
7447
7448 /* The root window which contains the pointer. */
7449 &root,
7450
7451 /* Trash which we can't trust if the pointer is on
7452 a different screen. */
7453 &dummy_window,
7454
7455 /* The position on that root window. */
7456 &root_x, &root_y,
7457
7458 /* More trash we can't trust. */
7459 &dummy, &dummy,
7460
7461 /* Modifier keys and pointer buttons, about which
7462 we don't care. */
7463 (unsigned int *) &dummy);
7464
7465 /* Now we have a position on the root; find the innermost window
7466 containing the pointer. */
7467 {
7468 Window win, child;
7469 int win_x, win_y;
7470 int parent_x = 0, parent_y = 0;
7471 int count;
7472
7473 win = root;
7474
7475 /* XTranslateCoordinates can get errors if the window
7476 structure is changing at the same time this function
7477 is running. So at least we must not crash from them. */
7478
7479 count = x_catch_errors (FRAME_X_DISPLAY (*fp));
7480
7481 if (FRAME_X_DISPLAY_INFO (*fp)->grabbed && last_mouse_frame
7482 && FRAME_LIVE_P (last_mouse_frame))
7483 {
7484 /* If mouse was grabbed on a frame, give coords for that frame
7485 even if the mouse is now outside it. */
7486 XTranslateCoordinates (FRAME_X_DISPLAY (*fp),
7487
7488 /* From-window, to-window. */
7489 root, FRAME_X_WINDOW (last_mouse_frame),
7490
7491 /* From-position, to-position. */
7492 root_x, root_y, &win_x, &win_y,
7493
7494 /* Child of win. */
7495 &child);
7496 f1 = last_mouse_frame;
7497 }
7498 else
7499 {
7500 while (1)
7501 {
7502 XTranslateCoordinates (FRAME_X_DISPLAY (*fp),
7503
7504 /* From-window, to-window. */
7505 root, win,
7506
7507 /* From-position, to-position. */
7508 root_x, root_y, &win_x, &win_y,
7509
7510 /* Child of win. */
7511 &child);
7512
7513 if (child == None || child == win)
7514 break;
7515
7516 win = child;
7517 parent_x = win_x;
7518 parent_y = win_y;
7519 }
7520
7521 /* Now we know that:
7522 win is the innermost window containing the pointer
7523 (XTC says it has no child containing the pointer),
7524 win_x and win_y are the pointer's position in it
7525 (XTC did this the last time through), and
7526 parent_x and parent_y are the pointer's position in win's parent.
7527 (They are what win_x and win_y were when win was child.
7528 If win is the root window, it has no parent, and
7529 parent_{x,y} are invalid, but that's okay, because we'll
7530 never use them in that case.) */
7531
7532 /* Is win one of our frames? */
7533 f1 = x_any_window_to_frame (FRAME_X_DISPLAY_INFO (*fp), win);
7534
7535 #ifdef USE_X_TOOLKIT
7536 /* If we end up with the menu bar window, say it's not
7537 on the frame. */
7538 if (f1 != NULL
7539 && f1->output_data.x->menubar_widget
7540 && win == XtWindow (f1->output_data.x->menubar_widget))
7541 f1 = NULL;
7542 #endif /* USE_X_TOOLKIT */
7543 }
7544
7545 if (x_had_errors_p (FRAME_X_DISPLAY (*fp)))
7546 f1 = 0;
7547
7548 x_uncatch_errors (FRAME_X_DISPLAY (*fp), count);
7549
7550 /* If not, is it one of our scroll bars? */
7551 if (! f1)
7552 {
7553 struct scroll_bar *bar = x_window_to_scroll_bar (win);
7554
7555 if (bar)
7556 {
7557 f1 = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
7558 win_x = parent_x;
7559 win_y = parent_y;
7560 }
7561 }
7562
7563 if (f1 == 0 && insist > 0)
7564 f1 = SELECTED_FRAME ();
7565
7566 if (f1)
7567 {
7568 /* Ok, we found a frame. Store all the values.
7569 last_mouse_glyph is a rectangle used to reduce the
7570 generation of mouse events. To not miss any motion
7571 events, we must divide the frame into rectangles of the
7572 size of the smallest character that could be displayed
7573 on it, i.e. into the same rectangles that matrices on
7574 the frame are divided into. */
7575
7576 #if OLD_REDISPLAY_CODE
7577 int ignore1, ignore2;
7578 pixel_to_glyph_coords (f1, win_x, win_y, &ignore1, &ignore2,
7579 &last_mouse_glyph,
7580 FRAME_X_DISPLAY_INFO (f1)->grabbed
7581 || insist);
7582 #else
7583 {
7584 int width = FRAME_SMALLEST_CHAR_WIDTH (f1);
7585 int height = FRAME_SMALLEST_FONT_HEIGHT (f1);
7586 int x = win_x;
7587 int y = win_y;
7588
7589 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to
7590 round down even for negative values. */
7591 if (x < 0)
7592 x -= width - 1;
7593 if (y < 0)
7594 y -= height - 1;
7595
7596 last_mouse_glyph.width = width;
7597 last_mouse_glyph.height = height;
7598 last_mouse_glyph.x = (x + width - 1) / width * width;
7599 last_mouse_glyph.y = (y + height - 1) / height * height;
7600 }
7601 #endif
7602
7603 *bar_window = Qnil;
7604 *part = 0;
7605 *fp = f1;
7606 XSETINT (*x, win_x);
7607 XSETINT (*y, win_y);
7608 *time = last_mouse_movement_time;
7609 }
7610 }
7611 }
7612
7613 UNBLOCK_INPUT;
7614 }
7615
7616
7617 #ifdef USE_X_TOOLKIT
7618
7619 /* Atimer callback function for TIMER. Called every 0.1s to process
7620 Xt timeouts, if needed. We must avoid calling XtAppPending as
7621 much as possible because that function does an implicit XFlush
7622 that slows us down. */
7623
7624 static void
7625 x_process_timeouts (timer)
7626 struct atimer *timer;
7627 {
7628 if (toolkit_scroll_bar_interaction || popup_activated_flag)
7629 {
7630 BLOCK_INPUT;
7631 while (XtAppPending (Xt_app_con) & XtIMTimer)
7632 XtAppProcessEvent (Xt_app_con, XtIMTimer);
7633 UNBLOCK_INPUT;
7634 }
7635 }
7636
7637 #endif /* USE_X_TOOLKIT */
7638
7639 \f
7640 /* Scroll bar support. */
7641
7642 /* Given an X window ID, find the struct scroll_bar which manages it.
7643 This can be called in GC, so we have to make sure to strip off mark
7644 bits. */
7645
7646 static struct scroll_bar *
7647 x_window_to_scroll_bar (window_id)
7648 Window window_id;
7649 {
7650 Lisp_Object tail;
7651
7652 for (tail = Vframe_list;
7653 XGCTYPE (tail) == Lisp_Cons;
7654 tail = XCDR (tail))
7655 {
7656 Lisp_Object frame, bar, condemned;
7657
7658 frame = XCAR (tail);
7659 /* All elements of Vframe_list should be frames. */
7660 if (! GC_FRAMEP (frame))
7661 abort ();
7662
7663 /* Scan this frame's scroll bar list for a scroll bar with the
7664 right window ID. */
7665 condemned = FRAME_CONDEMNED_SCROLL_BARS (XFRAME (frame));
7666 for (bar = FRAME_SCROLL_BARS (XFRAME (frame));
7667 /* This trick allows us to search both the ordinary and
7668 condemned scroll bar lists with one loop. */
7669 ! GC_NILP (bar) || (bar = condemned,
7670 condemned = Qnil,
7671 ! GC_NILP (bar));
7672 bar = XSCROLL_BAR (bar)->next)
7673 if (SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar)) == window_id)
7674 return XSCROLL_BAR (bar);
7675 }
7676
7677 return 0;
7678 }
7679
7680
7681 \f
7682 /************************************************************************
7683 Toolkit scroll bars
7684 ************************************************************************/
7685
7686 #ifdef USE_TOOLKIT_SCROLL_BARS
7687
7688 static void x_scroll_bar_to_input_event P_ ((XEvent *, struct input_event *));
7689 static void x_send_scroll_bar_event P_ ((Lisp_Object, int, int, int));
7690 static void x_create_toolkit_scroll_bar P_ ((struct frame *,
7691 struct scroll_bar *));
7692 static void x_set_toolkit_scroll_bar_thumb P_ ((struct scroll_bar *,
7693 int, int, int));
7694
7695
7696 /* Id of action hook installed for scroll bars. */
7697
7698 static XtActionHookId action_hook_id;
7699
7700 /* Lisp window being scrolled. Set when starting to interact with
7701 a toolkit scroll bar, reset to nil when ending the interaction. */
7702
7703 static Lisp_Object window_being_scrolled;
7704
7705 /* Last scroll bar part sent in xm_scroll_callback. */
7706
7707 static int last_scroll_bar_part;
7708
7709 /* Whether this is an Xaw with arrow-scrollbars. This should imply
7710 that movements of 1/20 of the screen size are mapped to up/down. */
7711
7712 static Boolean xaw3d_arrow_scroll;
7713
7714 /* Whether the drag scrolling maintains the mouse at the top of the
7715 thumb. If not, resizing the thumb needs to be done more carefully
7716 to avoid jerkyness. */
7717
7718 static Boolean xaw3d_pick_top;
7719
7720
7721 /* Action hook installed via XtAppAddActionHook when toolkit scroll
7722 bars are used.. The hook is responsible for detecting when
7723 the user ends an interaction with the scroll bar, and generates
7724 a `end-scroll' scroll_bar_click' event if so. */
7725
7726 static void
7727 xt_action_hook (widget, client_data, action_name, event, params,
7728 num_params)
7729 Widget widget;
7730 XtPointer client_data;
7731 String action_name;
7732 XEvent *event;
7733 String *params;
7734 Cardinal *num_params;
7735 {
7736 int scroll_bar_p;
7737 char *end_action;
7738
7739 #ifdef USE_MOTIF
7740 scroll_bar_p = XmIsScrollBar (widget);
7741 end_action = "Release";
7742 #else /* !USE_MOTIF i.e. use Xaw */
7743 scroll_bar_p = XtIsSubclass (widget, scrollbarWidgetClass);
7744 end_action = "EndScroll";
7745 #endif /* USE_MOTIF */
7746
7747 if (scroll_bar_p
7748 && strcmp (action_name, end_action) == 0
7749 && WINDOWP (window_being_scrolled))
7750 {
7751 struct window *w;
7752
7753 x_send_scroll_bar_event (window_being_scrolled,
7754 scroll_bar_end_scroll, 0, 0);
7755 w = XWINDOW (window_being_scrolled);
7756 XSCROLL_BAR (w->vertical_scroll_bar)->dragging = Qnil;
7757 window_being_scrolled = Qnil;
7758 last_scroll_bar_part = -1;
7759
7760 /* Xt timeouts no longer needed. */
7761 toolkit_scroll_bar_interaction = 0;
7762 }
7763 }
7764
7765 /* A vector of windows used for communication between
7766 x_send_scroll_bar_event and x_scroll_bar_to_input_event. */
7767
7768 static struct window **scroll_bar_windows;
7769 static int scroll_bar_windows_size;
7770
7771
7772 /* Send a client message with message type Xatom_Scrollbar for a
7773 scroll action to the frame of WINDOW. PART is a value identifying
7774 the part of the scroll bar that was clicked on. PORTION is the
7775 amount to scroll of a whole of WHOLE. */
7776
7777 static void
7778 x_send_scroll_bar_event (window, part, portion, whole)
7779 Lisp_Object window;
7780 int part, portion, whole;
7781 {
7782 XEvent event;
7783 XClientMessageEvent *ev = (XClientMessageEvent *) &event;
7784 struct window *w = XWINDOW (window);
7785 struct frame *f = XFRAME (w->frame);
7786 int i;
7787
7788 BLOCK_INPUT;
7789
7790 /* Construct a ClientMessage event to send to the frame. */
7791 ev->type = ClientMessage;
7792 ev->message_type = FRAME_X_DISPLAY_INFO (f)->Xatom_Scrollbar;
7793 ev->display = FRAME_X_DISPLAY (f);
7794 ev->window = FRAME_X_WINDOW (f);
7795 ev->format = 32;
7796
7797 /* We can only transfer 32 bits in the XClientMessageEvent, which is
7798 not enough to store a pointer or Lisp_Object on a 64 bit system.
7799 So, store the window in scroll_bar_windows and pass the index
7800 into that array in the event. */
7801 for (i = 0; i < scroll_bar_windows_size; ++i)
7802 if (scroll_bar_windows[i] == NULL)
7803 break;
7804
7805 if (i == scroll_bar_windows_size)
7806 {
7807 int new_size = max (10, 2 * scroll_bar_windows_size);
7808 size_t nbytes = new_size * sizeof *scroll_bar_windows;
7809 size_t old_nbytes = scroll_bar_windows_size * sizeof *scroll_bar_windows;
7810
7811 scroll_bar_windows = (struct window **) xrealloc (scroll_bar_windows,
7812 nbytes);
7813 bzero (&scroll_bar_windows[i], nbytes - old_nbytes);
7814 scroll_bar_windows_size = new_size;
7815 }
7816
7817 scroll_bar_windows[i] = w;
7818 ev->data.l[0] = (long) i;
7819 ev->data.l[1] = (long) part;
7820 ev->data.l[2] = (long) 0;
7821 ev->data.l[3] = (long) portion;
7822 ev->data.l[4] = (long) whole;
7823
7824 /* Make Xt timeouts work while the scroll bar is active. */
7825 toolkit_scroll_bar_interaction = 1;
7826
7827 /* Setting the event mask to zero means that the message will
7828 be sent to the client that created the window, and if that
7829 window no longer exists, no event will be sent. */
7830 XSendEvent (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), False, 0, &event);
7831 UNBLOCK_INPUT;
7832 }
7833
7834
7835 /* Transform a scroll bar ClientMessage EVENT to an Emacs input event
7836 in *IEVENT. */
7837
7838 static void
7839 x_scroll_bar_to_input_event (event, ievent)
7840 XEvent *event;
7841 struct input_event *ievent;
7842 {
7843 XClientMessageEvent *ev = (XClientMessageEvent *) event;
7844 Lisp_Object window;
7845 struct frame *f;
7846 struct window *w;
7847
7848 w = scroll_bar_windows[ev->data.l[0]];
7849 scroll_bar_windows[ev->data.l[0]] = NULL;
7850
7851 XSETWINDOW (window, w);
7852 f = XFRAME (w->frame);
7853
7854 ievent->kind = scroll_bar_click;
7855 ievent->frame_or_window = window;
7856 ievent->arg = Qnil;
7857 ievent->timestamp = XtLastTimestampProcessed (FRAME_X_DISPLAY (f));
7858 ievent->part = ev->data.l[1];
7859 ievent->code = ev->data.l[2];
7860 ievent->x = make_number ((int) ev->data.l[3]);
7861 ievent->y = make_number ((int) ev->data.l[4]);
7862 ievent->modifiers = 0;
7863 }
7864
7865
7866 #ifdef USE_MOTIF
7867
7868 /* Minimum and maximum values used for Motif scroll bars. */
7869
7870 #define XM_SB_MIN 1
7871 #define XM_SB_MAX 10000000
7872 #define XM_SB_RANGE (XM_SB_MAX - XM_SB_MIN)
7873
7874
7875 /* Scroll bar callback for Motif scroll bars. WIDGET is the scroll
7876 bar widget. CLIENT_DATA is a pointer to the scroll_bar structure.
7877 CALL_DATA is a pointer a a XmScrollBarCallbackStruct. */
7878
7879 static void
7880 xm_scroll_callback (widget, client_data, call_data)
7881 Widget widget;
7882 XtPointer client_data, call_data;
7883 {
7884 struct scroll_bar *bar = (struct scroll_bar *) client_data;
7885 XmScrollBarCallbackStruct *cs = (XmScrollBarCallbackStruct *) call_data;
7886 double percent;
7887 int part = -1, whole = 0, portion = 0;
7888
7889 switch (cs->reason)
7890 {
7891 case XmCR_DECREMENT:
7892 bar->dragging = Qnil;
7893 part = scroll_bar_up_arrow;
7894 break;
7895
7896 case XmCR_INCREMENT:
7897 bar->dragging = Qnil;
7898 part = scroll_bar_down_arrow;
7899 break;
7900
7901 case XmCR_PAGE_DECREMENT:
7902 bar->dragging = Qnil;
7903 part = scroll_bar_above_handle;
7904 break;
7905
7906 case XmCR_PAGE_INCREMENT:
7907 bar->dragging = Qnil;
7908 part = scroll_bar_below_handle;
7909 break;
7910
7911 case XmCR_TO_TOP:
7912 bar->dragging = Qnil;
7913 part = scroll_bar_to_top;
7914 break;
7915
7916 case XmCR_TO_BOTTOM:
7917 bar->dragging = Qnil;
7918 part = scroll_bar_to_bottom;
7919 break;
7920
7921 case XmCR_DRAG:
7922 {
7923 int slider_size;
7924 int dragging_down_p = (INTEGERP (bar->dragging)
7925 && XINT (bar->dragging) <= cs->value);
7926
7927 /* Get the slider size. */
7928 BLOCK_INPUT;
7929 XtVaGetValues (widget, XmNsliderSize, &slider_size, NULL);
7930 UNBLOCK_INPUT;
7931
7932 /* At the max position of the scroll bar, do a line-wise
7933 movement. Without doing anything, the LessTif scroll bar
7934 calls us with the same cs->value again and again. If we
7935 want to make sure that we can reach the end of the buffer,
7936 we have to do something.
7937
7938 Implementation note: setting bar->dragging always to
7939 cs->value gives a smoother movement at the max position.
7940 Setting it to nil when doing line-wise movement gives
7941 a better slider behavior. */
7942
7943 if (cs->value + slider_size == XM_SB_MAX
7944 || (dragging_down_p
7945 && last_scroll_bar_part == scroll_bar_down_arrow))
7946 {
7947 part = scroll_bar_down_arrow;
7948 bar->dragging = Qnil;
7949 }
7950 else
7951 {
7952 whole = XM_SB_RANGE;
7953 portion = min (cs->value - XM_SB_MIN, XM_SB_MAX - slider_size);
7954 part = scroll_bar_handle;
7955 bar->dragging = make_number (cs->value);
7956 }
7957 }
7958 break;
7959
7960 case XmCR_VALUE_CHANGED:
7961 break;
7962 };
7963
7964 if (part >= 0)
7965 {
7966 window_being_scrolled = bar->window;
7967 last_scroll_bar_part = part;
7968 x_send_scroll_bar_event (bar->window, part, portion, whole);
7969 }
7970 }
7971
7972
7973 #else /* !USE_MOTIF, i.e. Xaw. */
7974
7975
7976 /* Xaw scroll bar callback. Invoked when the thumb is dragged.
7977 WIDGET is the scroll bar widget. CLIENT_DATA is a pointer to the
7978 scroll bar struct. CALL_DATA is a pointer to a float saying where
7979 the thumb is. */
7980
7981 static void
7982 xaw_jump_callback (widget, client_data, call_data)
7983 Widget widget;
7984 XtPointer client_data, call_data;
7985 {
7986 struct scroll_bar *bar = (struct scroll_bar *) client_data;
7987 float top = *(float *) call_data;
7988 float shown;
7989 int whole, portion, height;
7990 int part;
7991
7992 /* Get the size of the thumb, a value between 0 and 1. */
7993 BLOCK_INPUT;
7994 XtVaGetValues (widget, XtNshown, &shown, XtNheight, &height, NULL);
7995 UNBLOCK_INPUT;
7996
7997 whole = 10000000;
7998 portion = shown < 1 ? top * whole : 0;
7999
8000 if (shown < 1 && (abs (top + shown - 1) < 1.0/height))
8001 /* Some derivatives of Xaw refuse to shrink the thumb when you reach
8002 the bottom, so we force the scrolling whenever we see that we're
8003 too close to the bottom (in x_set_toolkit_scroll_bar_thumb
8004 we try to ensure that we always stay two pixels away from the
8005 bottom). */
8006 part = scroll_bar_down_arrow;
8007 else
8008 part = scroll_bar_handle;
8009
8010 window_being_scrolled = bar->window;
8011 bar->dragging = make_number (portion);
8012 last_scroll_bar_part = part;
8013 x_send_scroll_bar_event (bar->window, part, portion, whole);
8014 }
8015
8016
8017 /* Xaw scroll bar callback. Invoked for incremental scrolling.,
8018 i.e. line or page up or down. WIDGET is the Xaw scroll bar
8019 widget. CLIENT_DATA is a pointer to the scroll_bar structure for
8020 the scroll bar. CALL_DATA is an integer specifying the action that
8021 has taken place. It's magnitude is in the range 0..height of the
8022 scroll bar. Negative values mean scroll towards buffer start.
8023 Values < height of scroll bar mean line-wise movement. */
8024
8025 static void
8026 xaw_scroll_callback (widget, client_data, call_data)
8027 Widget widget;
8028 XtPointer client_data, call_data;
8029 {
8030 struct scroll_bar *bar = (struct scroll_bar *) client_data;
8031 int position = (int) call_data;
8032 Dimension height;
8033 int part;
8034
8035 /* Get the height of the scroll bar. */
8036 BLOCK_INPUT;
8037 XtVaGetValues (widget, XtNheight, &height, NULL);
8038 UNBLOCK_INPUT;
8039
8040 if (abs (position) >= height)
8041 part = (position < 0) ? scroll_bar_above_handle : scroll_bar_below_handle;
8042
8043 /* If Xaw3d was compiled with ARROW_SCROLLBAR,
8044 it maps line-movement to call_data = max(5, height/20). */
8045 else if (xaw3d_arrow_scroll && abs (position) <= max (5, height / 20))
8046 part = (position < 0) ? scroll_bar_up_arrow : scroll_bar_down_arrow;
8047 else
8048 part = scroll_bar_move_ratio;
8049
8050 window_being_scrolled = bar->window;
8051 bar->dragging = Qnil;
8052 last_scroll_bar_part = part;
8053 x_send_scroll_bar_event (bar->window, part, position, height);
8054 }
8055
8056
8057 #endif /* not USE_MOTIF */
8058
8059
8060 /* Create the widget for scroll bar BAR on frame F. Record the widget
8061 and X window of the scroll bar in BAR. */
8062
8063 static void
8064 x_create_toolkit_scroll_bar (f, bar)
8065 struct frame *f;
8066 struct scroll_bar *bar;
8067 {
8068 Window xwindow;
8069 Widget widget;
8070 Arg av[20];
8071 int ac = 0;
8072 char *scroll_bar_name = "verticalScrollBar";
8073 unsigned long pixel;
8074
8075 BLOCK_INPUT;
8076
8077 #ifdef USE_MOTIF
8078 /* LessTif 0.85, problems:
8079
8080 1. When the mouse if over the scroll bar, the scroll bar will
8081 get keyboard events. I didn't find a way to turn this off.
8082
8083 2. Do we have to explicitly set the cursor to get an arrow
8084 cursor (see below)? */
8085
8086 /* Set resources. Create the widget. */
8087 XtSetArg (av[ac], XtNmappedWhenManaged, False); ++ac;
8088 XtSetArg (av[ac], XmNminimum, XM_SB_MIN); ++ac;
8089 XtSetArg (av[ac], XmNmaximum, XM_SB_MAX); ++ac;
8090 XtSetArg (av[ac], XmNorientation, XmVERTICAL); ++ac;
8091 XtSetArg (av[ac], XmNprocessingDirection, XmMAX_ON_BOTTOM), ++ac;
8092 XtSetArg (av[ac], XmNincrement, 1); ++ac;
8093 XtSetArg (av[ac], XmNpageIncrement, 1); ++ac;
8094
8095 pixel = f->output_data.x->scroll_bar_foreground_pixel;
8096 if (pixel != -1)
8097 {
8098 XtSetArg (av[ac], XmNforeground, pixel);
8099 ++ac;
8100 }
8101
8102 pixel = f->output_data.x->scroll_bar_background_pixel;
8103 if (pixel != -1)
8104 {
8105 XtSetArg (av[ac], XmNbackground, pixel);
8106 ++ac;
8107 }
8108
8109 widget = XmCreateScrollBar (f->output_data.x->edit_widget,
8110 scroll_bar_name, av, ac);
8111
8112 /* Add one callback for everything that can happen. */
8113 XtAddCallback (widget, XmNdecrementCallback, xm_scroll_callback,
8114 (XtPointer) bar);
8115 XtAddCallback (widget, XmNdragCallback, xm_scroll_callback,
8116 (XtPointer) bar);
8117 XtAddCallback (widget, XmNincrementCallback, xm_scroll_callback,
8118 (XtPointer) bar);
8119 XtAddCallback (widget, XmNpageDecrementCallback, xm_scroll_callback,
8120 (XtPointer) bar);
8121 XtAddCallback (widget, XmNpageIncrementCallback, xm_scroll_callback,
8122 (XtPointer) bar);
8123 XtAddCallback (widget, XmNtoBottomCallback, xm_scroll_callback,
8124 (XtPointer) bar);
8125 XtAddCallback (widget, XmNtoTopCallback, xm_scroll_callback,
8126 (XtPointer) bar);
8127
8128 /* Realize the widget. Only after that is the X window created. */
8129 XtRealizeWidget (widget);
8130
8131 /* Set the cursor to an arrow. I didn't find a resource to do that.
8132 And I'm wondering why it hasn't an arrow cursor by default. */
8133 XDefineCursor (XtDisplay (widget), XtWindow (widget),
8134 f->output_data.x->nontext_cursor);
8135
8136 #else /* !USE_MOTIF i.e. use Xaw */
8137
8138 /* Set resources. Create the widget. The background of the
8139 Xaw3d scroll bar widget is a little bit light for my taste.
8140 We don't alter it here to let users change it according
8141 to their taste with `emacs*verticalScrollBar.background: xxx'. */
8142 XtSetArg (av[ac], XtNmappedWhenManaged, False); ++ac;
8143 XtSetArg (av[ac], XtNorientation, XtorientVertical); ++ac;
8144 /* For smoother scrolling with Xaw3d -sm */
8145 /* XtSetArg (av[ac], XtNpickTop, True); ++ac; */
8146 /* XtSetArg (av[ac], XtNbeNiceToColormap, True); ++ac; */
8147
8148 pixel = f->output_data.x->scroll_bar_foreground_pixel;
8149 if (pixel != -1)
8150 {
8151 XtSetArg (av[ac], XtNforeground, pixel);
8152 ++ac;
8153 }
8154
8155 pixel = f->output_data.x->scroll_bar_background_pixel;
8156 if (pixel != -1)
8157 {
8158 XtSetArg (av[ac], XtNbackground, pixel);
8159 ++ac;
8160 }
8161
8162 widget = XtCreateWidget (scroll_bar_name, scrollbarWidgetClass,
8163 f->output_data.x->edit_widget, av, ac);
8164
8165 {
8166 char *initial = "";
8167 char *val = initial;
8168 XtVaGetValues (widget, XtNscrollVCursor, (XtPointer) &val,
8169 XtNpickTop, (XtPointer) &xaw3d_pick_top, NULL);
8170 if (val == initial)
8171 { /* ARROW_SCROLL */
8172 xaw3d_arrow_scroll = True;
8173 /* Isn't that just a personal preference ? -sm */
8174 XtVaSetValues (widget, XtNcursorName, "top_left_arrow", NULL);
8175 }
8176 }
8177
8178 /* Define callbacks. */
8179 XtAddCallback (widget, XtNjumpProc, xaw_jump_callback, (XtPointer) bar);
8180 XtAddCallback (widget, XtNscrollProc, xaw_scroll_callback,
8181 (XtPointer) bar);
8182
8183 /* Realize the widget. Only after that is the X window created. */
8184 XtRealizeWidget (widget);
8185
8186 #endif /* !USE_MOTIF */
8187
8188 /* Install an action hook that let's us detect when the user
8189 finishes interacting with a scroll bar. */
8190 if (action_hook_id == 0)
8191 action_hook_id = XtAppAddActionHook (Xt_app_con, xt_action_hook, 0);
8192
8193 /* Remember X window and widget in the scroll bar vector. */
8194 SET_SCROLL_BAR_X_WIDGET (bar, widget);
8195 xwindow = XtWindow (widget);
8196 SET_SCROLL_BAR_X_WINDOW (bar, xwindow);
8197
8198 UNBLOCK_INPUT;
8199 }
8200
8201
8202 /* Set the thumb size and position of scroll bar BAR. We are currently
8203 displaying PORTION out of a whole WHOLE, and our position POSITION. */
8204
8205 static void
8206 x_set_toolkit_scroll_bar_thumb (bar, portion, position, whole)
8207 struct scroll_bar *bar;
8208 int portion, position, whole;
8209 {
8210 struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
8211 Widget widget = SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar);
8212 float top, shown;
8213
8214 if (whole == 0)
8215 top = 0, shown = 1;
8216 else
8217 {
8218 top = (float) position / whole;
8219 shown = (float) portion / whole;
8220 }
8221
8222 BLOCK_INPUT;
8223
8224 #ifdef USE_MOTIF
8225 {
8226 int size, value;
8227 Boolean arrow1_selected, arrow2_selected;
8228 unsigned char flags;
8229 XmScrollBarWidget sb;
8230
8231 /* Slider size. Must be in the range [1 .. MAX - MIN] where MAX
8232 is the scroll bar's maximum and MIN is the scroll bar's minimum
8233 value. */
8234 size = shown * XM_SB_RANGE;
8235 size = min (size, XM_SB_RANGE);
8236 size = max (size, 1);
8237
8238 /* Position. Must be in the range [MIN .. MAX - SLIDER_SIZE]. */
8239 value = top * XM_SB_RANGE;
8240 value = min (value, XM_SB_MAX - size);
8241 value = max (value, XM_SB_MIN);
8242
8243 /* LessTif: Calling XmScrollBarSetValues after an increment or
8244 decrement turns off auto-repeat LessTif-internally. This can
8245 be seen in ScrollBar.c which resets Arrow1Selected and
8246 Arrow2Selected. It also sets internal flags so that LessTif
8247 believes the mouse is in the slider. We either have to change
8248 our code, or work around that by accessing private data. */
8249
8250 sb = (XmScrollBarWidget) widget;
8251 arrow1_selected = sb->scrollBar.arrow1_selected;
8252 arrow2_selected = sb->scrollBar.arrow2_selected;
8253 flags = sb->scrollBar.flags;
8254
8255 if (NILP (bar->dragging))
8256 XmScrollBarSetValues (widget, value, size, 0, 0, False);
8257 else if (last_scroll_bar_part == scroll_bar_down_arrow)
8258 /* This has the negative side effect that the slider value is
8259 not what it would be if we scrolled here using line-wise or
8260 page-wise movement. */
8261 XmScrollBarSetValues (widget, value, XM_SB_RANGE - value, 0, 0, False);
8262 else
8263 {
8264 /* If currently dragging, only update the slider size.
8265 This reduces flicker effects. */
8266 int old_value, old_size, increment, page_increment;
8267
8268 XmScrollBarGetValues (widget, &old_value, &old_size,
8269 &increment, &page_increment);
8270 XmScrollBarSetValues (widget, old_value,
8271 min (size, XM_SB_RANGE - old_value),
8272 0, 0, False);
8273 }
8274
8275 sb->scrollBar.arrow1_selected = arrow1_selected;
8276 sb->scrollBar.arrow2_selected = arrow2_selected;
8277 sb->scrollBar.flags = flags;
8278 }
8279 #else /* !USE_MOTIF i.e. use Xaw */
8280 {
8281 float old_top, old_shown;
8282 Dimension height;
8283 XtVaGetValues (widget,
8284 XtNtopOfThumb, &old_top,
8285 XtNshown, &old_shown,
8286 XtNheight, &height,
8287 NULL);
8288
8289 /* Massage the top+shown values. */
8290 if (NILP (bar->dragging) || last_scroll_bar_part == scroll_bar_down_arrow)
8291 top = max (0, min (1, top));
8292 else
8293 top = old_top;
8294 /* Keep two pixels available for moving the thumb down. */
8295 shown = max (0, min (1 - top - (2.0 / height), shown));
8296
8297 /* If the call to XawScrollbarSetThumb below doesn't seem to work,
8298 check that your system's configuration file contains a define
8299 for `NARROWPROTO'. See s/freebsd.h for an example. */
8300 if (top != old_top || shown != old_shown)
8301 {
8302 if (NILP (bar->dragging))
8303 XawScrollbarSetThumb (widget, top, shown);
8304 else
8305 {
8306 #ifdef HAVE_XAW3D
8307 ScrollbarWidget sb = (ScrollbarWidget) widget;
8308 int scroll_mode = 0;
8309
8310 /* `scroll_mode' only exists with Xaw3d + ARROW_SCROLLBAR. */
8311 if (xaw3d_arrow_scroll)
8312 {
8313 /* Xaw3d stupidly ignores resize requests while dragging
8314 so we have to make it believe it's not in dragging mode. */
8315 scroll_mode = sb->scrollbar.scroll_mode;
8316 if (scroll_mode == 2)
8317 sb->scrollbar.scroll_mode = 0;
8318 }
8319 #endif
8320 /* Try to make the scrolling a tad smoother. */
8321 if (!xaw3d_pick_top)
8322 shown = min (shown, old_shown);
8323
8324 XawScrollbarSetThumb (widget, top, shown);
8325
8326 #ifdef HAVE_XAW3D
8327 if (xaw3d_arrow_scroll && scroll_mode == 2)
8328 sb->scrollbar.scroll_mode = scroll_mode;
8329 #endif
8330 }
8331 }
8332 }
8333 #endif /* !USE_MOTIF */
8334
8335 UNBLOCK_INPUT;
8336 }
8337
8338 #endif /* USE_TOOLKIT_SCROLL_BARS */
8339
8340
8341 \f
8342 /************************************************************************
8343 Scroll bars, general
8344 ************************************************************************/
8345
8346 /* Create a scroll bar and return the scroll bar vector for it. W is
8347 the Emacs window on which to create the scroll bar. TOP, LEFT,
8348 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
8349 scroll bar. */
8350
8351 static struct scroll_bar *
8352 x_scroll_bar_create (w, top, left, width, height)
8353 struct window *w;
8354 int top, left, width, height;
8355 {
8356 struct frame *f = XFRAME (w->frame);
8357 struct scroll_bar *bar
8358 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE), Qnil));
8359
8360 BLOCK_INPUT;
8361
8362 #ifdef USE_TOOLKIT_SCROLL_BARS
8363 x_create_toolkit_scroll_bar (f, bar);
8364 #else /* not USE_TOOLKIT_SCROLL_BARS */
8365 {
8366 XSetWindowAttributes a;
8367 unsigned long mask;
8368 Window window;
8369
8370 a.background_pixel = f->output_data.x->scroll_bar_background_pixel;
8371 if (a.background_pixel == -1)
8372 a.background_pixel = f->output_data.x->background_pixel;
8373
8374 a.event_mask = (ButtonPressMask | ButtonReleaseMask
8375 | ButtonMotionMask | PointerMotionHintMask
8376 | ExposureMask);
8377 a.cursor = FRAME_X_DISPLAY_INFO (f)->vertical_scroll_bar_cursor;
8378
8379 mask = (CWBackPixel | CWEventMask | CWCursor);
8380
8381 /* Clear the area of W that will serve as a scroll bar. This is
8382 for the case that a window has been split horizontally. In
8383 this case, no clear_frame is generated to reduce flickering. */
8384 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
8385 left, top, width,
8386 window_box_height (w), False);
8387
8388 window = XCreateWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
8389 /* Position and size of scroll bar. */
8390 left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
8391 top,
8392 width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
8393 height,
8394 /* Border width, depth, class, and visual. */
8395 0,
8396 CopyFromParent,
8397 CopyFromParent,
8398 CopyFromParent,
8399 /* Attributes. */
8400 mask, &a);
8401 SET_SCROLL_BAR_X_WINDOW (bar, window);
8402 }
8403 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8404
8405 XSETWINDOW (bar->window, w);
8406 XSETINT (bar->top, top);
8407 XSETINT (bar->left, left);
8408 XSETINT (bar->width, width);
8409 XSETINT (bar->height, height);
8410 XSETINT (bar->start, 0);
8411 XSETINT (bar->end, 0);
8412 bar->dragging = Qnil;
8413
8414 /* Add bar to its frame's list of scroll bars. */
8415 bar->next = FRAME_SCROLL_BARS (f);
8416 bar->prev = Qnil;
8417 XSETVECTOR (FRAME_SCROLL_BARS (f), bar);
8418 if (!NILP (bar->next))
8419 XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
8420
8421 /* Map the window/widget. */
8422 #ifdef USE_TOOLKIT_SCROLL_BARS
8423 {
8424 Widget scroll_bar = SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar);
8425 XtConfigureWidget (scroll_bar,
8426 left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
8427 top,
8428 width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
8429 height, 0);
8430 XtMapWidget (scroll_bar);
8431 }
8432 #else /* not USE_TOOLKIT_SCROLL_BARS */
8433 XMapRaised (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (bar));
8434 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8435
8436 UNBLOCK_INPUT;
8437 return bar;
8438 }
8439
8440
8441 /* Draw BAR's handle in the proper position.
8442
8443 If the handle is already drawn from START to END, don't bother
8444 redrawing it, unless REBUILD is non-zero; in that case, always
8445 redraw it. (REBUILD is handy for drawing the handle after expose
8446 events.)
8447
8448 Normally, we want to constrain the start and end of the handle to
8449 fit inside its rectangle, but if the user is dragging the scroll
8450 bar handle, we want to let them drag it down all the way, so that
8451 the bar's top is as far down as it goes; otherwise, there's no way
8452 to move to the very end of the buffer. */
8453
8454 #ifndef USE_TOOLKIT_SCROLL_BARS
8455
8456 static void
8457 x_scroll_bar_set_handle (bar, start, end, rebuild)
8458 struct scroll_bar *bar;
8459 int start, end;
8460 int rebuild;
8461 {
8462 int dragging = ! NILP (bar->dragging);
8463 Window w = SCROLL_BAR_X_WINDOW (bar);
8464 FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
8465 GC gc = f->output_data.x->normal_gc;
8466
8467 /* If the display is already accurate, do nothing. */
8468 if (! rebuild
8469 && start == XINT (bar->start)
8470 && end == XINT (bar->end))
8471 return;
8472
8473 BLOCK_INPUT;
8474
8475 {
8476 int inside_width = VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f, XINT (bar->width));
8477 int inside_height = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f, XINT (bar->height));
8478 int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
8479
8480 /* Make sure the values are reasonable, and try to preserve
8481 the distance between start and end. */
8482 {
8483 int length = end - start;
8484
8485 if (start < 0)
8486 start = 0;
8487 else if (start > top_range)
8488 start = top_range;
8489 end = start + length;
8490
8491 if (end < start)
8492 end = start;
8493 else if (end > top_range && ! dragging)
8494 end = top_range;
8495 }
8496
8497 /* Store the adjusted setting in the scroll bar. */
8498 XSETINT (bar->start, start);
8499 XSETINT (bar->end, end);
8500
8501 /* Clip the end position, just for display. */
8502 if (end > top_range)
8503 end = top_range;
8504
8505 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
8506 below top positions, to make sure the handle is always at least
8507 that many pixels tall. */
8508 end += VERTICAL_SCROLL_BAR_MIN_HANDLE;
8509
8510 /* Draw the empty space above the handle. Note that we can't clear
8511 zero-height areas; that means "clear to end of window." */
8512 if (0 < start)
8513 x_clear_area (FRAME_X_DISPLAY (f), w,
8514 /* x, y, width, height, and exposures. */
8515 VERTICAL_SCROLL_BAR_LEFT_BORDER,
8516 VERTICAL_SCROLL_BAR_TOP_BORDER,
8517 inside_width, start,
8518 False);
8519
8520 /* Change to proper foreground color if one is specified. */
8521 if (f->output_data.x->scroll_bar_foreground_pixel != -1)
8522 XSetForeground (FRAME_X_DISPLAY (f), gc,
8523 f->output_data.x->scroll_bar_foreground_pixel);
8524
8525 /* Draw the handle itself. */
8526 XFillRectangle (FRAME_X_DISPLAY (f), w, gc,
8527
8528 /* x, y, width, height */
8529 VERTICAL_SCROLL_BAR_LEFT_BORDER,
8530 VERTICAL_SCROLL_BAR_TOP_BORDER + start,
8531 inside_width, end - start);
8532
8533 /* Restore the foreground color of the GC if we changed it above. */
8534 if (f->output_data.x->scroll_bar_foreground_pixel != -1)
8535 XSetForeground (FRAME_X_DISPLAY (f), gc,
8536 f->output_data.x->foreground_pixel);
8537
8538 /* Draw the empty space below the handle. Note that we can't
8539 clear zero-height areas; that means "clear to end of window." */
8540 if (end < inside_height)
8541 x_clear_area (FRAME_X_DISPLAY (f), w,
8542 /* x, y, width, height, and exposures. */
8543 VERTICAL_SCROLL_BAR_LEFT_BORDER,
8544 VERTICAL_SCROLL_BAR_TOP_BORDER + end,
8545 inside_width, inside_height - end,
8546 False);
8547
8548 }
8549
8550 UNBLOCK_INPUT;
8551 }
8552
8553 #endif /* !USE_TOOLKIT_SCROLL_BARS */
8554
8555 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
8556 nil. */
8557
8558 static void
8559 x_scroll_bar_remove (bar)
8560 struct scroll_bar *bar;
8561 {
8562 struct frame *f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
8563 BLOCK_INPUT;
8564
8565 #ifdef USE_TOOLKIT_SCROLL_BARS
8566 XtDestroyWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar));
8567 #else
8568 XDestroyWindow (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (bar));
8569 #endif
8570
8571 /* Disassociate this scroll bar from its window. */
8572 XWINDOW (bar->window)->vertical_scroll_bar = Qnil;
8573
8574 UNBLOCK_INPUT;
8575 }
8576
8577
8578 /* Set the handle of the vertical scroll bar for WINDOW to indicate
8579 that we are displaying PORTION characters out of a total of WHOLE
8580 characters, starting at POSITION. If WINDOW has no scroll bar,
8581 create one. */
8582
8583 static void
8584 XTset_vertical_scroll_bar (w, portion, whole, position)
8585 struct window *w;
8586 int portion, whole, position;
8587 {
8588 struct frame *f = XFRAME (w->frame);
8589 struct scroll_bar *bar;
8590 int top, height, left, sb_left, width, sb_width;
8591 int window_x, window_y, window_width, window_height;
8592
8593 /* Get window dimensions. */
8594 window_box (w, -1, &window_x, &window_y, &window_width, &window_height);
8595 top = window_y;
8596 width = FRAME_SCROLL_BAR_COLS (f) * CANON_X_UNIT (f);
8597 height = window_height;
8598
8599 /* Compute the left edge of the scroll bar area. */
8600 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
8601 left = XINT (w->left) + XINT (w->width) - FRAME_SCROLL_BAR_COLS (f);
8602 else
8603 left = XFASTINT (w->left);
8604 left *= CANON_X_UNIT (f);
8605 left += FRAME_INTERNAL_BORDER_WIDTH (f);
8606
8607 /* Compute the width of the scroll bar which might be less than
8608 the width of the area reserved for the scroll bar. */
8609 if (FRAME_SCROLL_BAR_PIXEL_WIDTH (f) > 0)
8610 sb_width = FRAME_SCROLL_BAR_PIXEL_WIDTH (f);
8611 else
8612 sb_width = width;
8613
8614 /* Compute the left edge of the scroll bar. */
8615 #ifdef USE_TOOLKIT_SCROLL_BARS
8616 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
8617 sb_left = left + width - sb_width - (width - sb_width) / 2;
8618 else
8619 sb_left = left + (width - sb_width) / 2;
8620 #else
8621 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f))
8622 sb_left = left + width - sb_width;
8623 else
8624 sb_left = left;
8625 #endif
8626
8627 /* Does the scroll bar exist yet? */
8628 if (NILP (w->vertical_scroll_bar))
8629 {
8630 BLOCK_INPUT;
8631 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
8632 left, top, width, height, False);
8633 UNBLOCK_INPUT;
8634 bar = x_scroll_bar_create (w, top, sb_left, sb_width, height);
8635 }
8636 else
8637 {
8638 /* It may just need to be moved and resized. */
8639 unsigned int mask = 0;
8640
8641 bar = XSCROLL_BAR (w->vertical_scroll_bar);
8642
8643 BLOCK_INPUT;
8644
8645 if (sb_left != XINT (bar->left))
8646 mask |= CWX;
8647 if (top != XINT (bar->top))
8648 mask |= CWY;
8649 if (sb_width != XINT (bar->width))
8650 mask |= CWWidth;
8651 if (height != XINT (bar->height))
8652 mask |= CWHeight;
8653
8654 #ifdef USE_TOOLKIT_SCROLL_BARS
8655
8656 /* Since toolkit scroll bars are smaller than the space reserved
8657 for them on the frame, we have to clear "under" them. */
8658 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
8659 left, top, width, height, False);
8660
8661 /* Move/size the scroll bar widget. */
8662 if (mask)
8663 XtConfigureWidget (SCROLL_BAR_X_WIDGET (FRAME_X_DISPLAY (f), bar),
8664 sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM,
8665 top,
8666 sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2,
8667 height, 0);
8668
8669 #else /* not USE_TOOLKIT_SCROLL_BARS */
8670
8671 if (VERTICAL_SCROLL_BAR_WIDTH_TRIM)
8672 {
8673 /* Clear areas not covered by the scroll bar. This makes sure a
8674 previous mode line display is cleared after C-x 2 C-x 1, for
8675 example. Non-toolkit scroll bars are as wide as the area
8676 reserved for scroll bars - trim at both sides. */
8677 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
8678 left, top, VERTICAL_SCROLL_BAR_WIDTH_TRIM,
8679 height, False);
8680 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
8681 left + width - VERTICAL_SCROLL_BAR_WIDTH_TRIM,
8682 top, VERTICAL_SCROLL_BAR_WIDTH_TRIM,
8683 height, False);
8684 }
8685
8686 /* Move/size the scroll bar window. */
8687 if (mask)
8688 {
8689 XWindowChanges wc;
8690
8691 wc.x = sb_left + VERTICAL_SCROLL_BAR_WIDTH_TRIM;
8692 wc.y = top;
8693 wc.width = sb_width - VERTICAL_SCROLL_BAR_WIDTH_TRIM * 2;
8694 wc.height = height;
8695 XConfigureWindow (FRAME_X_DISPLAY (f), SCROLL_BAR_X_WINDOW (bar),
8696 mask, &wc);
8697 }
8698
8699 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8700
8701 /* Remember new settings. */
8702 XSETINT (bar->left, sb_left);
8703 XSETINT (bar->top, top);
8704 XSETINT (bar->width, sb_width);
8705 XSETINT (bar->height, height);
8706
8707 UNBLOCK_INPUT;
8708 }
8709
8710 #ifdef USE_TOOLKIT_SCROLL_BARS
8711 x_set_toolkit_scroll_bar_thumb (bar, portion, position, whole);
8712 #else /* not USE_TOOLKIT_SCROLL_BARS */
8713 /* Set the scroll bar's current state, unless we're currently being
8714 dragged. */
8715 if (NILP (bar->dragging))
8716 {
8717 int top_range = VERTICAL_SCROLL_BAR_TOP_RANGE (f, height);
8718
8719 if (whole == 0)
8720 x_scroll_bar_set_handle (bar, 0, top_range, 0);
8721 else
8722 {
8723 int start = ((double) position * top_range) / whole;
8724 int end = ((double) (position + portion) * top_range) / whole;
8725 x_scroll_bar_set_handle (bar, start, end, 0);
8726 }
8727 }
8728 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8729
8730 XSETVECTOR (w->vertical_scroll_bar, bar);
8731 }
8732
8733
8734 /* The following three hooks are used when we're doing a thorough
8735 redisplay of the frame. We don't explicitly know which scroll bars
8736 are going to be deleted, because keeping track of when windows go
8737 away is a real pain - "Can you say set-window-configuration, boys
8738 and girls?" Instead, we just assert at the beginning of redisplay
8739 that *all* scroll bars are to be removed, and then save a scroll bar
8740 from the fiery pit when we actually redisplay its window. */
8741
8742 /* Arrange for all scroll bars on FRAME to be removed at the next call
8743 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
8744 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
8745
8746 static void
8747 XTcondemn_scroll_bars (frame)
8748 FRAME_PTR frame;
8749 {
8750 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
8751 while (! NILP (FRAME_SCROLL_BARS (frame)))
8752 {
8753 Lisp_Object bar;
8754 bar = FRAME_SCROLL_BARS (frame);
8755 FRAME_SCROLL_BARS (frame) = XSCROLL_BAR (bar)->next;
8756 XSCROLL_BAR (bar)->next = FRAME_CONDEMNED_SCROLL_BARS (frame);
8757 XSCROLL_BAR (bar)->prev = Qnil;
8758 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame)))
8759 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame))->prev = bar;
8760 FRAME_CONDEMNED_SCROLL_BARS (frame) = bar;
8761 }
8762 }
8763
8764
8765 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
8766 Note that WINDOW isn't necessarily condemned at all. */
8767
8768 static void
8769 XTredeem_scroll_bar (window)
8770 struct window *window;
8771 {
8772 struct scroll_bar *bar;
8773 struct frame *f;
8774
8775 /* We can't redeem this window's scroll bar if it doesn't have one. */
8776 if (NILP (window->vertical_scroll_bar))
8777 abort ();
8778
8779 bar = XSCROLL_BAR (window->vertical_scroll_bar);
8780
8781 /* Unlink it from the condemned list. */
8782 f = XFRAME (WINDOW_FRAME (window));
8783 if (NILP (bar->prev))
8784 {
8785 /* If the prev pointer is nil, it must be the first in one of
8786 the lists. */
8787 if (EQ (FRAME_SCROLL_BARS (f), window->vertical_scroll_bar))
8788 /* It's not condemned. Everything's fine. */
8789 return;
8790 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f),
8791 window->vertical_scroll_bar))
8792 FRAME_CONDEMNED_SCROLL_BARS (f) = bar->next;
8793 else
8794 /* If its prev pointer is nil, it must be at the front of
8795 one or the other! */
8796 abort ();
8797 }
8798 else
8799 XSCROLL_BAR (bar->prev)->next = bar->next;
8800
8801 if (! NILP (bar->next))
8802 XSCROLL_BAR (bar->next)->prev = bar->prev;
8803
8804 bar->next = FRAME_SCROLL_BARS (f);
8805 bar->prev = Qnil;
8806 XSETVECTOR (FRAME_SCROLL_BARS (f), bar);
8807 if (! NILP (bar->next))
8808 XSETVECTOR (XSCROLL_BAR (bar->next)->prev, bar);
8809 }
8810
8811 /* Remove all scroll bars on FRAME that haven't been saved since the
8812 last call to `*condemn_scroll_bars_hook'. */
8813
8814 static void
8815 XTjudge_scroll_bars (f)
8816 FRAME_PTR f;
8817 {
8818 Lisp_Object bar, next;
8819
8820 bar = FRAME_CONDEMNED_SCROLL_BARS (f);
8821
8822 /* Clear out the condemned list now so we won't try to process any
8823 more events on the hapless scroll bars. */
8824 FRAME_CONDEMNED_SCROLL_BARS (f) = Qnil;
8825
8826 for (; ! NILP (bar); bar = next)
8827 {
8828 struct scroll_bar *b = XSCROLL_BAR (bar);
8829
8830 x_scroll_bar_remove (b);
8831
8832 next = b->next;
8833 b->next = b->prev = Qnil;
8834 }
8835
8836 /* Now there should be no references to the condemned scroll bars,
8837 and they should get garbage-collected. */
8838 }
8839
8840
8841 /* Handle an Expose or GraphicsExpose event on a scroll bar. This
8842 is a no-op when using toolkit scroll bars.
8843
8844 This may be called from a signal handler, so we have to ignore GC
8845 mark bits. */
8846
8847 static void
8848 x_scroll_bar_expose (bar, event)
8849 struct scroll_bar *bar;
8850 XEvent *event;
8851 {
8852 #ifndef USE_TOOLKIT_SCROLL_BARS
8853
8854 Window w = SCROLL_BAR_X_WINDOW (bar);
8855 FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
8856 GC gc = f->output_data.x->normal_gc;
8857 int width_trim = VERTICAL_SCROLL_BAR_WIDTH_TRIM;
8858
8859 BLOCK_INPUT;
8860
8861 x_scroll_bar_set_handle (bar, XINT (bar->start), XINT (bar->end), 1);
8862
8863 /* Draw a one-pixel border just inside the edges of the scroll bar. */
8864 XDrawRectangle (FRAME_X_DISPLAY (f), w, gc,
8865
8866 /* x, y, width, height */
8867 0, 0,
8868 XINT (bar->width) - 1 - width_trim - width_trim,
8869 XINT (bar->height) - 1);
8870
8871 UNBLOCK_INPUT;
8872
8873 #endif /* not USE_TOOLKIT_SCROLL_BARS */
8874 }
8875
8876 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
8877 is set to something other than no_event, it is enqueued.
8878
8879 This may be called from a signal handler, so we have to ignore GC
8880 mark bits. */
8881
8882 #ifndef USE_TOOLKIT_SCROLL_BARS
8883
8884 static void
8885 x_scroll_bar_handle_click (bar, event, emacs_event)
8886 struct scroll_bar *bar;
8887 XEvent *event;
8888 struct input_event *emacs_event;
8889 {
8890 if (! GC_WINDOWP (bar->window))
8891 abort ();
8892
8893 emacs_event->kind = scroll_bar_click;
8894 emacs_event->code = event->xbutton.button - Button1;
8895 emacs_event->modifiers
8896 = (x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO
8897 (XFRAME (WINDOW_FRAME (XWINDOW (bar->window)))),
8898 event->xbutton.state)
8899 | (event->type == ButtonRelease
8900 ? up_modifier
8901 : down_modifier));
8902 emacs_event->frame_or_window = bar->window;
8903 emacs_event->arg = Qnil;
8904 emacs_event->timestamp = event->xbutton.time;
8905 {
8906 #if 0
8907 FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
8908 int internal_height
8909 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f, XINT (bar->height));
8910 #endif
8911 int top_range
8912 = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
8913 int y = event->xbutton.y - VERTICAL_SCROLL_BAR_TOP_BORDER;
8914
8915 if (y < 0) y = 0;
8916 if (y > top_range) y = top_range;
8917
8918 if (y < XINT (bar->start))
8919 emacs_event->part = scroll_bar_above_handle;
8920 else if (y < XINT (bar->end) + VERTICAL_SCROLL_BAR_MIN_HANDLE)
8921 emacs_event->part = scroll_bar_handle;
8922 else
8923 emacs_event->part = scroll_bar_below_handle;
8924
8925 /* Just because the user has clicked on the handle doesn't mean
8926 they want to drag it. Lisp code needs to be able to decide
8927 whether or not we're dragging. */
8928 #if 0
8929 /* If the user has just clicked on the handle, record where they're
8930 holding it. */
8931 if (event->type == ButtonPress
8932 && emacs_event->part == scroll_bar_handle)
8933 XSETINT (bar->dragging, y - XINT (bar->start));
8934 #endif
8935
8936 /* If the user has released the handle, set it to its final position. */
8937 if (event->type == ButtonRelease
8938 && ! NILP (bar->dragging))
8939 {
8940 int new_start = y - XINT (bar->dragging);
8941 int new_end = new_start + (XINT (bar->end) - XINT (bar->start));
8942
8943 x_scroll_bar_set_handle (bar, new_start, new_end, 0);
8944 bar->dragging = Qnil;
8945 }
8946
8947 /* Same deal here as the other #if 0. */
8948 #if 0
8949 /* Clicks on the handle are always reported as occurring at the top of
8950 the handle. */
8951 if (emacs_event->part == scroll_bar_handle)
8952 emacs_event->x = bar->start;
8953 else
8954 XSETINT (emacs_event->x, y);
8955 #else
8956 XSETINT (emacs_event->x, y);
8957 #endif
8958
8959 XSETINT (emacs_event->y, top_range);
8960 }
8961 }
8962
8963 /* Handle some mouse motion while someone is dragging the scroll bar.
8964
8965 This may be called from a signal handler, so we have to ignore GC
8966 mark bits. */
8967
8968 static void
8969 x_scroll_bar_note_movement (bar, event)
8970 struct scroll_bar *bar;
8971 XEvent *event;
8972 {
8973 FRAME_PTR f = XFRAME (XWINDOW (bar->window)->frame);
8974
8975 last_mouse_movement_time = event->xmotion.time;
8976
8977 f->mouse_moved = 1;
8978 XSETVECTOR (last_mouse_scroll_bar, bar);
8979
8980 /* If we're dragging the bar, display it. */
8981 if (! GC_NILP (bar->dragging))
8982 {
8983 /* Where should the handle be now? */
8984 int new_start = event->xmotion.y - XINT (bar->dragging);
8985
8986 if (new_start != XINT (bar->start))
8987 {
8988 int new_end = new_start + (XINT (bar->end) - XINT (bar->start));
8989
8990 x_scroll_bar_set_handle (bar, new_start, new_end, 0);
8991 }
8992 }
8993 }
8994
8995 #endif /* !USE_TOOLKIT_SCROLL_BARS */
8996
8997 /* Return information to the user about the current position of the mouse
8998 on the scroll bar. */
8999
9000 static void
9001 x_scroll_bar_report_motion (fp, bar_window, part, x, y, time)
9002 FRAME_PTR *fp;
9003 Lisp_Object *bar_window;
9004 enum scroll_bar_part *part;
9005 Lisp_Object *x, *y;
9006 unsigned long *time;
9007 {
9008 struct scroll_bar *bar = XSCROLL_BAR (last_mouse_scroll_bar);
9009 Window w = SCROLL_BAR_X_WINDOW (bar);
9010 FRAME_PTR f = XFRAME (WINDOW_FRAME (XWINDOW (bar->window)));
9011 int win_x, win_y;
9012 Window dummy_window;
9013 int dummy_coord;
9014 unsigned int dummy_mask;
9015
9016 BLOCK_INPUT;
9017
9018 /* Get the mouse's position relative to the scroll bar window, and
9019 report that. */
9020 if (! XQueryPointer (FRAME_X_DISPLAY (f), w,
9021
9022 /* Root, child, root x and root y. */
9023 &dummy_window, &dummy_window,
9024 &dummy_coord, &dummy_coord,
9025
9026 /* Position relative to scroll bar. */
9027 &win_x, &win_y,
9028
9029 /* Mouse buttons and modifier keys. */
9030 &dummy_mask))
9031 ;
9032 else
9033 {
9034 #if 0
9035 int inside_height
9036 = VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f, XINT (bar->height));
9037 #endif
9038 int top_range
9039 = VERTICAL_SCROLL_BAR_TOP_RANGE (f, XINT (bar->height));
9040
9041 win_y -= VERTICAL_SCROLL_BAR_TOP_BORDER;
9042
9043 if (! NILP (bar->dragging))
9044 win_y -= XINT (bar->dragging);
9045
9046 if (win_y < 0)
9047 win_y = 0;
9048 if (win_y > top_range)
9049 win_y = top_range;
9050
9051 *fp = f;
9052 *bar_window = bar->window;
9053
9054 if (! NILP (bar->dragging))
9055 *part = scroll_bar_handle;
9056 else if (win_y < XINT (bar->start))
9057 *part = scroll_bar_above_handle;
9058 else if (win_y < XINT (bar->end) + VERTICAL_SCROLL_BAR_MIN_HANDLE)
9059 *part = scroll_bar_handle;
9060 else
9061 *part = scroll_bar_below_handle;
9062
9063 XSETINT (*x, win_y);
9064 XSETINT (*y, top_range);
9065
9066 f->mouse_moved = 0;
9067 last_mouse_scroll_bar = Qnil;
9068 }
9069
9070 *time = last_mouse_movement_time;
9071
9072 UNBLOCK_INPUT;
9073 }
9074
9075
9076 /* The screen has been cleared so we may have changed foreground or
9077 background colors, and the scroll bars may need to be redrawn.
9078 Clear out the scroll bars, and ask for expose events, so we can
9079 redraw them. */
9080
9081 void
9082 x_scroll_bar_clear (f)
9083 FRAME_PTR f;
9084 {
9085 #ifndef USE_TOOLKIT_SCROLL_BARS
9086 Lisp_Object bar;
9087
9088 /* We can have scroll bars even if this is 0,
9089 if we just turned off scroll bar mode.
9090 But in that case we should not clear them. */
9091 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
9092 for (bar = FRAME_SCROLL_BARS (f); VECTORP (bar);
9093 bar = XSCROLL_BAR (bar)->next)
9094 XClearArea (FRAME_X_DISPLAY (f),
9095 SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar)),
9096 0, 0, 0, 0, True);
9097 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9098 }
9099
9100 /* This processes Expose events from the menu-bar specific X event
9101 loop in xmenu.c. This allows to redisplay the frame if necessary
9102 when handling menu-bar or pop-up items. */
9103
9104 int
9105 process_expose_from_menu (event)
9106 XEvent event;
9107 {
9108 FRAME_PTR f;
9109 struct x_display_info *dpyinfo;
9110 int frame_exposed_p = 0;
9111
9112 BLOCK_INPUT;
9113
9114 dpyinfo = x_display_info_for_display (event.xexpose.display);
9115 f = x_window_to_frame (dpyinfo, event.xexpose.window);
9116 if (f)
9117 {
9118 if (f->async_visible == 0)
9119 {
9120 f->async_visible = 1;
9121 f->async_iconified = 0;
9122 f->output_data.x->has_been_visible = 1;
9123 SET_FRAME_GARBAGED (f);
9124 }
9125 else
9126 {
9127 expose_frame (x_window_to_frame (dpyinfo, event.xexpose.window),
9128 event.xexpose.x, event.xexpose.y,
9129 event.xexpose.width, event.xexpose.height);
9130 frame_exposed_p = 1;
9131 }
9132 }
9133 else
9134 {
9135 struct scroll_bar *bar
9136 = x_window_to_scroll_bar (event.xexpose.window);
9137
9138 if (bar)
9139 x_scroll_bar_expose (bar, &event);
9140 }
9141
9142 UNBLOCK_INPUT;
9143 return frame_exposed_p;
9144 }
9145 \f
9146 /* Define a queue to save up SelectionRequest events for later handling. */
9147
9148 struct selection_event_queue
9149 {
9150 XEvent event;
9151 struct selection_event_queue *next;
9152 };
9153
9154 static struct selection_event_queue *queue;
9155
9156 /* Nonzero means queue up certain events--don't process them yet. */
9157
9158 static int x_queue_selection_requests;
9159
9160 /* Queue up an X event *EVENT, to be processed later. */
9161
9162 static void
9163 x_queue_event (f, event)
9164 FRAME_PTR f;
9165 XEvent *event;
9166 {
9167 struct selection_event_queue *queue_tmp
9168 = (struct selection_event_queue *) xmalloc (sizeof (struct selection_event_queue));
9169
9170 if (queue_tmp != NULL)
9171 {
9172 queue_tmp->event = *event;
9173 queue_tmp->next = queue;
9174 queue = queue_tmp;
9175 }
9176 }
9177
9178 /* Take all the queued events and put them back
9179 so that they get processed afresh. */
9180
9181 static void
9182 x_unqueue_events (display)
9183 Display *display;
9184 {
9185 while (queue != NULL)
9186 {
9187 struct selection_event_queue *queue_tmp = queue;
9188 XPutBackEvent (display, &queue_tmp->event);
9189 queue = queue_tmp->next;
9190 xfree ((char *)queue_tmp);
9191 }
9192 }
9193
9194 /* Start queuing SelectionRequest events. */
9195
9196 void
9197 x_start_queuing_selection_requests (display)
9198 Display *display;
9199 {
9200 x_queue_selection_requests++;
9201 }
9202
9203 /* Stop queuing SelectionRequest events. */
9204
9205 void
9206 x_stop_queuing_selection_requests (display)
9207 Display *display;
9208 {
9209 x_queue_selection_requests--;
9210 x_unqueue_events (display);
9211 }
9212 \f
9213 /* The main X event-reading loop - XTread_socket. */
9214
9215 /* Time stamp of enter window event. This is only used by XTread_socket,
9216 but we have to put it out here, since static variables within functions
9217 sometimes don't work. */
9218
9219 static Time enter_timestamp;
9220
9221 /* This holds the state XLookupString needs to implement dead keys
9222 and other tricks known as "compose processing". _X Window System_
9223 says that a portable program can't use this, but Stephen Gildea assures
9224 me that letting the compiler initialize it to zeros will work okay.
9225
9226 This must be defined outside of XTread_socket, for the same reasons
9227 given for enter_time stamp, above. */
9228
9229 static XComposeStatus compose_status;
9230
9231 /* Record the last 100 characters stored
9232 to help debug the loss-of-chars-during-GC problem. */
9233
9234 static int temp_index;
9235 static short temp_buffer[100];
9236
9237 /* Set this to nonzero to fake an "X I/O error"
9238 on a particular display. */
9239
9240 struct x_display_info *XTread_socket_fake_io_error;
9241
9242 /* When we find no input here, we occasionally do a no-op command
9243 to verify that the X server is still running and we can still talk with it.
9244 We try all the open displays, one by one.
9245 This variable is used for cycling thru the displays. */
9246
9247 static struct x_display_info *next_noop_dpyinfo;
9248
9249 #define SET_SAVED_MENU_EVENT(size) \
9250 do \
9251 { \
9252 if (f->output_data.x->saved_menu_event == 0) \
9253 f->output_data.x->saved_menu_event \
9254 = (XEvent *) xmalloc (sizeof (XEvent)); \
9255 bcopy (&event, f->output_data.x->saved_menu_event, size); \
9256 if (numchars >= 1) \
9257 { \
9258 bufp->kind = menu_bar_activate_event; \
9259 XSETFRAME (bufp->frame_or_window, f); \
9260 bufp->arg = Qnil; \
9261 bufp++; \
9262 count++; \
9263 numchars--; \
9264 } \
9265 } \
9266 while (0)
9267
9268 #define SET_SAVED_BUTTON_EVENT SET_SAVED_MENU_EVENT (sizeof (XButtonEvent))
9269 #define SET_SAVED_KEY_EVENT SET_SAVED_MENU_EVENT (sizeof (XKeyEvent))
9270
9271 /* Read events coming from the X server.
9272 This routine is called by the SIGIO handler.
9273 We return as soon as there are no more events to be read.
9274
9275 Events representing keys are stored in buffer BUFP,
9276 which can hold up to NUMCHARS characters.
9277 We return the number of characters stored into the buffer,
9278 thus pretending to be `read'.
9279
9280 EXPECTED is nonzero if the caller knows input is available. */
9281
9282 int
9283 XTread_socket (sd, bufp, numchars, expected)
9284 register int sd;
9285 /* register */ struct input_event *bufp;
9286 /* register */ int numchars;
9287 int expected;
9288 {
9289 int count = 0;
9290 int nbytes = 0;
9291 XEvent event;
9292 struct frame *f;
9293 int event_found = 0;
9294 struct x_display_info *dpyinfo;
9295 struct coding_system coding;
9296
9297 if (interrupt_input_blocked)
9298 {
9299 interrupt_input_pending = 1;
9300 return -1;
9301 }
9302
9303 interrupt_input_pending = 0;
9304 BLOCK_INPUT;
9305
9306 /* So people can tell when we have read the available input. */
9307 input_signal_count++;
9308
9309 if (numchars <= 0)
9310 abort (); /* Don't think this happens. */
9311
9312 ++handling_signal;
9313
9314 /* The input should be decoded if it is from XIM. Currently the
9315 locale of XIM is the same as that of the system. So, we can use
9316 Vlocale_coding_system which is initialized properly at Emacs
9317 startup time. */
9318 setup_coding_system (Vlocale_coding_system, &coding);
9319 coding.src_multibyte = 0;
9320 coding.dst_multibyte = 1;
9321 /* The input is converted to events, thus we can't handle
9322 composition. Anyway, there's no XIM that gives us composition
9323 information. */
9324 coding.composing = COMPOSITION_DISABLED;
9325
9326 /* Find the display we are supposed to read input for.
9327 It's the one communicating on descriptor SD. */
9328 for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
9329 {
9330 #if 0 /* This ought to be unnecessary; let's verify it. */
9331 #ifdef FIOSNBIO
9332 /* If available, Xlib uses FIOSNBIO to make the socket
9333 non-blocking, and then looks for EWOULDBLOCK. If O_NDELAY is set,
9334 FIOSNBIO is ignored, and instead of signaling EWOULDBLOCK,
9335 a read returns 0, which Xlib interprets as equivalent to EPIPE. */
9336 fcntl (dpyinfo->connection, F_SETFL, 0);
9337 #endif /* ! defined (FIOSNBIO) */
9338 #endif
9339
9340 #if 0 /* This code can't be made to work, with multiple displays,
9341 and appears not to be used on any system any more.
9342 Also keyboard.c doesn't turn O_NDELAY on and off
9343 for X connections. */
9344 #ifndef SIGIO
9345 #ifndef HAVE_SELECT
9346 if (! (fcntl (dpyinfo->connection, F_GETFL, 0) & O_NDELAY))
9347 {
9348 extern int read_alarm_should_throw;
9349 read_alarm_should_throw = 1;
9350 XPeekEvent (dpyinfo->display, &event);
9351 read_alarm_should_throw = 0;
9352 }
9353 #endif /* HAVE_SELECT */
9354 #endif /* SIGIO */
9355 #endif
9356
9357 /* For debugging, this gives a way to fake an I/O error. */
9358 if (dpyinfo == XTread_socket_fake_io_error)
9359 {
9360 XTread_socket_fake_io_error = 0;
9361 x_io_error_quitter (dpyinfo->display);
9362 }
9363
9364 while (XPending (dpyinfo->display))
9365 {
9366 XNextEvent (dpyinfo->display, &event);
9367
9368 #ifdef HAVE_X_I18N
9369 {
9370 /* Filter events for the current X input method.
9371 XFilterEvent returns non-zero if the input method has
9372 consumed the event. We pass the frame's X window to
9373 XFilterEvent because that's the one for which the IC
9374 was created. */
9375 struct frame *f1 = x_any_window_to_frame (dpyinfo,
9376 event.xclient.window);
9377 if (XFilterEvent (&event, f1 ? FRAME_X_WINDOW (f1) : None))
9378 break;
9379 }
9380 #endif
9381 event_found = 1;
9382
9383 switch (event.type)
9384 {
9385 case ClientMessage:
9386 {
9387 if (event.xclient.message_type
9388 == dpyinfo->Xatom_wm_protocols
9389 && event.xclient.format == 32)
9390 {
9391 if (event.xclient.data.l[0]
9392 == dpyinfo->Xatom_wm_take_focus)
9393 {
9394 /* Use x_any_window_to_frame because this
9395 could be the shell widget window
9396 if the frame has no title bar. */
9397 f = x_any_window_to_frame (dpyinfo, event.xclient.window);
9398 #ifdef HAVE_X_I18N
9399 /* Not quite sure this is needed -pd */
9400 if (f && FRAME_XIC (f))
9401 XSetICFocus (FRAME_XIC (f));
9402 #endif
9403 #if 0 /* Emacs sets WM hints whose `input' field is `true'. This
9404 instructs the WM to set the input focus automatically for
9405 Emacs with a call to XSetInputFocus. Setting WM_TAKE_FOCUS
9406 tells the WM to send us a ClientMessage WM_TAKE_FOCUS after
9407 it has set the focus. So, XSetInputFocus below is not
9408 needed.
9409
9410 The call to XSetInputFocus below has also caused trouble. In
9411 cases where the XSetInputFocus done by the WM and the one
9412 below are temporally close (on a fast machine), the call
9413 below can generate additional FocusIn events which confuse
9414 Emacs. */
9415
9416 /* Since we set WM_TAKE_FOCUS, we must call
9417 XSetInputFocus explicitly. But not if f is null,
9418 since that might be an event for a deleted frame. */
9419 if (f)
9420 {
9421 Display *d = event.xclient.display;
9422 /* Catch and ignore errors, in case window has been
9423 iconified by a window manager such as GWM. */
9424 int count = x_catch_errors (d);
9425 XSetInputFocus (d, event.xclient.window,
9426 /* The ICCCM says this is
9427 the only valid choice. */
9428 RevertToParent,
9429 event.xclient.data.l[1]);
9430 /* This is needed to detect the error
9431 if there is an error. */
9432 XSync (d, False);
9433 x_uncatch_errors (d, count);
9434 }
9435 /* Not certain about handling scroll bars here */
9436 #endif /* 0 */
9437 }
9438 else if (event.xclient.data.l[0]
9439 == dpyinfo->Xatom_wm_save_yourself)
9440 {
9441 /* Save state modify the WM_COMMAND property to
9442 something which can reinstate us. This notifies
9443 the session manager, who's looking for such a
9444 PropertyNotify. Can restart processing when
9445 a keyboard or mouse event arrives. */
9446 if (numchars > 0)
9447 {
9448 f = x_top_window_to_frame (dpyinfo,
9449 event.xclient.window);
9450
9451 /* This is just so we only give real data once
9452 for a single Emacs process. */
9453 if (f == SELECTED_FRAME ())
9454 XSetCommand (FRAME_X_DISPLAY (f),
9455 event.xclient.window,
9456 initial_argv, initial_argc);
9457 else if (f)
9458 XSetCommand (FRAME_X_DISPLAY (f),
9459 event.xclient.window,
9460 0, 0);
9461 }
9462 }
9463 else if (event.xclient.data.l[0]
9464 == dpyinfo->Xatom_wm_delete_window)
9465 {
9466 struct frame *f
9467 = x_any_window_to_frame (dpyinfo,
9468 event.xclient.window);
9469
9470 if (f)
9471 {
9472 if (numchars == 0)
9473 abort ();
9474
9475 bufp->kind = delete_window_event;
9476 XSETFRAME (bufp->frame_or_window, f);
9477 bufp->arg = Qnil;
9478 bufp++;
9479
9480 count += 1;
9481 numchars -= 1;
9482 }
9483 }
9484 }
9485 else if (event.xclient.message_type
9486 == dpyinfo->Xatom_wm_configure_denied)
9487 {
9488 }
9489 else if (event.xclient.message_type
9490 == dpyinfo->Xatom_wm_window_moved)
9491 {
9492 int new_x, new_y;
9493 struct frame *f
9494 = x_window_to_frame (dpyinfo, event.xclient.window);
9495
9496 new_x = event.xclient.data.s[0];
9497 new_y = event.xclient.data.s[1];
9498
9499 if (f)
9500 {
9501 f->output_data.x->left_pos = new_x;
9502 f->output_data.x->top_pos = new_y;
9503 }
9504 }
9505 #ifdef HACK_EDITRES
9506 else if (event.xclient.message_type
9507 == dpyinfo->Xatom_editres)
9508 {
9509 struct frame *f
9510 = x_any_window_to_frame (dpyinfo, event.xclient.window);
9511 _XEditResCheckMessages (f->output_data.x->widget, NULL,
9512 &event, NULL);
9513 }
9514 #endif /* HACK_EDITRES */
9515 else if ((event.xclient.message_type
9516 == dpyinfo->Xatom_DONE)
9517 || (event.xclient.message_type
9518 == dpyinfo->Xatom_PAGE))
9519 {
9520 /* Ghostview job completed. Kill it. We could
9521 reply with "Next" if we received "Page", but we
9522 currently never do because we are interested in
9523 images, only, which should have 1 page. */
9524 Pixmap pixmap = (Pixmap) event.xclient.data.l[1];
9525 struct frame *f
9526 = x_window_to_frame (dpyinfo, event.xclient.window);
9527 x_kill_gs_process (pixmap, f);
9528 expose_frame (f, 0, 0, 0, 0);
9529 }
9530 #ifdef USE_TOOLKIT_SCROLL_BARS
9531 /* Scroll bar callbacks send a ClientMessage from which
9532 we construct an input_event. */
9533 else if (event.xclient.message_type
9534 == dpyinfo->Xatom_Scrollbar)
9535 {
9536 x_scroll_bar_to_input_event (&event, bufp);
9537 ++bufp, ++count, --numchars;
9538 goto out;
9539 }
9540 #endif /* USE_TOOLKIT_SCROLL_BARS */
9541 else
9542 goto OTHER;
9543 }
9544 break;
9545
9546 case SelectionNotify:
9547 #ifdef USE_X_TOOLKIT
9548 if (! x_window_to_frame (dpyinfo, event.xselection.requestor))
9549 goto OTHER;
9550 #endif /* not USE_X_TOOLKIT */
9551 x_handle_selection_notify (&event.xselection);
9552 break;
9553
9554 case SelectionClear: /* Someone has grabbed ownership. */
9555 #ifdef USE_X_TOOLKIT
9556 if (! x_window_to_frame (dpyinfo, event.xselectionclear.window))
9557 goto OTHER;
9558 #endif /* USE_X_TOOLKIT */
9559 {
9560 XSelectionClearEvent *eventp = (XSelectionClearEvent *) &event;
9561
9562 if (numchars == 0)
9563 abort ();
9564
9565 bufp->kind = selection_clear_event;
9566 SELECTION_EVENT_DISPLAY (bufp) = eventp->display;
9567 SELECTION_EVENT_SELECTION (bufp) = eventp->selection;
9568 SELECTION_EVENT_TIME (bufp) = eventp->time;
9569 bufp->frame_or_window = Qnil;
9570 bufp->arg = Qnil;
9571 bufp++;
9572
9573 count += 1;
9574 numchars -= 1;
9575 }
9576 break;
9577
9578 case SelectionRequest: /* Someone wants our selection. */
9579 #ifdef USE_X_TOOLKIT
9580 if (!x_window_to_frame (dpyinfo, event.xselectionrequest.owner))
9581 goto OTHER;
9582 #endif /* USE_X_TOOLKIT */
9583 if (x_queue_selection_requests)
9584 x_queue_event (x_window_to_frame (dpyinfo, event.xselectionrequest.owner),
9585 &event);
9586 else
9587 {
9588 XSelectionRequestEvent *eventp = (XSelectionRequestEvent *) &event;
9589
9590 if (numchars == 0)
9591 abort ();
9592
9593 bufp->kind = selection_request_event;
9594 SELECTION_EVENT_DISPLAY (bufp) = eventp->display;
9595 SELECTION_EVENT_REQUESTOR (bufp) = eventp->requestor;
9596 SELECTION_EVENT_SELECTION (bufp) = eventp->selection;
9597 SELECTION_EVENT_TARGET (bufp) = eventp->target;
9598 SELECTION_EVENT_PROPERTY (bufp) = eventp->property;
9599 SELECTION_EVENT_TIME (bufp) = eventp->time;
9600 bufp->frame_or_window = Qnil;
9601 bufp->arg = Qnil;
9602 bufp++;
9603
9604 count += 1;
9605 numchars -= 1;
9606 }
9607 break;
9608
9609 case PropertyNotify:
9610 #ifdef USE_X_TOOLKIT
9611 if (!x_any_window_to_frame (dpyinfo, event.xproperty.window))
9612 goto OTHER;
9613 #endif /* not USE_X_TOOLKIT */
9614 x_handle_property_notify (&event.xproperty);
9615 break;
9616
9617 case ReparentNotify:
9618 f = x_top_window_to_frame (dpyinfo, event.xreparent.window);
9619 if (f)
9620 {
9621 int x, y;
9622 f->output_data.x->parent_desc = event.xreparent.parent;
9623 x_real_positions (f, &x, &y);
9624 f->output_data.x->left_pos = x;
9625 f->output_data.x->top_pos = y;
9626 }
9627 break;
9628
9629 case Expose:
9630 f = x_window_to_frame (dpyinfo, event.xexpose.window);
9631 if (f)
9632 {
9633 if (f->async_visible == 0)
9634 {
9635 f->async_visible = 1;
9636 f->async_iconified = 0;
9637 f->output_data.x->has_been_visible = 1;
9638 SET_FRAME_GARBAGED (f);
9639 }
9640 else
9641 expose_frame (x_window_to_frame (dpyinfo,
9642 event.xexpose.window),
9643 event.xexpose.x, event.xexpose.y,
9644 event.xexpose.width, event.xexpose.height);
9645 }
9646 else
9647 {
9648 #ifdef USE_TOOLKIT_SCROLL_BARS
9649 /* Dispatch event to the widget. */
9650 goto OTHER;
9651 #else /* not USE_TOOLKIT_SCROLL_BARS */
9652 struct scroll_bar *bar
9653 = x_window_to_scroll_bar (event.xexpose.window);
9654
9655 if (bar)
9656 x_scroll_bar_expose (bar, &event);
9657 #ifdef USE_X_TOOLKIT
9658 else
9659 goto OTHER;
9660 #endif /* USE_X_TOOLKIT */
9661 #endif /* not USE_TOOLKIT_SCROLL_BARS */
9662 }
9663 break;
9664
9665 case GraphicsExpose: /* This occurs when an XCopyArea's
9666 source area was obscured or not
9667 available.*/
9668 f = x_window_to_frame (dpyinfo, event.xgraphicsexpose.drawable);
9669 if (f)
9670 {
9671 expose_frame (f,
9672 event.xgraphicsexpose.x, event.xgraphicsexpose.y,
9673 event.xgraphicsexpose.width,
9674 event.xgraphicsexpose.height);
9675 }
9676 #ifdef USE_X_TOOLKIT
9677 else
9678 goto OTHER;
9679 #endif /* USE_X_TOOLKIT */
9680 break;
9681
9682 case NoExpose: /* This occurs when an XCopyArea's
9683 source area was completely
9684 available */
9685 break;
9686
9687 case UnmapNotify:
9688 /* Redo the mouse-highlight after the tooltip has gone. */
9689 if (event.xmap.window == tip_window)
9690 {
9691 tip_window = 0;
9692 redo_mouse_highlight ();
9693 }
9694
9695 f = x_top_window_to_frame (dpyinfo, event.xunmap.window);
9696 if (f) /* F may no longer exist if
9697 the frame was deleted. */
9698 {
9699 /* While a frame is unmapped, display generation is
9700 disabled; you don't want to spend time updating a
9701 display that won't ever be seen. */
9702 f->async_visible = 0;
9703 /* We can't distinguish, from the event, whether the window
9704 has become iconified or invisible. So assume, if it
9705 was previously visible, than now it is iconified.
9706 But x_make_frame_invisible clears both
9707 the visible flag and the iconified flag;
9708 and that way, we know the window is not iconified now. */
9709 if (FRAME_VISIBLE_P (f) || FRAME_ICONIFIED_P (f))
9710 {
9711 f->async_iconified = 1;
9712
9713 bufp->kind = iconify_event;
9714 XSETFRAME (bufp->frame_or_window, f);
9715 bufp->arg = Qnil;
9716 bufp++;
9717 count++;
9718 numchars--;
9719 }
9720 }
9721 goto OTHER;
9722
9723 case MapNotify:
9724 if (event.xmap.window == tip_window)
9725 /* The tooltip has been drawn already. Avoid
9726 the SET_FRAME_GARBAGED below. */
9727 goto OTHER;
9728
9729 /* We use x_top_window_to_frame because map events can
9730 come for sub-windows and they don't mean that the
9731 frame is visible. */
9732 f = x_top_window_to_frame (dpyinfo, event.xmap.window);
9733 if (f)
9734 {
9735 f->async_visible = 1;
9736 f->async_iconified = 0;
9737 f->output_data.x->has_been_visible = 1;
9738
9739 /* wait_reading_process_input will notice this and update
9740 the frame's display structures. */
9741 SET_FRAME_GARBAGED (f);
9742
9743 if (f->iconified)
9744 {
9745 bufp->kind = deiconify_event;
9746 XSETFRAME (bufp->frame_or_window, f);
9747 bufp->arg = Qnil;
9748 bufp++;
9749 count++;
9750 numchars--;
9751 }
9752 else if (! NILP (Vframe_list)
9753 && ! NILP (XCDR (Vframe_list)))
9754 /* Force a redisplay sooner or later
9755 to update the frame titles
9756 in case this is the second frame. */
9757 record_asynch_buffer_change ();
9758 }
9759 goto OTHER;
9760
9761 case KeyPress:
9762 f = x_any_window_to_frame (dpyinfo, event.xkey.window);
9763
9764 #if defined USE_MOTIF && defined USE_TOOLKIT_SCROLL_BARS
9765 /* I couldn't find a way to prevent LessTif scroll bars
9766 from consuming key events. */
9767 if (f == 0)
9768 {
9769 Widget widget = XtWindowToWidget (dpyinfo->display,
9770 event.xkey.window);
9771 if (widget && XmIsScrollBar (widget))
9772 {
9773 widget = XtParent (widget);
9774 f = x_any_window_to_frame (dpyinfo, XtWindow (widget));
9775 }
9776 }
9777 #endif /* USE_MOTIF and USE_TOOLKIT_SCROLL_BARS */
9778
9779 if (f != 0)
9780 {
9781 KeySym keysym, orig_keysym;
9782 /* al%imercury@uunet.uu.net says that making this 81
9783 instead of 80 fixed a bug whereby meta chars made
9784 his Emacs hang.
9785
9786 It seems that some version of XmbLookupString has
9787 a bug of not returning XBufferOverflow in
9788 status_return even if the input is too long to
9789 fit in 81 bytes. So, we must prepare sufficient
9790 bytes for copy_buffer. 513 bytes (256 chars for
9791 two-byte character set) seems to be a faily good
9792 approximation. -- 2000.8.10 handa@etl.go.jp */
9793 unsigned char copy_buffer[513];
9794 unsigned char *copy_bufptr = copy_buffer;
9795 int copy_bufsiz = sizeof (copy_buffer);
9796 int modifiers;
9797
9798 event.xkey.state
9799 |= x_emacs_to_x_modifiers (FRAME_X_DISPLAY_INFO (f),
9800 extra_keyboard_modifiers);
9801 modifiers = event.xkey.state;
9802
9803 /* This will have to go some day... */
9804
9805 /* make_lispy_event turns chars into control chars.
9806 Don't do it here because XLookupString is too eager. */
9807 event.xkey.state &= ~ControlMask;
9808 event.xkey.state &= ~(dpyinfo->meta_mod_mask
9809 | dpyinfo->super_mod_mask
9810 | dpyinfo->hyper_mod_mask
9811 | dpyinfo->alt_mod_mask);
9812
9813 /* In case Meta is ComposeCharacter,
9814 clear its status. According to Markus Ehrnsperger
9815 Markus.Ehrnsperger@lehrstuhl-bross.physik.uni-muenchen.de
9816 this enables ComposeCharacter to work whether or
9817 not it is combined with Meta. */
9818 if (modifiers & dpyinfo->meta_mod_mask)
9819 bzero (&compose_status, sizeof (compose_status));
9820
9821 #ifdef HAVE_X_I18N
9822 if (FRAME_XIC (f))
9823 {
9824 Status status_return;
9825
9826 nbytes = XmbLookupString (FRAME_XIC (f),
9827 &event.xkey, copy_bufptr,
9828 copy_bufsiz, &keysym,
9829 &status_return);
9830 if (status_return == XBufferOverflow)
9831 {
9832 copy_bufsiz = nbytes + 1;
9833 copy_bufptr = (char *) alloca (copy_bufsiz);
9834 nbytes = XmbLookupString (FRAME_XIC (f),
9835 &event.xkey, copy_bufptr,
9836 copy_bufsiz, &keysym,
9837 &status_return);
9838 }
9839
9840 if (status_return == XLookupNone)
9841 break;
9842 else if (status_return == XLookupChars)
9843 {
9844 keysym = NoSymbol;
9845 modifiers = 0;
9846 }
9847 else if (status_return != XLookupKeySym
9848 && status_return != XLookupBoth)
9849 abort ();
9850 }
9851 else
9852 nbytes = XLookupString (&event.xkey, copy_bufptr,
9853 copy_bufsiz, &keysym,
9854 &compose_status);
9855 #else
9856 nbytes = XLookupString (&event.xkey, copy_bufptr,
9857 copy_bufsiz, &keysym,
9858 &compose_status);
9859 #endif
9860
9861 orig_keysym = keysym;
9862
9863 if (numchars > 1)
9864 {
9865 if (((keysym >= XK_BackSpace && keysym <= XK_Escape)
9866 || keysym == XK_Delete
9867 #ifdef XK_ISO_Left_Tab
9868 || (keysym >= XK_ISO_Left_Tab && keysym <= XK_ISO_Enter)
9869 #endif
9870 || (keysym >= XK_Kanji && keysym <= XK_Eisu_toggle)
9871 || IsCursorKey (keysym) /* 0xff50 <= x < 0xff60 */
9872 || IsMiscFunctionKey (keysym) /* 0xff60 <= x < VARIES */
9873 #ifdef HPUX
9874 /* This recognizes the "extended function keys".
9875 It seems there's no cleaner way.
9876 Test IsModifierKey to avoid handling mode_switch
9877 incorrectly. */
9878 || ((unsigned) (keysym) >= XK_Select
9879 && (unsigned)(keysym) < XK_KP_Space)
9880 #endif
9881 #ifdef XK_dead_circumflex
9882 || orig_keysym == XK_dead_circumflex
9883 #endif
9884 #ifdef XK_dead_grave
9885 || orig_keysym == XK_dead_grave
9886 #endif
9887 #ifdef XK_dead_tilde
9888 || orig_keysym == XK_dead_tilde
9889 #endif
9890 #ifdef XK_dead_diaeresis
9891 || orig_keysym == XK_dead_diaeresis
9892 #endif
9893 #ifdef XK_dead_macron
9894 || orig_keysym == XK_dead_macron
9895 #endif
9896 #ifdef XK_dead_degree
9897 || orig_keysym == XK_dead_degree
9898 #endif
9899 #ifdef XK_dead_acute
9900 || orig_keysym == XK_dead_acute
9901 #endif
9902 #ifdef XK_dead_cedilla
9903 || orig_keysym == XK_dead_cedilla
9904 #endif
9905 #ifdef XK_dead_breve
9906 || orig_keysym == XK_dead_breve
9907 #endif
9908 #ifdef XK_dead_ogonek
9909 || orig_keysym == XK_dead_ogonek
9910 #endif
9911 #ifdef XK_dead_caron
9912 || orig_keysym == XK_dead_caron
9913 #endif
9914 #ifdef XK_dead_doubleacute
9915 || orig_keysym == XK_dead_doubleacute
9916 #endif
9917 #ifdef XK_dead_abovedot
9918 || orig_keysym == XK_dead_abovedot
9919 #endif
9920 || IsKeypadKey (keysym) /* 0xff80 <= x < 0xffbe */
9921 || IsFunctionKey (keysym) /* 0xffbe <= x < 0xffe1 */
9922 /* Any "vendor-specific" key is ok. */
9923 || (orig_keysym & (1 << 28)))
9924 && ! (IsModifierKey (orig_keysym)
9925 #ifndef HAVE_X11R5
9926 #ifdef XK_Mode_switch
9927 || ((unsigned)(orig_keysym) == XK_Mode_switch)
9928 #endif
9929 #ifdef XK_Num_Lock
9930 || ((unsigned)(orig_keysym) == XK_Num_Lock)
9931 #endif
9932 #endif /* not HAVE_X11R5 */
9933 ))
9934 {
9935 if (temp_index == sizeof temp_buffer / sizeof (short))
9936 temp_index = 0;
9937 temp_buffer[temp_index++] = keysym;
9938 bufp->kind = non_ascii_keystroke;
9939 bufp->code = keysym;
9940 XSETFRAME (bufp->frame_or_window, f);
9941 bufp->arg = Qnil;
9942 bufp->modifiers
9943 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
9944 modifiers);
9945 bufp->timestamp = event.xkey.time;
9946 bufp++;
9947 count++;
9948 numchars--;
9949 }
9950 else if (numchars > nbytes)
9951 {
9952 register int i;
9953 register int c;
9954 int nchars, len;
9955
9956 for (i = 0; i < nbytes; i++)
9957 {
9958 if (temp_index == (sizeof temp_buffer
9959 / sizeof (short)))
9960 temp_index = 0;
9961 temp_buffer[temp_index++] = copy_bufptr[i];
9962 }
9963
9964 if (/* If the event is not from XIM, */
9965 event.xkey.keycode != 0
9966 /* or the current locale doesn't request
9967 decoding of the intup data, ... */
9968 || coding.type == coding_type_raw_text
9969 || coding.type == coding_type_no_conversion)
9970 {
9971 /* ... we can use the input data as is. */
9972 nchars = nbytes;
9973 }
9974 else
9975 {
9976 /* We have to decode the input data. */
9977 int require;
9978 unsigned char *p;
9979
9980 require = decoding_buffer_size (&coding, nbytes);
9981 p = (unsigned char *) alloca (require);
9982 coding.mode |= CODING_MODE_LAST_BLOCK;
9983 decode_coding (&coding, copy_bufptr, p,
9984 nbytes, require);
9985 nbytes = coding.produced;
9986 nchars = coding.produced_char;
9987 copy_bufptr = p;
9988 }
9989
9990 /* Convert the input data to a sequence of
9991 character events. */
9992 for (i = 0; i < nbytes; i += len)
9993 {
9994 c = STRING_CHAR_AND_LENGTH (copy_bufptr + i,
9995 nbytes - i, len);
9996 bufp->kind = (SINGLE_BYTE_CHAR_P (c)
9997 ? ascii_keystroke
9998 : multibyte_char_keystroke);
9999 bufp->code = c;
10000 XSETFRAME (bufp->frame_or_window, f);
10001 bufp->arg = Qnil;
10002 bufp->modifiers
10003 = x_x_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f),
10004 modifiers);
10005 bufp->timestamp = event.xkey.time;
10006 bufp++;
10007 }
10008
10009 count += nchars;
10010 numchars -= nchars;
10011
10012 if (keysym == NoSymbol)
10013 break;
10014 }
10015 else
10016 abort ();
10017 }
10018 else
10019 abort ();
10020 }
10021 #ifdef HAVE_X_I18N
10022 /* Don't dispatch this event since XtDispatchEvent calls
10023 XFilterEvent, and two calls in a row may freeze the
10024 client. */
10025 break;
10026 #else
10027 goto OTHER;
10028 #endif
10029
10030 case KeyRelease:
10031 #ifdef HAVE_X_I18N
10032 /* Don't dispatch this event since XtDispatchEvent calls
10033 XFilterEvent, and two calls in a row may freeze the
10034 client. */
10035 break;
10036 #else
10037 goto OTHER;
10038 #endif
10039
10040 /* Here's a possible interpretation of the whole
10041 FocusIn-EnterNotify FocusOut-LeaveNotify mess. If
10042 you get a FocusIn event, you have to get a FocusOut
10043 event before you relinquish the focus. If you
10044 haven't received a FocusIn event, then a mere
10045 LeaveNotify is enough to free you. */
10046
10047 case EnterNotify:
10048 {
10049 int from_menu_bar_p = 0;
10050
10051 f = x_any_window_to_frame (dpyinfo, event.xcrossing.window);
10052
10053 #ifdef LESSTIF_VERSION
10054 /* When clicking outside of a menu bar popup to close
10055 it, we get a FocusIn/ EnterNotify sequence of
10056 events. The flag event.xcrossing.focus is not set
10057 in the EnterNotify event of that sequence because
10058 the focus is in the menu bar,
10059 event.xcrossing.window is the frame's X window.
10060 Unconditionally setting the focus frame to null in
10061 this case is not the right thing, because no event
10062 follows that could set the focus frame to the right
10063 value.
10064
10065 This could be a LessTif bug, but I wasn't able to
10066 reproduce the behavior in a simple test program.
10067 On the other hand, Motif seems to not have this
10068 problem.
10069
10070 (gerd, LessTif 0.92). */
10071
10072 if (!event.xcrossing.focus
10073 && f
10074 && f->output_data.x->menubar_widget)
10075 {
10076 Window focus;
10077 int revert;
10078
10079 XGetInputFocus (FRAME_X_DISPLAY (f), &focus, &revert);
10080 if (focus == XtWindow (f->output_data.x->menubar_widget))
10081 from_menu_bar_p = 1;
10082 }
10083 #endif /* LESSTIF_VERSION */
10084
10085 if (event.xcrossing.focus || from_menu_bar_p)
10086 {
10087 /* Avoid nasty pop/raise loops. */
10088 if (f && (!(f->auto_raise)
10089 || !(f->auto_lower)
10090 || (event.xcrossing.time - enter_timestamp) > 500))
10091 {
10092 x_new_focus_frame (dpyinfo, f);
10093 enter_timestamp = event.xcrossing.time;
10094 }
10095 }
10096 else if (f == dpyinfo->x_focus_frame)
10097 x_new_focus_frame (dpyinfo, 0);
10098
10099 /* EnterNotify counts as mouse movement,
10100 so update things that depend on mouse position. */
10101 if (f && !f->output_data.x->busy_p)
10102 note_mouse_movement (f, &event.xmotion);
10103 goto OTHER;
10104 }
10105
10106 case FocusIn:
10107 f = x_any_window_to_frame (dpyinfo, event.xfocus.window);
10108 if (event.xfocus.detail != NotifyPointer)
10109 dpyinfo->x_focus_event_frame = f;
10110 if (f)
10111 {
10112 x_new_focus_frame (dpyinfo, f);
10113
10114 /* Don't stop displaying the initial startup message
10115 for a switch-frame event we don't need. */
10116 if (GC_NILP (Vterminal_frame)
10117 && GC_CONSP (Vframe_list)
10118 && !GC_NILP (XCDR (Vframe_list)))
10119 {
10120 bufp->kind = FOCUS_IN_EVENT;
10121 XSETFRAME (bufp->frame_or_window, f);
10122 bufp->arg = Qnil;
10123 ++bufp, ++count, --numchars;
10124 }
10125 }
10126
10127 #ifdef HAVE_X_I18N
10128 if (f && FRAME_XIC (f))
10129 XSetICFocus (FRAME_XIC (f));
10130 #endif
10131
10132 goto OTHER;
10133
10134 case LeaveNotify:
10135 f = x_top_window_to_frame (dpyinfo, event.xcrossing.window);
10136 if (f)
10137 {
10138 int from_menu_bar_p = 0;
10139
10140 if (f == dpyinfo->mouse_face_mouse_frame)
10141 {
10142 /* If we move outside the frame, then we're
10143 certainly no longer on any text in the frame. */
10144 clear_mouse_face (dpyinfo);
10145 dpyinfo->mouse_face_mouse_frame = 0;
10146 }
10147
10148 /* Generate a nil HELP_EVENT to cancel a help-echo.
10149 Do it only if there's something to cancel.
10150 Otherwise, the startup message is cleared when
10151 the mouse leaves the frame. */
10152 if (any_help_event_p)
10153 {
10154 Lisp_Object frame;
10155 int n;
10156
10157 XSETFRAME (frame, f);
10158 help_echo = Qnil;
10159 n = gen_help_event (bufp, numchars,
10160 Qnil, frame, Qnil, Qnil, 0);
10161 bufp += n, count += n, numchars -= n;
10162 }
10163
10164 #ifdef LESSTIF_VERSION
10165 /* Please see the comment at the start of the
10166 EnterNotify case. */
10167 if (!event.xcrossing.focus
10168 && f->output_data.x->menubar_widget)
10169 {
10170 Window focus;
10171 int revert;
10172 XGetInputFocus (FRAME_X_DISPLAY (f), &focus, &revert);
10173 if (focus == XtWindow (f->output_data.x->menubar_widget))
10174 from_menu_bar_p = 1;
10175 }
10176 #endif /* LESSTIF_VERSION */
10177
10178 if (event.xcrossing.focus || from_menu_bar_p)
10179 x_mouse_leave (dpyinfo);
10180 else
10181 {
10182 if (f == dpyinfo->x_focus_event_frame)
10183 dpyinfo->x_focus_event_frame = 0;
10184 if (f == dpyinfo->x_focus_frame)
10185 x_new_focus_frame (dpyinfo, 0);
10186 }
10187 }
10188 goto OTHER;
10189
10190 case FocusOut:
10191 f = x_any_window_to_frame (dpyinfo, event.xfocus.window);
10192 if (event.xfocus.detail != NotifyPointer
10193 && f == dpyinfo->x_focus_event_frame)
10194 dpyinfo->x_focus_event_frame = 0;
10195 if (f && f == dpyinfo->x_focus_frame)
10196 x_new_focus_frame (dpyinfo, 0);
10197
10198 #ifdef HAVE_X_I18N
10199 if (f && FRAME_XIC (f))
10200 XUnsetICFocus (FRAME_XIC (f));
10201 #endif
10202
10203 goto OTHER;
10204
10205 case MotionNotify:
10206 {
10207 previous_help_echo = help_echo;
10208 help_echo = help_echo_object = help_echo_window = Qnil;
10209 help_echo_pos = -1;
10210
10211 if (dpyinfo->grabbed && last_mouse_frame
10212 && FRAME_LIVE_P (last_mouse_frame))
10213 f = last_mouse_frame;
10214 else
10215 f = x_window_to_frame (dpyinfo, event.xmotion.window);
10216
10217 if (f)
10218 note_mouse_movement (f, &event.xmotion);
10219 else
10220 {
10221 #ifndef USE_TOOLKIT_SCROLL_BARS
10222 struct scroll_bar *bar
10223 = x_window_to_scroll_bar (event.xmotion.window);
10224
10225 if (bar)
10226 x_scroll_bar_note_movement (bar, &event);
10227 #endif /* USE_TOOLKIT_SCROLL_BARS */
10228
10229 /* If we move outside the frame, then we're
10230 certainly no longer on any text in the frame. */
10231 clear_mouse_face (dpyinfo);
10232 }
10233
10234 /* If the contents of the global variable help_echo
10235 has changed, generate a HELP_EVENT. */
10236 if (!NILP (help_echo)
10237 || !NILP (previous_help_echo))
10238 {
10239 Lisp_Object frame;
10240 int n;
10241
10242 if (f)
10243 XSETFRAME (frame, f);
10244 else
10245 frame = Qnil;
10246
10247 any_help_event_p = 1;
10248 n = gen_help_event (bufp, numchars, help_echo, frame,
10249 help_echo_window, help_echo_object,
10250 help_echo_pos);
10251 bufp += n, count += n, numchars -= n;
10252 }
10253
10254 goto OTHER;
10255 }
10256
10257 case ConfigureNotify:
10258 f = x_top_window_to_frame (dpyinfo, event.xconfigure.window);
10259 if (f)
10260 {
10261 #ifndef USE_X_TOOLKIT
10262 int rows = PIXEL_TO_CHAR_HEIGHT (f, event.xconfigure.height);
10263 int columns = PIXEL_TO_CHAR_WIDTH (f, event.xconfigure.width);
10264
10265 /* In the toolkit version, change_frame_size
10266 is called by the code that handles resizing
10267 of the EmacsFrame widget. */
10268
10269 /* Even if the number of character rows and columns has
10270 not changed, the font size may have changed, so we need
10271 to check the pixel dimensions as well. */
10272 if (columns != f->width
10273 || rows != f->height
10274 || event.xconfigure.width != f->output_data.x->pixel_width
10275 || event.xconfigure.height != f->output_data.x->pixel_height)
10276 {
10277 change_frame_size (f, rows, columns, 0, 1, 0);
10278 SET_FRAME_GARBAGED (f);
10279 cancel_mouse_face (f);
10280 }
10281 #endif
10282
10283 f->output_data.x->pixel_width = event.xconfigure.width;
10284 f->output_data.x->pixel_height = event.xconfigure.height;
10285
10286 /* What we have now is the position of Emacs's own window.
10287 Convert that to the position of the window manager window. */
10288 x_real_positions (f, &f->output_data.x->left_pos,
10289 &f->output_data.x->top_pos);
10290
10291 #ifdef HAVE_X_I18N
10292 if (FRAME_XIC (f) && (FRAME_XIC_STYLE (f) & XIMStatusArea))
10293 xic_set_statusarea (f);
10294 #endif
10295
10296 if (f->output_data.x->parent_desc != FRAME_X_DISPLAY_INFO (f)->root_window)
10297 {
10298 /* Since the WM decorations come below top_pos now,
10299 we must put them below top_pos in the future. */
10300 f->output_data.x->win_gravity = NorthWestGravity;
10301 x_wm_set_size_hint (f, (long) 0, 0);
10302 }
10303 #ifdef USE_MOTIF
10304 /* Some window managers pass (0,0) as the location of
10305 the window, and the Motif event handler stores it
10306 in the emacs widget, which messes up Motif menus. */
10307 if (event.xconfigure.x == 0 && event.xconfigure.y == 0)
10308 {
10309 event.xconfigure.x = f->output_data.x->widget->core.x;
10310 event.xconfigure.y = f->output_data.x->widget->core.y;
10311 }
10312 #endif /* USE_MOTIF */
10313 }
10314 goto OTHER;
10315
10316 case ButtonPress:
10317 case ButtonRelease:
10318 {
10319 /* If we decide we want to generate an event to be seen
10320 by the rest of Emacs, we put it here. */
10321 struct input_event emacs_event;
10322 int tool_bar_p = 0;
10323
10324 emacs_event.kind = no_event;
10325 bzero (&compose_status, sizeof (compose_status));
10326
10327 if (dpyinfo->grabbed
10328 && last_mouse_frame
10329 && FRAME_LIVE_P (last_mouse_frame))
10330 f = last_mouse_frame;
10331 else
10332 f = x_window_to_frame (dpyinfo, event.xbutton.window);
10333
10334 if (f)
10335 {
10336 /* Is this in the tool-bar? */
10337 if (WINDOWP (f->tool_bar_window)
10338 && XFASTINT (XWINDOW (f->tool_bar_window)->height))
10339 {
10340 Lisp_Object window;
10341 int p, x, y;
10342
10343 x = event.xbutton.x;
10344 y = event.xbutton.y;
10345
10346 /* Set x and y. */
10347 window = window_from_coordinates (f, x, y, &p, 1);
10348 if (EQ (window, f->tool_bar_window))
10349 {
10350 x_handle_tool_bar_click (f, &event.xbutton);
10351 tool_bar_p = 1;
10352 }
10353 }
10354
10355 if (!tool_bar_p)
10356 if (!dpyinfo->x_focus_frame
10357 || f == dpyinfo->x_focus_frame)
10358 construct_mouse_click (&emacs_event, &event, f);
10359 }
10360 else
10361 {
10362 #ifndef USE_TOOLKIT_SCROLL_BARS
10363 struct scroll_bar *bar
10364 = x_window_to_scroll_bar (event.xbutton.window);
10365
10366 if (bar)
10367 x_scroll_bar_handle_click (bar, &event, &emacs_event);
10368 #endif /* not USE_TOOLKIT_SCROLL_BARS */
10369 }
10370
10371 if (event.type == ButtonPress)
10372 {
10373 dpyinfo->grabbed |= (1 << event.xbutton.button);
10374 last_mouse_frame = f;
10375 /* Ignore any mouse motion that happened
10376 before this event; any subsequent mouse-movement
10377 Emacs events should reflect only motion after
10378 the ButtonPress. */
10379 if (f != 0)
10380 f->mouse_moved = 0;
10381
10382 if (!tool_bar_p)
10383 last_tool_bar_item = -1;
10384 }
10385 else
10386 {
10387 dpyinfo->grabbed &= ~(1 << event.xbutton.button);
10388 }
10389
10390 if (numchars >= 1 && emacs_event.kind != no_event)
10391 {
10392 bcopy (&emacs_event, bufp, sizeof (struct input_event));
10393 bufp++;
10394 count++;
10395 numchars--;
10396 }
10397
10398 #ifdef USE_X_TOOLKIT
10399 f = x_menubar_window_to_frame (dpyinfo, event.xbutton.window);
10400 /* For a down-event in the menu bar,
10401 don't pass it to Xt right now.
10402 Instead, save it away
10403 and we will pass it to Xt from kbd_buffer_get_event.
10404 That way, we can run some Lisp code first. */
10405 if (f && event.type == ButtonPress
10406 /* Verify the event is really within the menu bar
10407 and not just sent to it due to grabbing. */
10408 && event.xbutton.x >= 0
10409 && event.xbutton.x < f->output_data.x->pixel_width
10410 && event.xbutton.y >= 0
10411 && event.xbutton.y < f->output_data.x->menubar_height
10412 && event.xbutton.same_screen)
10413 {
10414 SET_SAVED_BUTTON_EVENT;
10415 XSETFRAME (last_mouse_press_frame, f);
10416 }
10417 else if (event.type == ButtonPress)
10418 {
10419 last_mouse_press_frame = Qnil;
10420 goto OTHER;
10421 }
10422
10423 #ifdef USE_MOTIF /* This should do not harm for Lucid,
10424 but I am trying to be cautious. */
10425 else if (event.type == ButtonRelease)
10426 {
10427 if (!NILP (last_mouse_press_frame))
10428 {
10429 f = XFRAME (last_mouse_press_frame);
10430 if (f->output_data.x)
10431 SET_SAVED_BUTTON_EVENT;
10432 }
10433 else
10434 goto OTHER;
10435 }
10436 #endif /* USE_MOTIF */
10437 else
10438 goto OTHER;
10439 #endif /* USE_X_TOOLKIT */
10440 }
10441 break;
10442
10443 case CirculateNotify:
10444 goto OTHER;
10445
10446 case CirculateRequest:
10447 goto OTHER;
10448
10449 case VisibilityNotify:
10450 goto OTHER;
10451
10452 case MappingNotify:
10453 /* Someone has changed the keyboard mapping - update the
10454 local cache. */
10455 switch (event.xmapping.request)
10456 {
10457 case MappingModifier:
10458 x_find_modifier_meanings (dpyinfo);
10459 /* This is meant to fall through. */
10460 case MappingKeyboard:
10461 XRefreshKeyboardMapping (&event.xmapping);
10462 }
10463 goto OTHER;
10464
10465 default:
10466 OTHER:
10467 #ifdef USE_X_TOOLKIT
10468 BLOCK_INPUT;
10469 XtDispatchEvent (&event);
10470 UNBLOCK_INPUT;
10471 #endif /* USE_X_TOOLKIT */
10472 break;
10473 }
10474 }
10475 }
10476
10477 out:;
10478
10479 /* On some systems, an X bug causes Emacs to get no more events
10480 when the window is destroyed. Detect that. (1994.) */
10481 if (! event_found)
10482 {
10483 /* Emacs and the X Server eats up CPU time if XNoOp is done every time.
10484 One XNOOP in 100 loops will make Emacs terminate.
10485 B. Bretthauer, 1994 */
10486 x_noop_count++;
10487 if (x_noop_count >= 100)
10488 {
10489 x_noop_count=0;
10490
10491 if (next_noop_dpyinfo == 0)
10492 next_noop_dpyinfo = x_display_list;
10493
10494 XNoOp (next_noop_dpyinfo->display);
10495
10496 /* Each time we get here, cycle through the displays now open. */
10497 next_noop_dpyinfo = next_noop_dpyinfo->next;
10498 }
10499 }
10500
10501 /* If the focus was just given to an auto-raising frame,
10502 raise it now. */
10503 /* ??? This ought to be able to handle more than one such frame. */
10504 if (pending_autoraise_frame)
10505 {
10506 x_raise_frame (pending_autoraise_frame);
10507 pending_autoraise_frame = 0;
10508 }
10509
10510 UNBLOCK_INPUT;
10511 --handling_signal;
10512 return count;
10513 }
10514
10515
10516
10517 \f
10518 /***********************************************************************
10519 Text Cursor
10520 ***********************************************************************/
10521
10522 /* Note if the text cursor of window W has been overwritten by a
10523 drawing operation that outputs N glyphs starting at HPOS in the
10524 line given by output_cursor.vpos. N < 0 means all the rest of the
10525 line after HPOS has been written. */
10526
10527 static void
10528 note_overwritten_text_cursor (w, hpos, n)
10529 struct window *w;
10530 int hpos, n;
10531 {
10532 if (updated_area == TEXT_AREA
10533 && output_cursor.vpos == w->phys_cursor.vpos
10534 && hpos <= w->phys_cursor.hpos
10535 && (n < 0
10536 || hpos + n > w->phys_cursor.hpos))
10537 w->phys_cursor_on_p = 0;
10538 }
10539
10540
10541 /* Set clipping for output in glyph row ROW. W is the window in which
10542 we operate. GC is the graphics context to set clipping in.
10543 WHOLE_LINE_P non-zero means include the areas used for truncation
10544 mark display and alike in the clipping rectangle.
10545
10546 ROW may be a text row or, e.g., a mode line. Text rows must be
10547 clipped to the interior of the window dedicated to text display,
10548 mode lines must be clipped to the whole window. */
10549
10550 static void
10551 x_clip_to_row (w, row, gc, whole_line_p)
10552 struct window *w;
10553 struct glyph_row *row;
10554 GC gc;
10555 int whole_line_p;
10556 {
10557 struct frame *f = XFRAME (WINDOW_FRAME (w));
10558 XRectangle clip_rect;
10559 int window_x, window_y, window_width, window_height;
10560
10561 window_box (w, -1, &window_x, &window_y, &window_width, &window_height);
10562
10563 clip_rect.x = WINDOW_TO_FRAME_PIXEL_X (w, 0);
10564 clip_rect.y = WINDOW_TO_FRAME_PIXEL_Y (w, row->y);
10565 clip_rect.y = max (clip_rect.y, window_y);
10566 clip_rect.width = window_width;
10567 clip_rect.height = row->visible_height;
10568
10569 /* If clipping to the whole line, including trunc marks, extend
10570 the rectangle to the left and increase its width. */
10571 if (whole_line_p)
10572 {
10573 clip_rect.x -= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f);
10574 clip_rect.width += FRAME_X_FLAGS_AREA_WIDTH (f);
10575 }
10576
10577 XSetClipRectangles (FRAME_X_DISPLAY (f), gc, 0, 0, &clip_rect, 1, Unsorted);
10578 }
10579
10580
10581 /* Draw a hollow box cursor on window W in glyph row ROW. */
10582
10583 static void
10584 x_draw_hollow_cursor (w, row)
10585 struct window *w;
10586 struct glyph_row *row;
10587 {
10588 struct frame *f = XFRAME (WINDOW_FRAME (w));
10589 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
10590 Display *dpy = FRAME_X_DISPLAY (f);
10591 int x, y, wd, h;
10592 XGCValues xgcv;
10593 struct glyph *cursor_glyph;
10594 GC gc;
10595
10596 /* Compute frame-relative coordinates from window-relative
10597 coordinates. */
10598 x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
10599 y = (WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y)
10600 + row->ascent - w->phys_cursor_ascent);
10601 h = row->height - 1;
10602
10603 /* Get the glyph the cursor is on. If we can't tell because
10604 the current matrix is invalid or such, give up. */
10605 cursor_glyph = get_phys_cursor_glyph (w);
10606 if (cursor_glyph == NULL)
10607 return;
10608
10609 /* Compute the width of the rectangle to draw. If on a stretch
10610 glyph, and `x-stretch-block-cursor' is nil, don't draw a
10611 rectangle as wide as the glyph, but use a canonical character
10612 width instead. */
10613 wd = cursor_glyph->pixel_width - 1;
10614 if (cursor_glyph->type == STRETCH_GLYPH
10615 && !x_stretch_cursor_p)
10616 wd = min (CANON_X_UNIT (f), wd);
10617
10618 /* The foreground of cursor_gc is typically the same as the normal
10619 background color, which can cause the cursor box to be invisible. */
10620 xgcv.foreground = f->output_data.x->cursor_pixel;
10621 if (dpyinfo->scratch_cursor_gc)
10622 XChangeGC (dpy, dpyinfo->scratch_cursor_gc, GCForeground, &xgcv);
10623 else
10624 dpyinfo->scratch_cursor_gc = XCreateGC (dpy, FRAME_X_WINDOW (f),
10625 GCForeground, &xgcv);
10626 gc = dpyinfo->scratch_cursor_gc;
10627
10628 /* Set clipping, draw the rectangle, and reset clipping again. */
10629 x_clip_to_row (w, row, gc, 0);
10630 XDrawRectangle (dpy, FRAME_X_WINDOW (f), gc, x, y, wd, h);
10631 XSetClipMask (dpy, gc, None);
10632 }
10633
10634
10635 /* Draw a bar cursor on window W in glyph row ROW.
10636
10637 Implementation note: One would like to draw a bar cursor with an
10638 angle equal to the one given by the font property XA_ITALIC_ANGLE.
10639 Unfortunately, I didn't find a font yet that has this property set.
10640 --gerd. */
10641
10642 static void
10643 x_draw_bar_cursor (w, row, width)
10644 struct window *w;
10645 struct glyph_row *row;
10646 int width;
10647 {
10648 struct frame *f = XFRAME (w->frame);
10649 struct glyph *cursor_glyph;
10650 GC gc;
10651 int x;
10652 unsigned long mask;
10653 XGCValues xgcv;
10654 Display *dpy;
10655 Window window;
10656
10657 /* If cursor is out of bounds, don't draw garbage. This can happen
10658 in mini-buffer windows when switching between echo area glyphs
10659 and mini-buffer. */
10660 cursor_glyph = get_phys_cursor_glyph (w);
10661 if (cursor_glyph == NULL)
10662 return;
10663
10664 /* If on an image, draw like a normal cursor. That's usually better
10665 visible than drawing a bar, esp. if the image is large so that
10666 the bar might not be in the window. */
10667 if (cursor_glyph->type == IMAGE_GLYPH)
10668 {
10669 struct glyph_row *row;
10670 row = MATRIX_ROW (w->current_matrix, w->phys_cursor.vpos);
10671 x_draw_phys_cursor_glyph (w, row, DRAW_CURSOR);
10672 }
10673 else
10674 {
10675 xgcv.background = f->output_data.x->cursor_pixel;
10676 xgcv.foreground = f->output_data.x->cursor_pixel;
10677 xgcv.graphics_exposures = 0;
10678 mask = GCForeground | GCBackground | GCGraphicsExposures;
10679 dpy = FRAME_X_DISPLAY (f);
10680 window = FRAME_X_WINDOW (f);
10681 gc = FRAME_X_DISPLAY_INFO (f)->scratch_cursor_gc;
10682
10683 if (gc)
10684 XChangeGC (dpy, gc, mask, &xgcv);
10685 else
10686 {
10687 gc = XCreateGC (dpy, window, mask, &xgcv);
10688 FRAME_X_DISPLAY_INFO (f)->scratch_cursor_gc = gc;
10689 }
10690
10691 if (width < 0)
10692 width = f->output_data.x->cursor_width;
10693
10694 x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x);
10695 x_clip_to_row (w, row, gc, 0);
10696 XFillRectangle (dpy, window, gc,
10697 x,
10698 WINDOW_TO_FRAME_PIXEL_Y (w, w->phys_cursor.y),
10699 min (cursor_glyph->pixel_width, width),
10700 row->height);
10701 XSetClipMask (dpy, gc, None);
10702 }
10703 }
10704
10705
10706 /* Clear the cursor of window W to background color, and mark the
10707 cursor as not shown. This is used when the text where the cursor
10708 is is about to be rewritten. */
10709
10710 static void
10711 x_clear_cursor (w)
10712 struct window *w;
10713 {
10714 if (FRAME_VISIBLE_P (XFRAME (w->frame)) && w->phys_cursor_on_p)
10715 x_update_window_cursor (w, 0);
10716 }
10717
10718
10719 /* Draw the cursor glyph of window W in glyph row ROW. See the
10720 comment of x_draw_glyphs for the meaning of HL. */
10721
10722 static void
10723 x_draw_phys_cursor_glyph (w, row, hl)
10724 struct window *w;
10725 struct glyph_row *row;
10726 enum draw_glyphs_face hl;
10727 {
10728 /* If cursor hpos is out of bounds, don't draw garbage. This can
10729 happen in mini-buffer windows when switching between echo area
10730 glyphs and mini-buffer. */
10731 if (w->phys_cursor.hpos < row->used[TEXT_AREA])
10732 {
10733 x_draw_glyphs (w, w->phys_cursor.x, row, TEXT_AREA,
10734 w->phys_cursor.hpos, w->phys_cursor.hpos + 1,
10735 hl, 0, 0, 0);
10736
10737 /* When we erase the cursor, and ROW is overlapped by other
10738 rows, make sure that these overlapping parts of other rows
10739 are redrawn. */
10740 if (hl == DRAW_NORMAL_TEXT && row->overlapped_p)
10741 {
10742 if (row > w->current_matrix->rows
10743 && MATRIX_ROW_OVERLAPS_SUCC_P (row - 1))
10744 x_fix_overlapping_area (w, row - 1, TEXT_AREA);
10745
10746 if (MATRIX_ROW_BOTTOM_Y (row) < window_text_bottom_y (w)
10747 && MATRIX_ROW_OVERLAPS_PRED_P (row + 1))
10748 x_fix_overlapping_area (w, row + 1, TEXT_AREA);
10749 }
10750 }
10751 }
10752
10753
10754 /* Erase the image of a cursor of window W from the screen. */
10755
10756 static void
10757 x_erase_phys_cursor (w)
10758 struct window *w;
10759 {
10760 struct frame *f = XFRAME (w->frame);
10761 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
10762 int hpos = w->phys_cursor.hpos;
10763 int vpos = w->phys_cursor.vpos;
10764 int mouse_face_here_p = 0;
10765 struct glyph_matrix *active_glyphs = w->current_matrix;
10766 struct glyph_row *cursor_row;
10767 struct glyph *cursor_glyph;
10768 enum draw_glyphs_face hl;
10769
10770 /* No cursor displayed or row invalidated => nothing to do on the
10771 screen. */
10772 if (w->phys_cursor_type == NO_CURSOR)
10773 goto mark_cursor_off;
10774
10775 /* VPOS >= active_glyphs->nrows means that window has been resized.
10776 Don't bother to erase the cursor. */
10777 if (vpos >= active_glyphs->nrows)
10778 goto mark_cursor_off;
10779
10780 /* If row containing cursor is marked invalid, there is nothing we
10781 can do. */
10782 cursor_row = MATRIX_ROW (active_glyphs, vpos);
10783 if (!cursor_row->enabled_p)
10784 goto mark_cursor_off;
10785
10786 /* This can happen when the new row is shorter than the old one.
10787 In this case, either x_draw_glyphs or clear_end_of_line
10788 should have cleared the cursor. Note that we wouldn't be
10789 able to erase the cursor in this case because we don't have a
10790 cursor glyph at hand. */
10791 if (w->phys_cursor.hpos >= cursor_row->used[TEXT_AREA])
10792 goto mark_cursor_off;
10793
10794 /* If the cursor is in the mouse face area, redisplay that when
10795 we clear the cursor. */
10796 if (! NILP (dpyinfo->mouse_face_window)
10797 && w == XWINDOW (dpyinfo->mouse_face_window)
10798 && (vpos > dpyinfo->mouse_face_beg_row
10799 || (vpos == dpyinfo->mouse_face_beg_row
10800 && hpos >= dpyinfo->mouse_face_beg_col))
10801 && (vpos < dpyinfo->mouse_face_end_row
10802 || (vpos == dpyinfo->mouse_face_end_row
10803 && hpos < dpyinfo->mouse_face_end_col))
10804 /* Don't redraw the cursor's spot in mouse face if it is at the
10805 end of a line (on a newline). The cursor appears there, but
10806 mouse highlighting does not. */
10807 && cursor_row->used[TEXT_AREA] > hpos)
10808 mouse_face_here_p = 1;
10809
10810 /* Maybe clear the display under the cursor. */
10811 if (w->phys_cursor_type == HOLLOW_BOX_CURSOR)
10812 {
10813 int x;
10814 int header_line_height = WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w);
10815
10816 cursor_glyph = get_phys_cursor_glyph (w);
10817 if (cursor_glyph == NULL)
10818 goto mark_cursor_off;
10819
10820 x = WINDOW_TEXT_TO_FRAME_PIXEL_X (w, w->phys_cursor.x),
10821
10822 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
10823 x,
10824 WINDOW_TO_FRAME_PIXEL_Y (w, max (header_line_height,
10825 cursor_row->y)),
10826 cursor_glyph->pixel_width,
10827 cursor_row->visible_height,
10828 False);
10829 }
10830
10831 /* Erase the cursor by redrawing the character underneath it. */
10832 if (mouse_face_here_p)
10833 hl = DRAW_MOUSE_FACE;
10834 else if (cursor_row->inverse_p)
10835 hl = DRAW_INVERSE_VIDEO;
10836 else
10837 hl = DRAW_NORMAL_TEXT;
10838 x_draw_phys_cursor_glyph (w, cursor_row, hl);
10839
10840 mark_cursor_off:
10841 w->phys_cursor_on_p = 0;
10842 w->phys_cursor_type = NO_CURSOR;
10843 }
10844
10845
10846 /* Display or clear cursor of window W. If ON is zero, clear the
10847 cursor. If it is non-zero, display the cursor. If ON is nonzero,
10848 where to put the cursor is specified by HPOS, VPOS, X and Y. */
10849
10850 void
10851 x_display_and_set_cursor (w, on, hpos, vpos, x, y)
10852 struct window *w;
10853 int on, hpos, vpos, x, y;
10854 {
10855 struct frame *f = XFRAME (w->frame);
10856 int new_cursor_type;
10857 int new_cursor_width;
10858 struct glyph_matrix *current_glyphs;
10859 struct glyph_row *glyph_row;
10860 struct glyph *glyph;
10861
10862 /* This is pointless on invisible frames, and dangerous on garbaged
10863 windows and frames; in the latter case, the frame or window may
10864 be in the midst of changing its size, and x and y may be off the
10865 window. */
10866 if (! FRAME_VISIBLE_P (f)
10867 || FRAME_GARBAGED_P (f)
10868 || vpos >= w->current_matrix->nrows
10869 || hpos >= w->current_matrix->matrix_w)
10870 return;
10871
10872 /* If cursor is off and we want it off, return quickly. */
10873 if (!on && !w->phys_cursor_on_p)
10874 return;
10875
10876 current_glyphs = w->current_matrix;
10877 glyph_row = MATRIX_ROW (current_glyphs, vpos);
10878 glyph = glyph_row->glyphs[TEXT_AREA] + hpos;
10879
10880 /* If cursor row is not enabled, we don't really know where to
10881 display the cursor. */
10882 if (!glyph_row->enabled_p)
10883 {
10884 w->phys_cursor_on_p = 0;
10885 return;
10886 }
10887
10888 xassert (interrupt_input_blocked);
10889
10890 /* Set new_cursor_type to the cursor we want to be displayed. In a
10891 mini-buffer window, we want the cursor only to appear if we are
10892 reading input from this window. For the selected window, we want
10893 the cursor type given by the frame parameter. If explicitly
10894 marked off, draw no cursor. In all other cases, we want a hollow
10895 box cursor. */
10896 new_cursor_width = -1;
10897 if (cursor_in_echo_area
10898 && FRAME_HAS_MINIBUF_P (f)
10899 && EQ (FRAME_MINIBUF_WINDOW (f), echo_area_window))
10900 {
10901 if (w == XWINDOW (echo_area_window))
10902 new_cursor_type = FRAME_DESIRED_CURSOR (f);
10903 else
10904 new_cursor_type = HOLLOW_BOX_CURSOR;
10905 }
10906 else
10907 {
10908 if (f != FRAME_X_DISPLAY_INFO (f)->x_highlight_frame
10909 || w != XWINDOW (f->selected_window))
10910 {
10911 extern int cursor_in_non_selected_windows;
10912
10913 if (MINI_WINDOW_P (w)
10914 || !cursor_in_non_selected_windows
10915 || NILP (XBUFFER (w->buffer)->cursor_type))
10916 new_cursor_type = NO_CURSOR;
10917 else
10918 new_cursor_type = HOLLOW_BOX_CURSOR;
10919 }
10920 else if (w->cursor_off_p)
10921 new_cursor_type = NO_CURSOR;
10922 else
10923 {
10924 struct buffer *b = XBUFFER (w->buffer);
10925
10926 if (EQ (b->cursor_type, Qt))
10927 new_cursor_type = FRAME_DESIRED_CURSOR (f);
10928 else
10929 new_cursor_type = x_specified_cursor_type (b->cursor_type,
10930 &new_cursor_width);
10931 }
10932 }
10933
10934 /* If cursor is currently being shown and we don't want it to be or
10935 it is in the wrong place, or the cursor type is not what we want,
10936 erase it. */
10937 if (w->phys_cursor_on_p
10938 && (!on
10939 || w->phys_cursor.x != x
10940 || w->phys_cursor.y != y
10941 || new_cursor_type != w->phys_cursor_type))
10942 x_erase_phys_cursor (w);
10943
10944 /* If the cursor is now invisible and we want it to be visible,
10945 display it. */
10946 if (on && !w->phys_cursor_on_p)
10947 {
10948 w->phys_cursor_ascent = glyph_row->ascent;
10949 w->phys_cursor_height = glyph_row->height;
10950
10951 /* Set phys_cursor_.* before x_draw_.* is called because some
10952 of them may need the information. */
10953 w->phys_cursor.x = x;
10954 w->phys_cursor.y = glyph_row->y;
10955 w->phys_cursor.hpos = hpos;
10956 w->phys_cursor.vpos = vpos;
10957 w->phys_cursor_type = new_cursor_type;
10958 w->phys_cursor_on_p = 1;
10959
10960 switch (new_cursor_type)
10961 {
10962 case HOLLOW_BOX_CURSOR:
10963 x_draw_hollow_cursor (w, glyph_row);
10964 break;
10965
10966 case FILLED_BOX_CURSOR:
10967 x_draw_phys_cursor_glyph (w, glyph_row, DRAW_CURSOR);
10968 break;
10969
10970 case BAR_CURSOR:
10971 x_draw_bar_cursor (w, glyph_row, new_cursor_width);
10972 break;
10973
10974 case NO_CURSOR:
10975 break;
10976
10977 default:
10978 abort ();
10979 }
10980
10981 #ifdef HAVE_X_I18N
10982 if (w == XWINDOW (f->selected_window))
10983 if (FRAME_XIC (f) && (FRAME_XIC_STYLE (f) & XIMPreeditPosition))
10984 xic_set_preeditarea (w, x, y);
10985 #endif
10986 }
10987
10988 #ifndef XFlush
10989 if (updating_frame != f)
10990 XFlush (FRAME_X_DISPLAY (f));
10991 #endif
10992 }
10993
10994
10995 /* Display the cursor on window W, or clear it. X and Y are window
10996 relative pixel coordinates. HPOS and VPOS are glyph matrix
10997 positions. If W is not the selected window, display a hollow
10998 cursor. ON non-zero means display the cursor at X, Y which
10999 correspond to HPOS, VPOS, otherwise it is cleared. */
11000
11001 void
11002 x_display_cursor (w, on, hpos, vpos, x, y)
11003 struct window *w;
11004 int on, hpos, vpos, x, y;
11005 {
11006 BLOCK_INPUT;
11007 x_display_and_set_cursor (w, on, hpos, vpos, x, y);
11008 UNBLOCK_INPUT;
11009 }
11010
11011
11012 /* Display the cursor on window W, or clear it, according to ON_P.
11013 Don't change the cursor's position. */
11014
11015 void
11016 x_update_cursor (f, on_p)
11017 struct frame *f;
11018 {
11019 x_update_cursor_in_window_tree (XWINDOW (f->root_window), on_p);
11020 }
11021
11022
11023 /* Call x_update_window_cursor with parameter ON_P on all leaf windows
11024 in the window tree rooted at W. */
11025
11026 static void
11027 x_update_cursor_in_window_tree (w, on_p)
11028 struct window *w;
11029 int on_p;
11030 {
11031 while (w)
11032 {
11033 if (!NILP (w->hchild))
11034 x_update_cursor_in_window_tree (XWINDOW (w->hchild), on_p);
11035 else if (!NILP (w->vchild))
11036 x_update_cursor_in_window_tree (XWINDOW (w->vchild), on_p);
11037 else
11038 x_update_window_cursor (w, on_p);
11039
11040 w = NILP (w->next) ? 0 : XWINDOW (w->next);
11041 }
11042 }
11043
11044
11045 /* Switch the display of W's cursor on or off, according to the value
11046 of ON. */
11047
11048 static void
11049 x_update_window_cursor (w, on)
11050 struct window *w;
11051 int on;
11052 {
11053 /* Don't update cursor in windows whose frame is in the process
11054 of being deleted. */
11055 if (w->current_matrix)
11056 {
11057 BLOCK_INPUT;
11058 x_display_and_set_cursor (w, on, w->phys_cursor.hpos, w->phys_cursor.vpos,
11059 w->phys_cursor.x, w->phys_cursor.y);
11060 UNBLOCK_INPUT;
11061 }
11062 }
11063
11064
11065
11066 \f
11067 /* Icons. */
11068
11069 /* Refresh bitmap kitchen sink icon for frame F
11070 when we get an expose event for it. */
11071
11072 void
11073 refreshicon (f)
11074 struct frame *f;
11075 {
11076 /* Normally, the window manager handles this function. */
11077 }
11078
11079 /* Make the x-window of frame F use the gnu icon bitmap. */
11080
11081 int
11082 x_bitmap_icon (f, file)
11083 struct frame *f;
11084 Lisp_Object file;
11085 {
11086 int bitmap_id;
11087
11088 if (FRAME_X_WINDOW (f) == 0)
11089 return 1;
11090
11091 /* Free up our existing icon bitmap if any. */
11092 if (f->output_data.x->icon_bitmap > 0)
11093 x_destroy_bitmap (f, f->output_data.x->icon_bitmap);
11094 f->output_data.x->icon_bitmap = 0;
11095
11096 if (STRINGP (file))
11097 bitmap_id = x_create_bitmap_from_file (f, file);
11098 else
11099 {
11100 /* Create the GNU bitmap if necessary. */
11101 if (FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id < 0)
11102 FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id
11103 = x_create_bitmap_from_data (f, gnu_bits,
11104 gnu_width, gnu_height);
11105
11106 /* The first time we create the GNU bitmap,
11107 this increments the ref-count one extra time.
11108 As a result, the GNU bitmap is never freed.
11109 That way, we don't have to worry about allocating it again. */
11110 x_reference_bitmap (f, FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id);
11111
11112 bitmap_id = FRAME_X_DISPLAY_INFO (f)->icon_bitmap_id;
11113 }
11114
11115 x_wm_set_icon_pixmap (f, bitmap_id);
11116 f->output_data.x->icon_bitmap = bitmap_id;
11117
11118 return 0;
11119 }
11120
11121
11122 /* Make the x-window of frame F use a rectangle with text.
11123 Use ICON_NAME as the text. */
11124
11125 int
11126 x_text_icon (f, icon_name)
11127 struct frame *f;
11128 char *icon_name;
11129 {
11130 if (FRAME_X_WINDOW (f) == 0)
11131 return 1;
11132
11133 #ifdef HAVE_X11R4
11134 {
11135 XTextProperty text;
11136 text.value = (unsigned char *) icon_name;
11137 text.encoding = XA_STRING;
11138 text.format = 8;
11139 text.nitems = strlen (icon_name);
11140 #ifdef USE_X_TOOLKIT
11141 XSetWMIconName (FRAME_X_DISPLAY (f), XtWindow (f->output_data.x->widget),
11142 &text);
11143 #else /* not USE_X_TOOLKIT */
11144 XSetWMIconName (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), &text);
11145 #endif /* not USE_X_TOOLKIT */
11146 }
11147 #else /* not HAVE_X11R4 */
11148 XSetIconName (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), icon_name);
11149 #endif /* not HAVE_X11R4 */
11150
11151 if (f->output_data.x->icon_bitmap > 0)
11152 x_destroy_bitmap (f, f->output_data.x->icon_bitmap);
11153 f->output_data.x->icon_bitmap = 0;
11154 x_wm_set_icon_pixmap (f, 0);
11155
11156 return 0;
11157 }
11158 \f
11159 #define X_ERROR_MESSAGE_SIZE 200
11160
11161 /* If non-nil, this should be a string.
11162 It means catch X errors and store the error message in this string. */
11163
11164 static Lisp_Object x_error_message_string;
11165
11166 /* An X error handler which stores the error message in
11167 x_error_message_string. This is called from x_error_handler if
11168 x_catch_errors is in effect. */
11169
11170 static void
11171 x_error_catcher (display, error)
11172 Display *display;
11173 XErrorEvent *error;
11174 {
11175 XGetErrorText (display, error->error_code,
11176 XSTRING (x_error_message_string)->data,
11177 X_ERROR_MESSAGE_SIZE);
11178 }
11179
11180 /* Begin trapping X errors for display DPY. Actually we trap X errors
11181 for all displays, but DPY should be the display you are actually
11182 operating on.
11183
11184 After calling this function, X protocol errors no longer cause
11185 Emacs to exit; instead, they are recorded in the string
11186 stored in x_error_message_string.
11187
11188 Calling x_check_errors signals an Emacs error if an X error has
11189 occurred since the last call to x_catch_errors or x_check_errors.
11190
11191 Calling x_uncatch_errors resumes the normal error handling. */
11192
11193 void x_check_errors ();
11194 static Lisp_Object x_catch_errors_unwind ();
11195
11196 int
11197 x_catch_errors (dpy)
11198 Display *dpy;
11199 {
11200 int count = specpdl_ptr - specpdl;
11201
11202 /* Make sure any errors from previous requests have been dealt with. */
11203 XSync (dpy, False);
11204
11205 record_unwind_protect (x_catch_errors_unwind, x_error_message_string);
11206
11207 x_error_message_string = make_uninit_string (X_ERROR_MESSAGE_SIZE);
11208 XSTRING (x_error_message_string)->data[0] = 0;
11209
11210 return count;
11211 }
11212
11213 /* Unbind the binding that we made to check for X errors. */
11214
11215 static Lisp_Object
11216 x_catch_errors_unwind (old_val)
11217 Lisp_Object old_val;
11218 {
11219 x_error_message_string = old_val;
11220 return Qnil;
11221 }
11222
11223 /* If any X protocol errors have arrived since the last call to
11224 x_catch_errors or x_check_errors, signal an Emacs error using
11225 sprintf (a buffer, FORMAT, the x error message text) as the text. */
11226
11227 void
11228 x_check_errors (dpy, format)
11229 Display *dpy;
11230 char *format;
11231 {
11232 /* Make sure to catch any errors incurred so far. */
11233 XSync (dpy, False);
11234
11235 if (XSTRING (x_error_message_string)->data[0])
11236 error (format, XSTRING (x_error_message_string)->data);
11237 }
11238
11239 /* Nonzero if we had any X protocol errors
11240 since we did x_catch_errors on DPY. */
11241
11242 int
11243 x_had_errors_p (dpy)
11244 Display *dpy;
11245 {
11246 /* Make sure to catch any errors incurred so far. */
11247 XSync (dpy, False);
11248
11249 return XSTRING (x_error_message_string)->data[0] != 0;
11250 }
11251
11252 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
11253
11254 void
11255 x_clear_errors (dpy)
11256 Display *dpy;
11257 {
11258 XSTRING (x_error_message_string)->data[0] = 0;
11259 }
11260
11261 /* Stop catching X protocol errors and let them make Emacs die.
11262 DPY should be the display that was passed to x_catch_errors.
11263 COUNT should be the value that was returned by
11264 the corresponding call to x_catch_errors. */
11265
11266 void
11267 x_uncatch_errors (dpy, count)
11268 Display *dpy;
11269 int count;
11270 {
11271 unbind_to (count, Qnil);
11272 }
11273
11274 #if 0
11275 static unsigned int x_wire_count;
11276 x_trace_wire ()
11277 {
11278 fprintf (stderr, "Lib call: %d\n", ++x_wire_count);
11279 }
11280 #endif /* ! 0 */
11281
11282 \f
11283 /* Handle SIGPIPE, which can happen when the connection to a server
11284 simply goes away. SIGPIPE is handled by x_connection_signal.
11285 Don't need to do anything, because the write which caused the
11286 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
11287 which will do the appropriate cleanup for us. */
11288
11289 static SIGTYPE
11290 x_connection_signal (signalnum) /* If we don't have an argument, */
11291 int signalnum; /* some compilers complain in signal calls. */
11292 {
11293 #ifdef USG
11294 /* USG systems forget handlers when they are used;
11295 must reestablish each time */
11296 signal (signalnum, x_connection_signal);
11297 #endif /* USG */
11298 }
11299
11300 \f
11301 /************************************************************************
11302 Handling X errors
11303 ************************************************************************/
11304
11305 /* Handle the loss of connection to display DPY. ERROR_MESSAGE is
11306 the text of an error message that lead to the connection loss. */
11307
11308 static SIGTYPE
11309 x_connection_closed (dpy, error_message)
11310 Display *dpy;
11311 char *error_message;
11312 {
11313 struct x_display_info *dpyinfo = x_display_info_for_display (dpy);
11314 Lisp_Object frame, tail;
11315 int count;
11316 char *msg;
11317
11318 msg = (char *) alloca (strlen (error_message) + 1);
11319 strcpy (msg, error_message);
11320 handling_signal = 0;
11321
11322 /* Prevent being called recursively because of an error condition
11323 below. Otherwise, we might end up with printing ``can't find per
11324 display information'' in the recursive call instead of printing
11325 the original message here. */
11326 count = x_catch_errors (dpy);
11327
11328 /* We have to close the display to inform Xt that it doesn't
11329 exist anymore. If we don't, Xt will continue to wait for
11330 events from the display. As a consequence, a sequence of
11331
11332 M-x make-frame-on-display RET :1 RET
11333 ...kill the new frame, so that we get an IO error...
11334 M-x make-frame-on-display RET :1 RET
11335
11336 will indefinitely wait in Xt for events for display `:1', opened
11337 in the first class to make-frame-on-display.
11338
11339 Closing the display is reported to lead to a bus error on
11340 OpenWindows in certain situations. I suspect that is a bug
11341 in OpenWindows. I don't know how to cicumvent it here. */
11342
11343 #ifdef USE_X_TOOLKIT
11344 /* If DPYINFO is null, this means we didn't open the display
11345 in the first place, so don't try to close it. */
11346 if (dpyinfo)
11347 XtCloseDisplay (dpy);
11348 #endif
11349
11350 /* Indicate that this display is dead. */
11351 if (dpyinfo)
11352 dpyinfo->display = 0;
11353
11354 /* First delete frames whose mini-buffers are on frames
11355 that are on the dead display. */
11356 FOR_EACH_FRAME (tail, frame)
11357 {
11358 Lisp_Object minibuf_frame;
11359 minibuf_frame
11360 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame))));
11361 if (FRAME_X_P (XFRAME (frame))
11362 && FRAME_X_P (XFRAME (minibuf_frame))
11363 && ! EQ (frame, minibuf_frame)
11364 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame)) == dpyinfo)
11365 Fdelete_frame (frame, Qt);
11366 }
11367
11368 /* Now delete all remaining frames on the dead display.
11369 We are now sure none of these is used as the mini-buffer
11370 for another frame that we need to delete. */
11371 FOR_EACH_FRAME (tail, frame)
11372 if (FRAME_X_P (XFRAME (frame))
11373 && FRAME_X_DISPLAY_INFO (XFRAME (frame)) == dpyinfo)
11374 {
11375 /* Set this to t so that Fdelete_frame won't get confused
11376 trying to find a replacement. */
11377 FRAME_KBOARD (XFRAME (frame))->Vdefault_minibuffer_frame = Qt;
11378 Fdelete_frame (frame, Qt);
11379 }
11380
11381 if (dpyinfo)
11382 x_delete_display (dpyinfo);
11383
11384 x_uncatch_errors (dpy, count);
11385
11386 if (x_display_list == 0)
11387 {
11388 fprintf (stderr, "%s\n", msg);
11389 shut_down_emacs (0, 0, Qnil);
11390 exit (70);
11391 }
11392
11393 /* Ordinary stack unwind doesn't deal with these. */
11394 #ifdef SIGIO
11395 sigunblock (sigmask (SIGIO));
11396 #endif
11397 sigunblock (sigmask (SIGALRM));
11398 TOTALLY_UNBLOCK_INPUT;
11399
11400 clear_waiting_for_input ();
11401 error ("%s", msg);
11402 }
11403
11404
11405 /* This is the usual handler for X protocol errors.
11406 It kills all frames on the display that we got the error for.
11407 If that was the only one, it prints an error message and kills Emacs. */
11408
11409 static void
11410 x_error_quitter (display, error)
11411 Display *display;
11412 XErrorEvent *error;
11413 {
11414 char buf[256], buf1[356];
11415
11416 /* Note that there is no real way portable across R3/R4 to get the
11417 original error handler. */
11418
11419 XGetErrorText (display, error->error_code, buf, sizeof (buf));
11420 sprintf (buf1, "X protocol error: %s on protocol request %d",
11421 buf, error->request_code);
11422 x_connection_closed (display, buf1);
11423 }
11424
11425
11426 /* This is the first-level handler for X protocol errors.
11427 It calls x_error_quitter or x_error_catcher. */
11428
11429 static int
11430 x_error_handler (display, error)
11431 Display *display;
11432 XErrorEvent *error;
11433 {
11434 if (! NILP (x_error_message_string))
11435 x_error_catcher (display, error);
11436 else
11437 x_error_quitter (display, error);
11438 return 0;
11439 }
11440
11441 /* This is the handler for X IO errors, always.
11442 It kills all frames on the display that we lost touch with.
11443 If that was the only one, it prints an error message and kills Emacs. */
11444
11445 static int
11446 x_io_error_quitter (display)
11447 Display *display;
11448 {
11449 char buf[256];
11450
11451 sprintf (buf, "Connection lost to X server `%s'", DisplayString (display));
11452 x_connection_closed (display, buf);
11453 return 0;
11454 }
11455 \f
11456 /* Changing the font of the frame. */
11457
11458 /* Give frame F the font named FONTNAME as its default font, and
11459 return the full name of that font. FONTNAME may be a wildcard
11460 pattern; in that case, we choose some font that fits the pattern.
11461 The return value shows which font we chose. */
11462
11463 Lisp_Object
11464 x_new_font (f, fontname)
11465 struct frame *f;
11466 register char *fontname;
11467 {
11468 struct font_info *fontp
11469 = FS_LOAD_FONT (f, 0, fontname, -1);
11470
11471 if (!fontp)
11472 return Qnil;
11473
11474 f->output_data.x->font = (XFontStruct *) (fontp->font);
11475 f->output_data.x->baseline_offset = fontp->baseline_offset;
11476 f->output_data.x->fontset = -1;
11477
11478 /* Compute the scroll bar width in character columns. */
11479 if (f->scroll_bar_pixel_width > 0)
11480 {
11481 int wid = FONT_WIDTH (f->output_data.x->font);
11482 f->scroll_bar_cols = (f->scroll_bar_pixel_width + wid-1) / wid;
11483 }
11484 else
11485 {
11486 int wid = FONT_WIDTH (f->output_data.x->font);
11487 f->scroll_bar_cols = (14 + wid - 1) / wid;
11488 }
11489
11490 /* Now make the frame display the given font. */
11491 if (FRAME_X_WINDOW (f) != 0)
11492 {
11493 XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->normal_gc,
11494 f->output_data.x->font->fid);
11495 XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->reverse_gc,
11496 f->output_data.x->font->fid);
11497 XSetFont (FRAME_X_DISPLAY (f), f->output_data.x->cursor_gc,
11498 f->output_data.x->font->fid);
11499
11500 frame_update_line_height (f);
11501
11502 /* Don't change the size of a tip frame; there's no point in
11503 doing it because it's done in Fx_show_tip, and it leads to
11504 problems because the tip frame has no widget. */
11505 if (NILP (tip_frame) || XFRAME (tip_frame) != f)
11506 x_set_window_size (f, 0, f->width, f->height);
11507 }
11508 else
11509 /* If we are setting a new frame's font for the first time,
11510 there are no faces yet, so this font's height is the line height. */
11511 f->output_data.x->line_height = FONT_HEIGHT (f->output_data.x->font);
11512
11513 return build_string (fontp->full_name);
11514 }
11515
11516 /* Give frame F the fontset named FONTSETNAME as its default font, and
11517 return the full name of that fontset. FONTSETNAME may be a wildcard
11518 pattern; in that case, we choose some fontset that fits the pattern.
11519 The return value shows which fontset we chose. */
11520
11521 Lisp_Object
11522 x_new_fontset (f, fontsetname)
11523 struct frame *f;
11524 char *fontsetname;
11525 {
11526 int fontset = fs_query_fontset (build_string (fontsetname), 0);
11527 Lisp_Object result;
11528
11529 if (fontset < 0)
11530 return Qnil;
11531
11532 if (f->output_data.x->fontset == fontset)
11533 /* This fontset is already set in frame F. There's nothing more
11534 to do. */
11535 return fontset_name (fontset);
11536
11537 result = x_new_font (f, (XSTRING (fontset_ascii (fontset))->data));
11538
11539 if (!STRINGP (result))
11540 /* Can't load ASCII font. */
11541 return Qnil;
11542
11543 /* Since x_new_font doesn't update any fontset information, do it now. */
11544 f->output_data.x->fontset = fontset;
11545
11546 #ifdef HAVE_X_I18N
11547 if (FRAME_XIC (f)
11548 && (FRAME_XIC_STYLE (f) & (XIMPreeditPosition | XIMStatusArea)))
11549 xic_set_xfontset (f, XSTRING (fontset_ascii (fontset))->data);
11550 #endif
11551
11552 return build_string (fontsetname);
11553 }
11554
11555 \f
11556 /***********************************************************************
11557 X Input Methods
11558 ***********************************************************************/
11559
11560 #ifdef HAVE_X_I18N
11561
11562 #ifdef HAVE_X11R6
11563
11564 /* XIM destroy callback function, which is called whenever the
11565 connection to input method XIM dies. CLIENT_DATA contains a
11566 pointer to the x_display_info structure corresponding to XIM. */
11567
11568 static void
11569 xim_destroy_callback (xim, client_data, call_data)
11570 XIM xim;
11571 XPointer client_data;
11572 XPointer call_data;
11573 {
11574 struct x_display_info *dpyinfo = (struct x_display_info *) client_data;
11575 Lisp_Object frame, tail;
11576
11577 BLOCK_INPUT;
11578
11579 /* No need to call XDestroyIC.. */
11580 FOR_EACH_FRAME (tail, frame)
11581 {
11582 struct frame *f = XFRAME (frame);
11583 if (FRAME_X_DISPLAY_INFO (f) == dpyinfo)
11584 {
11585 FRAME_XIC (f) = NULL;
11586 if (FRAME_XIC_FONTSET (f))
11587 {
11588 XFreeFontSet (FRAME_X_DISPLAY (f), FRAME_XIC_FONTSET (f));
11589 FRAME_XIC_FONTSET (f) = NULL;
11590 }
11591 }
11592 }
11593
11594 /* No need to call XCloseIM. */
11595 dpyinfo->xim = NULL;
11596 XFree (dpyinfo->xim_styles);
11597 UNBLOCK_INPUT;
11598 }
11599
11600 #endif /* HAVE_X11R6 */
11601
11602 /* Open the connection to the XIM server on display DPYINFO.
11603 RESOURCE_NAME is the resource name Emacs uses. */
11604
11605 static void
11606 xim_open_dpy (dpyinfo, resource_name)
11607 struct x_display_info *dpyinfo;
11608 char *resource_name;
11609 {
11610 #ifdef USE_XIM
11611 XIM xim;
11612
11613 xim = XOpenIM (dpyinfo->display, dpyinfo->xrdb, resource_name, EMACS_CLASS);
11614 dpyinfo->xim = xim;
11615
11616 if (xim)
11617 {
11618 #ifdef HAVE_X11R6
11619 XIMCallback destroy;
11620 #endif
11621
11622 /* Get supported styles and XIM values. */
11623 XGetIMValues (xim, XNQueryInputStyle, &dpyinfo->xim_styles, NULL);
11624
11625 #ifdef HAVE_X11R6
11626 destroy.callback = xim_destroy_callback;
11627 destroy.client_data = (XPointer)dpyinfo;
11628 /* This isn't prptotyped in OSF 5.0. */
11629 XSetIMValues (xim, XNDestroyCallback, &destroy, NULL);
11630 #endif
11631 }
11632
11633 #else /* not USE_XIM */
11634 dpyinfo->xim = NULL;
11635 #endif /* not USE_XIM */
11636 }
11637
11638
11639 #ifdef HAVE_X11R6_XIM
11640
11641 struct xim_inst_t
11642 {
11643 struct x_display_info *dpyinfo;
11644 char *resource_name;
11645 };
11646
11647 /* XIM instantiate callback function, which is called whenever an XIM
11648 server is available. DISPLAY is teh display of the XIM.
11649 CLIENT_DATA contains a pointer to an xim_inst_t structure created
11650 when the callback was registered. */
11651
11652 static void
11653 xim_instantiate_callback (display, client_data, call_data)
11654 Display *display;
11655 XPointer client_data;
11656 XPointer call_data;
11657 {
11658 struct xim_inst_t *xim_inst = (struct xim_inst_t *) client_data;
11659 struct x_display_info *dpyinfo = xim_inst->dpyinfo;
11660
11661 /* We don't support multiple XIM connections. */
11662 if (dpyinfo->xim)
11663 return;
11664
11665 xim_open_dpy (dpyinfo, xim_inst->resource_name);
11666
11667 /* Create XIC for the existing frames on the same display, as long
11668 as they have no XIC. */
11669 if (dpyinfo->xim && dpyinfo->reference_count > 0)
11670 {
11671 Lisp_Object tail, frame;
11672
11673 BLOCK_INPUT;
11674 FOR_EACH_FRAME (tail, frame)
11675 {
11676 struct frame *f = XFRAME (frame);
11677
11678 if (FRAME_X_DISPLAY_INFO (f) == xim_inst->dpyinfo)
11679 if (FRAME_XIC (f) == NULL)
11680 {
11681 create_frame_xic (f);
11682 if (FRAME_XIC_STYLE (f) & XIMStatusArea)
11683 xic_set_statusarea (f);
11684 if (FRAME_XIC_STYLE (f) & XIMPreeditPosition)
11685 {
11686 struct window *w = XWINDOW (f->selected_window);
11687 xic_set_preeditarea (w, w->cursor.x, w->cursor.y);
11688 }
11689 }
11690 }
11691
11692 UNBLOCK_INPUT;
11693 }
11694 }
11695
11696 #endif /* HAVE_X11R6_XIM */
11697
11698
11699 /* Open a connection to the XIM server on display DPYINFO.
11700 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
11701 connection only at the first time. On X11R6, open the connection
11702 in the XIM instantiate callback function. */
11703
11704 static void
11705 xim_initialize (dpyinfo, resource_name)
11706 struct x_display_info *dpyinfo;
11707 char *resource_name;
11708 {
11709 #ifdef USE_XIM
11710 #ifdef HAVE_X11R6_XIM
11711 struct xim_inst_t *xim_inst;
11712 int len;
11713
11714 dpyinfo->xim = NULL;
11715 xim_inst = (struct xim_inst_t *) xmalloc (sizeof (struct xim_inst_t));
11716 xim_inst->dpyinfo = dpyinfo;
11717 len = strlen (resource_name);
11718 xim_inst->resource_name = (char *) xmalloc (len + 1);
11719 bcopy (resource_name, xim_inst->resource_name, len + 1);
11720 XRegisterIMInstantiateCallback (dpyinfo->display, dpyinfo->xrdb,
11721 resource_name, EMACS_CLASS,
11722 xim_instantiate_callback,
11723 /* Fixme: This is XPointer in
11724 XFree86 but (XPointer *) on
11725 Tru64, at least. */
11726 (XPointer) xim_inst);
11727 #else /* not HAVE_X11R6_XIM */
11728 dpyinfo->xim = NULL;
11729 xim_open_dpy (dpyinfo, resource_name);
11730 #endif /* not HAVE_X11R6_XIM */
11731
11732 #else /* not USE_XIM */
11733 dpyinfo->xim = NULL;
11734 #endif /* not USE_XIM */
11735 }
11736
11737
11738 /* Close the connection to the XIM server on display DPYINFO. */
11739
11740 static void
11741 xim_close_dpy (dpyinfo)
11742 struct x_display_info *dpyinfo;
11743 {
11744 #ifdef USE_XIM
11745 #ifdef HAVE_X11R6_XIM
11746 if (dpyinfo->display)
11747 XUnregisterIMInstantiateCallback (dpyinfo->display, dpyinfo->xrdb,
11748 NULL, EMACS_CLASS,
11749 xim_instantiate_callback, NULL);
11750 #endif /* not HAVE_X11R6_XIM */
11751 if (dpyinfo->display)
11752 XCloseIM (dpyinfo->xim);
11753 dpyinfo->xim = NULL;
11754 XFree (dpyinfo->xim_styles);
11755 #endif /* USE_XIM */
11756 }
11757
11758 #endif /* not HAVE_X11R6_XIM */
11759
11760
11761 \f
11762 /* Calculate the absolute position in frame F
11763 from its current recorded position values and gravity. */
11764
11765 void
11766 x_calc_absolute_position (f)
11767 struct frame *f;
11768 {
11769 Window child;
11770 int win_x = 0, win_y = 0;
11771 int flags = f->output_data.x->size_hint_flags;
11772 int this_window;
11773
11774 /* We have nothing to do if the current position
11775 is already for the top-left corner. */
11776 if (! ((flags & XNegative) || (flags & YNegative)))
11777 return;
11778
11779 #ifdef USE_X_TOOLKIT
11780 this_window = XtWindow (f->output_data.x->widget);
11781 #else
11782 this_window = FRAME_X_WINDOW (f);
11783 #endif
11784
11785 /* Find the position of the outside upper-left corner of
11786 the inner window, with respect to the outer window.
11787 But do this only if we will need the results. */
11788 if (f->output_data.x->parent_desc != FRAME_X_DISPLAY_INFO (f)->root_window)
11789 {
11790 int count;
11791
11792 BLOCK_INPUT;
11793 count = x_catch_errors (FRAME_X_DISPLAY (f));
11794 while (1)
11795 {
11796 x_clear_errors (FRAME_X_DISPLAY (f));
11797 XTranslateCoordinates (FRAME_X_DISPLAY (f),
11798
11799 /* From-window, to-window. */
11800 this_window,
11801 f->output_data.x->parent_desc,
11802
11803 /* From-position, to-position. */
11804 0, 0, &win_x, &win_y,
11805
11806 /* Child of win. */
11807 &child);
11808 if (x_had_errors_p (FRAME_X_DISPLAY (f)))
11809 {
11810 Window newroot, newparent = 0xdeadbeef;
11811 Window *newchildren;
11812 unsigned int nchildren;
11813
11814 if (! XQueryTree (FRAME_X_DISPLAY (f), this_window, &newroot,
11815 &newparent, &newchildren, &nchildren))
11816 break;
11817
11818 XFree ((char *) newchildren);
11819
11820 f->output_data.x->parent_desc = newparent;
11821 }
11822 else
11823 break;
11824 }
11825
11826 x_uncatch_errors (FRAME_X_DISPLAY (f), count);
11827 UNBLOCK_INPUT;
11828 }
11829
11830 /* Treat negative positions as relative to the leftmost bottommost
11831 position that fits on the screen. */
11832 if (flags & XNegative)
11833 f->output_data.x->left_pos = (FRAME_X_DISPLAY_INFO (f)->width
11834 - 2 * f->output_data.x->border_width - win_x
11835 - PIXEL_WIDTH (f)
11836 + f->output_data.x->left_pos);
11837
11838 {
11839 int height = PIXEL_HEIGHT (f);
11840
11841 #if defined USE_X_TOOLKIT && defined USE_MOTIF
11842 /* Something is fishy here. When using Motif, starting Emacs with
11843 `-g -0-0', the frame appears too low by a few pixels.
11844
11845 This seems to be so because initially, while Emacs is starting,
11846 the column widget's height and the frame's pixel height are
11847 different. The column widget's height is the right one. In
11848 later invocations, when Emacs is up, the frame's pixel height
11849 is right, though.
11850
11851 It's not obvious where the initial small difference comes from.
11852 2000-12-01, gerd. */
11853
11854 XtVaGetValues (f->output_data.x->column_widget, XtNheight, &height, NULL);
11855 #endif
11856
11857 if (flags & YNegative)
11858 f->output_data.x->top_pos = (FRAME_X_DISPLAY_INFO (f)->height
11859 - 2 * f->output_data.x->border_width
11860 - win_y
11861 - height
11862 + f->output_data.x->top_pos);
11863 }
11864
11865 /* The left_pos and top_pos
11866 are now relative to the top and left screen edges,
11867 so the flags should correspond. */
11868 f->output_data.x->size_hint_flags &= ~ (XNegative | YNegative);
11869 }
11870
11871 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
11872 to really change the position, and 0 when calling from
11873 x_make_frame_visible (in that case, XOFF and YOFF are the current
11874 position values). It is -1 when calling from x_set_frame_parameters,
11875 which means, do adjust for borders but don't change the gravity. */
11876
11877 void
11878 x_set_offset (f, xoff, yoff, change_gravity)
11879 struct frame *f;
11880 register int xoff, yoff;
11881 int change_gravity;
11882 {
11883 int modified_top, modified_left;
11884
11885 if (change_gravity > 0)
11886 {
11887 f->output_data.x->top_pos = yoff;
11888 f->output_data.x->left_pos = xoff;
11889 f->output_data.x->size_hint_flags &= ~ (XNegative | YNegative);
11890 if (xoff < 0)
11891 f->output_data.x->size_hint_flags |= XNegative;
11892 if (yoff < 0)
11893 f->output_data.x->size_hint_flags |= YNegative;
11894 f->output_data.x->win_gravity = NorthWestGravity;
11895 }
11896 x_calc_absolute_position (f);
11897
11898 BLOCK_INPUT;
11899 x_wm_set_size_hint (f, (long) 0, 0);
11900
11901 modified_left = f->output_data.x->left_pos;
11902 modified_top = f->output_data.x->top_pos;
11903 #if 0 /* Running on psilocin (Debian), and displaying on the NCD X-terminal,
11904 this seems to be unnecessary and incorrect. rms, 4/17/97. */
11905 /* It is a mystery why we need to add the border_width here
11906 when the frame is already visible, but experiment says we do. */
11907 if (change_gravity != 0)
11908 {
11909 modified_left += f->output_data.x->border_width;
11910 modified_top += f->output_data.x->border_width;
11911 }
11912 #endif
11913
11914 #ifdef USE_X_TOOLKIT
11915 XMoveWindow (FRAME_X_DISPLAY (f), XtWindow (f->output_data.x->widget),
11916 modified_left, modified_top);
11917 #else /* not USE_X_TOOLKIT */
11918 XMoveWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
11919 modified_left, modified_top);
11920 #endif /* not USE_X_TOOLKIT */
11921 UNBLOCK_INPUT;
11922 }
11923
11924
11925 /* Change the size of frame F's X window to COLS/ROWS in the case F
11926 doesn't have a widget. If CHANGE_GRAVITY is 1, we change to
11927 top-left-corner window gravity for this size change and subsequent
11928 size changes. Otherwise we leave the window gravity unchanged. */
11929
11930 static void
11931 x_set_window_size_1 (f, change_gravity, cols, rows)
11932 struct frame *f;
11933 int change_gravity;
11934 int cols, rows;
11935 {
11936 int pixelwidth, pixelheight;
11937
11938 check_frame_size (f, &rows, &cols);
11939 f->output_data.x->vertical_scroll_bar_extra
11940 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f)
11941 ? 0
11942 : FRAME_SCROLL_BAR_PIXEL_WIDTH (f) > 0
11943 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f)
11944 : (FRAME_SCROLL_BAR_COLS (f) * FONT_WIDTH (f->output_data.x->font)));
11945 f->output_data.x->flags_areas_extra
11946 = FRAME_FLAGS_AREA_WIDTH (f);
11947 pixelwidth = CHAR_TO_PIXEL_WIDTH (f, cols);
11948 pixelheight = CHAR_TO_PIXEL_HEIGHT (f, rows);
11949
11950 f->output_data.x->win_gravity = NorthWestGravity;
11951 x_wm_set_size_hint (f, (long) 0, 0);
11952
11953 XSync (FRAME_X_DISPLAY (f), False);
11954 XResizeWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
11955 pixelwidth, pixelheight);
11956
11957 /* Now, strictly speaking, we can't be sure that this is accurate,
11958 but the window manager will get around to dealing with the size
11959 change request eventually, and we'll hear how it went when the
11960 ConfigureNotify event gets here.
11961
11962 We could just not bother storing any of this information here,
11963 and let the ConfigureNotify event set everything up, but that
11964 might be kind of confusing to the Lisp code, since size changes
11965 wouldn't be reported in the frame parameters until some random
11966 point in the future when the ConfigureNotify event arrives.
11967
11968 We pass 1 for DELAY since we can't run Lisp code inside of
11969 a BLOCK_INPUT. */
11970 change_frame_size (f, rows, cols, 0, 1, 0);
11971 PIXEL_WIDTH (f) = pixelwidth;
11972 PIXEL_HEIGHT (f) = pixelheight;
11973
11974 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
11975 receive in the ConfigureNotify event; if we get what we asked
11976 for, then the event won't cause the screen to become garbaged, so
11977 we have to make sure to do it here. */
11978 SET_FRAME_GARBAGED (f);
11979
11980 XFlush (FRAME_X_DISPLAY (f));
11981 }
11982
11983
11984 /* Call this to change the size of frame F's x-window.
11985 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
11986 for this size change and subsequent size changes.
11987 Otherwise we leave the window gravity unchanged. */
11988
11989 void
11990 x_set_window_size (f, change_gravity, cols, rows)
11991 struct frame *f;
11992 int change_gravity;
11993 int cols, rows;
11994 {
11995 BLOCK_INPUT;
11996
11997 #ifdef USE_X_TOOLKIT
11998
11999 if (f->output_data.x->widget != None)
12000 {
12001 /* The x and y position of the widget is clobbered by the
12002 call to XtSetValues within EmacsFrameSetCharSize.
12003 This is a real kludge, but I don't understand Xt so I can't
12004 figure out a correct fix. Can anyone else tell me? -- rms. */
12005 int xpos = f->output_data.x->widget->core.x;
12006 int ypos = f->output_data.x->widget->core.y;
12007 EmacsFrameSetCharSize (f->output_data.x->edit_widget, cols, rows);
12008 f->output_data.x->widget->core.x = xpos;
12009 f->output_data.x->widget->core.y = ypos;
12010 }
12011 else
12012 x_set_window_size_1 (f, change_gravity, cols, rows);
12013
12014 #else /* not USE_X_TOOLKIT */
12015
12016 x_set_window_size_1 (f, change_gravity, cols, rows);
12017
12018 #endif /* not USE_X_TOOLKIT */
12019
12020 /* If cursor was outside the new size, mark it as off. */
12021 mark_window_cursors_off (XWINDOW (f->root_window));
12022
12023 /* Clear out any recollection of where the mouse highlighting was,
12024 since it might be in a place that's outside the new frame size.
12025 Actually checking whether it is outside is a pain in the neck,
12026 so don't try--just let the highlighting be done afresh with new size. */
12027 cancel_mouse_face (f);
12028
12029 UNBLOCK_INPUT;
12030 }
12031 \f
12032 /* Mouse warping. */
12033
12034 void
12035 x_set_mouse_position (f, x, y)
12036 struct frame *f;
12037 int x, y;
12038 {
12039 int pix_x, pix_y;
12040
12041 pix_x = CHAR_TO_PIXEL_COL (f, x) + FONT_WIDTH (f->output_data.x->font) / 2;
12042 pix_y = CHAR_TO_PIXEL_ROW (f, y) + f->output_data.x->line_height / 2;
12043
12044 if (pix_x < 0) pix_x = 0;
12045 if (pix_x > PIXEL_WIDTH (f)) pix_x = PIXEL_WIDTH (f);
12046
12047 if (pix_y < 0) pix_y = 0;
12048 if (pix_y > PIXEL_HEIGHT (f)) pix_y = PIXEL_HEIGHT (f);
12049
12050 BLOCK_INPUT;
12051
12052 XWarpPointer (FRAME_X_DISPLAY (f), None, FRAME_X_WINDOW (f),
12053 0, 0, 0, 0, pix_x, pix_y);
12054 UNBLOCK_INPUT;
12055 }
12056
12057 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
12058
12059 void
12060 x_set_mouse_pixel_position (f, pix_x, pix_y)
12061 struct frame *f;
12062 int pix_x, pix_y;
12063 {
12064 BLOCK_INPUT;
12065
12066 XWarpPointer (FRAME_X_DISPLAY (f), None, FRAME_X_WINDOW (f),
12067 0, 0, 0, 0, pix_x, pix_y);
12068 UNBLOCK_INPUT;
12069 }
12070 \f
12071 /* focus shifting, raising and lowering. */
12072
12073 void
12074 x_focus_on_frame (f)
12075 struct frame *f;
12076 {
12077 #if 0 /* This proves to be unpleasant. */
12078 x_raise_frame (f);
12079 #endif
12080 #if 0
12081 /* I don't think that the ICCCM allows programs to do things like this
12082 without the interaction of the window manager. Whatever you end up
12083 doing with this code, do it to x_unfocus_frame too. */
12084 XSetInputFocus (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
12085 RevertToPointerRoot, CurrentTime);
12086 #endif /* ! 0 */
12087 }
12088
12089 void
12090 x_unfocus_frame (f)
12091 struct frame *f;
12092 {
12093 #if 0
12094 /* Look at the remarks in x_focus_on_frame. */
12095 if (FRAME_X_DISPLAY_INFO (f)->x_focus_frame == f)
12096 XSetInputFocus (FRAME_X_DISPLAY (f), PointerRoot,
12097 RevertToPointerRoot, CurrentTime);
12098 #endif /* ! 0 */
12099 }
12100
12101 /* Raise frame F. */
12102
12103 void
12104 x_raise_frame (f)
12105 struct frame *f;
12106 {
12107 if (f->async_visible)
12108 {
12109 BLOCK_INPUT;
12110 #ifdef USE_X_TOOLKIT
12111 XRaiseWindow (FRAME_X_DISPLAY (f), XtWindow (f->output_data.x->widget));
12112 #else /* not USE_X_TOOLKIT */
12113 XRaiseWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
12114 #endif /* not USE_X_TOOLKIT */
12115 XFlush (FRAME_X_DISPLAY (f));
12116 UNBLOCK_INPUT;
12117 }
12118 }
12119
12120 /* Lower frame F. */
12121
12122 void
12123 x_lower_frame (f)
12124 struct frame *f;
12125 {
12126 if (f->async_visible)
12127 {
12128 BLOCK_INPUT;
12129 #ifdef USE_X_TOOLKIT
12130 XLowerWindow (FRAME_X_DISPLAY (f), XtWindow (f->output_data.x->widget));
12131 #else /* not USE_X_TOOLKIT */
12132 XLowerWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
12133 #endif /* not USE_X_TOOLKIT */
12134 XFlush (FRAME_X_DISPLAY (f));
12135 UNBLOCK_INPUT;
12136 }
12137 }
12138
12139 static void
12140 XTframe_raise_lower (f, raise_flag)
12141 FRAME_PTR f;
12142 int raise_flag;
12143 {
12144 if (raise_flag)
12145 x_raise_frame (f);
12146 else
12147 x_lower_frame (f);
12148 }
12149 \f
12150 /* Change of visibility. */
12151
12152 /* This tries to wait until the frame is really visible.
12153 However, if the window manager asks the user where to position
12154 the frame, this will return before the user finishes doing that.
12155 The frame will not actually be visible at that time,
12156 but it will become visible later when the window manager
12157 finishes with it. */
12158
12159 void
12160 x_make_frame_visible (f)
12161 struct frame *f;
12162 {
12163 Lisp_Object type;
12164 int original_top, original_left;
12165 int retry_count = 2;
12166
12167 retry:
12168
12169 BLOCK_INPUT;
12170
12171 type = x_icon_type (f);
12172 if (!NILP (type))
12173 x_bitmap_icon (f, type);
12174
12175 if (! FRAME_VISIBLE_P (f))
12176 {
12177 /* We test FRAME_GARBAGED_P here to make sure we don't
12178 call x_set_offset a second time
12179 if we get to x_make_frame_visible a second time
12180 before the window gets really visible. */
12181 if (! FRAME_ICONIFIED_P (f)
12182 && ! f->output_data.x->asked_for_visible)
12183 x_set_offset (f, f->output_data.x->left_pos, f->output_data.x->top_pos, 0);
12184
12185 f->output_data.x->asked_for_visible = 1;
12186
12187 if (! EQ (Vx_no_window_manager, Qt))
12188 x_wm_set_window_state (f, NormalState);
12189 #ifdef USE_X_TOOLKIT
12190 /* This was XtPopup, but that did nothing for an iconified frame. */
12191 XtMapWidget (f->output_data.x->widget);
12192 #else /* not USE_X_TOOLKIT */
12193 XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
12194 #endif /* not USE_X_TOOLKIT */
12195 #if 0 /* This seems to bring back scroll bars in the wrong places
12196 if the window configuration has changed. They seem
12197 to come back ok without this. */
12198 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f))
12199 XMapSubwindows (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
12200 #endif
12201 }
12202
12203 XFlush (FRAME_X_DISPLAY (f));
12204
12205 /* Synchronize to ensure Emacs knows the frame is visible
12206 before we do anything else. We do this loop with input not blocked
12207 so that incoming events are handled. */
12208 {
12209 Lisp_Object frame;
12210 int count;
12211 /* This must be before UNBLOCK_INPUT
12212 since events that arrive in response to the actions above
12213 will set it when they are handled. */
12214 int previously_visible = f->output_data.x->has_been_visible;
12215
12216 original_left = f->output_data.x->left_pos;
12217 original_top = f->output_data.x->top_pos;
12218
12219 /* This must come after we set COUNT. */
12220 UNBLOCK_INPUT;
12221
12222 /* We unblock here so that arriving X events are processed. */
12223
12224 /* Now move the window back to where it was "supposed to be".
12225 But don't do it if the gravity is negative.
12226 When the gravity is negative, this uses a position
12227 that is 3 pixels too low. Perhaps that's really the border width.
12228
12229 Don't do this if the window has never been visible before,
12230 because the window manager may choose the position
12231 and we don't want to override it. */
12232
12233 if (! FRAME_VISIBLE_P (f) && ! FRAME_ICONIFIED_P (f)
12234 && f->output_data.x->win_gravity == NorthWestGravity
12235 && previously_visible)
12236 {
12237 Drawable rootw;
12238 int x, y;
12239 unsigned int width, height, border, depth;
12240
12241 BLOCK_INPUT;
12242
12243 /* On some window managers (such as FVWM) moving an existing
12244 window, even to the same place, causes the window manager
12245 to introduce an offset. This can cause the window to move
12246 to an unexpected location. Check the geometry (a little
12247 slow here) and then verify that the window is in the right
12248 place. If the window is not in the right place, move it
12249 there, and take the potential window manager hit. */
12250 XGetGeometry (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
12251 &rootw, &x, &y, &width, &height, &border, &depth);
12252
12253 if (original_left != x || original_top != y)
12254 XMoveWindow (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
12255 original_left, original_top);
12256
12257 UNBLOCK_INPUT;
12258 }
12259
12260 XSETFRAME (frame, f);
12261
12262 /* Wait until the frame is visible. Process X events until a
12263 MapNotify event has been seen, or until we think we won't get a
12264 MapNotify at all.. */
12265 for (count = input_signal_count + 10;
12266 input_signal_count < count && !FRAME_VISIBLE_P (f);)
12267 {
12268 /* Force processing of queued events. */
12269 x_sync (f);
12270
12271 /* Machines that do polling rather than SIGIO have been
12272 observed to go into a busy-wait here. So we'll fake an
12273 alarm signal to let the handler know that there's something
12274 to be read. We used to raise a real alarm, but it seems
12275 that the handler isn't always enabled here. This is
12276 probably a bug. */
12277 if (input_polling_used ())
12278 {
12279 /* It could be confusing if a real alarm arrives while
12280 processing the fake one. Turn it off and let the
12281 handler reset it. */
12282 extern void poll_for_input_1 P_ ((void));
12283 int old_poll_suppress_count = poll_suppress_count;
12284 poll_suppress_count = 1;
12285 poll_for_input_1 ();
12286 poll_suppress_count = old_poll_suppress_count;
12287 }
12288
12289 /* See if a MapNotify event has been processed. */
12290 FRAME_SAMPLE_VISIBILITY (f);
12291 }
12292
12293 /* 2000-09-28: In
12294
12295 (let ((f (selected-frame)))
12296 (iconify-frame f)
12297 (raise-frame f))
12298
12299 the frame is not raised with various window managers on
12300 FreeBSD, Linux and Solaris. It turns out that, for some
12301 unknown reason, the call to XtMapWidget is completely ignored.
12302 Mapping the widget a second time works. */
12303
12304 if (!FRAME_VISIBLE_P (f) && --retry_count > 0)
12305 goto retry;
12306 }
12307 }
12308
12309 /* Change from mapped state to withdrawn state. */
12310
12311 /* Make the frame visible (mapped and not iconified). */
12312
12313 void
12314 x_make_frame_invisible (f)
12315 struct frame *f;
12316 {
12317 Window window;
12318
12319 #ifdef USE_X_TOOLKIT
12320 /* Use the frame's outermost window, not the one we normally draw on. */
12321 window = XtWindow (f->output_data.x->widget);
12322 #else /* not USE_X_TOOLKIT */
12323 window = FRAME_X_WINDOW (f);
12324 #endif /* not USE_X_TOOLKIT */
12325
12326 /* Don't keep the highlight on an invisible frame. */
12327 if (FRAME_X_DISPLAY_INFO (f)->x_highlight_frame == f)
12328 FRAME_X_DISPLAY_INFO (f)->x_highlight_frame = 0;
12329
12330 #if 0/* This might add unreliability; I don't trust it -- rms. */
12331 if (! f->async_visible && ! f->async_iconified)
12332 return;
12333 #endif
12334
12335 BLOCK_INPUT;
12336
12337 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
12338 that the current position of the window is user-specified, rather than
12339 program-specified, so that when the window is mapped again, it will be
12340 placed at the same location, without forcing the user to position it
12341 by hand again (they have already done that once for this window.) */
12342 x_wm_set_size_hint (f, (long) 0, 1);
12343
12344 #ifdef HAVE_X11R4
12345
12346 if (! XWithdrawWindow (FRAME_X_DISPLAY (f), window,
12347 DefaultScreen (FRAME_X_DISPLAY (f))))
12348 {
12349 UNBLOCK_INPUT_RESIGNAL;
12350 error ("Can't notify window manager of window withdrawal");
12351 }
12352 #else /* ! defined (HAVE_X11R4) */
12353
12354 /* Tell the window manager what we're going to do. */
12355 if (! EQ (Vx_no_window_manager, Qt))
12356 {
12357 XEvent unmap;
12358
12359 unmap.xunmap.type = UnmapNotify;
12360 unmap.xunmap.window = window;
12361 unmap.xunmap.event = DefaultRootWindow (FRAME_X_DISPLAY (f));
12362 unmap.xunmap.from_configure = False;
12363 if (! XSendEvent (FRAME_X_DISPLAY (f),
12364 DefaultRootWindow (FRAME_X_DISPLAY (f)),
12365 False,
12366 SubstructureRedirectMaskSubstructureNotifyMask,
12367 &unmap))
12368 {
12369 UNBLOCK_INPUT_RESIGNAL;
12370 error ("Can't notify window manager of withdrawal");
12371 }
12372 }
12373
12374 /* Unmap the window ourselves. Cheeky! */
12375 XUnmapWindow (FRAME_X_DISPLAY (f), window);
12376 #endif /* ! defined (HAVE_X11R4) */
12377
12378 /* We can't distinguish this from iconification
12379 just by the event that we get from the server.
12380 So we can't win using the usual strategy of letting
12381 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
12382 and synchronize with the server to make sure we agree. */
12383 f->visible = 0;
12384 FRAME_ICONIFIED_P (f) = 0;
12385 f->async_visible = 0;
12386 f->async_iconified = 0;
12387
12388 x_sync (f);
12389
12390 UNBLOCK_INPUT;
12391 }
12392
12393 /* Change window state from mapped to iconified. */
12394
12395 void
12396 x_iconify_frame (f)
12397 struct frame *f;
12398 {
12399 int result;
12400 Lisp_Object type;
12401
12402 /* Don't keep the highlight on an invisible frame. */
12403 if (FRAME_X_DISPLAY_INFO (f)->x_highlight_frame == f)
12404 FRAME_X_DISPLAY_INFO (f)->x_highlight_frame = 0;
12405
12406 if (f->async_iconified)
12407 return;
12408
12409 BLOCK_INPUT;
12410
12411 FRAME_SAMPLE_VISIBILITY (f);
12412
12413 type = x_icon_type (f);
12414 if (!NILP (type))
12415 x_bitmap_icon (f, type);
12416
12417 #ifdef USE_X_TOOLKIT
12418
12419 if (! FRAME_VISIBLE_P (f))
12420 {
12421 if (! EQ (Vx_no_window_manager, Qt))
12422 x_wm_set_window_state (f, IconicState);
12423 /* This was XtPopup, but that did nothing for an iconified frame. */
12424 XtMapWidget (f->output_data.x->widget);
12425 /* The server won't give us any event to indicate
12426 that an invisible frame was changed to an icon,
12427 so we have to record it here. */
12428 f->iconified = 1;
12429 f->visible = 1;
12430 f->async_iconified = 1;
12431 f->async_visible = 0;
12432 UNBLOCK_INPUT;
12433 return;
12434 }
12435
12436 result = XIconifyWindow (FRAME_X_DISPLAY (f),
12437 XtWindow (f->output_data.x->widget),
12438 DefaultScreen (FRAME_X_DISPLAY (f)));
12439 UNBLOCK_INPUT;
12440
12441 if (!result)
12442 error ("Can't notify window manager of iconification");
12443
12444 f->async_iconified = 1;
12445 f->async_visible = 0;
12446
12447
12448 BLOCK_INPUT;
12449 XFlush (FRAME_X_DISPLAY (f));
12450 UNBLOCK_INPUT;
12451 #else /* not USE_X_TOOLKIT */
12452
12453 /* Make sure the X server knows where the window should be positioned,
12454 in case the user deiconifies with the window manager. */
12455 if (! FRAME_VISIBLE_P (f) && !FRAME_ICONIFIED_P (f))
12456 x_set_offset (f, f->output_data.x->left_pos, f->output_data.x->top_pos, 0);
12457
12458 /* Since we don't know which revision of X we're running, we'll use both
12459 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
12460
12461 /* X11R4: send a ClientMessage to the window manager using the
12462 WM_CHANGE_STATE type. */
12463 {
12464 XEvent message;
12465
12466 message.xclient.window = FRAME_X_WINDOW (f);
12467 message.xclient.type = ClientMessage;
12468 message.xclient.message_type = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_change_state;
12469 message.xclient.format = 32;
12470 message.xclient.data.l[0] = IconicState;
12471
12472 if (! XSendEvent (FRAME_X_DISPLAY (f),
12473 DefaultRootWindow (FRAME_X_DISPLAY (f)),
12474 False,
12475 SubstructureRedirectMask | SubstructureNotifyMask,
12476 &message))
12477 {
12478 UNBLOCK_INPUT_RESIGNAL;
12479 error ("Can't notify window manager of iconification");
12480 }
12481 }
12482
12483 /* X11R3: set the initial_state field of the window manager hints to
12484 IconicState. */
12485 x_wm_set_window_state (f, IconicState);
12486
12487 if (!FRAME_VISIBLE_P (f))
12488 {
12489 /* If the frame was withdrawn, before, we must map it. */
12490 XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
12491 }
12492
12493 f->async_iconified = 1;
12494 f->async_visible = 0;
12495
12496 XFlush (FRAME_X_DISPLAY (f));
12497 UNBLOCK_INPUT;
12498 #endif /* not USE_X_TOOLKIT */
12499 }
12500
12501 \f
12502 /* Free X resources of frame F. */
12503
12504 void
12505 x_free_frame_resources (f)
12506 struct frame *f;
12507 {
12508 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
12509
12510 BLOCK_INPUT;
12511
12512 /* If a display connection is dead, don't try sending more
12513 commands to the X server. */
12514 if (dpyinfo->display)
12515 {
12516 if (f->output_data.x->icon_desc)
12517 XDestroyWindow (FRAME_X_DISPLAY (f), f->output_data.x->icon_desc);
12518
12519 #ifdef HAVE_X_I18N
12520 if (FRAME_XIC (f))
12521 free_frame_xic (f);
12522 #endif
12523
12524 if (FRAME_X_WINDOW (f))
12525 XDestroyWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
12526
12527 #ifdef USE_X_TOOLKIT
12528 if (f->output_data.x->widget)
12529 XtDestroyWidget (f->output_data.x->widget);
12530 free_frame_menubar (f);
12531 #endif /* USE_X_TOOLKIT */
12532
12533 unload_color (f, f->output_data.x->foreground_pixel);
12534 unload_color (f, f->output_data.x->background_pixel);
12535 unload_color (f, f->output_data.x->cursor_pixel);
12536 unload_color (f, f->output_data.x->cursor_foreground_pixel);
12537 unload_color (f, f->output_data.x->border_pixel);
12538 unload_color (f, f->output_data.x->mouse_pixel);
12539
12540 if (f->output_data.x->scroll_bar_background_pixel != -1)
12541 unload_color (f, f->output_data.x->scroll_bar_background_pixel);
12542 if (f->output_data.x->scroll_bar_foreground_pixel != -1)
12543 unload_color (f, f->output_data.x->scroll_bar_foreground_pixel);
12544 if (f->output_data.x->white_relief.allocated_p)
12545 unload_color (f, f->output_data.x->white_relief.pixel);
12546 if (f->output_data.x->black_relief.allocated_p)
12547 unload_color (f, f->output_data.x->black_relief.pixel);
12548
12549 if (FRAME_FACE_CACHE (f))
12550 free_frame_faces (f);
12551
12552 x_free_gcs (f);
12553 XFlush (FRAME_X_DISPLAY (f));
12554 }
12555
12556 if (f->output_data.x->saved_menu_event)
12557 xfree (f->output_data.x->saved_menu_event);
12558
12559 xfree (f->output_data.x);
12560 f->output_data.x = NULL;
12561
12562 if (f == dpyinfo->x_focus_frame)
12563 dpyinfo->x_focus_frame = 0;
12564 if (f == dpyinfo->x_focus_event_frame)
12565 dpyinfo->x_focus_event_frame = 0;
12566 if (f == dpyinfo->x_highlight_frame)
12567 dpyinfo->x_highlight_frame = 0;
12568
12569 if (f == dpyinfo->mouse_face_mouse_frame)
12570 {
12571 dpyinfo->mouse_face_beg_row
12572 = dpyinfo->mouse_face_beg_col = -1;
12573 dpyinfo->mouse_face_end_row
12574 = dpyinfo->mouse_face_end_col = -1;
12575 dpyinfo->mouse_face_window = Qnil;
12576 dpyinfo->mouse_face_deferred_gc = 0;
12577 dpyinfo->mouse_face_mouse_frame = 0;
12578 }
12579
12580 UNBLOCK_INPUT;
12581 }
12582
12583
12584 /* Destroy the X window of frame F. */
12585
12586 void
12587 x_destroy_window (f)
12588 struct frame *f;
12589 {
12590 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
12591
12592 /* If a display connection is dead, don't try sending more
12593 commands to the X server. */
12594 if (dpyinfo->display != 0)
12595 x_free_frame_resources (f);
12596
12597 dpyinfo->reference_count--;
12598 }
12599
12600 \f
12601 /* Setting window manager hints. */
12602
12603 /* Set the normal size hints for the window manager, for frame F.
12604 FLAGS is the flags word to use--or 0 meaning preserve the flags
12605 that the window now has.
12606 If USER_POSITION is nonzero, we set the USPosition
12607 flag (this is useful when FLAGS is 0). */
12608
12609 void
12610 x_wm_set_size_hint (f, flags, user_position)
12611 struct frame *f;
12612 long flags;
12613 int user_position;
12614 {
12615 XSizeHints size_hints;
12616
12617 #ifdef USE_X_TOOLKIT
12618 Arg al[2];
12619 int ac = 0;
12620 Dimension widget_width, widget_height;
12621 Window window = XtWindow (f->output_data.x->widget);
12622 #else /* not USE_X_TOOLKIT */
12623 Window window = FRAME_X_WINDOW (f);
12624 #endif /* not USE_X_TOOLKIT */
12625
12626 /* Setting PMaxSize caused various problems. */
12627 size_hints.flags = PResizeInc | PMinSize /* | PMaxSize */;
12628
12629 size_hints.x = f->output_data.x->left_pos;
12630 size_hints.y = f->output_data.x->top_pos;
12631
12632 #ifdef USE_X_TOOLKIT
12633 XtSetArg (al[ac], XtNwidth, &widget_width); ac++;
12634 XtSetArg (al[ac], XtNheight, &widget_height); ac++;
12635 XtGetValues (f->output_data.x->widget, al, ac);
12636 size_hints.height = widget_height;
12637 size_hints.width = widget_width;
12638 #else /* not USE_X_TOOLKIT */
12639 size_hints.height = PIXEL_HEIGHT (f);
12640 size_hints.width = PIXEL_WIDTH (f);
12641 #endif /* not USE_X_TOOLKIT */
12642
12643 size_hints.width_inc = FONT_WIDTH (f->output_data.x->font);
12644 size_hints.height_inc = f->output_data.x->line_height;
12645 size_hints.max_width
12646 = FRAME_X_DISPLAY_INFO (f)->width - CHAR_TO_PIXEL_WIDTH (f, 0);
12647 size_hints.max_height
12648 = FRAME_X_DISPLAY_INFO (f)->height - CHAR_TO_PIXEL_HEIGHT (f, 0);
12649
12650 /* Calculate the base and minimum sizes.
12651
12652 (When we use the X toolkit, we don't do it here.
12653 Instead we copy the values that the widgets are using, below.) */
12654 #ifndef USE_X_TOOLKIT
12655 {
12656 int base_width, base_height;
12657 int min_rows = 0, min_cols = 0;
12658
12659 base_width = CHAR_TO_PIXEL_WIDTH (f, 0);
12660 base_height = CHAR_TO_PIXEL_HEIGHT (f, 0);
12661
12662 check_frame_size (f, &min_rows, &min_cols);
12663
12664 /* The window manager uses the base width hints to calculate the
12665 current number of rows and columns in the frame while
12666 resizing; min_width and min_height aren't useful for this
12667 purpose, since they might not give the dimensions for a
12668 zero-row, zero-column frame.
12669
12670 We use the base_width and base_height members if we have
12671 them; otherwise, we set the min_width and min_height members
12672 to the size for a zero x zero frame. */
12673
12674 #ifdef HAVE_X11R4
12675 size_hints.flags |= PBaseSize;
12676 size_hints.base_width = base_width;
12677 size_hints.base_height = base_height;
12678 size_hints.min_width = base_width + min_cols * size_hints.width_inc;
12679 size_hints.min_height = base_height + min_rows * size_hints.height_inc;
12680 #else
12681 size_hints.min_width = base_width;
12682 size_hints.min_height = base_height;
12683 #endif
12684 }
12685
12686 /* If we don't need the old flags, we don't need the old hint at all. */
12687 if (flags)
12688 {
12689 size_hints.flags |= flags;
12690 goto no_read;
12691 }
12692 #endif /* not USE_X_TOOLKIT */
12693
12694 {
12695 XSizeHints hints; /* Sometimes I hate X Windows... */
12696 long supplied_return;
12697 int value;
12698
12699 #ifdef HAVE_X11R4
12700 value = XGetWMNormalHints (FRAME_X_DISPLAY (f), window, &hints,
12701 &supplied_return);
12702 #else
12703 value = XGetNormalHints (FRAME_X_DISPLAY (f), window, &hints);
12704 #endif
12705
12706 #ifdef USE_X_TOOLKIT
12707 size_hints.base_height = hints.base_height;
12708 size_hints.base_width = hints.base_width;
12709 size_hints.min_height = hints.min_height;
12710 size_hints.min_width = hints.min_width;
12711 #endif
12712
12713 if (flags)
12714 size_hints.flags |= flags;
12715 else
12716 {
12717 if (value == 0)
12718 hints.flags = 0;
12719 if (hints.flags & PSize)
12720 size_hints.flags |= PSize;
12721 if (hints.flags & PPosition)
12722 size_hints.flags |= PPosition;
12723 if (hints.flags & USPosition)
12724 size_hints.flags |= USPosition;
12725 if (hints.flags & USSize)
12726 size_hints.flags |= USSize;
12727 }
12728 }
12729
12730 #ifndef USE_X_TOOLKIT
12731 no_read:
12732 #endif
12733
12734 #ifdef PWinGravity
12735 size_hints.win_gravity = f->output_data.x->win_gravity;
12736 size_hints.flags |= PWinGravity;
12737
12738 if (user_position)
12739 {
12740 size_hints.flags &= ~ PPosition;
12741 size_hints.flags |= USPosition;
12742 }
12743 #endif /* PWinGravity */
12744
12745 #ifdef HAVE_X11R4
12746 XSetWMNormalHints (FRAME_X_DISPLAY (f), window, &size_hints);
12747 #else
12748 XSetNormalHints (FRAME_X_DISPLAY (f), window, &size_hints);
12749 #endif
12750 }
12751
12752 /* Used for IconicState or NormalState */
12753
12754 void
12755 x_wm_set_window_state (f, state)
12756 struct frame *f;
12757 int state;
12758 {
12759 #ifdef USE_X_TOOLKIT
12760 Arg al[1];
12761
12762 XtSetArg (al[0], XtNinitialState, state);
12763 XtSetValues (f->output_data.x->widget, al, 1);
12764 #else /* not USE_X_TOOLKIT */
12765 Window window = FRAME_X_WINDOW (f);
12766
12767 f->output_data.x->wm_hints.flags |= StateHint;
12768 f->output_data.x->wm_hints.initial_state = state;
12769
12770 XSetWMHints (FRAME_X_DISPLAY (f), window, &f->output_data.x->wm_hints);
12771 #endif /* not USE_X_TOOLKIT */
12772 }
12773
12774 void
12775 x_wm_set_icon_pixmap (f, pixmap_id)
12776 struct frame *f;
12777 int pixmap_id;
12778 {
12779 Pixmap icon_pixmap;
12780
12781 #ifndef USE_X_TOOLKIT
12782 Window window = FRAME_X_WINDOW (f);
12783 #endif
12784
12785 if (pixmap_id > 0)
12786 {
12787 icon_pixmap = x_bitmap_pixmap (f, pixmap_id);
12788 f->output_data.x->wm_hints.icon_pixmap = icon_pixmap;
12789 }
12790 else
12791 {
12792 /* It seems there is no way to turn off use of an icon pixmap.
12793 The following line does it, only if no icon has yet been created,
12794 for some window managers. But with mwm it crashes.
12795 Some people say it should clear the IconPixmapHint bit in this case,
12796 but that doesn't work, and the X consortium said it isn't the
12797 right thing at all. Since there is no way to win,
12798 best to explicitly give up. */
12799 #if 0
12800 f->output_data.x->wm_hints.icon_pixmap = None;
12801 #else
12802 return;
12803 #endif
12804 }
12805
12806 #ifdef USE_X_TOOLKIT /* same as in x_wm_set_window_state. */
12807
12808 {
12809 Arg al[1];
12810 XtSetArg (al[0], XtNiconPixmap, icon_pixmap);
12811 XtSetValues (f->output_data.x->widget, al, 1);
12812 }
12813
12814 #else /* not USE_X_TOOLKIT */
12815
12816 f->output_data.x->wm_hints.flags |= IconPixmapHint;
12817 XSetWMHints (FRAME_X_DISPLAY (f), window, &f->output_data.x->wm_hints);
12818
12819 #endif /* not USE_X_TOOLKIT */
12820 }
12821
12822 void
12823 x_wm_set_icon_position (f, icon_x, icon_y)
12824 struct frame *f;
12825 int icon_x, icon_y;
12826 {
12827 #ifdef USE_X_TOOLKIT
12828 Window window = XtWindow (f->output_data.x->widget);
12829 #else
12830 Window window = FRAME_X_WINDOW (f);
12831 #endif
12832
12833 f->output_data.x->wm_hints.flags |= IconPositionHint;
12834 f->output_data.x->wm_hints.icon_x = icon_x;
12835 f->output_data.x->wm_hints.icon_y = icon_y;
12836
12837 XSetWMHints (FRAME_X_DISPLAY (f), window, &f->output_data.x->wm_hints);
12838 }
12839
12840 \f
12841 /***********************************************************************
12842 Fonts
12843 ***********************************************************************/
12844
12845 /* Return a pointer to struct font_info of font FONT_IDX of frame F. */
12846
12847 struct font_info *
12848 x_get_font_info (f, font_idx)
12849 FRAME_PTR f;
12850 int font_idx;
12851 {
12852 return (FRAME_X_FONT_TABLE (f) + font_idx);
12853 }
12854
12855
12856 /* Return a list of names of available fonts matching PATTERN on frame F.
12857
12858 If SIZE is > 0, it is the size (maximum bounds width) of fonts
12859 to be listed.
12860
12861 SIZE < 0 means include scalable fonts.
12862
12863 Frame F null means we have not yet created any frame on X, and
12864 consult the first display in x_display_list. MAXNAMES sets a limit
12865 on how many fonts to match. */
12866
12867 Lisp_Object
12868 x_list_fonts (f, pattern, size, maxnames)
12869 struct frame *f;
12870 Lisp_Object pattern;
12871 int size;
12872 int maxnames;
12873 {
12874 Lisp_Object list = Qnil, patterns, newlist = Qnil, key = Qnil;
12875 Lisp_Object tem, second_best;
12876 struct x_display_info *dpyinfo
12877 = f ? FRAME_X_DISPLAY_INFO (f) : x_display_list;
12878 Display *dpy = dpyinfo->display;
12879 int try_XLoadQueryFont = 0;
12880 int count;
12881 int allow_scalable_fonts_p = 0;
12882
12883 if (size < 0)
12884 {
12885 allow_scalable_fonts_p = 1;
12886 size = 0;
12887 }
12888
12889 patterns = Fassoc (pattern, Valternate_fontname_alist);
12890 if (NILP (patterns))
12891 patterns = Fcons (pattern, Qnil);
12892
12893 if (maxnames == 1 && !size)
12894 /* We can return any single font matching PATTERN. */
12895 try_XLoadQueryFont = 1;
12896
12897 for (; CONSP (patterns); patterns = XCDR (patterns))
12898 {
12899 int num_fonts;
12900 char **names = NULL;
12901
12902 pattern = XCAR (patterns);
12903 /* See if we cached the result for this particular query.
12904 The cache is an alist of the form:
12905 ((((PATTERN . MAXNAMES) . SCALABLE) (FONTNAME . WIDTH) ...) ...) */
12906 tem = XCDR (dpyinfo->name_list_element);
12907 key = Fcons (Fcons (pattern, make_number (maxnames)),
12908 allow_scalable_fonts_p ? Qt : Qnil);
12909 list = Fassoc (key, tem);
12910 if (!NILP (list))
12911 {
12912 list = Fcdr_safe (list);
12913 /* We have a cashed list. Don't have to get the list again. */
12914 goto label_cached;
12915 }
12916
12917 /* At first, put PATTERN in the cache. */
12918
12919 BLOCK_INPUT;
12920 count = x_catch_errors (dpy);
12921
12922 if (try_XLoadQueryFont)
12923 {
12924 XFontStruct *font;
12925 unsigned long value;
12926
12927 font = XLoadQueryFont (dpy, XSTRING (pattern)->data);
12928 if (x_had_errors_p (dpy))
12929 {
12930 /* This error is perhaps due to insufficient memory on X
12931 server. Let's just ignore it. */
12932 font = NULL;
12933 x_clear_errors (dpy);
12934 }
12935
12936 if (font
12937 && XGetFontProperty (font, XA_FONT, &value))
12938 {
12939 char *name = (char *) XGetAtomName (dpy, (Atom) value);
12940 int len = strlen (name);
12941 char *tmp;
12942
12943 /* If DXPC (a Differential X Protocol Compressor)
12944 Ver.3.7 is running, XGetAtomName will return null
12945 string. We must avoid such a name. */
12946 if (len == 0)
12947 try_XLoadQueryFont = 0;
12948 else
12949 {
12950 num_fonts = 1;
12951 names = (char **) alloca (sizeof (char *));
12952 /* Some systems only allow alloca assigned to a
12953 simple var. */
12954 tmp = (char *) alloca (len + 1); names[0] = tmp;
12955 bcopy (name, names[0], len + 1);
12956 XFree (name);
12957 }
12958 }
12959 else
12960 try_XLoadQueryFont = 0;
12961
12962 if (font)
12963 XFreeFont (dpy, font);
12964 }
12965
12966 if (!try_XLoadQueryFont)
12967 {
12968 /* We try at least 10 fonts because XListFonts will return
12969 auto-scaled fonts at the head. */
12970 names = XListFonts (dpy, XSTRING (pattern)->data, max (maxnames, 10),
12971 &num_fonts);
12972 if (x_had_errors_p (dpy))
12973 {
12974 /* This error is perhaps due to insufficient memory on X
12975 server. Let's just ignore it. */
12976 names = NULL;
12977 x_clear_errors (dpy);
12978 }
12979 }
12980
12981 x_uncatch_errors (dpy, count);
12982 UNBLOCK_INPUT;
12983
12984 if (names)
12985 {
12986 int i;
12987
12988 /* Make a list of all the fonts we got back.
12989 Store that in the font cache for the display. */
12990 for (i = 0; i < num_fonts; i++)
12991 {
12992 int width = 0;
12993 char *p = names[i];
12994 int average_width = -1, dashes = 0;
12995
12996 /* Count the number of dashes in NAMES[I]. If there are
12997 14 dashes, and the field value following 12th dash
12998 (AVERAGE_WIDTH) is 0, this is a auto-scaled font which
12999 is usually too ugly to be used for editing. Let's
13000 ignore it. */
13001 while (*p)
13002 if (*p++ == '-')
13003 {
13004 dashes++;
13005 if (dashes == 7) /* PIXEL_SIZE field */
13006 width = atoi (p);
13007 else if (dashes == 12) /* AVERAGE_WIDTH field */
13008 average_width = atoi (p);
13009 }
13010
13011 if (allow_scalable_fonts_p
13012 || dashes < 14 || average_width != 0)
13013 {
13014 tem = build_string (names[i]);
13015 if (NILP (Fassoc (tem, list)))
13016 {
13017 if (STRINGP (Vx_pixel_size_width_font_regexp)
13018 && ((fast_c_string_match_ignore_case
13019 (Vx_pixel_size_width_font_regexp, names[i]))
13020 >= 0))
13021 /* We can set the value of PIXEL_SIZE to the
13022 width of this font. */
13023 list = Fcons (Fcons (tem, make_number (width)), list);
13024 else
13025 /* For the moment, width is not known. */
13026 list = Fcons (Fcons (tem, Qnil), list);
13027 }
13028 }
13029 }
13030 if (!try_XLoadQueryFont)
13031 XFreeFontNames (names);
13032 }
13033
13034 /* Now store the result in the cache. */
13035 XCDR (dpyinfo->name_list_element)
13036 = Fcons (Fcons (key, list), XCDR (dpyinfo->name_list_element));
13037
13038 label_cached:
13039 if (NILP (list)) continue; /* Try the remaining alternatives. */
13040
13041 newlist = second_best = Qnil;
13042 /* Make a list of the fonts that have the right width. */
13043 for (; CONSP (list); list = XCDR (list))
13044 {
13045 int found_size;
13046
13047 tem = XCAR (list);
13048
13049 if (!CONSP (tem) || NILP (XCAR (tem)))
13050 continue;
13051 if (!size)
13052 {
13053 newlist = Fcons (XCAR (tem), newlist);
13054 continue;
13055 }
13056
13057 if (!INTEGERP (XCDR (tem)))
13058 {
13059 /* Since we have not yet known the size of this font, we
13060 must try slow function call XLoadQueryFont. */
13061 XFontStruct *thisinfo;
13062
13063 BLOCK_INPUT;
13064 count = x_catch_errors (dpy);
13065 thisinfo = XLoadQueryFont (dpy,
13066 XSTRING (XCAR (tem))->data);
13067 if (x_had_errors_p (dpy))
13068 {
13069 /* This error is perhaps due to insufficient memory on X
13070 server. Let's just ignore it. */
13071 thisinfo = NULL;
13072 x_clear_errors (dpy);
13073 }
13074 x_uncatch_errors (dpy, count);
13075 UNBLOCK_INPUT;
13076
13077 if (thisinfo)
13078 {
13079 XCDR (tem)
13080 = (thisinfo->min_bounds.width == 0
13081 ? make_number (0)
13082 : make_number (thisinfo->max_bounds.width));
13083 XFreeFont (dpy, thisinfo);
13084 }
13085 else
13086 /* For unknown reason, the previous call of XListFont had
13087 returned a font which can't be opened. Record the size
13088 as 0 not to try to open it again. */
13089 XCDR (tem) = make_number (0);
13090 }
13091
13092 found_size = XINT (XCDR (tem));
13093 if (found_size == size)
13094 newlist = Fcons (XCAR (tem), newlist);
13095 else if (found_size > 0)
13096 {
13097 if (NILP (second_best))
13098 second_best = tem;
13099 else if (found_size < size)
13100 {
13101 if (XINT (XCDR (second_best)) > size
13102 || XINT (XCDR (second_best)) < found_size)
13103 second_best = tem;
13104 }
13105 else
13106 {
13107 if (XINT (XCDR (second_best)) > size
13108 && XINT (XCDR (second_best)) > found_size)
13109 second_best = tem;
13110 }
13111 }
13112 }
13113 if (!NILP (newlist))
13114 break;
13115 else if (!NILP (second_best))
13116 {
13117 newlist = Fcons (XCAR (second_best), Qnil);
13118 break;
13119 }
13120 }
13121
13122 return newlist;
13123 }
13124
13125
13126 #if GLYPH_DEBUG
13127
13128 /* Check that FONT is valid on frame F. It is if it can be found in F's
13129 font table. */
13130
13131 static void
13132 x_check_font (f, font)
13133 struct frame *f;
13134 XFontStruct *font;
13135 {
13136 int i;
13137 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
13138
13139 xassert (font != NULL);
13140
13141 for (i = 0; i < dpyinfo->n_fonts; i++)
13142 if (dpyinfo->font_table[i].name
13143 && font == dpyinfo->font_table[i].font)
13144 break;
13145
13146 xassert (i < dpyinfo->n_fonts);
13147 }
13148
13149 #endif /* GLYPH_DEBUG != 0 */
13150
13151 /* Set *W to the minimum width, *H to the minimum font height of FONT.
13152 Note: There are (broken) X fonts out there with invalid XFontStruct
13153 min_bounds contents. For example, handa@etl.go.jp reports that
13154 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
13155 have font->min_bounds.width == 0. */
13156
13157 static INLINE void
13158 x_font_min_bounds (font, w, h)
13159 XFontStruct *font;
13160 int *w, *h;
13161 {
13162 *h = FONT_HEIGHT (font);
13163 *w = font->min_bounds.width;
13164
13165 /* Try to handle the case where FONT->min_bounds has invalid
13166 contents. Since the only font known to have invalid min_bounds
13167 is fixed-width, use max_bounds if min_bounds seems to be invalid. */
13168 if (*w <= 0)
13169 *w = font->max_bounds.width;
13170 }
13171
13172
13173 /* Compute the smallest character width and smallest font height over
13174 all fonts available on frame F. Set the members smallest_char_width
13175 and smallest_font_height in F's x_display_info structure to
13176 the values computed. Value is non-zero if smallest_font_height or
13177 smallest_char_width become smaller than they were before. */
13178
13179 static int
13180 x_compute_min_glyph_bounds (f)
13181 struct frame *f;
13182 {
13183 int i;
13184 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
13185 XFontStruct *font;
13186 int old_width = dpyinfo->smallest_char_width;
13187 int old_height = dpyinfo->smallest_font_height;
13188
13189 dpyinfo->smallest_font_height = 100000;
13190 dpyinfo->smallest_char_width = 100000;
13191
13192 for (i = 0; i < dpyinfo->n_fonts; ++i)
13193 if (dpyinfo->font_table[i].name)
13194 {
13195 struct font_info *fontp = dpyinfo->font_table + i;
13196 int w, h;
13197
13198 font = (XFontStruct *) fontp->font;
13199 xassert (font != (XFontStruct *) ~0);
13200 x_font_min_bounds (font, &w, &h);
13201
13202 dpyinfo->smallest_font_height = min (dpyinfo->smallest_font_height, h);
13203 dpyinfo->smallest_char_width = min (dpyinfo->smallest_char_width, w);
13204 }
13205
13206 xassert (dpyinfo->smallest_char_width > 0
13207 && dpyinfo->smallest_font_height > 0);
13208
13209 return (dpyinfo->n_fonts == 1
13210 || dpyinfo->smallest_char_width < old_width
13211 || dpyinfo->smallest_font_height < old_height);
13212 }
13213
13214
13215 /* Load font named FONTNAME of the size SIZE for frame F, and return a
13216 pointer to the structure font_info while allocating it dynamically.
13217 If SIZE is 0, load any size of font.
13218 If loading is failed, return NULL. */
13219
13220 struct font_info *
13221 x_load_font (f, fontname, size)
13222 struct frame *f;
13223 register char *fontname;
13224 int size;
13225 {
13226 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
13227 Lisp_Object font_names;
13228 int count;
13229
13230 /* Get a list of all the fonts that match this name. Once we
13231 have a list of matching fonts, we compare them against the fonts
13232 we already have by comparing names. */
13233 font_names = x_list_fonts (f, build_string (fontname), size, 1);
13234
13235 if (!NILP (font_names))
13236 {
13237 Lisp_Object tail;
13238 int i;
13239
13240 for (i = 0; i < dpyinfo->n_fonts; i++)
13241 for (tail = font_names; CONSP (tail); tail = XCDR (tail))
13242 if (dpyinfo->font_table[i].name
13243 && (!strcmp (dpyinfo->font_table[i].name,
13244 XSTRING (XCAR (tail))->data)
13245 || !strcmp (dpyinfo->font_table[i].full_name,
13246 XSTRING (XCAR (tail))->data)))
13247 return (dpyinfo->font_table + i);
13248 }
13249
13250 /* Load the font and add it to the table. */
13251 {
13252 char *full_name;
13253 XFontStruct *font;
13254 struct font_info *fontp;
13255 unsigned long value;
13256 int i;
13257
13258 /* If we have found fonts by x_list_font, load one of them. If
13259 not, we still try to load a font by the name given as FONTNAME
13260 because XListFonts (called in x_list_font) of some X server has
13261 a bug of not finding a font even if the font surely exists and
13262 is loadable by XLoadQueryFont. */
13263 if (size > 0 && !NILP (font_names))
13264 fontname = (char *) XSTRING (XCAR (font_names))->data;
13265
13266 BLOCK_INPUT;
13267 count = x_catch_errors (FRAME_X_DISPLAY (f));
13268 font = (XFontStruct *) XLoadQueryFont (FRAME_X_DISPLAY (f), fontname);
13269 if (x_had_errors_p (FRAME_X_DISPLAY (f)))
13270 {
13271 /* This error is perhaps due to insufficient memory on X
13272 server. Let's just ignore it. */
13273 font = NULL;
13274 x_clear_errors (FRAME_X_DISPLAY (f));
13275 }
13276 x_uncatch_errors (FRAME_X_DISPLAY (f), count);
13277 UNBLOCK_INPUT;
13278 if (!font)
13279 return NULL;
13280
13281 /* Find a free slot in the font table. */
13282 for (i = 0; i < dpyinfo->n_fonts; ++i)
13283 if (dpyinfo->font_table[i].name == NULL)
13284 break;
13285
13286 /* If no free slot found, maybe enlarge the font table. */
13287 if (i == dpyinfo->n_fonts
13288 && dpyinfo->n_fonts == dpyinfo->font_table_size)
13289 {
13290 int sz;
13291 dpyinfo->font_table_size = max (16, 2 * dpyinfo->font_table_size);
13292 sz = dpyinfo->font_table_size * sizeof *dpyinfo->font_table;
13293 dpyinfo->font_table
13294 = (struct font_info *) xrealloc (dpyinfo->font_table, sz);
13295 }
13296
13297 fontp = dpyinfo->font_table + i;
13298 if (i == dpyinfo->n_fonts)
13299 ++dpyinfo->n_fonts;
13300
13301 /* Now fill in the slots of *FONTP. */
13302 BLOCK_INPUT;
13303 fontp->font = font;
13304 fontp->font_idx = i;
13305 fontp->name = (char *) xmalloc (strlen (fontname) + 1);
13306 bcopy (fontname, fontp->name, strlen (fontname) + 1);
13307
13308 /* Try to get the full name of FONT. Put it in FULL_NAME. */
13309 full_name = 0;
13310 if (XGetFontProperty (font, XA_FONT, &value))
13311 {
13312 char *name = (char *) XGetAtomName (FRAME_X_DISPLAY (f), (Atom) value);
13313 char *p = name;
13314 int dashes = 0;
13315
13316 /* Count the number of dashes in the "full name".
13317 If it is too few, this isn't really the font's full name,
13318 so don't use it.
13319 In X11R4, the fonts did not come with their canonical names
13320 stored in them. */
13321 while (*p)
13322 {
13323 if (*p == '-')
13324 dashes++;
13325 p++;
13326 }
13327
13328 if (dashes >= 13)
13329 {
13330 full_name = (char *) xmalloc (p - name + 1);
13331 bcopy (name, full_name, p - name + 1);
13332 }
13333
13334 XFree (name);
13335 }
13336
13337 if (full_name != 0)
13338 fontp->full_name = full_name;
13339 else
13340 fontp->full_name = fontp->name;
13341
13342 fontp->size = font->max_bounds.width;
13343 fontp->height = FONT_HEIGHT (font);
13344
13345 if (NILP (font_names))
13346 {
13347 /* We come here because of a bug of XListFonts mentioned at
13348 the head of this block. Let's store this information in
13349 the cache for x_list_fonts. */
13350 Lisp_Object lispy_name = build_string (fontname);
13351 Lisp_Object lispy_full_name = build_string (fontp->full_name);
13352 Lisp_Object key = Fcons (Fcons (lispy_name, make_number (256)),
13353 Qnil);
13354
13355 XCDR (dpyinfo->name_list_element)
13356 = Fcons (Fcons (key,
13357 Fcons (Fcons (lispy_full_name,
13358 make_number (fontp->size)),
13359 Qnil)),
13360 XCDR (dpyinfo->name_list_element));
13361 if (full_name)
13362 {
13363 key = Fcons (Fcons (lispy_full_name, make_number (256)),
13364 Qnil);
13365 XCDR (dpyinfo->name_list_element)
13366 = Fcons (Fcons (key,
13367 Fcons (Fcons (lispy_full_name,
13368 make_number (fontp->size)),
13369 Qnil)),
13370 XCDR (dpyinfo->name_list_element));
13371 }
13372 }
13373
13374 /* The slot `encoding' specifies how to map a character
13375 code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
13376 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
13377 (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
13378 2:0xA020..0xFF7F). For the moment, we don't know which charset
13379 uses this font. So, we set information in fontp->encoding[1]
13380 which is never used by any charset. If mapping can't be
13381 decided, set FONT_ENCODING_NOT_DECIDED. */
13382 fontp->encoding[1]
13383 = (font->max_byte1 == 0
13384 /* 1-byte font */
13385 ? (font->min_char_or_byte2 < 0x80
13386 ? (font->max_char_or_byte2 < 0x80
13387 ? 0 /* 0x20..0x7F */
13388 : FONT_ENCODING_NOT_DECIDED) /* 0x20..0xFF */
13389 : 1) /* 0xA0..0xFF */
13390 /* 2-byte font */
13391 : (font->min_byte1 < 0x80
13392 ? (font->max_byte1 < 0x80
13393 ? (font->min_char_or_byte2 < 0x80
13394 ? (font->max_char_or_byte2 < 0x80
13395 ? 0 /* 0x2020..0x7F7F */
13396 : FONT_ENCODING_NOT_DECIDED) /* 0x2020..0x7FFF */
13397 : 3) /* 0x20A0..0x7FFF */
13398 : FONT_ENCODING_NOT_DECIDED) /* 0x20??..0xA0?? */
13399 : (font->min_char_or_byte2 < 0x80
13400 ? (font->max_char_or_byte2 < 0x80
13401 ? 2 /* 0xA020..0xFF7F */
13402 : FONT_ENCODING_NOT_DECIDED) /* 0xA020..0xFFFF */
13403 : 1))); /* 0xA0A0..0xFFFF */
13404
13405 fontp->baseline_offset
13406 = (XGetFontProperty (font, dpyinfo->Xatom_MULE_BASELINE_OFFSET, &value)
13407 ? (long) value : 0);
13408 fontp->relative_compose
13409 = (XGetFontProperty (font, dpyinfo->Xatom_MULE_RELATIVE_COMPOSE, &value)
13410 ? (long) value : 0);
13411 fontp->default_ascent
13412 = (XGetFontProperty (font, dpyinfo->Xatom_MULE_DEFAULT_ASCENT, &value)
13413 ? (long) value : 0);
13414
13415 /* Set global flag fonts_changed_p to non-zero if the font loaded
13416 has a character with a smaller width than any other character
13417 before, or if the font loaded has a smalle>r height than any
13418 other font loaded before. If this happens, it will make a
13419 glyph matrix reallocation necessary. */
13420 fonts_changed_p = x_compute_min_glyph_bounds (f);
13421 UNBLOCK_INPUT;
13422 return fontp;
13423 }
13424 }
13425
13426
13427 /* Return a pointer to struct font_info of a font named FONTNAME for
13428 frame F. If no such font is loaded, return NULL. */
13429
13430 struct font_info *
13431 x_query_font (f, fontname)
13432 struct frame *f;
13433 register char *fontname;
13434 {
13435 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
13436 int i;
13437
13438 for (i = 0; i < dpyinfo->n_fonts; i++)
13439 if (dpyinfo->font_table[i].name
13440 && (!strcmp (dpyinfo->font_table[i].name, fontname)
13441 || !strcmp (dpyinfo->font_table[i].full_name, fontname)))
13442 return (dpyinfo->font_table + i);
13443 return NULL;
13444 }
13445
13446
13447 /* Find a CCL program for a font specified by FONTP, and set the member
13448 `encoder' of the structure. */
13449
13450 void
13451 x_find_ccl_program (fontp)
13452 struct font_info *fontp;
13453 {
13454 Lisp_Object list, elt;
13455
13456 elt = Qnil;
13457 for (list = Vfont_ccl_encoder_alist; CONSP (list); list = XCDR (list))
13458 {
13459 elt = XCAR (list);
13460 if (CONSP (elt)
13461 && STRINGP (XCAR (elt))
13462 && ((fast_c_string_match_ignore_case (XCAR (elt), fontp->name)
13463 >= 0)
13464 || (fast_c_string_match_ignore_case (XCAR (elt), fontp->full_name)
13465 >= 0)))
13466 break;
13467 }
13468
13469 if (! NILP (list))
13470 {
13471 struct ccl_program *ccl
13472 = (struct ccl_program *) xmalloc (sizeof (struct ccl_program));
13473
13474 if (setup_ccl_program (ccl, XCDR (elt)) < 0)
13475 xfree (ccl);
13476 else
13477 fontp->font_encoder = ccl;
13478 }
13479 }
13480
13481
13482 \f
13483 /***********************************************************************
13484 Initialization
13485 ***********************************************************************/
13486
13487 #ifdef USE_X_TOOLKIT
13488 static XrmOptionDescRec emacs_options[] = {
13489 {"-geometry", ".geometry", XrmoptionSepArg, NULL},
13490 {"-iconic", ".iconic", XrmoptionNoArg, (XtPointer) "yes"},
13491
13492 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
13493 XrmoptionSepArg, NULL},
13494 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg, NULL},
13495
13496 {"-T", "*EmacsShell.title", XrmoptionSepArg, (XtPointer) NULL},
13497 {"-wn", "*EmacsShell.title", XrmoptionSepArg, (XtPointer) NULL},
13498 {"-title", "*EmacsShell.title", XrmoptionSepArg, (XtPointer) NULL},
13499 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg, (XtPointer) NULL},
13500 {"-in", "*EmacsShell.iconName", XrmoptionSepArg, (XtPointer) NULL},
13501 {"-mc", "*pointerColor", XrmoptionSepArg, (XtPointer) NULL},
13502 {"-cr", "*cursorColor", XrmoptionSepArg, (XtPointer) NULL}
13503 };
13504 #endif /* USE_X_TOOLKIT */
13505
13506 static int x_initialized;
13507
13508 #ifdef MULTI_KBOARD
13509 /* Test whether two display-name strings agree up to the dot that separates
13510 the screen number from the server number. */
13511 static int
13512 same_x_server (name1, name2)
13513 char *name1, *name2;
13514 {
13515 int seen_colon = 0;
13516 unsigned char *system_name = XSTRING (Vsystem_name)->data;
13517 int system_name_length = strlen (system_name);
13518 int length_until_period = 0;
13519
13520 while (system_name[length_until_period] != 0
13521 && system_name[length_until_period] != '.')
13522 length_until_period++;
13523
13524 /* Treat `unix' like an empty host name. */
13525 if (! strncmp (name1, "unix:", 5))
13526 name1 += 4;
13527 if (! strncmp (name2, "unix:", 5))
13528 name2 += 4;
13529 /* Treat this host's name like an empty host name. */
13530 if (! strncmp (name1, system_name, system_name_length)
13531 && name1[system_name_length] == ':')
13532 name1 += system_name_length;
13533 if (! strncmp (name2, system_name, system_name_length)
13534 && name2[system_name_length] == ':')
13535 name2 += system_name_length;
13536 /* Treat this host's domainless name like an empty host name. */
13537 if (! strncmp (name1, system_name, length_until_period)
13538 && name1[length_until_period] == ':')
13539 name1 += length_until_period;
13540 if (! strncmp (name2, system_name, length_until_period)
13541 && name2[length_until_period] == ':')
13542 name2 += length_until_period;
13543
13544 for (; *name1 != '\0' && *name1 == *name2; name1++, name2++)
13545 {
13546 if (*name1 == ':')
13547 seen_colon++;
13548 if (seen_colon && *name1 == '.')
13549 return 1;
13550 }
13551 return (seen_colon
13552 && (*name1 == '.' || *name1 == '\0')
13553 && (*name2 == '.' || *name2 == '\0'));
13554 }
13555 #endif
13556
13557 struct x_display_info *
13558 x_term_init (display_name, xrm_option, resource_name)
13559 Lisp_Object display_name;
13560 char *xrm_option;
13561 char *resource_name;
13562 {
13563 int connection;
13564 Display *dpy;
13565 struct x_display_info *dpyinfo;
13566 XrmDatabase xrdb;
13567
13568 BLOCK_INPUT;
13569
13570 if (!x_initialized)
13571 {
13572 x_initialize ();
13573 x_initialized = 1;
13574 }
13575
13576 #ifdef USE_X_TOOLKIT
13577 /* weiner@footloose.sps.mot.com reports that this causes
13578 errors with X11R5:
13579 X protocol error: BadAtom (invalid Atom parameter)
13580 on protocol request 18skiloaf.
13581 So let's not use it until R6. */
13582 #ifdef HAVE_X11XTR6
13583 XtSetLanguageProc (NULL, NULL, NULL);
13584 #endif
13585
13586 {
13587 int argc = 0;
13588 char *argv[3];
13589
13590 argv[0] = "";
13591 argc = 1;
13592 if (xrm_option)
13593 {
13594 argv[argc++] = "-xrm";
13595 argv[argc++] = xrm_option;
13596 }
13597 dpy = XtOpenDisplay (Xt_app_con, XSTRING (display_name)->data,
13598 resource_name, EMACS_CLASS,
13599 emacs_options, XtNumber (emacs_options),
13600 &argc, argv);
13601
13602 #ifdef HAVE_X11XTR6
13603 /* I think this is to compensate for XtSetLanguageProc. */
13604 fixup_locale ();
13605 #endif
13606 }
13607
13608 #else /* not USE_X_TOOLKIT */
13609 #ifdef HAVE_X11R5
13610 XSetLocaleModifiers ("");
13611 #endif
13612 dpy = XOpenDisplay (XSTRING (display_name)->data);
13613 #endif /* not USE_X_TOOLKIT */
13614
13615 /* Detect failure. */
13616 if (dpy == 0)
13617 {
13618 UNBLOCK_INPUT;
13619 return 0;
13620 }
13621
13622 /* We have definitely succeeded. Record the new connection. */
13623
13624 dpyinfo = (struct x_display_info *) xmalloc (sizeof (struct x_display_info));
13625 bzero (dpyinfo, sizeof *dpyinfo);
13626
13627 #ifdef MULTI_KBOARD
13628 {
13629 struct x_display_info *share;
13630 Lisp_Object tail;
13631
13632 for (share = x_display_list, tail = x_display_name_list; share;
13633 share = share->next, tail = XCDR (tail))
13634 if (same_x_server (XSTRING (XCAR (XCAR (tail)))->data,
13635 XSTRING (display_name)->data))
13636 break;
13637 if (share)
13638 dpyinfo->kboard = share->kboard;
13639 else
13640 {
13641 dpyinfo->kboard = (KBOARD *) xmalloc (sizeof (KBOARD));
13642 init_kboard (dpyinfo->kboard);
13643 if (!EQ (XSYMBOL (Qvendor_specific_keysyms)->function, Qunbound))
13644 {
13645 char *vendor = ServerVendor (dpy);
13646 UNBLOCK_INPUT;
13647 dpyinfo->kboard->Vsystem_key_alist
13648 = call1 (Qvendor_specific_keysyms,
13649 build_string (vendor ? vendor : ""));
13650 BLOCK_INPUT;
13651 }
13652
13653 dpyinfo->kboard->next_kboard = all_kboards;
13654 all_kboards = dpyinfo->kboard;
13655 /* Don't let the initial kboard remain current longer than necessary.
13656 That would cause problems if a file loaded on startup tries to
13657 prompt in the mini-buffer. */
13658 if (current_kboard == initial_kboard)
13659 current_kboard = dpyinfo->kboard;
13660 }
13661 dpyinfo->kboard->reference_count++;
13662 }
13663 #endif
13664
13665 /* Put this display on the chain. */
13666 dpyinfo->next = x_display_list;
13667 x_display_list = dpyinfo;
13668
13669 /* Put it on x_display_name_list as well, to keep them parallel. */
13670 x_display_name_list = Fcons (Fcons (display_name, Qnil),
13671 x_display_name_list);
13672 dpyinfo->name_list_element = XCAR (x_display_name_list);
13673
13674 dpyinfo->display = dpy;
13675
13676 #if 0
13677 XSetAfterFunction (x_current_display, x_trace_wire);
13678 #endif /* ! 0 */
13679
13680 dpyinfo->x_id_name
13681 = (char *) xmalloc (STRING_BYTES (XSTRING (Vinvocation_name))
13682 + STRING_BYTES (XSTRING (Vsystem_name))
13683 + 2);
13684 sprintf (dpyinfo->x_id_name, "%s@%s",
13685 XSTRING (Vinvocation_name)->data, XSTRING (Vsystem_name)->data);
13686
13687 /* Figure out which modifier bits mean what. */
13688 x_find_modifier_meanings (dpyinfo);
13689
13690 /* Get the scroll bar cursor. */
13691 dpyinfo->vertical_scroll_bar_cursor
13692 = XCreateFontCursor (dpyinfo->display, XC_sb_v_double_arrow);
13693
13694 xrdb = x_load_resources (dpyinfo->display, xrm_option,
13695 resource_name, EMACS_CLASS);
13696 #ifdef HAVE_XRMSETDATABASE
13697 XrmSetDatabase (dpyinfo->display, xrdb);
13698 #else
13699 dpyinfo->display->db = xrdb;
13700 #endif
13701 /* Put the rdb where we can find it in a way that works on
13702 all versions. */
13703 dpyinfo->xrdb = xrdb;
13704
13705 dpyinfo->screen = ScreenOfDisplay (dpyinfo->display,
13706 DefaultScreen (dpyinfo->display));
13707 select_visual (dpyinfo);
13708 dpyinfo->cmap = DefaultColormapOfScreen (dpyinfo->screen);
13709 dpyinfo->height = HeightOfScreen (dpyinfo->screen);
13710 dpyinfo->width = WidthOfScreen (dpyinfo->screen);
13711 dpyinfo->root_window = RootWindowOfScreen (dpyinfo->screen);
13712 dpyinfo->grabbed = 0;
13713 dpyinfo->reference_count = 0;
13714 dpyinfo->icon_bitmap_id = -1;
13715 dpyinfo->font_table = NULL;
13716 dpyinfo->n_fonts = 0;
13717 dpyinfo->font_table_size = 0;
13718 dpyinfo->bitmaps = 0;
13719 dpyinfo->bitmaps_size = 0;
13720 dpyinfo->bitmaps_last = 0;
13721 dpyinfo->scratch_cursor_gc = 0;
13722 dpyinfo->mouse_face_mouse_frame = 0;
13723 dpyinfo->mouse_face_deferred_gc = 0;
13724 dpyinfo->mouse_face_beg_row = dpyinfo->mouse_face_beg_col = -1;
13725 dpyinfo->mouse_face_end_row = dpyinfo->mouse_face_end_col = -1;
13726 dpyinfo->mouse_face_face_id = DEFAULT_FACE_ID;
13727 dpyinfo->mouse_face_window = Qnil;
13728 dpyinfo->mouse_face_mouse_x = dpyinfo->mouse_face_mouse_y = 0;
13729 dpyinfo->mouse_face_defer = 0;
13730 dpyinfo->x_focus_frame = 0;
13731 dpyinfo->x_focus_event_frame = 0;
13732 dpyinfo->x_highlight_frame = 0;
13733 dpyinfo->image_cache = make_image_cache ();
13734
13735 /* See if a private colormap is requested. */
13736 if (dpyinfo->visual == DefaultVisualOfScreen (dpyinfo->screen))
13737 {
13738 if (dpyinfo->visual->class == PseudoColor)
13739 {
13740 Lisp_Object value;
13741 value = display_x_get_resource (dpyinfo,
13742 build_string ("privateColormap"),
13743 build_string ("PrivateColormap"),
13744 Qnil, Qnil);
13745 if (STRINGP (value)
13746 && (!strcmp (XSTRING (value)->data, "true")
13747 || !strcmp (XSTRING (value)->data, "on")))
13748 dpyinfo->cmap = XCopyColormapAndFree (dpyinfo->display, dpyinfo->cmap);
13749 }
13750 }
13751 else
13752 dpyinfo->cmap = XCreateColormap (dpyinfo->display, dpyinfo->root_window,
13753 dpyinfo->visual, AllocNone);
13754
13755 {
13756 int screen_number = XScreenNumberOfScreen (dpyinfo->screen);
13757 double pixels = DisplayHeight (dpyinfo->display, screen_number);
13758 double mm = DisplayHeightMM (dpyinfo->display, screen_number);
13759 dpyinfo->resy = pixels * 25.4 / mm;
13760 pixels = DisplayWidth (dpyinfo->display, screen_number);
13761 mm = DisplayWidthMM (dpyinfo->display, screen_number);
13762 dpyinfo->resx = pixels * 25.4 / mm;
13763 }
13764
13765 dpyinfo->Xatom_wm_protocols
13766 = XInternAtom (dpyinfo->display, "WM_PROTOCOLS", False);
13767 dpyinfo->Xatom_wm_take_focus
13768 = XInternAtom (dpyinfo->display, "WM_TAKE_FOCUS", False);
13769 dpyinfo->Xatom_wm_save_yourself
13770 = XInternAtom (dpyinfo->display, "WM_SAVE_YOURSELF", False);
13771 dpyinfo->Xatom_wm_delete_window
13772 = XInternAtom (dpyinfo->display, "WM_DELETE_WINDOW", False);
13773 dpyinfo->Xatom_wm_change_state
13774 = XInternAtom (dpyinfo->display, "WM_CHANGE_STATE", False);
13775 dpyinfo->Xatom_wm_configure_denied
13776 = XInternAtom (dpyinfo->display, "WM_CONFIGURE_DENIED", False);
13777 dpyinfo->Xatom_wm_window_moved
13778 = XInternAtom (dpyinfo->display, "WM_MOVED", False);
13779 dpyinfo->Xatom_editres
13780 = XInternAtom (dpyinfo->display, "Editres", False);
13781 dpyinfo->Xatom_CLIPBOARD
13782 = XInternAtom (dpyinfo->display, "CLIPBOARD", False);
13783 dpyinfo->Xatom_TIMESTAMP
13784 = XInternAtom (dpyinfo->display, "TIMESTAMP", False);
13785 dpyinfo->Xatom_TEXT
13786 = XInternAtom (dpyinfo->display, "TEXT", False);
13787 dpyinfo->Xatom_COMPOUND_TEXT
13788 = XInternAtom (dpyinfo->display, "COMPOUND_TEXT", False);
13789 dpyinfo->Xatom_DELETE
13790 = XInternAtom (dpyinfo->display, "DELETE", False);
13791 dpyinfo->Xatom_MULTIPLE
13792 = XInternAtom (dpyinfo->display, "MULTIPLE", False);
13793 dpyinfo->Xatom_INCR
13794 = XInternAtom (dpyinfo->display, "INCR", False);
13795 dpyinfo->Xatom_EMACS_TMP
13796 = XInternAtom (dpyinfo->display, "_EMACS_TMP_", False);
13797 dpyinfo->Xatom_TARGETS
13798 = XInternAtom (dpyinfo->display, "TARGETS", False);
13799 dpyinfo->Xatom_NULL
13800 = XInternAtom (dpyinfo->display, "NULL", False);
13801 dpyinfo->Xatom_ATOM_PAIR
13802 = XInternAtom (dpyinfo->display, "ATOM_PAIR", False);
13803 /* For properties of font. */
13804 dpyinfo->Xatom_PIXEL_SIZE
13805 = XInternAtom (dpyinfo->display, "PIXEL_SIZE", False);
13806 dpyinfo->Xatom_MULE_BASELINE_OFFSET
13807 = XInternAtom (dpyinfo->display, "_MULE_BASELINE_OFFSET", False);
13808 dpyinfo->Xatom_MULE_RELATIVE_COMPOSE
13809 = XInternAtom (dpyinfo->display, "_MULE_RELATIVE_COMPOSE", False);
13810 dpyinfo->Xatom_MULE_DEFAULT_ASCENT
13811 = XInternAtom (dpyinfo->display, "_MULE_DEFAULT_ASCENT", False);
13812
13813 /* Ghostscript support. */
13814 dpyinfo->Xatom_PAGE = XInternAtom (dpyinfo->display, "PAGE", False);
13815 dpyinfo->Xatom_DONE = XInternAtom (dpyinfo->display, "DONE", False);
13816
13817 dpyinfo->Xatom_Scrollbar = XInternAtom (dpyinfo->display, "SCROLLBAR",
13818 False);
13819
13820 dpyinfo->cut_buffers_initialized = 0;
13821
13822 connection = ConnectionNumber (dpyinfo->display);
13823 dpyinfo->connection = connection;
13824
13825 {
13826 char null_bits[1];
13827
13828 null_bits[0] = 0x00;
13829
13830 dpyinfo->null_pixel
13831 = XCreatePixmapFromBitmapData (dpyinfo->display, dpyinfo->root_window,
13832 null_bits, 1, 1, (long) 0, (long) 0,
13833 1);
13834 }
13835
13836 {
13837 extern int gray_bitmap_width, gray_bitmap_height;
13838 extern char *gray_bitmap_bits;
13839 dpyinfo->gray
13840 = XCreatePixmapFromBitmapData (dpyinfo->display, dpyinfo->root_window,
13841 gray_bitmap_bits,
13842 gray_bitmap_width, gray_bitmap_height,
13843 (unsigned long) 1, (unsigned long) 0, 1);
13844 }
13845
13846 #ifdef HAVE_X_I18N
13847 xim_initialize (dpyinfo, resource_name);
13848 #endif
13849
13850 #ifdef subprocesses
13851 /* This is only needed for distinguishing keyboard and process input. */
13852 if (connection != 0)
13853 add_keyboard_wait_descriptor (connection);
13854 #endif
13855
13856 #ifndef F_SETOWN_BUG
13857 #ifdef F_SETOWN
13858 #ifdef F_SETOWN_SOCK_NEG
13859 /* stdin is a socket here */
13860 fcntl (connection, F_SETOWN, -getpid ());
13861 #else /* ! defined (F_SETOWN_SOCK_NEG) */
13862 fcntl (connection, F_SETOWN, getpid ());
13863 #endif /* ! defined (F_SETOWN_SOCK_NEG) */
13864 #endif /* ! defined (F_SETOWN) */
13865 #endif /* F_SETOWN_BUG */
13866
13867 #ifdef SIGIO
13868 if (interrupt_input)
13869 init_sigio (connection);
13870 #endif /* ! defined (SIGIO) */
13871
13872 #ifdef USE_LUCID
13873 #ifdef HAVE_X11R5 /* It seems X11R4 lacks XtCvtStringToFont, and XPointer. */
13874 /* Make sure that we have a valid font for dialog boxes
13875 so that Xt does not crash. */
13876 {
13877 Display *dpy = dpyinfo->display;
13878 XrmValue d, fr, to;
13879 Font font;
13880 int count;
13881
13882 d.addr = (XPointer)&dpy;
13883 d.size = sizeof (Display *);
13884 fr.addr = XtDefaultFont;
13885 fr.size = sizeof (XtDefaultFont);
13886 to.size = sizeof (Font *);
13887 to.addr = (XPointer)&font;
13888 count = x_catch_errors (dpy);
13889 if (!XtCallConverter (dpy, XtCvtStringToFont, &d, 1, &fr, &to, NULL))
13890 abort ();
13891 if (x_had_errors_p (dpy) || !XQueryFont (dpy, font))
13892 XrmPutLineResource (&xrdb, "Emacs.dialog.*.font: 9x15");
13893 x_uncatch_errors (dpy, count);
13894 }
13895 #endif
13896 #endif
13897
13898 /* See if we should run in synchronous mode. This is useful
13899 for debugging X code. */
13900 {
13901 Lisp_Object value;
13902 value = display_x_get_resource (dpyinfo,
13903 build_string ("synchronous"),
13904 build_string ("Synchronous"),
13905 Qnil, Qnil);
13906 if (STRINGP (value)
13907 && (!strcmp (XSTRING (value)->data, "true")
13908 || !strcmp (XSTRING (value)->data, "on")))
13909 XSynchronize (dpyinfo->display, True);
13910 }
13911
13912 UNBLOCK_INPUT;
13913
13914 return dpyinfo;
13915 }
13916 \f
13917 /* Get rid of display DPYINFO, assuming all frames are already gone,
13918 and without sending any more commands to the X server. */
13919
13920 void
13921 x_delete_display (dpyinfo)
13922 struct x_display_info *dpyinfo;
13923 {
13924 delete_keyboard_wait_descriptor (dpyinfo->connection);
13925
13926 /* Discard this display from x_display_name_list and x_display_list.
13927 We can't use Fdelq because that can quit. */
13928 if (! NILP (x_display_name_list)
13929 && EQ (XCAR (x_display_name_list), dpyinfo->name_list_element))
13930 x_display_name_list = XCDR (x_display_name_list);
13931 else
13932 {
13933 Lisp_Object tail;
13934
13935 tail = x_display_name_list;
13936 while (CONSP (tail) && CONSP (XCDR (tail)))
13937 {
13938 if (EQ (XCAR (XCDR (tail)), dpyinfo->name_list_element))
13939 {
13940 XCDR (tail) = XCDR (XCDR (tail));
13941 break;
13942 }
13943 tail = XCDR (tail);
13944 }
13945 }
13946
13947 if (next_noop_dpyinfo == dpyinfo)
13948 next_noop_dpyinfo = dpyinfo->next;
13949
13950 if (x_display_list == dpyinfo)
13951 x_display_list = dpyinfo->next;
13952 else
13953 {
13954 struct x_display_info *tail;
13955
13956 for (tail = x_display_list; tail; tail = tail->next)
13957 if (tail->next == dpyinfo)
13958 tail->next = tail->next->next;
13959 }
13960
13961 #ifndef USE_X_TOOLKIT /* I'm told Xt does this itself. */
13962 #ifndef AIX /* On AIX, XCloseDisplay calls this. */
13963 XrmDestroyDatabase (dpyinfo->xrdb);
13964 #endif
13965 #endif
13966 #ifdef MULTI_KBOARD
13967 if (--dpyinfo->kboard->reference_count == 0)
13968 delete_kboard (dpyinfo->kboard);
13969 #endif
13970 #ifdef HAVE_X_I18N
13971 if (dpyinfo->xim)
13972 xim_close_dpy (dpyinfo);
13973 #endif
13974
13975 xfree (dpyinfo->font_table);
13976 xfree (dpyinfo->x_id_name);
13977 xfree (dpyinfo->color_cells);
13978 xfree (dpyinfo);
13979 }
13980
13981 \f
13982 /* Set up use of X before we make the first connection. */
13983
13984 static struct redisplay_interface x_redisplay_interface =
13985 {
13986 x_produce_glyphs,
13987 x_write_glyphs,
13988 x_insert_glyphs,
13989 x_clear_end_of_line,
13990 x_scroll_run,
13991 x_after_update_window_line,
13992 x_update_window_begin,
13993 x_update_window_end,
13994 XTcursor_to,
13995 x_flush,
13996 x_clear_mouse_face,
13997 x_get_glyph_overhangs,
13998 x_fix_overlapping_area
13999 };
14000
14001 void
14002 x_initialize ()
14003 {
14004 rif = &x_redisplay_interface;
14005
14006 clear_frame_hook = x_clear_frame;
14007 ins_del_lines_hook = x_ins_del_lines;
14008 change_line_highlight_hook = x_change_line_highlight;
14009 delete_glyphs_hook = x_delete_glyphs;
14010 ring_bell_hook = XTring_bell;
14011 reset_terminal_modes_hook = XTreset_terminal_modes;
14012 set_terminal_modes_hook = XTset_terminal_modes;
14013 update_begin_hook = x_update_begin;
14014 update_end_hook = x_update_end;
14015 set_terminal_window_hook = XTset_terminal_window;
14016 read_socket_hook = XTread_socket;
14017 frame_up_to_date_hook = XTframe_up_to_date;
14018 reassert_line_highlight_hook = XTreassert_line_highlight;
14019 mouse_position_hook = XTmouse_position;
14020 frame_rehighlight_hook = XTframe_rehighlight;
14021 frame_raise_lower_hook = XTframe_raise_lower;
14022 set_vertical_scroll_bar_hook = XTset_vertical_scroll_bar;
14023 condemn_scroll_bars_hook = XTcondemn_scroll_bars;
14024 redeem_scroll_bar_hook = XTredeem_scroll_bar;
14025 judge_scroll_bars_hook = XTjudge_scroll_bars;
14026 estimate_mode_line_height_hook = x_estimate_mode_line_height;
14027
14028 scroll_region_ok = 1; /* we'll scroll partial frames */
14029 char_ins_del_ok = 1;
14030 line_ins_del_ok = 1; /* we'll just blt 'em */
14031 fast_clear_end_of_line = 1; /* X does this well */
14032 memory_below_frame = 0; /* we don't remember what scrolls
14033 off the bottom */
14034 baud_rate = 19200;
14035
14036 x_noop_count = 0;
14037 last_tool_bar_item = -1;
14038 any_help_event_p = 0;
14039
14040 /* Try to use interrupt input; if we can't, then start polling. */
14041 Fset_input_mode (Qt, Qnil, Qt, Qnil);
14042
14043 #ifdef USE_X_TOOLKIT
14044 XtToolkitInitialize ();
14045 Xt_app_con = XtCreateApplicationContext ();
14046 XtAppSetFallbackResources (Xt_app_con, Xt_default_resources);
14047
14048 /* Install an asynchronous timer that processes Xt timeout events
14049 every 0.1s. This is necessary because some widget sets use
14050 timeouts internally, for example the LessTif menu bar, or the
14051 Xaw3d scroll bar. When Xt timouts aren't processed, these
14052 widgets don't behave normally. */
14053 {
14054 EMACS_TIME interval;
14055 EMACS_SET_SECS_USECS (interval, 0, 100000);
14056 start_atimer (ATIMER_CONTINUOUS, interval, x_process_timeouts, 0);
14057 }
14058 #endif
14059
14060 #ifdef USE_TOOLKIT_SCROLL_BARS
14061 xaw3d_arrow_scroll = False;
14062 xaw3d_pick_top = True;
14063 #endif
14064
14065 /* Note that there is no real way portable across R3/R4 to get the
14066 original error handler. */
14067 XSetErrorHandler (x_error_handler);
14068 XSetIOErrorHandler (x_io_error_quitter);
14069
14070 /* Disable Window Change signals; they are handled by X events. */
14071 #ifdef SIGWINCH
14072 signal (SIGWINCH, SIG_DFL);
14073 #endif /* ! defined (SIGWINCH) */
14074
14075 signal (SIGPIPE, x_connection_signal);
14076 }
14077
14078
14079 void
14080 syms_of_xterm ()
14081 {
14082 staticpro (&x_error_message_string);
14083 x_error_message_string = Qnil;
14084
14085 staticpro (&x_display_name_list);
14086 x_display_name_list = Qnil;
14087
14088 staticpro (&last_mouse_scroll_bar);
14089 last_mouse_scroll_bar = Qnil;
14090
14091 staticpro (&Qvendor_specific_keysyms);
14092 Qvendor_specific_keysyms = intern ("vendor-specific-keysyms");
14093
14094 staticpro (&last_mouse_press_frame);
14095 last_mouse_press_frame = Qnil;
14096
14097 help_echo = Qnil;
14098 staticpro (&help_echo);
14099 help_echo_object = Qnil;
14100 staticpro (&help_echo_object);
14101 help_echo_window = Qnil;
14102 staticpro (&help_echo_window);
14103 previous_help_echo = Qnil;
14104 staticpro (&previous_help_echo);
14105 help_echo_pos = -1;
14106
14107 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p,
14108 "*Non-nil means draw block cursor as wide as the glyph under it.\n\
14109 For example, if a block cursor is over a tab, it will be drawn as\n\
14110 wide as that tab on the display.");
14111 x_stretch_cursor_p = 0;
14112
14113 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars,
14114 "What X toolkit scroll bars Emacs uses.\n\
14115 A value of nil means Emacs doesn't use X toolkit scroll bars.\n\
14116 Otherwise, value is a symbol describing the X toolkit.");
14117 #ifdef USE_TOOLKIT_SCROLL_BARS
14118 #ifdef USE_MOTIF
14119 Vx_toolkit_scroll_bars = intern ("motif");
14120 #elif defined HAVE_XAW3D
14121 Vx_toolkit_scroll_bars = intern ("xaw3d");
14122 #else
14123 Vx_toolkit_scroll_bars = intern ("xaw");
14124 #endif
14125 #else
14126 Vx_toolkit_scroll_bars = Qnil;
14127 #endif
14128
14129 staticpro (&last_mouse_motion_frame);
14130 last_mouse_motion_frame = Qnil;
14131 }
14132
14133 #endif /* not HAVE_X_WINDOWS */