1 /* Implementation of GUI terminal on the Mac OS.
2 Copyright (C) 2000 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* Contributed by Andrew Choi (akochoi@users.sourceforge.net). */
25 /* On 4.3 these lose if they come after xterm.h. */
26 /* Putting these at the beginning seems to be standard for other .c files. */
32 #include "blockinput.h"
34 /* Need syssignal.h for various externs and definitions that may be required
35 by some configurations for calls to signal later in this source file. */
36 #include "syssignal.h"
38 /* This may include sys/types.h, and that somehow loses
39 if this is not done before the other system files. */
46 #include <Quickdraw.h>
47 #include <ToolUtils.h>
51 #include <Resources.h>
53 #include <TextUtils.h>
56 #if defined (__MRC__) || defined (CODEWARRIOR_VERSION_6)
57 #include <ControlDefinitions.h>
64 #include <sys/types.h>
69 #ifndef INCLUDED_FCNTL
80 #include "dispextern.h"
82 #include "termhooks.h"
90 #include "intervals.h"
100 #define x_any_window_to_frame x_window_to_frame
101 #define x_top_window_to_frame x_window_to_frame
105 #define min(a,b) ((a) < (b) ? (a) : (b))
108 #define max(a,b) ((a) > (b) ? (a) : (b))
111 #define BETWEEN(X, LOWER, UPPER) ((X) >= (LOWER) && (X) < (UPPER))
114 /* Bitmaps for truncated lines. */
119 LEFT_TRUNCATION_BITMAP
,
120 RIGHT_TRUNCATION_BITMAP
,
121 OVERLAY_ARROW_BITMAP
,
122 CONTINUED_LINE_BITMAP
,
123 CONTINUATION_LINE_BITMAP
,
127 /* Bitmap drawn to indicate lines not displaying text if
128 `indicate-empty-lines' is non-nil. */
132 static unsigned char zv_bits
[] = {
133 0x00, 0x00, 0x78, 0x78, 0x78, 0x78, 0x00, 0x00};
135 /* An arrow like this: `<-'. */
138 #define left_height 8
139 static unsigned char left_bits
[] = {
140 0x18, 0x30, 0x60, 0xfc, 0xfc, 0x60, 0x30, 0x18};
142 /* Right truncation arrow bitmap `->'. */
144 #define right_width 8
145 #define right_height 8
146 static unsigned char right_bits
[] = {
147 0x18, 0x0c, 0x06, 0x3f, 0x3f, 0x06, 0x0c, 0x18};
149 /* Marker for continued lines. */
151 #define continued_width 8
152 #define continued_height 8
153 static unsigned char continued_bits
[] = {
154 0x3c, 0x3e, 0x03, 0x27, 0x3f, 0x3e, 0x3c, 0x3e};
156 /* Marker for continuation lines. */
158 #define continuation_width 8
159 #define continuation_height 8
160 static unsigned char continuation_bits
[] = {
161 0x3c, 0x7c, 0xc0, 0xe4, 0xfc, 0x7c, 0x3c, 0x7c};
163 /* Overlay arrow bitmap. */
169 static unsigned char ov_bits
[] = {
170 0x0c, 0x10, 0x3c, 0x7e, 0x5e, 0x5e, 0x46, 0x3c};
172 /* A triangular arrow. */
175 static unsigned char ov_bits
[] = {
176 0xc0, 0xf0, 0xf8, 0xfc, 0xfc, 0xf8, 0xf0, 0xc0};
179 extern Lisp_Object Qhelp_echo
;
182 /* Non-zero means Emacs uses toolkit scroll bars. */
184 int x_toolkit_scroll_bars_p
;
186 /* If a string, XTread_socket generates an event to display that string.
187 (The display is done in read_char.) */
189 static Lisp_Object help_echo
;
190 static Lisp_Object help_echo_window
;
191 static Lisp_Object help_echo_object
;
192 static int help_echo_pos
;
194 /* Temporary variable for XTread_socket. */
196 static Lisp_Object previous_help_echo
;
198 /* Non-zero means that a HELP_EVENT has been generated since Emacs
201 static int any_help_event_p
;
203 /* Non-zero means draw block and hollow cursor as wide as the glyph
204 under it. For example, if a block cursor is over a tab, it will be
205 drawn as wide as that tab on the display. */
207 int x_stretch_cursor_p
;
209 /* This is a chain of structures for all the X displays currently in
212 struct x_display_info
*x_display_list
;
214 /* This is a list of cons cells, each of the form (NAME
215 . FONT-LIST-CACHE), one for each element of x_display_list and in
216 the same order. NAME is the name of the frame. FONT-LIST-CACHE
217 records previous values returned by x-list-fonts. */
219 Lisp_Object x_display_name_list
;
221 /* This is display since Mac does not support multiple ones. */
222 struct mac_display_info one_mac_display_info
;
224 /* Frame being updated by update_frame. This is declared in term.c.
225 This is set by update_begin and looked at by all the XT functions.
226 It is zero while not inside an update. In that case, the XT
227 functions assume that `selected_frame' is the frame to apply to. */
229 extern struct frame
*updating_frame
;
231 extern int waiting_for_input
;
233 /* This is a frame waiting to be auto-raised, within XTread_socket. */
235 struct frame
*pending_autoraise_frame
;
237 /* Nominal cursor position -- where to draw output.
238 HPOS and VPOS are window relative glyph matrix coordinates.
239 X and Y are window relative pixel coordinates. */
241 struct cursor_pos output_cursor
;
243 /* Non-zero means user is interacting with a toolkit scroll bar. */
245 static int toolkit_scroll_bar_interaction
;
249 Formerly, we used PointerMotionHintMask (in standard_event_mask)
250 so that we would have to call XQueryPointer after each MotionNotify
251 event to ask for another such event. However, this made mouse tracking
252 slow, and there was a bug that made it eventually stop.
254 Simply asking for MotionNotify all the time seems to work better.
256 In order to avoid asking for motion events and then throwing most
257 of them away or busy-polling the server for mouse positions, we ask
258 the server for pointer motion hints. This means that we get only
259 one event per group of mouse movements. "Groups" are delimited by
260 other kinds of events (focus changes and button clicks, for
261 example), or by XQueryPointer calls; when one of these happens, we
262 get another MotionNotify event the next time the mouse moves. This
263 is at least as efficient as getting motion events when mouse
264 tracking is on, and I suspect only negligibly worse when tracking
267 /* Where the mouse was last time we reported a mouse event. */
269 FRAME_PTR last_mouse_frame
;
270 static Rect last_mouse_glyph
;
271 static Lisp_Object last_mouse_press_frame
;
273 /* The scroll bar in which the last X motion event occurred.
275 If the last X motion event occurred in a scroll bar, we set this so
276 XTmouse_position can know whether to report a scroll bar motion or
279 If the last X motion event didn't occur in a scroll bar, we set
280 this to Qnil, to tell XTmouse_position to return an ordinary motion
283 static Lisp_Object last_mouse_scroll_bar
;
285 /* This is a hack. We would really prefer that XTmouse_position would
286 return the time associated with the position it returns, but there
287 doesn't seem to be any way to wrest the time-stamp from the server
288 along with the position query. So, we just keep track of the time
289 of the last movement we received, and return that in hopes that
290 it's somewhat accurate. */
292 static Time last_mouse_movement_time
;
294 enum mouse_tracking_type
{
296 mouse_tracking_mouse_movement
,
297 mouse_tracking_scroll_bar
300 enum mouse_tracking_type mouse_tracking_in_progress
= mouse_tracking_none
;
302 struct scroll_bar
*tracked_scroll_bar
= NULL
;
304 /* Incremented by XTread_socket whenever it really tries to read
308 static int volatile input_signal_count
;
310 static int input_signal_count
;
313 /* Used locally within XTread_socket. */
315 static int x_noop_count
;
317 /* Initial values of argv and argc. */
319 extern char **initial_argv
;
320 extern int initial_argc
;
322 extern Lisp_Object Vcommand_line_args
, Vsystem_name
;
324 /* Tells if a window manager is present or not. */
326 extern Lisp_Object Vx_no_window_manager
;
328 extern Lisp_Object Qface
, Qmouse_face
;
332 /* A mask of extra modifier bits to put into every keyboard char. */
334 extern int extra_keyboard_modifiers
;
336 static Lisp_Object Qvendor_specific_keysyms
;
339 extern XrmDatabase x_load_resources
P_ ((Display
*, char *, char *, char *));
342 extern Lisp_Object x_icon_type
P_ ((struct frame
*));
346 QDGlobals qd
; /* QuickDraw global information structure. */
350 /* Enumeration for overriding/changing the face to use for drawing
351 glyphs in x_draw_glyphs. */
353 enum draw_glyphs_face
363 struct frame
* x_window_to_frame (struct mac_display_info
*, WindowPtr
);
364 struct mac_display_info
*mac_display_info_for_display (Display
*);
365 static void x_update_window_end
P_ ((struct window
*, int, int));
366 static void frame_to_window_pixel_xy
P_ ((struct window
*, int *, int *));
367 void x_delete_display
P_ ((struct x_display_info
*));
368 static unsigned int x_mac_to_emacs_modifiers
P_ ((struct x_display_info
*,
370 static int fast_find_position
P_ ((struct window
*, int, int *, int *,
372 static void set_output_cursor
P_ ((struct cursor_pos
*));
373 static struct glyph
*x_y_to_hpos_vpos
P_ ((struct window
*, int, int,
374 int *, int *, int *));
375 static void note_mode_line_highlight
P_ ((struct window
*, int, int));
376 static void note_mouse_highlight
P_ ((struct frame
*, int, int));
377 static void note_tool_bar_highlight
P_ ((struct frame
*f
, int, int));
378 static void x_handle_tool_bar_click
P_ ((struct frame
*, XButtonEvent
*));
379 static void show_mouse_face
P_ ((struct x_display_info
*,
380 enum draw_glyphs_face
));
381 void clear_mouse_face
P_ ((struct mac_display_info
*));
382 static int x_io_error_quitter
P_ ((Display
*));
383 int x_catch_errors
P_ ((Display
*));
384 void x_uncatch_errors
P_ ((Display
*, int));
385 void x_lower_frame
P_ ((struct frame
*));
386 void x_scroll_bar_clear
P_ ((struct frame
*));
387 int x_had_errors_p
P_ ((Display
*));
388 void x_wm_set_size_hint
P_ ((struct frame
*, long, int));
389 void x_raise_frame
P_ ((struct frame
*));
390 void x_set_window_size
P_ ((struct frame
*, int, int, int));
391 void x_wm_set_window_state
P_ ((struct frame
*, int));
392 void x_wm_set_icon_pixmap
P_ ((struct frame
*, int));
393 void x_initialize
P_ ((void));
394 static void x_font_min_bounds
P_ ((XFontStruct
*, int *, int *));
395 static int x_compute_min_glyph_bounds
P_ ((struct frame
*));
396 enum text_cursor_kinds x_specified_cursor_type
P_ ((Lisp_Object
, int *));
397 static void x_draw_phys_cursor_glyph
P_ ((struct window
*,
399 enum draw_glyphs_face
));
400 static void x_update_end
P_ ((struct frame
*));
401 static void XTframe_up_to_date
P_ ((struct frame
*));
402 static void XTreassert_line_highlight
P_ ((int, int));
403 static void x_change_line_highlight
P_ ((int, int, int, int));
404 static void XTset_terminal_modes
P_ ((void));
405 static void XTreset_terminal_modes
P_ ((void));
406 static void XTcursor_to
P_ ((int, int, int, int));
407 static void x_write_glyphs
P_ ((struct glyph
*, int));
408 static void x_clear_end_of_line
P_ ((int));
409 static void x_clear_frame
P_ ((void));
410 static void x_clear_cursor
P_ ((struct window
*));
411 static void frame_highlight
P_ ((struct frame
*));
412 static void frame_unhighlight
P_ ((struct frame
*));
413 static void x_new_focus_frame
P_ ((struct x_display_info
*, struct frame
*));
414 static void XTframe_rehighlight
P_ ((struct frame
*));
415 static void x_frame_rehighlight
P_ ((struct x_display_info
*));
416 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
417 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int));
418 static int x_intersect_rectangles
P_ ((Rect
*, Rect
*, Rect
*));
419 static void expose_frame
P_ ((struct frame
*, int, int, int, int));
420 static void expose_window_tree
P_ ((struct window
*, Rect
*));
421 static void expose_window
P_ ((struct window
*, Rect
*));
422 static void expose_area
P_ ((struct window
*, struct glyph_row
*,
423 XRectangle
*, enum glyph_row_area
));
424 static void expose_line
P_ ((struct window
*, struct glyph_row
*,
426 void x_display_cursor (struct window
*, int, int, int, int, int);
427 void x_update_cursor
P_ ((struct frame
*, int));
428 static void x_update_cursor_in_window_tree
P_ ((struct window
*, int));
429 static void x_update_window_cursor
P_ ((struct window
*, int));
430 static void x_erase_phys_cursor
P_ ((struct window
*));
431 void x_display_and_set_cursor
P_ ((struct window
*, int, int, int, int, int));
432 static void x_draw_bitmap
P_ ((struct window
*, struct glyph_row
*,
435 static void x_clip_to_row
P_ ((struct window
*, struct glyph_row
*,
437 static int x_phys_cursor_in_rect_p
P_ ((struct window
*, Rect
*));
438 static void x_draw_row_bitmaps
P_ ((struct window
*, struct glyph_row
*));
439 static void note_overwritten_text_cursor
P_ ((struct window
*, int, int));
440 static void x_flush
P_ ((struct frame
*f
));
441 static void x_update_begin
P_ ((struct frame
*));
442 static void x_update_window_begin
P_ ((struct window
*));
443 static void x_draw_vertical_border
P_ ((struct window
*));
444 static void x_after_update_window_line
P_ ((struct glyph_row
*));
445 static INLINE
void take_vertical_position_into_account
P_ ((struct it
*));
446 static void x_produce_stretch_glyph
P_ ((struct it
*));
448 static void activate_scroll_bars (FRAME_PTR
);
449 static void deactivate_scroll_bars (FRAME_PTR
);
451 extern int image_ascent (struct image
*, struct face
*);
452 void x_set_offset (struct frame
*, int, int, int);
453 int x_bitmap_icon (struct frame
*, Lisp_Object
);
454 void x_make_frame_visible (struct frame
*);
456 extern void window_scroll (Lisp_Object
, int, int, int);
458 /* Defined in macmenu.h. */
459 extern void menubar_selection_callback (FRAME_PTR
, int);
460 extern void set_frame_menubar (FRAME_PTR
, int, int);
462 /* X display function emulation */
464 /* Structure borrowed from Xlib.h to represent two-byte characters in
473 XFreePixmap (display
, pixmap
)
477 PixMap
*p
= (PixMap
*) pixmap
;
484 /* Set foreground color for subsequent QuickDraw commands. Assume
485 graphic port has already been set. */
488 mac_set_forecolor (unsigned long color
)
492 fg_color
.red
= RED_FROM_ULONG (color
) * 256;
493 fg_color
.green
= GREEN_FROM_ULONG (color
) * 256;
494 fg_color
.blue
= BLUE_FROM_ULONG (color
) * 256;
496 RGBForeColor (&fg_color
);
500 /* Set background color for subsequent QuickDraw commands. Assume
501 graphic port has already been set. */
504 mac_set_backcolor (unsigned long color
)
508 bg_color
.red
= RED_FROM_ULONG (color
) * 256;
509 bg_color
.green
= GREEN_FROM_ULONG (color
) * 256;
510 bg_color
.blue
= BLUE_FROM_ULONG (color
) * 256;
512 RGBBackColor (&bg_color
);
515 /* Set foreground and background color for subsequent QuickDraw
516 commands. Assume that the graphic port has already been set. */
519 mac_set_colors (GC gc
)
521 mac_set_forecolor (gc
->foreground
);
522 mac_set_backcolor (gc
->background
);
525 /* Mac version of XDrawLine. */
528 XDrawLine (display
, w
, gc
, x1
, y1
, x2
, y2
)
541 /* Mac version of XClearArea. */
544 XClearArea (display
, w
, x
, y
, width
, height
, exposures
)
548 unsigned int width
, height
;
551 struct mac_output
*mwp
= (mac_output
*) GetWRefCon (w
);
555 xgc
.foreground
= mwp
->foreground_pixel
;
556 xgc
.background
= mwp
->background_pixel
;
559 mac_set_colors (&xgc
);
560 SetRect (&r
, x
, y
, x
+ width
, y
+ height
);
565 /* Mac version of XClearWindow. */
568 XClearWindow (display
, w
)
572 struct mac_output
*mwp
= (mac_output
*) GetWRefCon (w
);
575 xgc
.foreground
= mwp
->foreground_pixel
;
576 xgc
.background
= mwp
->background_pixel
;
579 mac_set_colors (&xgc
);
581 EraseRect (&(w
->portRect
));
585 /* Mac replacement for XCopyArea. */
588 mac_draw_bitmap (display
, w
, gc
, x
, y
, bitmap
)
599 SetRect (&r
, x
, y
, x
+ bitmap
->bounds
.right
, y
+ bitmap
->bounds
.bottom
);
601 CopyBits (bitmap
, &(w
->portBits
), &(bitmap
->bounds
), &r
, srcCopy
, 0);
605 /* Mac replacement for XSetClipRectangles. */
608 mac_set_clip_rectangle (display
, w
, r
)
619 /* Mac replacement for XSetClipMask. */
622 mac_reset_clipping (display
, w
)
630 SetRect (&r
, -32767, -32767, 32767, 32767);
635 /* Mac replacement for XCreateBitmapFromBitmapData. */
638 mac_create_bitmap_from_bitmap_data (bitmap
, bits
, w
, h
)
643 int bytes_per_row
, i
, j
;
645 bitmap
->rowBytes
= (w
+ 15) / 16 * 2; /* must be on word boundary */
646 bitmap
->baseAddr
= xmalloc (bitmap
->rowBytes
* h
);
647 if (!bitmap
->baseAddr
)
650 bzero (bitmap
->baseAddr
, bitmap
->rowBytes
* h
);
651 for (i
= 0; i
< h
; i
++)
652 for (j
= 0; j
< w
; j
++)
653 if (BitTst (bits
, i
* w
+ j
))
654 BitSet (bitmap
->baseAddr
, i
* bitmap
->rowBytes
* 8 + j
);
656 SetRect (&(bitmap
->bounds
), 0, 0, w
, h
);
661 mac_free_bitmap (bitmap
)
664 xfree (bitmap
->baseAddr
);
667 /* Mac replacement for XFillRectangle. */
670 XFillRectangle (display
, w
, gc
, x
, y
, width
, height
)
675 unsigned int width
, height
;
681 SetRect (&r
, x
, y
, x
+ width
, y
+ height
);
683 PaintRect (&r
); /* using foreground color of gc */
687 /* Mac replacement for XDrawRectangle: dest is a window. */
690 mac_draw_rectangle (display
, w
, gc
, x
, y
, width
, height
)
695 unsigned int width
, height
;
701 SetRect (&r
, x
, y
, x
+ width
+ 1, y
+ height
+ 1);
703 FrameRect (&r
); /* using foreground color of gc */
707 /* Mac replacement for XDrawRectangle: dest is a Pixmap. */
710 mac_draw_rectangle_to_pixmap (display
, p
, gc
, x
, y
, width
, height
)
715 unsigned int width
, height
;
717 #if 0 /* MAC_TODO: draw a rectangle in a PixMap */
722 SetRect (&r
, x
, y
, x
+ width
, y
+ height
);
724 FrameRect (&r
); /* using foreground color of gc */
730 mac_draw_string_common (display
, w
, gc
, x
, y
, buf
, nchars
, mode
,
737 int nchars
, mode
, bytes_per_char
;
742 TextFont (gc
->font
->mac_fontnum
);
743 TextSize (gc
->font
->mac_fontsize
);
744 TextFace (gc
->font
->mac_fontface
);
748 DrawText (buf
, 0, nchars
* bytes_per_char
);
752 /* Mac replacement for XDrawString. */
755 XDrawString (display
, w
, gc
, x
, y
, buf
, nchars
)
763 mac_draw_string_common (display
, w
, gc
, x
, y
, buf
, nchars
, srcOr
, 1);
767 /* Mac replacement for XDrawString16. */
770 XDrawString16 (display
, w
, gc
, x
, y
, buf
, nchars
)
778 mac_draw_string_common (display
, w
, gc
, x
, y
, (char *) buf
, nchars
, srcOr
,
783 /* Mac replacement for XDrawImageString. */
786 XDrawImageString (display
, w
, gc
, x
, y
, buf
, nchars
)
794 mac_draw_string_common (display
, w
, gc
, x
, y
, buf
, nchars
, srcCopy
, 1);
798 /* Mac replacement for XDrawString16. */
801 XDrawImageString16 (display
, w
, gc
, x
, y
, buf
, nchars
)
809 mac_draw_string_common (display
, w
, gc
, x
, y
, (char *) buf
, nchars
, srcCopy
,
814 /* Mac replacement for XCopyArea: dest must be window. */
817 mac_copy_area (display
, src
, dest
, gc
, src_x
, src_y
, width
, height
, dest_x
,
824 unsigned int width
, height
;
832 SetRect (&src_r
, src_x
, src_y
, src_x
+ width
, src_y
+ height
);
833 SetRect (&dest_r
, dest_x
, dest_y
, dest_x
+ width
, dest_y
+ height
);
835 CopyBits ((BitMap
*) src
, &(dest
->portBits
), &src_r
, &dest_r
, srcCopy
, 0);
839 /* Convert a pair of local coordinates to global (screen) coordinates.
840 Assume graphic port has been properly set. */
842 local_to_global_coord (short *h
, short *v
)
856 /* Mac replacement for XCopyArea: used only for scrolling. */
859 mac_scroll_area (display
, w
, gc
, src_x
, src_y
, width
, height
, dest_x
, dest_y
)
864 unsigned int width
, height
;
872 SetRect (&src_r
, src_x
, src_y
, src_x
+ width
, src_y
+ height
);
873 SetRect (&dest_r
, dest_x
, dest_y
, dest_x
+ width
, dest_y
+ height
);
875 /* Need to use global coordinates and screenBits since src and dest
876 areas overlap in general. */
877 local_to_global_coord (&src_r
.left
, &src_r
.top
);
878 local_to_global_coord (&src_r
.right
, &src_r
.bottom
);
879 local_to_global_coord (&dest_r
.left
, &dest_r
.top
);
880 local_to_global_coord (&dest_r
.right
, &dest_r
.bottom
);
882 CopyBits (&qd
.screenBits
, &qd
.screenBits
, &src_r
, &dest_r
, srcCopy
, 0);
886 /* Mac replacement for XCopyArea: dest must be Pixmap. */
889 mac_copy_area_to_pixmap (display
, src
, dest
, gc
, src_x
, src_y
, width
, height
,
896 unsigned int width
, height
;
900 int src_right
= ((PixMap
*) src
)->bounds
.right
;
901 int src_bottom
= ((PixMap
*) src
)->bounds
.bottom
;
902 int w
= src_right
- src_x
;
903 int h
= src_bottom
- src_y
;
907 SetRect (&src_r
, src_x
, src_y
, src_right
, src_bottom
);
908 SetRect (&dest_r
, dest_x
, dest_y
, dest_x
+ w
, dest_y
+ h
);
910 CopyBits ((BitMap
*) src
, (BitMap
*) dest
, &src_r
, &dest_r
, srcCopy
, 0);
914 /* Mac replacement for XChangeGC. */
917 XChangeGC (void * ignore
, XGCValues
* gc
, unsigned long mask
,
920 if (mask
& GCForeground
)
921 gc
->foreground
= xgcv
->foreground
;
922 if (mask
& GCBackground
)
923 gc
->background
= xgcv
->background
;
925 gc
->font
= xgcv
->font
;
929 /* Mac replacement for XCreateGC. */
932 XCreateGC (void * ignore
, Window window
, unsigned long mask
,
935 XGCValues
*gc
= (XGCValues
*) xmalloc (sizeof (XGCValues
));
936 bzero (gc
, sizeof (XGCValues
));
938 XChangeGC (ignore
, gc
, mask
, xgcv
);
944 /* Used in xfaces.c. */
947 XFreeGC (display
, gc
)
955 /* Mac replacement for XGetGCValues. */
958 XGetGCValues (void* ignore
, XGCValues
*gc
,
959 unsigned long mask
, XGCValues
*xgcv
)
961 XChangeGC (ignore
, xgcv
, mask
, gc
);
965 /* Mac replacement for XSetForeground. */
968 XSetForeground (display
, gc
, color
)
973 gc
->foreground
= color
;
977 /* Mac replacement for XSetFont. */
980 XSetFont (display
, gc
, font
)
990 XTextExtents16 (XFontStruct
*font
, XChar2b
*text
, int nchars
,
991 int *direction
,int *font_ascent
,
992 int *font_descent
, XCharStruct
*cs
)
994 /* MAC_TODO: Use GetTextMetrics to do this and inline it below. */
998 /* x_sync is a no-op on Mac. */
1006 /* Flush display of frame F, or of all frames if F is null. */
1012 #if 0 /* Nothing to do for Mac OS (needed in OS X perhaps?). */
1016 Lisp_Object rest
, frame
;
1017 FOR_EACH_FRAME (rest
, frame
)
1018 x_flush (XFRAME (frame
));
1020 else if (FRAME_X_P (f
))
1021 XFlush (FRAME_MAC_DISPLAY (f
));
1027 /* Remove calls to XFlush by defining XFlush to an empty replacement.
1028 Calls to XFlush should be unnecessary because the X output buffer
1029 is flushed automatically as needed by calls to XPending,
1030 XNextEvent, or XWindowEvent according to the XFlush man page.
1031 XTread_socket calls XPending. Removing XFlush improves
1034 #define XFlush(DISPLAY) (void) 0
1037 /* Return the struct mac_display_info corresponding to DPY. There's
1040 struct mac_display_info
*
1041 mac_display_info_for_display (dpy
)
1044 return &one_mac_display_info
;
1049 /***********************************************************************
1050 Starting and ending an update
1051 ***********************************************************************/
1053 /* Start an update of frame F. This function is installed as a hook
1054 for update_begin, i.e. it is called when update_begin is called.
1055 This function is called prior to calls to x_update_window_begin for
1056 each window being updated. Currently, there is nothing to do here
1057 because all interesting stuff is done on a window basis. */
1063 /* Nothing to do. */
1067 /* Start update of window W. Set the global variable updated_window
1068 to the window being updated and set output_cursor to the cursor
1072 x_update_window_begin (w
)
1075 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1076 struct mac_display_info
*display_info
= FRAME_MAC_DISPLAY_INFO (f
);
1079 set_output_cursor (&w
->cursor
);
1083 if (f
== display_info
->mouse_face_mouse_frame
)
1085 /* Don't do highlighting for mouse motion during the update. */
1086 display_info
->mouse_face_defer
= 1;
1088 /* If F needs to be redrawn, simply forget about any prior mouse
1090 if (FRAME_GARBAGED_P (f
))
1091 display_info
->mouse_face_window
= Qnil
;
1093 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
1094 their mouse_face_p flag set, which means that they are always
1095 unequal to rows in a desired matrix which never have that
1096 flag set. So, rows containing mouse-face glyphs are never
1097 scrolled, and we don't have to switch the mouse highlight off
1098 here to prevent it from being scrolled. */
1100 /* Can we tell that this update does not affect the window
1101 where the mouse highlight is? If so, no need to turn off.
1102 Likewise, don't do anything if the frame is garbaged;
1103 in that case, the frame's current matrix that we would use
1104 is all wrong, and we will redisplay that line anyway. */
1105 if (!NILP (display_info
->mouse_face_window
)
1106 && w
== XWINDOW (display_info
->mouse_face_window
))
1110 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
1111 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
1114 if (i
< w
->desired_matrix
->nrows
)
1115 clear_mouse_face (display_info
);
1124 /* Draw a vertical window border to the right of window W if W doesn't
1125 have vertical scroll bars. */
1128 x_draw_vertical_border (w
)
1131 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1133 /* Redraw borders between horizontally adjacent windows. Don't
1134 do it for frames with vertical scroll bars because either the
1135 right scroll bar of a window, or the left scroll bar of its
1136 neighbor will suffice as a border. */
1137 if (!WINDOW_RIGHTMOST_P (w
)
1138 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
1142 window_box_edges (w
, -1, &x0
, &y0
, &x1
, &y1
);
1143 x1
+= FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
);
1146 XDrawLine (FRAME_MAC_DISPLAY (f
), FRAME_MAC_WINDOW (f
),
1147 f
->output_data
.mac
->normal_gc
, x1
, y0
, x1
, y1
);
1152 /* End update of window W (which is equal to updated_window).
1154 Draw vertical borders between horizontally adjacent windows, and
1155 display W's cursor if CURSOR_ON_P is non-zero.
1157 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
1158 glyphs in mouse-face were overwritten. In that case we have to
1159 make sure that the mouse-highlight is properly redrawn.
1161 W may be a menu bar pseudo-window in case we don't have X toolkit
1162 support. Such windows don't have a cursor, so don't display it
1166 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
1168 int cursor_on_p
, mouse_face_overwritten_p
;
1170 if (!w
->pseudo_window_p
)
1172 struct mac_display_info
*dpyinfo
1173 = FRAME_MAC_DISPLAY_INFO (XFRAME (w
->frame
));
1177 /* If a row with mouse-face was overwritten, arrange for
1178 XTframe_up_to_date to redisplay the mouse highlight. */
1179 if (mouse_face_overwritten_p
)
1181 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
1182 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
1183 dpyinfo
->mouse_face_window
= Qnil
;
1187 x_display_and_set_cursor (w
, 1, output_cursor
.hpos
,
1189 output_cursor
.x
, output_cursor
.y
);
1191 x_draw_vertical_border (w
);
1195 updated_window
= NULL
;
1199 /* End update of frame F. This function is installed as a hook in
1206 /* Reset the background color of Mac OS Window to that of the frame after
1207 update so that it is used by Mac Toolbox to clear the update region before
1208 an update event is generated. */
1209 SetPort (FRAME_MAC_WINDOW (f
));
1210 mac_set_backcolor (FRAME_BACKGROUND_PIXEL (f
));
1212 /* Mouse highlight may be displayed again. */
1213 FRAME_MAC_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
1216 XFlush (FRAME_MAC_DISPLAY (f
));
1221 /* This function is called from various places in xdisp.c whenever a
1222 complete update has been performed. The global variable
1223 updated_window is not available here. */
1226 XTframe_up_to_date (f
)
1231 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
1233 if (dpyinfo
->mouse_face_deferred_gc
1234 || f
== dpyinfo
->mouse_face_mouse_frame
)
1237 if (dpyinfo
->mouse_face_mouse_frame
)
1238 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
1239 dpyinfo
->mouse_face_mouse_x
,
1240 dpyinfo
->mouse_face_mouse_y
);
1241 dpyinfo
->mouse_face_deferred_gc
= 0;
1248 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
1249 arrow bitmaps, or clear the areas where they would be displayed
1250 before DESIRED_ROW is made current. The window being updated is
1251 found in updated_window. This function It is called from
1252 update_window_line only if it is known that there are differences
1253 between bitmaps to be drawn between current row and DESIRED_ROW. */
1256 x_after_update_window_line (desired_row
)
1257 struct glyph_row
*desired_row
;
1259 struct window
*w
= updated_window
;
1263 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
1266 x_draw_row_bitmaps (w
, desired_row
);
1268 /* When a window has disappeared, make sure that no rest of
1269 full-width rows stays visible in the internal border. */
1270 if (windows_or_buffers_changed
)
1272 struct frame
*f
= XFRAME (w
->frame
);
1273 int width
= FRAME_INTERNAL_BORDER_WIDTH (f
);
1274 int height
= desired_row
->visible_height
;
1275 int x
= (window_box_right (w
, -1)
1276 + FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
));
1277 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
1279 XClearArea (FRAME_MAC_DISPLAY (f
), FRAME_MAC_WINDOW (f
),
1280 x
, y
, width
, height
, 0);
1288 /* Draw the bitmap WHICH in one of the areas to the left or right of
1289 window W. ROW is the glyph row for which to display the bitmap; it
1290 determines the vertical position at which the bitmap has to be
1294 x_draw_bitmap (w
, row
, which
)
1296 struct glyph_row
*row
;
1297 enum bitmap_type which
;
1299 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1300 Display
*display
= FRAME_MAC_DISPLAY (f
);
1301 WindowPtr window
= FRAME_MAC_WINDOW (f
);
1302 int x
, y
, wd
, h
, dy
;
1303 unsigned char *bits
;
1308 /* Must clip because of partially visible lines. */
1309 x_clip_to_row (w
, row
, 1);
1313 case LEFT_TRUNCATION_BITMAP
:
1317 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
1319 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
1322 case OVERLAY_ARROW_BITMAP
:
1326 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
1328 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
1331 case RIGHT_TRUNCATION_BITMAP
:
1335 x
= window_box_right (w
, -1);
1336 x
+= (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
) - wd
) / 2;
1339 case CONTINUED_LINE_BITMAP
:
1342 bits
= continued_bits
;
1343 x
= window_box_right (w
, -1);
1344 x
+= (FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
) - wd
) / 2;
1347 case CONTINUATION_LINE_BITMAP
:
1348 wd
= continuation_width
;
1349 h
= continuation_height
;
1350 bits
= continuation_bits
;
1351 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
1353 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
1356 case ZV_LINE_BITMAP
:
1360 x
= (WINDOW_TO_FRAME_PIXEL_X (w
, 0)
1362 - (FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - wd
) / 2);
1369 /* Convert to frame coordinates. Set dy to the offset in the row to
1370 start drawing the bitmap. */
1371 y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
1372 dy
= (row
->height
- h
) / 2;
1374 /* Draw the bitmap. I believe these small pixmaps can be cached
1376 face
= FACE_FROM_ID (f
, BITMAP_AREA_FACE_ID
);
1378 mac_create_bitmap_from_bitmap_data (&bitmap
, bits
, wd
, h
);
1379 gcv
.foreground
= face
->foreground
;
1380 gcv
.background
= face
->background
;
1382 mac_draw_bitmap (display
, window
, &gcv
, x
, y
+ dy
, &bitmap
);
1384 mac_free_bitmap (&bitmap
);
1385 mac_reset_clipping (display
, window
);
1389 /* Draw flags bitmaps for glyph row ROW on window W. Call this
1390 function with input blocked. */
1393 x_draw_row_bitmaps (w
, row
)
1395 struct glyph_row
*row
;
1397 struct frame
*f
= XFRAME (w
->frame
);
1398 enum bitmap_type bitmap
;
1400 int header_line_height
= -1;
1402 xassert (interrupt_input_blocked
);
1404 /* If row is completely invisible, because of vscrolling, we
1405 don't have to draw anything. */
1406 if (row
->visible_height
<= 0)
1409 face
= FACE_FROM_ID (f
, BITMAP_AREA_FACE_ID
);
1410 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1412 /* Decide which bitmap to draw at the left side. */
1413 if (row
->overlay_arrow_p
)
1414 bitmap
= OVERLAY_ARROW_BITMAP
;
1415 else if (row
->truncated_on_left_p
)
1416 bitmap
= LEFT_TRUNCATION_BITMAP
;
1417 else if (MATRIX_ROW_CONTINUATION_LINE_P (row
))
1418 bitmap
= CONTINUATION_LINE_BITMAP
;
1419 else if (row
->indicate_empty_line_p
)
1420 bitmap
= ZV_LINE_BITMAP
;
1424 /* Clear flags area if no bitmap to draw or if bitmap doesn't fill
1426 if (bitmap
== NO_BITMAP
1427 || FRAME_FLAGS_BITMAP_WIDTH (f
) < FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
)
1428 || row
->height
> FRAME_FLAGS_BITMAP_HEIGHT (f
))
1430 /* If W has a vertical border to its left, don't draw over it. */
1431 int border
= ((XFASTINT (w
->left
) > 0
1432 && !FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
1434 int left
= window_box_left (w
, -1);
1436 if (header_line_height
< 0)
1437 header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
1439 #if 0 /* MAC_TODO: stipple */
1440 /* In case the same realized face is used for bitmap areas and
1441 for something displayed in the text (e.g. face `region' on
1442 mono-displays, the fill style may have been changed to
1443 FillSolid in x_draw_glyph_string_background. */
1445 XSetFillStyle (FRAME_X_DISPLAY (f
), face
->gc
, FillOpaqueStippled
);
1447 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->background
);
1449 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1452 - FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
)
1454 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
1456 FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - border
,
1457 row
->visible_height
);
1459 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->foreground
);
1463 gcv
.foreground
= face
->background
;
1464 XFillRectangle (FRAME_MAC_DISPLAY (f
), FRAME_MAC_WINDOW (f
),
1467 - FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
)
1469 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
1471 FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
) - border
,
1472 row
->visible_height
);
1477 /* Draw the left bitmap. */
1478 if (bitmap
!= NO_BITMAP
)
1479 x_draw_bitmap (w
, row
, bitmap
);
1481 /* Decide which bitmap to draw at the right side. */
1482 if (row
->truncated_on_right_p
)
1483 bitmap
= RIGHT_TRUNCATION_BITMAP
;
1484 else if (row
->continued_p
)
1485 bitmap
= CONTINUED_LINE_BITMAP
;
1489 /* Clear flags area if no bitmap to draw of if bitmap doesn't fill
1491 if (bitmap
== NO_BITMAP
1492 || FRAME_FLAGS_BITMAP_WIDTH (f
) < FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
)
1493 || row
->height
> FRAME_FLAGS_BITMAP_HEIGHT (f
))
1495 int right
= window_box_right (w
, -1);
1497 if (header_line_height
< 0)
1498 header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
1500 #if 0 /* MAC_TODO: stipple */
1501 /* In case the same realized face is used for bitmap areas and
1502 for something displayed in the text (e.g. face `region' on
1503 mono-displays, the fill style may have been changed to
1504 FillSolid in x_draw_glyph_string_background. */
1506 XSetFillStyle (FRAME_X_DISPLAY (f
), face
->gc
, FillOpaqueStippled
);
1508 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->background
);
1509 XFillRectangle (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1512 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
1514 FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
),
1515 row
->visible_height
);
1517 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->foreground
);
1521 gcv
.foreground
= face
->background
;
1522 XFillRectangle (FRAME_MAC_DISPLAY (f
), FRAME_MAC_WINDOW (f
),
1525 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
1527 FRAME_X_RIGHT_FLAGS_AREA_WIDTH (f
),
1528 row
->visible_height
);
1533 /* Draw the right bitmap. */
1534 if (bitmap
!= NO_BITMAP
)
1535 x_draw_bitmap (w
, row
, bitmap
);
1539 /***********************************************************************
1541 ***********************************************************************/
1543 /* External interface to control of standout mode. Not used for X
1544 frames. Aborts when called. */
1547 XTreassert_line_highlight (new, vpos
)
1554 /* Call this when about to modify line at position VPOS and change
1555 whether it is highlighted. Not used for X frames. Aborts when
1559 x_change_line_highlight (new_highlight
, vpos
, y
, first_unused_hpos
)
1560 int new_highlight
, vpos
, y
, first_unused_hpos
;
1566 /* This is called when starting Emacs and when restarting after
1567 suspend. When starting Emacs, no X window is mapped. And nothing
1568 must be done to Emacs's own window if it is suspended (though that
1572 XTset_terminal_modes ()
1576 /* This is called when exiting or suspending Emacs. Exiting will make
1577 the X-windows go away, and suspending requires no action. */
1580 XTreset_terminal_modes ()
1586 /***********************************************************************
1588 ***********************************************************************/
1590 /* Set the global variable output_cursor to CURSOR. All cursor
1591 positions are relative to updated_window. */
1594 set_output_cursor (cursor
)
1595 struct cursor_pos
*cursor
;
1597 output_cursor
.hpos
= cursor
->hpos
;
1598 output_cursor
.vpos
= cursor
->vpos
;
1599 output_cursor
.x
= cursor
->x
;
1600 output_cursor
.y
= cursor
->y
;
1604 /* Set a nominal cursor position.
1606 HPOS and VPOS are column/row positions in a window glyph matrix. X
1607 and Y are window text area relative pixel positions.
1609 If this is done during an update, updated_window will contain the
1610 window that is being updated and the position is the future output
1611 cursor position for that window. If updated_window is null, use
1612 selected_window and display the cursor at the given position. */
1615 XTcursor_to (vpos
, hpos
, y
, x
)
1616 int vpos
, hpos
, y
, x
;
1620 /* If updated_window is not set, work on selected_window. */
1624 w
= XWINDOW (selected_window
);
1626 /* Set the output cursor. */
1627 output_cursor
.hpos
= hpos
;
1628 output_cursor
.vpos
= vpos
;
1629 output_cursor
.x
= x
;
1630 output_cursor
.y
= y
;
1632 /* If not called as part of an update, really display the cursor.
1633 This will also set the cursor position of W. */
1634 if (updated_window
== NULL
)
1637 x_display_cursor (w
, 1, hpos
, vpos
, x
, y
);
1638 XFlush (FRAME_X_DISPLAY (SELECTED_FRAME ()));
1645 /***********************************************************************
1647 ***********************************************************************/
1649 /* Function prototypes of this page. */
1651 static struct face
*x_get_glyph_face_and_encoding
P_ ((struct frame
*,
1655 static struct face
*x_get_char_face_and_encoding
P_ ((struct frame
*, int,
1656 int, XChar2b
*, int));
1657 static XCharStruct
*x_per_char_metric
P_ ((XFontStruct
*, XChar2b
*));
1658 static void x_encode_char
P_ ((int, XChar2b
*, struct font_info
*));
1659 static void x_append_glyph
P_ ((struct it
*));
1660 static void x_append_composite_glyph
P_ ((struct it
*));
1661 static void x_append_stretch_glyph
P_ ((struct it
*it
, Lisp_Object
,
1663 static void x_produce_glyphs
P_ ((struct it
*));
1664 static void x_produce_image_glyph
P_ ((struct it
*it
));
1667 /* Return a pointer to per-char metric information in FONT of a
1668 character pointed by B which is a pointer to an XChar2b. */
1670 #define PER_CHAR_METRIC(font, b) \
1672 ? ((font)->per_char + (b)->byte2 - (font)->min_char_or_byte2 \
1673 + (((font)->min_byte1 || (font)->max_byte1) \
1674 ? (((b)->byte1 - (font)->min_byte1) \
1675 * ((font)->max_char_or_byte2 - (font)->min_char_or_byte2 + 1)) \
1677 : &((font)->max_bounds))
1680 /* Get metrics of character CHAR2B in FONT. Value is null if CHAR2B
1681 is not contained in the font. */
1683 static INLINE XCharStruct
*
1684 x_per_char_metric (font
, char2b
)
1688 /* The result metric information. */
1689 XCharStruct
*pcm
= NULL
;
1691 xassert (font
&& char2b
);
1693 if (font
->per_char
!= NULL
)
1695 if (font
->min_byte1
== 0 && font
->max_byte1
== 0)
1697 /* min_char_or_byte2 specifies the linear character index
1698 corresponding to the first element of the per_char array,
1699 max_char_or_byte2 is the index of the last character. A
1700 character with non-zero CHAR2B->byte1 is not in the font.
1701 A character with byte2 less than min_char_or_byte2 or
1702 greater max_char_or_byte2 is not in the font. */
1703 if (char2b
->byte1
== 0
1704 && char2b
->byte2
>= font
->min_char_or_byte2
1705 && char2b
->byte2
<= font
->max_char_or_byte2
)
1706 pcm
= font
->per_char
+ char2b
->byte2
- font
->min_char_or_byte2
;
1710 /* If either min_byte1 or max_byte1 are nonzero, both
1711 min_char_or_byte2 and max_char_or_byte2 are less than
1712 256, and the 2-byte character index values corresponding
1713 to the per_char array element N (counting from 0) are:
1715 byte1 = N/D + min_byte1
1716 byte2 = N\D + min_char_or_byte2
1720 D = max_char_or_byte2 - min_char_or_byte2 + 1
1721 / = integer division
1722 \ = integer modulus */
1723 if (char2b
->byte1
>= font
->min_byte1
1724 && char2b
->byte1
<= font
->max_byte1
1725 && char2b
->byte2
>= font
->min_char_or_byte2
1726 && char2b
->byte2
<= font
->max_char_or_byte2
)
1728 pcm
= (font
->per_char
1729 + ((font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1)
1730 * (char2b
->byte1
- font
->min_byte1
))
1731 + (char2b
->byte2
- font
->min_char_or_byte2
));
1737 /* If the per_char pointer is null, all glyphs between the first
1738 and last character indexes inclusive have the same
1739 information, as given by both min_bounds and max_bounds. */
1740 if (char2b
->byte2
>= font
->min_char_or_byte2
1741 && char2b
->byte2
<= font
->max_char_or_byte2
)
1742 pcm
= &font
->max_bounds
;
1745 return ((pcm
== NULL
1746 || (pcm
->width
== 0 && (pcm
->rbearing
- pcm
->lbearing
) == 0))
1751 /* Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
1752 the two-byte form of C. Encoding is returned in *CHAR2B. */
1755 x_encode_char (c
, char2b
, font_info
)
1758 struct font_info
*font_info
;
1760 int charset
= CHAR_CHARSET (c
);
1761 XFontStruct
*font
= font_info
->font
;
1763 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
1764 This may be either a program in a special encoder language or a
1766 if (font_info
->font_encoder
)
1768 /* It's a program. */
1769 struct ccl_program
*ccl
= font_info
->font_encoder
;
1771 if (CHARSET_DIMENSION (charset
) == 1)
1773 ccl
->reg
[0] = charset
;
1774 ccl
->reg
[1] = char2b
->byte2
;
1778 ccl
->reg
[0] = charset
;
1779 ccl
->reg
[1] = char2b
->byte1
;
1780 ccl
->reg
[2] = char2b
->byte2
;
1783 ccl_driver (ccl
, NULL
, NULL
, 0, 0, NULL
);
1785 /* We assume that MSBs are appropriately set/reset by CCL
1787 if (font
->max_byte1
== 0) /* 1-byte font */
1788 char2b
->byte1
= 0, char2b
->byte2
= ccl
->reg
[1];
1790 char2b
->byte1
= ccl
->reg
[1], char2b
->byte2
= ccl
->reg
[2];
1792 else if (font_info
->encoding
[charset
])
1794 /* Fixed encoding scheme. See fontset.h for the meaning of the
1795 encoding numbers. */
1796 int enc
= font_info
->encoding
[charset
];
1798 if ((enc
== 1 || enc
== 2)
1799 && CHARSET_DIMENSION (charset
) == 2)
1800 char2b
->byte1
|= 0x80;
1802 if (enc
== 1 || enc
== 3)
1803 char2b
->byte2
|= 0x80;
1809 ENCODE_SJIS (char2b
->byte1
, char2b
->byte2
, sjis1
, sjis2
);
1810 char2b
->byte1
= sjis1
;
1811 char2b
->byte2
= sjis2
;
1817 /* Get face and two-byte form of character C in face FACE_ID on frame
1818 F. The encoding of C is returned in *CHAR2B. MULTIBYTE_P non-zero
1819 means we want to display multibyte text. Value is a pointer to a
1820 realized face that is ready for display. */
1822 static INLINE
struct face
*
1823 x_get_char_face_and_encoding (f
, c
, face_id
, char2b
, multibyte_p
)
1829 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1833 /* Unibyte case. We don't have to encode, but we have to make
1834 sure to use a face suitable for unibyte. */
1837 face_id
= FACE_FOR_CHAR (f
, face
, c
);
1838 face
= FACE_FROM_ID (f
, face_id
);
1840 else if (c
< 128 && face_id
< BASIC_FACE_ID_SENTINEL
)
1842 /* Case of ASCII in a face known to fit ASCII. */
1848 int c1
, c2
, charset
;
1850 /* Split characters into bytes. If c2 is -1 afterwards, C is
1851 really a one-byte character so that byte1 is zero. */
1852 SPLIT_CHAR (c
, charset
, c1
, c2
);
1854 char2b
->byte1
= c1
, char2b
->byte2
= c2
;
1856 char2b
->byte1
= 0, char2b
->byte2
= c1
;
1858 /* Maybe encode the character in *CHAR2B. */
1859 if (face
->font
!= NULL
)
1861 struct font_info
*font_info
1862 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
1864 x_encode_char (c
, char2b
, font_info
);
1868 /* Make sure X resources of the face are allocated. */
1869 xassert (face
!= NULL
);
1870 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1876 /* Get face and two-byte form of character glyph GLYPH on frame F.
1877 The encoding of GLYPH->u.ch is returned in *CHAR2B. Value is
1878 a pointer to a realized face that is ready for display. */
1880 static INLINE
struct face
*
1881 x_get_glyph_face_and_encoding (f
, glyph
, char2b
, two_byte_p
)
1883 struct glyph
*glyph
;
1889 xassert (glyph
->type
== CHAR_GLYPH
);
1890 face
= FACE_FROM_ID (f
, glyph
->face_id
);
1895 if (!glyph
->multibyte_p
)
1897 /* Unibyte case. We don't have to encode, but we have to make
1898 sure to use a face suitable for unibyte. */
1900 char2b
->byte2
= glyph
->u
.ch
;
1902 else if (glyph
->u
.ch
< 128
1903 && glyph
->face_id
< BASIC_FACE_ID_SENTINEL
)
1905 /* Case of ASCII in a face known to fit ASCII. */
1907 char2b
->byte2
= glyph
->u
.ch
;
1911 int c1
, c2
, charset
;
1913 /* Split characters into bytes. If c2 is -1 afterwards, C is
1914 really a one-byte character so that byte1 is zero. */
1915 SPLIT_CHAR (glyph
->u
.ch
, charset
, c1
, c2
);
1917 char2b
->byte1
= c1
, char2b
->byte2
= c2
;
1919 char2b
->byte1
= 0, char2b
->byte2
= c1
;
1921 /* Maybe encode the character in *CHAR2B. */
1922 if (charset
!= CHARSET_ASCII
)
1924 struct font_info
*font_info
1925 = FONT_INFO_FROM_ID (f
, face
->font_info_id
);
1928 x_encode_char (glyph
->u
.ch
, char2b
, font_info
);
1931 = ((XFontStruct
*) (font_info
->font
))->max_byte1
> 0;
1936 /* Make sure X resources of the face are allocated. */
1937 xassert (face
!= NULL
);
1938 PREPARE_FACE_FOR_DISPLAY (f
, face
);
1943 /* Store one glyph for IT->char_to_display in IT->glyph_row.
1944 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1950 struct glyph
*glyph
;
1951 enum glyph_row_area area
= it
->area
;
1953 xassert (it
->glyph_row
);
1954 xassert (it
->char_to_display
!= '\n' && it
->char_to_display
!= '\t');
1956 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1957 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1959 glyph
->charpos
= CHARPOS (it
->position
);
1960 glyph
->object
= it
->object
;
1961 glyph
->pixel_width
= it
->pixel_width
;
1962 glyph
->voffset
= it
->voffset
;
1963 glyph
->type
= CHAR_GLYPH
;
1964 glyph
->multibyte_p
= it
->multibyte_p
;
1965 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1966 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
1967 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
1968 || it
->phys_descent
> it
->descent
);
1969 glyph
->padding_p
= 0;
1970 glyph
->glyph_not_available_p
= it
->glyph_not_available_p
;
1971 glyph
->face_id
= it
->face_id
;
1972 glyph
->u
.ch
= it
->char_to_display
;
1973 ++it
->glyph_row
->used
[area
];
1977 /* Store one glyph for the composition IT->cmp_id in IT->glyph_row.
1978 Called from x_produce_glyphs when IT->glyph_row is non-null. */
1981 x_append_composite_glyph (it
)
1984 struct glyph
*glyph
;
1985 enum glyph_row_area area
= it
->area
;
1987 xassert (it
->glyph_row
);
1989 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
1990 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
1992 glyph
->charpos
= CHARPOS (it
->position
);
1993 glyph
->object
= it
->object
;
1994 glyph
->pixel_width
= it
->pixel_width
;
1995 glyph
->voffset
= it
->voffset
;
1996 glyph
->type
= COMPOSITE_GLYPH
;
1997 glyph
->multibyte_p
= it
->multibyte_p
;
1998 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
1999 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
2000 glyph
->overlaps_vertically_p
= (it
->phys_ascent
> it
->ascent
2001 || it
->phys_descent
> it
->descent
);
2002 glyph
->padding_p
= 0;
2003 glyph
->glyph_not_available_p
= 0;
2004 glyph
->face_id
= it
->face_id
;
2005 glyph
->u
.cmp_id
= it
->cmp_id
;
2006 ++it
->glyph_row
->used
[area
];
2011 /* Change IT->ascent and IT->height according to the setting of
2015 take_vertical_position_into_account (it
)
2020 if (it
->voffset
< 0)
2021 /* Increase the ascent so that we can display the text higher
2023 it
->ascent
+= abs (it
->voffset
);
2025 /* Increase the descent so that we can display the text lower
2027 it
->descent
+= it
->voffset
;
2032 /* Produce glyphs/get display metrics for the image IT is loaded with.
2033 See the description of struct display_iterator in dispextern.h for
2034 an overview of struct display_iterator. */
2037 x_produce_image_glyph (it
)
2043 xassert (it
->what
== IT_IMAGE
);
2045 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2046 img
= IMAGE_FROM_ID (it
->f
, it
->image_id
);
2049 /* Make sure X resources of the face and image are loaded. */
2050 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
2051 prepare_image_for_display (it
->f
, img
);
2053 it
->ascent
= it
->phys_ascent
= image_ascent (img
, face
);
2054 it
->descent
= it
->phys_descent
= img
->height
+ 2 * img
->margin
- it
->ascent
;
2055 it
->pixel_width
= img
->width
+ 2 * img
->margin
;
2059 if (face
->box
!= FACE_NO_BOX
)
2061 it
->ascent
+= face
->box_line_width
;
2062 it
->descent
+= face
->box_line_width
;
2064 if (it
->start_of_box_run_p
)
2065 it
->pixel_width
+= face
->box_line_width
;
2066 if (it
->end_of_box_run_p
)
2067 it
->pixel_width
+= face
->box_line_width
;
2070 take_vertical_position_into_account (it
);
2074 struct glyph
*glyph
;
2075 enum glyph_row_area area
= it
->area
;
2077 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
2078 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
2080 glyph
->charpos
= CHARPOS (it
->position
);
2081 glyph
->object
= it
->object
;
2082 glyph
->pixel_width
= it
->pixel_width
;
2083 glyph
->voffset
= it
->voffset
;
2084 glyph
->type
= IMAGE_GLYPH
;
2085 glyph
->multibyte_p
= it
->multibyte_p
;
2086 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
2087 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
2088 glyph
->overlaps_vertically_p
= 0;
2089 glyph
->padding_p
= 0;
2090 glyph
->glyph_not_available_p
= 0;
2091 glyph
->face_id
= it
->face_id
;
2092 glyph
->u
.img_id
= img
->id
;
2093 ++it
->glyph_row
->used
[area
];
2099 /* Append a stretch glyph to IT->glyph_row. OBJECT is the source
2100 of the glyph, WIDTH and HEIGHT are the width and height of the
2101 stretch. ASCENT is the percentage/100 of HEIGHT to use for the
2102 ascent of the glyph (0 <= ASCENT <= 1). */
2105 x_append_stretch_glyph (it
, object
, width
, height
, ascent
)
2111 struct glyph
*glyph
;
2112 enum glyph_row_area area
= it
->area
;
2114 xassert (ascent
>= 0 && ascent
<= 1);
2116 glyph
= it
->glyph_row
->glyphs
[area
] + it
->glyph_row
->used
[area
];
2117 if (glyph
< it
->glyph_row
->glyphs
[area
+ 1])
2119 glyph
->charpos
= CHARPOS (it
->position
);
2120 glyph
->object
= object
;
2121 glyph
->pixel_width
= width
;
2122 glyph
->voffset
= it
->voffset
;
2123 glyph
->type
= STRETCH_GLYPH
;
2124 glyph
->multibyte_p
= it
->multibyte_p
;
2125 glyph
->left_box_line_p
= it
->start_of_box_run_p
;
2126 glyph
->right_box_line_p
= it
->end_of_box_run_p
;
2127 glyph
->overlaps_vertically_p
= 0;
2128 glyph
->padding_p
= 0;
2129 glyph
->glyph_not_available_p
= 0;
2130 glyph
->face_id
= it
->face_id
;
2131 glyph
->u
.stretch
.ascent
= height
* ascent
;
2132 glyph
->u
.stretch
.height
= height
;
2133 ++it
->glyph_row
->used
[area
];
2138 /* Produce a stretch glyph for iterator IT. IT->object is the value
2139 of the glyph property displayed. The value must be a list
2140 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
2143 1. `:width WIDTH' specifies that the space should be WIDTH *
2144 canonical char width wide. WIDTH may be an integer or floating
2147 2. `:relative-width FACTOR' specifies that the width of the stretch
2148 should be computed from the width of the first character having the
2149 `glyph' property, and should be FACTOR times that width.
2151 3. `:align-to HPOS' specifies that the space should be wide enough
2152 to reach HPOS, a value in canonical character units.
2154 Exactly one of the above pairs must be present.
2156 4. `:height HEIGHT' specifies that the height of the stretch produced
2157 should be HEIGHT, measured in canonical character units.
2159 5. `:relative-height FACTOR' specifies that the height of the the
2160 stretch should be FACTOR times the height of the characters having
2163 Either none or exactly one of 4 or 5 must be present.
2165 6. `:ascent ASCENT' specifies that ASCENT percent of the height
2166 of the stretch should be used for the ascent of the stretch.
2167 ASCENT must be in the range 0 <= ASCENT <= 100. */
2170 ((INTEGERP (X) || FLOATP (X)) \
2176 x_produce_stretch_glyph (it
)
2179 /* (space :width WIDTH :height HEIGHT. */
2181 extern Lisp_Object Qspace
;
2183 extern Lisp_Object QCwidth
, QCheight
, QCascent
;
2184 extern Lisp_Object QCrelative_width
, QCrelative_height
;
2185 extern Lisp_Object QCalign_to
;
2186 Lisp_Object prop
, plist
;
2187 double width
= 0, height
= 0, ascent
= 0;
2188 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2189 XFontStruct
*font
= face
->font
? face
->font
: FRAME_FONT (it
->f
);
2191 PREPARE_FACE_FOR_DISPLAY (it
->f
, face
);
2193 /* List should start with `space'. */
2194 xassert (CONSP (it
->object
) && EQ (XCAR (it
->object
), Qspace
));
2195 plist
= XCDR (it
->object
);
2197 /* Compute the width of the stretch. */
2198 if (prop
= Fplist_get (plist
, QCwidth
),
2200 /* Absolute width `:width WIDTH' specified and valid. */
2201 width
= NUMVAL (prop
) * CANON_X_UNIT (it
->f
);
2202 else if (prop
= Fplist_get (plist
, QCrelative_width
),
2205 /* Relative width `:relative-width FACTOR' specified and valid.
2206 Compute the width of the characters having the `glyph'
2209 unsigned char *p
= BYTE_POS_ADDR (IT_BYTEPOS (*it
));
2212 if (it
->multibyte_p
)
2214 int maxlen
= ((IT_BYTEPOS (*it
) >= GPT
? ZV
: GPT
)
2215 - IT_BYTEPOS (*it
));
2216 it2
.c
= STRING_CHAR_AND_LENGTH (p
, maxlen
, it2
.len
);
2219 it2
.c
= *p
, it2
.len
= 1;
2221 it2
.glyph_row
= NULL
;
2222 it2
.what
= IT_CHARACTER
;
2223 x_produce_glyphs (&it2
);
2224 width
= NUMVAL (prop
) * it2
.pixel_width
;
2226 else if (prop
= Fplist_get (plist
, QCalign_to
),
2228 width
= NUMVAL (prop
) * CANON_X_UNIT (it
->f
) - it
->current_x
;
2230 /* Nothing specified -> width defaults to canonical char width. */
2231 width
= CANON_X_UNIT (it
->f
);
2233 /* Compute height. */
2234 if (prop
= Fplist_get (plist
, QCheight
),
2236 height
= NUMVAL (prop
) * CANON_Y_UNIT (it
->f
);
2237 else if (prop
= Fplist_get (plist
, QCrelative_height
),
2239 height
= FONT_HEIGHT (font
) * NUMVAL (prop
);
2241 height
= FONT_HEIGHT (font
);
2243 /* Compute percentage of height used for ascent. If
2244 `:ascent ASCENT' is present and valid, use that. Otherwise,
2245 derive the ascent from the font in use. */
2246 if (prop
= Fplist_get (plist
, QCascent
),
2247 NUMVAL (prop
) > 0 && NUMVAL (prop
) <= 100)
2248 ascent
= NUMVAL (prop
) / 100.0;
2250 ascent
= (double) font
->ascent
/ FONT_HEIGHT (font
);
2259 Lisp_Object object
= it
->stack
[it
->sp
- 1].string
;
2260 if (!STRINGP (object
))
2261 object
= it
->w
->buffer
;
2262 x_append_stretch_glyph (it
, object
, width
, height
, ascent
);
2265 it
->pixel_width
= width
;
2266 it
->ascent
= it
->phys_ascent
= height
* ascent
;
2267 it
->descent
= it
->phys_descent
= height
- it
->ascent
;
2270 if (face
->box
!= FACE_NO_BOX
)
2272 it
->ascent
+= face
->box_line_width
;
2273 it
->descent
+= face
->box_line_width
;
2275 if (it
->start_of_box_run_p
)
2276 it
->pixel_width
+= face
->box_line_width
;
2277 if (it
->end_of_box_run_p
)
2278 it
->pixel_width
+= face
->box_line_width
;
2281 take_vertical_position_into_account (it
);
2284 /* Return proper value to be used as baseline offset of font that has
2285 ASCENT and DESCENT to draw characters by the font at the vertical
2286 center of the line of frame F.
2288 Here, out task is to find the value of BOFF in the following figure;
2290 -------------------------+-----------+-
2291 -+-+---------+-+ | |
2293 | | | | F_ASCENT F_HEIGHT
2296 | | |-|-+------+-----------|------- baseline
2298 | |---------|-+-+ | |
2300 -+-+---------+-+ F_DESCENT |
2301 -------------------------+-----------+-
2303 -BOFF + DESCENT + (F_HEIGHT - HEIGHT) / 2 = F_DESCENT
2304 BOFF = DESCENT + (F_HEIGHT - HEIGHT) / 2 - F_DESCENT
2305 DESCENT = FONT->descent
2306 HEIGHT = FONT_HEIGHT (FONT)
2307 F_DESCENT = (F->output_data.x->font->descent
2308 - F->output_data.x->baseline_offset)
2309 F_HEIGHT = FRAME_LINE_HEIGHT (F)
2312 #define VCENTER_BASELINE_OFFSET(FONT, F) \
2314 + (FRAME_LINE_HEIGHT ((F)) - FONT_HEIGHT ((FONT))) / 2 \
2315 - ((F)->output_data.mac->font->descent - (F)->output_data.mac->baseline_offset))
2317 /* Produce glyphs/get display metrics for the display element IT is
2318 loaded with. See the description of struct display_iterator in
2319 dispextern.h for an overview of struct display_iterator. */
2322 x_produce_glyphs (it
)
2325 it
->glyph_not_available_p
= 0;
2327 if (it
->what
== IT_CHARACTER
)
2331 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2333 int font_not_found_p
;
2334 struct font_info
*font_info
;
2335 int boff
; /* baseline offset */
2337 /* Maybe translate single-byte characters to multibyte, or the
2339 it
->char_to_display
= it
->c
;
2340 if (!ASCII_BYTE_P (it
->c
))
2342 if (unibyte_display_via_language_environment
2343 && SINGLE_BYTE_CHAR_P (it
->c
)
2345 || !NILP (Vnonascii_translation_table
)))
2347 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
2348 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
2349 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2351 else if (!SINGLE_BYTE_CHAR_P (it
->c
)
2352 && !it
->multibyte_p
)
2354 it
->char_to_display
= multibyte_char_to_unibyte (it
->c
, Qnil
);
2355 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
2356 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2360 /* Get font to use. Encode IT->char_to_display. */
2361 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
2362 it
->face_id
, &char2b
,
2366 /* When no suitable font found, use the default font. */
2367 font_not_found_p
= font
== NULL
;
2368 if (font_not_found_p
)
2370 font
= FRAME_FONT (it
->f
);
2371 boff
= it
->f
->output_data
.mac
->baseline_offset
;
2376 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2377 boff
= font_info
->baseline_offset
;
2378 if (font_info
->vertical_centering
)
2379 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2382 if (it
->char_to_display
>= ' '
2383 && (!it
->multibyte_p
|| it
->char_to_display
< 128))
2385 /* Either unibyte or ASCII. */
2390 pcm
= x_per_char_metric (font
, &char2b
);
2391 it
->ascent
= font
->ascent
+ boff
;
2392 it
->descent
= font
->descent
- boff
;
2396 it
->phys_ascent
= pcm
->ascent
+ boff
;
2397 it
->phys_descent
= pcm
->descent
- boff
;
2398 it
->pixel_width
= pcm
->width
;
2402 it
->glyph_not_available_p
= 1;
2403 it
->phys_ascent
= font
->ascent
+ boff
;
2404 it
->phys_descent
= font
->descent
- boff
;
2405 it
->pixel_width
= FONT_WIDTH (font
);
2408 /* If this is a space inside a region of text with
2409 `space-width' property, change its width. */
2410 stretched_p
= it
->char_to_display
== ' ' && !NILP (it
->space_width
);
2412 it
->pixel_width
*= XFLOATINT (it
->space_width
);
2414 /* If face has a box, add the box thickness to the character
2415 height. If character has a box line to the left and/or
2416 right, add the box line width to the character's width. */
2417 if (face
->box
!= FACE_NO_BOX
)
2419 int thick
= face
->box_line_width
;
2421 it
->ascent
+= thick
;
2422 it
->descent
+= thick
;
2424 if (it
->start_of_box_run_p
)
2425 it
->pixel_width
+= thick
;
2426 if (it
->end_of_box_run_p
)
2427 it
->pixel_width
+= thick
;
2430 /* If face has an overline, add the height of the overline
2431 (1 pixel) and a 1 pixel margin to the character height. */
2432 if (face
->overline_p
)
2435 take_vertical_position_into_account (it
);
2437 /* If we have to actually produce glyphs, do it. */
2442 /* Translate a space with a `space-width' property
2443 into a stretch glyph. */
2444 double ascent
= (double) font
->ascent
/ FONT_HEIGHT (font
);
2445 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
2446 it
->ascent
+ it
->descent
, ascent
);
2449 x_append_glyph (it
);
2451 /* If characters with lbearing or rbearing are displayed
2452 in this line, record that fact in a flag of the
2453 glyph row. This is used to optimize X output code. */
2454 if (pcm
&& (pcm
->lbearing
< 0 || pcm
->rbearing
> pcm
->width
))
2455 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
2458 else if (it
->char_to_display
== '\n')
2460 /* A newline has no width but we need the height of the line. */
2461 it
->pixel_width
= 0;
2463 it
->ascent
= it
->phys_ascent
= font
->ascent
+ boff
;
2464 it
->descent
= it
->phys_descent
= font
->descent
- boff
;
2466 if (face
->box
!= FACE_NO_BOX
)
2468 int thick
= face
->box_line_width
;
2469 it
->ascent
+= thick
;
2470 it
->descent
+= thick
;
2473 else if (it
->char_to_display
== '\t')
2475 int tab_width
= it
->tab_width
* CANON_X_UNIT (it
->f
);
2476 int x
= it
->current_x
+ it
->continuation_lines_width
;
2477 int next_tab_x
= ((1 + x
+ tab_width
- 1) / tab_width
) * tab_width
;
2479 it
->pixel_width
= next_tab_x
- x
;
2481 it
->ascent
= it
->phys_ascent
= font
->ascent
+ boff
;
2482 it
->descent
= it
->phys_descent
= font
->descent
- boff
;
2486 double ascent
= (double) it
->ascent
/ (it
->ascent
+ it
->descent
);
2487 x_append_stretch_glyph (it
, it
->object
, it
->pixel_width
,
2488 it
->ascent
+ it
->descent
, ascent
);
2493 /* A multi-byte character. Assume that the display width of the
2494 character is the width of the character multiplied by the
2495 width of the font. */
2497 /* If we found a font, this font should give us the right
2498 metrics. If we didn't find a font, use the frame's
2499 default font and calculate the width of the character
2500 from the charset width; this is what old redisplay code
2502 pcm
= x_per_char_metric (font
, &char2b
);
2503 if (font_not_found_p
|| !pcm
)
2505 int charset
= CHAR_CHARSET (it
->char_to_display
);
2507 it
->glyph_not_available_p
= 1;
2508 it
->pixel_width
= (FONT_WIDTH (FRAME_FONT (it
->f
))
2509 * CHARSET_WIDTH (charset
));
2510 it
->phys_ascent
= font
->ascent
+ boff
;
2511 it
->phys_descent
= font
->descent
- boff
;
2515 it
->pixel_width
= pcm
->width
;
2516 it
->phys_ascent
= pcm
->ascent
+ boff
;
2517 it
->phys_descent
= pcm
->descent
- boff
;
2519 && (pcm
->lbearing
< 0
2520 || pcm
->rbearing
> pcm
->width
))
2521 it
->glyph_row
->contains_overlapping_glyphs_p
= 1;
2524 it
->ascent
= font
->ascent
+ boff
;
2525 it
->descent
= font
->descent
- boff
;
2526 if (face
->box
!= FACE_NO_BOX
)
2528 int thick
= face
->box_line_width
;
2529 it
->ascent
+= thick
;
2530 it
->descent
+= thick
;
2532 if (it
->start_of_box_run_p
)
2533 it
->pixel_width
+= thick
;
2534 if (it
->end_of_box_run_p
)
2535 it
->pixel_width
+= thick
;
2538 /* If face has an overline, add the height of the overline
2539 (1 pixel) and a 1 pixel margin to the character height. */
2540 if (face
->overline_p
)
2543 take_vertical_position_into_account (it
);
2546 x_append_glyph (it
);
2549 else if (it
->what
== IT_COMPOSITION
)
2551 /* Note: A composition is represented as one glyph in the
2552 glyph matrix. There are no padding glyphs. */
2555 struct face
*face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2557 int font_not_found_p
;
2558 struct font_info
*font_info
;
2559 int boff
; /* baseline offset */
2560 struct composition
*cmp
= composition_table
[it
->cmp_id
];
2562 /* Maybe translate single-byte characters to multibyte. */
2563 it
->char_to_display
= it
->c
;
2564 if (unibyte_display_via_language_environment
2565 && SINGLE_BYTE_CHAR_P (it
->c
)
2568 && !NILP (Vnonascii_translation_table
))))
2570 it
->char_to_display
= unibyte_char_to_multibyte (it
->c
);
2573 /* Get face and font to use. Encode IT->char_to_display. */
2574 it
->face_id
= FACE_FOR_CHAR (it
->f
, face
, it
->char_to_display
);
2575 face
= FACE_FROM_ID (it
->f
, it
->face_id
);
2576 x_get_char_face_and_encoding (it
->f
, it
->char_to_display
,
2577 it
->face_id
, &char2b
, it
->multibyte_p
);
2580 /* When no suitable font found, use the default font. */
2581 font_not_found_p
= font
== NULL
;
2582 if (font_not_found_p
)
2584 font
= FRAME_FONT (it
->f
);
2585 boff
= it
->f
->output_data
.mac
->baseline_offset
;
2590 font_info
= FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2591 boff
= font_info
->baseline_offset
;
2592 if (font_info
->vertical_centering
)
2593 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2596 /* There are no padding glyphs, so there is only one glyph to
2597 produce for the composition. Important is that pixel_width,
2598 ascent and descent are the values of what is drawn by
2599 draw_glyphs (i.e. the values of the overall glyphs composed). */
2602 /* If we have not yet calculated pixel size data of glyphs of
2603 the composition for the current face font, calculate them
2604 now. Theoretically, we have to check all fonts for the
2605 glyphs, but that requires much time and memory space. So,
2606 here we check only the font of the first glyph. This leads
2607 to incorrect display very rarely, and C-l (recenter) can
2608 correct the display anyway. */
2609 if (cmp
->font
!= (void *) font
)
2611 /* Ascent and descent of the font of the first character of
2612 this composition (adjusted by baseline offset). Ascent
2613 and descent of overall glyphs should not be less than
2614 them respectively. */
2615 int font_ascent
= font
->ascent
+ boff
;
2616 int font_descent
= font
->descent
- boff
;
2617 /* Bounding box of the overall glyphs. */
2618 int leftmost
, rightmost
, lowest
, highest
;
2619 int i
, width
, ascent
, descent
;
2621 cmp
->font
= (void *) font
;
2623 /* Initialize the bounding box. */
2624 pcm
= x_per_char_metric (font
, &char2b
);
2628 ascent
= pcm
->ascent
;
2629 descent
= pcm
->descent
;
2633 width
= FONT_WIDTH (font
);
2634 ascent
= font
->ascent
;
2635 descent
= font
->descent
;
2639 lowest
= - descent
+ boff
;
2640 highest
= ascent
+ boff
;
2644 && font_info
->default_ascent
2645 && CHAR_TABLE_P (Vuse_default_ascent
)
2646 && !NILP (Faref (Vuse_default_ascent
,
2647 make_number (it
->char_to_display
))))
2648 highest
= font_info
->default_ascent
+ boff
;
2650 /* Draw the first glyph at the normal position. It may be
2651 shifted to right later if some other glyphs are drawn at
2653 cmp
->offsets
[0] = 0;
2654 cmp
->offsets
[1] = boff
;
2656 /* Set cmp->offsets for the remaining glyphs. */
2657 for (i
= 1; i
< cmp
->glyph_len
; i
++)
2659 int left
, right
, btm
, top
;
2660 int ch
= COMPOSITION_GLYPH (cmp
, i
);
2661 int face_id
= FACE_FOR_CHAR (it
->f
, face
, ch
);
2663 face
= FACE_FROM_ID (it
->f
, face_id
);
2664 x_get_char_face_and_encoding (it
->f
, ch
, face
->id
, &char2b
,
2669 font
= FRAME_FONT (it
->f
);
2670 boff
= it
->f
->output_data
.mac
->baseline_offset
;
2676 = FONT_INFO_FROM_ID (it
->f
, face
->font_info_id
);
2677 boff
= font_info
->baseline_offset
;
2678 if (font_info
->vertical_centering
)
2679 boff
= VCENTER_BASELINE_OFFSET (font
, it
->f
) - boff
;
2682 pcm
= x_per_char_metric (font
, &char2b
);
2686 ascent
= pcm
->ascent
;
2687 descent
= pcm
->descent
;
2691 width
= FONT_WIDTH (font
);
2692 ascent
= font
->ascent
;
2693 descent
= font
->descent
;
2696 if (cmp
->method
!= COMPOSITION_WITH_RULE_ALTCHARS
)
2698 /* Relative composition with or without
2700 left
= (leftmost
+ rightmost
- width
) / 2;
2701 btm
= - descent
+ boff
;
2702 if (font_info
&& font_info
->relative_compose
2703 && (! CHAR_TABLE_P (Vignore_relative_composition
)
2704 || NILP (Faref (Vignore_relative_composition
,
2705 make_number (ch
)))))
2708 if (- descent
>= font_info
->relative_compose
)
2709 /* One extra pixel between two glyphs. */
2711 else if (ascent
<= 0)
2712 /* One extra pixel between two glyphs. */
2713 btm
= lowest
- 1 - ascent
- descent
;
2718 /* A composition rule is specified by an integer
2719 value that encodes global and new reference
2720 points (GREF and NREF). GREF and NREF are
2721 specified by numbers as below:
2729 ---3---4---5--- baseline
2731 6---7---8 -- descent
2733 int rule
= COMPOSITION_RULE (cmp
, i
);
2734 int gref
, nref
, grefx
, grefy
, nrefx
, nrefy
;
2736 COMPOSITION_DECODE_RULE (rule
, gref
, nref
);
2737 grefx
= gref
% 3, nrefx
= nref
% 3;
2738 grefy
= gref
/ 3, nrefy
= nref
/ 3;
2741 + grefx
* (rightmost
- leftmost
) / 2
2742 - nrefx
* width
/ 2);
2743 btm
= ((grefy
== 0 ? highest
2745 : grefy
== 2 ? lowest
2746 : (highest
+ lowest
) / 2)
2747 - (nrefy
== 0 ? ascent
+ descent
2748 : nrefy
== 1 ? descent
- boff
2750 : (ascent
+ descent
) / 2));
2753 cmp
->offsets
[i
* 2] = left
;
2754 cmp
->offsets
[i
* 2 + 1] = btm
+ descent
;
2756 /* Update the bounding box of the overall glyphs. */
2757 right
= left
+ width
;
2758 top
= btm
+ descent
+ ascent
;
2759 if (left
< leftmost
)
2761 if (right
> rightmost
)
2769 /* If there are glyphs whose x-offsets are negative,
2770 shift all glyphs to the right and make all x-offsets
2774 for (i
= 0; i
< cmp
->glyph_len
; i
++)
2775 cmp
->offsets
[i
* 2] -= leftmost
;
2776 rightmost
-= leftmost
;
2779 cmp
->pixel_width
= rightmost
;
2780 cmp
->ascent
= highest
;
2781 cmp
->descent
= - lowest
;
2782 if (cmp
->ascent
< font_ascent
)
2783 cmp
->ascent
= font_ascent
;
2784 if (cmp
->descent
< font_descent
)
2785 cmp
->descent
= font_descent
;
2788 it
->pixel_width
= cmp
->pixel_width
;
2789 it
->ascent
= it
->phys_ascent
= cmp
->ascent
;
2790 it
->descent
= it
->phys_descent
= cmp
->descent
;
2792 if (face
->box
!= FACE_NO_BOX
)
2794 int thick
= face
->box_line_width
;
2795 it
->ascent
+= thick
;
2796 it
->descent
+= thick
;
2798 if (it
->start_of_box_run_p
)
2799 it
->pixel_width
+= thick
;
2800 if (it
->end_of_box_run_p
)
2801 it
->pixel_width
+= thick
;
2804 /* If face has an overline, add the height of the overline
2805 (1 pixel) and a 1 pixel margin to the character height. */
2806 if (face
->overline_p
)
2809 take_vertical_position_into_account (it
);
2812 x_append_composite_glyph (it
);
2814 else if (it
->what
== IT_IMAGE
)
2815 x_produce_image_glyph (it
);
2816 else if (it
->what
== IT_STRETCH
)
2817 x_produce_stretch_glyph (it
);
2819 /* Accumulate dimensions. Note: can't assume that it->descent > 0
2820 because this isn't true for images with `:ascent 100'. */
2821 xassert (it
->ascent
>= 0 && it
->descent
>= 0);
2822 if (it
->area
== TEXT_AREA
)
2823 it
->current_x
+= it
->pixel_width
;
2825 it
->descent
+= it
->extra_line_spacing
;
2827 it
->max_ascent
= max (it
->max_ascent
, it
->ascent
);
2828 it
->max_descent
= max (it
->max_descent
, it
->descent
);
2829 it
->max_phys_ascent
= max (it
->max_phys_ascent
, it
->phys_ascent
);
2830 it
->max_phys_descent
= max (it
->max_phys_descent
, it
->phys_descent
);
2834 /* Estimate the pixel height of the mode or top line on frame F.
2835 FACE_ID specifies what line's height to estimate. */
2838 x_estimate_mode_line_height (f
, face_id
)
2840 enum face_id face_id
;
2844 /* This function is called so early when Emacs starts that the face
2845 cache and mode line face are not yet initialized. */
2846 if (FRAME_FACE_CACHE (f
))
2848 struct face
*face
= FACE_FROM_ID (f
, face_id
);
2850 height
= FONT_HEIGHT (face
->font
) + 2 * face
->box_line_width
;
2857 /***********************************************************************
2859 ***********************************************************************/
2861 /* A sequence of glyphs to be drawn in the same face.
2863 This data structure is not really completely X specific, so it
2864 could possibly, at least partially, be useful for other systems. It
2865 is currently not part of the external redisplay interface because
2866 it's not clear what other systems will need. */
2870 /* X-origin of the string. */
2873 /* Y-origin and y-position of the base line of this string. */
2876 /* The width of the string, not including a face extension. */
2879 /* The width of the string, including a face extension. */
2880 int background_width
;
2882 /* The height of this string. This is the height of the line this
2883 string is drawn in, and can be different from the height of the
2884 font the string is drawn in. */
2887 /* Number of pixels this string overwrites in front of its x-origin.
2888 This number is zero if the string has an lbearing >= 0; it is
2889 -lbearing, if the string has an lbearing < 0. */
2892 /* Number of pixels this string overwrites past its right-most
2893 nominal x-position, i.e. x + width. Zero if the string's
2894 rbearing is <= its nominal width, rbearing - width otherwise. */
2897 /* The frame on which the glyph string is drawn. */
2900 /* The window on which the glyph string is drawn. */
2903 /* X display and window for convenience. */
2907 /* The glyph row for which this string was built. It determines the
2908 y-origin and height of the string. */
2909 struct glyph_row
*row
;
2911 /* The area within row. */
2912 enum glyph_row_area area
;
2914 /* Characters to be drawn, and number of characters. */
2918 /* A face-override for drawing cursors, mouse face and similar. */
2919 enum draw_glyphs_face hl
;
2921 /* Face in which this string is to be drawn. */
2924 /* Font in which this string is to be drawn. */
2927 /* Font info for this string. */
2928 struct font_info
*font_info
;
2930 /* Non-null means this string describes (part of) a composition.
2931 All characters from char2b are drawn composed. */
2932 struct composition
*cmp
;
2934 /* Index of this glyph string's first character in the glyph
2935 definition of CMP. If this is zero, this glyph string describes
2936 the first character of a composition. */
2939 /* 1 means this glyph strings face has to be drawn to the right end
2940 of the window's drawing area. */
2941 unsigned extends_to_end_of_line_p
: 1;
2943 /* 1 means the background of this string has been drawn. */
2944 unsigned background_filled_p
: 1;
2946 /* 1 means glyph string must be drawn with 16-bit functions. */
2947 unsigned two_byte_p
: 1;
2949 /* 1 means that the original font determined for drawing this glyph
2950 string could not be loaded. The member `font' has been set to
2951 the frame's default font in this case. */
2952 unsigned font_not_found_p
: 1;
2954 /* 1 means that the face in which this glyph string is drawn has a
2956 unsigned stippled_p
: 1;
2958 /* 1 means only the foreground of this glyph string must be drawn,
2959 and we should use the physical height of the line this glyph
2960 string appears in as clip rect. */
2961 unsigned for_overlaps_p
: 1;
2963 /* The GC to use for drawing this glyph string. */
2966 /* A pointer to the first glyph in the string. This glyph
2967 corresponds to char2b[0]. Needed to draw rectangles if
2968 font_not_found_p is 1. */
2969 struct glyph
*first_glyph
;
2971 /* Image, if any. */
2974 struct glyph_string
*next
, *prev
;
2981 x_dump_glyph_string (s
)
2982 struct glyph_string
*s
;
2984 fprintf (stderr
, "glyph string\n");
2985 fprintf (stderr
, " x, y, w, h = %d, %d, %d, %d\n",
2986 s
->x
, s
->y
, s
->width
, s
->height
);
2987 fprintf (stderr
, " ybase = %d\n", s
->ybase
);
2988 fprintf (stderr
, " hl = %d\n", s
->hl
);
2989 fprintf (stderr
, " left overhang = %d, right = %d\n",
2990 s
->left_overhang
, s
->right_overhang
);
2991 fprintf (stderr
, " nchars = %d\n", s
->nchars
);
2992 fprintf (stderr
, " extends to end of line = %d\n",
2993 s
->extends_to_end_of_line_p
);
2994 fprintf (stderr
, " font height = %d\n", FONT_HEIGHT (s
->font
));
2995 fprintf (stderr
, " bg width = %d\n", s
->background_width
);
2998 #endif /* GLYPH_DEBUG */
3002 static void x_append_glyph_string_lists
P_ ((struct glyph_string
**,
3003 struct glyph_string
**,
3004 struct glyph_string
*,
3005 struct glyph_string
*));
3006 static void x_prepend_glyph_string_lists
P_ ((struct glyph_string
**,
3007 struct glyph_string
**,
3008 struct glyph_string
*,
3009 struct glyph_string
*));
3010 static void x_append_glyph_string
P_ ((struct glyph_string
**,
3011 struct glyph_string
**,
3012 struct glyph_string
*));
3013 static int x_left_overwritten
P_ ((struct glyph_string
*));
3014 static int x_left_overwriting
P_ ((struct glyph_string
*));
3015 static int x_right_overwritten
P_ ((struct glyph_string
*));
3016 static int x_right_overwriting
P_ ((struct glyph_string
*));
3017 static int x_fill_glyph_string
P_ ((struct glyph_string
*, int, int, int,
3019 static void x_init_glyph_string
P_ ((struct glyph_string
*,
3020 XChar2b
*, struct window
*,
3022 enum glyph_row_area
, int,
3023 enum draw_glyphs_face
));
3024 static int x_draw_glyphs
P_ ((struct window
*, int , struct glyph_row
*,
3025 enum glyph_row_area
, int, int,
3026 enum draw_glyphs_face
, int *, int *, int));
3027 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
3028 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
3029 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
3031 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
3032 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
3033 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
3034 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
3035 static void x_compute_glyph_string_overhangs
P_ ((struct glyph_string
*));
3036 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
3037 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
3038 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
3039 static void x_get_glyph_overhangs
P_ ((struct glyph
*, struct frame
*,
3041 static void x_compute_overhangs_and_x
P_ ((struct glyph_string
*, int, int));
3042 static int x_alloc_lighter_color
P_ ((struct frame
*, Display
*, Colormap
,
3043 unsigned long *, double, int));
3044 static void x_setup_relief_color
P_ ((struct frame
*, struct relief
*,
3045 double, int, unsigned long));
3046 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
3047 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
3048 static void x_draw_image_relief
P_ ((struct glyph_string
*));
3049 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
3050 static void x_draw_image_foreground_1
P_ ((struct glyph_string
*, Pixmap
));
3051 static void x_fill_image_glyph_string
P_ ((struct glyph_string
*));
3052 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
3054 static void x_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
3055 int, int, int, int, XRectangle
*));
3056 static void x_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
3057 int, int, int, XRectangle
*));
3058 static void x_fix_overlapping_area
P_ ((struct window
*, struct glyph_row
*,
3059 enum glyph_row_area
));
3060 static int x_fill_stretch_glyph_string
P_ ((struct glyph_string
*,
3062 enum glyph_row_area
, int, int));
3065 static void x_check_font
P_ ((struct frame
*, XFontStruct
*));
3069 /* Append the list of glyph strings with head H and tail T to the list
3070 with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the result. */
3073 x_append_glyph_string_lists (head
, tail
, h
, t
)
3074 struct glyph_string
**head
, **tail
;
3075 struct glyph_string
*h
, *t
;
3089 /* Prepend the list of glyph strings with head H and tail T to the
3090 list with head *HEAD and tail *TAIL. Set *HEAD and *TAIL to the
3094 x_prepend_glyph_string_lists (head
, tail
, h
, t
)
3095 struct glyph_string
**head
, **tail
;
3096 struct glyph_string
*h
, *t
;
3110 /* Append glyph string S to the list with head *HEAD and tail *TAIL.
3111 Set *HEAD and *TAIL to the resulting list. */
3114 x_append_glyph_string (head
, tail
, s
)
3115 struct glyph_string
**head
, **tail
;
3116 struct glyph_string
*s
;
3118 s
->next
= s
->prev
= NULL
;
3119 x_append_glyph_string_lists (head
, tail
, s
, s
);
3123 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
3128 struct glyph_string
*s
;
3130 if (s
->font
== FRAME_FONT (s
->f
)
3131 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
3132 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
3134 s
->gc
= s
->f
->output_data
.mac
->cursor_gc
;
3137 /* Cursor on non-default face: must merge. */
3141 xgcv
.background
= s
->f
->output_data
.mac
->cursor_pixel
;
3142 xgcv
.foreground
= s
->face
->background
;
3144 /* If the glyph would be invisible, try a different foreground. */
3145 if (xgcv
.foreground
== xgcv
.background
)
3146 xgcv
.foreground
= s
->face
->foreground
;
3147 if (xgcv
.foreground
== xgcv
.background
)
3148 xgcv
.foreground
= s
->f
->output_data
.mac
->cursor_foreground_pixel
;
3149 if (xgcv
.foreground
== xgcv
.background
)
3150 xgcv
.foreground
= s
->face
->foreground
;
3152 /* Make sure the cursor is distinct from text in this face. */
3153 if (xgcv
.background
== s
->face
->background
3154 && xgcv
.foreground
== s
->face
->foreground
)
3156 xgcv
.background
= s
->face
->foreground
;
3157 xgcv
.foreground
= s
->face
->background
;
3160 IF_DEBUG (x_check_font (s
->f
, s
->font
));
3161 xgcv
.font
= s
->font
;
3162 mask
= GCForeground
| GCBackground
| GCFont
;
3164 if (FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
3165 XChangeGC (s
->display
, FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
3168 FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
3169 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
3171 s
->gc
= FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
3176 /* Set up S->gc of glyph string S for drawing text in mouse face. */
3179 x_set_mouse_face_gc (s
)
3180 struct glyph_string
*s
;
3185 /* What face has to be used for the mouse face? */
3186 face_id
= FRAME_X_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
3187 face
= FACE_FROM_ID (s
->f
, face_id
);
3188 if (s
->first_glyph
->type
== CHAR_GLYPH
)
3189 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
);
3191 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0);
3192 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
3193 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
3195 /* If font in this face is same as S->font, use it. */
3196 if (s
->font
== s
->face
->font
)
3197 s
->gc
= s
->face
->gc
;
3200 /* Otherwise construct scratch_cursor_gc with values from FACE
3205 xgcv
.background
= s
->face
->background
;
3206 xgcv
.foreground
= s
->face
->foreground
;
3207 IF_DEBUG (x_check_font (s
->f
, s
->font
));
3208 xgcv
.font
= s
->font
;
3209 mask
= GCForeground
| GCBackground
| GCFont
;
3211 if (FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
3212 XChangeGC (s
->display
, FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
3215 FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
3216 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
3218 s
->gc
= FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
3221 xassert (s
->gc
!= 0);
3225 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
3226 Faces to use in the mode line have already been computed when the
3227 matrix was built, so there isn't much to do, here. */
3230 x_set_mode_line_face_gc (s
)
3231 struct glyph_string
*s
;
3233 s
->gc
= s
->face
->gc
;
3237 /* Set S->gc of glyph string S for drawing that glyph string. Set
3238 S->stippled_p to a non-zero value if the face of S has a stipple
3242 x_set_glyph_string_gc (s
)
3243 struct glyph_string
*s
;
3245 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
3247 if (s
->hl
== DRAW_NORMAL_TEXT
)
3249 s
->gc
= s
->face
->gc
;
3250 s
->stippled_p
= s
->face
->stipple
!= 0;
3252 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
3254 x_set_mode_line_face_gc (s
);
3255 s
->stippled_p
= s
->face
->stipple
!= 0;
3257 else if (s
->hl
== DRAW_CURSOR
)
3259 x_set_cursor_gc (s
);
3262 else if (s
->hl
== DRAW_MOUSE_FACE
)
3264 x_set_mouse_face_gc (s
);
3265 s
->stippled_p
= s
->face
->stipple
!= 0;
3267 else if (s
->hl
== DRAW_IMAGE_RAISED
3268 || s
->hl
== DRAW_IMAGE_SUNKEN
)
3270 s
->gc
= s
->face
->gc
;
3271 s
->stippled_p
= s
->face
->stipple
!= 0;
3275 s
->gc
= s
->face
->gc
;
3276 s
->stippled_p
= s
->face
->stipple
!= 0;
3279 /* GC must have been set. */
3280 xassert (s
->gc
!= 0);
3284 /* Return in *R the clipping rectangle for glyph string S. */
3287 x_get_glyph_string_clip_rect (s
, r
)
3288 struct glyph_string
*s
;
3291 int r_height
, r_width
;
3293 if (s
->row
->full_width_p
)
3295 /* Draw full-width. X coordinates are relative to S->w->left. */
3296 int canon_x
= CANON_X_UNIT (s
->f
);
3298 r
->left
= WINDOW_LEFT_MARGIN (s
->w
) * canon_x
;
3299 r_width
= XFASTINT (s
->w
->width
) * canon_x
;
3301 if (FRAME_HAS_VERTICAL_SCROLL_BARS (s
->f
))
3303 int width
= FRAME_SCROLL_BAR_WIDTH (s
->f
) * canon_x
;
3304 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_LEFT (s
->f
))
3308 r
->left
+= FRAME_INTERNAL_BORDER_WIDTH (s
->f
);
3310 /* Unless displaying a mode or menu bar line, which are always
3311 fully visible, clip to the visible part of the row. */
3312 if (s
->w
->pseudo_window_p
)
3313 r_height
= s
->row
->visible_height
;
3315 r_height
= s
->height
;
3319 /* This is a text line that may be partially visible. */
3320 r
->left
= WINDOW_AREA_TO_FRAME_PIXEL_X (s
->w
, s
->area
, 0);
3321 r_width
= window_box_width (s
->w
, s
->area
);
3322 r_height
= s
->row
->visible_height
;
3325 /* Don't use S->y for clipping because it doesn't take partially
3326 visible lines into account. For example, it can be negative for
3327 partially visible lines at the top of a window. */
3328 if (!s
->row
->full_width_p
3329 && MATRIX_ROW_PARTIALLY_VISIBLE_AT_TOP_P (s
->w
, s
->row
))
3330 r
->top
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
3332 r
->top
= max (0, s
->row
->y
);
3334 /* If drawing a tool-bar window, draw it over the internal border
3335 at the top of the window. */
3336 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
3337 r
->top
-= s
->f
->output_data
.mac
->internal_border_width
;
3339 /* If S draws overlapping rows, it's sufficient to use the top and
3340 bottom of the window for clipping because this glyph string
3341 intentionally draws over other lines. */
3342 if (s
->for_overlaps_p
)
3344 r
->top
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (s
->w
);
3345 r_height
= window_text_bottom_y (s
->w
) - r
->top
;
3348 r
->top
= WINDOW_TO_FRAME_PIXEL_Y (s
->w
, r
->top
);
3350 r
->bottom
= r
->top
+ r_height
;
3351 r
->right
= r
->left
+ r_width
;
3355 /* Set clipping for output of glyph string S. S may be part of a mode
3356 line or menu if we don't have X toolkit support. */
3359 x_set_glyph_string_clipping (s
)
3360 struct glyph_string
*s
;
3363 x_get_glyph_string_clip_rect (s
, &r
);
3364 mac_set_clip_rectangle (s
->display
, s
->window
, &r
);
3368 /* Compute left and right overhang of glyph string S. If S is a glyph
3369 string for a composition, assume overhangs don't exist. */
3372 x_compute_glyph_string_overhangs (s
)
3373 struct glyph_string
*s
;
3376 && s
->first_glyph
->type
== CHAR_GLYPH
)
3379 int direction
, font_ascent
, font_descent
;
3380 XTextExtents16 (s
->font
, s
->char2b
, s
->nchars
, &direction
,
3381 &font_ascent
, &font_descent
, &cs
);
3382 s
->right_overhang
= cs
.rbearing
> cs
.width
? cs
.rbearing
- cs
.width
: 0;
3383 s
->left_overhang
= cs
.lbearing
< 0 ? -cs
.lbearing
: 0;
3388 /* Compute overhangs and x-positions for glyph string S and its
3389 predecessors, or successors. X is the starting x-position for S.
3390 BACKWARD_P non-zero means process predecessors. */
3393 x_compute_overhangs_and_x (s
, x
, backward_p
)
3394 struct glyph_string
*s
;
3402 x_compute_glyph_string_overhangs (s
);
3412 x_compute_glyph_string_overhangs (s
);
3421 /* Set *LEFT and *RIGHT to the left and right overhang of GLYPH on
3422 frame F. Overhangs of glyphs other than type CHAR_GLYPH are
3423 assumed to be zero. */
3426 x_get_glyph_overhangs (glyph
, f
, left
, right
)
3427 struct glyph
*glyph
;
3433 if (glyph
->type
== CHAR_GLYPH
)
3437 struct font_info
*font_info
;
3441 face
= x_get_glyph_face_and_encoding (f
, glyph
, &char2b
, NULL
);
3443 font_info
= FONT_INFO_FROM_ID (f
, face
->font_info_id
);
3445 && (pcm
= x_per_char_metric (font
, &char2b
)))
3447 if (pcm
->rbearing
> pcm
->width
)
3448 *right
= pcm
->rbearing
- pcm
->width
;
3449 if (pcm
->lbearing
< 0)
3450 *left
= -pcm
->lbearing
;
3456 /* Return the index of the first glyph preceding glyph string S that
3457 is overwritten by S because of S's left overhang. Value is -1
3458 if no glyphs are overwritten. */
3461 x_left_overwritten (s
)
3462 struct glyph_string
*s
;
3466 if (s
->left_overhang
)
3469 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3470 int first
= s
->first_glyph
- glyphs
;
3472 for (i
= first
- 1; i
>= 0 && x
> -s
->left_overhang
; --i
)
3473 x
-= glyphs
[i
].pixel_width
;
3484 /* Return the index of the first glyph preceding glyph string S that
3485 is overwriting S because of its right overhang. Value is -1 if no
3486 glyph in front of S overwrites S. */
3489 x_left_overwriting (s
)
3490 struct glyph_string
*s
;
3493 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3494 int first
= s
->first_glyph
- glyphs
;
3498 for (i
= first
- 1; i
>= 0; --i
)
3501 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
3504 x
-= glyphs
[i
].pixel_width
;
3511 /* Return the index of the last glyph following glyph string S that is
3512 not overwritten by S because of S's right overhang. Value is -1 if
3513 no such glyph is found. */
3516 x_right_overwritten (s
)
3517 struct glyph_string
*s
;
3521 if (s
->right_overhang
)
3524 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3525 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
3526 int end
= s
->row
->used
[s
->area
];
3528 for (i
= first
; i
< end
&& s
->right_overhang
> x
; ++i
)
3529 x
+= glyphs
[i
].pixel_width
;
3538 /* Return the index of the last glyph following glyph string S that
3539 overwrites S because of its left overhang. Value is negative
3540 if no such glyph is found. */
3543 x_right_overwriting (s
)
3544 struct glyph_string
*s
;
3547 int end
= s
->row
->used
[s
->area
];
3548 struct glyph
*glyphs
= s
->row
->glyphs
[s
->area
];
3549 int first
= (s
->first_glyph
- glyphs
) + (s
->cmp
? 1 : s
->nchars
);
3553 for (i
= first
; i
< end
; ++i
)
3556 x_get_glyph_overhangs (glyphs
+ i
, s
->f
, &left
, &right
);
3559 x
+= glyphs
[i
].pixel_width
;
3566 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
3569 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
3570 struct glyph_string
*s
;
3575 xgcv
.foreground
= s
->gc
->background
;
3576 XFillRectangle (s
->display
, s
->window
, &xgcv
, x
, y
, w
, h
);
3580 /* Draw the background of glyph_string S. If S->background_filled_p
3581 is non-zero don't draw it. FORCE_P non-zero means draw the
3582 background even if it wouldn't be drawn normally. This is used
3583 when a string preceding S draws into the background of S, or S
3584 contains the first component of a composition. */
3587 x_draw_glyph_string_background (s
, force_p
)
3588 struct glyph_string
*s
;
3591 /* Nothing to do if background has already been drawn or if it
3592 shouldn't be drawn in the first place. */
3593 if (!s
->background_filled_p
)
3595 #if 0 /* MAC_TODO: stipple */
3598 /* Fill background with a stipple pattern. */
3599 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3600 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
3601 s
->y
+ s
->face
->box_line_width
,
3602 s
->background_width
,
3603 s
->height
- 2 * s
->face
->box_line_width
);
3604 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3605 s
->background_filled_p
= 1;
3609 if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * s
->face
->box_line_width
3610 || s
->font_not_found_p
3611 || s
->extends_to_end_of_line_p
3614 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ s
->face
->box_line_width
,
3615 s
->background_width
,
3616 s
->height
- 2 * s
->face
->box_line_width
);
3617 s
->background_filled_p
= 1;
3623 /* Draw the foreground of glyph string S. */
3626 x_draw_glyph_string_foreground (s
)
3627 struct glyph_string
*s
;
3631 /* If first glyph of S has a left box line, start drawing the text
3632 of S to the right of that box line. */
3633 if (s
->face
->box
!= FACE_NO_BOX
3634 && s
->first_glyph
->left_box_line_p
)
3635 x
= s
->x
+ s
->face
->box_line_width
;
3639 /* Draw characters of S as rectangles if S's font could not be
3641 if (s
->font_not_found_p
)
3643 for (i
= 0; i
< s
->nchars
; ++i
)
3645 struct glyph
*g
= s
->first_glyph
+ i
;
3646 mac_draw_rectangle (s
->display
, s
->window
,
3647 s
->gc
, x
, s
->y
, g
->pixel_width
- 1,
3649 x
+= g
->pixel_width
;
3654 char *char1b
= (char *) s
->char2b
;
3655 int boff
= s
->font_info
->baseline_offset
;
3657 if (s
->font_info
->vertical_centering
)
3658 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
3660 /* If we can use 8-bit functions, condense S->char2b. */
3662 for (i
= 0; i
< s
->nchars
; ++i
)
3663 char1b
[i
] = s
->char2b
[i
].byte2
;
3665 /* Draw text with XDrawString if background has already been
3666 filled. Otherwise, use XDrawImageString. (Note that
3667 XDrawImageString is usually faster than XDrawString.) Always
3668 use XDrawImageString when drawing the cursor so that there is
3669 no chance that characters under a box cursor are invisible. */
3670 if (s
->for_overlaps_p
3671 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
3673 /* Draw characters with 16-bit or 8-bit functions. */
3675 XDrawString16 (s
->display
, s
->window
, s
->gc
, x
,
3676 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
3678 XDrawString (s
->display
, s
->window
, s
->gc
, x
,
3679 s
->ybase
- boff
, char1b
, s
->nchars
);
3684 XDrawImageString16 (s
->display
, s
->window
, s
->gc
, x
,
3685 s
->ybase
- boff
, s
->char2b
, s
->nchars
);
3687 XDrawImageString (s
->display
, s
->window
, s
->gc
, x
,
3688 s
->ybase
- boff
, char1b
, s
->nchars
);
3693 /* Draw the foreground of composite glyph string S. */
3696 x_draw_composite_glyph_string_foreground (s
)
3697 struct glyph_string
*s
;
3701 /* If first glyph of S has a left box line, start drawing the text
3702 of S to the right of that box line. */
3703 if (s
->face
->box
!= FACE_NO_BOX
3704 && s
->first_glyph
->left_box_line_p
)
3705 x
= s
->x
+ s
->face
->box_line_width
;
3709 /* S is a glyph string for a composition. S->gidx is the index of
3710 the first character drawn for glyphs of this composition.
3711 S->gidx == 0 means we are drawing the very first character of
3712 this composition. */
3714 /* Draw a rectangle for the composition if the font for the very
3715 first character of the composition could not be loaded. */
3716 if (s
->font_not_found_p
)
3719 mac_draw_rectangle (s
->display
, s
->window
, s
->gc
, x
, s
->y
,
3720 s
->width
- 1, s
->height
- 1);
3724 for (i
= 0; i
< s
->nchars
; i
++, ++s
->gidx
)
3725 XDrawString16 (s
->display
, s
->window
, s
->gc
,
3726 x
+ s
->cmp
->offsets
[s
->gidx
* 2],
3727 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
3733 #ifdef USE_X_TOOLKIT
3735 static struct frame
*x_frame_of_widget
P_ ((Widget
));
3738 /* Return the frame on which widget WIDGET is used.. Abort if frame
3739 cannot be determined. */
3741 static struct frame
*
3742 x_frame_of_widget (widget
)
3745 struct x_display_info
*dpyinfo
;
3749 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
3751 /* Find the top-level shell of the widget. Note that this function
3752 can be called when the widget is not yet realized, so XtWindow
3753 (widget) == 0. That's the reason we can't simply use
3754 x_any_window_to_frame. */
3755 while (!XtIsTopLevelShell (widget
))
3756 widget
= XtParent (widget
);
3758 /* Look for a frame with that top-level widget. Allocate the color
3759 on that frame to get the right gamma correction value. */
3760 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
3761 if (GC_FRAMEP (XCAR (tail
))
3762 && (f
= XFRAME (XCAR (tail
)),
3763 (f
->output_data
.nothing
!= 1
3764 && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
))
3765 && f
->output_data
.x
->widget
== widget
)
3772 /* Allocate the color COLOR->pixel on the screen and display of
3773 widget WIDGET in colormap CMAP. If an exact match cannot be
3774 allocated, try the nearest color available. Value is non-zero
3775 if successful. This is called from lwlib. */
3778 x_alloc_nearest_color_for_widget (widget
, cmap
, color
)
3783 struct frame
*f
= x_frame_of_widget (widget
);
3784 return x_alloc_nearest_color (f
, cmap
, color
);
3788 #endif /* USE_X_TOOLKIT */
3792 /* Allocate the color COLOR->pixel on SCREEN of DISPLAY, colormap
3793 CMAP. If an exact match can't be allocated, try the nearest color
3794 available. Value is non-zero if successful. Set *COLOR to the
3798 x_alloc_nearest_color (f
, cmap
, color
)
3803 Display
*display
= FRAME_X_DISPLAY (f
);
3804 Screen
*screen
= FRAME_X_SCREEN (f
);
3807 gamma_correct (f
, color
);
3808 rc
= XAllocColor (display
, cmap
, color
);
3811 /* If we got to this point, the colormap is full, so we're going
3812 to try to get the next closest color. The algorithm used is
3813 a least-squares matching, which is what X uses for closest
3814 color matching with StaticColor visuals. */
3816 unsigned long nearest_delta
= ~0;
3817 int ncells
= XDisplayCells (display
, XScreenNumberOfScreen (screen
));
3818 XColor
*cells
= (XColor
*) alloca (ncells
* sizeof *cells
);
3820 for (i
= 0; i
< ncells
; ++i
)
3822 XQueryColors (display
, cmap
, cells
, ncells
);
3824 for (nearest
= i
= 0; i
< ncells
; ++i
)
3826 long dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
3827 long dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
3828 long dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
3829 unsigned long delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
3831 if (delta
< nearest_delta
)
3834 nearest_delta
= delta
;
3838 color
->red
= cells
[nearest
].red
;
3839 color
->green
= cells
[nearest
].green
;
3840 color
->blue
= cells
[nearest
].blue
;
3841 rc
= XAllocColor (display
, cmap
, color
);
3844 #ifdef DEBUG_X_COLORS
3846 register_color (color
->pixel
);
3847 #endif /* DEBUG_X_COLORS */
3853 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
3854 It's necessary to do this instead of just using PIXEL directly to
3855 get color reference counts right. */
3858 x_copy_color (f
, pixel
)
3860 unsigned long pixel
;
3864 color
.pixel
= pixel
;
3866 XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
3867 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
3869 #ifdef DEBUG_X_COLORS
3870 register_color (pixel
);
3876 /* Allocate color PIXEL on display DPY. PIXEL must already be allocated.
3877 It's necessary to do this instead of just using PIXEL directly to
3878 get color reference counts right. */
3881 x_copy_dpy_color (dpy
, cmap
, pixel
)
3884 unsigned long pixel
;
3888 color
.pixel
= pixel
;
3890 XQueryColor (dpy
, cmap
, &color
);
3891 XAllocColor (dpy
, cmap
, &color
);
3893 #ifdef DEBUG_X_COLORS
3894 register_color (pixel
);
3901 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
3902 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3903 If this produces the same color as COLOR, try a color where all RGB
3904 values have DELTA added. Return the allocated color in *COLOR.
3905 DISPLAY is the X display, CMAP is the colormap to operate on.
3906 Value is non-zero if successful. */
3909 mac_alloc_lighter_color (f
, color
, factor
, delta
)
3911 unsigned long *color
;
3917 /* Change RGB values by specified FACTOR. Avoid overflow! */
3918 xassert (factor
>= 0);
3919 new = RGB_TO_ULONG (min (0xff, (int) (factor
* RED_FROM_ULONG (*color
))),
3920 min (0xff, (int) (factor
* GREEN_FROM_ULONG (*color
))),
3921 min (0xff, (int) (factor
* BLUE_FROM_ULONG (*color
))));
3923 new = RGB_TO_ULONG (max (0, min (0xff, (int) (delta
+ RED_FROM_ULONG (*color
)))),
3924 max (0, min (0xff, (int) (delta
+ GREEN_FROM_ULONG (*color
)))),
3925 max (0, min (0xff, (int) (delta
+ BLUE_FROM_ULONG (*color
)))));
3927 /* MAC_TODO: Map to palette and retry with delta if same? */
3928 /* MAC_TODO: Free colors (if using palette)? */
3939 /* Set up the foreground color for drawing relief lines of glyph
3940 string S. RELIEF is a pointer to a struct relief containing the GC
3941 with which lines will be drawn. Use a color that is FACTOR or
3942 DELTA lighter or darker than the relief's background which is found
3943 in S->f->output_data.x->relief_background. If such a color cannot
3944 be allocated, use DEFAULT_PIXEL, instead. */
3947 x_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
3949 struct relief
*relief
;
3952 unsigned long default_pixel
;
3955 struct mac_output
*di
= f
->output_data
.mac
;
3956 unsigned long mask
= GCForeground
;
3957 unsigned long pixel
;
3958 unsigned long background
= di
->relief_background
;
3959 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
3961 /* MAC_TODO: Free colors (if using palette)? */
3963 /* Allocate new color. */
3964 xgcv
.foreground
= default_pixel
;
3966 if (mac_alloc_lighter_color (f
, &pixel
, factor
, delta
))
3968 relief
->allocated_p
= 1;
3969 xgcv
.foreground
= relief
->pixel
= pixel
;
3972 if (relief
->gc
== 0)
3974 #if 0 /* MAC_TODO: stipple */
3975 xgcv
.stipple
= dpyinfo
->gray
;
3978 relief
->gc
= XCreateGC (NULL
, FRAME_MAC_WINDOW (f
), mask
, &xgcv
);
3981 XChangeGC (NULL
, relief
->gc
, mask
, &xgcv
);
3985 /* Set up colors for the relief lines around glyph string S. */
3988 x_setup_relief_colors (s
)
3989 struct glyph_string
*s
;
3991 struct mac_output
*di
= s
->f
->output_data
.mac
;
3992 unsigned long color
;
3994 if (s
->face
->use_box_color_for_shadows_p
)
3995 color
= s
->face
->box_color
;
4000 /* Get the background color of the face. */
4001 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
4002 color
= xgcv
.background
;
4005 if (di
->white_relief
.gc
== 0
4006 || color
!= di
->relief_background
)
4008 di
->relief_background
= color
;
4009 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
4010 WHITE_PIX_DEFAULT (s
->f
));
4011 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
4012 BLACK_PIX_DEFAULT (s
->f
));
4017 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
4018 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
4019 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
4020 relief. LEFT_P non-zero means draw a relief on the left side of
4021 the rectangle. RIGHT_P non-zero means draw a relief on the right
4022 side of the rectangle. CLIP_RECT is the clipping rectangle to use
4026 x_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
4027 raised_p
, left_p
, right_p
, clip_rect
)
4029 int left_x
, top_y
, right_x
, bottom_y
, left_p
, right_p
, raised_p
;
4036 gc
= f
->output_data
.mac
->white_relief
.gc
;
4038 gc
= f
->output_data
.mac
->black_relief
.gc
;
4039 mac_set_clip_rectangle (FRAME_MAC_DISPLAY (f
), FRAME_MAC_WINDOW (f
), clip_rect
);
4042 for (i
= 0; i
< width
; ++i
)
4043 XDrawLine (FRAME_MAC_DISPLAY (f
), FRAME_MAC_WINDOW (f
), gc
,
4044 left_x
+ i
* left_p
, top_y
+ i
,
4045 right_x
+ 1 - i
* right_p
, top_y
+ i
);
4049 for (i
= 0; i
< width
; ++i
)
4050 XDrawLine (FRAME_MAC_DISPLAY (f
), FRAME_MAC_WINDOW (f
), gc
,
4051 left_x
+ i
, top_y
+ i
, left_x
+ i
, bottom_y
- i
);
4053 mac_reset_clipping (FRAME_MAC_DISPLAY (f
), FRAME_MAC_WINDOW (f
));
4055 gc
= f
->output_data
.mac
->black_relief
.gc
;
4057 gc
= f
->output_data
.mac
->white_relief
.gc
;
4058 mac_set_clip_rectangle (FRAME_MAC_DISPLAY (f
), FRAME_MAC_WINDOW (f
), clip_rect
);
4061 for (i
= 0; i
< width
; ++i
)
4062 XDrawLine (FRAME_MAC_DISPLAY (f
), FRAME_MAC_WINDOW (f
), gc
,
4063 left_x
+ i
* left_p
, bottom_y
- i
,
4064 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
4068 for (i
= 0; i
< width
; ++i
)
4069 XDrawLine (FRAME_MAC_DISPLAY (f
), FRAME_MAC_WINDOW (f
), gc
,
4070 right_x
- i
, top_y
+ i
+ 1, right_x
- i
, bottom_y
- i
);
4072 mac_reset_clipping (FRAME_MAC_DISPLAY (f
), FRAME_MAC_WINDOW (f
));
4076 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
4077 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
4078 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
4079 left side of the rectangle. RIGHT_P non-zero means draw a line
4080 on the right side of the rectangle. CLIP_RECT is the clipping
4081 rectangle to use when drawing. */
4084 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
4085 left_p
, right_p
, clip_rect
)
4086 struct glyph_string
*s
;
4087 int left_x
, top_y
, right_x
, bottom_y
, left_p
, right_p
;
4092 xgcv
.foreground
= s
->face
->box_color
;
4093 mac_set_clip_rectangle (s
->display
, s
->window
, clip_rect
);
4096 XFillRectangle (s
->display
, s
->window
, &xgcv
,
4097 left_x
, top_y
, right_x
- left_x
, width
);
4101 XFillRectangle (s
->display
, s
->window
, &xgcv
,
4102 left_x
, top_y
, width
, bottom_y
- top_y
);
4105 XFillRectangle (s
->display
, s
->window
, &xgcv
,
4106 left_x
, bottom_y
- width
, right_x
- left_x
, width
);
4110 XFillRectangle (s
->display
, s
->window
, &xgcv
,
4111 right_x
- width
, top_y
, width
, bottom_y
- top_y
);
4113 mac_reset_clipping (s
->display
, s
->window
);
4117 /* Draw a box around glyph string S. */
4120 x_draw_glyph_string_box (s
)
4121 struct glyph_string
*s
;
4123 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
4124 int left_p
, right_p
;
4125 struct glyph
*last_glyph
;
4128 last_x
= window_box_right (s
->w
, s
->area
);
4129 if (s
->row
->full_width_p
4130 && !s
->w
->pseudo_window_p
)
4132 last_x
+= FRAME_X_RIGHT_FLAGS_AREA_WIDTH (s
->f
);
4133 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (s
->f
))
4134 last_x
+= FRAME_SCROLL_BAR_WIDTH (s
->f
) * CANON_X_UNIT (s
->f
);
4137 /* The glyph that may have a right box line. */
4138 last_glyph
= (s
->cmp
|| s
->img
4140 : s
->first_glyph
+ s
->nchars
- 1);
4142 width
= s
->face
->box_line_width
;
4143 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
4145 right_x
= ((s
->row
->full_width_p
4147 : min (last_x
, s
->x
+ s
->background_width
) - 1));
4149 bottom_y
= top_y
+ s
->height
- 1;
4151 left_p
= (s
->first_glyph
->left_box_line_p
4152 || (s
->hl
== DRAW_MOUSE_FACE
4154 || s
->prev
->hl
!= s
->hl
)));
4155 right_p
= (last_glyph
->right_box_line_p
4156 || (s
->hl
== DRAW_MOUSE_FACE
4158 || s
->next
->hl
!= s
->hl
)));
4160 x_get_glyph_string_clip_rect (s
, &clip_rect
);
4162 if (s
->face
->box
== FACE_SIMPLE_BOX
)
4163 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
4164 left_p
, right_p
, &clip_rect
);
4167 x_setup_relief_colors (s
);
4168 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
4169 width
, raised_p
, left_p
, right_p
, &clip_rect
);
4174 /* Draw foreground of image glyph string S. */
4177 x_draw_image_foreground (s
)
4178 struct glyph_string
*s
;
4181 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
);
4183 /* If first glyph of S has a left box line, start drawing it to the
4184 right of that line. */
4185 if (s
->face
->box
!= FACE_NO_BOX
4186 && s
->first_glyph
->left_box_line_p
)
4187 x
= s
->x
+ s
->face
->box_line_width
;
4191 /* If there is a margin around the image, adjust x- and y-position
4195 x
+= s
->img
->margin
;
4196 y
+= s
->img
->margin
;
4201 #if 0 /* MAC_TODO: image mask */
4204 /* We can't set both a clip mask and use XSetClipRectangles
4205 because the latter also sets a clip mask. We also can't
4206 trust on the shape extension to be available
4207 (XShapeCombineRegion). So, compute the rectangle to draw
4209 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
4212 XRectangle clip_rect
, image_rect
, r
;
4214 xgcv
.clip_mask
= s
->img
->mask
;
4215 xgcv
.clip_x_origin
= x
;
4216 xgcv
.clip_y_origin
= y
;
4217 xgcv
.function
= GXcopy
;
4218 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
4220 x_get_glyph_string_clip_rect (s
, &clip_rect
);
4223 image_rect
.width
= s
->img
->width
;
4224 image_rect
.height
= s
->img
->height
;
4225 if (x_intersect_rectangles (&clip_rect
, &image_rect
, &r
))
4226 XCopyArea (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
4227 r
.x
- x
, r
.y
- y
, r
.width
, r
.height
, r
.x
, r
.y
);
4232 mac_copy_area (s
->display
, s
->img
->pixmap
, s
->window
, s
->gc
,
4233 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
4235 /* When the image has a mask, we can expect that at
4236 least part of a mouse highlight or a block cursor will
4237 be visible. If the image doesn't have a mask, make
4238 a block cursor visible by drawing a rectangle around
4239 the image. I believe it's looking better if we do
4240 nothing here for mouse-face. */
4241 if (s
->hl
== DRAW_CURSOR
)
4242 mac_draw_rectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
4243 s
->img
->width
- 1, s
->img
->height
- 1);
4247 /* Draw a rectangle if image could not be loaded. */
4248 mac_draw_rectangle (s
->display
, s
->window
, s
->gc
, x
, y
,
4249 s
->img
->width
- 1, s
->img
->height
- 1);
4253 /* Draw a relief around the image glyph string S. */
4256 x_draw_image_relief (s
)
4257 struct glyph_string
*s
;
4259 int x0
, y0
, x1
, y1
, thick
, raised_p
;
4262 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
);
4264 /* If first glyph of S has a left box line, start drawing it to the
4265 right of that line. */
4266 if (s
->face
->box
!= FACE_NO_BOX
4267 && s
->first_glyph
->left_box_line_p
)
4268 x
= s
->x
+ s
->face
->box_line_width
;
4272 /* If there is a margin around the image, adjust x- and y-position
4276 x
+= s
->img
->margin
;
4277 y
+= s
->img
->margin
;
4280 if (s
->hl
== DRAW_IMAGE_SUNKEN
4281 || s
->hl
== DRAW_IMAGE_RAISED
)
4283 thick
= tool_bar_button_relief
> 0 ? tool_bar_button_relief
: 3;
4284 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
4288 thick
= abs (s
->img
->relief
);
4289 raised_p
= s
->img
->relief
> 0;
4294 x1
= x
+ s
->img
->width
+ thick
- 1;
4295 y1
= y
+ s
->img
->height
+ thick
- 1;
4297 x_setup_relief_colors (s
);
4298 x_get_glyph_string_clip_rect (s
, &r
);
4299 x_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
, 1, 1, &r
);
4303 /* Draw the foreground of image glyph string S to PIXMAP. */
4306 x_draw_image_foreground_1 (s
, pixmap
)
4307 struct glyph_string
*s
;
4311 int y
= s
->ybase
- s
->y
- image_ascent (s
->img
, s
->face
);
4313 /* If first glyph of S has a left box line, start drawing it to the
4314 right of that line. */
4315 if (s
->face
->box
!= FACE_NO_BOX
4316 && s
->first_glyph
->left_box_line_p
)
4317 x
= s
->face
->box_line_width
;
4321 /* If there is a margin around the image, adjust x- and y-position
4325 x
+= s
->img
->margin
;
4326 y
+= s
->img
->margin
;
4331 #if 0 /* MAC_TODO: image mask */
4334 /* We can't set both a clip mask and use XSetClipRectangles
4335 because the latter also sets a clip mask. We also can't
4336 trust on the shape extension to be available
4337 (XShapeCombineRegion). So, compute the rectangle to draw
4339 unsigned long mask
= (GCClipMask
| GCClipXOrigin
| GCClipYOrigin
4343 xgcv
.clip_mask
= s
->img
->mask
;
4344 xgcv
.clip_x_origin
= x
;
4345 xgcv
.clip_y_origin
= y
;
4346 xgcv
.function
= GXcopy
;
4347 XChangeGC (s
->display
, s
->gc
, mask
, &xgcv
);
4349 XCopyArea (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
4350 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
4351 XSetClipMask (s
->display
, s
->gc
, None
);
4356 mac_copy_area_to_pixmap (s
->display
, s
->img
->pixmap
, pixmap
, s
->gc
,
4357 0, 0, s
->img
->width
, s
->img
->height
, x
, y
);
4359 /* When the image has a mask, we can expect that at
4360 least part of a mouse highlight or a block cursor will
4361 be visible. If the image doesn't have a mask, make
4362 a block cursor visible by drawing a rectangle around
4363 the image. I believe it's looking better if we do
4364 nothing here for mouse-face. */
4365 if (s
->hl
== DRAW_CURSOR
)
4366 mac_draw_rectangle_to_pixmap (s
->display
, pixmap
, s
->gc
, x
, y
,
4367 s
->img
->width
- 1, s
->img
->height
- 1);
4371 /* Draw a rectangle if image could not be loaded. */
4372 mac_draw_rectangle_to_pixmap (s
->display
, pixmap
, s
->gc
, x
, y
,
4373 s
->img
->width
- 1, s
->img
->height
- 1);
4377 /* Draw part of the background of glyph string S. X, Y, W, and H
4378 give the rectangle to draw. */
4381 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
4382 struct glyph_string
*s
;
4385 #if 0 /* MAC_TODO: stipple */
4388 /* Fill background with a stipple pattern. */
4389 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
4390 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
4391 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
4395 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
4399 /* Draw image glyph string S.
4402 s->x +-------------------------
4405 | +-------------------------
4408 | | +-------------------
4414 x_draw_image_glyph_string (s
)
4415 struct glyph_string
*s
;
4418 int box_line_width
= s
->face
->box_line_width
;
4419 int margin
= s
->img
->margin
;
4423 height
= s
->height
- 2 * box_line_width
;
4425 /* Fill background with face under the image. Do it only if row is
4426 taller than image or if image has a clip mask to reduce
4428 s
->stippled_p
= s
->face
->stipple
!= 0;
4429 if (height
> s
->img
->height
4431 #if 0 /* MAC_TODO: image mask */
4434 || s
->img
->pixmap
== 0
4435 || s
->width
!= s
->background_width
)
4437 if (box_line_width
&& s
->first_glyph
->left_box_line_p
)
4438 x
= s
->x
+ box_line_width
;
4442 y
= s
->y
+ box_line_width
;
4444 #if 0 /* MAC_TODO: image mask */
4447 /* Create a pixmap as large as the glyph string Fill it with
4448 the background color. Copy the image to it, using its
4449 mask. Copy the temporary pixmap to the display. */
4450 Screen
*screen
= FRAME_X_SCREEN (s
->f
);
4451 int depth
= DefaultDepthOfScreen (screen
);
4453 /* Create a pixmap as large as the glyph string. */
4454 pixmap
= XCreatePixmap (s
->display
, s
->window
,
4455 s
->background_width
,
4458 /* Don't clip in the following because we're working on the
4460 XSetClipMask (s
->display
, s
->gc
, None
);
4462 /* Fill the pixmap with the background color/stipple. */
4465 /* Fill background with a stipple pattern. */
4466 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
4467 XFillRectangle (s
->display
, pixmap
, s
->gc
,
4468 0, 0, s
->background_width
, s
->height
);
4469 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
4474 XGetGCValues (s
->display
, s
->gc
, GCForeground
| GCBackground
,
4476 XSetForeground (s
->display
, s
->gc
, xgcv
.background
);
4477 XFillRectangle (s
->display
, pixmap
, s
->gc
,
4478 0, 0, s
->background_width
, s
->height
);
4479 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4484 /* Implementation idea: Is it possible to construct a mask?
4485 We could look at the color at the margins of the image, and
4486 say that this color is probably the background color of the
4488 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
4490 s
->background_filled_p
= 1;
4493 /* Draw the foreground. */
4496 x_draw_image_foreground_1 (s
, pixmap
);
4497 x_set_glyph_string_clipping (s
);
4498 mac_copy_area (s
->display
, pixmap
, s
->window
, s
->gc
,
4499 0, 0, s
->background_width
, s
->height
, s
->x
, s
->y
);
4500 XFreePixmap (s
->display
, pixmap
);
4503 x_draw_image_foreground (s
);
4505 /* If we must draw a relief around the image, do it. */
4507 || s
->hl
== DRAW_IMAGE_RAISED
4508 || s
->hl
== DRAW_IMAGE_SUNKEN
)
4509 x_draw_image_relief (s
);
4513 /* Draw stretch glyph string S. */
4516 x_draw_stretch_glyph_string (s
)
4517 struct glyph_string
*s
;
4519 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
4520 s
->stippled_p
= s
->face
->stipple
!= 0;
4522 if (s
->hl
== DRAW_CURSOR
4523 && !x_stretch_cursor_p
)
4525 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
4526 as wide as the stretch glyph. */
4527 int width
= min (CANON_X_UNIT (s
->f
), s
->background_width
);
4530 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, width
, s
->height
);
4532 /* Clear rest using the GC of the original non-cursor face. */
4533 if (width
< s
->background_width
)
4535 GC gc
= s
->face
->gc
;
4536 int x
= s
->x
+ width
, y
= s
->y
;
4537 int w
= s
->background_width
- width
, h
= s
->height
;
4540 x_get_glyph_string_clip_rect (s
, &r
);
4541 mac_set_clip_rectangle (s
->display
, s
->window
, &r
);
4543 #if 0 /* MAC_TODO: stipple */
4544 if (s
->face
->stipple
)
4546 /* Fill background with a stipple pattern. */
4547 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
4548 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
4549 XSetFillStyle (s
->display
, gc
, FillSolid
);
4555 XGetGCValues (s
->display
, gc
, GCForeground
| GCBackground
, &xgcv
);
4556 XSetForeground (s
->display
, gc
, xgcv
.background
);
4557 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
4558 XSetForeground (s
->display
, gc
, xgcv
.foreground
);
4563 x_draw_glyph_string_bg_rect (s
, s
->x
, s
->y
, s
->background_width
,
4566 s
->background_filled_p
= 1;
4570 /* Draw glyph string S. */
4573 x_draw_glyph_string (s
)
4574 struct glyph_string
*s
;
4576 /* If S draws into the background of its successor, draw the
4577 background of the successor first so that S can draw into it.
4578 This makes S->next use XDrawString instead of XDrawImageString. */
4579 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps_p
)
4581 xassert (s
->next
->img
== NULL
);
4582 x_set_glyph_string_gc (s
->next
);
4583 x_set_glyph_string_clipping (s
->next
);
4584 x_draw_glyph_string_background (s
->next
, 1);
4587 /* Set up S->gc, set clipping and draw S. */
4588 x_set_glyph_string_gc (s
);
4589 x_set_glyph_string_clipping (s
);
4591 switch (s
->first_glyph
->type
)
4594 x_draw_image_glyph_string (s
);
4598 x_draw_stretch_glyph_string (s
);
4602 if (s
->for_overlaps_p
)
4603 s
->background_filled_p
= 1;
4605 x_draw_glyph_string_background (s
, 0);
4606 x_draw_glyph_string_foreground (s
);
4609 case COMPOSITE_GLYPH
:
4610 if (s
->for_overlaps_p
|| s
->gidx
> 0)
4611 s
->background_filled_p
= 1;
4613 x_draw_glyph_string_background (s
, 1);
4614 x_draw_composite_glyph_string_foreground (s
);
4621 if (!s
->for_overlaps_p
)
4623 /* Draw underline. */
4624 if (s
->face
->underline_p
)
4626 unsigned long h
= 1;
4627 unsigned long dy
= s
->height
- h
;
4629 if (s
->face
->underline_defaulted_p
)
4630 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4635 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4636 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
4637 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4639 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4643 /* Draw overline. */
4644 if (s
->face
->overline_p
)
4646 unsigned long dy
= 0, h
= 1;
4648 if (s
->face
->overline_color_defaulted_p
)
4649 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4654 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4655 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
4656 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4658 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4662 /* Draw strike-through. */
4663 if (s
->face
->strike_through_p
)
4665 unsigned long h
= 1;
4666 unsigned long dy
= (s
->height
- h
) / 2;
4668 if (s
->face
->strike_through_color_defaulted_p
)
4669 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4674 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4675 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
4676 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
, s
->y
+ dy
,
4678 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4683 if (s
->face
->box
!= FACE_NO_BOX
)
4684 x_draw_glyph_string_box (s
);
4687 /* Reset clipping. */
4688 mac_reset_clipping (s
->display
, s
->window
);
4692 static int x_fill_composite_glyph_string
P_ ((struct glyph_string
*,
4693 struct face
**, int));
4696 /* Fill glyph string S with composition components specified by S->cmp.
4698 FACES is an array of faces for all components of this composition.
4699 S->gidx is the index of the first component for S.
4700 OVERLAPS_P non-zero means S should draw the foreground only, and
4701 use its physical height for clipping.
4703 Value is the index of a component not in S. */
4706 x_fill_composite_glyph_string (s
, faces
, overlaps_p
)
4707 struct glyph_string
*s
;
4708 struct face
**faces
;
4715 s
->for_overlaps_p
= overlaps_p
;
4717 s
->face
= faces
[s
->gidx
];
4718 s
->font
= s
->face
->font
;
4719 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4721 /* For all glyphs of this composition, starting at the offset
4722 S->gidx, until we reach the end of the definition or encounter a
4723 glyph that requires the different face, add it to S. */
4725 for (i
= s
->gidx
+ 1; i
< s
->cmp
->glyph_len
&& faces
[i
] == s
->face
; ++i
)
4728 /* All glyph strings for the same composition has the same width,
4729 i.e. the width set for the first component of the composition. */
4731 s
->width
= s
->first_glyph
->pixel_width
;
4733 /* If the specified font could not be loaded, use the frame's
4734 default font, but record the fact that we couldn't load it in
4735 the glyph string so that we can draw rectangles for the
4736 characters of the glyph string. */
4737 if (s
->font
== NULL
)
4739 s
->font_not_found_p
= 1;
4740 s
->font
= FRAME_FONT (s
->f
);
4743 /* Adjust base line for subscript/superscript text. */
4744 s
->ybase
+= s
->first_glyph
->voffset
;
4746 xassert (s
->face
&& s
->face
->gc
);
4748 /* This glyph string must always be drawn with 16-bit functions. */
4751 return s
->gidx
+ s
->nchars
;
4755 /* Fill glyph string S from a sequence of character glyphs.
4757 FACE_ID is the face id of the string. START is the index of the
4758 first glyph to consider, END is the index of the last + 1.
4759 OVERLAPS_P non-zero means S should draw the foreground only, and
4760 use its physical height for clipping.
4762 Value is the index of the first glyph not in S. */
4765 x_fill_glyph_string (s
, face_id
, start
, end
, overlaps_p
)
4766 struct glyph_string
*s
;
4768 int start
, end
, overlaps_p
;
4770 struct glyph
*glyph
, *last
;
4772 int glyph_not_available_p
;
4774 xassert (s
->f
== XFRAME (s
->w
->frame
));
4775 xassert (s
->nchars
== 0);
4776 xassert (start
>= 0 && end
> start
);
4778 s
->for_overlaps_p
= overlaps_p
,
4779 glyph
= s
->row
->glyphs
[s
->area
] + start
;
4780 last
= s
->row
->glyphs
[s
->area
] + end
;
4781 voffset
= glyph
->voffset
;
4783 glyph_not_available_p
= glyph
->glyph_not_available_p
;
4786 && glyph
->type
== CHAR_GLYPH
4787 && glyph
->voffset
== voffset
4788 /* Same face id implies same font, nowadays. */
4789 && glyph
->face_id
== face_id
4790 && glyph
->glyph_not_available_p
== glyph_not_available_p
)
4794 s
->face
= x_get_glyph_face_and_encoding (s
->f
, glyph
,
4795 s
->char2b
+ s
->nchars
,
4797 s
->two_byte_p
= two_byte_p
;
4799 xassert (s
->nchars
<= end
- start
);
4800 s
->width
+= glyph
->pixel_width
;
4804 s
->font
= s
->face
->font
;
4805 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4807 /* If the specified font could not be loaded, use the frame's font,
4808 but record the fact that we couldn't load it in
4809 S->font_not_found_p so that we can draw rectangles for the
4810 characters of the glyph string. */
4811 if (s
->font
== NULL
|| glyph_not_available_p
)
4813 s
->font_not_found_p
= 1;
4814 s
->font
= FRAME_FONT (s
->f
);
4817 /* Adjust base line for subscript/superscript text. */
4818 s
->ybase
+= voffset
;
4820 xassert (s
->face
&& s
->face
->gc
);
4821 return glyph
- s
->row
->glyphs
[s
->area
];
4825 /* Fill glyph string S from image glyph S->first_glyph. */
4828 x_fill_image_glyph_string (s
)
4829 struct glyph_string
*s
;
4831 xassert (s
->first_glyph
->type
== IMAGE_GLYPH
);
4832 s
->img
= IMAGE_FROM_ID (s
->f
, s
->first_glyph
->u
.img_id
);
4834 s
->face
= FACE_FROM_ID (s
->f
, s
->first_glyph
->face_id
);
4835 s
->font
= s
->face
->font
;
4836 s
->width
= s
->first_glyph
->pixel_width
;
4838 /* Adjust base line for subscript/superscript text. */
4839 s
->ybase
+= s
->first_glyph
->voffset
;
4843 /* Fill glyph string S from a sequence of stretch glyphs.
4845 ROW is the glyph row in which the glyphs are found, AREA is the
4846 area within the row. START is the index of the first glyph to
4847 consider, END is the index of the last + 1.
4849 Value is the index of the first glyph not in S. */
4852 x_fill_stretch_glyph_string (s
, row
, area
, start
, end
)
4853 struct glyph_string
*s
;
4854 struct glyph_row
*row
;
4855 enum glyph_row_area area
;
4858 struct glyph
*glyph
, *last
;
4859 int voffset
, face_id
;
4861 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
4863 glyph
= s
->row
->glyphs
[s
->area
] + start
;
4864 last
= s
->row
->glyphs
[s
->area
] + end
;
4865 face_id
= glyph
->face_id
;
4866 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
4867 s
->font
= s
->face
->font
;
4868 s
->font_info
= FONT_INFO_FROM_ID (s
->f
, s
->face
->font_info_id
);
4869 s
->width
= glyph
->pixel_width
;
4870 voffset
= glyph
->voffset
;
4874 && glyph
->type
== STRETCH_GLYPH
4875 && glyph
->voffset
== voffset
4876 && glyph
->face_id
== face_id
);
4878 s
->width
+= glyph
->pixel_width
;
4880 /* Adjust base line for subscript/superscript text. */
4881 s
->ybase
+= voffset
;
4883 xassert (s
->face
&& s
->face
->gc
);
4884 return glyph
- s
->row
->glyphs
[s
->area
];
4888 /* Initialize glyph string S. CHAR2B is a suitably allocated vector
4889 of XChar2b structures for S; it can't be allocated in
4890 x_init_glyph_string because it must be allocated via `alloca'. W
4891 is the window on which S is drawn. ROW and AREA are the glyph row
4892 and area within the row from which S is constructed. START is the
4893 index of the first glyph structure covered by S. HL is a
4894 face-override for drawing S. */
4897 x_init_glyph_string (s
, char2b
, w
, row
, area
, start
, hl
)
4898 struct glyph_string
*s
;
4901 struct glyph_row
*row
;
4902 enum glyph_row_area area
;
4904 enum draw_glyphs_face hl
;
4906 bzero (s
, sizeof *s
);
4908 s
->f
= XFRAME (w
->frame
);
4909 s
->display
= FRAME_MAC_DISPLAY (s
->f
);
4910 s
->window
= FRAME_MAC_WINDOW (s
->f
);
4915 s
->first_glyph
= row
->glyphs
[area
] + start
;
4916 s
->height
= row
->height
;
4917 s
->y
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
4919 /* Display the internal border below the tool-bar window. */
4920 if (s
->w
== XWINDOW (s
->f
->tool_bar_window
))
4921 s
->y
-= s
->f
->output_data
.mac
->internal_border_width
;
4923 s
->ybase
= s
->y
+ row
->ascent
;
4927 /* Set background width of glyph string S. START is the index of the
4928 first glyph following S. LAST_X is the right-most x-position + 1
4929 in the drawing area. */
4932 x_set_glyph_string_background_width (s
, start
, last_x
)
4933 struct glyph_string
*s
;
4937 /* If the face of this glyph string has to be drawn to the end of
4938 the drawing area, set S->extends_to_end_of_line_p. */
4939 struct face
*default_face
= FACE_FROM_ID (s
->f
, DEFAULT_FACE_ID
);
4941 if (start
== s
->row
->used
[s
->area
]
4942 && s
->hl
== DRAW_NORMAL_TEXT
4943 && ((s
->area
== TEXT_AREA
&& s
->row
->fill_line_p
)
4944 || s
->face
->background
!= default_face
->background
4945 || s
->face
->stipple
!= default_face
->stipple
))
4946 s
->extends_to_end_of_line_p
= 1;
4948 /* If S extends its face to the end of the line, set its
4949 background_width to the distance to the right edge of the drawing
4951 if (s
->extends_to_end_of_line_p
)
4952 s
->background_width
= last_x
- s
->x
+ 1;
4954 s
->background_width
= s
->width
;
4958 /* Add a glyph string for a stretch glyph to the list of strings
4959 between HEAD and TAIL. START is the index of the stretch glyph in
4960 row area AREA of glyph row ROW. END is the index of the last glyph
4961 in that glyph row area. X is the current output position assigned
4962 to the new glyph string constructed. HL overrides that face of the
4963 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4964 is the right-most x-position of the drawing area. */
4966 /* SunOS 4 bundled cc, barfed on continuations in the arg lists here
4967 and below -- keep them on one line. */
4968 #define BUILD_STRETCH_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4971 s = (struct glyph_string *) alloca (sizeof *s); \
4972 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
4973 START = x_fill_stretch_glyph_string (s, ROW, AREA, START, END); \
4974 x_append_glyph_string (&HEAD, &TAIL, s); \
4980 /* Add a glyph string for an image glyph to the list of strings
4981 between HEAD and TAIL. START is the index of the image glyph in
4982 row area AREA of glyph row ROW. END is the index of the last glyph
4983 in that glyph row area. X is the current output position assigned
4984 to the new glyph string constructed. HL overrides that face of the
4985 glyph; e.g. it is DRAW_CURSOR if a cursor has to be drawn. LAST_X
4986 is the right-most x-position of the drawing area. */
4988 #define BUILD_IMAGE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X) \
4991 s = (struct glyph_string *) alloca (sizeof *s); \
4992 x_init_glyph_string (s, NULL, W, ROW, AREA, START, HL); \
4993 x_fill_image_glyph_string (s); \
4994 x_append_glyph_string (&HEAD, &TAIL, s); \
5001 /* Add a glyph string for a sequence of character glyphs to the list
5002 of strings between HEAD and TAIL. START is the index of the first
5003 glyph in row area AREA of glyph row ROW that is part of the new
5004 glyph string. END is the index of the last glyph in that glyph row
5005 area. X is the current output position assigned to the new glyph
5006 string constructed. HL overrides that face of the glyph; e.g. it
5007 is DRAW_CURSOR if a cursor has to be drawn. LAST_X is the
5008 right-most x-position of the drawing area. */
5010 #define BUILD_CHAR_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
5016 c = (ROW)->glyphs[AREA][START].u.ch; \
5017 face_id = (ROW)->glyphs[AREA][START].face_id; \
5019 s = (struct glyph_string *) alloca (sizeof *s); \
5020 char2b = (XChar2b *) alloca ((END - START) * sizeof *char2b); \
5021 x_init_glyph_string (s, char2b, W, ROW, AREA, START, HL); \
5022 x_append_glyph_string (&HEAD, &TAIL, s); \
5024 START = x_fill_glyph_string (s, face_id, START, END, \
5030 /* Add a glyph string for a composite sequence to the list of strings
5031 between HEAD and TAIL. START is the index of the first glyph in
5032 row area AREA of glyph row ROW that is part of the new glyph
5033 string. END is the index of the last glyph in that glyph row area.
5034 X is the current output position assigned to the new glyph string
5035 constructed. HL overrides that face of the glyph; e.g. it is
5036 DRAW_CURSOR if a cursor has to be drawn. LAST_X is the right-most
5037 x-position of the drawing area. */
5039 #define BUILD_COMPOSITE_GLYPH_STRING(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
5041 int cmp_id = (ROW)->glyphs[AREA][START].u.cmp_id; \
5042 int face_id = (ROW)->glyphs[AREA][START].face_id; \
5043 struct face *base_face = FACE_FROM_ID (XFRAME (w->frame), face_id); \
5044 struct composition *cmp = composition_table[cmp_id]; \
5045 int glyph_len = cmp->glyph_len; \
5047 struct face **faces; \
5048 struct glyph_string *first_s = NULL; \
5051 base_face = base_face->ascii_face; \
5052 char2b = (XChar2b *) alloca ((sizeof *char2b) * glyph_len); \
5053 faces = (struct face **) alloca ((sizeof *faces) * glyph_len); \
5054 /* At first, fill in `char2b' and `faces'. */ \
5055 for (n = 0; n < glyph_len; n++) \
5057 int c = COMPOSITION_GLYPH (cmp, n); \
5058 int this_face_id = FACE_FOR_CHAR (XFRAME (w->frame), base_face, c); \
5059 faces[n] = FACE_FROM_ID (XFRAME (w->frame), this_face_id); \
5060 x_get_char_face_and_encoding (XFRAME (w->frame), c, \
5061 this_face_id, char2b + n, 1); \
5064 /* Make glyph_strings for each glyph sequence that is drawable by \
5065 the same face, and append them to HEAD/TAIL. */ \
5066 for (n = 0; n < cmp->glyph_len;) \
5068 s = (struct glyph_string *) alloca (sizeof *s); \
5069 x_init_glyph_string (s, char2b + n, W, ROW, AREA, START, HL); \
5070 x_append_glyph_string (&(HEAD), &(TAIL), s); \
5078 n = x_fill_composite_glyph_string (s, faces, OVERLAPS_P); \
5086 /* Build a list of glyph strings between HEAD and TAIL for the glyphs
5087 of AREA of glyph row ROW on window W between indices START and END.
5088 HL overrides the face for drawing glyph strings, e.g. it is
5089 DRAW_CURSOR to draw a cursor. X and LAST_X are start and end
5090 x-positions of the drawing area.
5092 This is an ugly monster macro construct because we must use alloca
5093 to allocate glyph strings (because x_draw_glyphs can be called
5096 #define BUILD_GLYPH_STRINGS(W, ROW, AREA, START, END, HEAD, TAIL, HL, X, LAST_X, OVERLAPS_P) \
5099 HEAD = TAIL = NULL; \
5100 while (START < END) \
5102 struct glyph *first_glyph = (ROW)->glyphs[AREA] + START; \
5103 switch (first_glyph->type) \
5106 BUILD_CHAR_GLYPH_STRINGS (W, ROW, AREA, START, END, HEAD, \
5107 TAIL, HL, X, LAST_X, \
5111 case COMPOSITE_GLYPH: \
5112 BUILD_COMPOSITE_GLYPH_STRING (W, ROW, AREA, START, END, \
5113 HEAD, TAIL, HL, X, LAST_X,\
5117 case STRETCH_GLYPH: \
5118 BUILD_STRETCH_GLYPH_STRING (W, ROW, AREA, START, END, \
5119 HEAD, TAIL, HL, X, LAST_X); \
5123 BUILD_IMAGE_GLYPH_STRING (W, ROW, AREA, START, END, HEAD, \
5124 TAIL, HL, X, LAST_X); \
5131 x_set_glyph_string_background_width (s, START, LAST_X); \
5138 /* Draw glyphs between START and END in AREA of ROW on window W,
5139 starting at x-position X. X is relative to AREA in W. HL is a
5140 face-override with the following meaning:
5142 DRAW_NORMAL_TEXT draw normally
5143 DRAW_CURSOR draw in cursor face
5144 DRAW_MOUSE_FACE draw in mouse face.
5145 DRAW_INVERSE_VIDEO draw in mode line face
5146 DRAW_IMAGE_SUNKEN draw an image with a sunken relief around it
5147 DRAW_IMAGE_RAISED draw an image with a raised relief around it
5149 If REAL_START is non-null, return in *REAL_START the real starting
5150 position for display. This can be different from START in case
5151 overlapping glyphs must be displayed. If REAL_END is non-null,
5152 return in *REAL_END the real end position for display. This can be
5153 different from END in case overlapping glyphs must be displayed.
5155 If OVERLAPS_P is non-zero, draw only the foreground of characters
5156 and clip to the physical height of ROW.
5158 Value is the x-position reached, relative to AREA of W. */
5161 x_draw_glyphs (w
, x
, row
, area
, start
, end
, hl
, real_start
, real_end
,
5165 struct glyph_row
*row
;
5166 enum glyph_row_area area
;
5168 enum draw_glyphs_face hl
;
5169 int *real_start
, *real_end
;
5172 struct glyph_string
*head
, *tail
;
5173 struct glyph_string
*s
;
5174 int last_x
, area_width
;
5178 /* Let's rather be paranoid than getting a SEGV. */
5179 start
= max (0, start
);
5180 end
= min (end
, row
->used
[area
]);
5182 *real_start
= start
;
5186 /* Translate X to frame coordinates. Set last_x to the right
5187 end of the drawing area. */
5188 if (row
->full_width_p
)
5190 /* X is relative to the left edge of W, without scroll bars
5192 struct frame
*f
= XFRAME (w
->frame
);
5193 /* int width = FRAME_FLAGS_AREA_WIDTH (f); */
5194 int window_left_x
= WINDOW_LEFT_MARGIN (w
) * CANON_X_UNIT (f
);
5197 area_width
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
5198 last_x
= window_left_x
+ area_width
;
5200 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5202 int width
= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
5203 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
5209 x
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
5210 last_x
-= FRAME_INTERNAL_BORDER_WIDTH (f
);
5214 x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, x
);
5215 area_width
= window_box_width (w
, area
);
5216 last_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, area
, area_width
);
5219 /* Build a doubly-linked list of glyph_string structures between
5220 head and tail from what we have to draw. Note that the macro
5221 BUILD_GLYPH_STRINGS will modify its start parameter. That's
5222 the reason we use a separate variable `i'. */
5224 BUILD_GLYPH_STRINGS (w
, row
, area
, i
, end
, head
, tail
, hl
, x
, last_x
,
5227 x_reached
= tail
->x
+ tail
->background_width
;
5231 /* If there are any glyphs with lbearing < 0 or rbearing > width in
5232 the row, redraw some glyphs in front or following the glyph
5233 strings built above. */
5234 if (!overlaps_p
&& row
->contains_overlapping_glyphs_p
)
5237 struct glyph_string
*h
, *t
;
5239 /* Compute overhangs for all glyph strings. */
5240 for (s
= head
; s
; s
= s
->next
)
5241 x_compute_glyph_string_overhangs (s
);
5243 /* Prepend glyph strings for glyphs in front of the first glyph
5244 string that are overwritten because of the first glyph
5245 string's left overhang. The background of all strings
5246 prepended must be drawn because the first glyph string
5248 i
= x_left_overwritten (head
);
5252 BUILD_GLYPH_STRINGS (w
, row
, area
, j
, start
, h
, t
,
5253 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
5257 *real_start
= start
;
5258 x_compute_overhangs_and_x (t
, head
->x
, 1);
5259 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
5262 /* Prepend glyph strings for glyphs in front of the first glyph
5263 string that overwrite that glyph string because of their
5264 right overhang. For these strings, only the foreground must
5265 be drawn, because it draws over the glyph string at `head'.
5266 The background must not be drawn because this would overwrite
5267 right overhangs of preceding glyphs for which no glyph
5269 i
= x_left_overwriting (head
);
5272 BUILD_GLYPH_STRINGS (w
, row
, area
, i
, start
, h
, t
,
5273 DRAW_NORMAL_TEXT
, dummy_x
, last_x
,
5275 for (s
= h
; s
; s
= s
->next
)
5276 s
->background_filled_p
= 1;
5279 x_compute_overhangs_and_x (t
, head
->x
, 1);
5280 x_prepend_glyph_string_lists (&head
, &tail
, h
, t
);
5283 /* Append glyphs strings for glyphs following the last glyph
5284 string tail that are overwritten by tail. The background of
5285 these strings has to be drawn because tail's foreground draws
5287 i
= x_right_overwritten (tail
);
5290 BUILD_GLYPH_STRINGS (w
, row
, area
, end
, i
, h
, t
,
5291 DRAW_NORMAL_TEXT
, x
, last_x
,
5293 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
5294 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
5299 /* Append glyph strings for glyphs following the last glyph
5300 string tail that overwrite tail. The foreground of such
5301 glyphs has to be drawn because it writes into the background
5302 of tail. The background must not be drawn because it could
5303 paint over the foreground of following glyphs. */
5304 i
= x_right_overwriting (tail
);
5307 BUILD_GLYPH_STRINGS (w
, row
, area
, end
, i
, h
, t
,
5308 DRAW_NORMAL_TEXT
, x
, last_x
,
5310 for (s
= h
; s
; s
= s
->next
)
5311 s
->background_filled_p
= 1;
5312 x_compute_overhangs_and_x (h
, tail
->x
+ tail
->width
, 0);
5313 x_append_glyph_string_lists (&head
, &tail
, h
, t
);
5319 /* Draw all strings. */
5320 for (s
= head
; s
; s
= s
->next
)
5321 x_draw_glyph_string (s
);
5323 /* Value is the x-position up to which drawn, relative to AREA of W.
5324 This doesn't include parts drawn because of overhangs. */
5325 x_reached
= FRAME_TO_WINDOW_PIXEL_X (w
, x_reached
);
5326 if (!row
->full_width_p
)
5328 if (area
> LEFT_MARGIN_AREA
)
5329 x_reached
-= window_box_width (w
, LEFT_MARGIN_AREA
);
5330 if (area
> TEXT_AREA
)
5331 x_reached
-= window_box_width (w
, TEXT_AREA
);
5337 /* Fix the display of area AREA of overlapping row ROW in window W. */
5340 x_fix_overlapping_area (w
, row
, area
)
5342 struct glyph_row
*row
;
5343 enum glyph_row_area area
;
5349 if (area
== LEFT_MARGIN_AREA
)
5351 else if (area
== TEXT_AREA
)
5352 x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
5354 x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5355 + window_box_width (w
, TEXT_AREA
));
5357 for (i
= 0; i
< row
->used
[area
];)
5359 if (row
->glyphs
[area
][i
].overlaps_vertically_p
)
5361 int start
= i
, start_x
= x
;
5365 x
+= row
->glyphs
[area
][i
].pixel_width
;
5368 while (i
< row
->used
[area
]
5369 && row
->glyphs
[area
][i
].overlaps_vertically_p
);
5371 x_draw_glyphs (w
, start_x
, row
, area
, start
, i
,
5373 ? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
),
5378 x
+= row
->glyphs
[area
][i
].pixel_width
;
5387 /* Output LEN glyphs starting at START at the nominal cursor position.
5388 Advance the nominal cursor over the text. The global variable
5389 updated_window contains the window being updated, updated_row is
5390 the glyph row being updated, and updated_area is the area of that
5391 row being updated. */
5394 x_write_glyphs (start
, len
)
5395 struct glyph
*start
;
5398 int x
, hpos
, real_start
, real_end
;
5400 xassert (updated_window
&& updated_row
);
5405 hpos
= start
- updated_row
->glyphs
[updated_area
];
5406 x
= x_draw_glyphs (updated_window
, output_cursor
.x
,
5407 updated_row
, updated_area
,
5409 (updated_row
->inverse_p
5410 ? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
),
5411 &real_start
, &real_end
, 0);
5413 /* If we drew over the cursor, note that it is not visible any more. */
5414 note_overwritten_text_cursor (updated_window
, real_start
,
5415 real_end
- real_start
);
5419 /* Advance the output cursor. */
5420 output_cursor
.hpos
+= len
;
5421 output_cursor
.x
= x
;
5425 /* Insert LEN glyphs from START at the nominal cursor position. */
5428 x_insert_glyphs (start
, len
)
5429 struct glyph
*start
;
5434 int line_height
, shift_by_width
, shifted_region_width
;
5435 struct glyph_row
*row
;
5436 struct glyph
*glyph
;
5437 int frame_x
, frame_y
, hpos
, real_start
, real_end
;
5439 xassert (updated_window
&& updated_row
);
5442 f
= XFRAME (WINDOW_FRAME (w
));
5444 /* Get the height of the line we are in. */
5446 line_height
= row
->height
;
5448 /* Get the width of the glyphs to insert. */
5450 for (glyph
= start
; glyph
< start
+ len
; ++glyph
)
5451 shift_by_width
+= glyph
->pixel_width
;
5453 /* Get the width of the region to shift right. */
5454 shifted_region_width
= (window_box_width (w
, updated_area
)
5459 frame_x
= WINDOW_TO_FRAME_PIXEL_X (w
, output_cursor
.x
);
5460 frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, output_cursor
.y
);
5462 mac_scroll_area (FRAME_MAC_DISPLAY (f
), FRAME_MAC_WINDOW (f
),
5463 f
->output_data
.mac
->normal_gc
,
5465 shifted_region_width
, line_height
,
5466 frame_x
+ shift_by_width
, frame_y
);
5468 /* Write the glyphs. */
5469 hpos
= start
- row
->glyphs
[updated_area
];
5470 x_draw_glyphs (w
, output_cursor
.x
, row
, updated_area
, hpos
, hpos
+ len
,
5471 DRAW_NORMAL_TEXT
, &real_start
, &real_end
, 0);
5472 note_overwritten_text_cursor (w
, real_start
, real_end
- real_start
);
5474 /* Advance the output cursor. */
5475 output_cursor
.hpos
+= len
;
5476 output_cursor
.x
+= shift_by_width
;
5481 /* Delete N glyphs at the nominal cursor position. Not implemented
5492 /* Erase the current text line from the nominal cursor position
5493 (inclusive) to pixel column TO_X (exclusive). The idea is that
5494 everything from TO_X onward is already erased.
5496 TO_X is a pixel position relative to updated_area of
5497 updated_window. TO_X == -1 means clear to the end of this area. */
5500 x_clear_end_of_line (to_x
)
5504 struct window
*w
= updated_window
;
5505 int max_x
, min_y
, max_y
;
5506 int from_x
, from_y
, to_y
;
5508 xassert (updated_window
&& updated_row
);
5509 f
= XFRAME (w
->frame
);
5511 if (updated_row
->full_width_p
)
5513 max_x
= XFASTINT (w
->width
) * CANON_X_UNIT (f
);
5514 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
5515 && !w
->pseudo_window_p
)
5516 max_x
+= FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
5519 max_x
= window_box_width (w
, updated_area
);
5520 max_y
= window_text_bottom_y (w
);
5522 /* TO_X == 0 means don't do anything. TO_X < 0 means clear to end
5523 of window. For TO_X > 0, truncate to end of drawing area. */
5529 to_x
= min (to_x
, max_x
);
5531 to_y
= min (max_y
, output_cursor
.y
+ updated_row
->height
);
5533 /* Notice if the cursor will be cleared by this operation. */
5534 if (!updated_row
->full_width_p
)
5535 note_overwritten_text_cursor (w
, output_cursor
.hpos
, -1);
5537 from_x
= output_cursor
.x
;
5539 /* Translate to frame coordinates. */
5540 if (updated_row
->full_width_p
)
5542 from_x
= WINDOW_TO_FRAME_PIXEL_X (w
, from_x
);
5543 to_x
= WINDOW_TO_FRAME_PIXEL_X (w
, to_x
);
5547 from_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, from_x
);
5548 to_x
= WINDOW_AREA_TO_FRAME_PIXEL_X (w
, updated_area
, to_x
);
5551 min_y
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
5552 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (min_y
, output_cursor
.y
));
5553 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, to_y
);
5555 /* Prevent inadvertently clearing to end of the X window. */
5556 if (to_x
> from_x
&& to_y
> from_y
)
5559 XClearArea (FRAME_MAC_DISPLAY (f
), FRAME_MAC_WINDOW (f
),
5560 from_x
, from_y
, to_x
- from_x
, to_y
- from_y
,
5567 /* Clear entire frame. If updating_frame is non-null, clear that
5568 frame. Otherwise clear the selected frame. */
5578 f
= SELECTED_FRAME ();
5580 /* Clearing the frame will erase any cursor, so mark them all as no
5582 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
5583 output_cursor
.hpos
= output_cursor
.vpos
= 0;
5584 output_cursor
.x
= -1;
5586 /* We don't set the output cursor here because there will always
5587 follow an explicit cursor_to. */
5589 XClearWindow (FRAME_MAC_DISPLAY (f
), FRAME_MAC_WINDOW (f
));
5591 #if 0 /* Clearing frame on Mac OS clears scroll bars. */
5592 /* We have to clear the scroll bars, too. If we have changed
5593 colors or something like that, then they should be notified. */
5594 x_scroll_bar_clear (f
);
5597 XFlush (FRAME_MAC_DISPLAY (f
));
5603 /* Invert the middle quarter of the frame for .15 sec. */
5605 /* We use the select system call to do the waiting, so we have to make
5606 sure it's available. If it isn't, we just won't do visual bells. */
5608 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
5610 /* Subtract the `struct timeval' values X and Y, storing the result in
5611 *RESULT. Return 1 if the difference is negative, otherwise 0. */
5614 timeval_subtract (result
, x
, y
)
5615 struct timeval
*result
, x
, y
;
5617 /* Perform the carry for the later subtraction by updating y. This
5618 is safer because on some systems the tv_sec member is unsigned. */
5619 if (x
.tv_usec
< y
.tv_usec
)
5621 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
5622 y
.tv_usec
-= 1000000 * nsec
;
5626 if (x
.tv_usec
- y
.tv_usec
> 1000000)
5628 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
5629 y
.tv_usec
+= 1000000 * nsec
;
5633 /* Compute the time remaining to wait. tv_usec is certainly
5635 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
5636 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
5638 /* Return indication of whether the result should be considered
5640 return x
.tv_sec
< y
.tv_sec
;
5652 struct timeval wakeup
;
5654 EMACS_GET_TIME (wakeup
);
5656 /* Compute time to wait until, propagating carry from usecs. */
5657 wakeup
.tv_usec
+= 150000;
5658 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
5659 wakeup
.tv_usec
%= 1000000;
5661 /* Keep waiting until past the time wakeup. */
5664 struct timeval timeout
;
5666 EMACS_GET_TIME (timeout
);
5668 /* In effect, timeout = wakeup - timeout.
5669 Break if result would be negative. */
5670 if (timeval_subtract (&timeout
, wakeup
, timeout
))
5673 /* Try to wait that long--but we might wake up sooner. */
5674 select (0, NULL
, NULL
, NULL
, &timeout
);
5683 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
5686 /* Make audible bell. */
5691 struct frame
*f
= SELECTED_FRAME ();
5693 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
5701 XFlush (FRAME_MAC_DISPLAY (f
));
5708 /* Specify how many text lines, from the top of the window,
5709 should be affected by insert-lines and delete-lines operations.
5710 This, and those operations, are used only within an update
5711 that is bounded by calls to x_update_begin and x_update_end. */
5714 XTset_terminal_window (n
)
5717 /* This function intentionally left blank. */
5722 /***********************************************************************
5724 ***********************************************************************/
5726 /* Perform an insert-lines or delete-lines operation, inserting N
5727 lines or deleting -N lines at vertical position VPOS. */
5730 x_ins_del_lines (vpos
, n
)
5737 /* Scroll part of the display as described by RUN. */
5740 x_scroll_run (w
, run
)
5744 struct frame
*f
= XFRAME (w
->frame
);
5745 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
5747 /* Get frame-relative bounding box of the text display area of W,
5748 without mode lines. Include in this box the flags areas to the
5749 left and right of W. */
5750 window_box (w
, -1, &x
, &y
, &width
, &height
);
5751 width
+= FRAME_X_FLAGS_AREA_WIDTH (f
);
5752 x
-= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
);
5754 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
5755 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
5756 bottom_y
= y
+ height
;
5760 /* Scrolling up. Make sure we don't copy part of the mode
5761 line at the bottom. */
5762 if (from_y
+ run
->height
> bottom_y
)
5763 height
= bottom_y
- from_y
;
5765 height
= run
->height
;
5769 /* Scolling down. Make sure we don't copy over the mode line.
5771 if (to_y
+ run
->height
> bottom_y
)
5772 height
= bottom_y
- to_y
;
5774 height
= run
->height
;
5779 /* Cursor off. Will be switched on again in x_update_window_end. */
5783 mac_scroll_area (FRAME_MAC_DISPLAY (f
), FRAME_MAC_WINDOW (f
),
5784 f
->output_data
.mac
->normal_gc
,
5794 /***********************************************************************
5796 ***********************************************************************/
5798 /* Redisplay an exposed area of frame F. X and Y are the upper-left
5799 corner of the exposed rectangle. W and H are width and height of
5800 the exposed area. All are pixel values. W or H zero means redraw
5801 the entire frame. */
5804 expose_frame (f
, x
, y
, w
, h
)
5810 TRACE ((stderr
, "expose_frame "));
5812 /* No need to redraw if frame will be redrawn soon. */
5813 if (FRAME_GARBAGED_P (f
))
5815 TRACE ((stderr
, " garbaged\n"));
5819 /* MAC_TODO: this is a kludge, but if scroll bars are not activated
5820 or deactivated here, for unknown reasons, activated scroll bars
5821 are shown in deactivated frames in some instances. */
5822 if (f
== FRAME_MAC_DISPLAY_INFO (f
)->x_focus_frame
)
5823 activate_scroll_bars (f
);
5825 deactivate_scroll_bars (f
);
5827 /* If basic faces haven't been realized yet, there is no point in
5828 trying to redraw anything. This can happen when we get an expose
5829 event while Emacs is starting, e.g. by moving another window. */
5830 if (FRAME_FACE_CACHE (f
) == NULL
5831 || FRAME_FACE_CACHE (f
)->used
< BASIC_FACE_ID_SENTINEL
)
5833 TRACE ((stderr
, " no faces\n"));
5837 if (w
== 0 || h
== 0)
5840 r
.right
= CANON_X_UNIT (f
) * f
->width
;
5841 r
.bottom
= CANON_Y_UNIT (f
) * f
->height
;
5851 TRACE ((stderr
, "(%d, %d, %d, %d)\n", r
.left
, r
.top
, r
.right
, r
.bottom
));
5852 expose_window_tree (XWINDOW (f
->root_window
), &r
);
5854 if (WINDOWP (f
->tool_bar_window
))
5856 struct window
*w
= XWINDOW (f
->tool_bar_window
);
5858 Rect intersection_rect
;
5859 int window_x
, window_y
, window_width
, window_height
;
5862 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
5863 window_rect
.left
= window_x
;
5864 window_rect
.top
= window_y
;
5865 window_rect
.right
= window_x
+ window_width
;
5866 window_rect
.bottom
= window_y
+ window_height
;
5868 if (x_intersect_rectangles (&r
, &window_rect
, &intersection_rect
))
5869 expose_window (w
, &intersection_rect
);
5872 #ifndef USE_X_TOOLKIT
5873 if (WINDOWP (f
->menu_bar_window
))
5875 struct window
*w
= XWINDOW (f
->menu_bar_window
);
5877 Rect intersection_rect
;
5878 int window_x
, window_y
, window_width
, window_height
;
5881 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
5882 window_rect
.left
= window_x
;
5883 window_rect
.top
= window_y
;
5884 window_rect
.right
= window_x
+ window_width
;
5885 window_rect
.bottom
= window_y
+ window_height
;
5887 if (x_intersect_rectangles (&r
, &window_rect
, &intersection_rect
))
5888 expose_window (w
, &intersection_rect
);
5890 #endif /* not USE_X_TOOLKIT */
5894 /* Redraw (parts) of all windows in the window tree rooted at W that
5895 intersect R. R contains frame pixel coordinates. */
5898 expose_window_tree (w
, r
)
5904 if (!NILP (w
->hchild
))
5905 expose_window_tree (XWINDOW (w
->hchild
), r
);
5906 else if (!NILP (w
->vchild
))
5907 expose_window_tree (XWINDOW (w
->vchild
), r
);
5911 Rect intersection_rect
;
5912 struct frame
*f
= XFRAME (w
->frame
);
5913 int window_x
, window_y
, window_width
, window_height
;
5915 /* Frame-relative pixel rectangle of W. */
5916 window_box (w
, -1, &window_x
, &window_y
, &window_width
,
5920 - FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
)
5921 - FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_Y_UNIT (f
));
5922 window_rect
.top
= window_y
;
5923 window_rect
.right
= window_rect
.left
5925 + FRAME_X_FLAGS_AREA_WIDTH (f
)
5926 + FRAME_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
));
5927 window_rect
.bottom
= window_rect
.top
5928 + window_height
+ CURRENT_MODE_LINE_HEIGHT (w
);
5930 if (x_intersect_rectangles (r
, &window_rect
, &intersection_rect
))
5931 expose_window (w
, &intersection_rect
);
5934 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
5939 /* Redraw the part of glyph row area AREA of glyph row ROW on window W
5940 which intersects rectangle R. R is in window-relative coordinates. */
5943 expose_area (w
, row
, r
, area
)
5945 struct glyph_row
*row
;
5947 enum glyph_row_area area
;
5950 struct glyph
*first
= row
->glyphs
[area
];
5951 struct glyph
*end
= row
->glyphs
[area
] + row
->used
[area
];
5955 /* Set x to the window-relative start position for drawing glyphs of
5956 AREA. The first glyph of the text area can be partially visible.
5957 The first glyphs of other areas cannot. */
5958 if (area
== LEFT_MARGIN_AREA
)
5960 else if (area
== TEXT_AREA
)
5961 x
= row
->x
+ window_box_width (w
, LEFT_MARGIN_AREA
);
5963 x
= (window_box_width (w
, LEFT_MARGIN_AREA
)
5964 + window_box_width (w
, TEXT_AREA
));
5966 if (area
== TEXT_AREA
&& row
->fill_line_p
)
5967 /* If row extends face to end of line write the whole line. */
5968 x_draw_glyphs (w
, x
, row
, area
,
5970 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
5974 /* Find the first glyph that must be redrawn. */
5976 && x
+ first
->pixel_width
< r
->left
)
5978 x
+= first
->pixel_width
;
5982 /* Find the last one. */
5988 x
+= last
->pixel_width
;
5994 x_draw_glyphs (w
, first_x
, row
, area
,
5995 first
- row
->glyphs
[area
],
5996 last
- row
->glyphs
[area
],
5997 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
6003 /* Redraw the parts of the glyph row ROW on window W intersecting
6004 rectangle R. R is in window-relative coordinates. */
6007 expose_line (w
, row
, r
)
6009 struct glyph_row
*row
;
6012 xassert (row
->enabled_p
);
6014 if (row
->mode_line_p
|| w
->pseudo_window_p
)
6015 x_draw_glyphs (w
, 0, row
, TEXT_AREA
, 0, row
->used
[TEXT_AREA
],
6016 row
->inverse_p
? DRAW_INVERSE_VIDEO
: DRAW_NORMAL_TEXT
,
6020 if (row
->used
[LEFT_MARGIN_AREA
])
6021 expose_area (w
, row
, r
, LEFT_MARGIN_AREA
);
6022 if (row
->used
[TEXT_AREA
])
6023 expose_area (w
, row
, r
, TEXT_AREA
);
6024 if (row
->used
[RIGHT_MARGIN_AREA
])
6025 expose_area (w
, row
, r
, RIGHT_MARGIN_AREA
);
6026 x_draw_row_bitmaps (w
, row
);
6031 /* Return non-zero if W's cursor intersects rectangle R. */
6034 x_phys_cursor_in_rect_p (w
, r
)
6039 struct glyph
*cursor_glyph
;
6041 cursor_glyph
= get_phys_cursor_glyph (w
);
6044 cr
.left
= w
->phys_cursor
.x
;
6045 cr
.top
= w
->phys_cursor
.y
;
6046 cr
.right
= cr
.left
+ cursor_glyph
->pixel_width
;
6047 cr
.bottom
= cr
.top
+ w
->phys_cursor_height
;
6048 return x_intersect_rectangles (&cr
, r
, &result
);
6055 /* Redraw a rectangle of window W. R is a rectangle in window
6056 relative coordinates. Call this function with input blocked. */
6059 expose_window (w
, r
)
6063 struct glyph_row
*row
;
6065 int yb
= window_text_bottom_y (w
);
6066 int cursor_cleared_p
;
6068 /* If window is not yet fully initialized, do nothing. This can
6069 happen when toolkit scroll bars are used and a window is split.
6070 Reconfiguring the scroll bar will generate an expose for a newly
6072 if (w
->current_matrix
== NULL
)
6075 TRACE ((stderr
, "expose_window (%d, %d, %d, %d)\n",
6076 r
->left
, r
->top
, r
->right
, r
->bottom
));
6078 /* Convert to window coordinates. */
6079 r
->left
= FRAME_TO_WINDOW_PIXEL_X (w
, r
->left
);
6080 r
->top
= FRAME_TO_WINDOW_PIXEL_Y (w
, r
->top
);
6081 r
->right
= FRAME_TO_WINDOW_PIXEL_X (w
, r
->right
);
6082 r
->bottom
= FRAME_TO_WINDOW_PIXEL_Y (w
, r
->bottom
);
6084 /* Turn off the cursor. */
6085 if (!w
->pseudo_window_p
6086 && x_phys_cursor_in_rect_p (w
, r
))
6089 cursor_cleared_p
= 1;
6092 cursor_cleared_p
= 0;
6094 /* Find the first row intersecting the rectangle R. */
6095 row
= w
->current_matrix
->rows
;
6097 while (row
->enabled_p
6099 && y
+ row
->height
< r
->top
)
6105 /* Display the text in the rectangle, one text line at a time. */
6106 while (row
->enabled_p
6110 expose_line (w
, row
, r
);
6115 /* Display the mode line if there is one. */
6116 if (WINDOW_WANTS_MODELINE_P (w
)
6117 && (row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
),
6119 && row
->y
< r
->bottom
)
6120 expose_line (w
, row
, r
);
6122 if (!w
->pseudo_window_p
)
6124 /* Draw border between windows. */
6125 x_draw_vertical_border (w
);
6127 /* Turn the cursor on again. */
6128 if (cursor_cleared_p
)
6129 x_update_window_cursor (w
, 1);
6132 /* Display scroll bar for this window. */
6133 if (!NILP (w
->vertical_scroll_bar
))
6136 = SCROLL_BAR_CONTROL_HANDLE (XSCROLL_BAR (w
->vertical_scroll_bar
));
6143 /* Determine the intersection of two rectangles R1 and R2. Return
6144 the intersection in *RESULT. Value is non-zero if RESULT is not
6148 x_intersect_rectangles (r1
, r2
, result
)
6149 Rect
*r1
, *r2
, *result
;
6152 Rect
*upper
, *lower
;
6153 int intersection_p
= 0;
6155 /* Rerrange so that R1 is the left-most rectangle. */
6156 if (r1
->left
< r2
->left
)
6157 left
= r1
, right
= r2
;
6159 left
= r2
, right
= r1
;
6161 /* X0 of the intersection is right.x0, if this is inside R1,
6162 otherwise there is no intersection. */
6163 if (right
->left
<= left
->right
)
6165 result
->left
= right
->left
;
6167 /* The right end of the intersection is the minimum of the
6168 the right ends of left and right. */
6169 result
->right
= min (left
->right
, right
->right
);
6171 /* Same game for Y. */
6172 if (r1
->top
< r2
->top
)
6173 upper
= r1
, lower
= r2
;
6175 upper
= r2
, lower
= r1
;
6177 /* The upper end of the intersection is lower.y0, if this is inside
6178 of upper. Otherwise, there is no intersection. */
6179 if (lower
->top
<= upper
->bottom
)
6181 result
->top
= lower
->top
;
6183 /* The lower end of the intersection is the minimum of the lower
6184 ends of upper and lower. */
6185 result
->bottom
= min (lower
->bottom
, upper
->bottom
);
6190 return intersection_p
;
6201 x_update_cursor (f
, 1);
6205 frame_unhighlight (f
)
6208 x_update_cursor (f
, 1);
6211 /* The focus has changed. Update the frames as necessary to reflect
6212 the new situation. Note that we can't change the selected frame
6213 here, because the Lisp code we are interrupting might become confused.
6214 Each event gets marked with the frame in which it occurred, so the
6215 Lisp code can tell when the switch took place by examining the events. */
6218 x_new_focus_frame (dpyinfo
, frame
)
6219 struct x_display_info
*dpyinfo
;
6220 struct frame
*frame
;
6222 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
6224 if (frame
!= dpyinfo
->x_focus_frame
)
6226 /* Set this before calling other routines, so that they see
6227 the correct value of x_focus_frame. */
6228 dpyinfo
->x_focus_frame
= frame
;
6230 if (old_focus
&& old_focus
->auto_lower
)
6231 x_lower_frame (old_focus
);
6234 selected_frame
= frame
;
6235 XSETFRAME (XWINDOW (selected_frame
->selected_window
)->frame
,
6237 Fselect_window (selected_frame
->selected_window
);
6238 choose_minibuf_frame ();
6241 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
6242 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
6244 pending_autoraise_frame
= 0;
6247 x_frame_rehighlight (dpyinfo
);
6250 /* Handle an event saying the mouse has moved out of an Emacs frame. */
6253 x_mouse_leave (dpyinfo
)
6254 struct x_display_info
*dpyinfo
;
6256 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
6259 /* The focus has changed, or we have redirected a frame's focus to
6260 another frame (this happens when a frame uses a surrogate
6261 mini-buffer frame). Shift the highlight as appropriate.
6263 The FRAME argument doesn't necessarily have anything to do with which
6264 frame is being highlighted or un-highlighted; we only use it to find
6265 the appropriate X display info. */
6268 XTframe_rehighlight (frame
)
6269 struct frame
*frame
;
6271 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
6275 x_frame_rehighlight (dpyinfo
)
6276 struct x_display_info
*dpyinfo
;
6278 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
6280 if (dpyinfo
->x_focus_frame
)
6282 dpyinfo
->x_highlight_frame
6283 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
6284 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
6285 : dpyinfo
->x_focus_frame
);
6286 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
6288 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
6289 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
6293 dpyinfo
->x_highlight_frame
= 0;
6295 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
6298 frame_unhighlight (old_highlight
);
6299 if (dpyinfo
->x_highlight_frame
)
6300 frame_highlight (dpyinfo
->x_highlight_frame
);
6306 /* Keyboard processing - modifier keys, vendor-specific keysyms, etc. */
6309 /* Initialize mode_switch_bit and modifier_meaning. */
6311 x_find_modifier_meanings (dpyinfo
)
6312 struct x_display_info
*dpyinfo
;
6314 int min_code
, max_code
;
6317 XModifierKeymap
*mods
;
6319 dpyinfo
->meta_mod_mask
= 0;
6320 dpyinfo
->shift_lock_mask
= 0;
6321 dpyinfo
->alt_mod_mask
= 0;
6322 dpyinfo
->super_mod_mask
= 0;
6323 dpyinfo
->hyper_mod_mask
= 0;
6326 XDisplayKeycodes (dpyinfo
->display
, &min_code
, &max_code
);
6328 min_code
= dpyinfo
->display
->min_keycode
;
6329 max_code
= dpyinfo
->display
->max_keycode
;
6332 syms
= XGetKeyboardMapping (dpyinfo
->display
,
6333 min_code
, max_code
- min_code
+ 1,
6335 mods
= XGetModifierMapping (dpyinfo
->display
);
6337 /* Scan the modifier table to see which modifier bits the Meta and
6338 Alt keysyms are on. */
6340 int row
, col
; /* The row and column in the modifier table. */
6342 for (row
= 3; row
< 8; row
++)
6343 for (col
= 0; col
< mods
->max_keypermod
; col
++)
6346 = mods
->modifiermap
[(row
* mods
->max_keypermod
) + col
];
6348 /* Zeroes are used for filler. Skip them. */
6352 /* Are any of this keycode's keysyms a meta key? */
6356 for (code_col
= 0; code_col
< syms_per_code
; code_col
++)
6358 int sym
= syms
[((code
- min_code
) * syms_per_code
) + code_col
];
6364 dpyinfo
->meta_mod_mask
|= (1 << row
);
6369 dpyinfo
->alt_mod_mask
|= (1 << row
);
6374 dpyinfo
->hyper_mod_mask
|= (1 << row
);
6379 dpyinfo
->super_mod_mask
|= (1 << row
);
6383 /* Ignore this if it's not on the lock modifier. */
6384 if ((1 << row
) == LockMask
)
6385 dpyinfo
->shift_lock_mask
= LockMask
;
6393 /* If we couldn't find any meta keys, accept any alt keys as meta keys. */
6394 if (! dpyinfo
->meta_mod_mask
)
6396 dpyinfo
->meta_mod_mask
= dpyinfo
->alt_mod_mask
;
6397 dpyinfo
->alt_mod_mask
= 0;
6400 /* If some keys are both alt and meta,
6401 make them just meta, not alt. */
6402 if (dpyinfo
->alt_mod_mask
& dpyinfo
->meta_mod_mask
)
6404 dpyinfo
->alt_mod_mask
&= ~dpyinfo
->meta_mod_mask
;
6407 XFree ((char *) syms
);
6408 XFreeModifiermap (mods
);
6413 /* Convert between the modifier bits X uses and the modifier bits
6417 x_mac_to_emacs_modifiers (dpyinfo
, state
)
6418 struct x_display_info
*dpyinfo
;
6419 unsigned short state
;
6421 return (((state
& shiftKey
) ? shift_modifier
: 0)
6422 | ((state
& controlKey
) ? ctrl_modifier
: 0)
6423 | ((state
& cmdKey
) ? meta_modifier
: 0)
6424 | ((state
& optionKey
) ? alt_modifier
: 0));
6428 static unsigned short
6429 x_emacs_to_x_modifiers (dpyinfo
, state
)
6430 struct x_display_info
*dpyinfo
;
6433 return ( ((state
& alt_modifier
) ? dpyinfo
->alt_mod_mask
: 0)
6434 | ((state
& super_modifier
) ? dpyinfo
->super_mod_mask
: 0)
6435 | ((state
& hyper_modifier
) ? dpyinfo
->hyper_mod_mask
: 0)
6436 | ((state
& shift_modifier
) ? ShiftMask
: 0)
6437 | ((state
& ctrl_modifier
) ? ControlMask
: 0)
6438 | ((state
& meta_modifier
) ? dpyinfo
->meta_mod_mask
: 0));
6442 /* Convert a keysym to its name. */
6445 x_get_keysym_name (keysym
)
6452 value
= XKeysymToString (keysym
);
6463 /* Mouse clicks and mouse movement. Rah. */
6465 /* Given a pixel position (PIX_X, PIX_Y) on frame F, return glyph
6466 co-ordinates in (*X, *Y). Set *BOUNDS to the rectangle that the
6467 glyph at X, Y occupies, if BOUNDS != 0. If NOCLIP is non-zero, do
6468 not force the value into range. */
6471 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
6473 register int pix_x
, pix_y
;
6474 register int *x
, *y
;
6478 /* Arrange for the division in PIXEL_TO_CHAR_COL etc. to round down
6479 even for negative values. */
6481 pix_x
-= FONT_WIDTH ((f
)->output_data
.mac
->font
) - 1;
6483 pix_y
-= (f
)->output_data
.mac
->line_height
- 1;
6485 pix_x
= PIXEL_TO_CHAR_COL (f
, pix_x
);
6486 pix_y
= PIXEL_TO_CHAR_ROW (f
, pix_y
);
6490 bounds
->left
= CHAR_TO_PIXEL_COL (f
, pix_x
);
6491 bounds
->top
= CHAR_TO_PIXEL_ROW (f
, pix_y
);
6492 bounds
->right
= bounds
->left
+ FONT_WIDTH (f
->output_data
.mac
->font
);
6493 bounds
->bottom
= bounds
->top
+ f
->output_data
.mac
->line_height
;
6500 else if (pix_x
> FRAME_WINDOW_WIDTH (f
))
6501 pix_x
= FRAME_WINDOW_WIDTH (f
);
6505 else if (pix_y
> f
->height
)
6514 /* Given HPOS/VPOS in the current matrix of W, return corresponding
6515 frame-relative pixel positions in *FRAME_X and *FRAME_Y. If we
6516 can't tell the positions because W's display is not up to date,
6520 glyph_to_pixel_coords (w
, hpos
, vpos
, frame_x
, frame_y
)
6523 int *frame_x
, *frame_y
;
6527 xassert (hpos
>= 0 && hpos
< w
->current_matrix
->matrix_w
);
6528 xassert (vpos
>= 0 && vpos
< w
->current_matrix
->matrix_h
);
6530 if (display_completed
)
6532 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, vpos
);
6533 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
];
6534 struct glyph
*end
= glyph
+ min (hpos
, row
->used
[TEXT_AREA
]);
6540 *frame_x
+= glyph
->pixel_width
;
6548 *frame_y
= *frame_x
= 0;
6552 *frame_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, *frame_y
);
6553 *frame_x
= WINDOW_TO_FRAME_PIXEL_X (w
, *frame_x
);
6558 /* Prepare a mouse-event in *RESULT for placement in the input queue.
6560 If the event is a button press, then note that we have grabbed
6564 construct_mouse_click (result
, event
, f
)
6565 struct input_event
*result
;
6571 result
->kind
= mouse_click
;
6572 result
->code
= 0; /* only one mouse button */
6573 result
->timestamp
= event
->when
;
6574 result
->modifiers
= event
->what
== mouseDown
? down_modifier
: up_modifier
;
6576 mouseLoc
= event
->where
;
6577 SetPort (FRAME_MAC_WINDOW (f
));
6578 GlobalToLocal (&mouseLoc
);
6579 XSETINT (result
->x
, mouseLoc
.h
);
6580 XSETINT (result
->y
, mouseLoc
.v
);
6582 XSETFRAME (result
->frame_or_window
, f
);
6589 /* Function to report a mouse movement to the mainstream Emacs code.
6590 The input handler calls this.
6592 We have received a mouse movement event, which is given in *event.
6593 If the mouse is over a different glyph than it was last time, tell
6594 the mainstream emacs code by setting mouse_moved. If not, ask for
6595 another motion event, so we can check again the next time it moves. */
6597 static Point last_mouse_motion_position
;
6598 static Lisp_Object last_mouse_motion_frame
;
6601 note_mouse_movement (frame
, pos
)
6605 last_mouse_movement_time
= TickCount () * (1000 / 60); /* to milliseconds */
6606 last_mouse_motion_position
= *pos
;
6607 XSETFRAME (last_mouse_motion_frame
, frame
);
6609 if (!PtInRect (*pos
, &FRAME_MAC_WINDOW (frame
)->portRect
))
6611 frame
->mouse_moved
= 1;
6612 last_mouse_scroll_bar
= Qnil
;
6613 note_mouse_highlight (frame
, -1, -1);
6615 /* Has the mouse moved off the glyph it was on at the last sighting? */
6616 else if (pos
->h
< last_mouse_glyph
.left
6617 || pos
->h
>= last_mouse_glyph
.right
6618 || pos
->v
< last_mouse_glyph
.top
6619 || pos
->v
>= last_mouse_glyph
.bottom
)
6621 frame
->mouse_moved
= 1;
6622 last_mouse_scroll_bar
= Qnil
;
6623 note_mouse_highlight (frame
, pos
->h
, pos
->v
);
6627 /* This is used for debugging, to turn off note_mouse_highlight. */
6629 int disable_mouse_highlight
;
6633 /************************************************************************
6635 ************************************************************************/
6637 /* Find the glyph under window-relative coordinates X/Y in window W.
6638 Consider only glyphs from buffer text, i.e. no glyphs from overlay
6639 strings. Return in *HPOS and *VPOS the row and column number of
6640 the glyph found. Return in *AREA the glyph area containing X.
6641 Value is a pointer to the glyph found or null if X/Y is not on
6642 text, or we can't tell because W's current matrix is not up to
6645 static struct glyph
*
6646 x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, area
)
6649 int *hpos
, *vpos
, *area
;
6651 struct glyph
*glyph
, *end
;
6652 struct glyph_row
*row
= NULL
;
6653 int x0
, i
, left_area_width
;
6655 /* Find row containing Y. Give up if some row is not enabled. */
6656 for (i
= 0; i
< w
->current_matrix
->nrows
; ++i
)
6658 row
= MATRIX_ROW (w
->current_matrix
, i
);
6659 if (!row
->enabled_p
)
6661 if (y
>= row
->y
&& y
< MATRIX_ROW_BOTTOM_Y (row
))
6668 /* Give up if Y is not in the window. */
6669 if (i
== w
->current_matrix
->nrows
)
6672 /* Get the glyph area containing X. */
6673 if (w
->pseudo_window_p
)
6680 left_area_width
= window_box_width (w
, LEFT_MARGIN_AREA
);
6681 if (x
< left_area_width
)
6683 *area
= LEFT_MARGIN_AREA
;
6686 else if (x
< left_area_width
+ window_box_width (w
, TEXT_AREA
))
6689 x0
= row
->x
+ left_area_width
;
6693 *area
= RIGHT_MARGIN_AREA
;
6694 x0
= left_area_width
+ window_box_width (w
, TEXT_AREA
);
6698 /* Find glyph containing X. */
6699 glyph
= row
->glyphs
[*area
];
6700 end
= glyph
+ row
->used
[*area
];
6703 if (x
< x0
+ glyph
->pixel_width
)
6705 if (w
->pseudo_window_p
)
6707 else if (BUFFERP (glyph
->object
))
6711 x0
+= glyph
->pixel_width
;
6718 *hpos
= glyph
- row
->glyphs
[*area
];
6723 /* Convert frame-relative x/y to coordinates relative to window W.
6724 Takes pseudo-windows into account. */
6727 frame_to_window_pixel_xy (w
, x
, y
)
6731 if (w
->pseudo_window_p
)
6733 /* A pseudo-window is always full-width, and starts at the
6734 left edge of the frame, plus a frame border. */
6735 struct frame
*f
= XFRAME (w
->frame
);
6736 *x
-= FRAME_INTERNAL_BORDER_WIDTH_SAFE (f
);
6737 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6741 *x
= FRAME_TO_WINDOW_PIXEL_X (w
, *x
);
6742 *y
= FRAME_TO_WINDOW_PIXEL_Y (w
, *y
);
6747 /* Take proper action when mouse has moved to the mode or top line of
6748 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
6749 mode line. X is relative to the start of the text display area of
6750 W, so the width of bitmap areas and scroll bars must be subtracted
6751 to get a position relative to the start of the mode line. */
6754 note_mode_line_highlight (w
, x
, mode_line_p
)
6758 struct frame
*f
= XFRAME (w
->frame
);
6759 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
6760 Cursor cursor
= dpyinfo
->vertical_scroll_bar_cursor
;
6761 struct glyph_row
*row
;
6764 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
6766 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
6770 struct glyph
*glyph
, *end
;
6771 Lisp_Object help
, map
;
6774 /* Find the glyph under X. */
6775 glyph
= row
->glyphs
[TEXT_AREA
];
6776 end
= glyph
+ row
->used
[TEXT_AREA
];
6777 x0
= - (FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
)
6778 + FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
));
6780 && x
>= x0
+ glyph
->pixel_width
)
6782 x0
+= glyph
->pixel_width
;
6787 && STRINGP (glyph
->object
)
6788 && XSTRING (glyph
->object
)->intervals
6789 && glyph
->charpos
>= 0
6790 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
6792 /* If we're on a string with `help-echo' text property,
6793 arrange for the help to be displayed. This is done by
6794 setting the global variable help_echo to the help string. */
6795 help
= Fget_text_property (make_number (glyph
->charpos
),
6796 Qhelp_echo
, glyph
->object
);
6800 XSETWINDOW (help_echo_window
, w
);
6801 help_echo_object
= glyph
->object
;
6802 help_echo_pos
= glyph
->charpos
;
6805 /* Change the mouse pointer according to what is under X/Y. */
6806 map
= Fget_text_property (make_number (glyph
->charpos
),
6807 Qlocal_map
, glyph
->object
);
6808 if (!NILP (Fkeymapp (map
)))
6809 cursor
= f
->output_data
.mac
->nontext_cursor
;
6812 map
= Fget_text_property (make_number (glyph
->charpos
),
6813 Qkeymap
, glyph
->object
);
6814 if (!NILP (Fkeymapp (map
)))
6815 cursor
= f
->output_data
.mac
->nontext_cursor
;
6820 #if 0 /* MAC_TODO: mouse cursor */
6821 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), cursor
);
6826 /* Take proper action when the mouse has moved to position X, Y on
6827 frame F as regards highlighting characters that have mouse-face
6828 properties. Also de-highlighting chars where the mouse was before.
6829 X and Y can be negative or out of range. */
6832 note_mouse_highlight (f
, x
, y
)
6836 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
6841 /* When a menu is active, don't highlight because this looks odd. */
6842 #ifdef USE_X_TOOLKIT
6843 if (popup_activated ())
6847 if (disable_mouse_highlight
6848 || !f
->glyphs_initialized_p
)
6851 dpyinfo
->mouse_face_mouse_x
= x
;
6852 dpyinfo
->mouse_face_mouse_y
= y
;
6853 dpyinfo
->mouse_face_mouse_frame
= f
;
6855 if (dpyinfo
->mouse_face_defer
)
6860 dpyinfo
->mouse_face_deferred_gc
= 1;
6864 /* Which window is that in? */
6865 window
= window_from_coordinates (f
, x
, y
, &portion
, 1);
6867 /* If we were displaying active text in another window, clear that. */
6868 if (! EQ (window
, dpyinfo
->mouse_face_window
))
6869 clear_mouse_face (dpyinfo
);
6871 /* Not on a window -> return. */
6872 if (!WINDOWP (window
))
6875 /* Convert to window-relative pixel coordinates. */
6876 w
= XWINDOW (window
);
6877 frame_to_window_pixel_xy (w
, &x
, &y
);
6879 /* Handle tool-bar window differently since it doesn't display a
6881 if (EQ (window
, f
->tool_bar_window
))
6883 note_tool_bar_highlight (f
, x
, y
);
6887 if (portion
== 1 || portion
== 3)
6889 /* Mouse is on the mode or top line. */
6890 note_mode_line_highlight (w
, x
, portion
== 1);
6893 #if 0 /* MAC_TODO: mouse cursor */
6895 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6896 f
->output_data
.x
->text_cursor
);
6899 /* Are we in a window whose display is up to date?
6900 And verify the buffer's text has not changed. */
6901 if (/* Within text portion of the window. */
6903 && EQ (w
->window_end_valid
, w
->buffer
)
6904 && XFASTINT (w
->last_modified
) == BUF_MODIFF (XBUFFER (w
->buffer
))
6905 && (XFASTINT (w
->last_overlay_modified
)
6906 == BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
))))
6908 int hpos
, vpos
, pos
, i
, area
;
6909 struct glyph
*glyph
;
6911 /* Find the glyph under X/Y. */
6912 glyph
= x_y_to_hpos_vpos (w
, x
, y
, &hpos
, &vpos
, &area
);
6914 /* Clear mouse face if X/Y not over text. */
6916 || area
!= TEXT_AREA
6917 || !MATRIX_ROW (w
->current_matrix
, vpos
)->displays_text_p
)
6919 clear_mouse_face (dpyinfo
);
6923 pos
= glyph
->charpos
;
6924 xassert (w
->pseudo_window_p
|| BUFFERP (glyph
->object
));
6926 /* Check for mouse-face and help-echo. */
6928 Lisp_Object mouse_face
, overlay
, position
;
6929 Lisp_Object
*overlay_vec
;
6931 struct buffer
*obuf
;
6934 /* If we get an out-of-range value, return now; avoid an error. */
6935 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
6938 /* Make the window's buffer temporarily current for
6939 overlays_at and compute_char_face. */
6940 obuf
= current_buffer
;
6941 current_buffer
= XBUFFER (w
->buffer
);
6947 /* Is this char mouse-active or does it have help-echo? */
6948 XSETINT (position
, pos
);
6950 /* Put all the overlays we want in a vector in overlay_vec.
6951 Store the length in len. If there are more than 10, make
6952 enough space for all, and try again. */
6954 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
6955 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
);
6956 if (noverlays
> len
)
6959 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
6960 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
);
6963 /* Sort overlays into increasing priority order. */
6964 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
6966 /* Check mouse-face highlighting. */
6967 if (! (EQ (window
, dpyinfo
->mouse_face_window
)
6968 && vpos
>= dpyinfo
->mouse_face_beg_row
6969 && vpos
<= dpyinfo
->mouse_face_end_row
6970 && (vpos
> dpyinfo
->mouse_face_beg_row
6971 || hpos
>= dpyinfo
->mouse_face_beg_col
)
6972 && (vpos
< dpyinfo
->mouse_face_end_row
6973 || hpos
< dpyinfo
->mouse_face_end_col
6974 || dpyinfo
->mouse_face_past_end
)))
6976 /* Clear the display of the old active region, if any. */
6977 clear_mouse_face (dpyinfo
);
6979 /* Find the highest priority overlay that has a mouse-face prop. */
6981 for (i
= noverlays
- 1; i
>= 0; --i
)
6983 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
6984 if (!NILP (mouse_face
))
6986 overlay
= overlay_vec
[i
];
6991 /* If no overlay applies, get a text property. */
6993 mouse_face
= Fget_text_property (position
, Qmouse_face
, w
->buffer
);
6995 /* Handle the overlay case. */
6996 if (! NILP (overlay
))
6998 /* Find the range of text around this char that
6999 should be active. */
7000 Lisp_Object before
, after
;
7003 before
= Foverlay_start (overlay
);
7004 after
= Foverlay_end (overlay
);
7005 /* Record this as the current active region. */
7006 fast_find_position (w
, XFASTINT (before
),
7007 &dpyinfo
->mouse_face_beg_col
,
7008 &dpyinfo
->mouse_face_beg_row
,
7009 &dpyinfo
->mouse_face_beg_x
,
7010 &dpyinfo
->mouse_face_beg_y
);
7011 dpyinfo
->mouse_face_past_end
7012 = !fast_find_position (w
, XFASTINT (after
),
7013 &dpyinfo
->mouse_face_end_col
,
7014 &dpyinfo
->mouse_face_end_row
,
7015 &dpyinfo
->mouse_face_end_x
,
7016 &dpyinfo
->mouse_face_end_y
);
7017 dpyinfo
->mouse_face_window
= window
;
7018 dpyinfo
->mouse_face_face_id
7019 = face_at_buffer_position (w
, pos
, 0, 0,
7020 &ignore
, pos
+ 1, 1);
7022 /* Display it as active. */
7023 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
7025 /* Handle the text property case. */
7026 else if (! NILP (mouse_face
))
7028 /* Find the range of text around this char that
7029 should be active. */
7030 Lisp_Object before
, after
, beginning
, end
;
7033 beginning
= Fmarker_position (w
->start
);
7034 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
7035 - XFASTINT (w
->window_end_pos
)));
7037 = Fprevious_single_property_change (make_number (pos
+ 1),
7039 w
->buffer
, beginning
);
7041 = Fnext_single_property_change (position
, Qmouse_face
,
7043 /* Record this as the current active region. */
7044 fast_find_position (w
, XFASTINT (before
),
7045 &dpyinfo
->mouse_face_beg_col
,
7046 &dpyinfo
->mouse_face_beg_row
,
7047 &dpyinfo
->mouse_face_beg_x
,
7048 &dpyinfo
->mouse_face_beg_y
);
7049 dpyinfo
->mouse_face_past_end
7050 = !fast_find_position (w
, XFASTINT (after
),
7051 &dpyinfo
->mouse_face_end_col
,
7052 &dpyinfo
->mouse_face_end_row
,
7053 &dpyinfo
->mouse_face_end_x
,
7054 &dpyinfo
->mouse_face_end_y
);
7055 dpyinfo
->mouse_face_window
= window
;
7056 dpyinfo
->mouse_face_face_id
7057 = face_at_buffer_position (w
, pos
, 0, 0,
7058 &ignore
, pos
+ 1, 1);
7060 /* Display it as active. */
7061 show_mouse_face (dpyinfo
, DRAW_MOUSE_FACE
);
7065 /* Look for a `help-echo' property. */
7067 Lisp_Object help
, overlay
;
7069 /* Check overlays first. */
7071 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
7073 overlay
= overlay_vec
[i
];
7074 help
= Foverlay_get (overlay
, Qhelp_echo
);
7080 help_echo_window
= window
;
7081 help_echo_object
= overlay
;
7082 help_echo_pos
= pos
;
7086 /* Try text properties. */
7087 if ((STRINGP (glyph
->object
)
7088 && glyph
->charpos
>= 0
7089 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
7090 || (BUFFERP (glyph
->object
)
7091 && glyph
->charpos
>= BEGV
7092 && glyph
->charpos
< ZV
))
7093 help
= Fget_text_property (make_number (glyph
->charpos
),
7094 Qhelp_echo
, glyph
->object
);
7099 help_echo_window
= window
;
7100 help_echo_object
= glyph
->object
;
7101 help_echo_pos
= glyph
->charpos
;
7108 current_buffer
= obuf
;
7114 redo_mouse_highlight ()
7116 if (!NILP (last_mouse_motion_frame
)
7117 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
7118 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
7119 last_mouse_motion_position
.h
,
7120 last_mouse_motion_position
.v
);
7125 /***********************************************************************
7127 ***********************************************************************/
7129 static int x_tool_bar_item
P_ ((struct frame
*, int, int,
7130 struct glyph
**, int *, int *, int *));
7132 /* Tool-bar item index of the item on which a mouse button was pressed
7135 static int last_tool_bar_item
;
7138 /* Get information about the tool-bar item at position X/Y on frame F.
7139 Return in *GLYPH a pointer to the glyph of the tool-bar item in
7140 the current matrix of the tool-bar window of F, or NULL if not
7141 on a tool-bar item. Return in *PROP_IDX the index of the tool-bar
7142 item in F->current_tool_bar_items. Value is
7144 -1 if X/Y is not on a tool-bar item
7145 0 if X/Y is on the same item that was highlighted before.
7149 x_tool_bar_item (f
, x
, y
, glyph
, hpos
, vpos
, prop_idx
)
7152 struct glyph
**glyph
;
7153 int *hpos
, *vpos
, *prop_idx
;
7155 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
7156 struct window
*w
= XWINDOW (f
->tool_bar_window
);
7159 /* Find the glyph under X/Y. */
7160 *glyph
= x_y_to_hpos_vpos (w
, x
, y
, hpos
, vpos
, &area
);
7164 /* Get the start of this tool-bar item's properties in
7165 f->current_tool_bar_items. */
7166 if (!tool_bar_item_info (f
, *glyph
, prop_idx
))
7169 /* Is mouse on the highlighted item? */
7170 if (EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
)
7171 && *vpos
>= dpyinfo
->mouse_face_beg_row
7172 && *vpos
<= dpyinfo
->mouse_face_end_row
7173 && (*vpos
> dpyinfo
->mouse_face_beg_row
7174 || *hpos
>= dpyinfo
->mouse_face_beg_col
)
7175 && (*vpos
< dpyinfo
->mouse_face_end_row
7176 || *hpos
< dpyinfo
->mouse_face_end_col
7177 || dpyinfo
->mouse_face_past_end
))
7184 /* Handle mouse button event on the tool-bar of frame F, at
7185 frame-relative coordinates X/Y. EVENT_TYPE is either ButtionPress
7189 x_handle_tool_bar_click (f
, button_event
)
7191 EventRecord
*button_event
;
7193 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
7194 struct window
*w
= XWINDOW (f
->tool_bar_window
);
7195 int hpos
, vpos
, prop_idx
;
7196 struct glyph
*glyph
;
7197 Lisp_Object enabled_p
;
7198 int x
= button_event
->where
.h
;
7199 int y
= button_event
->where
.v
;
7201 /* If not on the highlighted tool-bar item, return. */
7202 frame_to_window_pixel_xy (w
, &x
, &y
);
7203 if (x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
) != 0)
7206 /* If item is disabled, do nothing. */
7207 enabled_p
= (XVECTOR (f
->current_tool_bar_items
)
7208 ->contents
[prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
]);
7209 if (NILP (enabled_p
))
7212 if (button_event
->what
== mouseDown
)
7214 /* Show item in pressed state. */
7215 show_mouse_face (dpyinfo
, DRAW_IMAGE_SUNKEN
);
7216 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_SUNKEN
;
7217 last_tool_bar_item
= prop_idx
;
7221 Lisp_Object key
, frame
;
7222 struct input_event event
;
7224 /* Show item in released state. */
7225 show_mouse_face (dpyinfo
, DRAW_IMAGE_RAISED
);
7226 dpyinfo
->mouse_face_image_state
= DRAW_IMAGE_RAISED
;
7228 key
= (XVECTOR (f
->current_tool_bar_items
)
7229 ->contents
[prop_idx
+ TOOL_BAR_ITEM_KEY
]);
7231 XSETFRAME (frame
, f
);
7232 event
.kind
= TOOL_BAR_EVENT
;
7233 event
.frame_or_window
= frame
;
7235 kbd_buffer_store_event (&event
);
7237 event
.kind
= TOOL_BAR_EVENT
;
7238 event
.frame_or_window
= frame
;
7240 event
.modifiers
= x_mac_to_emacs_modifiers (FRAME_X_DISPLAY_INFO (f
),
7241 button_event
->modifiers
);
7242 kbd_buffer_store_event (&event
);
7243 last_tool_bar_item
= -1;
7248 /* Possibly highlight a tool-bar item on frame F when mouse moves to
7249 tool-bar window-relative coordinates X/Y. Called from
7250 note_mouse_highlight. */
7253 note_tool_bar_highlight (f
, x
, y
)
7257 Lisp_Object window
= f
->tool_bar_window
;
7258 struct window
*w
= XWINDOW (window
);
7259 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
7261 struct glyph
*glyph
;
7262 struct glyph_row
*row
;
7264 Lisp_Object enabled_p
;
7266 enum draw_glyphs_face draw
= DRAW_IMAGE_RAISED
;
7267 int mouse_down_p
, rc
;
7269 /* Function note_mouse_highlight is called with negative x(y
7270 values when mouse moves outside of the frame. */
7271 if (x
<= 0 || y
<= 0)
7273 clear_mouse_face (dpyinfo
);
7277 rc
= x_tool_bar_item (f
, x
, y
, &glyph
, &hpos
, &vpos
, &prop_idx
);
7280 /* Not on tool-bar item. */
7281 clear_mouse_face (dpyinfo
);
7285 /* On same tool-bar item as before. */
7288 clear_mouse_face (dpyinfo
);
7290 /* Mouse is down, but on different tool-bar item? */
7291 mouse_down_p
= (dpyinfo
->grabbed
7292 && f
== last_mouse_frame
7293 && FRAME_LIVE_P (f
));
7295 && last_tool_bar_item
!= prop_idx
)
7298 dpyinfo
->mouse_face_image_state
= DRAW_NORMAL_TEXT
;
7299 draw
= mouse_down_p
? DRAW_IMAGE_SUNKEN
: DRAW_IMAGE_RAISED
;
7301 /* If tool-bar item is not enabled, don't highlight it. */
7302 enabled_p
= (XVECTOR (f
->current_tool_bar_items
)
7303 ->contents
[prop_idx
+ TOOL_BAR_ITEM_ENABLED_P
]);
7304 if (!NILP (enabled_p
))
7306 /* Compute the x-position of the glyph. In front and past the
7307 image is a space. We include this is the highlighted area. */
7308 row
= MATRIX_ROW (w
->current_matrix
, vpos
);
7309 for (i
= x
= 0; i
< hpos
; ++i
)
7310 x
+= row
->glyphs
[TEXT_AREA
][i
].pixel_width
;
7312 /* Record this as the current active region. */
7313 dpyinfo
->mouse_face_beg_col
= hpos
;
7314 dpyinfo
->mouse_face_beg_row
= vpos
;
7315 dpyinfo
->mouse_face_beg_x
= x
;
7316 dpyinfo
->mouse_face_beg_y
= row
->y
;
7317 dpyinfo
->mouse_face_past_end
= 0;
7319 dpyinfo
->mouse_face_end_col
= hpos
+ 1;
7320 dpyinfo
->mouse_face_end_row
= vpos
;
7321 dpyinfo
->mouse_face_end_x
= x
+ glyph
->pixel_width
;
7322 dpyinfo
->mouse_face_end_y
= row
->y
;
7323 dpyinfo
->mouse_face_window
= window
;
7324 dpyinfo
->mouse_face_face_id
= TOOL_BAR_FACE_ID
;
7326 /* Display it as active. */
7327 show_mouse_face (dpyinfo
, draw
);
7328 dpyinfo
->mouse_face_image_state
= draw
;
7333 /* Set help_echo to a help string.to display for this tool-bar item.
7334 XTread_socket does the rest. */
7335 help_echo_object
= help_echo_window
= Qnil
;
7337 help_echo
= (XVECTOR (f
->current_tool_bar_items
)
7338 ->contents
[prop_idx
+ TOOL_BAR_ITEM_HELP
]);
7339 if (NILP (help_echo
))
7340 help_echo
= (XVECTOR (f
->current_tool_bar_items
)
7341 ->contents
[prop_idx
+ TOOL_BAR_ITEM_CAPTION
]);
7346 /* Find the glyph matrix position of buffer position POS in window W.
7347 *HPOS, *VPOS, *X, and *Y are set to the positions found. W's
7348 current glyphs must be up to date. If POS is above window start
7349 return (0, 0, 0, 0). If POS is after end of W, return end of
7353 fast_find_position (w
, pos
, hpos
, vpos
, x
, y
)
7356 int *hpos
, *vpos
, *x
, *y
;
7360 int maybe_next_line_p
= 0;
7361 int line_start_position
;
7362 int yb
= window_text_bottom_y (w
);
7363 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, 0);
7364 struct glyph_row
*best_row
= row
;
7365 int row_vpos
= 0, best_row_vpos
= 0;
7370 if (row
->used
[TEXT_AREA
])
7371 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
7373 line_start_position
= 0;
7375 if (line_start_position
> pos
)
7377 /* If the position sought is the end of the buffer,
7378 don't include the blank lines at the bottom of the window. */
7379 else if (line_start_position
== pos
7380 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
7382 maybe_next_line_p
= 1;
7385 else if (line_start_position
> 0)
7388 best_row_vpos
= row_vpos
;
7391 if (row
->y
+ row
->height
>= yb
)
7398 /* Find the right column within BEST_ROW. */
7400 current_x
= best_row
->x
;
7401 for (i
= 0; i
< best_row
->used
[TEXT_AREA
]; i
++)
7403 struct glyph
*glyph
= best_row
->glyphs
[TEXT_AREA
] + i
;
7406 charpos
= glyph
->charpos
;
7410 *vpos
= best_row_vpos
;
7415 else if (charpos
> pos
)
7417 else if (charpos
> 0)
7420 current_x
+= glyph
->pixel_width
;
7423 /* If we're looking for the end of the buffer,
7424 and we didn't find it in the line we scanned,
7425 use the start of the following line. */
7426 if (maybe_next_line_p
)
7431 current_x
= best_row
->x
;
7434 *vpos
= best_row_vpos
;
7435 *hpos
= lastcol
+ 1;
7442 /* Display the active region described by mouse_face_*
7443 in its mouse-face if HL > 0, in its normal face if HL = 0. */
7446 show_mouse_face (dpyinfo
, draw
)
7447 struct mac_display_info
*dpyinfo
;
7448 enum draw_glyphs_face draw
;
7450 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
7451 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
7453 int cursor_off_p
= 0;
7454 struct cursor_pos saved_cursor
;
7456 saved_cursor
= output_cursor
;
7458 /* If window is in the process of being destroyed, don't bother
7460 if (w
->current_matrix
== NULL
)
7463 /* Recognize when we are called to operate on rows that don't exist
7464 anymore. This can happen when a window is split. */
7465 if (dpyinfo
->mouse_face_end_row
>= w
->current_matrix
->nrows
)
7468 set_output_cursor (&w
->phys_cursor
);
7470 /* Note that mouse_face_beg_row etc. are window relative. */
7471 for (i
= dpyinfo
->mouse_face_beg_row
;
7472 i
<= dpyinfo
->mouse_face_end_row
;
7475 int start_hpos
, end_hpos
, start_x
;
7476 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
7478 /* Don't do anything if row doesn't have valid contents. */
7479 if (!row
->enabled_p
)
7482 /* For all but the first row, the highlight starts at column 0. */
7483 if (i
== dpyinfo
->mouse_face_beg_row
)
7485 start_hpos
= dpyinfo
->mouse_face_beg_col
;
7486 start_x
= dpyinfo
->mouse_face_beg_x
;
7494 if (i
== dpyinfo
->mouse_face_end_row
)
7495 end_hpos
= dpyinfo
->mouse_face_end_col
;
7497 end_hpos
= row
->used
[TEXT_AREA
];
7499 /* If the cursor's in the text we are about to rewrite, turn the
7501 if (!w
->pseudo_window_p
7502 && i
== output_cursor
.vpos
7503 && output_cursor
.hpos
>= start_hpos
- 1
7504 && output_cursor
.hpos
<= end_hpos
)
7506 x_update_window_cursor (w
, 0);
7510 if (end_hpos
> start_hpos
)
7512 row
->mouse_face_p
= draw
== DRAW_MOUSE_FACE
;
7513 x_draw_glyphs (w
, start_x
, row
, TEXT_AREA
,
7514 start_hpos
, end_hpos
, draw
, NULL
, NULL
, 0);
7518 /* If we turned the cursor off, turn it back on. */
7520 x_display_cursor (w
, 1,
7521 output_cursor
.hpos
, output_cursor
.vpos
,
7522 output_cursor
.x
, output_cursor
.y
);
7524 output_cursor
= saved_cursor
;
7527 #if 0 /* MAC_TODO: mouse cursor */
7528 /* Change the mouse cursor. */
7529 if (draw
== DRAW_NORMAL_TEXT
)
7530 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7531 f
->output_data
.x
->text_cursor
);
7532 else if (draw
== DRAW_MOUSE_FACE
)
7533 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7534 f
->output_data
.x
->cross_cursor
);
7536 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7537 f
->output_data
.x
->nontext_cursor
);
7542 /* Clear out the mouse-highlighted active region.
7543 Redraw it un-highlighted first. */
7546 clear_mouse_face (dpyinfo
)
7547 struct mac_display_info
*dpyinfo
;
7552 if (! NILP (dpyinfo
->mouse_face_window
))
7553 show_mouse_face (dpyinfo
, DRAW_NORMAL_TEXT
);
7555 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
7556 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
7557 dpyinfo
->mouse_face_window
= Qnil
;
7561 /* Clear any mouse-face on window W. This function is part of the
7562 redisplay interface, and is called from try_window_id and similar
7563 functions to ensure the mouse-highlight is off. */
7566 x_clear_mouse_face (w
)
7569 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (XFRAME (w
->frame
));
7572 XSETWINDOW (window
, w
);
7573 if (EQ (window
, dpyinfo
->mouse_face_window
))
7574 clear_mouse_face (dpyinfo
);
7578 /* Just discard the mouse face information for frame F, if any.
7579 This is used when the size of F is changed. */
7582 cancel_mouse_face (f
)
7586 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
7588 window
= dpyinfo
->mouse_face_window
;
7589 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
7591 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
7592 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
7593 dpyinfo
->mouse_face_window
= Qnil
;
7597 static struct scroll_bar
*x_window_to_scroll_bar ();
7598 static void x_scroll_bar_report_motion ();
7600 /* Return the current position of the mouse.
7601 *fp should be a frame which indicates which display to ask about.
7603 If the mouse movement started in a scroll bar, set *fp, *bar_window,
7604 and *part to the frame, window, and scroll bar part that the mouse
7605 is over. Set *x and *y to the portion and whole of the mouse's
7606 position on the scroll bar.
7608 If the mouse movement started elsewhere, set *fp to the frame the
7609 mouse is on, *bar_window to nil, and *x and *y to the character cell
7612 Set *time to the server time-stamp for the time at which the mouse
7613 was at this position.
7615 Don't store anything if we don't have a valid set of values to report.
7617 This clears the mouse_moved flag, so we can wait for the next mouse
7621 XTmouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
7624 Lisp_Object
*bar_window
;
7625 enum scroll_bar_part
*part
;
7627 unsigned long *time
;
7630 int ignore1
, ignore2
;
7631 WindowPtr wp
= FrontWindow ();
7632 struct frame
*f
= ((mac_output
*) GetWRefCon (wp
))->mFP
;
7633 Lisp_Object frame
, tail
;
7637 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
7638 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
7641 /* Clear the mouse-moved flag for every frame on this display. */
7642 FOR_EACH_FRAME (tail
, frame
)
7643 XFRAME (frame
)->mouse_moved
= 0;
7645 last_mouse_scroll_bar
= Qnil
;
7648 GetMouse (&mouse_pos
);
7650 pixel_to_glyph_coords (f
, mouse_pos
.h
, mouse_pos
.v
, &ignore1
, &ignore2
,
7651 &last_mouse_glyph
, insist
);
7654 *part
= scroll_bar_handle
;
7656 XSETINT (*x
, mouse_pos
.h
);
7657 XSETINT (*y
, mouse_pos
.v
);
7658 *time
= last_mouse_movement_time
;
7665 /************************************************************************
7666 Scroll bars, general
7667 ************************************************************************/
7669 /* Create a scroll bar and return the scroll bar vector for it. W is
7670 the Emacs window on which to create the scroll bar. TOP, LEFT,
7671 WIDTH and HEIGHT are.the pixel coordinates and dimensions of the
7674 static struct scroll_bar
*
7675 x_scroll_bar_create (w
, top
, left
, width
, height
, disp_top
, disp_height
)
7677 int top
, left
, width
, height
, disp_top
, disp_height
;
7679 struct frame
*f
= XFRAME (w
->frame
);
7680 struct scroll_bar
*bar
7681 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
7689 r
.right
= left
+ width
;
7690 r
.bottom
= disp_top
+ disp_height
;
7692 ch
= NewControl (FRAME_MAC_WINDOW (f
), &r
, "\p", 1, 0, 0, 0, scrollBarProc
,
7694 SET_SCROLL_BAR_CONTROL_HANDLE (bar
, ch
);
7695 SetControlReference (ch
, (long) bar
);
7697 XSETWINDOW (bar
->window
, w
);
7698 XSETINT (bar
->top
, top
);
7699 XSETINT (bar
->left
, left
);
7700 XSETINT (bar
->width
, width
);
7701 XSETINT (bar
->height
, height
);
7702 XSETINT (bar
->start
, 0);
7703 XSETINT (bar
->end
, 0);
7704 bar
->dragging
= Qnil
;
7706 /* Add bar to its frame's list of scroll bars. */
7707 bar
->next
= FRAME_SCROLL_BARS (f
);
7709 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
7710 if (!NILP (bar
->next
))
7711 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
7718 /* Draw BAR's handle in the proper position.
7720 If the handle is already drawn from START to END, don't bother
7721 redrawing it, unless REBUILD is non-zero; in that case, always
7722 redraw it. (REBUILD is handy for drawing the handle after expose
7725 Normally, we want to constrain the start and end of the handle to
7726 fit inside its rectangle, but if the user is dragging the scroll
7727 bar handle, we want to let them drag it down all the way, so that
7728 the bar's top is as far down as it goes; otherwise, there's no way
7729 to move to the very end of the buffer. */
7732 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
7733 struct scroll_bar
*bar
;
7737 int dragging
= ! NILP (bar
->dragging
);
7738 ControlHandle ch
= SCROLL_BAR_CONTROL_HANDLE (bar
);
7739 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
7741 /* If the display is already accurate, do nothing. */
7743 && start
== XINT (bar
->start
)
7744 && end
== XINT (bar
->end
))
7750 int inside_width
= VERTICAL_SCROLL_BAR_INSIDE_WIDTH (f
, XINT (bar
->width
));
7751 int inside_height
= VERTICAL_SCROLL_BAR_INSIDE_HEIGHT (f
, XINT (bar
->height
));
7752 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
7754 /* Make sure the values are reasonable, and try to preserve
7755 the distance between start and end. */
7757 int length
= end
- start
;
7761 else if (start
> top_range
)
7763 end
= start
+ length
;
7767 else if (end
> top_range
&& ! dragging
)
7771 /* Store the adjusted setting in the scroll bar. */
7772 XSETINT (bar
->start
, start
);
7773 XSETINT (bar
->end
, end
);
7775 /* Clip the end position, just for display. */
7776 if (end
> top_range
)
7779 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels
7780 below top positions, to make sure the handle is always at least
7781 that many pixels tall. */
7782 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
7784 SetControlMinimum (ch
, 0);
7785 /* Don't inadvertently activate deactivated scroll bars */
7786 if (GetControlMaximum (ch
) != -1)
7787 SetControlMaximum (ch
,
7788 VERTICAL_SCROLL_BAR_TOP_RANGE (f
,
7791 SetControlValue (ch
, start
);
7792 #if 0 /* MAC_TODO: detect Appearance Manager 1.1 before use. */
7793 SetControlViewSize (ch
, end
);
7801 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
7805 x_scroll_bar_remove (bar
)
7806 struct scroll_bar
*bar
;
7808 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
7812 /* Destroy the Mac scroll bar control */
7813 DisposeControl (SCROLL_BAR_CONTROL_HANDLE (bar
));
7815 /* Disassociate this scroll bar from its window. */
7816 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
7822 /* Set the handle of the vertical scroll bar for WINDOW to indicate
7823 that we are displaying PORTION characters out of a total of WHOLE
7824 characters, starting at POSITION. If WINDOW has no scroll bar,
7828 XTset_vertical_scroll_bar (w
, portion
, whole
, position
)
7830 int portion
, whole
, position
;
7832 struct frame
*f
= XFRAME (w
->frame
);
7833 struct scroll_bar
*bar
;
7834 int top
, height
, left
, sb_left
, width
, sb_width
, disp_top
, disp_height
;
7835 int window_x
, window_y
, window_width
, window_height
;
7837 /* Get window dimensions. */
7838 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
7840 width
= FRAME_SCROLL_BAR_COLS (f
) * CANON_X_UNIT (f
);
7841 height
= window_height
;
7843 /* Compute the left edge of the scroll bar area. */
7844 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
7845 left
= XINT (w
->left
) + XINT (w
->width
) - FRAME_SCROLL_BAR_COLS (f
);
7847 left
= XFASTINT (w
->left
);
7848 left
*= CANON_X_UNIT (f
);
7849 left
+= FRAME_INTERNAL_BORDER_WIDTH (f
);
7851 /* Compute the width of the scroll bar which might be less than
7852 the width of the area reserved for the scroll bar. */
7853 if (FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0)
7854 sb_width
= FRAME_SCROLL_BAR_PIXEL_WIDTH (f
);
7858 /* Compute the left edge of the scroll bar. */
7859 if (FRAME_HAS_VERTICAL_SCROLL_BARS_ON_RIGHT (f
))
7860 sb_left
= left
+ width
- sb_width
- (width
- sb_width
) / 2;
7862 sb_left
= left
+ (width
- sb_width
) / 2;
7864 /* Adjustments according to Inside Macintosh to make it look nice */
7866 disp_height
= height
;
7872 else if (disp_top
== PIXEL_HEIGHT (f
) - 16)
7878 if (sb_left
+ sb_width
== PIXEL_WIDTH (f
))
7881 /* Does the scroll bar exist yet? */
7882 if (NILP (w
->vertical_scroll_bar
))
7885 XClearArea (FRAME_MAC_DISPLAY (f
), FRAME_MAC_WINDOW (f
),
7886 left
, top
, width
, height
, 0);
7888 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
, disp_top
,
7890 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
7894 /* It may just need to be moved and resized. */
7897 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
7898 ch
= SCROLL_BAR_CONTROL_HANDLE (bar
);
7902 /* If already correctly positioned, do nothing. */
7903 if (XINT (bar
->left
) == sb_left
7904 && XINT (bar
->top
) == top
7905 && XINT (bar
->width
) == sb_width
7906 && XINT (bar
->height
) == height
)
7910 if (sb_left
+ sb_width
>= PIXEL_WIDTH (f
))
7911 XClearArea (FRAME_MAC_DISPLAY (f
), FRAME_MAC_WINDOW (f
),
7912 sb_left
- 1, top
, 1, height
, 0);
7915 MoveControl (ch
, sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
, disp_top
);
7916 SizeControl (ch
, sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
7920 /* Remember new settings. */
7921 XSETINT (bar
->left
, sb_left
);
7922 XSETINT (bar
->top
, top
);
7923 XSETINT (bar
->width
, sb_width
);
7924 XSETINT (bar
->height
, height
);
7930 /* Set the scroll bar's current state, unless we're currently being
7932 if (NILP (bar
->dragging
))
7934 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
7937 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
7940 int start
= ((double) position
* top_range
) / whole
;
7941 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
7942 x_scroll_bar_set_handle (bar
, start
, end
, 0);
7948 /* The following three hooks are used when we're doing a thorough
7949 redisplay of the frame. We don't explicitly know which scroll bars
7950 are going to be deleted, because keeping track of when windows go
7951 away is a real pain - "Can you say set-window-configuration, boys
7952 and girls?" Instead, we just assert at the beginning of redisplay
7953 that *all* scroll bars are to be removed, and then save a scroll bar
7954 from the fiery pit when we actually redisplay its window. */
7956 /* Arrange for all scroll bars on FRAME to be removed at the next call
7957 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
7958 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
7961 XTcondemn_scroll_bars (frame
)
7964 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
7965 while (! NILP (FRAME_SCROLL_BARS (frame
)))
7968 bar
= FRAME_SCROLL_BARS (frame
);
7969 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
7970 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
7971 XSCROLL_BAR (bar
)->prev
= Qnil
;
7972 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
7973 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
7974 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
7978 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
7979 Note that WINDOW isn't necessarily condemned at all. */
7981 XTredeem_scroll_bar (window
)
7982 struct window
*window
;
7984 struct scroll_bar
*bar
;
7986 /* We can't redeem this window's scroll bar if it doesn't have one. */
7987 if (NILP (window
->vertical_scroll_bar
))
7990 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
7992 /* Unlink it from the condemned list. */
7994 FRAME_PTR f
= XFRAME (WINDOW_FRAME (window
));
7996 if (NILP (bar
->prev
))
7998 /* If the prev pointer is nil, it must be the first in one of
8000 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
8001 /* It's not condemned. Everything's fine. */
8003 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
8004 window
->vertical_scroll_bar
))
8005 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
8007 /* If its prev pointer is nil, it must be at the front of
8008 one or the other! */
8012 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
8014 if (! NILP (bar
->next
))
8015 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
8017 bar
->next
= FRAME_SCROLL_BARS (f
);
8019 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
8020 if (! NILP (bar
->next
))
8021 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
8025 /* Remove all scroll bars on FRAME that haven't been saved since the
8026 last call to `*condemn_scroll_bars_hook'. */
8029 XTjudge_scroll_bars (f
)
8032 Lisp_Object bar
, next
;
8034 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
8036 /* Clear out the condemned list now so we won't try to process any
8037 more events on the hapless scroll bars. */
8038 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
8040 for (; ! NILP (bar
); bar
= next
)
8042 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
8044 x_scroll_bar_remove (b
);
8047 b
->next
= b
->prev
= Qnil
;
8050 /* Now there should be no references to the condemned scroll bars,
8051 and they should get garbage-collected. */
8056 activate_scroll_bars (frame
)
8062 bar
= FRAME_SCROLL_BARS (frame
);
8063 while (! NILP (bar
))
8065 ch
= SCROLL_BAR_CONTROL_HANDLE (XSCROLL_BAR (bar
));
8066 SetControlMaximum (ch
,
8067 VERTICAL_SCROLL_BAR_TOP_RANGE (frame
,
8068 XINT (XSCROLL_BAR (bar
)
8071 bar
= XSCROLL_BAR (bar
)->next
;
8077 deactivate_scroll_bars (frame
)
8083 bar
= FRAME_SCROLL_BARS (frame
);
8084 while (! NILP (bar
))
8086 ch
= SCROLL_BAR_CONTROL_HANDLE (XSCROLL_BAR (bar
));
8087 SetControlMaximum (ch
, XINT (-1));
8089 bar
= XSCROLL_BAR (bar
)->next
;
8093 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
8094 is set to something other than no_event, it is enqueued.
8096 This may be called from a signal handler, so we have to ignore GC
8100 x_scroll_bar_handle_click (bar
, part_code
, er
, bufp
)
8101 struct scroll_bar
*bar
;
8104 struct input_event
*bufp
;
8106 if (! GC_WINDOWP (bar
->window
))
8109 bufp
->kind
= scroll_bar_click
;
8110 bufp
->frame_or_window
= bar
->window
;
8113 bar
->dragging
= Qnil
;
8117 case kControlUpButtonPart
:
8118 bufp
->part
= scroll_bar_up_arrow
;
8120 case kControlDownButtonPart
:
8121 bufp
->part
= scroll_bar_down_arrow
;
8123 case kControlPageUpPart
:
8124 bufp
->part
= scroll_bar_above_handle
;
8126 case kControlPageDownPart
:
8127 bufp
->part
= scroll_bar_below_handle
;
8129 case kControlIndicatorPart
:
8130 if (er
->what
== mouseDown
)
8131 bar
->dragging
= make_number (0);
8132 XSETVECTOR (last_mouse_scroll_bar
, bar
);
8133 bufp
->part
= scroll_bar_handle
;
8139 /* Handle some mouse motion while someone is dragging the scroll bar.
8141 This may be called from a signal handler, so we have to ignore GC
8145 x_scroll_bar_note_movement (bar
, y_pos
, t
)
8146 struct scroll_bar
*bar
;
8150 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
8152 last_mouse_movement_time
= t
;
8155 XSETVECTOR (last_mouse_scroll_bar
, bar
);
8157 /* If we're dragging the bar, display it. */
8158 if (! GC_NILP (bar
->dragging
))
8160 /* Where should the handle be now? */
8161 int new_start
= y_pos
- 24;
8163 if (new_start
!= XINT (bar
->start
))
8165 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
8167 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
8173 /* Return information to the user about the current position of the
8174 mouse on the scroll bar. */
8177 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
8179 Lisp_Object
*bar_window
;
8180 enum scroll_bar_part
*part
;
8182 unsigned long *time
;
8184 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
8185 WindowPtr wp
= FrontWindow ();
8187 struct frame
*f
= ((mac_output
*) GetWRefCon (wp
))->mFP
;
8188 int win_y
, top_range
;
8191 GetMouse (&mouse_pos
);
8193 win_y
= mouse_pos
.v
- XINT (bar
->top
);
8194 top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
8196 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
8200 if (! NILP (bar
->dragging
))
8201 win_y
-= XINT (bar
->dragging
);
8205 if (win_y
> top_range
)
8209 *bar_window
= bar
->window
;
8211 if (! NILP (bar
->dragging
))
8212 *part
= scroll_bar_handle
;
8213 else if (win_y
< XINT (bar
->start
))
8214 *part
= scroll_bar_above_handle
;
8215 else if (win_y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
8216 *part
= scroll_bar_handle
;
8218 *part
= scroll_bar_below_handle
;
8220 XSETINT (*x
, win_y
);
8221 XSETINT (*y
, top_range
);
8224 last_mouse_scroll_bar
= Qnil
;
8226 *time
= last_mouse_movement_time
;
8229 /***********************************************************************
8231 ***********************************************************************/
8233 /* Note if the text cursor of window W has been overwritten by a
8234 drawing operation that outputs N glyphs starting at HPOS in the
8235 line given by output_cursor.vpos. N < 0 means all the rest of the
8236 line after HPOS has been written. */
8239 note_overwritten_text_cursor (w
, hpos
, n
)
8243 if (updated_area
== TEXT_AREA
8244 && output_cursor
.vpos
== w
->phys_cursor
.vpos
8245 && hpos
<= w
->phys_cursor
.hpos
8247 || hpos
+ n
> w
->phys_cursor
.hpos
))
8248 w
->phys_cursor_on_p
= 0;
8252 /* Set clipping for output in glyph row ROW. W is the window in which
8253 we operate. GC is the graphics context to set clipping in.
8254 WHOLE_LINE_P non-zero means include the areas used for truncation
8255 mark display and alike in the clipping rectangle.
8257 ROW may be a text row or, e.g., a mode line. Text rows must be
8258 clipped to the interior of the window dedicated to text display,
8259 mode lines must be clipped to the whole window. */
8262 x_clip_to_row (w
, row
, gc
, whole_line_p
)
8264 struct glyph_row
*row
;
8268 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
8270 int window_x
, window_y
, window_width
, window_height
;
8272 window_box (w
, -1, &window_x
, &window_y
, &window_width
, &window_height
);
8274 clip_rect
.left
= WINDOW_TO_FRAME_PIXEL_X (w
, 0);
8275 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
8276 clip_rect
.top
= max (clip_rect
.top
, window_y
);
8277 clip_rect
.right
= clip_rect
.left
+ window_width
;
8278 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
8280 /* If clipping to the whole line, including trunc marks, extend
8281 the rectangle to the left and increase its width. */
8284 clip_rect
.left
-= FRAME_X_LEFT_FLAGS_AREA_WIDTH (f
);
8285 clip_rect
.right
+= FRAME_X_FLAGS_AREA_WIDTH (f
);
8288 mac_set_clip_rectangle (FRAME_MAC_DISPLAY (f
), FRAME_MAC_WINDOW (f
), &clip_rect
);
8292 /* Draw a hollow box cursor on window W in glyph row ROW. */
8295 x_draw_hollow_cursor (w
, row
)
8297 struct glyph_row
*row
;
8299 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
8300 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
8301 Display
*dpy
= FRAME_MAC_DISPLAY (f
);
8304 struct glyph
*cursor_glyph
;
8307 /* Compute frame-relative coordinates from window-relative
8309 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
8310 y
= (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
)
8311 + row
->ascent
- w
->phys_cursor_ascent
);
8312 h
= row
->height
- 1;
8314 /* Get the glyph the cursor is on. If we can't tell because
8315 the current matrix is invalid or such, give up. */
8316 cursor_glyph
= get_phys_cursor_glyph (w
);
8317 if (cursor_glyph
== NULL
)
8320 /* Compute the width of the rectangle to draw. If on a stretch
8321 glyph, and `x-stretch-block-cursor' is nil, don't draw a
8322 rectangle as wide as the glyph, but use a canonical character
8324 wd
= cursor_glyph
->pixel_width
- 1;
8325 if (cursor_glyph
->type
== STRETCH_GLYPH
8326 && !x_stretch_cursor_p
)
8327 wd
= min (CANON_X_UNIT (f
), wd
);
8329 /* The foreground of cursor_gc is typically the same as the normal
8330 background color, which can cause the cursor box to be invisible. */
8331 xgcv
.foreground
= f
->output_data
.mac
->cursor_pixel
;
8332 if (dpyinfo
->scratch_cursor_gc
)
8333 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
8335 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_MAC_WINDOW (f
),
8336 GCForeground
, &xgcv
);
8337 gc
= dpyinfo
->scratch_cursor_gc
;
8339 /* Set clipping, draw the rectangle, and reset clipping again. */
8340 x_clip_to_row (w
, row
, gc
, 0);
8341 mac_draw_rectangle (dpy
, FRAME_MAC_WINDOW (f
), gc
, x
, y
, wd
, h
);
8342 mac_reset_clipping (dpy
, FRAME_MAC_WINDOW (f
));
8346 /* Draw a bar cursor on window W in glyph row ROW.
8348 Implementation note: One would like to draw a bar cursor with an
8349 angle equal to the one given by the font property XA_ITALIC_ANGLE.
8350 Unfortunately, I didn't find a font yet that has this property set.
8354 x_draw_bar_cursor (w
, row
, width
)
8356 struct glyph_row
*row
;
8359 /* If cursor hpos is out of bounds, don't draw garbage. This can
8360 happen in mini-buffer windows when switching between echo area
8361 glyphs and mini-buffer. */
8362 if (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])
8364 struct frame
*f
= XFRAME (w
->frame
);
8365 struct glyph
*cursor_glyph
;
8373 cursor_glyph
= get_phys_cursor_glyph (w
);
8374 if (cursor_glyph
== NULL
)
8377 xgcv
.background
= f
->output_data
.mac
->cursor_pixel
;
8378 xgcv
.foreground
= f
->output_data
.mac
->cursor_pixel
;
8379 mask
= GCForeground
| GCBackground
;
8380 dpy
= FRAME_MAC_DISPLAY (f
);
8381 window
= FRAME_MAC_WINDOW (f
);
8382 gc
= FRAME_X_DISPLAY_INFO (f
)->scratch_cursor_gc
;
8385 XChangeGC (dpy
, gc
, mask
, &xgcv
);
8388 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
8389 FRAME_MAC_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
8393 width
= f
->output_data
.mac
->cursor_width
;
8395 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
);
8396 x_clip_to_row (w
, row
, gc
, 0);
8397 XFillRectangle (dpy
, window
, gc
,
8399 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
8400 min (cursor_glyph
->pixel_width
, width
),
8402 mac_reset_clipping (dpy
, FRAME_MAC_WINDOW (f
));
8407 /* Clear the cursor of window W to background color, and mark the
8408 cursor as not shown. This is used when the text where the cursor
8409 is is about to be rewritten. */
8415 if (FRAME_VISIBLE_P (XFRAME (w
->frame
)) && w
->phys_cursor_on_p
)
8416 x_update_window_cursor (w
, 0);
8420 /* Draw the cursor glyph of window W in glyph row ROW. See the
8421 comment of x_draw_glyphs for the meaning of HL. */
8424 x_draw_phys_cursor_glyph (w
, row
, hl
)
8426 struct glyph_row
*row
;
8427 enum draw_glyphs_face hl
;
8429 /* If cursor hpos is out of bounds, don't draw garbage. This can
8430 happen in mini-buffer windows when switching between echo area
8431 glyphs and mini-buffer. */
8432 if (w
->phys_cursor
.hpos
< row
->used
[TEXT_AREA
])
8434 x_draw_glyphs (w
, w
->phys_cursor
.x
, row
, TEXT_AREA
,
8435 w
->phys_cursor
.hpos
, w
->phys_cursor
.hpos
+ 1,
8438 /* When we erase the cursor, and ROW is overlapped by other
8439 rows, make sure that these overlapping parts of other rows
8441 if (hl
== DRAW_NORMAL_TEXT
&& row
->overlapped_p
)
8443 if (row
> w
->current_matrix
->rows
8444 && MATRIX_ROW_OVERLAPS_SUCC_P (row
- 1))
8445 x_fix_overlapping_area (w
, row
- 1, TEXT_AREA
);
8447 if (MATRIX_ROW_BOTTOM_Y (row
) < window_text_bottom_y (w
)
8448 && MATRIX_ROW_OVERLAPS_PRED_P (row
+ 1))
8449 x_fix_overlapping_area (w
, row
+ 1, TEXT_AREA
);
8455 /* Erase the image of a cursor of window W from the screen. */
8458 x_erase_phys_cursor (w
)
8461 struct frame
*f
= XFRAME (w
->frame
);
8462 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8463 int hpos
= w
->phys_cursor
.hpos
;
8464 int vpos
= w
->phys_cursor
.vpos
;
8465 int mouse_face_here_p
= 0;
8466 struct glyph_matrix
*active_glyphs
= w
->current_matrix
;
8467 struct glyph_row
*cursor_row
;
8468 struct glyph
*cursor_glyph
;
8469 enum draw_glyphs_face hl
;
8471 /* No cursor displayed or row invalidated => nothing to do on the
8473 if (w
->phys_cursor_type
== NO_CURSOR
)
8474 goto mark_cursor_off
;
8476 /* VPOS >= active_glyphs->nrows means that window has been resized.
8477 Don't bother to erase the cursor. */
8478 if (vpos
>= active_glyphs
->nrows
)
8479 goto mark_cursor_off
;
8481 /* If row containing cursor is marked invalid, there is nothing we
8483 cursor_row
= MATRIX_ROW (active_glyphs
, vpos
);
8484 if (!cursor_row
->enabled_p
)
8485 goto mark_cursor_off
;
8487 /* This can happen when the new row is shorter than the old one.
8488 In this case, either x_draw_glyphs or clear_end_of_line
8489 should have cleared the cursor. Note that we wouldn't be
8490 able to erase the cursor in this case because we don't have a
8491 cursor glyph at hand. */
8492 if (w
->phys_cursor
.hpos
>= cursor_row
->used
[TEXT_AREA
])
8493 goto mark_cursor_off
;
8495 /* If the cursor is in the mouse face area, redisplay that when
8496 we clear the cursor. */
8497 if (! NILP (dpyinfo
->mouse_face_window
)
8498 && w
== XWINDOW (dpyinfo
->mouse_face_window
)
8499 && (vpos
> dpyinfo
->mouse_face_beg_row
8500 || (vpos
== dpyinfo
->mouse_face_beg_row
8501 && hpos
>= dpyinfo
->mouse_face_beg_col
))
8502 && (vpos
< dpyinfo
->mouse_face_end_row
8503 || (vpos
== dpyinfo
->mouse_face_end_row
8504 && hpos
< dpyinfo
->mouse_face_end_col
))
8505 /* Don't redraw the cursor's spot in mouse face if it is at the
8506 end of a line (on a newline). The cursor appears there, but
8507 mouse highlighting does not. */
8508 && cursor_row
->used
[TEXT_AREA
] > hpos
)
8509 mouse_face_here_p
= 1;
8511 /* Maybe clear the display under the cursor. */
8512 if (w
->phys_cursor_type
== HOLLOW_BOX_CURSOR
)
8515 int header_line_height
= WINDOW_DISPLAY_HEADER_LINE_HEIGHT (w
);
8517 cursor_glyph
= get_phys_cursor_glyph (w
);
8518 if (cursor_glyph
== NULL
)
8519 goto mark_cursor_off
;
8521 x
= WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
8523 XClearArea (FRAME_MAC_DISPLAY (f
), FRAME_MAC_WINDOW (f
),
8525 WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
8527 cursor_glyph
->pixel_width
,
8528 cursor_row
->visible_height
,
8532 /* Erase the cursor by redrawing the character underneath it. */
8533 if (mouse_face_here_p
)
8534 hl
= DRAW_MOUSE_FACE
;
8535 else if (cursor_row
->inverse_p
)
8536 hl
= DRAW_INVERSE_VIDEO
;
8538 hl
= DRAW_NORMAL_TEXT
;
8539 x_draw_phys_cursor_glyph (w
, cursor_row
, hl
);
8542 w
->phys_cursor_on_p
= 0;
8543 w
->phys_cursor_type
= NO_CURSOR
;
8547 /* Display or clear cursor of window W. If ON is zero, clear the
8548 cursor. If it is non-zero, display the cursor. If ON is nonzero,
8549 where to put the cursor is specified by HPOS, VPOS, X and Y. */
8552 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
)
8554 int on
, hpos
, vpos
, x
, y
;
8556 struct frame
*f
= XFRAME (w
->frame
);
8557 int new_cursor_type
;
8558 int new_cursor_width
;
8559 struct glyph_matrix
*current_glyphs
;
8560 struct glyph_row
*glyph_row
;
8561 struct glyph
*glyph
;
8563 /* This is pointless on invisible frames, and dangerous on garbaged
8564 windows and frames; in the latter case, the frame or window may
8565 be in the midst of changing its size, and x and y may be off the
8567 if (! FRAME_VISIBLE_P (f
)
8568 || FRAME_GARBAGED_P (f
)
8569 || vpos
>= w
->current_matrix
->nrows
8570 || hpos
>= w
->current_matrix
->matrix_w
)
8573 /* If cursor is off and we want it off, return quickly. */
8574 if (!on
&& !w
->phys_cursor_on_p
)
8577 current_glyphs
= w
->current_matrix
;
8578 glyph_row
= MATRIX_ROW (current_glyphs
, vpos
);
8579 glyph
= glyph_row
->glyphs
[TEXT_AREA
] + hpos
;
8581 /* If cursor row is not enabled, we don't really know where to
8582 display the cursor. */
8583 if (!glyph_row
->enabled_p
)
8585 w
->phys_cursor_on_p
= 0;
8589 xassert (interrupt_input_blocked
);
8591 /* Set new_cursor_type to the cursor we want to be displayed. In a
8592 mini-buffer window, we want the cursor only to appear if we are
8593 reading input from this window. For the selected window, we want
8594 the cursor type given by the frame parameter. If explicitly
8595 marked off, draw no cursor. In all other cases, we want a hollow
8597 new_cursor_width
= -1;
8598 if (cursor_in_echo_area
8599 && FRAME_HAS_MINIBUF_P (f
)
8600 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
))
8602 if (w
== XWINDOW (echo_area_window
))
8603 new_cursor_type
= FRAME_DESIRED_CURSOR (f
);
8605 new_cursor_type
= HOLLOW_BOX_CURSOR
;
8609 if (w
!= XWINDOW (selected_window
)
8610 || f
!= FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
)
8612 extern int cursor_in_non_selected_windows
;
8614 if (MINI_WINDOW_P (w
) || !cursor_in_non_selected_windows
)
8615 new_cursor_type
= NO_CURSOR
;
8617 new_cursor_type
= HOLLOW_BOX_CURSOR
;
8619 else if (w
->cursor_off_p
)
8620 new_cursor_type
= NO_CURSOR
;
8623 struct buffer
*b
= XBUFFER (w
->buffer
);
8625 if (EQ (b
->cursor_type
, Qt
))
8626 new_cursor_type
= FRAME_DESIRED_CURSOR (f
);
8628 new_cursor_type
= x_specified_cursor_type (b
->cursor_type
,
8633 /* If cursor is currently being shown and we don't want it to be or
8634 it is in the wrong place, or the cursor type is not what we want,
8636 if (w
->phys_cursor_on_p
8638 || w
->phys_cursor
.x
!= x
8639 || w
->phys_cursor
.y
!= y
8640 || new_cursor_type
!= w
->phys_cursor_type
))
8641 x_erase_phys_cursor (w
);
8643 /* If the cursor is now invisible and we want it to be visible,
8645 if (on
&& !w
->phys_cursor_on_p
)
8647 w
->phys_cursor_ascent
= glyph_row
->ascent
;
8648 w
->phys_cursor_height
= glyph_row
->height
;
8650 /* Set phys_cursor_.* before x_draw_.* is called because some
8651 of them may need the information. */
8652 w
->phys_cursor
.x
= x
;
8653 w
->phys_cursor
.y
= glyph_row
->y
;
8654 w
->phys_cursor
.hpos
= hpos
;
8655 w
->phys_cursor
.vpos
= vpos
;
8656 w
->phys_cursor_type
= new_cursor_type
;
8657 w
->phys_cursor_on_p
= 1;
8659 switch (new_cursor_type
)
8661 case HOLLOW_BOX_CURSOR
:
8662 x_draw_hollow_cursor (w
, glyph_row
);
8665 case FILLED_BOX_CURSOR
:
8666 x_draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
8670 x_draw_bar_cursor (w
, glyph_row
, new_cursor_width
);
8681 if (w
== XWINDOW (f
->selected_window
))
8682 if (FRAME_XIC (f
) && (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
))
8683 xic_set_preeditarea (w
, x
, y
);
8688 if (updating_frame
!= f
)
8689 XFlush (FRAME_X_DISPLAY (f
));
8694 /* Display the cursor on window W, or clear it. X and Y are window
8695 relative pixel coordinates. HPOS and VPOS are glyph matrix
8696 positions. If W is not the selected window, display a hollow
8697 cursor. ON non-zero means display the cursor at X, Y which
8698 correspond to HPOS, VPOS, otherwise it is cleared. */
8701 x_display_cursor (w
, on
, hpos
, vpos
, x
, y
)
8703 int on
, hpos
, vpos
, x
, y
;
8706 x_display_and_set_cursor (w
, on
, hpos
, vpos
, x
, y
);
8711 /* Display the cursor on window W, or clear it, according to ON_P.
8712 Don't change the cursor's position. */
8715 x_update_cursor (f
, on_p
)
8718 x_update_cursor_in_window_tree (XWINDOW (f
->root_window
), on_p
);
8722 /* Call x_update_window_cursor with parameter ON_P on all leaf windows
8723 in the window tree rooted at W. */
8726 x_update_cursor_in_window_tree (w
, on_p
)
8732 if (!NILP (w
->hchild
))
8733 x_update_cursor_in_window_tree (XWINDOW (w
->hchild
), on_p
);
8734 else if (!NILP (w
->vchild
))
8735 x_update_cursor_in_window_tree (XWINDOW (w
->vchild
), on_p
);
8737 x_update_window_cursor (w
, on_p
);
8739 w
= NILP (w
->next
) ? 0 : XWINDOW (w
->next
);
8744 /* Switch the display of W's cursor on or off, according to the value
8748 x_update_window_cursor (w
, on
)
8752 /* Don't update cursor in windows whose frame is in the process
8753 of being deleted. */
8754 if (w
->current_matrix
)
8757 x_display_and_set_cursor (w
, on
, w
->phys_cursor
.hpos
, w
->phys_cursor
.vpos
,
8758 w
->phys_cursor
.x
, w
->phys_cursor
.y
);
8764 #if 0 /* MAC_TODO: no icon and X error handling (?) */
8767 /* Refresh bitmap kitchen sink icon for frame F
8768 when we get an expose event for it. */
8774 /* Normally, the window manager handles this function. */
8777 /* Make the x-window of frame F use the gnu icon bitmap. */
8780 x_bitmap_icon (f
, file
)
8786 if (FRAME_X_WINDOW (f
) == 0)
8789 /* Free up our existing icon bitmap if any. */
8790 if (f
->output_data
.x
->icon_bitmap
> 0)
8791 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
8792 f
->output_data
.x
->icon_bitmap
= 0;
8795 bitmap_id
= x_create_bitmap_from_file (f
, file
);
8798 /* Create the GNU bitmap if necessary. */
8799 if (FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
< 0)
8800 FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
8801 = x_create_bitmap_from_data (f
, gnu_bits
,
8802 gnu_width
, gnu_height
);
8804 /* The first time we create the GNU bitmap,
8805 this increments the ref-count one extra time.
8806 As a result, the GNU bitmap is never freed.
8807 That way, we don't have to worry about allocating it again. */
8808 x_reference_bitmap (f
, FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
);
8810 bitmap_id
= FRAME_X_DISPLAY_INFO (f
)->icon_bitmap_id
;
8813 x_wm_set_icon_pixmap (f
, bitmap_id
);
8814 f
->output_data
.x
->icon_bitmap
= bitmap_id
;
8820 /* Make the x-window of frame F use a rectangle with text.
8821 Use ICON_NAME as the text. */
8824 x_text_icon (f
, icon_name
)
8828 if (FRAME_X_WINDOW (f
) == 0)
8834 text
.value
= (unsigned char *) icon_name
;
8835 text
.encoding
= XA_STRING
;
8837 text
.nitems
= strlen (icon_name
);
8838 #ifdef USE_X_TOOLKIT
8839 XSetWMIconName (FRAME_X_DISPLAY (f
), XtWindow (f
->output_data
.x
->widget
),
8841 #else /* not USE_X_TOOLKIT */
8842 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &text
);
8843 #endif /* not USE_X_TOOLKIT */
8845 #else /* not HAVE_X11R4 */
8846 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), icon_name
);
8847 #endif /* not HAVE_X11R4 */
8849 if (f
->output_data
.x
->icon_bitmap
> 0)
8850 x_destroy_bitmap (f
, f
->output_data
.x
->icon_bitmap
);
8851 f
->output_data
.x
->icon_bitmap
= 0;
8852 x_wm_set_icon_pixmap (f
, 0);
8857 #define X_ERROR_MESSAGE_SIZE 200
8859 /* If non-nil, this should be a string.
8860 It means catch X errors and store the error message in this string. */
8862 static Lisp_Object x_error_message_string
;
8864 /* An X error handler which stores the error message in
8865 x_error_message_string. This is called from x_error_handler if
8866 x_catch_errors is in effect. */
8869 x_error_catcher (display
, error
)
8873 XGetErrorText (display
, error
->error_code
,
8874 XSTRING (x_error_message_string
)->data
,
8875 X_ERROR_MESSAGE_SIZE
);
8878 /* Begin trapping X errors for display DPY. Actually we trap X errors
8879 for all displays, but DPY should be the display you are actually
8882 After calling this function, X protocol errors no longer cause
8883 Emacs to exit; instead, they are recorded in the string
8884 stored in x_error_message_string.
8886 Calling x_check_errors signals an Emacs error if an X error has
8887 occurred since the last call to x_catch_errors or x_check_errors.
8889 Calling x_uncatch_errors resumes the normal error handling. */
8891 void x_check_errors ();
8892 static Lisp_Object
x_catch_errors_unwind ();
8895 x_catch_errors (dpy
)
8898 int count
= specpdl_ptr
- specpdl
;
8900 /* Make sure any errors from previous requests have been dealt with. */
8903 record_unwind_protect (x_catch_errors_unwind
, x_error_message_string
);
8905 x_error_message_string
= make_uninit_string (X_ERROR_MESSAGE_SIZE
);
8906 XSTRING (x_error_message_string
)->data
[0] = 0;
8911 /* Unbind the binding that we made to check for X errors. */
8914 x_catch_errors_unwind (old_val
)
8915 Lisp_Object old_val
;
8917 x_error_message_string
= old_val
;
8921 /* If any X protocol errors have arrived since the last call to
8922 x_catch_errors or x_check_errors, signal an Emacs error using
8923 sprintf (a buffer, FORMAT, the x error message text) as the text. */
8926 x_check_errors (dpy
, format
)
8930 /* Make sure to catch any errors incurred so far. */
8933 if (XSTRING (x_error_message_string
)->data
[0])
8934 error (format
, XSTRING (x_error_message_string
)->data
);
8937 /* Nonzero if we had any X protocol errors
8938 since we did x_catch_errors on DPY. */
8941 x_had_errors_p (dpy
)
8944 /* Make sure to catch any errors incurred so far. */
8947 return XSTRING (x_error_message_string
)->data
[0] != 0;
8950 /* Forget about any errors we have had, since we did x_catch_errors on DPY. */
8953 x_clear_errors (dpy
)
8956 XSTRING (x_error_message_string
)->data
[0] = 0;
8959 /* Stop catching X protocol errors and let them make Emacs die.
8960 DPY should be the display that was passed to x_catch_errors.
8961 COUNT should be the value that was returned by
8962 the corresponding call to x_catch_errors. */
8965 x_uncatch_errors (dpy
, count
)
8969 unbind_to (count
, Qnil
);
8973 static unsigned int x_wire_count
;
8976 fprintf (stderr
, "Lib call: %d\n", ++x_wire_count
);
8981 /* Handle SIGPIPE, which can happen when the connection to a server
8982 simply goes away. SIGPIPE is handled by x_connection_signal.
8983 Don't need to do anything, because the write which caused the
8984 SIGPIPE will fail, causing Xlib to invoke the X IO error handler,
8985 which will do the appropriate cleanup for us. */
8988 x_connection_signal (signalnum
) /* If we don't have an argument, */
8989 int signalnum
; /* some compilers complain in signal calls. */
8992 /* USG systems forget handlers when they are used;
8993 must reestablish each time */
8994 signal (signalnum
, x_connection_signal
);
8998 /* Handling X errors. */
9000 /* Handle the loss of connection to display DISPLAY. */
9003 x_connection_closed (display
, error_message
)
9005 char *error_message
;
9007 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
9008 Lisp_Object frame
, tail
;
9010 /* Indicate that this display is dead. */
9012 #if 0 /* Closing the display caused a bus error on OpenWindows. */
9013 #ifdef USE_X_TOOLKIT
9014 XtCloseDisplay (display
);
9019 dpyinfo
->display
= 0;
9021 /* First delete frames whose mini-buffers are on frames
9022 that are on the dead display. */
9023 FOR_EACH_FRAME (tail
, frame
)
9025 Lisp_Object minibuf_frame
;
9027 = WINDOW_FRAME (XWINDOW (FRAME_MINIBUF_WINDOW (XFRAME (frame
))));
9028 if (FRAME_X_P (XFRAME (frame
))
9029 && FRAME_X_P (XFRAME (minibuf_frame
))
9030 && ! EQ (frame
, minibuf_frame
)
9031 && FRAME_X_DISPLAY_INFO (XFRAME (minibuf_frame
)) == dpyinfo
)
9032 Fdelete_frame (frame
, Qt
);
9035 /* Now delete all remaining frames on the dead display.
9036 We are now sure none of these is used as the mini-buffer
9037 for another frame that we need to delete. */
9038 FOR_EACH_FRAME (tail
, frame
)
9039 if (FRAME_X_P (XFRAME (frame
))
9040 && FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
9042 /* Set this to t so that Fdelete_frame won't get confused
9043 trying to find a replacement. */
9044 FRAME_KBOARD (XFRAME (frame
))->Vdefault_minibuffer_frame
= Qt
;
9045 Fdelete_frame (frame
, Qt
);
9049 x_delete_display (dpyinfo
);
9051 if (x_display_list
== 0)
9053 fprintf (stderr
, "%s\n", error_message
);
9054 shut_down_emacs (0, 0, Qnil
);
9058 /* Ordinary stack unwind doesn't deal with these. */
9060 sigunblock (sigmask (SIGIO
));
9062 sigunblock (sigmask (SIGALRM
));
9063 TOTALLY_UNBLOCK_INPUT
;
9065 clear_waiting_for_input ();
9066 error ("%s", error_message
);
9069 /* This is the usual handler for X protocol errors.
9070 It kills all frames on the display that we got the error for.
9071 If that was the only one, it prints an error message and kills Emacs. */
9074 x_error_quitter (display
, error
)
9078 char buf
[256], buf1
[356];
9080 /* Note that there is no real way portable across R3/R4 to get the
9081 original error handler. */
9083 XGetErrorText (display
, error
->error_code
, buf
, sizeof (buf
));
9084 sprintf (buf1
, "X protocol error: %s on protocol request %d",
9085 buf
, error
->request_code
);
9086 x_connection_closed (display
, buf1
);
9089 /* This is the first-level handler for X protocol errors.
9090 It calls x_error_quitter or x_error_catcher. */
9093 x_error_handler (display
, error
)
9097 if (! NILP (x_error_message_string
))
9098 x_error_catcher (display
, error
);
9100 x_error_quitter (display
, error
);
9104 /* This is the handler for X IO errors, always.
9105 It kills all frames on the display that we lost touch with.
9106 If that was the only one, it prints an error message and kills Emacs. */
9109 x_io_error_quitter (display
)
9114 sprintf (buf
, "Connection lost to X server `%s'", DisplayString (display
));
9115 x_connection_closed (display
, buf
);
9120 /* Changing the font of the frame. */
9122 /* Give frame F the font named FONTNAME as its default font, and
9123 return the full name of that font. FONTNAME may be a wildcard
9124 pattern; in that case, we choose some font that fits the pattern.
9125 The return value shows which font we chose. */
9128 x_new_font (f
, fontname
)
9130 register char *fontname
;
9132 struct font_info
*fontp
9133 = FS_LOAD_FONT (f
, 0, fontname
, -1);
9138 f
->output_data
.mac
->font
= (XFontStruct
*) (fontp
->font
);
9139 f
->output_data
.mac
->baseline_offset
= fontp
->baseline_offset
;
9140 f
->output_data
.mac
->fontset
= -1;
9142 /* Compute the scroll bar width in character columns. */
9143 if (f
->scroll_bar_pixel_width
> 0)
9145 int wid
= FONT_WIDTH (f
->output_data
.mac
->font
);
9146 f
->scroll_bar_cols
= (f
->scroll_bar_pixel_width
+ wid
-1) / wid
;
9150 int wid
= FONT_WIDTH (f
->output_data
.mac
->font
);
9151 f
->scroll_bar_cols
= (14 + wid
- 1) / wid
;
9154 /* Now make the frame display the given font. */
9155 if (FRAME_MAC_WINDOW (f
) != 0)
9157 XSetFont (FRAME_MAC_DISPLAY (f
), f
->output_data
.mac
->normal_gc
,
9158 f
->output_data
.mac
->font
);
9159 XSetFont (FRAME_MAC_DISPLAY (f
), f
->output_data
.mac
->reverse_gc
,
9160 f
->output_data
.mac
->font
);
9161 XSetFont (FRAME_MAC_DISPLAY (f
), f
->output_data
.mac
->cursor_gc
,
9162 f
->output_data
.mac
->font
);
9164 frame_update_line_height (f
);
9165 x_set_window_size (f
, 0, f
->width
, f
->height
);
9168 /* If we are setting a new frame's font for the first time, there
9169 are no faces yet, so this font's height is the line height. */
9170 f
->output_data
.mac
->line_height
= FONT_HEIGHT (f
->output_data
.mac
->font
);
9172 return build_string (fontp
->full_name
);
9175 /* Give frame F the fontset named FONTSETNAME as its default font, and
9176 return the full name of that fontset. FONTSETNAME may be a
9177 wildcard pattern; in that case, we choose some fontset that fits
9178 the pattern. The return value shows which fontset we chose. */
9181 x_new_fontset (f
, fontsetname
)
9185 int fontset
= fs_query_fontset (build_string (fontsetname
), 0);
9191 if (f
->output_data
.mac
->fontset
== fontset
)
9192 /* This fontset is already set in frame F. There's nothing more
9194 return fontset_name (fontset
);
9196 result
= x_new_font (f
, (XSTRING (fontset_ascii (fontset
))->data
));
9198 if (!STRINGP (result
))
9199 /* Can't load ASCII font. */
9202 /* Since x_new_font doesn't update any fontset information, do it
9204 f
->output_data
.mac
->fontset
= fontset
;
9208 && (FRAME_XIC_STYLE (f
) & (XIMPreeditPosition
| XIMStatusArea
)))
9209 xic_set_xfontset (f
, XSTRING (fontset_ascii (fontset
))->data
);
9212 return build_string (fontsetname
);
9215 #if 0 /* MAC_TODO: inline input methods for Mac */
9217 /***********************************************************************
9219 ***********************************************************************/
9225 /* XIM destroy callback function, which is called whenever the
9226 connection to input method XIM dies. CLIENT_DATA contains a
9227 pointer to the x_display_info structure corresponding to XIM. */
9230 xim_destroy_callback (xim
, client_data
, call_data
)
9232 XPointer client_data
;
9235 struct x_display_info
*dpyinfo
= (struct x_display_info
*) client_data
;
9236 Lisp_Object frame
, tail
;
9240 /* No need to call XDestroyIC.. */
9241 FOR_EACH_FRAME (tail
, frame
)
9243 struct frame
*f
= XFRAME (frame
);
9244 if (FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
9246 FRAME_XIC (f
) = NULL
;
9247 if (FRAME_XIC_FONTSET (f
))
9249 XFreeFontSet (FRAME_X_DISPLAY (f
), FRAME_XIC_FONTSET (f
));
9250 FRAME_XIC_FONTSET (f
) = NULL
;
9255 /* No need to call XCloseIM. */
9256 dpyinfo
->xim
= NULL
;
9257 XFree (dpyinfo
->xim_styles
);
9261 #endif /* HAVE_X11R6 */
9263 /* Open the connection to the XIM server on display DPYINFO.
9264 RESOURCE_NAME is the resource name Emacs uses. */
9267 xim_open_dpy (dpyinfo
, resource_name
)
9268 struct x_display_info
*dpyinfo
;
9269 char *resource_name
;
9274 xim
= XOpenIM (dpyinfo
->display
, dpyinfo
->xrdb
, resource_name
, EMACS_CLASS
);
9280 XIMCallback destroy
;
9283 /* Get supported styles and XIM values. */
9284 XGetIMValues (xim
, XNQueryInputStyle
, &dpyinfo
->xim_styles
, NULL
);
9287 destroy
.callback
= xim_destroy_callback
;
9288 destroy
.client_data
= (XPointer
)dpyinfo
;
9289 /* This isn't prptotyped in OSF 5.0. */
9290 XSetIMValues (xim
, XNDestroyCallback
, &destroy
, NULL
);
9294 #else /* not USE_XIM */
9295 dpyinfo
->xim
= NULL
;
9296 #endif /* not USE_XIM */
9300 #ifdef HAVE_X11R6_XIM
9304 struct x_display_info
*dpyinfo
;
9305 char *resource_name
;
9308 /* XIM instantiate callback function, which is called whenever an XIM
9309 server is available. DISPLAY is teh display of the XIM.
9310 CLIENT_DATA contains a pointer to an xim_inst_t structure created
9311 when the callback was registered. */
9314 xim_instantiate_callback (display
, client_data
, call_data
)
9316 XPointer client_data
;
9319 struct xim_inst_t
*xim_inst
= (struct xim_inst_t
*) client_data
;
9320 struct x_display_info
*dpyinfo
= xim_inst
->dpyinfo
;
9322 /* We don't support multiple XIM connections. */
9326 xim_open_dpy (dpyinfo
, xim_inst
->resource_name
);
9328 /* Create XIC for the existing frames on the same display, as long
9329 as they have no XIC. */
9330 if (dpyinfo
->xim
&& dpyinfo
->reference_count
> 0)
9332 Lisp_Object tail
, frame
;
9335 FOR_EACH_FRAME (tail
, frame
)
9337 struct frame
*f
= XFRAME (frame
);
9339 if (FRAME_X_DISPLAY_INFO (f
) == xim_inst
->dpyinfo
)
9340 if (FRAME_XIC (f
) == NULL
)
9342 create_frame_xic (f
);
9343 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
9344 xic_set_statusarea (f
);
9345 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
9347 struct window
*w
= XWINDOW (f
->selected_window
);
9348 xic_set_preeditarea (w
, w
->cursor
.x
, w
->cursor
.y
);
9357 #endif /* HAVE_X11R6_XIM */
9360 /* Open a connection to the XIM server on display DPYINFO.
9361 RESOURCE_NAME is the resource name for Emacs. On X11R5, open the
9362 connection only at the first time. On X11R6, open the connection
9363 in the XIM instantiate callback function. */
9366 xim_initialize (dpyinfo
, resource_name
)
9367 struct x_display_info
*dpyinfo
;
9368 char *resource_name
;
9371 #ifdef HAVE_X11R6_XIM
9372 struct xim_inst_t
*xim_inst
;
9375 dpyinfo
->xim
= NULL
;
9376 xim_inst
= (struct xim_inst_t
*) xmalloc (sizeof (struct xim_inst_t
));
9377 xim_inst
->dpyinfo
= dpyinfo
;
9378 len
= strlen (resource_name
);
9379 xim_inst
->resource_name
= (char *) xmalloc (len
+ 1);
9380 bcopy (resource_name
, xim_inst
->resource_name
, len
+ 1);
9381 XRegisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
9382 resource_name
, EMACS_CLASS
,
9383 xim_instantiate_callback
,
9384 /* Fixme: This is XPointer in
9385 XFree86 but (XPointer *) on
9387 (XPointer
) xim_inst
);
9388 #else /* not HAVE_X11R6_XIM */
9389 dpyinfo
->xim
= NULL
;
9390 xim_open_dpy (dpyinfo
, resource_name
);
9391 #endif /* not HAVE_X11R6_XIM */
9393 #else /* not USE_XIM */
9394 dpyinfo
->xim
= NULL
;
9395 #endif /* not USE_XIM */
9399 /* Close the connection to the XIM server on display DPYINFO. */
9402 xim_close_dpy (dpyinfo
)
9403 struct x_display_info
*dpyinfo
;
9406 #ifdef HAVE_X11R6_XIM
9407 XUnregisterIMInstantiateCallback (dpyinfo
->display
, dpyinfo
->xrdb
,
9409 xim_instantiate_callback
, NULL
);
9410 #endif /* not HAVE_X11R6_XIM */
9411 XCloseIM (dpyinfo
->xim
);
9412 dpyinfo
->xim
= NULL
;
9413 XFree (dpyinfo
->xim_styles
);
9414 #endif /* USE_XIM */
9417 #endif /* not HAVE_X11R6_XIM */
9421 /* Calculate the absolute position in frame F
9422 from its current recorded position values and gravity. */
9425 x_calc_absolute_position (f
)
9429 int flags
= f
->output_data
.mac
->size_hint_flags
;
9433 /* Find the position of the outside upper-left corner of
9434 the inner window, with respect to the outer window. */
9435 if (f
->output_data
.mac
->parent_desc
!= FRAME_MAC_DISPLAY_INFO (f
)->root_window
)
9438 GetPort (&savePort
);
9439 SetPort (FRAME_MAC_WINDOW (f
));
9440 SetPt(&pt
, FRAME_MAC_WINDOW (f
)->portRect
.left
, FRAME_MAC_WINDOW (f
)->portRect
.top
);
9441 LocalToGlobal (&pt
);
9445 /* Treat negative positions as relative to the leftmost bottommost
9446 position that fits on the screen. */
9447 if (flags
& XNegative
)
9448 f
->output_data
.mac
->left_pos
= (FRAME_MAC_DISPLAY_INFO (f
)->width
9449 - 2 * f
->output_data
.mac
->border_width
- pt
.h
9451 + f
->output_data
.mac
->left_pos
);
9452 /* NTEMACS_TODO: Subtract menubar height? */
9453 if (flags
& YNegative
)
9454 f
->output_data
.mac
->top_pos
= (FRAME_MAC_DISPLAY_INFO (f
)->height
9455 - 2 * f
->output_data
.mac
->border_width
- pt
.v
9457 + f
->output_data
.mac
->top_pos
);
9458 /* The left_pos and top_pos
9459 are now relative to the top and left screen edges,
9460 so the flags should correspond. */
9461 f
->output_data
.mac
->size_hint_flags
&= ~ (XNegative
| YNegative
);
9464 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
9465 to really change the position, and 0 when calling from
9466 x_make_frame_visible (in that case, XOFF and YOFF are the current
9467 position values). It is -1 when calling from x_set_frame_parameters,
9468 which means, do adjust for borders but don't change the gravity. */
9471 x_set_offset (f
, xoff
, yoff
, change_gravity
)
9473 register int xoff
, yoff
;
9476 if (change_gravity
> 0)
9478 f
->output_data
.mac
->top_pos
= yoff
;
9479 f
->output_data
.mac
->left_pos
= xoff
;
9480 f
->output_data
.mac
->size_hint_flags
&= ~ (XNegative
| YNegative
);
9482 f
->output_data
.mac
->size_hint_flags
|= XNegative
;
9484 f
->output_data
.mac
->size_hint_flags
|= YNegative
;
9485 f
->output_data
.mac
->win_gravity
= NorthWestGravity
;
9487 x_calc_absolute_position (f
);
9490 x_wm_set_size_hint (f
, (long) 0, 0);
9492 MoveWindow (f
->output_data
.mac
->mWP
, xoff
+ 6, yoff
+ 42, false);
9497 /* Call this to change the size of frame F's x-window.
9498 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
9499 for this size change and subsequent size changes.
9500 Otherwise we leave the window gravity unchanged. */
9503 x_set_window_size (f
, change_gravity
, cols
, rows
)
9508 int pixelwidth
, pixelheight
;
9510 check_frame_size (f
, &rows
, &cols
);
9511 f
->output_data
.mac
->vertical_scroll_bar_extra
9512 = (!FRAME_HAS_VERTICAL_SCROLL_BARS (f
)
9514 : FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) > 0
9515 ? FRAME_SCROLL_BAR_PIXEL_WIDTH (f
)
9516 : (FRAME_SCROLL_BAR_COLS (f
) * FONT_WIDTH (f
->output_data
.mac
->font
)));
9517 f
->output_data
.mac
->flags_areas_extra
9518 = FRAME_FLAGS_AREA_WIDTH (f
);
9519 pixelwidth
= CHAR_TO_PIXEL_WIDTH (f
, cols
);
9520 pixelheight
= CHAR_TO_PIXEL_HEIGHT (f
, rows
);
9522 f
->output_data
.mac
->win_gravity
= NorthWestGravity
;
9523 x_wm_set_size_hint (f
, (long) 0, 0);
9525 SizeWindow (FRAME_MAC_WINDOW (f
), pixelwidth
, pixelheight
, 0);
9527 /* Now, strictly speaking, we can't be sure that this is accurate,
9528 but the window manager will get around to dealing with the size
9529 change request eventually, and we'll hear how it went when the
9530 ConfigureNotify event gets here.
9532 We could just not bother storing any of this information here,
9533 and let the ConfigureNotify event set everything up, but that
9534 might be kind of confusing to the Lisp code, since size changes
9535 wouldn't be reported in the frame parameters until some random
9536 point in the future when the ConfigureNotify event arrives.
9538 We pass 1 for DELAY since we can't run Lisp code inside of
9540 change_frame_size (f
, rows
, cols
, 0, 1, 0);
9541 PIXEL_WIDTH (f
) = pixelwidth
;
9542 PIXEL_HEIGHT (f
) = pixelheight
;
9544 /* We've set {FRAME,PIXEL}_{WIDTH,HEIGHT} to the values we hope to
9545 receive in the ConfigureNotify event; if we get what we asked
9546 for, then the event won't cause the screen to become garbaged, so
9547 we have to make sure to do it here. */
9548 SET_FRAME_GARBAGED (f
);
9550 XFlush (FRAME_X_DISPLAY (f
));
9552 /* If cursor was outside the new size, mark it as off. */
9553 mark_window_cursors_off (XWINDOW (f
->root_window
));
9555 /* Clear out any recollection of where the mouse highlighting was,
9556 since it might be in a place that's outside the new frame size.
9557 Actually checking whether it is outside is a pain in the neck,
9558 so don't try--just let the highlighting be done afresh with new size. */
9559 cancel_mouse_face (f
);
9562 /* Mouse warping. */
9564 void x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
);
9567 x_set_mouse_position (f
, x
, y
)
9573 pix_x
= CHAR_TO_PIXEL_COL (f
, x
) + FONT_WIDTH (f
->output_data
.mac
->font
) / 2;
9574 pix_y
= CHAR_TO_PIXEL_ROW (f
, y
) + f
->output_data
.mac
->line_height
/ 2;
9576 if (pix_x
< 0) pix_x
= 0;
9577 if (pix_x
> PIXEL_WIDTH (f
)) pix_x
= PIXEL_WIDTH (f
);
9579 if (pix_y
< 0) pix_y
= 0;
9580 if (pix_y
> PIXEL_HEIGHT (f
)) pix_y
= PIXEL_HEIGHT (f
);
9582 x_set_mouse_pixel_position (f
, pix_x
, pix_y
);
9585 /* Move the mouse to position pixel PIX_X, PIX_Y relative to frame F. */
9588 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
9592 #if 0 /* MAC_TODO: CursorDeviceMoveTo is non-Carbon */
9595 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
9596 0, 0, 0, 0, pix_x
, pix_y
);
9601 /* focus shifting, raising and lowering. */
9604 x_focus_on_frame (f
)
9607 #if 0 /* This proves to be unpleasant. */
9611 /* I don't think that the ICCCM allows programs to do things like this
9612 without the interaction of the window manager. Whatever you end up
9613 doing with this code, do it to x_unfocus_frame too. */
9614 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9615 RevertToPointerRoot
, CurrentTime
);
9624 /* Look at the remarks in x_focus_on_frame. */
9625 if (FRAME_X_DISPLAY_INFO (f
)->x_focus_frame
== f
)
9626 XSetInputFocus (FRAME_X_DISPLAY (f
), PointerRoot
,
9627 RevertToPointerRoot
, CurrentTime
);
9631 /* Raise frame F. */
9637 if (f
->async_visible
)
9638 SelectWindow (FRAME_MAC_WINDOW (f
));
9641 /* Lower frame F. */
9647 if (f
->async_visible
)
9648 SendBehind (FRAME_MAC_WINDOW (f
), nil
);
9652 XTframe_raise_lower (f
, raise_flag
)
9662 /* Change of visibility. */
9664 /* This tries to wait until the frame is really visible.
9665 However, if the window manager asks the user where to position
9666 the frame, this will return before the user finishes doing that.
9667 The frame will not actually be visible at that time,
9668 but it will become visible later when the window manager
9669 finishes with it. */
9672 x_make_frame_visible (f
)
9676 int original_top
, original_left
;
9680 if (! FRAME_VISIBLE_P (f
))
9682 /* We test FRAME_GARBAGED_P here to make sure we don't
9683 call x_set_offset a second time
9684 if we get to x_make_frame_visible a second time
9685 before the window gets really visible. */
9686 if (! FRAME_ICONIFIED_P (f
)
9687 && ! f
->output_data
.mac
->asked_for_visible
)
9688 x_set_offset (f
, f
->output_data
.mac
->left_pos
,
9689 f
->output_data
.mac
->top_pos
, 0);
9691 f
->output_data
.mac
->asked_for_visible
= 1;
9693 ShowWindow (FRAME_MAC_WINDOW (f
));
9696 XFlush (FRAME_MAC_DISPLAY (f
));
9698 /* Synchronize to ensure Emacs knows the frame is visible
9699 before we do anything else. We do this loop with input not blocked
9700 so that incoming events are handled. */
9705 /* This must come after we set COUNT. */
9708 XSETFRAME (frame
, f
);
9710 /* Wait until the frame is visible. Process X events until a
9711 MapNotify event has been seen, or until we think we won't get a
9712 MapNotify at all.. */
9713 for (count
= input_signal_count
+ 10;
9714 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
9716 /* Force processing of queued events. */
9719 /* Machines that do polling rather than SIGIO have been
9720 observed to go into a busy-wait here. So we'll fake an
9721 alarm signal to let the handler know that there's something
9722 to be read. We used to raise a real alarm, but it seems
9723 that the handler isn't always enabled here. This is
9725 if (input_polling_used ())
9727 /* It could be confusing if a real alarm arrives while
9728 processing the fake one. Turn it off and let the
9729 handler reset it. */
9730 extern void poll_for_input_1
P_ ((void));
9731 int old_poll_suppress_count
= poll_suppress_count
;
9732 poll_suppress_count
= 1;
9733 poll_for_input_1 ();
9734 poll_suppress_count
= old_poll_suppress_count
;
9737 /* See if a MapNotify event has been processed. */
9738 FRAME_SAMPLE_VISIBILITY (f
);
9743 /* Change from mapped state to withdrawn state. */
9745 /* Make the frame visible (mapped and not iconified). */
9748 x_make_frame_invisible (f
)
9751 /* Don't keep the highlight on an invisible frame. */
9752 if (FRAME_MAC_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9753 FRAME_MAC_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9757 HideWindow (FRAME_MAC_WINDOW (f
));
9759 /* We can't distinguish this from iconification
9760 just by the event that we get from the server.
9761 So we can't win using the usual strategy of letting
9762 FRAME_SAMPLE_VISIBILITY set this. So do it by hand,
9763 and synchronize with the server to make sure we agree. */
9765 FRAME_ICONIFIED_P (f
) = 0;
9766 f
->async_visible
= 0;
9767 f
->async_iconified
= 0;
9772 /* Change window state from mapped to iconified. */
9778 #if 0 /* MAC_TODO: really no iconify on Mac */
9782 /* Don't keep the highlight on an invisible frame. */
9783 if (FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
9784 FRAME_X_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
9786 if (f
->async_iconified
)
9791 FRAME_SAMPLE_VISIBILITY (f
);
9793 type
= x_icon_type (f
);
9795 x_bitmap_icon (f
, type
);
9797 #ifdef USE_X_TOOLKIT
9799 if (! FRAME_VISIBLE_P (f
))
9801 if (! EQ (Vx_no_window_manager
, Qt
))
9802 x_wm_set_window_state (f
, IconicState
);
9803 /* This was XtPopup, but that did nothing for an iconified frame. */
9804 XtMapWidget (f
->output_data
.x
->widget
);
9805 /* The server won't give us any event to indicate
9806 that an invisible frame was changed to an icon,
9807 so we have to record it here. */
9810 f
->async_iconified
= 1;
9811 f
->async_visible
= 0;
9816 result
= XIconifyWindow (FRAME_X_DISPLAY (f
),
9817 XtWindow (f
->output_data
.x
->widget
),
9818 DefaultScreen (FRAME_X_DISPLAY (f
)));
9822 error ("Can't notify window manager of iconification");
9824 f
->async_iconified
= 1;
9825 f
->async_visible
= 0;
9829 XFlush (FRAME_X_DISPLAY (f
));
9831 #else /* not USE_X_TOOLKIT */
9833 /* Make sure the X server knows where the window should be positioned,
9834 in case the user deiconifies with the window manager. */
9835 if (! FRAME_VISIBLE_P (f
) && !FRAME_ICONIFIED_P (f
))
9836 x_set_offset (f
, f
->output_data
.x
->left_pos
, f
->output_data
.x
->top_pos
, 0);
9838 /* Since we don't know which revision of X we're running, we'll use both
9839 the X11R3 and X11R4 techniques. I don't know if this is a good idea. */
9841 /* X11R4: send a ClientMessage to the window manager using the
9842 WM_CHANGE_STATE type. */
9846 message
.xclient
.window
= FRAME_X_WINDOW (f
);
9847 message
.xclient
.type
= ClientMessage
;
9848 message
.xclient
.message_type
= FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_change_state
;
9849 message
.xclient
.format
= 32;
9850 message
.xclient
.data
.l
[0] = IconicState
;
9852 if (! XSendEvent (FRAME_X_DISPLAY (f
),
9853 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
9855 SubstructureRedirectMask
| SubstructureNotifyMask
,
9858 UNBLOCK_INPUT_RESIGNAL
;
9859 error ("Can't notify window manager of iconification");
9863 /* X11R3: set the initial_state field of the window manager hints to
9865 x_wm_set_window_state (f
, IconicState
);
9867 if (!FRAME_VISIBLE_P (f
))
9869 /* If the frame was withdrawn, before, we must map it. */
9870 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
9873 f
->async_iconified
= 1;
9874 f
->async_visible
= 0;
9876 XFlush (FRAME_X_DISPLAY (f
));
9878 #endif /* not USE_X_TOOLKIT */
9882 /* Destroy the X window of frame F. */
9885 x_destroy_window (f
)
9888 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
9892 DisposeWindow (FRAME_MAC_WINDOW (f
));
9894 free_frame_menubar (f
);
9895 free_frame_faces (f
);
9897 xfree (f
->output_data
.mac
);
9898 f
->output_data
.mac
= 0;
9899 if (f
== dpyinfo
->x_focus_frame
)
9900 dpyinfo
->x_focus_frame
= 0;
9901 if (f
== dpyinfo
->x_focus_event_frame
)
9902 dpyinfo
->x_focus_event_frame
= 0;
9903 if (f
== dpyinfo
->x_highlight_frame
)
9904 dpyinfo
->x_highlight_frame
= 0;
9906 dpyinfo
->reference_count
--;
9908 if (f
== dpyinfo
->mouse_face_mouse_frame
)
9910 dpyinfo
->mouse_face_beg_row
9911 = dpyinfo
->mouse_face_beg_col
= -1;
9912 dpyinfo
->mouse_face_end_row
9913 = dpyinfo
->mouse_face_end_col
= -1;
9914 dpyinfo
->mouse_face_window
= Qnil
;
9915 dpyinfo
->mouse_face_deferred_gc
= 0;
9916 dpyinfo
->mouse_face_mouse_frame
= 0;
9922 /* Setting window manager hints. */
9924 /* Set the normal size hints for the window manager, for frame F.
9925 FLAGS is the flags word to use--or 0 meaning preserve the flags
9926 that the window now has.
9927 If USER_POSITION is nonzero, we set the USPosition
9928 flag (this is useful when FLAGS is 0). */
9931 x_wm_set_size_hint (f
, flags
, user_position
)
9936 #if 0 /* MAC_TODO: connect this to the Appearance Manager */
9937 XSizeHints size_hints
;
9939 #ifdef USE_X_TOOLKIT
9942 Dimension widget_width
, widget_height
;
9943 Window window
= XtWindow (f
->output_data
.x
->widget
);
9944 #else /* not USE_X_TOOLKIT */
9945 Window window
= FRAME_X_WINDOW (f
);
9946 #endif /* not USE_X_TOOLKIT */
9948 /* Setting PMaxSize caused various problems. */
9949 size_hints
.flags
= PResizeInc
| PMinSize
/* | PMaxSize */;
9951 size_hints
.x
= f
->output_data
.x
->left_pos
;
9952 size_hints
.y
= f
->output_data
.x
->top_pos
;
9954 #ifdef USE_X_TOOLKIT
9955 XtSetArg (al
[ac
], XtNwidth
, &widget_width
); ac
++;
9956 XtSetArg (al
[ac
], XtNheight
, &widget_height
); ac
++;
9957 XtGetValues (f
->output_data
.x
->widget
, al
, ac
);
9958 size_hints
.height
= widget_height
;
9959 size_hints
.width
= widget_width
;
9960 #else /* not USE_X_TOOLKIT */
9961 size_hints
.height
= PIXEL_HEIGHT (f
);
9962 size_hints
.width
= PIXEL_WIDTH (f
);
9963 #endif /* not USE_X_TOOLKIT */
9965 size_hints
.width_inc
= FONT_WIDTH (f
->output_data
.x
->font
);
9966 size_hints
.height_inc
= f
->output_data
.x
->line_height
;
9967 size_hints
.max_width
9968 = FRAME_X_DISPLAY_INFO (f
)->width
- CHAR_TO_PIXEL_WIDTH (f
, 0);
9969 size_hints
.max_height
9970 = FRAME_X_DISPLAY_INFO (f
)->height
- CHAR_TO_PIXEL_HEIGHT (f
, 0);
9972 /* Calculate the base and minimum sizes.
9974 (When we use the X toolkit, we don't do it here.
9975 Instead we copy the values that the widgets are using, below.) */
9976 #ifndef USE_X_TOOLKIT
9978 int base_width
, base_height
;
9979 int min_rows
= 0, min_cols
= 0;
9981 base_width
= CHAR_TO_PIXEL_WIDTH (f
, 0);
9982 base_height
= CHAR_TO_PIXEL_HEIGHT (f
, 0);
9984 check_frame_size (f
, &min_rows
, &min_cols
);
9986 /* The window manager uses the base width hints to calculate the
9987 current number of rows and columns in the frame while
9988 resizing; min_width and min_height aren't useful for this
9989 purpose, since they might not give the dimensions for a
9990 zero-row, zero-column frame.
9992 We use the base_width and base_height members if we have
9993 them; otherwise, we set the min_width and min_height members
9994 to the size for a zero x zero frame. */
9997 size_hints
.flags
|= PBaseSize
;
9998 size_hints
.base_width
= base_width
;
9999 size_hints
.base_height
= base_height
;
10000 size_hints
.min_width
= base_width
+ min_cols
* size_hints
.width_inc
;
10001 size_hints
.min_height
= base_height
+ min_rows
* size_hints
.height_inc
;
10003 size_hints
.min_width
= base_width
;
10004 size_hints
.min_height
= base_height
;
10008 /* If we don't need the old flags, we don't need the old hint at all. */
10011 size_hints
.flags
|= flags
;
10014 #endif /* not USE_X_TOOLKIT */
10017 XSizeHints hints
; /* Sometimes I hate X Windows... */
10018 long supplied_return
;
10022 value
= XGetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
,
10025 value
= XGetNormalHints (FRAME_X_DISPLAY (f
), window
, &hints
);
10028 #ifdef USE_X_TOOLKIT
10029 size_hints
.base_height
= hints
.base_height
;
10030 size_hints
.base_width
= hints
.base_width
;
10031 size_hints
.min_height
= hints
.min_height
;
10032 size_hints
.min_width
= hints
.min_width
;
10036 size_hints
.flags
|= flags
;
10041 if (hints
.flags
& PSize
)
10042 size_hints
.flags
|= PSize
;
10043 if (hints
.flags
& PPosition
)
10044 size_hints
.flags
|= PPosition
;
10045 if (hints
.flags
& USPosition
)
10046 size_hints
.flags
|= USPosition
;
10047 if (hints
.flags
& USSize
)
10048 size_hints
.flags
|= USSize
;
10052 #ifndef USE_X_TOOLKIT
10057 size_hints
.win_gravity
= f
->output_data
.x
->win_gravity
;
10058 size_hints
.flags
|= PWinGravity
;
10062 size_hints
.flags
&= ~ PPosition
;
10063 size_hints
.flags
|= USPosition
;
10065 #endif /* PWinGravity */
10068 XSetWMNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
10070 XSetNormalHints (FRAME_X_DISPLAY (f
), window
, &size_hints
);
10072 #endif /* MACTODO */
10075 #if 0 /* MACTODO: hide application instead of iconify? */
10076 /* Used for IconicState or NormalState */
10079 x_wm_set_window_state (f
, state
)
10083 #ifdef USE_X_TOOLKIT
10086 XtSetArg (al
[0], XtNinitialState
, state
);
10087 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
10088 #else /* not USE_X_TOOLKIT */
10089 Window window
= FRAME_X_WINDOW (f
);
10091 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
10092 f
->output_data
.x
->wm_hints
.initial_state
= state
;
10094 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
10095 #endif /* not USE_X_TOOLKIT */
10099 x_wm_set_icon_pixmap (f
, pixmap_id
)
10103 Pixmap icon_pixmap
;
10105 #ifndef USE_X_TOOLKIT
10106 Window window
= FRAME_X_WINDOW (f
);
10111 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
10112 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
10116 /* It seems there is no way to turn off use of an icon pixmap.
10117 The following line does it, only if no icon has yet been created,
10118 for some window managers. But with mwm it crashes.
10119 Some people say it should clear the IconPixmapHint bit in this case,
10120 but that doesn't work, and the X consortium said it isn't the
10121 right thing at all. Since there is no way to win,
10122 best to explicitly give up. */
10124 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
10130 #ifdef USE_X_TOOLKIT /* same as in x_wm_set_window_state. */
10134 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
10135 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
10138 #else /* not USE_X_TOOLKIT */
10140 f
->output_data
.x
->wm_hints
.flags
|= IconPixmapHint
;
10141 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
10143 #endif /* not USE_X_TOOLKIT */
10149 x_wm_set_icon_position (f
, icon_x
, icon_y
)
10151 int icon_x
, icon_y
;
10153 #if 0 /* MAC_TODO: no icons on Mac */
10154 #ifdef USE_X_TOOLKIT
10155 Window window
= XtWindow (f
->output_data
.x
->widget
);
10157 Window window
= FRAME_X_WINDOW (f
);
10160 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
10161 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
10162 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
10164 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
10169 /***********************************************************************
10171 ***********************************************************************/
10173 /* Return a pointer to struct font_info of font FONT_IDX of frame F. */
10176 x_get_font_info (f
, font_idx
)
10180 return (FRAME_MAC_FONT_TABLE (f
) + font_idx
);
10183 /* the global font name table */
10184 char **font_name_table
= NULL
;
10185 int font_name_table_size
= 0;
10186 int font_name_count
= 0;
10188 /* compare two strings ignoring case */
10190 stricmp (const char *s
, const char *t
)
10192 for ( ; tolower (*s
) == tolower (*t
); s
++, t
++)
10195 return tolower (*s
) - tolower (*t
);
10198 /* compare two strings ignoring case and handling wildcard */
10200 wildstrieq (char *s1
, char *s2
)
10202 if (strcmp (s1
, "*") == 0 || strcmp (s2
, "*") == 0)
10205 return stricmp (s1
, s2
) == 0;
10208 /* Assume parameter 1 is fully qualified, no wildcards. */
10210 mac_font_pattern_match (fontname
, pattern
)
10214 char *regex
= (char *) alloca (strlen (pattern
) * 2);
10215 char *font_name_copy
= (char *) alloca (strlen (fontname
) + 1);
10218 /* Copy fontname so we can modify it during comparison. */
10219 strcpy (font_name_copy
, fontname
);
10224 /* Turn pattern into a regexp and do a regexp match. */
10225 for (; *pattern
; pattern
++)
10227 if (*pattern
== '?')
10229 else if (*pattern
== '*')
10240 return (fast_c_string_match_ignore_case (build_string (regex
),
10241 font_name_copy
) >= 0);
10244 /* Two font specs are considered to match if their foundry, family,
10245 weight, slant, and charset match. */
10247 mac_font_match (char *mf
, char *xf
)
10249 char m_foundry
[50], m_family
[50], m_weight
[20], m_slant
[2], m_charset
[20];
10250 char x_foundry
[50], x_family
[50], x_weight
[20], x_slant
[2], x_charset
[20];
10252 if (sscanf (mf
, "-%49[^-]-%49[^-]-%19[^-]-%1[^-]-%*[^-]--%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]-%19s",
10253 m_foundry
, m_family
, m_weight
, m_slant
, m_charset
) != 5)
10254 return mac_font_pattern_match (mf
, xf
);
10256 if (sscanf (xf
, "-%49[^-]-%49[^-]-%19[^-]-%1[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]-%19s",
10257 x_foundry
, x_family
, x_weight
, x_slant
, x_charset
) != 5)
10258 return mac_font_pattern_match (mf
, xf
);
10260 return (wildstrieq (m_foundry
, x_foundry
)
10261 && wildstrieq (m_family
, x_family
)
10262 && wildstrieq (m_weight
, x_weight
)
10263 && wildstrieq (m_slant
, x_slant
)
10264 && wildstrieq (m_charset
, x_charset
))
10265 || mac_font_pattern_match (mf
, xf
);
10270 mac_to_x_fontname (char *name
, int size
, Style style
, short scriptcode
)
10272 char foundry
[32], family
[32], cs
[32];
10273 char xf
[255], *result
, *p
;
10275 if (sscanf (name
, "%31[^-]-%31[^-]-%31s", foundry
, family
, cs
) != 3)
10277 strcpy(foundry
, "Apple");
10278 strcpy(family
, name
);
10280 switch (scriptcode
)
10282 case smTradChinese
:
10283 strcpy(cs
, "big5-0");
10285 case smSimpChinese
:
10286 strcpy(cs
, "gb2312-0");
10289 strcpy(cs
, "jisx0208.1983-sjis");
10292 strcpy(cs
, "ksc5601-0");
10295 strcpy(cs
, "mac-roman");
10300 sprintf(xf
, "-%s-%s-%s-%c-normal--%d-%d-75-75-m-%d-%s",
10301 foundry
, family
, style
& bold
? "bold" : "medium",
10302 style
& italic
? 'i' : 'r', size
, size
* 10, size
* 10, cs
);
10304 result
= (char *) xmalloc (strlen (xf
) + 1);
10305 strcpy (result
, xf
);
10306 for (p
= result
; *p
; p
++)
10312 /* Convert an X font spec to the corresponding mac font name, which
10313 can then be passed to GetFNum after conversion to a Pascal string.
10314 For ordinary Mac fonts, this should just be their names, like
10315 "monaco", "Taipei", etc. Fonts converted from the GNU intlfonts
10316 collection contain their charset designation in their names, like
10317 "ETL-Fixed-iso8859-1", "ETL-Fixed-koi8-r", etc. Both types of font
10318 names are handled accordingly. */
10320 x_font_name_to_mac_font_name (char *xf
, char *mf
)
10322 char foundry
[32], family
[32], weight
[20], slant
[2], cs
[32];
10326 if (sscanf (xf
, "-%31[^-]-%31[^-]-%19[^-]-%1[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]-%31s",
10327 foundry
, family
, weight
, slant
, cs
) != 5 &&
10328 sscanf (xf
, "-%31[^-]-%31[^-]-%19[^-]-%1[^-]-%*[^-]--%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]-%31s",
10329 foundry
, family
, weight
, slant
, cs
) != 5)
10332 if (strcmp (cs
, "big5-0") == 0 || strcmp (cs
, "gb2312-0") == 0
10333 || strcmp (cs
, "jisx0208.1983-sjis") == 0
10334 || strcmp (cs
, "ksc5601-0") == 0 || strcmp (cs
, "mac-roman") == 0)
10335 strcpy(mf
, family
);
10337 sprintf(mf
, "%s-%s-%s", foundry
, family
, cs
);
10341 /* Sets up the table font_name_table to contain the list of all
10342 monospace fonts in the system the first time the table is used so
10343 that the Resource Manager need not be accessed every time this
10344 information is needed. */
10347 init_font_name_table ()
10350 SInt16 fontnum
, old_fontnum
;
10351 int num_mac_fonts
= CountResources('FOND');
10353 Handle font_handle
, font_handle_2
;
10354 short id
, scriptcode
;
10357 struct FontAssoc
*fat
;
10358 struct AsscEntry
*assc_entry
;
10360 GetPort (&port
); /* save the current font number used */
10361 old_fontnum
= port
->txFont
;
10363 for (i
= 1; i
<= num_mac_fonts
; i
++) /* loop to get all available fonts */
10365 font_handle
= GetIndResource ('FOND', i
);
10369 GetResInfo (font_handle
, &id
, &type
, name
);
10370 GetFNum (name
, &fontnum
);
10375 TextFont (fontnum
);
10376 scriptcode
= FontToScript (fontnum
);
10379 HLock (font_handle
);
10381 if (GetResourceSizeOnDisk (font_handle
) >= sizeof (struct FamRec
))
10383 fat
= (struct FontAssoc
*) (*font_handle
10384 + sizeof (struct FamRec
));
10385 assc_entry
= (struct AsscEntry
*) (*font_handle
10386 + sizeof (struct FamRec
)
10387 + sizeof (struct FontAssoc
));
10389 for (j
= 0; j
<= fat
->numAssoc
; j
++, assc_entry
++)
10391 if (font_name_table_size
== 0)
10393 font_name_table_size
= 16;
10394 font_name_table
= (char **)
10395 xmalloc (font_name_table_size
* sizeof (char *));
10397 else if (font_name_count
>= font_name_table_size
)
10399 font_name_table_size
+= 16;
10400 font_name_table
= (char **)
10401 xrealloc (font_name_table
,
10402 font_name_table_size
* sizeof (char *));
10404 font_name_table
[font_name_count
++]
10405 = mac_to_x_fontname (name
,
10406 assc_entry
->fontSize
,
10407 assc_entry
->fontStyle
,
10412 HUnlock (font_handle
);
10413 font_handle_2
= GetNextFOND (font_handle
);
10414 ReleaseResource (font_handle
);
10415 font_handle
= font_handle_2
;
10417 while (ResError () == noErr
&& font_handle
);
10420 TextFont (old_fontnum
);
10424 /* Return a list of at most MAXNAMES font specs matching the one in
10425 PATTERN. Note that each '*' in the PATTERN matches exactly one
10426 field of the font spec, unlike X in which an '*' in a font spec can
10427 match a number of fields. The result is in the Mac implementation
10428 all fonts must be specified by a font spec with all 13 fields
10429 (although many of these can be "*'s"). */
10432 x_list_fonts (struct frame
*f
,
10433 Lisp_Object pattern
,
10438 Lisp_Object newlist
= Qnil
;
10442 if (font_name_table
== NULL
) /* Initialize when first used. */
10443 init_font_name_table ();
10445 ptnstr
= XSTRING (pattern
)->data
;
10447 /* Scan and matching bitmap fonts. */
10448 for (i
= 0; i
< font_name_count
; i
++)
10450 if (mac_font_pattern_match (font_name_table
[i
], ptnstr
))
10452 newlist
= Fcons (build_string (font_name_table
[i
]), newlist
);
10455 if (n_fonts
>= maxnames
)
10460 /* MAC_TODO: add code for matching outline fonts here */
10468 /* Check that FONT is valid on frame F. It is if it can be found in
10472 x_check_font (f
, font
)
10477 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
10479 xassert (font
!= NULL
);
10481 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
10482 if (dpyinfo
->font_table
[i
].name
10483 && font
== dpyinfo
->font_table
[i
].font
)
10486 xassert (i
< dpyinfo
->n_fonts
);
10489 #endif /* GLYPH_DEBUG != 0 */
10492 /* Set *W to the minimum width, *H to the minimum font height of FONT.
10493 Note: There are (broken) X fonts out there with invalid XFontStruct
10494 min_bounds contents. For example, handa@etl.go.jp reports that
10495 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
10496 have font->min_bounds.width == 0. */
10499 x_font_min_bounds (font
, w
, h
)
10500 MacFontStruct
*font
;
10503 *h
= FONT_HEIGHT (font
);
10504 *w
= font
->min_bounds
.width
;
10506 /* Try to handle the case where FONT->min_bounds has invalid
10507 contents. Since the only font known to have invalid min_bounds
10508 is fixed-width, use max_bounds if min_bounds seems to be invalid. */
10510 *w
= font
->max_bounds
.width
;
10514 /* Compute the smallest character width and smallest font height over
10515 all fonts available on frame F. Set the members smallest_char_width
10516 and smallest_font_height in F's x_display_info structure to
10517 the values computed. Value is non-zero if smallest_font_height or
10518 smallest_char_width become smaller than they were before. */
10521 x_compute_min_glyph_bounds (f
)
10525 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
10526 MacFontStruct
*font
;
10527 int old_width
= dpyinfo
->smallest_char_width
;
10528 int old_height
= dpyinfo
->smallest_font_height
;
10530 dpyinfo
->smallest_font_height
= 100000;
10531 dpyinfo
->smallest_char_width
= 100000;
10533 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
10534 if (dpyinfo
->font_table
[i
].name
)
10536 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
10539 font
= (MacFontStruct
*) fontp
->font
;
10540 xassert (font
!= (MacFontStruct
*) ~0);
10541 x_font_min_bounds (font
, &w
, &h
);
10543 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
10544 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
10547 xassert (dpyinfo
->smallest_char_width
> 0
10548 && dpyinfo
->smallest_font_height
> 0);
10550 return (dpyinfo
->n_fonts
== 1
10551 || dpyinfo
->smallest_char_width
< old_width
10552 || dpyinfo
->smallest_font_height
< old_height
);
10556 /* Determine whether given string is a fully-specified XLFD: all 14
10557 fields are present, none is '*'. */
10560 is_fully_specified_xlfd (char *p
)
10568 for (i
= 0; i
< 13; i
++)
10570 q
= strchr (p
+ 1, '-');
10573 if (q
- p
== 2 && *(p
+ 1) == '*')
10578 if (strchr (p
+ 1, '-') != NULL
)
10581 if (*(p
+ 1) == '*' && *(p
+ 2) == '\0')
10588 const int kDefaultFontSize
= 9;
10591 /* MacLoadQueryFont creates and returns an internal representation for
10592 a font in a MacFontStruct struct (similar in function to
10593 XLoadQueryFont in X). There is really no concept corresponding to
10594 "loading" a font on the Mac. But we check its existence and find
10595 the font number and all other information for it and store them in
10596 the returned MacFontStruct. */
10598 static MacFontStruct
*
10599 XLoadQueryFont (Display
*dpy
, char *fontname
)
10601 int i
, size
, is_two_byte_font
, char_width
;
10604 SInt16 old_fontnum
, old_fontsize
;
10605 Style old_fontface
;
10608 Style fontface
= normal
;
10609 MacFontStruct
*font
;
10610 FontInfo the_fontinfo
;
10611 char s_weight
[7], c_slant
;
10613 if (is_fully_specified_xlfd (fontname
))
10617 for (i
= 0; i
< font_name_count
; i
++)
10618 if (mac_font_pattern_match (font_name_table
[i
], fontname
))
10621 if (i
>= font_name_count
)
10624 name
= font_name_table
[i
];
10627 GetPort (&port
); /* save the current font number used */
10628 old_fontnum
= port
->txFont
;
10629 old_fontsize
= port
->txSize
;
10630 old_fontface
= port
->txFace
;
10632 if (sscanf (name
, "-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]--%d-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]-%*s", &size
) != 1)
10633 size
= kDefaultFontSize
;
10635 if (sscanf (name
, "-%*[^-]-%*[^-]-%6[^-]-%*c-%*[^-]--%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]-%*s", s_weight
) == 1)
10636 if (strcmp (s_weight
, "bold") == 0)
10639 if (sscanf (name
, "-%*[^-]-%*[^-]-%*[^-]-%c-%*[^-]--%*[^-]-%*[^-]-%*[^-]-%*[^-]-%*c-%*[^-]-%*s", &c_slant
) == 1)
10640 if (c_slant
== 'i')
10641 fontface
|= italic
;
10643 x_font_name_to_mac_font_name (name
, mfontname
);
10644 c2pstr (mfontname
);
10645 GetFNum (mfontname
, &fontnum
);
10649 font
= (MacFontStruct
*) xmalloc (sizeof (struct MacFontStruct
));
10651 font
->fontname
= (char *) xmalloc (strlen (name
) + 1);
10652 bcopy (name
, font
->fontname
, strlen (name
) + 1);
10654 font
->mac_fontnum
= fontnum
;
10655 font
->mac_fontsize
= size
;
10656 font
->mac_fontface
= fontface
;
10657 font
->mac_scriptcode
= FontToScript (fontnum
);
10659 is_two_byte_font
= font
->mac_scriptcode
== smJapanese
||
10660 font
->mac_scriptcode
== smTradChinese
||
10661 font
->mac_scriptcode
== smSimpChinese
||
10662 font
->mac_scriptcode
== smKorean
;
10664 TextFont (fontnum
);
10666 TextFace (fontface
);
10668 GetFontInfo (&the_fontinfo
);
10670 font
->ascent
= the_fontinfo
.ascent
;
10671 font
->descent
= the_fontinfo
.descent
;
10673 font
->min_byte1
= 0;
10674 if (is_two_byte_font
)
10675 font
->max_byte1
= 1;
10677 font
->max_byte1
= 0;
10678 font
->min_char_or_byte2
= 0x20;
10679 font
->max_char_or_byte2
= 0xff;
10681 if (is_two_byte_font
)
10683 /* Use the width of an "ideographic space" of that font because
10684 the_fontinfo.widMax returns the wrong width for some fonts. */
10685 switch (font
->mac_scriptcode
)
10688 char_width
= StringWidth("\p\x81\x40");
10690 case smTradChinese
:
10691 char_width
= StringWidth("\p\xa1\x40");
10693 case smSimpChinese
:
10694 char_width
= StringWidth("\p\xa1\xa1");
10697 char_width
= StringWidth("\p\xa1\xa1");
10702 /* Do this instead of use the_fontinfo.widMax, which incorrectly
10703 returns 15 for 12-point Monaco! */
10704 char_width
= CharWidth ('m');
10706 font
->max_bounds
.rbearing
= char_width
;
10707 font
->max_bounds
.lbearing
= 0;
10708 font
->max_bounds
.width
= char_width
;
10709 font
->max_bounds
.ascent
= the_fontinfo
.ascent
;
10710 font
->max_bounds
.descent
= the_fontinfo
.descent
;
10712 font
->min_bounds
= font
->max_bounds
;
10714 if (is_two_byte_font
|| CharWidth ('m') == CharWidth ('i'))
10715 font
->per_char
= NULL
;
10718 font
->per_char
= (XCharStruct
*)
10719 xmalloc (sizeof (XCharStruct
) * (0xff - 0x20 + 1));
10723 for (c
= 0x20; c
<= 0xff; c
++)
10725 font
->per_char
[c
- 0x20] = font
->max_bounds
;
10726 font
->per_char
[c
- 0x20].width
= CharWidth (c
);
10731 TextFont (old_fontnum
); /* restore previous font number, size and face */
10732 TextSize (old_fontsize
);
10733 TextFace (old_fontface
);
10739 /* Load font named FONTNAME of the size SIZE for frame F, and return a
10740 pointer to the structure font_info while allocating it dynamically.
10741 If SIZE is 0, load any size of font.
10742 If loading is failed, return NULL. */
10745 x_load_font (f
, fontname
, size
)
10747 register char *fontname
;
10750 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
10751 Lisp_Object font_names
;
10753 /* Get a list of all the fonts that match this name. Once we
10754 have a list of matching fonts, we compare them against the fonts
10755 we already have by comparing names. */
10756 font_names
= x_list_fonts (f
, build_string (fontname
), size
, 1);
10758 if (!NILP (font_names
))
10763 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
10764 for (tail
= font_names
; CONSP (tail
); tail
= XCDR (tail
))
10765 if (dpyinfo
->font_table
[i
].name
10766 && (!strcmp (dpyinfo
->font_table
[i
].name
,
10767 XSTRING (XCAR (tail
))->data
)
10768 || !strcmp (dpyinfo
->font_table
[i
].full_name
,
10769 XSTRING (XCAR (tail
))->data
)))
10770 return (dpyinfo
->font_table
+ i
);
10773 /* Load the font and add it to the table. */
10776 struct MacFontStruct
*font
;
10777 struct font_info
*fontp
;
10778 unsigned long value
;
10781 /* If we have found fonts by x_list_font, load one of them. If
10782 not, we still try to load a font by the name given as FONTNAME
10783 because XListFonts (called in x_list_font) of some X server has
10784 a bug of not finding a font even if the font surely exists and
10785 is loadable by XLoadQueryFont. */
10786 if (size
> 0 && !NILP (font_names
))
10787 fontname
= (char *) XSTRING (XCAR (font_names
))->data
;
10789 font
= (MacFontStruct
*) XLoadQueryFont (FRAME_MAC_DISPLAY (f
), fontname
);
10793 /* Find a free slot in the font table. */
10794 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
10795 if (dpyinfo
->font_table
[i
].name
== NULL
)
10798 /* If no free slot found, maybe enlarge the font table. */
10799 if (i
== dpyinfo
->n_fonts
10800 && dpyinfo
->n_fonts
== dpyinfo
->font_table_size
)
10803 dpyinfo
->font_table_size
= max (16, 2 * dpyinfo
->font_table_size
);
10804 sz
= dpyinfo
->font_table_size
* sizeof *dpyinfo
->font_table
;
10805 dpyinfo
->font_table
10806 = (struct font_info
*) xrealloc (dpyinfo
->font_table
, sz
);
10809 fontp
= dpyinfo
->font_table
+ i
;
10810 if (i
== dpyinfo
->n_fonts
)
10811 ++dpyinfo
->n_fonts
;
10813 /* Now fill in the slots of *FONTP. */
10815 fontp
->font
= font
;
10816 fontp
->font_idx
= i
;
10817 fontp
->name
= (char *) xmalloc (strlen (font
->fontname
) + 1);
10818 bcopy (font
->fontname
, fontp
->name
, strlen (font
->fontname
) + 1);
10820 fontp
->full_name
= fontp
->name
;
10822 fontp
->size
= font
->max_bounds
.width
;
10823 fontp
->height
= FONT_HEIGHT (font
);
10825 /* For some font, ascent and descent in max_bounds field is
10826 larger than the above value. */
10827 int max_height
= font
->max_bounds
.ascent
+ font
->max_bounds
.descent
;
10828 if (max_height
> fontp
->height
)
10829 fontp
->height
= max_height
;
10832 /* The slot `encoding' specifies how to map a character
10833 code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
10834 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
10835 (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
10836 2:0xA020..0xFF7F). For the moment, we don't know which charset
10837 uses this font. So, we set information in fontp->encoding[1]
10838 which is never used by any charset. If mapping can't be
10839 decided, set FONT_ENCODING_NOT_DECIDED. */
10840 if (font
->mac_scriptcode
== smJapanese
)
10841 fontp
->encoding
[1] = 4;
10845 = (font
->max_byte1
== 0
10847 ? (font
->min_char_or_byte2
< 0x80
10848 ? (font
->max_char_or_byte2
< 0x80
10849 ? 0 /* 0x20..0x7F */
10850 : FONT_ENCODING_NOT_DECIDED
) /* 0x20..0xFF */
10851 : 1) /* 0xA0..0xFF */
10853 : (font
->min_byte1
< 0x80
10854 ? (font
->max_byte1
< 0x80
10855 ? (font
->min_char_or_byte2
< 0x80
10856 ? (font
->max_char_or_byte2
< 0x80
10857 ? 0 /* 0x2020..0x7F7F */
10858 : FONT_ENCODING_NOT_DECIDED
) /* 0x2020..0x7FFF */
10859 : 3) /* 0x20A0..0x7FFF */
10860 : FONT_ENCODING_NOT_DECIDED
) /* 0x20??..0xA0?? */
10861 : (font
->min_char_or_byte2
< 0x80
10862 ? (font
->max_char_or_byte2
< 0x80
10863 ? 2 /* 0xA020..0xFF7F */
10864 : FONT_ENCODING_NOT_DECIDED
) /* 0xA020..0xFFFF */
10865 : 1))); /* 0xA0A0..0xFFFF */
10868 #if 0 /* MAC_TODO: fill these out with more reasonably values */
10869 fontp
->baseline_offset
10870 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_BASELINE_OFFSET
, &value
)
10871 ? (long) value
: 0);
10872 fontp
->relative_compose
10873 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
, &value
)
10874 ? (long) value
: 0);
10875 fontp
->default_ascent
10876 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
, &value
)
10877 ? (long) value
: 0);
10879 fontp
->baseline_offset
= 0;
10880 fontp
->relative_compose
= 0;
10881 fontp
->default_ascent
= 0;
10884 /* Set global flag fonts_changed_p to non-zero if the font loaded
10885 has a character with a smaller width than any other character
10886 before, or if the font loaded has a smalle>r height than any
10887 other font loaded before. If this happens, it will make a
10888 glyph matrix reallocation necessary. */
10889 fonts_changed_p
= x_compute_min_glyph_bounds (f
);
10896 /* Return a pointer to struct font_info of a font named FONTNAME for
10897 frame F. If no such font is loaded, return NULL. */
10900 x_query_font (f
, fontname
)
10902 register char *fontname
;
10904 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
10907 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
10908 if (dpyinfo
->font_table
[i
].name
10909 && (!strcmp (dpyinfo
->font_table
[i
].name
, fontname
)
10910 || !strcmp (dpyinfo
->font_table
[i
].full_name
, fontname
)))
10911 return (dpyinfo
->font_table
+ i
);
10916 /* Find a CCL program for a font specified by FONTP, and set the member
10917 `encoder' of the structure. */
10920 x_find_ccl_program (fontp
)
10921 struct font_info
*fontp
;
10923 Lisp_Object list
, elt
;
10925 for (list
= Vfont_ccl_encoder_alist
; CONSP (list
); list
= XCDR (list
))
10929 && STRINGP (XCAR (elt
))
10930 && (fast_c_string_match_ignore_case (XCAR (elt
), fontp
->name
)
10936 struct ccl_program
*ccl
10937 = (struct ccl_program
*) xmalloc (sizeof (struct ccl_program
));
10939 if (setup_ccl_program (ccl
, XCDR (elt
)) < 0)
10942 fontp
->font_encoder
= ccl
;
10948 /***********************************************************************
10950 ***********************************************************************/
10952 #ifdef USE_X_TOOLKIT
10953 static XrmOptionDescRec emacs_options
[] = {
10954 {"-geometry", ".geometry", XrmoptionSepArg
, NULL
},
10955 {"-iconic", ".iconic", XrmoptionNoArg
, (XtPointer
) "yes"},
10957 {"-internal-border-width", "*EmacsScreen.internalBorderWidth",
10958 XrmoptionSepArg
, NULL
},
10959 {"-ib", "*EmacsScreen.internalBorderWidth", XrmoptionSepArg
, NULL
},
10961 {"-T", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10962 {"-wn", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10963 {"-title", "*EmacsShell.title", XrmoptionSepArg
, (XtPointer
) NULL
},
10964 {"-iconname", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
10965 {"-in", "*EmacsShell.iconName", XrmoptionSepArg
, (XtPointer
) NULL
},
10966 {"-mc", "*pointerColor", XrmoptionSepArg
, (XtPointer
) NULL
},
10967 {"-cr", "*cursorColor", XrmoptionSepArg
, (XtPointer
) NULL
}
10969 #endif /* USE_X_TOOLKIT */
10971 static int x_initialized
;
10973 #ifdef MULTI_KBOARD
10974 /* Test whether two display-name strings agree up to the dot that separates
10975 the screen number from the server number. */
10977 same_x_server (name1
, name2
)
10978 char *name1
, *name2
;
10980 int seen_colon
= 0;
10981 unsigned char *system_name
= XSTRING (Vsystem_name
)->data
;
10982 int system_name_length
= strlen (system_name
);
10983 int length_until_period
= 0;
10985 while (system_name
[length_until_period
] != 0
10986 && system_name
[length_until_period
] != '.')
10987 length_until_period
++;
10989 /* Treat `unix' like an empty host name. */
10990 if (! strncmp (name1
, "unix:", 5))
10992 if (! strncmp (name2
, "unix:", 5))
10994 /* Treat this host's name like an empty host name. */
10995 if (! strncmp (name1
, system_name
, system_name_length
)
10996 && name1
[system_name_length
] == ':')
10997 name1
+= system_name_length
;
10998 if (! strncmp (name2
, system_name
, system_name_length
)
10999 && name2
[system_name_length
] == ':')
11000 name2
+= system_name_length
;
11001 /* Treat this host's domainless name like an empty host name. */
11002 if (! strncmp (name1
, system_name
, length_until_period
)
11003 && name1
[length_until_period
] == ':')
11004 name1
+= length_until_period
;
11005 if (! strncmp (name2
, system_name
, length_until_period
)
11006 && name2
[length_until_period
] == ':')
11007 name2
+= length_until_period
;
11009 for (; *name1
!= '\0' && *name1
== *name2
; name1
++, name2
++)
11013 if (seen_colon
&& *name1
== '.')
11017 && (*name1
== '.' || *name1
== '\0')
11018 && (*name2
== '.' || *name2
== '\0'));
11022 struct mac_display_info
*
11023 x_term_init (display_name
, xrm_option
, resource_name
)
11024 Lisp_Object display_name
;
11026 char *resource_name
;
11028 if (!x_initialized
)
11034 return &one_mac_display_info
;
11037 /* Set up use of X before we make the first connection. */
11039 static struct redisplay_interface x_redisplay_interface
=
11044 x_clear_end_of_line
,
11046 x_after_update_window_line
,
11047 x_update_window_begin
,
11048 x_update_window_end
,
11051 x_clear_mouse_face
,
11052 x_get_glyph_overhangs
,
11053 x_fix_overlapping_area
11057 /* The Mac Event loop code */
11059 #include <Events.h>
11060 #include <Quickdraw.h>
11061 #include <Balloons.h>
11062 #include <Devices.h>
11064 #include <Gestalt.h>
11066 #include <Processes.h>
11068 #include <ToolUtils.h>
11069 #include <TextUtils.h>
11070 #include <Dialogs.h>
11071 #include <Script.h>
11074 #include <TextEncodingConverter.h>
11075 #include <Resources.h>
11081 #define M_APPLE 128
11084 #define WINDOW_RESOURCE 128
11085 #define TERM_WINDOW_RESOURCE 129
11087 #define DEFAULT_NUM_COLS 80
11089 #define MIN_DOC_SIZE 64
11090 #define MAX_DOC_SIZE 32767
11092 /* sleep time for WaitNextEvent */
11093 #define WNE_SLEEP_AT_SUSPEND 10
11094 #define WNE_SLEEP_AT_RESUME 1
11096 /* true when cannot handle any Mac OS events */
11097 static int handling_window_update
= 0;
11099 /* the flag appl_is_suspended is used both for determining the sleep
11100 time to be passed to WaitNextEvent and whether the cursor should be
11101 drawn when updating the display. The cursor is turned off when
11102 Emacs is suspended. Redrawing it is unnecessary and what needs to
11103 be done depends on whether the cursor lies inside or outside the
11104 redraw region. So we might as well skip drawing it when Emacs is
11106 static Boolean app_is_suspended
= false;
11107 static long app_sleep_time
= WNE_SLEEP_AT_RESUME
;
11109 #define EXTRA_STACK_ALLOC (256 * 1024)
11111 #define ARGV_STRING_LIST_ID 129
11112 #define ABOUT_ALERT_ID 128
11114 Boolean terminate_flag
= false;
11116 /* true if using command key as meta key */
11117 Lisp_Object Vmac_command_key_is_meta
;
11119 /* convert input from Mac keyboard (assumed to be in Mac Roman coding)
11120 to this text encoding */
11121 int mac_keyboard_text_encoding
;
11122 int current_mac_keyboard_text_encoding
= kTextEncodingMacRoman
;
11124 /* Set in term/mac-win.el to indicate that event loop can now generate
11125 drag and drop events. */
11126 Lisp_Object Vmac_ready_for_drag_n_drop
;
11128 Lisp_Object drag_and_drop_file_list
;
11130 Point saved_menu_event_location
;
11133 static void init_required_apple_events(void);
11134 static pascal OSErr
do_ae_open_application(const AppleEvent
*, AppleEvent
*, long);
11135 static pascal OSErr
do_ae_print_documents(const AppleEvent
*, AppleEvent
*, long);
11136 static pascal OSErr
do_ae_open_documents(AppleEvent
*, AppleEvent
*, long);
11137 static pascal OSErr
do_ae_quit_application(AppleEvent
*, AppleEvent
*, long);
11139 extern void init_emacs_passwd_dir ();
11140 extern int emacs_main (int, char **, char **);
11141 extern void check_alarm ();
11143 extern void initialize_applescript();
11144 extern void terminate_applescript();
11148 do_get_menus (void)
11150 Handle menubar_handle
;
11151 MenuHandle menu_handle
;
11153 menubar_handle
= GetNewMBar (128);
11154 if(menubar_handle
== NULL
)
11156 SetMenuBar (menubar_handle
);
11159 menu_handle
= GetMenuHandle (M_APPLE
);
11160 if(menu_handle
!= NULL
)
11161 AppendResMenu (menu_handle
,'DRVR');
11168 do_init_managers (void)
11170 InitGraf (&qd
.thePort
);
11172 FlushEvents (everyEvent
, 0);
11176 InitDialogs (NULL
);
11179 /* set up some extra stack space for use by emacs */
11180 SetApplLimit ((Ptr
) ((long) GetApplLimit () - EXTRA_STACK_ALLOC
));
11182 /* MaxApplZone must be called for AppleScript to execute more
11183 complicated scripts */
11190 do_window_update (WindowPtr win
)
11192 struct mac_output
*mwp
= (mac_output
*) GetWRefCon (win
);
11193 struct frame
*f
= mwp
->mFP
;
11197 if (f
->async_visible
== 0)
11199 f
->async_visible
= 1;
11200 f
->async_iconified
= 0;
11201 SET_FRAME_GARBAGED (f
);
11203 /* An update event is equivalent to MapNotify on X, so report
11204 visibility changes properly. */
11205 if (! NILP(Vframe_list
) && ! NILP (XCDR (Vframe_list
)))
11206 /* Force a redisplay sooner or later to update the
11207 frame titles in case this is the second frame. */
11208 record_asynch_buffer_change ();
11213 handling_window_update
= 1;
11215 expose_frame (f
, 0, 0, 0, 0);
11217 handling_window_update
= 0;
11224 do_window_activate (WindowPtr win
)
11226 mac_output
*mwp
= (mac_output
*) GetWRefCon (win
);
11227 struct frame
*f
= mwp
->mFP
;
11231 x_new_focus_frame (FRAME_MAC_DISPLAY_INFO (f
), f
);
11232 activate_scroll_bars (f
);
11237 do_window_deactivate (WindowPtr win
)
11239 mac_output
*mwp
= (mac_output
*) GetWRefCon (win
);
11240 struct frame
*f
= mwp
->mFP
;
11242 if (f
== FRAME_MAC_DISPLAY_INFO (f
)->x_focus_frame
)
11244 x_new_focus_frame (FRAME_MAC_DISPLAY_INFO (f
), 0);
11245 deactivate_scroll_bars (f
);
11252 mac_output
*mwp
= (mac_output
*) GetWRefCon (FrontWindow ());
11253 struct frame
*f
= mwp
->mFP
;
11257 x_new_focus_frame (FRAME_MAC_DISPLAY_INFO (f
), f
);
11258 activate_scroll_bars (f
);
11261 app_is_suspended
= false;
11262 app_sleep_time
= WNE_SLEEP_AT_RESUME
;
11268 mac_output
*mwp
= (mac_output
*) GetWRefCon (FrontWindow ());
11269 struct frame
*f
= mwp
->mFP
;
11271 if (f
== FRAME_MAC_DISPLAY_INFO (f
)->x_focus_frame
)
11273 x_new_focus_frame (FRAME_MAC_DISPLAY_INFO (f
), 0);
11274 deactivate_scroll_bars (f
);
11277 app_is_suspended
= true;
11278 app_sleep_time
= WNE_SLEEP_AT_SUSPEND
;
11283 do_mouse_moved (Point mouse_pos
)
11285 WindowPtr wp
= FrontWindow ();
11286 struct frame
*f
= ((mac_output
*) GetWRefCon (wp
))->mFP
;
11289 GlobalToLocal (&mouse_pos
);
11291 note_mouse_movement (f
, &mouse_pos
);
11296 do_os_event (EventRecord
*erp
)
11298 switch((erp
->message
>> 24) & 0x000000FF)
11300 case suspendResumeMessage
:
11301 if((erp
->message
& resumeFlag
) == 1)
11307 case mouseMovedMessage
:
11308 do_mouse_moved (erp
->where
);
11314 do_events (EventRecord
*erp
)
11319 do_window_update ((WindowPtr
) erp
->message
);
11327 if ((erp
->modifiers
& activeFlag
) != 0)
11328 do_window_activate ((WindowPtr
) erp
->message
);
11330 do_window_deactivate ((WindowPtr
) erp
->message
);
11336 do_apple_menu (SInt16 menu_item
)
11339 SInt16 da_driver_refnum
;
11341 if (menu_item
== I_ABOUT
)
11342 NoteAlert (ABOUT_ALERT_ID
, NULL
);
11345 GetMenuItemText (GetMenuHandle (M_APPLE
), menu_item
, item_name
);
11346 da_driver_refnum
= OpenDeskAcc (item_name
);
11351 do_menu_choice (SInt32 menu_choice
)
11353 SInt16 menu_id
, menu_item
;
11355 menu_id
= HiWord (menu_choice
);
11356 menu_item
= LoWord (menu_choice
);
11364 do_apple_menu (menu_item
);
11369 WindowPtr wp
= FrontWindow ();
11370 struct frame
*f
= ((mac_output
*) GetWRefCon (wp
))->mFP
;
11371 MenuHandle menu
= GetMenuHandle (menu_id
);
11376 GetMenuItemRefCon (menu
, menu_item
, &refcon
);
11377 menubar_selection_callback (f
, refcon
);
11386 /* Handle drags in size box. Based on code contributed by Ben
11387 Mesander and IM - Window Manager A. */
11390 do_grow_window (WindowPtr w
, EventRecord
*e
)
11395 mac_output
*mwp
= (mac_output
*) GetWRefCon (w
);
11396 struct frame
*f
= mwp
->mFP
;
11398 SetRect(&limit_rect
, MIN_DOC_SIZE
, MIN_DOC_SIZE
, MAX_DOC_SIZE
, MAX_DOC_SIZE
);
11400 grow_size
= GrowWindow (w
, e
->where
, &limit_rect
);
11402 /* see if it really changed size */
11403 if (grow_size
!= 0)
11405 rows
= PIXEL_TO_CHAR_HEIGHT (f
, HiWord (grow_size
));
11406 columns
= PIXEL_TO_CHAR_WIDTH (f
, LoWord (grow_size
));
11408 x_set_window_size (f
, 0, columns
, rows
);
11413 /* Handle clicks in zoom box. Calculation of "standard state" based
11414 on code in IM - Window Manager A and code contributed by Ben
11415 Mesander. The standard state of an Emacs window is 80-characters
11416 wide (DEFAULT_NUM_COLS) and as tall as will fit on the screen. */
11419 do_zoom_window (WindowPtr w
, int zoom_in_or_out
)
11422 Rect zoom_rect
, port_rect
;
11424 int w_title_height
, columns
, rows
, width
, height
, dummy
, x
, y
;
11425 mac_output
*mwp
= (mac_output
*) GetWRefCon (w
);
11426 struct frame
*f
= mwp
->mFP
;
11428 GetPort (&save_port
);
11430 EraseRect (&(w
->portRect
)); /* erase to avoid flicker */
11431 if (zoom_in_or_out
== inZoomOut
)
11433 SetPt(&top_left
, w
->portRect
.left
, w
->portRect
.top
);
11434 LocalToGlobal (&top_left
);
11436 /* calculate height of window's title bar */
11437 w_title_height
= top_left
.v
- 1
11438 - (**((WindowPeek
) w
)->strucRgn
).rgnBBox
.top
+ GetMBarHeight();
11440 /* get maximum height of window into zoom_rect.bottom - zoom_rect.top */
11441 zoom_rect
= qd
.screenBits
.bounds
;
11442 zoom_rect
.top
+= w_title_height
;
11443 InsetRect (&zoom_rect
, 8, 4); /* not too tight */
11445 zoom_rect
.right
= zoom_rect
.left
11446 + CHAR_TO_PIXEL_WIDTH (f
, DEFAULT_NUM_COLS
);
11448 (**((WStateDataHandle
) ((WindowPeek
) w
)->dataHandle
)).stdState
= zoom_rect
;
11451 ZoomWindow (w
, zoom_in_or_out
, w
== FrontWindow());
11453 /* retrieve window size and update application values */
11454 port_rect
= w
->portRect
;
11455 rows
= PIXEL_TO_CHAR_HEIGHT (f
, port_rect
.bottom
- port_rect
.top
);
11456 columns
= PIXEL_TO_CHAR_WIDTH (f
, port_rect
.right
- port_rect
.left
);
11457 x_set_window_size (mwp
->mFP
, 0, columns
, rows
);
11459 SetPort (save_port
);
11463 /* Intialize AppleEvent dispatcher table for the required events. */
11465 init_required_apple_events ()
11470 /* Make sure we have apple events before starting. */
11471 err
= Gestalt (gestaltAppleEventsAttr
, &result
);
11475 if (!(result
& (1 << gestaltAppleEventsPresent
)))
11478 err
= AEInstallEventHandler(kCoreEventClass
, kAEOpenApplication
,
11479 NewAEEventHandlerProc ((AEEventHandlerProcPtr
) do_ae_open_application
),
11484 err
= AEInstallEventHandler(kCoreEventClass
, kAEOpenDocuments
,
11485 NewAEEventHandlerProc ((AEEventHandlerProcPtr
) do_ae_open_documents
),
11490 err
= AEInstallEventHandler(kCoreEventClass
, kAEPrintDocuments
,
11491 NewAEEventHandlerProc ((AEEventHandlerProcPtr
) do_ae_print_documents
),
11496 err
= AEInstallEventHandler(kCoreEventClass
, kAEQuitApplication
,
11497 NewAEEventHandlerProc ((AEEventHandlerProcPtr
) do_ae_quit_application
),
11504 /* Open Application Apple Event */
11505 static pascal OSErr
11506 do_ae_open_application(const AppleEvent
*pae
, AppleEvent
*preply
, long prefcon
)
11512 /* Defined in mac.c. */
11514 path_from_vol_dir_name (char *, int, short, long, char *);
11517 /* Called when we receive an AppleEvent with an ID of
11518 "kAEOpenDocuments". This routine gets the direct parameter,
11519 extracts the FSSpecs in it, and puts their names on a list. */
11520 static pascal OSErr
11521 do_ae_open_documents(AppleEvent
*message
, AppleEvent
*reply
, long refcon
)
11526 DescType actual_type
;
11529 err
= AEGetParamDesc (message
, keyDirectObject
, typeAEList
, &the_desc
);
11531 goto descriptor_error_exit
;
11533 /* Check to see that we got all of the required parameters from the
11534 event descriptor. For an 'odoc' event this should just be the
11536 err
= AEGetAttributePtr(message
, keyMissedKeywordAttr
, typeWildCard
,
11537 &actual_type
, (Ptr
) &keyword
,
11538 sizeof (keyword
), &actual_size
);
11539 /* No error means that we found some unused parameters.
11540 errAEDescNotFound means that there are no more parameters. If we
11541 get an error code other than that, flag it. */
11542 if ((err
== noErr
) || (err
!= errAEDescNotFound
))
11544 err
= errAEEventNotHandled
;
11549 /* Got all the parameters we need. Now, go through the direct
11550 object list and parse it up. */
11552 long num_files_to_open
;
11554 err
= AECountItems (&the_desc
, &num_files_to_open
);
11559 /* AE file list is one based so just use that for indexing here. */
11560 for (i
= 1; (err
== noErr
) && (i
<= num_files_to_open
); i
++) {
11562 Str255 path_name
, unix_path_name
;
11564 err
= AEGetNthPtr(&the_desc
, i
, typeFSS
, &keyword
, &actual_type
,
11565 (Ptr
) &fs
, sizeof (fs
), &actual_size
);
11566 if (err
!= noErr
) break;
11568 if (path_from_vol_dir_name (path_name
, 255, fs
.vRefNum
, fs
.parID
,
11570 mac_to_unix_pathname (path_name
, unix_path_name
, 255))
11571 drag_and_drop_file_list
= Fcons (build_string (unix_path_name
),
11572 drag_and_drop_file_list
);
11578 /* Nuke the coerced file list in any case */
11579 err2
= AEDisposeDesc(&the_desc
);
11581 descriptor_error_exit
:
11582 /* InvalRect(&(gFrontMacWindowP->mWP->portRect)); */
11587 /* Print Document Apple Event */
11588 static pascal OSErr
11589 do_ae_print_documents (const AppleEvent
*pAE
, AppleEvent
*reply
, long refcon
)
11591 return errAEEventNotHandled
;
11595 static pascal OSErr
11596 do_ae_quit_application (AppleEvent
* message
, AppleEvent
*reply
, long refcon
)
11598 /* FixMe: Do we need an unwind-protect or something here? And what
11599 do we do about unsaved files. Currently just forces quit rather
11600 than doing recursive callback to get user input. */
11602 terminate_flag
= true;
11604 /* Fkill_emacs doesn't return. We have to return. (TI) */
11611 profiler_exit_proc ()
11613 ProfilerDump ("\pEmacs.prof");
11618 /* These few functions implement Emacs as a normal Mac application
11619 (almost): set up the the heap and the Toolbox, handle necessary
11620 system events plus a few simple menu events. They also set up
11621 Emacs's access to functions defined in the rest of this file.
11622 Emacs uses function hooks to perform all its terminal I/O. A
11623 complete list of these functions appear in termhooks.h. For what
11624 they do, read the comments there and see also w32term.c and
11625 xterm.c. What's noticeably missing here is the event loop, which
11626 is normally present in most Mac application. After performing the
11627 necessary Mac initializations, main passes off control to
11628 emacs_main (corresponding to main in emacs.c). Emacs_main calls
11629 mac_read_socket (defined further below) to read input. This is
11630 where WaitNextEvent is called to process Mac events. This is also
11631 where check_alarm in sysdep.c is called to simulate alarm signals.
11632 This makes the cursor jump back to its correct position after
11633 briefly jumping to that of the matching parenthesis, print useful
11634 hints and prompts in the minibuffer after the user stops typing for
11641 #if __profile__ /* is the profiler on? */
11642 if (ProfilerInit(collectDetailed
, bestTimeBase
, 5000, 200))
11647 /* set creator and type for files created by MSL */
11648 _fcreator
= 'EMAx';
11652 do_init_managers ();
11656 init_emacs_passwd_dir ();
11660 initialize_applescript ();
11662 init_required_apple_events ();
11668 /* set up argv array from STR# resource */
11669 get_string_list (&argv
, ARGV_STRING_LIST_ID
);
11673 /* free up AppleScript resources on exit */
11674 atexit (terminate_applescript
);
11676 #if __profile__ /* is the profiler on? */
11677 atexit (profiler_exit_proc
);
11680 /* 3rd param "envp" never used in emacs_main */
11681 (void) emacs_main (argc
, argv
, 0);
11684 /* Never reached - real exit in Fkill_emacs */
11689 /* Table for translating Mac keycode to X keysym values. Contributed
11690 by Sudhir Shenoy. */
11691 static unsigned char keycode_to_xkeysym_table
[] = {
11693 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
11694 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
11695 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
11696 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
11698 0, '\xae' /* kp. */, 0, '\xaa' /* kp* */,
11699 0, '\xab' /* kp+ */, 0, '\x7f' /* kp_clr */,
11700 0, 0, 0, '\xaf' /* kp/ */,
11701 '\x8d' /* kp_ent */, 0, '\xad' /* kp- */, 0,
11703 0, '\xbd' /* kp= */, '\xb0' /* kp0 */, '\xb1' /* kp1 */,
11704 '\xb2' /* kp2 */, '\xb3' /* kp3 */, '\xb4' /* kp4 */, '\xb5' /* kp5 */,
11705 '\xb6' /* kp6 */, '\xb7' /* kp7 */, 0, '\xb8' /* kp8 */,
11706 '\xb9' /* kp9 */, 0, 0, 0,
11708 '\xc2' /* F5 */, '\xc3' /* F6 */, '\xc4' /* F7 */, '\xc0' /* F3 */,
11709 '\xc5' /* F8 */, '\xc6' /* F9 */, 0, '\xc8' /* F11 */,
11710 0, '\xca' /* F13 */, 0, '\xcb' /* F14 */,
11711 0, '\xc7' /* F10 */, 0, '\xc9' /* F12 */,
11713 0, '\xcc' /* F15 */, '\x9e' /* ins */, '\x95' /* home */,
11714 '\x9a' /* pgup */, '\x9f' /* del */, '\xc1' /* F4 */, '\x9c' /* end */,
11715 '\xbf' /* F2 */, '\x9b' /* pgdown */, '\xbe' /* F1 */, '\x51' /* left */,
11716 '\x53' /* right */, '\x54' /* down */, '\x52' /* up */, 0
11720 keycode_to_xkeysym (int keyCode
, int *xKeySym
)
11722 *xKeySym
= keycode_to_xkeysym_table
[keyCode
& 0x7f];
11723 return *xKeySym
!= 0;
11726 /* Emacs calls this whenever it wants to read an input event from the
11729 XTread_socket (int sd
, struct input_event
*bufp
, int numchars
, int expected
)
11734 EventMask event_mask
;
11736 if (interrupt_input_blocked
)
11738 interrupt_input_pending
= 1;
11742 interrupt_input_pending
= 0;
11745 /* So people can tell when we have read the available input. */
11746 input_signal_count
++;
11751 /* Don't poll for events to process (specifically updateEvt) if
11752 window update currently already in progress. A call to redisplay
11753 (in do_window_update) can be preempted by another call to
11754 redisplay, causing blank regions to be left on the screen and the
11755 cursor to be left at strange places. */
11756 if (handling_window_update
)
11762 if (terminate_flag
)
11763 Fkill_emacs (make_number (1));
11765 /* It is necessary to set this (additional) argument slot of an
11766 event to nil because keyboard.c protects incompletely processed
11767 event from being garbage collected by placing them in the
11768 kbd_buffer_gcpro vector. */
11771 event_mask
= everyEvent
;
11772 if (NILP (Vmac_ready_for_drag_n_drop
))
11773 event_mask
-= highLevelEventMask
;
11775 if (WaitNextEvent (event_mask
, &er
, (expected
? app_sleep_time
: 0L), NULL
))
11781 WindowPtr window_ptr
= FrontWindow ();
11784 if (mouse_tracking_in_progress
== mouse_tracking_scroll_bar
11785 && er
.what
== mouseUp
)
11787 struct mac_output
*mwp
= (mac_output
*) GetWRefCon (window_ptr
);
11788 Point mouse_loc
= er
.where
;
11790 /* Convert to local coordinates of new window. */
11791 SetPort (window_ptr
);
11792 GlobalToLocal (&mouse_loc
);
11794 bufp
->code
= 0; /* only one mouse button */
11795 bufp
->kind
= scroll_bar_click
;
11796 bufp
->frame_or_window
= tracked_scroll_bar
->window
;
11797 bufp
->part
= scroll_bar_handle
;
11798 bufp
->modifiers
= up_modifier
;
11799 bufp
->timestamp
= er
.when
* (1000 / 60);
11800 /* ticks to milliseconds */
11802 XSETINT (bufp
->x
, tracked_scroll_bar
->left
+ 2);
11803 XSETINT (bufp
->y
, mouse_loc
.v
- 24);
11804 tracked_scroll_bar
->dragging
= Qnil
;
11805 mouse_tracking_in_progress
= mouse_tracking_none
;
11806 tracked_scroll_bar
= NULL
;
11811 part_code
= FindWindow (er
.where
, &window_ptr
);
11817 struct frame
*f
= ((mac_output
*)
11818 GetWRefCon (FrontWindow ()))->mFP
;
11819 saved_menu_event_location
= er
.where
;
11820 bufp
->kind
= menu_bar_activate_event
;
11821 XSETFRAME (bufp
->frame_or_window
, f
);
11827 if (window_ptr
!= FrontWindow ())
11828 SelectWindow (window_ptr
);
11831 int control_part_code
;
11833 struct mac_output
*mwp
= (mac_output
*)
11834 GetWRefCon (window_ptr
);
11835 Point mouse_loc
= er
.where
;
11837 /* convert to local coordinates of new window */
11838 SetPort (window_ptr
);
11839 GlobalToLocal (&mouse_loc
);
11840 control_part_code
= FindControl (mouse_loc
, window_ptr
, &ch
);
11842 bufp
->code
= 0; /* only one mouse button */
11843 XSETINT (bufp
->x
, mouse_loc
.h
);
11844 XSETINT (bufp
->y
, mouse_loc
.v
);
11845 bufp
->timestamp
= er
.when
* (1000 / 60);
11846 /* ticks to milliseconds */
11848 if (control_part_code
!= 0)
11850 struct scroll_bar
*bar
= (struct scroll_bar
*)
11851 GetControlReference (ch
);
11852 x_scroll_bar_handle_click (bar
, control_part_code
, &er
,
11854 if (er
.what
== mouseDown
11855 && control_part_code
== kControlIndicatorPart
)
11857 mouse_tracking_in_progress
= mouse_tracking_scroll_bar
;
11858 tracked_scroll_bar
= bar
;
11862 mouse_tracking_in_progress
= mouse_tracking_none
;
11863 tracked_scroll_bar
= NULL
;
11868 bufp
->kind
= mouse_click
;
11869 XSETFRAME (bufp
->frame_or_window
, mwp
->mFP
);
11870 if (er
.what
== mouseDown
)
11871 mouse_tracking_in_progress
= mouse_tracking_mouse_movement
;
11873 mouse_tracking_in_progress
= mouse_tracking_none
;
11879 bufp
->modifiers
= down_modifier
;
11882 bufp
->modifiers
= up_modifier
;
11891 DragWindow (window_ptr
, er
.where
, &qd
.screenBits
.bounds
);
11895 if (TrackGoAway (window_ptr
, er
.where
))
11897 bufp
->kind
= delete_window_event
;
11898 XSETFRAME (bufp
->frame_or_window
,
11899 ((mac_output
*) GetWRefCon (window_ptr
))->mFP
);
11904 /* window resize handling added --ben */
11906 do_grow_window(window_ptr
, &er
);
11909 /* window zoom handling added --ben */
11912 if (TrackBox (window_ptr
, er
.where
, part_code
))
11913 do_zoom_window (window_ptr
, part_code
);
11931 int keycode
= (er
.message
& keyCodeMask
) >> 8;
11936 if (keycode
== 0x33) /* delete key (charCode translated to 0x8) */
11939 bufp
->kind
= ascii_keystroke
;
11941 else if (keycode_to_xkeysym (keycode
, &xkeysym
))
11943 bufp
->code
= 0xff00 | xkeysym
;
11944 bufp
->kind
= non_ascii_keystroke
;
11949 & (NILP (Vmac_command_key_is_meta
) ? optionKey
: cmdKey
))
11951 /* This code comes from Keyboard Resource, Appendix
11952 C of IM - Text. This is necessary since shift is
11953 ignored in KCHR table translation when option or
11954 command is pressed. */
11955 int new_modifiers
= er
.modifiers
& 0xf600;
11956 /* mask off option and command */
11957 int new_keycode
= keycode
| new_modifiers
;
11958 Ptr kchr_ptr
= (Ptr
) GetScriptManagerVariable (smKCHRCache
);
11959 unsigned long some_state
= 0;
11960 bufp
->code
= KeyTranslate (kchr_ptr
, new_keycode
,
11961 &some_state
) & 0xff;
11964 bufp
->code
= er
.message
& charCodeMask
;
11965 bufp
->kind
= ascii_keystroke
;
11969 /* If variable mac-convert-keyboard-input-to-latin-1 is non-nil,
11970 convert non-ASCII characters typed at the Mac keyboard
11971 (presumed to be in the Mac Roman encoding) to iso-latin-1
11972 encoding before they are passed to Emacs. This enables the
11973 Mac keyboard to be used to enter non-ASCII iso-latin-1
11974 characters directly. */
11975 if (mac_keyboard_text_encoding
!= kTextEncodingMacRoman
11976 && bufp
->kind
== ascii_keystroke
&& bufp
->code
>= 128)
11978 static TECObjectRef converter
= NULL
;
11979 OSStatus the_err
= noErr
;
11980 OSStatus convert_status
= noErr
;
11982 if (converter
== NULL
)
11984 the_err
= TECCreateConverter (&converter
,
11985 kTextEncodingMacRoman
,
11986 mac_keyboard_text_encoding
);
11987 current_mac_keyboard_text_encoding
= mac_keyboard_text_encoding
;
11989 else if (mac_keyboard_text_encoding
!= current_mac_keyboard_text_encoding
)
11991 /* Free the converter for the current encoding before
11992 creating a new one. */
11993 TECDisposeConverter (converter
);
11994 the_err
= TECCreateConverter (&converter
,
11995 kTextEncodingMacRoman
,
11996 mac_keyboard_text_encoding
);
11997 current_mac_keyboard_text_encoding
= mac_keyboard_text_encoding
;
12000 if (the_err
== noErr
)
12002 unsigned char ch
= bufp
->code
;
12003 ByteCount actual_input_length
, actual_output_length
;
12004 unsigned char outch
;
12006 convert_status
= TECConvertText (converter
, &ch
, 1,
12007 &actual_input_length
,
12009 &actual_output_length
);
12010 if (convert_status
== noErr
12011 && actual_input_length
== 1
12012 && actual_output_length
== 1)
12013 bufp
->code
= outch
;
12018 if (er
.modifiers
& shiftKey
)
12019 the_modifiers
|= shift_modifier
;
12020 if (er
.modifiers
& controlKey
)
12021 the_modifiers
|= ctrl_modifier
;
12022 /* use option or command key as meta depending on value of
12023 mac-command-key-is-meta */
12025 & (NILP (Vmac_command_key_is_meta
) ? optionKey
: cmdKey
))
12026 the_modifiers
|= meta_modifier
;
12027 bufp
->modifiers
= the_modifiers
;
12030 mac_output
*mwp
= (mac_output
*) GetWRefCon (FrontWindow ());
12031 XSETFRAME (bufp
->frame_or_window
, mwp
->mFP
);
12034 bufp
->timestamp
= er
.when
* (1000 / 60); /* ticks to milliseconds */
12039 case kHighLevelEvent
:
12040 drag_and_drop_file_list
= Qnil
;
12042 AEProcessAppleEvent(&er
);
12044 /* Build a drag_n_drop type event as is done in
12045 constuct_drag_n_drop in w32term.c. */
12046 if (!NILP (drag_and_drop_file_list
))
12052 wp
= FrontWindow ();
12056 f
= ((mac_output
*) GetWRefCon (wp
))->mFP
;
12058 bufp
->kind
= drag_n_drop
;
12060 bufp
->timestamp
= er
.when
* (1000 / 60);
12061 /* ticks to milliseconds */
12062 bufp
->modifiers
= 0;
12064 XSETINT (bufp
->x
, 0);
12065 XSETINT (bufp
->y
, 0);
12067 XSETFRAME (frame
, f
);
12068 bufp
->frame_or_window
= Fcons (frame
, drag_and_drop_file_list
);
12070 /* Regardless of whether Emacs was suspended or in the
12071 foreground, ask it to redraw its entire screen.
12072 Otherwise parts of the screen can be left in an
12073 inconsistent state. */
12075 InvalRect (&(wp
->portRect
));
12084 /* If the focus was just given to an autoraising frame,
12086 /* ??? This ought to be able to handle more than one such frame. */
12087 if (pending_autoraise_frame
)
12089 x_raise_frame (pending_autoraise_frame
);
12090 pending_autoraise_frame
= 0;
12093 check_alarm (); /* simulate the handling of a SIGALRM */
12096 static Point old_mouse_pos
= { -1, -1 };
12098 if (app_is_suspended
)
12100 old_mouse_pos
.h
= -1;
12101 old_mouse_pos
.v
= -1;
12106 WindowPtr wp
= FrontWindow ();
12107 struct frame
*f
= ((mac_output
*) GetWRefCon (wp
))->mFP
;
12109 struct scroll_bar
*sb
;
12112 GetMouse (&mouse_pos
);
12114 if (!EqualPt (mouse_pos
, old_mouse_pos
))
12116 if (mouse_tracking_in_progress
== mouse_tracking_scroll_bar
12117 && tracked_scroll_bar
)
12118 x_scroll_bar_note_movement (tracked_scroll_bar
,
12120 - XINT (tracked_scroll_bar
->top
),
12121 TickCount() * (1000 / 60));
12123 note_mouse_movement (f
, &mouse_pos
);
12125 old_mouse_pos
= mouse_pos
;
12136 /* Need to override CodeWarrior's input function so no conversion is
12137 done on newlines Otherwise compiled functions in .elc files will be
12138 read incorrectly. Defined in ...:MSL C:MSL
12139 Common:Source:buffer_io.c. */
12142 __convert_to_newlines (unsigned char * p
, size_t * n
)
12144 #pragma unused(p,n)
12148 __convert_from_newlines (unsigned char * p
, size_t * n
)
12150 #pragma unused(p,n)
12155 /* Initialize the struct pointed to by MW to represent a new COLS x
12156 ROWS Macintosh window, using font with name FONTNAME and size
12159 NewMacWindow (FRAME_PTR fp
)
12162 static int making_terminal_window
= 1;
12164 mwp
= fp
->output_data
.mac
;
12166 if (making_terminal_window
)
12168 if (!(mwp
->mWP
= GetNewCWindow (TERM_WINDOW_RESOURCE
, NULL
,
12171 making_terminal_window
= 0;
12174 if (!(mwp
->mWP
= GetNewCWindow (WINDOW_RESOURCE
, NULL
, (WindowPtr
) -1)))
12178 SetWRefCon (mwp
->mWP
, (long) mwp
);
12179 /* so that update events can find this mac_output struct */
12180 mwp
->mFP
= fp
; /* point back to emacs frame */
12182 SetPort (mwp
->mWP
);
12186 SizeWindow (mwp
->mWP
, mwp
->pixel_width
, mwp
->pixel_height
, false);
12187 ShowWindow (mwp
->mWP
);
12192 void make_mac_frame (struct frame
*f
)
12194 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 1;
12195 FRAME_VERTICAL_SCROLL_BAR_TYPE (f
) = vertical_scroll_bar_right
;
12198 f
->output_data
.mac
->background_pixel
= 0xffffff;
12199 f
->output_data
.mac
->foreground_pixel
= 0;
12201 f
->output_data
.mac
->cursor_pixel
= 0;
12202 f
->output_data
.mac
->border_pixel
= 0x00ff00;
12203 f
->output_data
.mac
->mouse_pixel
= 0xff00ff;
12204 f
->output_data
.mac
->cursor_foreground_pixel
= 0x0000ff;
12206 f
->output_data
.mac
->desired_cursor
= FILLED_BOX_CURSOR
;
12208 f
->output_data
.mac
->fontset
= -1;
12209 f
->output_data
.mac
->scroll_bar_foreground_pixel
= -1;
12210 f
->output_data
.mac
->scroll_bar_background_pixel
= -1;
12211 f
->output_data
.mac
->left_pos
= 4;
12212 f
->output_data
.mac
->top_pos
= 4;
12213 f
->output_data
.mac
->border_width
= 0;
12214 f
->output_data
.mac
->explicit_parent
= 0;
12216 f
->output_data
.mac
->internal_border_width
= 0;
12218 f
->output_method
= output_mac
;
12227 void make_mac_terminal_frame (struct frame
*f
)
12231 XSETFRAME (frame
, f
);
12233 f
->output_method
= output_mac
;
12234 f
->output_data
.mac
= (struct mac_output
*)
12235 xmalloc (sizeof (struct mac_output
));
12236 bzero (f
->output_data
.mac
, sizeof (struct mac_output
));
12237 f
->output_data
.mac
->fontset
= -1;
12238 f
->output_data
.mac
->scroll_bar_foreground_pixel
= -1;
12239 f
->output_data
.mac
->scroll_bar_background_pixel
= -1;
12241 XSETFRAME (FRAME_KBOARD (f
)->Vdefault_minibuffer_frame
, f
);
12246 make_mac_frame (f
);
12248 Fmodify_frame_parameters (frame
,
12249 Fcons (Fcons (Qfont
,
12250 build_string ("-*-monaco-medium-r-*--*-90-*-*-*-*-mac-roman")), Qnil
));
12251 Fmodify_frame_parameters (frame
,
12252 Fcons (Fcons (Qforeground_color
,
12253 build_string ("black")), Qnil
));
12254 Fmodify_frame_parameters (frame
,
12255 Fcons (Fcons (Qbackground_color
,
12256 build_string ("white")), Qnil
));
12260 mac_initialize_display_info ()
12262 struct mac_display_info
*dpyinfo
= &one_mac_display_info
;
12263 GDHandle main_device_handle
;
12265 bzero (dpyinfo
, sizeof (*dpyinfo
));
12267 /* Put it on x_display_name_list. */
12268 x_display_name_list
= Fcons (Fcons (build_string ("Mac"), Qnil
),
12269 x_display_name_list
);
12270 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
12272 main_device_handle
= LMGetMainDevice();
12274 dpyinfo
->reference_count
= 0;
12275 dpyinfo
->resx
= 75.0;
12276 dpyinfo
->resy
= 75.0;
12277 dpyinfo
->n_planes
= 1;
12278 dpyinfo
->n_cbits
= 16;
12279 dpyinfo
->height
= (**main_device_handle
).gdRect
.bottom
;
12280 dpyinfo
->width
= (**main_device_handle
).gdRect
.right
;
12281 dpyinfo
->grabbed
= 0;
12282 dpyinfo
->root_window
= NULL
;
12284 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
12285 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
12286 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
12287 dpyinfo
->mouse_face_window
= Qnil
;
12294 rif
= &x_redisplay_interface
;
12296 clear_frame_hook
= x_clear_frame
;
12297 ins_del_lines_hook
= x_ins_del_lines
;
12298 change_line_highlight_hook
= x_change_line_highlight
;
12299 delete_glyphs_hook
= x_delete_glyphs
;
12300 ring_bell_hook
= XTring_bell
;
12301 reset_terminal_modes_hook
= XTreset_terminal_modes
;
12302 set_terminal_modes_hook
= XTset_terminal_modes
;
12303 update_begin_hook
= x_update_begin
;
12304 update_end_hook
= x_update_end
;
12305 set_terminal_window_hook
= XTset_terminal_window
;
12306 read_socket_hook
= XTread_socket
;
12307 frame_up_to_date_hook
= XTframe_up_to_date
;
12308 reassert_line_highlight_hook
= XTreassert_line_highlight
;
12309 mouse_position_hook
= XTmouse_position
;
12310 frame_rehighlight_hook
= XTframe_rehighlight
;
12311 frame_raise_lower_hook
= XTframe_raise_lower
;
12313 set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
12314 condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
12315 redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
12316 judge_scroll_bars_hook
= XTjudge_scroll_bars
;
12318 estimate_mode_line_height_hook
= x_estimate_mode_line_height
;
12320 scroll_region_ok
= 1; /* we'll scroll partial frames */
12321 char_ins_del_ok
= 0; /* just as fast to write the line */
12322 line_ins_del_ok
= 1; /* we'll just blt 'em */
12323 fast_clear_end_of_line
= 1; /* X does this well */
12324 memory_below_frame
= 0; /* we don't remember what scrolls
12329 last_tool_bar_item
= -1;
12330 any_help_event_p
= 0;
12332 /* Try to use interrupt input; if we can't, then start polling. */
12333 Fset_input_mode (Qt
, Qnil
, Qt
, Qnil
);
12335 #ifdef USE_X_TOOLKIT
12336 XtToolkitInitialize ();
12337 Xt_app_con
= XtCreateApplicationContext ();
12338 XtAppSetFallbackResources (Xt_app_con
, Xt_default_resources
);
12340 /* Install an asynchronous timer that processes Xt timeout events
12341 every 0.1s. This is necessary because some widget sets use
12342 timeouts internally, for example the LessTif menu bar, or the
12343 Xaw3d scroll bar. When Xt timouts aren't processed, these
12344 widgets don't behave normally. */
12346 EMACS_TIME interval
;
12347 EMACS_SET_SECS_USECS (interval
, 0, 100000);
12348 start_atimer (ATIMER_CONTINUOUS
, interval
, x_process_timeouts
, 0);
12352 #if USE_TOOLKIT_SCROLL_BARS
12353 xaw3d_arrow_scroll
= False
;
12354 xaw3d_pick_top
= True
;
12358 /* Note that there is no real way portable across R3/R4 to get the
12359 original error handler. */
12360 XSetErrorHandler (x_error_handler
);
12361 XSetIOErrorHandler (x_io_error_quitter
);
12363 /* Disable Window Change signals; they are handled by X events. */
12365 signal (SIGWINCH
, SIG_DFL
);
12366 #endif /* ! defined (SIGWINCH) */
12368 signal (SIGPIPE
, x_connection_signal
);
12371 mac_initialize_display_info ();
12379 staticpro (&x_error_message_string
);
12380 x_error_message_string
= Qnil
;
12383 staticpro (&x_display_name_list
);
12384 x_display_name_list
= Qnil
;
12386 staticpro (&last_mouse_scroll_bar
);
12387 last_mouse_scroll_bar
= Qnil
;
12389 staticpro (&Qvendor_specific_keysyms
);
12390 Qvendor_specific_keysyms
= intern ("vendor-specific-keysyms");
12392 staticpro (&last_mouse_press_frame
);
12393 last_mouse_press_frame
= Qnil
;
12396 staticpro (&help_echo
);
12397 help_echo_object
= Qnil
;
12398 staticpro (&help_echo_object
);
12399 help_echo_window
= Qnil
;
12400 staticpro (&help_echo_window
);
12401 previous_help_echo
= Qnil
;
12402 staticpro (&previous_help_echo
);
12403 help_echo_pos
= -1;
12405 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p
,
12406 "*Non-nil means draw block cursor as wide as the glyph under it.\n\
12407 For example, if a block cursor is over a tab, it will be drawn as\n\
12408 wide as that tab on the display.");
12409 x_stretch_cursor_p
= 0;
12411 DEFVAR_BOOL ("x-toolkit-scroll-bars-p", &x_toolkit_scroll_bars_p
,
12412 "If not nil, Emacs uses toolkit scroll bars.");
12413 #if USE_TOOLKIT_SCROLL_BARS
12414 x_toolkit_scroll_bars_p
= 1;
12416 x_toolkit_scroll_bars_p
= 0;
12419 staticpro (&last_mouse_motion_frame
);
12420 last_mouse_motion_frame
= Qnil
;
12422 DEFVAR_LISP ("mac-command-key-is-meta", &Vmac_command_key_is_meta
,
12423 "Non-nil means that the command key is used as the Emacs meta key.\n\
12424 Otherwise the option key is used.");
12425 Vmac_command_key_is_meta
= Qt
;
12427 DEFVAR_LISP ("mac-ready-for-drag-n-drop", &Vmac_ready_for_drag_n_drop
,
12428 "Non-nil indicates that the Mac event loop can now generate drag and\n\
12429 drop events. Set in term/mac-win.el.");
12430 Vmac_ready_for_drag_n_drop
= Qnil
;
12432 DEFVAR_INT ("mac-keyboard-text-encoding", &mac_keyboard_text_encoding
,
12433 "One of the Text Encoding Base constant values defined in the\n\
12434 Basic Text Constants section of Inside Macintosh - Text Encoding\n\
12435 Conversion Manager. Its value determines the encoding characters\n\
12436 typed at the Mac keyboard (presumed to be in the MacRoman encoding)\n\
12437 will convert into. E.g., if it is set to kTextEncodingMacRoman (0),\n\
12438 its default value, no conversion takes place. If it is set to\n\
12439 kTextEncodingISOLatin1 (0x201) or kTextEncodingISOLatin2 (0x202),\n\
12440 characters typed on Mac keyboard are first converted into the\n\
12441 ISO Latin-1 or ISO Latin-2 encoding, respectively before being\n\
12442 passed to Emacs. Together with Emacs's set-keyboard-coding-system\n\
12443 command, this enables the Mac keyboard to be used to enter non-ASCII\n\
12444 characters directly.");
12445 mac_keyboard_text_encoding
= kTextEncodingMacRoman
;