1 /* Implementation of GUI terminal on the Mac OS.
2 Copyright (C) 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
22 /* Contributed by Andrew Choi (akochoi@mac.com). */
30 #include "blockinput.h"
38 #if !TARGET_API_MAC_CARBON
39 #include <Quickdraw.h>
40 #include <ToolUtils.h>
44 #include <Resources.h>
46 #include <TextUtils.h>
51 #if defined (__MRC__) || (__MSL__ >= 0x6000)
52 #include <ControlDefinitions.h>
58 #endif /* not TARGET_API_MAC_CARBON */
71 #include "dispextern.h"
73 #include "termhooks.h"
80 #include "intervals.h"
83 #include "character.h"
88 /* Non-nil means Emacs uses toolkit scroll bars. */
90 Lisp_Object Vx_toolkit_scroll_bars
;
92 /* If non-zero, the text will be rendered using Core Graphics text
93 rendering which may anti-alias the text. */
94 int mac_use_core_graphics
;
97 /* Non-zero means that a HELP_EVENT has been generated since Emacs
100 static int any_help_event_p
;
102 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
103 static Lisp_Object last_window
;
105 /* Non-zero means make use of UNDERLINE_POSITION font properties.
106 (Not yet supported.) */
107 int x_use_underline_position_properties
;
109 /* Non-zero means to draw the underline at the same place as the descent line. */
111 int x_underline_at_descent_line
;
113 /* This is a chain of structures for all the X displays currently in
116 struct x_display_info
*x_display_list
;
118 /* This is a list of cons cells, each of the form (NAME
119 FONT-LIST-CACHE . RESOURCE-DATABASE), one for each element of
120 x_display_list and in the same order. NAME is the name of the
121 frame. FONT-LIST-CACHE records previous values returned by
122 x-list-fonts. RESOURCE-DATABASE preserves the X Resource Database
123 equivalent, which is implemented with a Lisp object, for the
126 Lisp_Object x_display_name_list
;
128 /* This is display since Mac does not support multiple ones. */
129 struct mac_display_info one_mac_display_info
;
131 /* Frame being updated by update_frame. This is declared in term.c.
132 This is set by update_begin and looked at by all the XT functions.
133 It is zero while not inside an update. In that case, the XT
134 functions assume that `selected_frame' is the frame to apply to. */
136 extern struct frame
*updating_frame
;
138 /* This is a frame waiting to be auto-raised, within XTread_socket. */
140 struct frame
*pending_autoraise_frame
;
144 Formerly, we used PointerMotionHintMask (in standard_event_mask)
145 so that we would have to call XQueryPointer after each MotionNotify
146 event to ask for another such event. However, this made mouse tracking
147 slow, and there was a bug that made it eventually stop.
149 Simply asking for MotionNotify all the time seems to work better.
151 In order to avoid asking for motion events and then throwing most
152 of them away or busy-polling the server for mouse positions, we ask
153 the server for pointer motion hints. This means that we get only
154 one event per group of mouse movements. "Groups" are delimited by
155 other kinds of events (focus changes and button clicks, for
156 example), or by XQueryPointer calls; when one of these happens, we
157 get another MotionNotify event the next time the mouse moves. This
158 is at least as efficient as getting motion events when mouse
159 tracking is on, and I suspect only negligibly worse when tracking
162 /* Where the mouse was last time we reported a mouse event. */
164 static Rect last_mouse_glyph
;
165 static FRAME_PTR last_mouse_glyph_frame
;
167 /* The scroll bar in which the last X motion event occurred.
169 If the last X motion event occurred in a scroll bar, we set this so
170 XTmouse_position can know whether to report a scroll bar motion or
173 If the last X motion event didn't occur in a scroll bar, we set
174 this to Qnil, to tell XTmouse_position to return an ordinary motion
177 static Lisp_Object last_mouse_scroll_bar
;
179 /* This is a hack. We would really prefer that XTmouse_position would
180 return the time associated with the position it returns, but there
181 doesn't seem to be any way to wrest the time-stamp from the server
182 along with the position query. So, we just keep track of the time
183 of the last movement we received, and return that in hopes that
184 it's somewhat accurate. */
186 static Time last_mouse_movement_time
;
188 struct scroll_bar
*tracked_scroll_bar
= NULL
;
190 /* Incremented by XTread_socket whenever it really tries to read
194 static int volatile input_signal_count
;
196 static int input_signal_count
;
199 extern Lisp_Object Vsystem_name
;
201 extern Lisp_Object Qeql
;
203 /* A mask of extra modifier bits to put into every keyboard char. */
205 extern EMACS_INT extra_keyboard_modifiers
;
207 /* The keysyms to use for the various modifiers. */
209 static Lisp_Object Qalt
, Qhyper
, Qsuper
, Qcontrol
, Qmeta
, Qmodifier_value
;
211 extern int inhibit_window_system
;
213 #if __MRC__ && !TARGET_API_MAC_CARBON
214 QDGlobals qd
; /* QuickDraw global information structure. */
217 #define mac_window_to_frame(wp) (((mac_output *) GetWRefCon (wp))->mFP)
219 struct mac_display_info
*mac_display_info_for_display (Display
*);
220 static void x_update_window_end
P_ ((struct window
*, int, int));
221 int x_catch_errors
P_ ((Display
*));
222 void x_uncatch_errors
P_ ((Display
*, int));
223 void x_lower_frame
P_ ((struct frame
*));
224 void x_scroll_bar_clear
P_ ((struct frame
*));
225 int x_had_errors_p
P_ ((Display
*));
226 void x_wm_set_size_hint
P_ ((struct frame
*, long, int));
227 void x_raise_frame
P_ ((struct frame
*));
228 void x_set_window_size
P_ ((struct frame
*, int, int, int));
229 void x_wm_set_window_state
P_ ((struct frame
*, int));
230 void x_wm_set_icon_pixmap
P_ ((struct frame
*, int));
231 static void mac_initialize
P_ ((void));
232 static void x_font_min_bounds
P_ ((XFontStruct
*, int *, int *));
233 static int x_compute_min_glyph_bounds
P_ ((struct frame
*));
234 static void x_update_end
P_ ((struct frame
*));
235 static void XTframe_up_to_date
P_ ((struct frame
*));
236 static void XTset_terminal_modes
P_ ((struct terminal
*));
237 static void XTreset_terminal_modes
P_ ((struct terminal
*));
238 static void x_clear_frame
P_ ((struct frame
*));
239 static void frame_highlight
P_ ((struct frame
*));
240 static void frame_unhighlight
P_ ((struct frame
*));
241 static void x_new_focus_frame
P_ ((struct x_display_info
*, struct frame
*));
242 static void mac_focus_changed
P_ ((int, struct mac_display_info
*,
243 struct frame
*, struct input_event
*));
244 static void x_detect_focus_change
P_ ((struct mac_display_info
*,
246 struct input_event
*));
247 static void XTframe_rehighlight
P_ ((struct frame
*));
248 static void x_frame_rehighlight
P_ ((struct x_display_info
*));
249 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
250 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int,
251 enum text_cursor_kinds
));
253 static void x_clip_to_row
P_ ((struct window
*, struct glyph_row
*, int, GC
));
254 static void x_flush
P_ ((struct frame
*f
));
255 static void x_update_begin
P_ ((struct frame
*));
256 static void x_update_window_begin
P_ ((struct window
*));
257 static void x_after_update_window_line
P_ ((struct glyph_row
*));
258 static void x_scroll_bar_report_motion
P_ ((struct frame
**, Lisp_Object
*,
259 enum scroll_bar_part
*,
260 Lisp_Object
*, Lisp_Object
*,
263 static int is_emacs_window
P_ ((WindowRef
));
264 static XCharStruct
*mac_per_char_metric
P_ ((XFontStruct
*, XChar2b
*, int));
265 static void XSetFont
P_ ((Display
*, GC
, XFontStruct
*));
266 static struct terminal
*mac_create_terminal
P_ ((struct mac_display_info
*dpyinfo
));
269 #define GC_FORE_COLOR(gc) (&(gc)->fore_color)
270 #define GC_BACK_COLOR(gc) (&(gc)->back_color)
271 #define GC_FONT(gc) ((gc)->xgcv.font)
272 #define FRAME_NORMAL_GC(f) ((f)->output_data.mac->normal_gc)
274 #define CG_SET_FILL_COLOR(context, color) \
275 CGContextSetRGBFillColor (context, \
276 RED_FROM_ULONG (color) / 255.0f, \
277 GREEN_FROM_ULONG (color) / 255.0f, \
278 BLUE_FROM_ULONG (color) / 255.0f, 1.0f)
279 #if USE_CG_DRAWING && MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
280 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
281 #define CG_SET_FILL_COLOR_MAYBE_WITH_CGCOLOR(context, color, cg_color) \
283 if (CGColorGetTypeID != NULL) \
284 CGContextSetFillColorWithColor (context, cg_color); \
286 CG_SET_FILL_COLOR (context, color); \
289 #define CG_SET_FILL_COLOR_MAYBE_WITH_CGCOLOR(context, color, cg_color) \
290 CGContextSetFillColorWithColor (context, cg_color)
293 #define CG_SET_FILL_COLOR_MAYBE_WITH_CGCOLOR(context, color, cg_color) \
294 CG_SET_FILL_COLOR (context, color)
296 #define CG_SET_FILL_COLOR_WITH_GC_FOREGROUND(context, gc) \
297 CG_SET_FILL_COLOR_MAYBE_WITH_CGCOLOR (context, (gc)->xgcv.foreground, \
299 #define CG_SET_FILL_COLOR_WITH_GC_BACKGROUND(context, gc) \
300 CG_SET_FILL_COLOR_MAYBE_WITH_CGCOLOR (context, (gc)->xgcv.background, \
304 #define CG_SET_STROKE_COLOR(context, color) \
305 CGContextSetRGBStrokeColor (context, \
306 RED_FROM_ULONG (color) / 255.0f, \
307 GREEN_FROM_ULONG (color) / 255.0f, \
308 BLUE_FROM_ULONG (color) / 255.0f, 1.0f)
309 #if USE_CG_DRAWING && MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
310 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
311 #define CG_SET_STROKE_COLOR_MAYBE_WITH_CGCOLOR(context, color, cg_color) \
313 if (CGColorGetTypeID != NULL) \
314 CGContextSetStrokeColorWithColor (context, cg_color); \
316 CG_SET_STROKE_COLOR (context, color); \
319 #define CG_SET_STROKE_COLOR_MAYBE_WITH_CGCOLOR(context, color, cg_color) \
320 CGContextSetStrokeColorWithColor (context, cg_color)
323 #define CG_SET_STROKE_COLOR_MAYBE_WITH_CGCOLOR(context, color, cg_color) \
324 CG_SET_STROKE_COLOR (context, color)
326 #define CG_SET_STROKE_COLOR_WITH_GC_FOREGROUND(context, gc) \
327 CG_SET_STROKE_COLOR_MAYBE_WITH_CGCOLOR (context, (gc)->xgcv.foreground, \
331 #define FRAME_CG_CONTEXT(f) ((f)->output_data.mac->cg_context)
333 /* Fringe bitmaps. */
335 static int max_fringe_bmp
= 0;
336 static CGImageRef
*fringe_bmp
= 0;
338 static CGColorSpaceRef mac_cg_color_space_rgb
;
339 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
340 static CGColorRef mac_cg_color_black
;
346 mac_cg_color_space_rgb
= CGColorSpaceCreateDeviceRGB ();
347 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
348 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
349 /* Don't check the availability of CGColorCreate; this symbol is
350 defined even in Mac OS X 10.1. */
351 if (CGColorGetTypeID
!= NULL
)
354 float rgba
[] = {0.0f
, 0.0f
, 0.0f
, 1.0f
};
356 mac_cg_color_black
= CGColorCreate (mac_cg_color_space_rgb
, rgba
);
362 mac_begin_cg_clip (f
, gc
)
366 CGContextRef context
= FRAME_CG_CONTEXT (f
);
370 QDBeginCGContext (GetWindowPort (FRAME_MAC_WINDOW (f
)), &context
);
371 FRAME_CG_CONTEXT (f
) = context
;
374 CGContextSaveGState (context
);
375 CGContextTranslateCTM (context
, 0, FRAME_PIXEL_HEIGHT (f
));
376 CGContextScaleCTM (context
, 1, -1);
377 if (gc
&& gc
->n_clip_rects
)
378 CGContextClipToRects (context
, gc
->clip_rects
, gc
->n_clip_rects
);
387 CGContextRestoreGState (FRAME_CG_CONTEXT (f
));
391 mac_prepare_for_quickdraw (f
)
396 Lisp_Object rest
, frame
;
397 FOR_EACH_FRAME (rest
, frame
)
398 if (FRAME_MAC_P (XFRAME (frame
)))
399 mac_prepare_for_quickdraw (XFRAME (frame
));
403 CGContextRef context
= FRAME_CG_CONTEXT (f
);
407 CGContextSynchronize (context
);
408 QDEndCGContext (GetWindowPort (FRAME_MAC_WINDOW (f
)),
409 &FRAME_CG_CONTEXT (f
));
415 static RgnHandle saved_port_clip_region
= NULL
;
418 mac_begin_clip (f
, gc
)
422 static RgnHandle new_region
= NULL
;
424 if (saved_port_clip_region
== NULL
)
425 saved_port_clip_region
= NewRgn ();
426 if (new_region
== NULL
)
427 new_region
= NewRgn ();
430 mac_prepare_for_quickdraw (f
);
432 SetPortWindowPort (FRAME_MAC_WINDOW (f
));
434 if (gc
->n_clip_rects
)
436 GetClip (saved_port_clip_region
);
437 SectRgn (saved_port_clip_region
, gc
->clip_region
, new_region
);
438 SetClip (new_region
);
446 if (gc
->n_clip_rects
)
447 SetClip (saved_port_clip_region
);
451 /* X display function emulation */
453 /* Mac version of XDrawLine. */
456 mac_draw_line (f
, gc
, x1
, y1
, x2
, y2
)
462 CGContextRef context
;
463 float gx1
= x1
, gy1
= y1
, gx2
= x2
, gy2
= y2
;
466 gx1
+= 0.5f
, gx2
+= 0.5f
;
468 gy1
+= 0.5f
, gy2
+= 0.5f
;
470 context
= mac_begin_cg_clip (f
, gc
);
471 CG_SET_STROKE_COLOR_WITH_GC_FOREGROUND (context
, gc
);
472 CGContextBeginPath (context
);
473 CGContextMoveToPoint (context
, gx1
, gy1
);
474 CGContextAddLineToPoint (context
, gx2
, gy2
);
475 CGContextClosePath (context
);
476 CGContextStrokePath (context
);
494 mac_begin_clip (f
, gc
);
495 RGBForeColor (GC_FORE_COLOR (gc
));
502 /* Mac version of XDrawLine (to Pixmap). */
505 XDrawLine (display
, p
, gc
, x1
, y1
, x2
, y2
)
529 GetGWorld (&old_port
, &old_gdh
);
532 RGBForeColor (GC_FORE_COLOR (gc
));
534 LockPixels (GetGWorldPixMap (p
));
537 UnlockPixels (GetGWorldPixMap (p
));
539 SetGWorld (old_port
, old_gdh
);
544 mac_erase_rectangle (f
, gc
, x
, y
, width
, height
)
548 unsigned int width
, height
;
552 CGContextRef context
;
554 context
= mac_begin_cg_clip (f
, gc
);
555 CG_SET_FILL_COLOR_WITH_GC_BACKGROUND (context
, gc
);
556 CGContextFillRect (context
, CGRectMake (x
, y
, width
, height
));
563 mac_begin_clip (f
, gc
);
564 RGBBackColor (GC_BACK_COLOR (gc
));
565 SetRect (&r
, x
, y
, x
+ width
, y
+ height
);
567 RGBBackColor (GC_BACK_COLOR (FRAME_NORMAL_GC (f
)));
574 /* Mac version of XClearArea. */
577 mac_clear_area (f
, x
, y
, width
, height
)
580 unsigned int width
, height
;
582 mac_erase_rectangle (f
, FRAME_NORMAL_GC (f
), x
, y
, width
, height
);
585 /* Mac version of XClearWindow. */
593 CGContextRef context
;
594 GC gc
= FRAME_NORMAL_GC (f
);
596 context
= mac_begin_cg_clip (f
, NULL
);
597 CG_SET_FILL_COLOR_WITH_GC_BACKGROUND (context
, gc
);
598 CGContextFillRect (context
, CGRectMake (0, 0, FRAME_PIXEL_WIDTH (f
),
599 FRAME_PIXEL_HEIGHT (f
)));
602 #else /* !USE_CG_DRAWING */
603 SetPortWindowPort (FRAME_MAC_WINDOW (f
));
605 RGBBackColor (GC_BACK_COLOR (FRAME_NORMAL_GC (f
)));
607 #if TARGET_API_MAC_CARBON
611 GetWindowPortBounds (FRAME_MAC_WINDOW (f
), &r
);
614 #else /* not TARGET_API_MAC_CARBON */
615 EraseRect (&(FRAME_MAC_WINDOW (f
)->portRect
));
616 #endif /* not TARGET_API_MAC_CARBON */
621 /* Mac replacement for XCopyArea. */
625 mac_draw_cg_image (image
, f
, gc
, src_x
, src_y
, width
, height
,
626 dest_x
, dest_y
, overlay_p
)
631 unsigned int width
, height
;
632 int dest_x
, dest_y
, overlay_p
;
634 CGContextRef context
;
635 float port_height
= FRAME_PIXEL_HEIGHT (f
);
636 CGRect dest_rect
= CGRectMake (dest_x
, dest_y
, width
, height
);
638 context
= mac_begin_cg_clip (f
, gc
);
641 CG_SET_FILL_COLOR_WITH_GC_BACKGROUND (context
, gc
);
642 CGContextFillRect (context
, dest_rect
);
644 CGContextClipToRect (context
, dest_rect
);
645 CGContextScaleCTM (context
, 1, -1);
646 CGContextTranslateCTM (context
, 0, -port_height
);
647 if (CGImageIsMask (image
))
648 CG_SET_FILL_COLOR_WITH_GC_FOREGROUND (context
, gc
);
649 CGContextDrawImage (context
,
650 CGRectMake (dest_x
- src_x
,
651 port_height
- (dest_y
- src_y
652 + CGImageGetHeight (image
)),
653 CGImageGetWidth (image
),
654 CGImageGetHeight (image
)),
659 #else /* !USE_CG_DRAWING */
662 mac_draw_bitmap (f
, gc
, x
, y
, width
, height
, bits
, overlay_p
)
665 int x
, y
, width
, height
;
666 unsigned short *bits
;
672 bitmap
.rowBytes
= sizeof(unsigned short);
673 bitmap
.baseAddr
= (char *)bits
;
674 SetRect (&(bitmap
.bounds
), 0, 0, width
, height
);
676 mac_begin_clip (f
, gc
);
677 RGBForeColor (GC_FORE_COLOR (gc
));
678 RGBBackColor (GC_BACK_COLOR (gc
));
679 SetRect (&r
, x
, y
, x
+ width
, y
+ height
);
680 #if TARGET_API_MAC_CARBON
686 CopyBits (&bitmap
, GetPortBitMapForCopyBits (port
),
687 &(bitmap
.bounds
), &r
, overlay_p
? srcOr
: srcCopy
, 0);
688 UnlockPortBits (port
);
690 #else /* not TARGET_API_MAC_CARBON */
691 CopyBits (&bitmap
, &(FRAME_MAC_WINDOW (f
)->portBits
), &(bitmap
.bounds
), &r
,
692 overlay_p
? srcOr
: srcCopy
, 0);
693 #endif /* not TARGET_API_MAC_CARBON */
694 RGBBackColor (GC_BACK_COLOR (FRAME_NORMAL_GC (f
)));
697 #endif /* !USE_CG_DRAWING */
700 /* Mac replacement for XCreateBitmapFromBitmapData. */
703 mac_create_bitmap_from_bitmap_data (bitmap
, bits
, w
, h
)
708 static const unsigned char swap_nibble
[16]
709 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
710 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
711 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
712 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
716 w1
= (w
+ 7) / 8; /* nb of 8bits elt in X bitmap */
717 bitmap
->rowBytes
= ((w
+ 15) / 16) * 2; /* nb of 16bits elt in Mac bitmap */
718 bitmap
->baseAddr
= xmalloc (bitmap
->rowBytes
* h
);
719 bzero (bitmap
->baseAddr
, bitmap
->rowBytes
* h
);
720 for (i
= 0; i
< h
; i
++)
722 p
= bitmap
->baseAddr
+ i
* bitmap
->rowBytes
;
723 for (j
= 0; j
< w1
; j
++)
725 /* Bitswap XBM bytes to match how Mac does things. */
726 unsigned char c
= *bits
++;
727 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
728 | (swap_nibble
[(c
>>4) & 0xf]));
732 SetRect (&(bitmap
->bounds
), 0, 0, w
, h
);
737 mac_free_bitmap (bitmap
)
740 xfree (bitmap
->baseAddr
);
745 XCreatePixmap (display
, w
, width
, height
, depth
)
748 unsigned int width
, height
;
755 SetPortWindowPort (w
);
757 SetRect (&r
, 0, 0, width
, height
);
758 #if !defined (WORDS_BIG_ENDIAN) && USE_CG_DRAWING
761 err
= NewGWorld (&pixmap
, depth
, &r
, NULL
, NULL
, 0);
762 #if !defined (WORDS_BIG_ENDIAN) && USE_CG_DRAWING
764 /* CreateCGImageFromPixMaps requires ARGB format. */
765 err
= QTNewGWorld (&pixmap
, k32ARGBPixelFormat
, &r
, NULL
, NULL
, 0);
774 XCreatePixmapFromBitmapData (display
, w
, data
, width
, height
, fg
, bg
, depth
)
778 unsigned int width
, height
;
779 unsigned long fg
, bg
;
789 gc
= XCreateGC (display
, w
, 0, NULL
);
791 pixmap
= XCreatePixmap (display
, w
, width
, height
, depth
);
795 GetGWorld (&old_port
, &old_gdh
);
796 SetGWorld (pixmap
, NULL
);
797 mac_create_bitmap_from_bitmap_data (&bitmap
, data
, width
, height
);
798 XSetForeground (display
, gc
, fg
);
799 XSetBackground (display
, gc
, bg
);
800 RGBForeColor (GC_FORE_COLOR (gc
));
801 RGBBackColor (GC_BACK_COLOR (gc
));
802 LockPixels (GetGWorldPixMap (pixmap
));
803 #if TARGET_API_MAC_CARBON
804 CopyBits (&bitmap
, GetPortBitMapForCopyBits (pixmap
),
805 &bitmap
.bounds
, &bitmap
.bounds
, srcCopy
, 0);
806 #else /* not TARGET_API_MAC_CARBON */
807 CopyBits (&bitmap
, &(((GrafPtr
)pixmap
)->portBits
),
808 &bitmap
.bounds
, &bitmap
.bounds
, srcCopy
, 0);
809 #endif /* not TARGET_API_MAC_CARBON */
810 UnlockPixels (GetGWorldPixMap (pixmap
));
811 SetGWorld (old_port
, old_gdh
);
812 mac_free_bitmap (&bitmap
);
819 XFreePixmap (display
, pixmap
)
823 DisposeGWorld (pixmap
);
827 /* Mac replacement for XFillRectangle. */
830 mac_fill_rectangle (f
, gc
, x
, y
, width
, height
)
834 unsigned int width
, height
;
837 CGContextRef context
;
839 context
= mac_begin_cg_clip (f
, gc
);
840 CG_SET_FILL_COLOR_WITH_GC_FOREGROUND (context
, gc
);
841 CGContextFillRect (context
, CGRectMake (x
, y
, width
, height
));
846 mac_begin_clip (f
, gc
);
847 RGBForeColor (GC_FORE_COLOR (gc
));
848 SetRect (&r
, x
, y
, x
+ width
, y
+ height
);
849 PaintRect (&r
); /* using foreground color of gc */
855 /* Mac replacement for XDrawRectangle: dest is a window. */
858 mac_draw_rectangle (f
, gc
, x
, y
, width
, height
)
862 unsigned int width
, height
;
865 CGContextRef context
;
867 context
= mac_begin_cg_clip (f
, gc
);
868 CG_SET_STROKE_COLOR_WITH_GC_FOREGROUND (context
, gc
);
869 CGContextStrokeRect (context
,
870 CGRectMake (x
+ 0.5f
, y
+ 0.5f
, width
, height
));
875 mac_begin_clip (f
, gc
);
876 RGBForeColor (GC_FORE_COLOR (gc
));
877 SetRect (&r
, x
, y
, x
+ width
+ 1, y
+ height
+ 1);
878 FrameRect (&r
); /* using foreground color of gc */
885 mac_invert_rectangle (f
, x
, y
, width
, height
)
888 unsigned int width
, height
;
893 mac_prepare_for_quickdraw (f
);
895 SetPortWindowPort (FRAME_MAC_WINDOW (f
));
897 SetRect (&r
, x
, y
, x
+ width
, y
+ height
);
905 atsu_get_text_layout_with_text_ptr (text
, text_length
, style
, text_layout
)
906 ConstUniCharArrayPtr text
;
907 UniCharCount text_length
;
909 ATSUTextLayout
*text_layout
;
912 static ATSUTextLayout saved_text_layout
= NULL
;
914 if (saved_text_layout
== NULL
)
916 static const UniCharCount lengths
[] = {kATSUToTextEnd
};
917 static const ATSUAttributeTag tags
[] = {kATSULineLayoutOptionsTag
};
918 static const ByteCount sizes
[] = {sizeof (ATSLineLayoutOptions
)};
919 static ATSLineLayoutOptions line_layout
=
920 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
921 kATSLineDisableAllLayoutOperations
| kATSLineUseDeviceMetrics
922 | kATSLineUseQDRendering
924 kATSLineIsDisplayOnly
| kATSLineFractDisable
927 static const ATSUAttributeValuePtr values
[] = {&line_layout
};
929 err
= ATSUCreateTextLayoutWithTextPtr (text
,
930 kATSUFromTextBeginning
,
936 err
= ATSUSetLayoutControls (saved_text_layout
,
937 sizeof (tags
) / sizeof (tags
[0]),
938 tags
, sizes
, values
);
940 err
= ATSUSetTransientFontMatching (saved_text_layout
, true);
944 err
= ATSUSetRunStyle (saved_text_layout
, style
,
945 kATSUFromTextBeginning
, kATSUToTextEnd
);
947 err
= ATSUSetTextPointerLocation (saved_text_layout
, text
,
948 kATSUFromTextBeginning
,
954 *text_layout
= saved_text_layout
;
960 mac_draw_image_string_atsui (f
, gc
, x
, y
, buf
, nchars
, bg_width
,
961 overstrike_p
, bytes_per_char
)
966 int nchars
, bg_width
, overstrike_p
, bytes_per_char
;
969 ATSUTextLayout text_layout
;
971 xassert (bytes_per_char
== 2);
973 #ifndef WORDS_BIG_ENDIAN
976 UniChar
*text
= (UniChar
*)buf
;
978 for (i
= 0; i
< nchars
; i
++)
979 text
[i
] = EndianU16_BtoN (text
[i
]);
982 err
= atsu_get_text_layout_with_text_ptr ((ConstUniCharArrayPtr
)buf
,
984 GC_FONT (gc
)->mac_style
,
989 if (!mac_use_core_graphics
)
992 mac_begin_clip (f
, gc
);
993 RGBForeColor (GC_FORE_COLOR (gc
));
998 SetRect (&r
, x
, y
- FONT_BASE (GC_FONT (gc
)),
999 x
+ bg_width
, y
+ FONT_DESCENT (GC_FONT (gc
)));
1000 RGBBackColor (GC_BACK_COLOR (gc
));
1002 RGBBackColor (GC_BACK_COLOR (FRAME_NORMAL_GC (f
)));
1005 ATSUDrawText (text_layout
,
1006 kATSUFromTextBeginning
, kATSUToTextEnd
,
1007 kATSUUseGrafPortPenLoc
, kATSUUseGrafPortPenLoc
);
1011 ATSUDrawText (text_layout
,
1012 kATSUFromTextBeginning
, kATSUToTextEnd
,
1013 kATSUUseGrafPortPenLoc
, kATSUUseGrafPortPenLoc
);
1020 static CGContextRef context
;
1021 float port_height
= FRAME_PIXEL_HEIGHT (f
);
1022 static const ATSUAttributeTag tags
[] = {kATSUCGContextTag
};
1023 static const ByteCount sizes
[] = {sizeof (CGContextRef
)};
1024 static const ATSUAttributeValuePtr values
[] = {&context
};
1027 context
= mac_begin_cg_clip (f
, gc
);
1032 QDBeginCGContext (port
, &context
);
1033 if (gc
->n_clip_rects
|| bg_width
)
1035 CGContextTranslateCTM (context
, 0, port_height
);
1036 CGContextScaleCTM (context
, 1, -1);
1037 if (gc
->n_clip_rects
)
1038 CGContextClipToRects (context
, gc
->clip_rects
,
1043 CG_SET_FILL_COLOR_WITH_GC_BACKGROUND (context
, gc
);
1044 CGContextFillRect (context
,
1045 CGRectMake (x
, y
- FONT_BASE (GC_FONT (gc
)),
1047 FONT_HEIGHT (GC_FONT (gc
))));
1049 CGContextScaleCTM (context
, 1, -1);
1050 CGContextTranslateCTM (context
, 0, -port_height
);
1054 CG_SET_FILL_COLOR_WITH_GC_FOREGROUND (context
, gc
);
1055 err
= ATSUSetLayoutControls (text_layout
,
1056 sizeof (tags
) / sizeof (tags
[0]),
1057 tags
, sizes
, values
);
1060 ATSUDrawText (text_layout
,
1061 kATSUFromTextBeginning
, kATSUToTextEnd
,
1062 Long2Fix (x
), Long2Fix (port_height
- y
));
1064 ATSUDrawText (text_layout
,
1065 kATSUFromTextBeginning
, kATSUToTextEnd
,
1066 Long2Fix (x
+ 1), Long2Fix (port_height
- y
));
1069 mac_end_cg_clip (f
);
1072 CGContextSynchronize (context
);
1073 QDEndCGContext (port
, &context
);
1076 /* This doesn't work on Mac OS X 10.1. */
1077 ATSUClearLayoutControls (text_layout
,
1078 sizeof (tags
) / sizeof (tags
[0]), tags
);
1080 ATSUSetLayoutControls (text_layout
,
1081 sizeof (tags
) / sizeof (tags
[0]),
1082 tags
, sizes
, values
);
1085 #endif /* MAC_OSX */
1087 #endif /* USE_ATSUI */
1091 mac_draw_image_string_qd (f
, gc
, x
, y
, buf
, nchars
, bg_width
,
1092 overstrike_p
, bytes_per_char
)
1097 int nchars
, bg_width
, overstrike_p
, bytes_per_char
;
1099 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
1103 mac_begin_clip (f
, gc
);
1104 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
1105 if (mac_use_core_graphics
)
1106 savedFlags
= SwapQDTextFlags (kQDUseCGTextRendering
);
1108 RGBForeColor (GC_FORE_COLOR (gc
));
1112 RGBBackColor (GC_BACK_COLOR (gc
));
1118 /* We prefer not to use srcCopy text transfer mode on Mac OS X
1120 - Screen is double-buffered. (In srcCopy mode, a text is drawn
1121 into an offscreen graphics world first. So performance gain
1122 cannot be expected.)
1123 - It lowers rendering quality.
1124 - Some fonts leave garbage on cursor movement. */
1129 RGBBackColor (GC_BACK_COLOR (gc
));
1130 SetRect (&r
, x
, y
- FONT_BASE (GC_FONT (gc
)),
1131 x
+ bg_width
, y
+ FONT_DESCENT (GC_FONT (gc
)));
1136 TextFont (GC_FONT (gc
)->mac_fontnum
);
1137 TextSize (GC_FONT (gc
)->mac_fontsize
);
1138 TextFace (GC_FONT (gc
)->mac_fontface
);
1140 DrawText (buf
, 0, nchars
* bytes_per_char
);
1145 DrawText (buf
, 0, nchars
* bytes_per_char
);
1148 RGBBackColor (GC_BACK_COLOR (FRAME_NORMAL_GC (f
)));
1151 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
1152 if (mac_use_core_graphics
)
1153 SwapQDTextFlags(savedFlags
);
1159 mac_draw_string_common (f
, gc
, x
, y
, buf
, nchars
, bg_width
,
1160 overstrike_p
, bytes_per_char
)
1165 int nchars
, bg_width
, overstrike_p
, bytes_per_char
;
1168 if (GC_FONT (gc
)->mac_style
)
1169 mac_draw_image_string_atsui (f
, gc
, x
, y
, buf
, nchars
, bg_width
,
1170 overstrike_p
, bytes_per_char
);
1172 #endif /* USE_ATSUI */
1173 mac_draw_image_string_qd (f
, gc
, x
, y
, buf
, nchars
, bg_width
,
1174 overstrike_p
, bytes_per_char
);
1178 /* Mac replacement for XDrawImageString. */
1181 mac_draw_image_string (f
, gc
, x
, y
, buf
, nchars
, bg_width
, overstrike_p
)
1186 int nchars
, bg_width
, overstrike_p
;
1188 mac_draw_string_common (f
, gc
, x
, y
, buf
, nchars
, bg_width
,
1193 /* Mac replacement for XDrawImageString16. */
1196 mac_draw_image_string_16 (f
, gc
, x
, y
, buf
, nchars
, bg_width
, overstrike_p
)
1201 int nchars
, bg_width
, overstrike_p
;
1203 mac_draw_string_common (f
, gc
, x
, y
, (char *) buf
, nchars
, bg_width
,
1208 /* Mac replacement for XQueryTextExtents, but takes a character. If
1209 STYLE is NULL, measurement is done by QuickDraw Text routines for
1210 the font of the current graphics port. If CG_GLYPH is not NULL,
1211 *CG_GLYPH is set to the glyph ID or 0 if it cannot be obtained. */
1214 mac_query_char_extents (style
, c
,
1215 font_ascent_return
, font_descent_return
,
1216 overall_return
, cg_glyph
)
1223 int *font_ascent_return
, *font_descent_return
;
1224 XCharStruct
*overall_return
;
1225 #if USE_CG_TEXT_DRAWING
1231 OSStatus err
= noErr
;
1238 ATSUTextLayout text_layout
;
1241 err
= atsu_get_text_layout_with_text_ptr (&ch
, 1, style
, &text_layout
);
1243 && (font_ascent_return
|| font_descent_return
|| overall_return
))
1245 ATSTrapezoid glyph_bounds
;
1247 err
= ATSUGetGlyphBounds (text_layout
, 0, 0,
1248 kATSUFromTextBeginning
, kATSUToTextEnd
,
1249 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
1250 kATSUseFractionalOrigins
,
1252 kATSUseDeviceOrigins
,
1254 1, &glyph_bounds
, NULL
);
1257 xassert (glyph_bounds
.lowerRight
.x
- glyph_bounds
.lowerLeft
.x
1258 == glyph_bounds
.upperRight
.x
- glyph_bounds
.upperLeft
.x
);
1260 width
= Fix2Long (glyph_bounds
.upperRight
.x
1261 - glyph_bounds
.upperLeft
.x
);
1262 if (font_ascent_return
)
1263 *font_ascent_return
= -Fix2Long (glyph_bounds
.upperLeft
.y
);
1264 if (font_descent_return
)
1265 *font_descent_return
= Fix2Long (glyph_bounds
.lowerLeft
.y
);
1268 if (err
== noErr
&& overall_return
)
1270 err
= ATSUMeasureTextImage (text_layout
,
1271 kATSUFromTextBeginning
, kATSUToTextEnd
,
1272 0, 0, &char_bounds
);
1274 STORE_XCHARSTRUCT (*overall_return
, width
, char_bounds
);
1275 #if USE_CG_TEXT_DRAWING
1276 if (err
== noErr
&& cg_glyph
)
1279 ATSUGlyphInfoArray glyph_info_array
;
1280 ByteCount count
= sizeof (ATSUGlyphInfoArray
);
1282 err1
= ATSUMatchFontsToText (text_layout
, kATSUFromTextBeginning
,
1283 kATSUToTextEnd
, NULL
, NULL
, NULL
);
1285 err1
= ATSUGetGlyphInfo (text_layout
, kATSUFromTextBeginning
,
1286 kATSUToTextEnd
, &count
,
1289 /* Make sure that we don't have to make layout
1291 && glyph_info_array
.glyphs
[0].deltaY
== 0.0f
1292 && glyph_info_array
.glyphs
[0].idealX
== 0.0f
1293 && glyph_info_array
.glyphs
[0].screenX
== 0)
1295 xassert (glyph_info_array
.glyphs
[0].glyphID
);
1296 *cg_glyph
= glyph_info_array
.glyphs
[0].glyphID
;
1307 if (font_ascent_return
|| font_descent_return
)
1311 GetFontInfo (&font_info
);
1312 if (font_ascent_return
)
1313 *font_ascent_return
= font_info
.ascent
;
1314 if (font_descent_return
)
1315 *font_descent_return
= font_info
.descent
;
1321 width
= CharWidth (ch
);
1322 QDTextBounds (1, &ch
, &char_bounds
);
1323 STORE_XCHARSTRUCT (*overall_return
, width
, char_bounds
);
1331 /* Mac replacement for XTextExtents16. Only sets horizontal metrics. */
1334 mac_text_extents_16 (font_struct
, string
, nchars
, overall_return
)
1335 XFontStruct
*font_struct
;
1338 XCharStruct
*overall_return
;
1341 short width
= 0, lbearing
= 0, rbearing
= 0;
1344 for (i
= 0; i
< nchars
; i
++)
1346 pcm
= mac_per_char_metric (font_struct
, string
, 0);
1348 width
+= FONT_WIDTH (font_struct
);
1351 lbearing
= min (lbearing
, width
+ pcm
->lbearing
);
1352 rbearing
= max (rbearing
, width
+ pcm
->rbearing
);
1353 width
+= pcm
->width
;
1358 overall_return
->lbearing
= lbearing
;
1359 overall_return
->rbearing
= rbearing
;
1360 overall_return
->width
= width
;
1362 /* What's the meaning of the return value of XTextExtents16? */
1366 #if USE_CG_TEXT_DRAWING
1367 static int cg_text_anti_aliasing_threshold
= 8;
1370 init_cg_text_anti_aliasing_threshold ()
1376 CFPreferencesGetAppIntegerValue (CFSTR ("AppleAntiAliasingThreshold"),
1377 kCFPreferencesCurrentApplication
,
1380 cg_text_anti_aliasing_threshold
= threshold
;
1384 mac_draw_image_string_cg (f
, gc
, x
, y
, buf
, nchars
, bg_width
, overstrike_p
)
1389 int nchars
, bg_width
, overstrike_p
;
1391 float port_height
, gx
, gy
;
1393 CGContextRef context
;
1397 if (!mac_use_core_graphics
|| GC_FONT (gc
)->cg_font
== NULL
)
1400 port_height
= FRAME_PIXEL_HEIGHT (f
);
1402 gy
= port_height
- y
;
1403 glyphs
= (CGGlyph
*)buf
;
1404 advances
= alloca (sizeof (CGSize
) * nchars
);
1405 if (advances
== NULL
)
1407 for (i
= 0; i
< nchars
; i
++)
1409 XCharStruct
*pcm
= mac_per_char_metric (GC_FONT (gc
), buf
, 0);
1411 advances
[i
].width
= pcm
->width
;
1412 advances
[i
].height
= 0;
1413 glyphs
[i
] = GC_FONT (gc
)->cg_glyphs
[buf
->byte2
];
1418 context
= mac_begin_cg_clip (f
, gc
);
1420 QDBeginCGContext (GetWindowPort (FRAME_MAC_WINDOW (f
)), &context
);
1421 if (gc
->n_clip_rects
|| bg_width
)
1423 CGContextTranslateCTM (context
, 0, port_height
);
1424 CGContextScaleCTM (context
, 1, -1);
1425 if (gc
->n_clip_rects
)
1426 CGContextClipToRects (context
, gc
->clip_rects
, gc
->n_clip_rects
);
1430 CG_SET_FILL_COLOR_WITH_GC_BACKGROUND (context
, gc
);
1433 CGRectMake (gx
, y
- FONT_BASE (GC_FONT (gc
)),
1434 bg_width
, FONT_HEIGHT (GC_FONT (gc
))));
1436 CGContextScaleCTM (context
, 1, -1);
1437 CGContextTranslateCTM (context
, 0, -port_height
);
1441 CG_SET_FILL_COLOR_WITH_GC_FOREGROUND (context
, gc
);
1442 CGContextSetFont (context
, GC_FONT (gc
)->cg_font
);
1443 CGContextSetFontSize (context
, GC_FONT (gc
)->mac_fontsize
);
1444 if (GC_FONT (gc
)->mac_fontsize
<= cg_text_anti_aliasing_threshold
)
1445 CGContextSetShouldAntialias (context
, false);
1446 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
1447 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
1448 if (CGContextShowGlyphsWithAdvances
!= NULL
)
1451 CGContextSetTextPosition (context
, gx
, gy
);
1452 CGContextShowGlyphsWithAdvances (context
, glyphs
, advances
, nchars
);
1455 CGContextSetTextPosition (context
, gx
+ 1.0f
, gy
);
1456 CGContextShowGlyphsWithAdvances (context
, glyphs
, advances
, nchars
);
1459 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
1460 else /* CGContextShowGlyphsWithAdvances == NULL */
1462 #endif /* MAC_OS_X_VERSION_MAX_ALLOWED >= 1030 */
1463 #if MAC_OS_X_VERSION_MAX_ALLOWED < 1030 || MAC_OS_X_VERSION_MIN_REQUIRED == 1020
1465 for (i
= 0; i
< nchars
; i
++)
1467 CGContextShowGlyphsAtPoint (context
, gx
, gy
, glyphs
+ i
, 1);
1469 CGContextShowGlyphsAtPoint (context
, gx
+ 1.0f
, gy
, glyphs
+ i
, 1);
1470 gx
+= advances
[i
].width
;
1475 mac_end_cg_clip (f
);
1477 CGContextSynchronize (context
);
1478 QDEndCGContext (GetWindowPort (FRAME_MAC_WINDOW (f
)), &context
);
1487 /* Mac replacement for XCopyArea: dest must be window. */
1490 mac_copy_area (src
, f
, gc
, src_x
, src_y
, width
, height
, dest_x
, dest_y
)
1495 unsigned int width
, height
;
1500 mac_begin_clip (f
, gc
);
1502 SetRect (&src_r
, src_x
, src_y
, src_x
+ width
, src_y
+ height
);
1503 SetRect (&dest_r
, dest_x
, dest_y
, dest_x
+ width
, dest_y
+ height
);
1505 ForeColor (blackColor
);
1506 BackColor (whiteColor
);
1508 LockPixels (GetGWorldPixMap (src
));
1509 #if TARGET_API_MAC_CARBON
1514 LockPortBits (port
);
1515 CopyBits (GetPortBitMapForCopyBits (src
),
1516 GetPortBitMapForCopyBits (port
),
1517 &src_r
, &dest_r
, srcCopy
, 0);
1518 UnlockPortBits (port
);
1520 #else /* not TARGET_API_MAC_CARBON */
1521 CopyBits (&(((GrafPtr
)src
)->portBits
), &(FRAME_MAC_WINDOW (f
)->portBits
),
1522 &src_r
, &dest_r
, srcCopy
, 0);
1523 #endif /* not TARGET_API_MAC_CARBON */
1524 UnlockPixels (GetGWorldPixMap (src
));
1526 RGBBackColor (GC_BACK_COLOR (FRAME_NORMAL_GC (f
)));
1533 mac_copy_area_with_mask (src
, mask
, f
, gc
, src_x
, src_y
,
1534 width
, height
, dest_x
, dest_y
)
1539 unsigned int width
, height
;
1544 mac_begin_clip (f
, gc
);
1546 SetRect (&src_r
, src_x
, src_y
, src_x
+ width
, src_y
+ height
);
1547 SetRect (&dest_r
, dest_x
, dest_y
, dest_x
+ width
, dest_y
+ height
);
1549 ForeColor (blackColor
);
1550 BackColor (whiteColor
);
1552 LockPixels (GetGWorldPixMap (src
));
1553 LockPixels (GetGWorldPixMap (mask
));
1554 #if TARGET_API_MAC_CARBON
1559 LockPortBits (port
);
1560 CopyMask (GetPortBitMapForCopyBits (src
), GetPortBitMapForCopyBits (mask
),
1561 GetPortBitMapForCopyBits (port
),
1562 &src_r
, &src_r
, &dest_r
);
1563 UnlockPortBits (port
);
1565 #else /* not TARGET_API_MAC_CARBON */
1566 CopyMask (&(((GrafPtr
)src
)->portBits
), &(((GrafPtr
)mask
)->portBits
),
1567 &(FRAME_MAC_WINDOW (f
)->portBits
), &src_r
, &src_r
, &dest_r
);
1568 #endif /* not TARGET_API_MAC_CARBON */
1569 UnlockPixels (GetGWorldPixMap (mask
));
1570 UnlockPixels (GetGWorldPixMap (src
));
1572 RGBBackColor (GC_BACK_COLOR (FRAME_NORMAL_GC (f
)));
1576 #endif /* !USE_CG_DRAWING */
1579 /* Mac replacement for XCopyArea: used only for scrolling. */
1582 mac_scroll_area (f
, gc
, src_x
, src_y
, width
, height
, dest_x
, dest_y
)
1586 unsigned int width
, height
;
1589 #if TARGET_API_MAC_CARBON
1591 RgnHandle dummy
= NewRgn (); /* For avoiding update events. */
1593 SetRect (&src_r
, src_x
, src_y
, src_x
+ width
, src_y
+ height
);
1595 mac_prepare_for_quickdraw (f
);
1597 ScrollWindowRect (FRAME_MAC_WINDOW (f
),
1598 &src_r
, dest_x
- src_x
, dest_y
- src_y
,
1599 kScrollWindowNoOptions
, dummy
);
1601 #else /* not TARGET_API_MAC_CARBON */
1603 WindowRef w
= FRAME_MAC_WINDOW (f
);
1605 mac_begin_clip (f
, gc
);
1607 SetRect (&src_r
, src_x
, src_y
, src_x
+ width
, src_y
+ height
);
1608 SetRect (&dest_r
, dest_x
, dest_y
, dest_x
+ width
, dest_y
+ height
);
1610 /* In Color QuickDraw, set ForeColor and BackColor as follows to avoid
1611 color mapping in CopyBits. Otherwise, it will be slow. */
1612 ForeColor (blackColor
);
1613 BackColor (whiteColor
);
1614 CopyBits (&(w
->portBits
), &(w
->portBits
), &src_r
, &dest_r
, srcCopy
, 0);
1616 RGBBackColor (GC_BACK_COLOR (FRAME_NORMAL_GC (f
)));
1619 #endif /* not TARGET_API_MAC_CARBON */
1623 /* Mac replacement for XChangeGC. */
1626 XChangeGC (display
, gc
, mask
, xgcv
)
1632 if (mask
& GCForeground
)
1633 XSetForeground (display
, gc
, xgcv
->foreground
);
1634 if (mask
& GCBackground
)
1635 XSetBackground (display
, gc
, xgcv
->background
);
1637 XSetFont (display
, gc
, xgcv
->font
);
1641 /* Mac replacement for XCreateGC. */
1644 XCreateGC (display
, d
, mask
, xgcv
)
1650 GC gc
= xmalloc (sizeof (*gc
));
1652 bzero (gc
, sizeof (*gc
));
1653 #if USE_CG_DRAWING && MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
1654 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
1655 if (CGColorGetTypeID
!= NULL
)
1658 gc
->cg_fore_color
= gc
->cg_back_color
= mac_cg_color_black
;
1659 CGColorRetain (gc
->cg_fore_color
);
1660 CGColorRetain (gc
->cg_back_color
);
1663 XChangeGC (display
, gc
, mask
, xgcv
);
1669 /* Used in xfaces.c. */
1672 XFreeGC (display
, gc
)
1676 if (gc
->clip_region
)
1677 DisposeRgn (gc
->clip_region
);
1678 #if USE_CG_DRAWING && MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
1679 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
1680 if (CGColorGetTypeID
!= NULL
)
1683 CGColorRelease (gc
->cg_fore_color
);
1684 CGColorRelease (gc
->cg_back_color
);
1691 /* Mac replacement for XGetGCValues. */
1694 XGetGCValues (display
, gc
, mask
, xgcv
)
1700 if (mask
& GCForeground
)
1701 xgcv
->foreground
= gc
->xgcv
.foreground
;
1702 if (mask
& GCBackground
)
1703 xgcv
->background
= gc
->xgcv
.background
;
1705 xgcv
->font
= gc
->xgcv
.font
;
1709 /* Mac replacement for XSetForeground. */
1712 XSetForeground (display
, gc
, color
)
1715 unsigned long color
;
1717 if (gc
->xgcv
.foreground
!= color
)
1719 gc
->xgcv
.foreground
= color
;
1720 gc
->fore_color
.red
= RED16_FROM_ULONG (color
);
1721 gc
->fore_color
.green
= GREEN16_FROM_ULONG (color
);
1722 gc
->fore_color
.blue
= BLUE16_FROM_ULONG (color
);
1723 #if USE_CG_DRAWING && MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
1724 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
1725 if (CGColorGetTypeID
!= NULL
)
1728 CGColorRelease (gc
->cg_fore_color
);
1731 gc
->cg_fore_color
= mac_cg_color_black
;
1732 CGColorRetain (gc
->cg_fore_color
);
1738 rgba
[0] = gc
->fore_color
.red
/ 65535.0f
;
1739 rgba
[1] = gc
->fore_color
.green
/ 65535.0f
;
1740 rgba
[2] = gc
->fore_color
.blue
/ 65535.0f
;
1742 gc
->cg_fore_color
= CGColorCreate (mac_cg_color_space_rgb
, rgba
);
1750 /* Mac replacement for XSetBackground. */
1753 XSetBackground (display
, gc
, color
)
1756 unsigned long color
;
1758 if (gc
->xgcv
.background
!= color
)
1760 gc
->xgcv
.background
= color
;
1761 gc
->back_color
.red
= RED16_FROM_ULONG (color
);
1762 gc
->back_color
.green
= GREEN16_FROM_ULONG (color
);
1763 gc
->back_color
.blue
= BLUE16_FROM_ULONG (color
);
1764 #if USE_CG_DRAWING && MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
1765 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
1766 if (CGColorGetTypeID
!= NULL
)
1769 CGColorRelease (gc
->cg_back_color
);
1772 gc
->cg_back_color
= mac_cg_color_black
;
1773 CGColorRetain (gc
->cg_back_color
);
1779 rgba
[0] = gc
->back_color
.red
/ 65535.0f
;
1780 rgba
[1] = gc
->back_color
.green
/ 65535.0f
;
1781 rgba
[2] = gc
->back_color
.blue
/ 65535.0f
;
1783 gc
->cg_back_color
= CGColorCreate (mac_cg_color_space_rgb
, rgba
);
1791 /* Mac replacement for XSetFont. */
1794 XSetFont (display
, gc
, font
)
1799 gc
->xgcv
.font
= font
;
1803 /* Mac replacement for XSetClipRectangles. */
1806 mac_set_clip_rectangles (display
, gc
, rectangles
, n
)
1814 xassert (n
>= 0 && n
<= MAX_CLIP_RECTS
);
1816 gc
->n_clip_rects
= n
;
1819 if (gc
->clip_region
== NULL
)
1820 gc
->clip_region
= NewRgn ();
1821 RectRgn (gc
->clip_region
, rectangles
);
1824 RgnHandle region
= NewRgn ();
1826 for (i
= 1; i
< n
; i
++)
1828 RectRgn (region
, rectangles
+ i
);
1829 UnionRgn (gc
->clip_region
, region
, gc
->clip_region
);
1831 DisposeRgn (region
);
1834 #if defined (MAC_OSX) && (USE_ATSUI || USE_CG_DRAWING)
1835 for (i
= 0; i
< n
; i
++)
1837 Rect
*rect
= rectangles
+ i
;
1839 gc
->clip_rects
[i
] = CGRectMake (rect
->left
, rect
->top
,
1840 rect
->right
- rect
->left
,
1841 rect
->bottom
- rect
->top
);
1847 /* Mac replacement for XSetClipMask. */
1850 mac_reset_clip_rectangles (display
, gc
)
1854 gc
->n_clip_rects
= 0;
1858 /* Mac replacement for XSetWindowBackground. */
1861 XSetWindowBackground (display
, w
, color
)
1864 unsigned long color
;
1866 #if !TARGET_API_MAC_CARBON
1867 AuxWinHandle aw_handle
;
1868 CTabHandle ctab_handle
;
1869 ColorSpecPtr ct_table
;
1874 bg_color
.red
= RED16_FROM_ULONG (color
);
1875 bg_color
.green
= GREEN16_FROM_ULONG (color
);
1876 bg_color
.blue
= BLUE16_FROM_ULONG (color
);
1878 #if TARGET_API_MAC_CARBON
1879 SetWindowContentColor (w
, &bg_color
);
1881 if (GetAuxWin (w
, &aw_handle
))
1883 ctab_handle
= (*aw_handle
)->awCTable
;
1884 HandToHand ((Handle
*) &ctab_handle
);
1885 ct_table
= (*ctab_handle
)->ctTable
;
1886 ct_size
= (*ctab_handle
)->ctSize
;
1887 while (ct_size
> -1)
1889 if (ct_table
->value
== 0)
1891 ct_table
->rgb
= bg_color
;
1892 CTabChanged (ctab_handle
);
1893 SetWinColor (w
, (WCTabHandle
) ctab_handle
);
1901 /* Flush display of frame F, or of all frames if F is null. */
1907 #if TARGET_API_MAC_CARBON
1910 mac_prepare_for_quickdraw (f
);
1913 QDFlushPortBuffer (GetWindowPort (FRAME_MAC_WINDOW (f
)), NULL
);
1915 QDFlushPortBuffer (GetQDGlobalsThePort (), NULL
);
1921 /* Remove calls to XFlush by defining XFlush to an empty replacement.
1922 Calls to XFlush should be unnecessary because the X output buffer
1923 is flushed automatically as needed by calls to XPending,
1924 XNextEvent, or XWindowEvent according to the XFlush man page.
1925 XTread_socket calls XPending. Removing XFlush improves
1928 #define XFlush(DISPLAY) (void) 0
1932 mac_flush_display_optional (f
)
1936 mac_prepare_for_quickdraw (f
);
1941 /***********************************************************************
1942 Starting and ending an update
1943 ***********************************************************************/
1945 /* Start an update of frame F. This function is installed as a hook
1946 for update_begin, i.e. it is called when update_begin is called.
1947 This function is called prior to calls to x_update_window_begin for
1948 each window being updated. */
1954 #if TARGET_API_MAC_CARBON
1955 /* During update of a frame, availability of input events is
1956 periodically checked with ReceiveNextEvent if
1957 redisplay-dont-pause is nil. That normally flushes window buffer
1958 changes for every check, and thus screen update looks waving even
1959 if no input is available. So we disable screen updates during
1960 update of a frame. */
1962 DisableScreenUpdates ();
1968 /* Start update of window W. Set the global variable updated_window
1969 to the window being updated and set output_cursor to the cursor
1973 x_update_window_begin (w
)
1976 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1977 struct mac_display_info
*display_info
= FRAME_MAC_DISPLAY_INFO (f
);
1980 set_output_cursor (&w
->cursor
);
1984 if (f
== display_info
->mouse_face_mouse_frame
)
1986 /* Don't do highlighting for mouse motion during the update. */
1987 display_info
->mouse_face_defer
= 1;
1989 /* If F needs to be redrawn, simply forget about any prior mouse
1991 if (FRAME_GARBAGED_P (f
))
1992 display_info
->mouse_face_window
= Qnil
;
1994 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
1995 their mouse_face_p flag set, which means that they are always
1996 unequal to rows in a desired matrix which never have that
1997 flag set. So, rows containing mouse-face glyphs are never
1998 scrolled, and we don't have to switch the mouse highlight off
1999 here to prevent it from being scrolled. */
2001 /* Can we tell that this update does not affect the window
2002 where the mouse highlight is? If so, no need to turn off.
2003 Likewise, don't do anything if the frame is garbaged;
2004 in that case, the frame's current matrix that we would use
2005 is all wrong, and we will redisplay that line anyway. */
2006 if (!NILP (display_info
->mouse_face_window
)
2007 && w
== XWINDOW (display_info
->mouse_face_window
))
2011 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
2012 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
2015 if (i
< w
->desired_matrix
->nrows
)
2016 clear_mouse_face (display_info
);
2025 /* Draw a vertical window border from (x,y0) to (x,y1) */
2028 mac_draw_vertical_window_border (w
, x
, y0
, y1
)
2032 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2035 face
= FACE_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
2037 XSetForeground (FRAME_MAC_DISPLAY (f
), f
->output_data
.mac
->normal_gc
,
2040 mac_draw_line (f
, f
->output_data
.mac
->normal_gc
, x
, y0
, x
, y1
);
2043 /* End update of window W (which is equal to updated_window).
2045 Draw vertical borders between horizontally adjacent windows, and
2046 display W's cursor if CURSOR_ON_P is non-zero.
2048 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
2049 glyphs in mouse-face were overwritten. In that case we have to
2050 make sure that the mouse-highlight is properly redrawn.
2052 W may be a menu bar pseudo-window in case we don't have X toolkit
2053 support. Such windows don't have a cursor, so don't display it
2057 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
2059 int cursor_on_p
, mouse_face_overwritten_p
;
2061 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (XFRAME (w
->frame
));
2063 if (!w
->pseudo_window_p
)
2068 display_and_set_cursor (w
, 1, output_cursor
.hpos
,
2070 output_cursor
.x
, output_cursor
.y
);
2072 if (draw_window_fringes (w
, 1))
2073 x_draw_vertical_border (w
);
2078 /* If a row with mouse-face was overwritten, arrange for
2079 XTframe_up_to_date to redisplay the mouse highlight. */
2080 if (mouse_face_overwritten_p
)
2082 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
2083 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
2084 dpyinfo
->mouse_face_window
= Qnil
;
2087 updated_window
= NULL
;
2091 /* End update of frame F. This function is installed as a hook in
2098 /* Mouse highlight may be displayed again. */
2099 FRAME_MAC_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
2102 #if TARGET_API_MAC_CARBON
2103 EnableScreenUpdates ();
2105 XFlush (FRAME_MAC_DISPLAY (f
));
2110 /* This function is called from various places in xdisp.c whenever a
2111 complete update has been performed. The global variable
2112 updated_window is not available here. */
2115 XTframe_up_to_date (f
)
2118 if (FRAME_MAC_P (f
))
2120 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
2122 if (dpyinfo
->mouse_face_deferred_gc
2123 || f
== dpyinfo
->mouse_face_mouse_frame
)
2126 if (dpyinfo
->mouse_face_mouse_frame
)
2127 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
2128 dpyinfo
->mouse_face_mouse_x
,
2129 dpyinfo
->mouse_face_mouse_y
);
2130 dpyinfo
->mouse_face_deferred_gc
= 0;
2137 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
2138 arrow bitmaps, or clear the fringes if no bitmaps are required
2139 before DESIRED_ROW is made current. The window being updated is
2140 found in updated_window. This function is called from
2141 update_window_line only if it is known that there are differences
2142 between bitmaps to be drawn between current row and DESIRED_ROW. */
2145 x_after_update_window_line (desired_row
)
2146 struct glyph_row
*desired_row
;
2148 struct window
*w
= updated_window
;
2154 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
2155 desired_row
->redraw_fringe_bitmaps_p
= 1;
2157 /* When a window has disappeared, make sure that no rest of
2158 full-width rows stays visible in the internal border. Could
2159 check here if updated_window is the leftmost/rightmost window,
2160 but I guess it's not worth doing since vertically split windows
2161 are almost never used, internal border is rarely set, and the
2162 overhead is very small. */
2163 if (windows_or_buffers_changed
2164 && desired_row
->full_width_p
2165 && (f
= XFRAME (w
->frame
),
2166 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
2168 && (height
= desired_row
->visible_height
,
2171 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
2173 /* Internal border is drawn below the tool bar. */
2174 if (WINDOWP (f
->tool_bar_window
)
2175 && w
== XWINDOW (f
->tool_bar_window
))
2179 mac_clear_area (f
, 0, y
, width
, height
);
2180 mac_clear_area (f
, FRAME_PIXEL_WIDTH (f
) - width
, y
, width
, height
);
2186 /* Draw the bitmap WHICH in one of the left or right fringes of
2187 window W. ROW is the glyph row for which to display the bitmap; it
2188 determines the vertical position at which the bitmap has to be
2192 x_draw_fringe_bitmap (w
, row
, p
)
2194 struct glyph_row
*row
;
2195 struct draw_fringe_bitmap_params
*p
;
2197 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2198 Display
*display
= FRAME_MAC_DISPLAY (f
);
2199 struct face
*face
= p
->face
;
2201 int overlay_p
= p
->overlay_p
;
2206 int bx
= p
->bx
, by
= p
->by
, nx
= p
->nx
, ny
= p
->ny
;
2208 #if 0 /* MAC_TODO: stipple */
2209 /* In case the same realized face is used for fringes and
2210 for something displayed in the text (e.g. face `region' on
2211 mono-displays, the fill style may have been changed to
2212 FillSolid in x_draw_glyph_string_background. */
2214 XSetFillStyle (FRAME_X_DISPLAY (f
), face
->gc
, FillOpaqueStippled
);
2216 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->background
);
2219 /* If the fringe is adjacent to the left (right) scroll bar of a
2220 leftmost (rightmost, respectively) window, then extend its
2221 background to the gap between the fringe and the bar. */
2222 if ((WINDOW_LEFTMOST_P (w
)
2223 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
2224 || (WINDOW_RIGHTMOST_P (w
)
2225 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
)))
2227 int sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
2231 int left
= WINDOW_SCROLL_BAR_AREA_X (w
);
2232 int width
= (WINDOW_CONFIG_SCROLL_BAR_COLS (w
)
2233 * FRAME_COLUMN_WIDTH (f
));
2236 && (left
+ width
== p
->x
2237 || p
->x
+ p
->wd
== left
))
2239 /* Bitmap fills the fringe and we need background
2241 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
2245 by
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
2247 ny
= row
->visible_height
;
2252 if (left
+ width
== bx
)
2254 bx
= left
+ sb_width
;
2255 nx
+= width
- sb_width
;
2257 else if (bx
+ nx
== left
)
2258 nx
+= width
- sb_width
;
2265 mac_erase_rectangle (f
, face
->gc
, bx
, by
, nx
, ny
);
2266 /* The fringe background has already been filled. */
2270 #if 0 /* MAC_TODO: stipple */
2272 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->foreground
);
2275 #endif /* MAC_OSX */
2277 /* Must clip because of partially visible lines. */
2278 rowY
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
2281 /* Adjust position of "bottom aligned" bitmap on partially
2282 visible last row. */
2284 int oldVH
= row
->visible_height
;
2285 row
->visible_height
= p
->h
;
2286 row
->y
-= rowY
- p
->y
;
2287 x_clip_to_row (w
, row
, -1, face
->gc
);
2289 row
->visible_height
= oldVH
;
2292 x_clip_to_row (w
, row
, -1, face
->gc
);
2295 if (p
->bx
>= 0 && !p
->overlay_p
)
2297 #if 0 /* MAC_TODO: stipple */
2298 /* In case the same realized face is used for fringes and
2299 for something displayed in the text (e.g. face `region' on
2300 mono-displays, the fill style may have been changed to
2301 FillSolid in x_draw_glyph_string_background. */
2303 XSetFillStyle (FRAME_X_DISPLAY (f
), face
->gc
, FillOpaqueStippled
);
2305 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->background
);
2308 mac_erase_rectangle (f
, face
->gc
, p
->bx
, p
->by
, p
->nx
, p
->ny
);
2310 #if 0 /* MAC_TODO: stipple */
2312 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->foreground
);
2315 #endif /* !MAC_OSX */
2319 && p
->which
< max_fringe_bmp
2325 XGetGCValues (display
, face
->gc
, GCForeground
, &gcv
);
2326 XSetForeground (display
, face
->gc
,
2328 ? (p
->overlay_p
? face
->background
2329 : f
->output_data
.mac
->cursor_pixel
)
2330 : face
->foreground
));
2332 mac_draw_cg_image (fringe_bmp
[p
->which
], f
, face
->gc
, 0, p
->dh
,
2333 p
->wd
, p
->h
, p
->x
, p
->y
, overlay_p
);
2335 mac_draw_bitmap (f
, face
->gc
, p
->x
, p
->y
,
2336 p
->wd
, p
->h
, p
->bits
+ p
->dh
, overlay_p
);
2338 XSetForeground (display
, face
->gc
, gcv
.foreground
);
2341 mac_reset_clip_rectangles (display
, face
->gc
);
2346 mac_define_fringe_bitmap (which
, bits
, h
, wd
)
2348 unsigned short *bits
;
2352 CGDataProviderRef provider
;
2354 if (which
>= max_fringe_bmp
)
2357 max_fringe_bmp
= which
+ 20;
2358 fringe_bmp
= (CGImageRef
*) xrealloc (fringe_bmp
, max_fringe_bmp
* sizeof (CGImageRef
));
2359 while (i
< max_fringe_bmp
)
2360 fringe_bmp
[i
++] = 0;
2363 for (i
= 0; i
< h
; i
++)
2368 provider
= CGDataProviderCreateWithData (NULL
, bits
,
2369 sizeof (unsigned short) * h
, NULL
);
2372 fringe_bmp
[which
] = CGImageMaskCreate (wd
, h
, 1, 1,
2373 sizeof (unsigned short),
2375 CGDataProviderRelease (provider
);
2382 mac_destroy_fringe_bitmap (which
)
2385 if (which
>= max_fringe_bmp
)
2388 if (fringe_bmp
[which
])
2391 CGImageRelease (fringe_bmp
[which
]);
2394 fringe_bmp
[which
] = 0;
2399 /* This is called when starting Emacs and when restarting after
2400 suspend. When starting Emacs, no window is mapped. And nothing
2401 must be done to Emacs's own window if it is suspended (though that
2405 XTset_terminal_modes (struct terminal
*t
)
2409 /* This is called when exiting or suspending Emacs. Exiting will make
2410 the windows go away, and suspending requires no action. */
2413 XTreset_terminal_modes (struct terminal
*t
)
2419 /***********************************************************************
2421 ***********************************************************************/
2423 /* Function prototypes of this page. */
2425 static XCharStruct
*x_per_char_metric
P_ ((XFontStruct
*, XChar2b
*));
2426 static int mac_encode_char
P_ ((int, XChar2b
*, struct font_info
*,
2427 struct charset
*, int *));
2431 pcm_init (pcm
, count
)
2435 bzero (pcm
, sizeof (XCharStruct
) * count
);
2436 while (--count
>= 0)
2438 pcm
->descent
= PCM_INVALID
;
2443 static enum pcm_status
2444 pcm_get_status (pcm
)
2445 const XCharStruct
*pcm
;
2447 int height
= pcm
->ascent
+ pcm
->descent
;
2449 /* Negative height means some special status. */
2450 return height
>= 0 ? PCM_VALID
: height
;
2453 /* Get metrics of character CHAR2B in FONT. Value is null if CHAR2B
2454 is not contained in the font. */
2456 static INLINE XCharStruct
*
2457 x_per_char_metric (font
, char2b
)
2461 /* The result metric information. */
2462 XCharStruct
*pcm
= NULL
;
2464 xassert (font
&& char2b
);
2467 if (font
->mac_style
)
2469 XCharStruct
**row
= font
->bounds
.rows
+ char2b
->byte1
;
2473 *row
= xmalloc (sizeof (XCharStruct
) * 0x100);
2474 pcm_init (*row
, 0x100);
2476 pcm
= *row
+ char2b
->byte2
;
2477 if (pcm_get_status (pcm
) != PCM_VALID
)
2480 mac_query_char_extents (font
->mac_style
,
2481 (char2b
->byte1
<< 8) + char2b
->byte2
,
2482 NULL
, NULL
, pcm
, NULL
);
2489 if (font
->bounds
.per_char
!= NULL
)
2491 if (font
->min_byte1
== 0 && font
->max_byte1
== 0)
2493 /* min_char_or_byte2 specifies the linear character index
2494 corresponding to the first element of the per_char array,
2495 max_char_or_byte2 is the index of the last character. A
2496 character with non-zero CHAR2B->byte1 is not in the font.
2497 A character with byte2 less than min_char_or_byte2 or
2498 greater max_char_or_byte2 is not in the font. */
2499 if (char2b
->byte1
== 0
2500 && char2b
->byte2
>= font
->min_char_or_byte2
2501 && char2b
->byte2
<= font
->max_char_or_byte2
)
2502 pcm
= font
->bounds
.per_char
2503 + (char2b
->byte2
- font
->min_char_or_byte2
);
2507 /* If either min_byte1 or max_byte1 are nonzero, both
2508 min_char_or_byte2 and max_char_or_byte2 are less than
2509 256, and the 2-byte character index values corresponding
2510 to the per_char array element N (counting from 0) are:
2512 byte1 = N/D + min_byte1
2513 byte2 = N\D + min_char_or_byte2
2517 D = max_char_or_byte2 - min_char_or_byte2 + 1
2518 / = integer division
2519 \ = integer modulus */
2520 if (char2b
->byte1
>= font
->min_byte1
2521 && char2b
->byte1
<= font
->max_byte1
2522 && char2b
->byte2
>= font
->min_char_or_byte2
2523 && char2b
->byte2
<= font
->max_char_or_byte2
)
2525 pcm
= (font
->bounds
.per_char
2526 + ((font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1)
2527 * (char2b
->byte1
- font
->min_byte1
))
2528 + (char2b
->byte2
- font
->min_char_or_byte2
));
2534 /* If the per_char pointer is null, all glyphs between the first
2535 and last character indexes inclusive have the same
2536 information, as given by both min_bounds and max_bounds. */
2537 if (char2b
->byte2
>= font
->min_char_or_byte2
2538 && char2b
->byte2
<= font
->max_char_or_byte2
)
2539 pcm
= &font
->max_bounds
;
2545 return ((pcm
== NULL
2547 #if 0 /* Show hollow boxes for zero-width glyphs such as combining diacritics. */
2548 && (pcm
->rbearing
- pcm
->lbearing
) == 0
2557 static XCharStruct
*
2558 mac_per_char_metric (font
, char2b
, font_type
)
2563 return x_per_char_metric (font
, char2b
);
2567 Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
2568 the two-byte form of C. Encoding is returned in *CHAR2B. */
2571 mac_encode_char (c
, char2b
, font_info
, charset
, two_byte_p
)
2574 struct font_info
*font_info
;
2575 struct charset
*charset
;
2578 XFontStruct
*font
= font_info
->font
;
2580 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
2581 This may be either a program in a special encoder language or a
2583 if (font_info
->font_encoder
)
2585 /* It's a program. */
2586 struct ccl_program
*ccl
= font_info
->font_encoder
;
2588 check_ccl_update (ccl
);
2589 if (CHARSET_DIMENSION (charset
) == 1)
2591 ccl
->reg
[0] = CHARSET_ID (charset
);
2592 ccl
->reg
[1] = XCHAR2B_BYTE2 (char2b
);
2597 ccl
->reg
[0] = CHARSET_ID (charset
);
2598 ccl
->reg
[1] = XCHAR2B_BYTE1 (char2b
);
2599 ccl
->reg
[2] = XCHAR2B_BYTE2 (char2b
);
2602 ccl_driver (ccl
, NULL
, NULL
, 0, 0, Qnil
);
2604 /* We assume that MSBs are appropriately set/reset by CCL
2606 if (font
->max_byte1
== 0) /* 1-byte font */
2607 STORE_XCHAR2B (char2b
, 0, ccl
->reg
[1]);
2609 STORE_XCHAR2B (char2b
, ccl
->reg
[1], ccl
->reg
[2]);
2611 else if (font_info
->encoding_type
)
2613 /* Fixed encoding scheme. See fontset.h for the meaning of the
2614 encoding numbers. */
2615 unsigned char enc
= font_info
->encoding_type
;
2617 if ((enc
== 1 || enc
== 2)
2618 && CHARSET_DIMENSION (charset
) == 2)
2619 char2b
->byte1
|= 0x80;
2621 if (enc
== 1 || enc
== 3)
2622 char2b
->byte2
|= 0x80;
2626 int code
= (char2b
->byte1
<< 8) | char2b
->byte2
;
2629 STORE_XCHAR2B (char2b
, (code
>> 8), (code
& 0xFF));
2634 *two_byte_p
= ((XFontStruct
*) (font_info
->font
))->max_byte1
> 0;
2636 return FONT_TYPE_UNKNOWN
;
2641 /***********************************************************************
2643 ***********************************************************************/
2647 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
2648 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
2649 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
2651 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
2652 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
2653 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
2654 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
2655 static void mac_compute_glyph_string_overhangs
P_ ((struct glyph_string
*));
2656 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
2657 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
2658 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
2659 /*static int x_alloc_lighter_color P_ ((struct frame *, Display *, Colormap,
2660 unsigned long *, double, int));*/
2661 static void x_setup_relief_color
P_ ((struct frame
*, struct relief
*,
2662 double, int, unsigned long));
2663 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
2664 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
2665 static void x_draw_image_relief
P_ ((struct glyph_string
*));
2666 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
2667 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
2669 static void x_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
2670 int, int, int, int, int, int,
2672 static void x_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
2673 int, int, int, Rect
*));
2676 static void x_check_font
P_ ((struct frame
*, XFontStruct
*));
2680 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
2685 struct glyph_string
*s
;
2687 if (s
->font
== FRAME_FONT (s
->f
)
2688 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
2689 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
2691 s
->gc
= s
->f
->output_data
.mac
->cursor_gc
;
2694 /* Cursor on non-default face: must merge. */
2698 xgcv
.background
= s
->f
->output_data
.mac
->cursor_pixel
;
2699 xgcv
.foreground
= s
->face
->background
;
2701 /* If the glyph would be invisible, try a different foreground. */
2702 if (xgcv
.foreground
== xgcv
.background
)
2703 xgcv
.foreground
= s
->face
->foreground
;
2704 if (xgcv
.foreground
== xgcv
.background
)
2705 xgcv
.foreground
= s
->f
->output_data
.mac
->cursor_foreground_pixel
;
2706 if (xgcv
.foreground
== xgcv
.background
)
2707 xgcv
.foreground
= s
->face
->foreground
;
2709 /* Make sure the cursor is distinct from text in this face. */
2710 if (xgcv
.background
== s
->face
->background
2711 && xgcv
.foreground
== s
->face
->foreground
)
2713 xgcv
.background
= s
->face
->foreground
;
2714 xgcv
.foreground
= s
->face
->background
;
2717 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2718 xgcv
.font
= s
->font
;
2719 mask
= GCForeground
| GCBackground
| GCFont
;
2721 if (FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2722 XChangeGC (s
->display
, FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2725 FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2726 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
2728 s
->gc
= FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2733 /* Set up S->gc of glyph string S for drawing text in mouse face. */
2736 x_set_mouse_face_gc (s
)
2737 struct glyph_string
*s
;
2742 /* What face has to be used last for the mouse face? */
2743 face_id
= FRAME_X_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
2744 face
= FACE_FROM_ID (s
->f
, face_id
);
2746 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
2748 if (s
->first_glyph
->type
== CHAR_GLYPH
)
2749 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
, -1, Qnil
);
2751 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0, -1, Qnil
);
2752 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
2753 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
2755 /* If font in this face is same as S->font, use it. */
2756 if (s
->font
== s
->face
->font
)
2757 s
->gc
= s
->face
->gc
;
2760 /* Otherwise construct scratch_cursor_gc with values from FACE
2765 xgcv
.background
= s
->face
->background
;
2766 xgcv
.foreground
= s
->face
->foreground
;
2767 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2768 xgcv
.font
= s
->font
;
2769 mask
= GCForeground
| GCBackground
| GCFont
;
2771 if (FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2772 XChangeGC (s
->display
, FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2775 FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2776 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
2778 s
->gc
= FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2781 xassert (s
->gc
!= 0);
2785 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
2786 Faces to use in the mode line have already been computed when the
2787 matrix was built, so there isn't much to do, here. */
2790 x_set_mode_line_face_gc (s
)
2791 struct glyph_string
*s
;
2793 s
->gc
= s
->face
->gc
;
2797 /* Set S->gc of glyph string S for drawing that glyph string. Set
2798 S->stippled_p to a non-zero value if the face of S has a stipple
2802 x_set_glyph_string_gc (s
)
2803 struct glyph_string
*s
;
2805 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
2807 if (s
->hl
== DRAW_NORMAL_TEXT
)
2809 s
->gc
= s
->face
->gc
;
2810 s
->stippled_p
= s
->face
->stipple
!= 0;
2812 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
2814 x_set_mode_line_face_gc (s
);
2815 s
->stippled_p
= s
->face
->stipple
!= 0;
2817 else if (s
->hl
== DRAW_CURSOR
)
2819 x_set_cursor_gc (s
);
2822 else if (s
->hl
== DRAW_MOUSE_FACE
)
2824 x_set_mouse_face_gc (s
);
2825 s
->stippled_p
= s
->face
->stipple
!= 0;
2827 else if (s
->hl
== DRAW_IMAGE_RAISED
2828 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2830 s
->gc
= s
->face
->gc
;
2831 s
->stippled_p
= s
->face
->stipple
!= 0;
2835 s
->gc
= s
->face
->gc
;
2836 s
->stippled_p
= s
->face
->stipple
!= 0;
2839 /* GC must have been set. */
2840 xassert (s
->gc
!= 0);
2844 /* Set clipping for output of glyph string S. S may be part of a mode
2845 line or menu if we don't have X toolkit support. */
2848 x_set_glyph_string_clipping (s
)
2849 struct glyph_string
*s
;
2851 Rect rects
[MAX_CLIP_RECTS
];
2854 n
= get_glyph_string_clip_rects (s
, rects
, MAX_CLIP_RECTS
);
2855 mac_set_clip_rectangles (s
->display
, s
->gc
, rects
, n
);
2860 Compute left and right overhang of glyph string S. If S is a glyph
2861 string for a composition, assume overhangs don't exist. */
2864 mac_compute_glyph_string_overhangs (s
)
2865 struct glyph_string
*s
;
2867 if (!(s
->cmp
== NULL
2868 && s
->first_glyph
->type
== CHAR_GLYPH
))
2873 || s
->font
->mac_style
2879 mac_text_extents_16 (s
->font
, s
->char2b
, s
->nchars
, &cs
);
2880 s
->right_overhang
= cs
.rbearing
> cs
.width
? cs
.rbearing
- cs
.width
: 0;
2881 s
->left_overhang
= cs
.lbearing
< 0 ? -cs
.lbearing
: 0;
2886 MacFontStruct
*font
= s
->font
;
2889 mac_prepare_for_quickdraw (s
->f
);
2891 SetPortWindowPort (FRAME_MAC_WINDOW (s
->f
));
2893 TextFont (font
->mac_fontnum
);
2894 TextSize (font
->mac_fontsize
);
2895 TextFace (font
->mac_fontface
);
2897 QDTextBounds (s
->nchars
* 2, (char *)s
->char2b
, &r
);
2899 s
->right_overhang
= r
.right
> s
->width
? r
.right
- s
->width
: 0;
2900 s
->left_overhang
= r
.left
< 0 ? -r
.left
: 0;
2905 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
2908 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
2909 struct glyph_string
*s
;
2912 mac_erase_rectangle (s
->f
, s
->gc
, x
, y
, w
, h
);
2916 /* Draw the background of glyph_string S. If S->background_filled_p
2917 is non-zero don't draw it. FORCE_P non-zero means draw the
2918 background even if it wouldn't be drawn normally. This is used
2919 when a string preceding S draws into the background of S, or S
2920 contains the first component of a composition. */
2923 x_draw_glyph_string_background (s
, force_p
)
2924 struct glyph_string
*s
;
2927 /* Nothing to do if background has already been drawn or if it
2928 shouldn't be drawn in the first place. */
2929 if (!s
->background_filled_p
)
2931 int box_line_width
= max (s
->face
->box_line_width
, 0);
2933 #if 0 /* MAC_TODO: stipple */
2936 /* Fill background with a stipple pattern. */
2937 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2938 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
2939 s
->y
+ box_line_width
,
2940 s
->background_width
,
2941 s
->height
- 2 * box_line_width
);
2942 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2943 s
->background_filled_p
= 1;
2947 if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
2948 || s
->font_not_found_p
2949 || s
->extends_to_end_of_line_p
2952 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
2953 s
->background_width
,
2954 s
->height
- 2 * box_line_width
);
2955 s
->background_filled_p
= 1;
2961 /* Draw the foreground of glyph string S. */
2964 x_draw_glyph_string_foreground (s
)
2965 struct glyph_string
*s
;
2969 /* If first glyph of S has a left box line, start drawing the text
2970 of S to the right of that box line. */
2971 if (s
->face
->box
!= FACE_NO_BOX
2972 && s
->first_glyph
->left_box_line_p
)
2973 x
= s
->x
+ eabs (s
->face
->box_line_width
);
2977 /* Draw characters of S as rectangles if S's font could not be
2979 if (s
->font_not_found_p
)
2981 for (i
= 0; i
< s
->nchars
; ++i
)
2983 struct glyph
*g
= s
->first_glyph
+ i
;
2984 mac_draw_rectangle (s
->f
, s
->gc
, x
, s
->y
,
2985 g
->pixel_width
- 1, s
->height
- 1);
2986 x
+= g
->pixel_width
;
2991 char *char1b
= (char *) s
->char2b
;
2992 int boff
= s
->font_info
->baseline_offset
;
2994 if (s
->font_info
->vertical_centering
)
2995 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
2997 /* If we can use 8-bit functions, condense S->char2b. */
3000 && GC_FONT (s
->gc
)->mac_style
== NULL
3003 for (i
= 0; i
< s
->nchars
; ++i
)
3004 char1b
[i
] = s
->char2b
[i
].byte2
;
3006 /* Draw text with XDrawString if background has already been
3007 filled. Otherwise, use XDrawImageString. (Note that
3008 XDrawImageString is usually faster than XDrawString.) Always
3009 use XDrawImageString when drawing the cursor so that there is
3010 no chance that characters under a box cursor are invisible. */
3012 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
3013 bg_width
= 0; /* Corresponds to XDrawString. */
3015 bg_width
= s
->background_width
; /* Corresponds to XDrawImageString. */
3019 || GC_FONT (s
->gc
)->mac_style
3022 #if USE_CG_TEXT_DRAWING
3024 && mac_draw_image_string_cg (s
->f
, s
->gc
, x
, s
->ybase
- boff
,
3025 s
->char2b
, s
->nchars
, bg_width
,
3026 s
->face
->overstrike
))
3030 mac_draw_image_string_16 (s
->f
, s
->gc
, x
, s
->ybase
- boff
,
3031 s
->char2b
, s
->nchars
, bg_width
,
3032 s
->face
->overstrike
);
3034 mac_draw_image_string (s
->f
, s
->gc
, x
, s
->ybase
- boff
,
3035 char1b
, s
->nchars
, bg_width
,
3036 s
->face
->overstrike
);
3040 /* Draw the foreground of composite glyph string S. */
3043 x_draw_composite_glyph_string_foreground (s
)
3044 struct glyph_string
*s
;
3048 /* If first glyph of S has a left box line, start drawing the text
3049 of S to the right of that box line. */
3050 if (s
->face
->box
!= FACE_NO_BOX
3051 && s
->first_glyph
->left_box_line_p
)
3052 x
= s
->x
+ eabs (s
->face
->box_line_width
);
3056 /* S is a glyph string for a composition. S->gidx is the index of
3057 the first character drawn for glyphs of this composition.
3058 S->gidx == 0 means we are drawing the very first character of
3059 this composition. */
3061 /* Draw a rectangle for the composition if the font for the very
3062 first character of the composition could not be loaded. */
3063 if (s
->font_not_found_p
)
3066 mac_draw_rectangle (s
->f
, s
->gc
, x
, s
->y
,
3067 s
->width
- 1, s
->height
- 1);
3071 for (i
= 0; i
< s
->nchars
; i
++, ++s
->gidx
)
3072 if (mac_per_char_metric (GC_FONT (s
->gc
), s
->char2b
+ i
, 0) == NULL
)
3073 /* This is a nonexistent or zero-width glyph such as a
3074 combining diacritic. Draw a rectangle. */
3075 mac_draw_rectangle (s
->f
, s
->gc
,
3076 x
+ s
->cmp
->offsets
[s
->gidx
* 2], s
->y
,
3077 FONT_WIDTH (GC_FONT (s
->gc
)) - 1, s
->height
- 1);
3079 mac_draw_image_string_16 (s
->f
, s
->gc
,
3080 x
+ s
->cmp
->offsets
[s
->gidx
* 2],
3081 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
3082 s
->char2b
+ i
, 1, 0, s
->face
->overstrike
);
3087 #ifdef USE_X_TOOLKIT
3089 static struct frame
*x_frame_of_widget
P_ ((Widget
));
3092 /* Return the frame on which widget WIDGET is used.. Abort if frame
3093 cannot be determined. */
3095 static struct frame
*
3096 x_frame_of_widget (widget
)
3099 struct x_display_info
*dpyinfo
;
3103 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
3105 /* Find the top-level shell of the widget. Note that this function
3106 can be called when the widget is not yet realized, so XtWindow
3107 (widget) == 0. That's the reason we can't simply use
3108 x_any_window_to_frame. */
3109 while (!XtIsTopLevelShell (widget
))
3110 widget
= XtParent (widget
);
3112 /* Look for a frame with that top-level widget. Allocate the color
3113 on that frame to get the right gamma correction value. */
3114 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
3115 if (FRAMEP (XCAR (tail
))
3116 && (f
= XFRAME (XCAR (tail
)),
3117 (f
->output_data
.nothing
!= 1
3118 && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
))
3119 && f
->output_data
.x
->widget
== widget
)
3126 /* Allocate the color COLOR->pixel on the screen and display of
3127 widget WIDGET in colormap CMAP. If an exact match cannot be
3128 allocated, try the nearest color available. Value is non-zero
3129 if successful. This is called from lwlib. */
3132 x_alloc_nearest_color_for_widget (widget
, cmap
, color
)
3137 struct frame
*f
= x_frame_of_widget (widget
);
3138 return x_alloc_nearest_color (f
, cmap
, color
);
3142 #endif /* USE_X_TOOLKIT */
3144 #if 0 /* MAC_TODO */
3146 /* Allocate the color COLOR->pixel on SCREEN of DISPLAY, colormap
3147 CMAP. If an exact match can't be allocated, try the nearest color
3148 available. Value is non-zero if successful. Set *COLOR to the
3152 x_alloc_nearest_color (f
, cmap
, color
)
3157 Display
*display
= FRAME_X_DISPLAY (f
);
3158 Screen
*screen
= FRAME_X_SCREEN (f
);
3161 gamma_correct (f
, color
);
3162 rc
= XAllocColor (display
, cmap
, color
);
3165 /* If we got to this point, the colormap is full, so we're going
3166 to try to get the next closest color. The algorithm used is
3167 a least-squares matching, which is what X uses for closest
3168 color matching with StaticColor visuals. */
3170 unsigned long nearest_delta
= ~0;
3171 int ncells
= XDisplayCells (display
, XScreenNumberOfScreen (screen
));
3172 XColor
*cells
= (XColor
*) alloca (ncells
* sizeof *cells
);
3174 for (i
= 0; i
< ncells
; ++i
)
3176 XQueryColors (display
, cmap
, cells
, ncells
);
3178 for (nearest
= i
= 0; i
< ncells
; ++i
)
3180 long dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
3181 long dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
3182 long dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
3183 unsigned long delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
3185 if (delta
< nearest_delta
)
3188 nearest_delta
= delta
;
3192 color
->red
= cells
[nearest
].red
;
3193 color
->green
= cells
[nearest
].green
;
3194 color
->blue
= cells
[nearest
].blue
;
3195 rc
= XAllocColor (display
, cmap
, color
);
3198 #ifdef DEBUG_X_COLORS
3200 register_color (color
->pixel
);
3201 #endif /* DEBUG_X_COLORS */
3207 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
3208 It's necessary to do this instead of just using PIXEL directly to
3209 get color reference counts right. */
3212 x_copy_color (f
, pixel
)
3214 unsigned long pixel
;
3218 color
.pixel
= pixel
;
3220 XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
3221 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
3223 #ifdef DEBUG_X_COLORS
3224 register_color (pixel
);
3230 /* Allocate color PIXEL on display DPY. PIXEL must already be allocated.
3231 It's necessary to do this instead of just using PIXEL directly to
3232 get color reference counts right. */
3235 x_copy_dpy_color (dpy
, cmap
, pixel
)
3238 unsigned long pixel
;
3242 color
.pixel
= pixel
;
3244 XQueryColor (dpy
, cmap
, &color
);
3245 XAllocColor (dpy
, cmap
, &color
);
3247 #ifdef DEBUG_X_COLORS
3248 register_color (pixel
);
3253 #endif /* MAC_TODO */
3256 /* Brightness beyond which a color won't have its highlight brightness
3259 Nominally, highlight colors for `3d' faces are calculated by
3260 brightening an object's color by a constant scale factor, but this
3261 doesn't yield good results for dark colors, so for colors who's
3262 brightness is less than this value (on a scale of 0-255) have to
3263 use an additional additive factor.
3265 The value here is set so that the default menu-bar/mode-line color
3266 (grey75) will not have its highlights changed at all. */
3267 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
3270 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
3271 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3272 If this produces the same color as COLOR, try a color where all RGB
3273 values have DELTA added. Return the allocated color in *COLOR.
3274 DISPLAY is the X display, CMAP is the colormap to operate on.
3275 Value is non-zero if successful. */
3278 mac_alloc_lighter_color (f
, color
, factor
, delta
)
3280 unsigned long *color
;
3287 /* On Mac, RGB values are 0-255, not 0-65535, so scale delta. */
3290 /* Change RGB values by specified FACTOR. Avoid overflow! */
3291 xassert (factor
>= 0);
3292 new = RGB_TO_ULONG (min (0xff, (int) (factor
* RED_FROM_ULONG (*color
))),
3293 min (0xff, (int) (factor
* GREEN_FROM_ULONG (*color
))),
3294 min (0xff, (int) (factor
* BLUE_FROM_ULONG (*color
))));
3296 /* Calculate brightness of COLOR. */
3297 bright
= (2 * RED_FROM_ULONG (*color
) + 3 * GREEN_FROM_ULONG (*color
)
3298 + BLUE_FROM_ULONG (*color
)) / 6;
3300 /* We only boost colors that are darker than
3301 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
3302 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
3303 /* Make an additive adjustment to NEW, because it's dark enough so
3304 that scaling by FACTOR alone isn't enough. */
3306 /* How far below the limit this color is (0 - 1, 1 being darker). */
3307 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
3308 /* The additive adjustment. */
3309 int min_delta
= delta
* dimness
* factor
/ 2;
3312 new = RGB_TO_ULONG (max (0, min (0xff, (int) (RED_FROM_ULONG (*color
)) - min_delta
)),
3313 max (0, min (0xff, (int) (GREEN_FROM_ULONG (*color
)) - min_delta
)),
3314 max (0, min (0xff, (int) (BLUE_FROM_ULONG (*color
)) - min_delta
)));
3316 new = RGB_TO_ULONG (max (0, min (0xff, (int) (min_delta
+ RED_FROM_ULONG (*color
)))),
3317 max (0, min (0xff, (int) (min_delta
+ GREEN_FROM_ULONG (*color
)))),
3318 max (0, min (0xff, (int) (min_delta
+ BLUE_FROM_ULONG (*color
)))));
3322 new = RGB_TO_ULONG (max (0, min (0xff, (int) (delta
+ RED_FROM_ULONG (*color
)))),
3323 max (0, min (0xff, (int) (delta
+ GREEN_FROM_ULONG (*color
)))),
3324 max (0, min (0xff, (int) (delta
+ BLUE_FROM_ULONG (*color
)))));
3326 /* MAC_TODO: Map to palette and retry with delta if same? */
3327 /* MAC_TODO: Free colors (if using palette)? */
3338 /* Set up the foreground color for drawing relief lines of glyph
3339 string S. RELIEF is a pointer to a struct relief containing the GC
3340 with which lines will be drawn. Use a color that is FACTOR or
3341 DELTA lighter or darker than the relief's background which is found
3342 in S->f->output_data.x->relief_background. If such a color cannot
3343 be allocated, use DEFAULT_PIXEL, instead. */
3346 x_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
3348 struct relief
*relief
;
3351 unsigned long default_pixel
;
3354 struct mac_output
*di
= f
->output_data
.mac
;
3355 unsigned long mask
= GCForeground
;
3356 unsigned long pixel
;
3357 unsigned long background
= di
->relief_background
;
3358 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
3360 /* MAC_TODO: Free colors (if using palette)? */
3362 /* Allocate new color. */
3363 xgcv
.foreground
= default_pixel
;
3365 if (dpyinfo
->n_planes
!= 1
3366 && mac_alloc_lighter_color (f
, &pixel
, factor
, delta
))
3368 relief
->allocated_p
= 1;
3369 xgcv
.foreground
= relief
->pixel
= pixel
;
3372 if (relief
->gc
== 0)
3374 #if 0 /* MAC_TODO: stipple */
3375 xgcv
.stipple
= dpyinfo
->gray
;
3378 relief
->gc
= XCreateGC (NULL
, FRAME_MAC_WINDOW (f
), mask
, &xgcv
);
3381 XChangeGC (NULL
, relief
->gc
, mask
, &xgcv
);
3385 /* Set up colors for the relief lines around glyph string S. */
3388 x_setup_relief_colors (s
)
3389 struct glyph_string
*s
;
3391 struct mac_output
*di
= s
->f
->output_data
.mac
;
3392 unsigned long color
;
3394 if (s
->face
->use_box_color_for_shadows_p
)
3395 color
= s
->face
->box_color
;
3396 else if (s
->first_glyph
->type
== IMAGE_GLYPH
3398 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
3399 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
3404 /* Get the background color of the face. */
3405 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
3406 color
= xgcv
.background
;
3409 if (di
->white_relief
.gc
== 0
3410 || color
!= di
->relief_background
)
3412 di
->relief_background
= color
;
3413 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
3414 WHITE_PIX_DEFAULT (s
->f
));
3415 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
3416 BLACK_PIX_DEFAULT (s
->f
));
3421 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
3422 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
3423 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
3424 relief. LEFT_P non-zero means draw a relief on the left side of
3425 the rectangle. RIGHT_P non-zero means draw a relief on the right
3426 side of the rectangle. CLIP_RECT is the clipping rectangle to use
3430 x_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
3431 raised_p
, top_p
, bot_p
, left_p
, right_p
, clip_rect
)
3433 int left_x
, top_y
, right_x
, bottom_y
, width
;
3434 int top_p
, bot_p
, left_p
, right_p
, raised_p
;
3437 Display
*dpy
= FRAME_MAC_DISPLAY (f
);
3442 gc
= f
->output_data
.mac
->white_relief
.gc
;
3444 gc
= f
->output_data
.mac
->black_relief
.gc
;
3445 mac_set_clip_rectangles (dpy
, gc
, clip_rect
, 1);
3449 for (i
= 0; i
< width
; ++i
)
3450 mac_draw_line (f
, gc
,
3451 left_x
+ i
* left_p
, top_y
+ i
,
3452 right_x
+ 1 - i
* right_p
, top_y
+ i
);
3456 for (i
= 0; i
< width
; ++i
)
3457 mac_draw_line (f
, gc
,
3458 left_x
+ i
, top_y
+ i
, left_x
+ i
, bottom_y
- i
+ 1);
3460 mac_reset_clip_rectangles (dpy
, gc
);
3462 gc
= f
->output_data
.mac
->black_relief
.gc
;
3464 gc
= f
->output_data
.mac
->white_relief
.gc
;
3465 mac_set_clip_rectangles (dpy
, gc
, clip_rect
, 1);
3469 for (i
= 0; i
< width
; ++i
)
3470 mac_draw_line (f
, gc
,
3471 left_x
+ i
* left_p
, bottom_y
- i
,
3472 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
3476 for (i
= 0; i
< width
; ++i
)
3477 mac_draw_line (f
, gc
,
3478 right_x
- i
, top_y
+ i
+ 1, right_x
- i
, bottom_y
- i
);
3480 mac_reset_clip_rectangles (dpy
, gc
);
3484 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
3485 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
3486 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
3487 left side of the rectangle. RIGHT_P non-zero means draw a line
3488 on the right side of the rectangle. CLIP_RECT is the clipping
3489 rectangle to use when drawing. */
3492 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3493 left_p
, right_p
, clip_rect
)
3494 struct glyph_string
*s
;
3495 int left_x
, top_y
, right_x
, bottom_y
, width
, left_p
, right_p
;
3500 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3501 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
3502 mac_set_clip_rectangles (s
->display
, s
->gc
, clip_rect
, 1);
3505 mac_fill_rectangle (s
->f
, s
->gc
, left_x
, top_y
,
3506 right_x
- left_x
+ 1, width
);
3510 mac_fill_rectangle (s
->f
, s
->gc
, left_x
, top_y
,
3511 width
, bottom_y
- top_y
+ 1);
3514 mac_fill_rectangle (s
->f
, s
->gc
, left_x
, bottom_y
- width
+ 1,
3515 right_x
- left_x
+ 1, width
);
3519 mac_fill_rectangle (s
->f
, s
->gc
, right_x
- width
+ 1,
3520 top_y
, width
, bottom_y
- top_y
+ 1);
3522 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3523 mac_reset_clip_rectangles (s
->display
, s
->gc
);
3527 /* Draw a box around glyph string S. */
3530 x_draw_glyph_string_box (s
)
3531 struct glyph_string
*s
;
3533 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
3534 int left_p
, right_p
;
3535 struct glyph
*last_glyph
;
3538 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
3539 ? WINDOW_RIGHT_EDGE_X (s
->w
)
3540 : window_box_right (s
->w
, s
->area
));
3542 /* The glyph that may have a right box line. */
3543 last_glyph
= (s
->cmp
|| s
->img
3545 : s
->first_glyph
+ s
->nchars
- 1);
3547 width
= eabs (s
->face
->box_line_width
);
3548 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
3550 right_x
= (s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
3552 : min (last_x
, s
->x
+ s
->background_width
) - 1);
3554 bottom_y
= top_y
+ s
->height
- 1;
3556 left_p
= (s
->first_glyph
->left_box_line_p
3557 || (s
->hl
== DRAW_MOUSE_FACE
3559 || s
->prev
->hl
!= s
->hl
)));
3560 right_p
= (last_glyph
->right_box_line_p
3561 || (s
->hl
== DRAW_MOUSE_FACE
3563 || s
->next
->hl
!= s
->hl
)));
3565 get_glyph_string_clip_rect (s
, &clip_rect
);
3567 if (s
->face
->box
== FACE_SIMPLE_BOX
)
3568 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3569 left_p
, right_p
, &clip_rect
);
3572 x_setup_relief_colors (s
);
3573 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
3574 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
3579 /* Draw foreground of image glyph string S. */
3582 x_draw_image_foreground (s
)
3583 struct glyph_string
*s
;
3586 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
3588 /* If first glyph of S has a left box line, start drawing it to the
3589 right of that line. */
3590 if (s
->face
->box
!= FACE_NO_BOX
3591 && s
->first_glyph
->left_box_line_p
3593 x
+= eabs (s
->face
->box_line_width
);
3595 /* If there is a margin around the image, adjust x- and y-position
3597 if (s
->slice
.x
== 0)
3598 x
+= s
->img
->hmargin
;
3599 if (s
->slice
.y
== 0)
3600 y
+= s
->img
->vmargin
;
3604 x_set_glyph_string_clipping (s
);
3607 mac_draw_cg_image (s
->img
->data
.ptr_val
,
3608 s
->f
, s
->gc
, s
->slice
.x
, s
->slice
.y
,
3609 s
->slice
.width
, s
->slice
.height
, x
, y
, 1);
3613 mac_copy_area_with_mask (s
->img
->pixmap
, s
->img
->mask
,
3614 s
->f
, s
->gc
, s
->slice
.x
, s
->slice
.y
,
3615 s
->slice
.width
, s
->slice
.height
, x
, y
);
3622 mac_copy_area (s
->img
->pixmap
,
3623 s
->f
, s
->gc
, s
->slice
.x
, s
->slice
.y
,
3624 s
->slice
.width
, s
->slice
.height
, x
, y
);
3627 /* When the image has a mask, we can expect that at
3628 least part of a mouse highlight or a block cursor will
3629 be visible. If the image doesn't have a mask, make
3630 a block cursor visible by drawing a rectangle around
3631 the image. I believe it's looking better if we do
3632 nothing here for mouse-face. */
3633 if (s
->hl
== DRAW_CURSOR
)
3635 int r
= s
->img
->relief
;
3637 mac_draw_rectangle (s
->f
, s
->gc
, x
- r
, y
- r
,
3638 s
->slice
.width
+ r
*2 - 1,
3639 s
->slice
.height
+ r
*2 - 1);
3644 /* Draw a rectangle if image could not be loaded. */
3645 mac_draw_rectangle (s
->f
, s
->gc
, x
, y
,
3646 s
->slice
.width
- 1, s
->slice
.height
- 1);
3650 /* Draw a relief around the image glyph string S. */
3653 x_draw_image_relief (s
)
3654 struct glyph_string
*s
;
3656 int x0
, y0
, x1
, y1
, thick
, raised_p
;
3659 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
3661 /* If first glyph of S has a left box line, start drawing it to the
3662 right of that line. */
3663 if (s
->face
->box
!= FACE_NO_BOX
3664 && s
->first_glyph
->left_box_line_p
3666 x
+= eabs (s
->face
->box_line_width
);
3668 /* If there is a margin around the image, adjust x- and y-position
3670 if (s
->slice
.x
== 0)
3671 x
+= s
->img
->hmargin
;
3672 if (s
->slice
.y
== 0)
3673 y
+= s
->img
->vmargin
;
3675 if (s
->hl
== DRAW_IMAGE_SUNKEN
3676 || s
->hl
== DRAW_IMAGE_RAISED
)
3678 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
3679 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
3683 thick
= eabs (s
->img
->relief
);
3684 raised_p
= s
->img
->relief
> 0;
3689 x1
= x
+ s
->slice
.width
+ thick
- 1;
3690 y1
= y
+ s
->slice
.height
+ thick
- 1;
3692 x_setup_relief_colors (s
);
3693 get_glyph_string_clip_rect (s
, &r
);
3694 x_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
,
3696 s
->slice
.y
+ s
->slice
.height
== s
->img
->height
,
3698 s
->slice
.x
+ s
->slice
.width
== s
->img
->width
,
3703 /* Draw part of the background of glyph string S. X, Y, W, and H
3704 give the rectangle to draw. */
3707 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
3708 struct glyph_string
*s
;
3711 #if 0 /* MAC_TODO: stipple */
3714 /* Fill background with a stipple pattern. */
3715 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3716 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
3717 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3720 #endif /* MAC_TODO */
3721 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
3725 /* Draw image glyph string S.
3728 s->x +-------------------------
3731 | +-------------------------
3734 | | +-------------------
3740 x_draw_image_glyph_string (s
)
3741 struct glyph_string
*s
;
3744 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
3745 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
3748 height
= s
->height
- 2 * box_line_vwidth
;
3751 /* Fill background with face under the image. Do it only if row is
3752 taller than image or if image has a clip mask to reduce
3754 s
->stippled_p
= s
->face
->stipple
!= 0;
3755 if (height
> s
->slice
.height
3759 || s
->img
->pixmap
== 0
3760 || s
->width
!= s
->background_width
)
3763 if (s
->first_glyph
->left_box_line_p
3765 x
+= box_line_hwidth
;
3768 if (s
->slice
.y
== 0)
3769 y
+= box_line_vwidth
;
3771 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
3773 s
->background_filled_p
= 1;
3776 /* Draw the foreground. */
3777 x_draw_image_foreground (s
);
3779 /* If we must draw a relief around the image, do it. */
3781 || s
->hl
== DRAW_IMAGE_RAISED
3782 || s
->hl
== DRAW_IMAGE_SUNKEN
)
3783 x_draw_image_relief (s
);
3787 /* Draw stretch glyph string S. */
3790 x_draw_stretch_glyph_string (s
)
3791 struct glyph_string
*s
;
3793 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
3795 if (s
->hl
== DRAW_CURSOR
3796 && !x_stretch_cursor_p
)
3798 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
3799 as wide as the stretch glyph. */
3800 int width
, background_width
= s
->background_width
;
3801 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
3805 background_width
-= left_x
- x
;
3808 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
3811 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
3813 /* Clear rest using the GC of the original non-cursor face. */
3814 if (width
< background_width
)
3817 int w
= background_width
- width
, h
= s
->height
;
3822 if (s
->row
->mouse_face_p
3823 && cursor_in_mouse_face_p (s
->w
))
3825 x_set_mouse_face_gc (s
);
3831 get_glyph_string_clip_rect (s
, &r
);
3832 mac_set_clip_rectangles (s
->display
, gc
, &r
, 1);
3834 #if 0 /* MAC_TODO: stipple */
3835 if (s
->face
->stipple
)
3837 /* Fill background with a stipple pattern. */
3838 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
3839 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
3840 XSetFillStyle (s
->display
, gc
, FillSolid
);
3843 #endif /* MAC_TODO */
3844 mac_erase_rectangle (s
->f
, gc
, x
, y
, w
, h
);
3847 else if (!s
->background_filled_p
)
3849 int background_width
= s
->background_width
;
3850 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
3852 /* Don't draw into left margin, fringe or scrollbar area
3853 except for header line and mode line. */
3854 if (x
< left_x
&& !s
->row
->mode_line_p
)
3856 background_width
-= left_x
- x
;
3859 if (background_width
> 0)
3860 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
3863 s
->background_filled_p
= 1;
3867 /* Draw glyph string S. */
3870 x_draw_glyph_string (s
)
3871 struct glyph_string
*s
;
3873 int relief_drawn_p
= 0;
3875 /* If S draws into the background of its successor that does not
3876 draw a cursor, draw the background of the successor first so that
3877 S can draw into it. This makes S->next use XDrawString instead
3878 of XDrawImageString. */
3879 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
3880 && s
->next
->hl
!= DRAW_CURSOR
)
3882 xassert (s
->next
->img
== NULL
);
3883 x_set_glyph_string_gc (s
->next
);
3884 x_set_glyph_string_clipping (s
->next
);
3885 x_draw_glyph_string_background (s
->next
, 1);
3888 /* Set up S->gc, set clipping and draw S. */
3889 x_set_glyph_string_gc (s
);
3891 /* Draw relief (if any) in advance for char/composition so that the
3892 glyph string can be drawn over it. */
3893 if (!s
->for_overlaps
3894 && s
->face
->box
!= FACE_NO_BOX
3895 && (s
->first_glyph
->type
== CHAR_GLYPH
3896 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
3899 x_set_glyph_string_clipping (s
);
3900 x_draw_glyph_string_background (s
, 1);
3901 x_draw_glyph_string_box (s
);
3902 x_set_glyph_string_clipping (s
);
3906 x_set_glyph_string_clipping (s
);
3908 switch (s
->first_glyph
->type
)
3911 x_draw_image_glyph_string (s
);
3915 x_draw_stretch_glyph_string (s
);
3919 if (s
->for_overlaps
)
3920 s
->background_filled_p
= 1;
3922 x_draw_glyph_string_background (s
, 0);
3923 x_draw_glyph_string_foreground (s
);
3926 case COMPOSITE_GLYPH
:
3927 if (s
->for_overlaps
|| s
->gidx
> 0)
3928 s
->background_filled_p
= 1;
3930 x_draw_glyph_string_background (s
, 1);
3931 x_draw_composite_glyph_string_foreground (s
);
3938 if (!s
->for_overlaps
)
3940 /* Draw underline. */
3941 if (s
->face
->underline_p
)
3943 unsigned long tem
, h
;
3947 /* Get the underline thickness. Default is 1 pixel. */
3948 if (!XGetFontProperty (s
->font
, XA_UNDERLINE_THICKNESS
, &h
))
3952 y
= s
->y
+ s
->height
- h
;
3953 if (!x_underline_at_descent_line
)
3955 /* Get the underline position. This is the recommended
3956 vertical offset in pixels from the baseline to the top of
3957 the underline. This is a signed value according to the
3958 specs, and its default is
3960 ROUND ((maximum descent) / 2), with
3961 ROUND(x) = floor (x + 0.5) */
3964 if (x_use_underline_position_properties
3965 && XGetFontProperty (s
->font
, XA_UNDERLINE_POSITION
, &tem
))
3966 y
= s
->ybase
+ (long) tem
;
3970 y
= s
->ybase
+ (s
->face
->font
->max_bounds
.descent
+ 1) / 2;
3973 if (s
->face
->underline_defaulted_p
)
3974 mac_fill_rectangle (s
->f
, s
->gc
, s
->x
, y
,
3975 s
->background_width
, h
);
3979 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3980 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
3981 mac_fill_rectangle (s
->f
, s
->gc
, s
->x
, y
,
3982 s
->background_width
, h
);
3983 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3987 /* Draw overline. */
3988 if (s
->face
->overline_p
)
3990 unsigned long dy
= 0, h
= 1;
3992 if (s
->face
->overline_color_defaulted_p
)
3993 mac_fill_rectangle (s
->f
, s
->gc
, s
->x
, s
->y
+ dy
,
3994 s
->background_width
, h
);
3998 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3999 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
4000 mac_fill_rectangle (s
->f
, s
->gc
, s
->x
, s
->y
+ dy
,
4001 s
->background_width
, h
);
4002 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4006 /* Draw strike-through. */
4007 if (s
->face
->strike_through_p
)
4009 unsigned long h
= 1;
4010 unsigned long dy
= (s
->height
- h
) / 2;
4012 if (s
->face
->strike_through_color_defaulted_p
)
4013 mac_fill_rectangle (s
->f
, s
->gc
, s
->x
, s
->y
+ dy
,
4018 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4019 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
4020 mac_fill_rectangle (s
->f
, s
->gc
, s
->x
, s
->y
+ dy
,
4022 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4026 /* Draw relief if not yet drawn. */
4027 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
4028 x_draw_glyph_string_box (s
);
4031 /* Reset clipping. */
4032 mac_reset_clip_rectangles (s
->display
, s
->gc
);
4035 /* Shift display to make room for inserted glyphs. */
4038 mac_shift_glyphs_for_insert (f
, x
, y
, width
, height
, shift_by
)
4040 int x
, y
, width
, height
, shift_by
;
4042 mac_scroll_area (f
, f
->output_data
.mac
->normal_gc
,
4043 x
, y
, width
, height
,
4047 /* Delete N glyphs at the nominal cursor position. Not implemented
4058 /* Clear entire frame. If updating_frame is non-null, clear that
4059 frame. Otherwise clear the selected frame. */
4062 x_clear_frame (struct frame
*f
)
4064 /* Clearing the frame will erase any cursor, so mark them all as no
4066 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
4067 output_cursor
.hpos
= output_cursor
.vpos
= 0;
4068 output_cursor
.x
= -1;
4070 /* We don't set the output cursor here because there will always
4071 follow an explicit cursor_to. */
4073 mac_clear_window (f
);
4075 /* We have to clear the scroll bars, too. If we have changed
4076 colors or something like that, then they should be notified. */
4077 x_scroll_bar_clear (f
);
4079 XFlush (FRAME_MAC_DISPLAY (f
));
4085 /* Invert the middle quarter of the frame for .15 sec. */
4087 /* We use the select system call to do the waiting, so we have to make
4088 sure it's available. If it isn't, we just won't do visual bells. */
4090 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
4093 /* Subtract the `struct timeval' values X and Y, storing the result in
4094 *RESULT. Return 1 if the difference is negative, otherwise 0. */
4097 timeval_subtract (result
, x
, y
)
4098 struct timeval
*result
, x
, y
;
4100 /* Perform the carry for the later subtraction by updating y. This
4101 is safer because on some systems the tv_sec member is unsigned. */
4102 if (x
.tv_usec
< y
.tv_usec
)
4104 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
4105 y
.tv_usec
-= 1000000 * nsec
;
4109 if (x
.tv_usec
- y
.tv_usec
> 1000000)
4111 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
4112 y
.tv_usec
+= 1000000 * nsec
;
4116 /* Compute the time remaining to wait. tv_usec is certainly
4118 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
4119 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
4121 /* Return indication of whether the result should be considered
4123 return x
.tv_sec
< y
.tv_sec
;
4130 /* Get the height not including a menu bar widget. */
4131 int height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, FRAME_LINES (f
));
4132 /* Height of each line to flash. */
4133 int flash_height
= FRAME_LINE_HEIGHT (f
);
4134 /* These will be the left and right margins of the rectangles. */
4135 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
4136 int flash_right
= FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
4140 /* Don't flash the area between a scroll bar and the frame
4141 edge it is next to. */
4142 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f
))
4144 case vertical_scroll_bar_left
:
4145 flash_left
+= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
4148 case vertical_scroll_bar_right
:
4149 flash_right
-= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
4156 width
= flash_right
- flash_left
;
4160 /* If window is tall, flash top and bottom line. */
4161 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
4163 mac_invert_rectangle (f
, flash_left
,
4164 (FRAME_INTERNAL_BORDER_WIDTH (f
)
4165 + FRAME_TOOL_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
)),
4166 width
, flash_height
);
4167 mac_invert_rectangle (f
, flash_left
,
4168 (height
- flash_height
4169 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
4170 width
, flash_height
);
4173 /* If it is short, flash it all. */
4174 mac_invert_rectangle (f
, flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
4175 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
4180 struct timeval wakeup
;
4182 EMACS_GET_TIME (wakeup
);
4184 /* Compute time to wait until, propagating carry from usecs. */
4185 wakeup
.tv_usec
+= 150000;
4186 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
4187 wakeup
.tv_usec
%= 1000000;
4189 /* Keep waiting until past the time wakeup or any input gets
4191 while (! detect_input_pending ())
4193 struct timeval current
;
4194 struct timeval timeout
;
4196 EMACS_GET_TIME (current
);
4198 /* Break if result would be negative. */
4199 if (timeval_subtract (¤t
, wakeup
, current
))
4202 /* How long `select' should wait. */
4204 timeout
.tv_usec
= 10000;
4206 /* Try to wait that long--but we might wake up sooner. */
4207 select (0, NULL
, NULL
, NULL
, &timeout
);
4211 /* If window is tall, flash top and bottom line. */
4212 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
4214 mac_invert_rectangle (f
, flash_left
,
4215 (FRAME_INTERNAL_BORDER_WIDTH (f
)
4216 + FRAME_TOOL_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
)),
4217 width
, flash_height
);
4218 mac_invert_rectangle (f
, flash_left
,
4219 (height
- flash_height
4220 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
4221 width
, flash_height
);
4224 /* If it is short, flash it all. */
4225 mac_invert_rectangle (f
, flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
4226 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
4233 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
4236 /* Make audible bell. */
4241 struct frame
*f
= SELECTED_FRAME ();
4243 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
4251 XFlush (FRAME_MAC_DISPLAY (f
));
4257 /* Specify how many text lines, from the top of the window,
4258 should be affected by insert-lines and delete-lines operations.
4259 This, and those operations, are used only within an update
4260 that is bounded by calls to x_update_begin and x_update_end. */
4263 XTset_terminal_window (n
)
4266 /* This function intentionally left blank. */
4271 /***********************************************************************
4273 ***********************************************************************/
4275 /* Perform an insert-lines or delete-lines operation, inserting N
4276 lines or deleting -N lines at vertical position VPOS. */
4279 x_ins_del_lines (vpos
, n
)
4286 /* Scroll part of the display as described by RUN. */
4289 x_scroll_run (w
, run
)
4293 struct frame
*f
= XFRAME (w
->frame
);
4294 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
4296 /* Get frame-relative bounding box of the text display area of W,
4297 without mode lines. Include in this box the left and right
4299 window_box (w
, -1, &x
, &y
, &width
, &height
);
4301 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
4302 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
4303 bottom_y
= y
+ height
;
4307 /* Scrolling up. Make sure we don't copy part of the mode
4308 line at the bottom. */
4309 if (from_y
+ run
->height
> bottom_y
)
4310 height
= bottom_y
- from_y
;
4312 height
= run
->height
;
4316 /* Scolling down. Make sure we don't copy over the mode line.
4318 if (to_y
+ run
->height
> bottom_y
)
4319 height
= bottom_y
- to_y
;
4321 height
= run
->height
;
4326 /* Cursor off. Will be switched on again in x_update_window_end. */
4330 mac_scroll_area (f
, f
->output_data
.mac
->normal_gc
,
4340 /***********************************************************************
4342 ***********************************************************************/
4349 x_update_cursor (f
, 1);
4353 frame_unhighlight (f
)
4356 x_update_cursor (f
, 1);
4359 /* The focus has changed. Update the frames as necessary to reflect
4360 the new situation. Note that we can't change the selected frame
4361 here, because the Lisp code we are interrupting might become confused.
4362 Each event gets marked with the frame in which it occurred, so the
4363 Lisp code can tell when the switch took place by examining the events. */
4366 x_new_focus_frame (dpyinfo
, frame
)
4367 struct x_display_info
*dpyinfo
;
4368 struct frame
*frame
;
4370 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
4372 if (frame
!= dpyinfo
->x_focus_frame
)
4374 /* Set this before calling other routines, so that they see
4375 the correct value of x_focus_frame. */
4376 dpyinfo
->x_focus_frame
= frame
;
4378 if (old_focus
&& old_focus
->auto_lower
)
4379 x_lower_frame (old_focus
);
4382 selected_frame
= frame
;
4383 XSETFRAME (XWINDOW (selected_frame
->selected_window
)->frame
,
4385 Fselect_window (selected_frame
->selected_window
, Qnil
);
4386 choose_minibuf_frame ();
4389 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
4390 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
4392 pending_autoraise_frame
= 0;
4394 #if USE_MAC_FONT_PANEL
4396 mac_set_font_info_for_selection (frame
, DEFAULT_FACE_ID
, 0);
4400 x_frame_rehighlight (dpyinfo
);
4403 /* Handle FocusIn and FocusOut state changes for FRAME.
4404 If FRAME has focus and there exists more than one frame, puts
4405 a FOCUS_IN_EVENT into *BUFP. */
4408 mac_focus_changed (type
, dpyinfo
, frame
, bufp
)
4410 struct mac_display_info
*dpyinfo
;
4411 struct frame
*frame
;
4412 struct input_event
*bufp
;
4414 if (type
== activeFlag
)
4416 if (dpyinfo
->x_focus_event_frame
!= frame
)
4418 x_new_focus_frame (dpyinfo
, frame
);
4419 dpyinfo
->x_focus_event_frame
= frame
;
4421 /* Don't stop displaying the initial startup message
4422 for a switch-frame event we don't need. */
4423 if (NILP (Vterminal_frame
)
4424 && CONSP (Vframe_list
)
4425 && !NILP (XCDR (Vframe_list
)))
4427 bufp
->kind
= FOCUS_IN_EVENT
;
4428 XSETFRAME (bufp
->frame_or_window
, frame
);
4434 if (dpyinfo
->x_focus_event_frame
== frame
)
4436 dpyinfo
->x_focus_event_frame
= 0;
4437 x_new_focus_frame (dpyinfo
, 0);
4442 /* The focus may have changed. Figure out if it is a real focus change,
4443 by checking both FocusIn/Out and Enter/LeaveNotify events.
4445 Returns FOCUS_IN_EVENT event in *BUFP. */
4448 x_detect_focus_change (dpyinfo
, event
, bufp
)
4449 struct mac_display_info
*dpyinfo
;
4450 const EventRecord
*event
;
4451 struct input_event
*bufp
;
4453 struct frame
*frame
;
4455 frame
= mac_window_to_frame ((WindowRef
) event
->message
);
4459 /* On Mac, this is only called from focus events, so no switch needed. */
4460 mac_focus_changed ((event
->modifiers
& activeFlag
),
4461 dpyinfo
, frame
, bufp
);
4465 /* Handle an event saying the mouse has moved out of an Emacs frame. */
4468 x_mouse_leave (dpyinfo
)
4469 struct x_display_info
*dpyinfo
;
4471 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
4474 /* The focus has changed, or we have redirected a frame's focus to
4475 another frame (this happens when a frame uses a surrogate
4476 mini-buffer frame). Shift the highlight as appropriate.
4478 The FRAME argument doesn't necessarily have anything to do with which
4479 frame is being highlighted or un-highlighted; we only use it to find
4480 the appropriate X display info. */
4483 XTframe_rehighlight (frame
)
4484 struct frame
*frame
;
4486 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
4490 x_frame_rehighlight (dpyinfo
)
4491 struct x_display_info
*dpyinfo
;
4493 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
4495 if (dpyinfo
->x_focus_frame
)
4497 dpyinfo
->x_highlight_frame
4498 = ((FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
4499 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
4500 : dpyinfo
->x_focus_frame
);
4501 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
4503 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
4504 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
4508 dpyinfo
->x_highlight_frame
= 0;
4510 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
4513 frame_unhighlight (old_highlight
);
4514 if (dpyinfo
->x_highlight_frame
)
4515 frame_highlight (dpyinfo
->x_highlight_frame
);
4521 /* Convert a keysym to its name. */
4524 x_get_keysym_name (keysym
)
4531 value
= XKeysymToString (keysym
);
4542 /* Function to report a mouse movement to the mainstream Emacs code.
4543 The input handler calls this.
4545 We have received a mouse movement event, which is given in *event.
4546 If the mouse is over a different glyph than it was last time, tell
4547 the mainstream emacs code by setting mouse_moved. If not, ask for
4548 another motion event, so we can check again the next time it moves. */
4550 static Point last_mouse_motion_position
;
4551 static Lisp_Object last_mouse_motion_frame
;
4554 note_mouse_movement (frame
, pos
)
4558 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (frame
);
4559 #if TARGET_API_MAC_CARBON
4563 last_mouse_movement_time
= TickCount () * (1000 / 60); /* to milliseconds */
4564 last_mouse_motion_position
= *pos
;
4565 XSETFRAME (last_mouse_motion_frame
, frame
);
4567 if (frame
== dpyinfo
->mouse_face_mouse_frame
4568 #if TARGET_API_MAC_CARBON
4569 && !PtInRect (*pos
, GetWindowPortBounds (FRAME_MAC_WINDOW (frame
), &r
))
4571 && !PtInRect (*pos
, &FRAME_MAC_WINDOW (frame
)->portRect
)
4575 /* This case corresponds to LeaveNotify in X11. If we move
4576 outside the frame, then we're certainly no longer on any text
4578 clear_mouse_face (dpyinfo
);
4579 dpyinfo
->mouse_face_mouse_frame
= 0;
4580 if (!dpyinfo
->grabbed
)
4581 FRAME_RIF (frame
)->define_frame_cursor (frame
,
4582 frame
->output_data
.mac
->nontext_cursor
);
4585 /* Has the mouse moved off the glyph it was on at the last sighting? */
4586 if (frame
!= last_mouse_glyph_frame
4587 || !PtInRect (*pos
, &last_mouse_glyph
))
4589 frame
->mouse_moved
= 1;
4590 last_mouse_scroll_bar
= Qnil
;
4591 note_mouse_highlight (frame
, pos
->h
, pos
->v
);
4592 /* Remember which glyph we're now on. */
4593 remember_mouse_glyph (frame
, pos
->h
, pos
->v
, &last_mouse_glyph
);
4594 last_mouse_glyph_frame
= frame
;
4602 /************************************************************************
4604 ************************************************************************/
4606 /* MAC TODO: This should be called from somewhere (or removed) ++KFS */
4609 redo_mouse_highlight ()
4611 if (!NILP (last_mouse_motion_frame
)
4612 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
4613 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
4614 last_mouse_motion_position
.h
,
4615 last_mouse_motion_position
.v
);
4619 static struct frame
*
4620 mac_focus_frame (dpyinfo
)
4621 struct mac_display_info
*dpyinfo
;
4623 if (dpyinfo
->x_focus_frame
)
4624 return dpyinfo
->x_focus_frame
;
4626 /* Mac version may get events, such as a menu bar click, even when
4627 all the frames are invisible. In this case, we regard the
4628 event came to the selected frame. */
4629 return SELECTED_FRAME ();
4633 /* Return the current position of the mouse.
4634 *FP should be a frame which indicates which display to ask about.
4636 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
4637 and *PART to the frame, window, and scroll bar part that the mouse
4638 is over. Set *X and *Y to the portion and whole of the mouse's
4639 position on the scroll bar.
4641 If the mouse movement started elsewhere, set *FP to the frame the
4642 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
4645 Set *TIME to the server time-stamp for the time at which the mouse
4646 was at this position.
4648 Don't store anything if we don't have a valid set of values to report.
4650 This clears the mouse_moved flag, so we can wait for the next mouse
4654 XTmouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
4657 Lisp_Object
*bar_window
;
4658 enum scroll_bar_part
*part
;
4660 unsigned long *time
;
4666 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
4667 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
4670 Lisp_Object frame
, tail
;
4672 /* Clear the mouse-moved flag for every frame on this display. */
4673 FOR_EACH_FRAME (tail
, frame
)
4674 XFRAME (frame
)->mouse_moved
= 0;
4676 last_mouse_scroll_bar
= Qnil
;
4678 if (FRAME_MAC_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
4679 && FRAME_LIVE_P (last_mouse_frame
))
4680 f1
= last_mouse_frame
;
4682 f1
= mac_focus_frame (FRAME_MAC_DISPLAY_INFO (*fp
));
4686 /* Ok, we found a frame. Store all the values.
4687 last_mouse_glyph is a rectangle used to reduce the
4688 generation of mouse events. To not miss any motion
4689 events, we must divide the frame into rectangles of the
4690 size of the smallest character that could be displayed
4691 on it, i.e. into the same rectangles that matrices on
4692 the frame are divided into. */
4695 #if TARGET_API_MAC_CARBON
4696 GetGlobalMouse (&mouse_pos
);
4697 mouse_pos
.h
-= f1
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f1
);
4698 mouse_pos
.v
-= f1
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f1
);
4700 SetPortWindowPort (FRAME_MAC_WINDOW (f1
));
4701 GetMouse (&mouse_pos
);
4703 remember_mouse_glyph (f1
, mouse_pos
.h
, mouse_pos
.v
,
4705 last_mouse_glyph_frame
= f1
;
4710 XSETINT (*x
, mouse_pos
.h
);
4711 XSETINT (*y
, mouse_pos
.v
);
4712 *time
= last_mouse_movement_time
;
4720 /************************************************************************
4722 ************************************************************************/
4724 #ifdef USE_TOOLKIT_SCROLL_BARS
4726 static pascal void scroll_bar_timer_callback
P_ ((EventLoopTimerRef
, void *));
4727 static OSStatus install_scroll_bar_timer
P_ ((void));
4728 static OSStatus set_scroll_bar_timer
P_ ((EventTimerInterval
));
4729 static int control_part_code_to_scroll_bar_part
P_ ((ControlPartCode
));
4730 static void construct_scroll_bar_click
P_ ((struct scroll_bar
*, int,
4731 struct input_event
*));
4732 static OSStatus get_control_part_bounds
P_ ((ControlRef
, ControlPartCode
,
4734 static void x_scroll_bar_handle_press
P_ ((struct scroll_bar
*,
4735 ControlPartCode
, Point
,
4736 struct input_event
*));
4737 static void x_scroll_bar_handle_release
P_ ((struct scroll_bar
*,
4738 struct input_event
*));
4739 static void x_scroll_bar_handle_drag
P_ ((WindowRef
, struct scroll_bar
*,
4740 Point
, struct input_event
*));
4741 static void x_set_toolkit_scroll_bar_thumb
P_ ((struct scroll_bar
*,
4744 /* Last scroll bar part sent in x_scroll_bar_handle_*. */
4746 static int last_scroll_bar_part
;
4748 static EventLoopTimerRef scroll_bar_timer
;
4750 static int scroll_bar_timer_event_posted_p
;
4752 #define SCROLL_BAR_FIRST_DELAY 0.5
4753 #define SCROLL_BAR_CONTINUOUS_DELAY (1.0 / 15)
4756 scroll_bar_timer_callback (timer
, data
)
4757 EventLoopTimerRef timer
;
4762 err
= mac_post_mouse_moved_event ();
4764 scroll_bar_timer_event_posted_p
= 1;
4768 install_scroll_bar_timer ()
4770 static EventLoopTimerUPP scroll_bar_timer_callbackUPP
= NULL
;
4772 if (scroll_bar_timer_callbackUPP
== NULL
)
4773 scroll_bar_timer_callbackUPP
=
4774 NewEventLoopTimerUPP (scroll_bar_timer_callback
);
4776 if (scroll_bar_timer
== NULL
)
4777 /* Mac OS X and CarbonLib 1.5 and later allow us to specify
4778 kEventDurationForever as delays. */
4780 InstallEventLoopTimer (GetCurrentEventLoop (),
4781 kEventDurationForever
, kEventDurationForever
,
4782 scroll_bar_timer_callbackUPP
, NULL
,
4787 set_scroll_bar_timer (delay
)
4788 EventTimerInterval delay
;
4790 if (scroll_bar_timer
== NULL
)
4791 install_scroll_bar_timer ();
4793 scroll_bar_timer_event_posted_p
= 0;
4795 return SetEventLoopTimerNextFireTime (scroll_bar_timer
, delay
);
4799 control_part_code_to_scroll_bar_part (part_code
)
4800 ControlPartCode part_code
;
4804 case kControlUpButtonPart
: return scroll_bar_up_arrow
;
4805 case kControlDownButtonPart
: return scroll_bar_down_arrow
;
4806 case kControlPageUpPart
: return scroll_bar_above_handle
;
4807 case kControlPageDownPart
: return scroll_bar_below_handle
;
4808 case kControlIndicatorPart
: return scroll_bar_handle
;
4815 construct_scroll_bar_click (bar
, part
, bufp
)
4816 struct scroll_bar
*bar
;
4818 struct input_event
*bufp
;
4820 bufp
->kind
= SCROLL_BAR_CLICK_EVENT
;
4821 bufp
->frame_or_window
= bar
->window
;
4825 XSETINT (bufp
->x
, 0);
4826 XSETINT (bufp
->y
, 0);
4827 bufp
->modifiers
= 0;
4831 get_control_part_bounds (ch
, part_code
, rect
)
4833 ControlPartCode part_code
;
4836 RgnHandle region
= NewRgn ();
4839 err
= GetControlRegion (ch
, part_code
, region
);
4841 GetRegionBounds (region
, rect
);
4842 DisposeRgn (region
);
4848 x_scroll_bar_handle_press (bar
, part_code
, mouse_pos
, bufp
)
4849 struct scroll_bar
*bar
;
4850 ControlPartCode part_code
;
4852 struct input_event
*bufp
;
4854 int part
= control_part_code_to_scroll_bar_part (part_code
);
4859 if (part
!= scroll_bar_handle
)
4861 construct_scroll_bar_click (bar
, part
, bufp
);
4862 HiliteControl (SCROLL_BAR_CONTROL_REF (bar
), part_code
);
4863 set_scroll_bar_timer (SCROLL_BAR_FIRST_DELAY
);
4864 bar
->dragging
= Qnil
;
4870 get_control_part_bounds (SCROLL_BAR_CONTROL_REF (bar
),
4871 kControlIndicatorPart
, &r
);
4872 XSETINT (bar
->dragging
, - (mouse_pos
.v
- r
.top
) - 1);
4875 last_scroll_bar_part
= part
;
4876 tracked_scroll_bar
= bar
;
4880 x_scroll_bar_handle_release (bar
, bufp
)
4881 struct scroll_bar
*bar
;
4882 struct input_event
*bufp
;
4884 if (last_scroll_bar_part
!= scroll_bar_handle
4885 || (INTEGERP (bar
->dragging
) && XINT (bar
->dragging
) >= 0))
4886 construct_scroll_bar_click (bar
, scroll_bar_end_scroll
, bufp
);
4888 HiliteControl (SCROLL_BAR_CONTROL_REF (bar
), 0);
4889 set_scroll_bar_timer (kEventDurationForever
);
4891 last_scroll_bar_part
= -1;
4892 bar
->dragging
= Qnil
;
4893 tracked_scroll_bar
= NULL
;
4897 x_scroll_bar_handle_drag (win
, bar
, mouse_pos
, bufp
)
4899 struct scroll_bar
*bar
;
4901 struct input_event
*bufp
;
4903 ControlRef ch
= SCROLL_BAR_CONTROL_REF (bar
);
4905 if (last_scroll_bar_part
== scroll_bar_handle
)
4910 get_control_part_bounds (SCROLL_BAR_CONTROL_REF (bar
),
4911 kControlIndicatorPart
, &r
);
4913 if (INTEGERP (bar
->dragging
) && XINT (bar
->dragging
) < 0)
4914 XSETINT (bar
->dragging
, - (XINT (bar
->dragging
) + 1));
4916 top
= mouse_pos
.v
- XINT (bar
->dragging
) - XINT (bar
->track_top
);
4917 top_range
= XINT (bar
->track_height
) - XINT (bar
->min_handle
);
4921 if (top
> top_range
)
4924 construct_scroll_bar_click (bar
, scroll_bar_handle
, bufp
);
4925 XSETINT (bufp
->x
, top
);
4926 XSETINT (bufp
->y
, top_range
);
4930 ControlPartCode part_code
;
4931 int unhilite_p
= 0, part
;
4933 if (ch
!= FindControlUnderMouse (mouse_pos
, win
, &part_code
))
4937 part
= control_part_code_to_scroll_bar_part (part_code
);
4939 switch (last_scroll_bar_part
)
4941 case scroll_bar_above_handle
:
4942 case scroll_bar_below_handle
:
4943 if (part
!= scroll_bar_above_handle
4944 && part
!= scroll_bar_below_handle
)
4948 case scroll_bar_up_arrow
:
4949 case scroll_bar_down_arrow
:
4950 if (part
!= scroll_bar_up_arrow
4951 && part
!= scroll_bar_down_arrow
)
4958 HiliteControl (SCROLL_BAR_CONTROL_REF (bar
), 0);
4959 else if (part
!= last_scroll_bar_part
4960 || scroll_bar_timer_event_posted_p
)
4962 construct_scroll_bar_click (bar
, part
, bufp
);
4963 last_scroll_bar_part
= part
;
4964 HiliteControl (SCROLL_BAR_CONTROL_REF (bar
), part_code
);
4965 set_scroll_bar_timer (SCROLL_BAR_CONTINUOUS_DELAY
);
4970 /* Set the thumb size and position of scroll bar BAR. We are currently
4971 displaying PORTION out of a whole WHOLE, and our position POSITION. */
4974 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
4975 struct scroll_bar
*bar
;
4976 int portion
, position
, whole
;
4978 ControlRef ch
= SCROLL_BAR_CONTROL_REF (bar
);
4979 int value
, viewsize
, maximum
;
4981 if (XINT (bar
->track_height
) == 0)
4984 if (whole
<= portion
)
4985 value
= 0, viewsize
= 1, maximum
= 0;
4990 maximum
= XINT (bar
->track_height
) - XINT (bar
->min_handle
);
4991 scale
= (float) maximum
/ (whole
- portion
);
4992 value
= position
* scale
+ 0.5f
;
4993 viewsize
= (int) (portion
* scale
+ 0.5f
) + XINT (bar
->min_handle
);
4998 if (GetControlViewSize (ch
) != viewsize
4999 || GetControl32BitValue (ch
) != value
5000 || GetControl32BitMaximum (ch
) != maximum
)
5002 /* Temporarily hide the scroll bar to avoid multiple redraws. */
5003 SetControlVisibility (ch
, false, false);
5005 SetControl32BitMaximum (ch
, maximum
);
5006 SetControl32BitValue (ch
, value
);
5007 SetControlViewSize (ch
, viewsize
);
5009 SetControlVisibility (ch
, true, true);
5015 #endif /* USE_TOOLKIT_SCROLL_BARS */
5019 /************************************************************************
5020 Scroll bars, general
5021 ************************************************************************/
5023 /* Create a scroll bar and return the scroll bar vector for it. W is
5024 the Emacs window on which to create the scroll bar. TOP, LEFT,
5025 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
5028 static struct scroll_bar
*
5029 x_scroll_bar_create (w
, top
, left
, width
, height
, disp_top
, disp_height
)
5031 int top
, left
, width
, height
, disp_top
, disp_height
;
5033 struct frame
*f
= XFRAME (w
->frame
);
5034 struct scroll_bar
*bar
5035 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
5043 r
.right
= left
+ width
;
5044 r
.bottom
= disp_top
+ disp_height
;
5047 mac_prepare_for_quickdraw (f
);
5049 #if TARGET_API_MAC_CARBON
5050 ch
= NewControl (FRAME_MAC_WINDOW (f
), &r
, "\p",
5051 #ifdef USE_TOOLKIT_SCROLL_BARS
5054 width
< disp_height
,
5056 0, 0, 0, kControlScrollBarProc
, (long) bar
);
5058 ch
= NewControl (FRAME_MAC_WINDOW (f
), &r
, "\p", width
< disp_height
,
5059 0, 0, 0, scrollBarProc
, (long) bar
);
5061 SET_SCROLL_BAR_CONTROL_REF (bar
, ch
);
5063 XSETWINDOW (bar
->window
, w
);
5064 XSETINT (bar
->top
, top
);
5065 XSETINT (bar
->left
, left
);
5066 XSETINT (bar
->width
, width
);
5067 XSETINT (bar
->height
, height
);
5068 XSETINT (bar
->start
, 0);
5069 XSETINT (bar
->end
, 0);
5070 bar
->dragging
= Qnil
;
5072 bar
->fringe_extended_p
= Qnil
;
5074 bar
->redraw_needed_p
= Qnil
;
5075 #ifdef USE_TOOLKIT_SCROLL_BARS
5076 bar
->track_top
= Qnil
;
5077 bar
->track_height
= Qnil
;
5078 bar
->min_handle
= Qnil
;
5081 /* Add bar to its frame's list of scroll bars. */
5082 bar
->next
= FRAME_SCROLL_BARS (f
);
5084 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
5085 if (!NILP (bar
->next
))
5086 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
5093 /* Draw BAR's handle in the proper position.
5095 If the handle is already drawn from START to END, don't bother
5096 redrawing it, unless REBUILD is non-zero; in that case, always
5097 redraw it. (REBUILD is handy for drawing the handle after expose
5100 Normally, we want to constrain the start and end of the handle to
5101 fit inside its rectangle, but if the user is dragging the scroll
5102 bar handle, we want to let them drag it down all the way, so that
5103 the bar's top is as far down as it goes; otherwise, there's no way
5104 to move to the very end of the buffer. */
5106 #ifndef USE_TOOLKIT_SCROLL_BARS
5109 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
5110 struct scroll_bar
*bar
;
5114 int dragging
= ! NILP (bar
->dragging
);
5115 ControlRef ch
= SCROLL_BAR_CONTROL_REF (bar
);
5116 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5117 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
5118 int length
= end
- start
;
5120 /* If the display is already accurate, do nothing. */
5122 && start
== XINT (bar
->start
)
5123 && end
== XINT (bar
->end
))
5128 /* Make sure the values are reasonable, and try to preserve the
5129 distance between start and end. */
5132 else if (start
> top_range
)
5134 end
= start
+ length
;
5138 else if (end
> top_range
&& ! dragging
)
5141 /* Store the adjusted setting in the scroll bar. */
5142 XSETINT (bar
->start
, start
);
5143 XSETINT (bar
->end
, end
);
5145 /* Clip the end position, just for display. */
5146 if (end
> top_range
)
5149 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels below
5150 top positions, to make sure the handle is always at least that
5151 many pixels tall. */
5152 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
5154 SetControlMinimum (ch
, 0);
5155 /* Don't inadvertently activate deactivated scroll bars */
5156 if (GetControlMaximum (ch
) != -1)
5157 SetControlMaximum (ch
, top_range
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
5159 SetControlValue (ch
, start
);
5160 #if TARGET_API_MAC_CARBON
5161 SetControlViewSize (ch
, end
- start
);
5167 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5169 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
5173 x_scroll_bar_remove (bar
)
5174 struct scroll_bar
*bar
;
5176 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5181 mac_prepare_for_quickdraw (f
);
5183 /* Destroy the Mac scroll bar control */
5184 DisposeControl (SCROLL_BAR_CONTROL_REF (bar
));
5186 /* Disassociate this scroll bar from its window. */
5187 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
5193 /* Set the handle of the vertical scroll bar for WINDOW to indicate
5194 that we are displaying PORTION characters out of a total of WHOLE
5195 characters, starting at POSITION. If WINDOW has no scroll bar,
5199 XTset_vertical_scroll_bar (w
, portion
, whole
, position
)
5201 int portion
, whole
, position
;
5203 struct frame
*f
= XFRAME (w
->frame
);
5204 struct scroll_bar
*bar
;
5205 int top
, height
, left
, sb_left
, width
, sb_width
, disp_top
, disp_height
;
5206 int window_y
, window_height
;
5208 int fringe_extended_p
;
5211 /* Get window dimensions. */
5212 window_box (w
, -1, 0, &window_y
, 0, &window_height
);
5214 width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
5215 height
= window_height
;
5217 /* Compute the left edge of the scroll bar area. */
5218 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
5220 /* Compute the width of the scroll bar which might be less than
5221 the width of the area reserved for the scroll bar. */
5222 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
) > 0)
5223 sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
5227 /* Compute the left edge of the scroll bar. */
5228 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
5229 sb_left
= left
+ (WINDOW_RIGHTMOST_P (w
) ? width
- sb_width
: 0);
5231 sb_left
= left
+ (WINDOW_LEFTMOST_P (w
) ? 0 : width
- sb_width
);
5233 /* Adjustments according to Inside Macintosh to make it look nice */
5235 disp_height
= height
;
5242 else if (disp_top
== FRAME_PIXEL_HEIGHT (f
) - 16)
5248 if (sb_left
+ sb_width
== FRAME_PIXEL_WIDTH (f
))
5253 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
5254 fringe_extended_p
= (WINDOW_LEFTMOST_P (w
)
5255 && WINDOW_LEFT_FRINGE_WIDTH (w
)
5256 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5257 || WINDOW_LEFT_MARGIN_COLS (w
) == 0));
5259 fringe_extended_p
= (WINDOW_RIGHTMOST_P (w
)
5260 && WINDOW_RIGHT_FRINGE_WIDTH (w
)
5261 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5262 || WINDOW_RIGHT_MARGIN_COLS (w
) == 0));
5265 /* Does the scroll bar exist yet? */
5266 if (NILP (w
->vertical_scroll_bar
))
5270 if (fringe_extended_p
)
5271 mac_clear_area (f
, sb_left
, top
, sb_width
, height
);
5274 mac_clear_area (f
, left
, top
, width
, height
);
5276 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
, disp_top
,
5278 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
5282 /* It may just need to be moved and resized. */
5285 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5286 ch
= SCROLL_BAR_CONTROL_REF (bar
);
5290 /* If already correctly positioned, do nothing. */
5291 if (XINT (bar
->left
) == sb_left
5292 && XINT (bar
->top
) == top
5293 && XINT (bar
->width
) == sb_width
5294 && XINT (bar
->height
) == height
5296 && !NILP (bar
->fringe_extended_p
) == fringe_extended_p
5300 if (!NILP (bar
->redraw_needed_p
))
5303 mac_prepare_for_quickdraw (f
);
5305 Draw1Control (SCROLL_BAR_CONTROL_REF (bar
));
5310 /* Since toolkit scroll bars are smaller than the space reserved
5311 for them on the frame, we have to clear "under" them. */
5313 if (fringe_extended_p
)
5314 mac_clear_area (f
, sb_left
, top
, sb_width
, height
);
5317 mac_clear_area (f
, left
, top
, width
, height
);
5320 mac_prepare_for_quickdraw (f
);
5323 MoveControl (ch
, sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
, disp_top
);
5324 SizeControl (ch
, sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
5326 #ifndef USE_TOOLKIT_SCROLL_BARS
5327 if (sb_width
< disp_height
)
5331 /* Remember new settings. */
5332 XSETINT (bar
->left
, sb_left
);
5333 XSETINT (bar
->top
, top
);
5334 XSETINT (bar
->width
, sb_width
);
5335 XSETINT (bar
->height
, height
);
5336 #ifdef USE_TOOLKIT_SCROLL_BARS
5337 bar
->track_top
= Qnil
;
5338 bar
->track_height
= Qnil
;
5339 bar
->min_handle
= Qnil
;
5347 bar
->fringe_extended_p
= fringe_extended_p
? Qt
: Qnil
;
5350 bar
->redraw_needed_p
= Qnil
;
5352 #ifdef USE_TOOLKIT_SCROLL_BARS
5353 if (NILP (bar
->track_top
))
5355 if (sb_width
>= disp_height
5357 || sb_width
< MAC_AQUA_SMALL_VERTICAL_SCROLL_BAR_WIDTH
5361 XSETINT (bar
->track_top
, 0);
5362 XSETINT (bar
->track_height
, 0);
5363 XSETINT (bar
->min_handle
, 0);
5367 ControlRef ch
= SCROLL_BAR_CONTROL_REF (bar
);
5372 SetControl32BitMinimum (ch
, 0);
5373 SetControl32BitMaximum (ch
, 1 << 30);
5374 SetControlViewSize (ch
, 1);
5376 /* Move the scroll bar thumb to the top. */
5377 SetControl32BitValue (ch
, 0);
5378 get_control_part_bounds (ch
, kControlIndicatorPart
, &r0
);
5380 /* Move the scroll bar thumb to the bottom. */
5381 SetControl32BitValue (ch
, 1 << 30);
5382 get_control_part_bounds (ch
, kControlIndicatorPart
, &r1
);
5384 UnionRect (&r0
, &r1
, &r0
);
5385 XSETINT (bar
->track_top
, r0
.top
);
5386 XSETINT (bar
->track_height
, r0
.bottom
- r0
.top
);
5387 XSETINT (bar
->min_handle
, r1
.bottom
- r1
.top
);
5389 /* Don't show the scroll bar if its height is not enough to
5390 display the scroll bar thumb. */
5391 if (r0
.bottom
- r0
.top
> 0)
5398 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
5399 #else /* not USE_TOOLKIT_SCROLL_BARS */
5400 /* Set the scroll bar's current state, unless we're currently being
5402 if (NILP (bar
->dragging
))
5404 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
5407 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
5410 int start
= ((double) position
* top_range
) / whole
;
5411 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
5412 x_scroll_bar_set_handle (bar
, start
, end
, 0);
5415 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5419 /* The following three hooks are used when we're doing a thorough
5420 redisplay of the frame. We don't explicitly know which scroll bars
5421 are going to be deleted, because keeping track of when windows go
5422 away is a real pain - "Can you say set-window-configuration, boys
5423 and girls?" Instead, we just assert at the beginning of redisplay
5424 that *all* scroll bars are to be removed, and then save a scroll bar
5425 from the fiery pit when we actually redisplay its window. */
5427 /* Arrange for all scroll bars on FRAME to be removed at the next call
5428 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
5429 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
5432 XTcondemn_scroll_bars (frame
)
5435 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
5436 while (! NILP (FRAME_SCROLL_BARS (frame
)))
5439 bar
= FRAME_SCROLL_BARS (frame
);
5440 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
5441 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
5442 XSCROLL_BAR (bar
)->prev
= Qnil
;
5443 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
5444 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
5445 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
5450 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
5451 Note that WINDOW isn't necessarily condemned at all. */
5454 XTredeem_scroll_bar (window
)
5455 struct window
*window
;
5457 struct scroll_bar
*bar
;
5460 /* We can't redeem this window's scroll bar if it doesn't have one. */
5461 if (NILP (window
->vertical_scroll_bar
))
5464 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
5466 /* Unlink it from the condemned list. */
5467 f
= XFRAME (WINDOW_FRAME (window
));
5468 if (NILP (bar
->prev
))
5470 /* If the prev pointer is nil, it must be the first in one of
5472 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
5473 /* It's not condemned. Everything's fine. */
5475 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
5476 window
->vertical_scroll_bar
))
5477 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
5479 /* If its prev pointer is nil, it must be at the front of
5480 one or the other! */
5484 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
5486 if (! NILP (bar
->next
))
5487 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
5489 bar
->next
= FRAME_SCROLL_BARS (f
);
5491 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
5492 if (! NILP (bar
->next
))
5493 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
5496 /* Remove all scroll bars on FRAME that haven't been saved since the
5497 last call to `*condemn_scroll_bars_hook'. */
5500 XTjudge_scroll_bars (f
)
5503 Lisp_Object bar
, next
;
5505 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
5507 /* Clear out the condemned list now so we won't try to process any
5508 more events on the hapless scroll bars. */
5509 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
5511 for (; ! NILP (bar
); bar
= next
)
5513 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
5515 x_scroll_bar_remove (b
);
5518 b
->next
= b
->prev
= Qnil
;
5521 /* Now there should be no references to the condemned scroll bars,
5522 and they should get garbage-collected. */
5526 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
5527 is set to something other than NO_EVENT, it is enqueued.
5529 This may be called from a signal handler, so we have to ignore GC
5533 x_scroll_bar_handle_click (bar
, part_code
, er
, bufp
)
5534 struct scroll_bar
*bar
;
5535 ControlPartCode part_code
;
5536 const EventRecord
*er
;
5537 struct input_event
*bufp
;
5539 int win_y
, top_range
;
5541 if (! WINDOWP (bar
->window
))
5544 bufp
->kind
= SCROLL_BAR_CLICK_EVENT
;
5545 bufp
->frame_or_window
= bar
->window
;
5548 bar
->dragging
= Qnil
;
5552 case kControlUpButtonPart
:
5553 bufp
->part
= scroll_bar_up_arrow
;
5555 case kControlDownButtonPart
:
5556 bufp
->part
= scroll_bar_down_arrow
;
5558 case kControlPageUpPart
:
5559 bufp
->part
= scroll_bar_above_handle
;
5561 case kControlPageDownPart
:
5562 bufp
->part
= scroll_bar_below_handle
;
5564 #if TARGET_API_MAC_CARBON
5567 case kControlIndicatorPart
:
5569 if (er
->what
== mouseDown
)
5570 bar
->dragging
= make_number (0);
5571 XSETVECTOR (last_mouse_scroll_bar
, bar
);
5572 bufp
->part
= scroll_bar_handle
;
5576 win_y
= XINT (bufp
->y
) - XINT (bar
->top
);
5577 top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (0/*dummy*/, XINT (bar
->height
));
5579 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
5583 if (! NILP (bar
->dragging
))
5584 win_y
-= XINT (bar
->dragging
);
5588 if (win_y
> top_range
)
5591 XSETINT (bufp
->x
, win_y
);
5592 XSETINT (bufp
->y
, top_range
);
5595 #ifndef USE_TOOLKIT_SCROLL_BARS
5597 /* Handle some mouse motion while someone is dragging the scroll bar.
5599 This may be called from a signal handler, so we have to ignore GC
5603 x_scroll_bar_note_movement (bar
, y_pos
, t
)
5604 struct scroll_bar
*bar
;
5608 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
5610 last_mouse_movement_time
= t
;
5613 XSETVECTOR (last_mouse_scroll_bar
, bar
);
5615 /* If we're dragging the bar, display it. */
5616 if (! NILP (bar
->dragging
))
5618 /* Where should the handle be now? */
5619 int new_start
= y_pos
- 24;
5621 if (new_start
!= XINT (bar
->start
))
5623 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
5625 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5630 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5632 /* Return information to the user about the current position of the mouse
5633 on the scroll bar. */
5636 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
5638 Lisp_Object
*bar_window
;
5639 enum scroll_bar_part
*part
;
5641 unsigned long *time
;
5643 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
5644 ControlRef ch
= SCROLL_BAR_CONTROL_REF (bar
);
5645 #if TARGET_API_MAC_CARBON
5646 WindowRef wp
= GetControlOwner (ch
);
5648 WindowRef wp
= (*ch
)->contrlOwner
;
5651 struct frame
*f
= mac_window_to_frame (wp
);
5652 int win_y
, top_range
;
5654 #if TARGET_API_MAC_CARBON
5655 GetGlobalMouse (&mouse_pos
);
5656 mouse_pos
.h
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
5657 mouse_pos
.v
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
5659 SetPortWindowPort (wp
);
5660 GetMouse (&mouse_pos
);
5663 win_y
= mouse_pos
.v
- XINT (bar
->top
);
5664 top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
5666 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
5670 if (! NILP (bar
->dragging
))
5671 win_y
-= XINT (bar
->dragging
);
5675 if (win_y
> top_range
)
5679 *bar_window
= bar
->window
;
5681 if (! NILP (bar
->dragging
))
5682 *part
= scroll_bar_handle
;
5683 else if (win_y
< XINT (bar
->start
))
5684 *part
= scroll_bar_above_handle
;
5685 else if (win_y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5686 *part
= scroll_bar_handle
;
5688 *part
= scroll_bar_below_handle
;
5690 XSETINT (*x
, win_y
);
5691 XSETINT (*y
, top_range
);
5694 last_mouse_scroll_bar
= Qnil
;
5696 *time
= last_mouse_movement_time
;
5700 /* The screen has been cleared so we may have changed foreground or
5701 background colors, and the scroll bars may need to be redrawn.
5702 Clear out the scroll bars, and ask for expose events, so we can
5706 x_scroll_bar_clear (f
)
5711 /* We can have scroll bars even if this is 0,
5712 if we just turned off scroll bar mode.
5713 But in that case we should not clear them. */
5714 if (FRAME_HAS_VERTICAL_SCROLL_BARS (f
))
5715 for (bar
= FRAME_SCROLL_BARS (f
); VECTORP (bar
);
5716 bar
= XSCROLL_BAR (bar
)->next
)
5717 XSCROLL_BAR (bar
)->redraw_needed_p
= Qt
;
5721 /***********************************************************************
5723 ***********************************************************************/
5726 /* In identifiers such as function/variable names, Emacs tool bar is
5727 referred to as `tool_bar', and Carbon HIToolbar as `toolbar'. */
5729 #define TOOLBAR_IDENTIFIER (CFSTR ("org.gnu.Emacs.toolbar"))
5730 #define TOOLBAR_ICON_ITEM_IDENTIFIER (CFSTR ("org.gnu.Emacs.toolbar.icon"))
5732 #define TOOLBAR_ITEM_COMMAND_ID_OFFSET 'Tb\0\0'
5733 #define TOOLBAR_ITEM_COMMAND_ID_P(id) \
5734 (((id) & ~0xffff) == TOOLBAR_ITEM_COMMAND_ID_OFFSET)
5735 #define TOOLBAR_ITEM_COMMAND_ID_VALUE(id) \
5736 ((id) - TOOLBAR_ITEM_COMMAND_ID_OFFSET)
5737 #define TOOLBAR_ITEM_MAKE_COMMAND_ID(value) \
5738 ((value) + TOOLBAR_ITEM_COMMAND_ID_OFFSET)
5740 static int mac_event_to_emacs_modifiers
P_ ((EventRef
));
5741 static void mac_handle_origin_change
P_ ((struct frame
*));
5742 static OSStatus mac_handle_toolbar_command_event
P_ ((EventHandlerCallRef
,
5746 mac_move_window_with_gravity (f
, win_gravity
, left
, top
)
5753 mac_get_window_bounds (f
, &inner
, &outer
);
5755 switch (win_gravity
)
5757 case NorthWestGravity
:
5759 case SouthWestGravity
:
5760 left
+= inner
.left
- outer
.left
;
5766 left
+= ((inner
.left
- outer
.left
) + (inner
.right
- outer
.right
)) / 2;
5769 case NorthEastGravity
:
5771 case SouthEastGravity
:
5772 left
+= inner
.right
- outer
.right
;
5776 switch (win_gravity
)
5778 case NorthWestGravity
:
5780 case NorthEastGravity
:
5781 top
+= inner
.top
- outer
.top
;
5787 top
+= ((inner
.top
- outer
.top
) + (inner
.bottom
- outer
.bottom
)) / 2;
5790 case SouthWestGravity
:
5792 case SouthEastGravity
:
5793 top
+= inner
.bottom
- outer
.bottom
;
5797 MoveWindow (FRAME_MAC_WINDOW (f
), left
, top
, false);
5801 mac_get_window_origin_with_gravity (f
, win_gravity
, left
, top
)
5808 mac_get_window_bounds (f
, &inner
, &outer
);
5810 switch (win_gravity
)
5812 case NorthWestGravity
:
5814 case SouthWestGravity
:
5821 *left
= outer
.left
+ ((outer
.right
- outer
.left
)
5822 - (inner
.right
- inner
.left
)) / 2;
5825 case NorthEastGravity
:
5827 case SouthEastGravity
:
5828 *left
= outer
.right
- (inner
.right
- inner
.left
);
5832 switch (win_gravity
)
5834 case NorthWestGravity
:
5836 case NorthEastGravity
:
5843 *top
= outer
.top
+ ((outer
.bottom
- outer
.top
)
5844 - (inner
.bottom
- inner
.top
)) / 2;
5847 case SouthWestGravity
:
5849 case SouthEastGravity
:
5850 *top
= outer
.bottom
- (inner
.bottom
- inner
.top
);
5856 mac_handle_toolbar_event (next_handler
, event
, data
)
5857 EventHandlerCallRef next_handler
;
5861 OSStatus err
, result
= eventNotHandledErr
;
5863 switch (GetEventKind (event
))
5865 case kEventToolbarGetDefaultIdentifiers
:
5869 case kEventToolbarGetAllowedIdentifiers
:
5871 CFMutableArrayRef array
;
5873 GetEventParameter (event
, kEventParamMutableArray
,
5874 typeCFMutableArrayRef
, NULL
,
5875 sizeof (CFMutableArrayRef
), NULL
, &array
);
5876 CFArrayAppendValue (array
, TOOLBAR_ICON_ITEM_IDENTIFIER
);
5881 case kEventToolbarCreateItemWithIdentifier
:
5883 CFStringRef identifier
;
5884 HIToolbarItemRef item
= NULL
;
5886 GetEventParameter (event
, kEventParamToolbarItemIdentifier
,
5887 typeCFStringRef
, NULL
,
5888 sizeof (CFStringRef
), NULL
, &identifier
);
5890 if (CFStringCompare (identifier
, TOOLBAR_ICON_ITEM_IDENTIFIER
, 0)
5891 == kCFCompareEqualTo
)
5892 HIToolbarItemCreate (identifier
,
5893 kHIToolbarItemAllowDuplicates
5894 | kHIToolbarItemCantBeRemoved
, &item
);
5898 SetEventParameter (event
, kEventParamToolbarItem
,
5899 typeHIToolbarItemRef
,
5900 sizeof (HIToolbarItemRef
), &item
);
5914 mac_image_spec_to_cg_image (f
, image
)
5918 if (!valid_image_p (image
))
5922 int img_id
= lookup_image (f
, image
);
5923 struct image
*img
= IMAGE_FROM_ID (f
, img_id
);
5925 prepare_image_for_display (f
, img
);
5927 return img
->data
.ptr_val
;
5931 /* Create a tool bar for frame F. */
5934 mac_create_frame_tool_bar (f
)
5938 HIToolbarRef toolbar
;
5940 err
= HIToolbarCreate (TOOLBAR_IDENTIFIER
, kHIToolbarNoAttributes
,
5944 static const EventTypeSpec specs
[] =
5945 {{kEventClassToolbar
, kEventToolbarGetDefaultIdentifiers
},
5946 {kEventClassToolbar
, kEventToolbarGetAllowedIdentifiers
},
5947 {kEventClassToolbar
, kEventToolbarCreateItemWithIdentifier
}};
5949 err
= InstallEventHandler (HIObjectGetEventTarget (toolbar
),
5950 mac_handle_toolbar_event
,
5951 GetEventTypeCount (specs
), specs
,
5956 err
= HIToolbarSetDisplayMode (toolbar
, kHIToolbarDisplayModeIconOnly
);
5959 static const EventTypeSpec specs
[] =
5960 {{kEventClassCommand
, kEventCommandProcess
}};
5962 err
= InstallWindowEventHandler (FRAME_MAC_WINDOW (f
),
5963 mac_handle_toolbar_command_event
,
5964 GetEventTypeCount (specs
),
5968 err
= SetWindowToolbar (FRAME_MAC_WINDOW (f
), toolbar
);
5971 CFRelease (toolbar
);
5976 /* Update the tool bar for frame F. Add new buttons and remove old. */
5979 update_frame_tool_bar (f
)
5982 HIToolbarRef toolbar
= NULL
;
5984 CFArrayRef old_items
= NULL
;
5986 int i
, pos
, win_gravity
= f
->output_data
.mac
->toolbar_win_gravity
;
5987 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
5991 GetWindowToolbar (FRAME_MAC_WINDOW (f
), &toolbar
);
5992 if (toolbar
== NULL
)
5994 mac_create_frame_tool_bar (f
);
5995 GetWindowToolbar (FRAME_MAC_WINDOW (f
), &toolbar
);
5996 if (toolbar
== NULL
)
5998 if (win_gravity
>= NorthWestGravity
&& win_gravity
<= SouthEastGravity
)
5999 mac_get_window_origin_with_gravity (f
, win_gravity
, &left
, &top
);
6002 HIToolbarCopyItems (toolbar
, &old_items
);
6003 if (old_items
== NULL
)
6006 old_count
= CFArrayGetCount (old_items
);
6008 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
6010 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
6012 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
6013 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
6016 CGImageRef cg_image
;
6018 HIToolbarItemRef item
;
6020 /* If image is a vector, choose the image according to the
6022 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
6023 if (VECTORP (image
))
6027 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
6028 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
6031 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
6032 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
6034 xassert (ASIZE (image
) >= idx
);
6035 image
= AREF (image
, idx
);
6040 cg_image
= mac_image_spec_to_cg_image (f
, image
);
6041 /* Ignore invalid image specifications. */
6042 if (cg_image
== NULL
)
6045 label
= cfstring_create_with_string (PROP (TOOL_BAR_ITEM_CAPTION
));
6049 if (pos
< old_count
)
6051 CGImageRef old_cg_image
= NULL
;
6052 CFStringRef old_label
= NULL
;
6053 Boolean old_enabled_p
;
6055 item
= (HIToolbarItemRef
) CFArrayGetValueAtIndex (old_items
, pos
);
6057 HIToolbarItemCopyImage (item
, &old_cg_image
);
6058 if (cg_image
!= old_cg_image
)
6059 HIToolbarItemSetImage (item
, cg_image
);
6060 CGImageRelease (old_cg_image
);
6062 HIToolbarItemCopyLabel (item
, &old_label
);
6063 if (CFStringCompare (label
, old_label
, 0) != kCFCompareEqualTo
)
6064 HIToolbarItemSetLabel (item
, label
);
6065 CFRelease (old_label
);
6067 old_enabled_p
= HIToolbarItemIsEnabled (item
);
6068 if ((enabled_p
|| idx
>= 0) != old_enabled_p
)
6069 HIToolbarItemSetEnabled (item
, (enabled_p
|| idx
>= 0));
6074 HIToolbarCreateItemWithIdentifier (toolbar
,
6075 TOOLBAR_ICON_ITEM_IDENTIFIER
,
6079 HIToolbarItemSetImage (item
, cg_image
);
6080 HIToolbarItemSetLabel (item
, label
);
6081 HIToolbarItemSetEnabled (item
, (enabled_p
|| idx
>= 0));
6082 HIToolbarAppendItem (toolbar
, item
);
6090 HIToolbarItemSetCommandID (item
, TOOLBAR_ITEM_MAKE_COMMAND_ID (i
));
6095 CFRelease (old_items
);
6097 while (pos
< old_count
)
6098 HIToolbarRemoveItemAtIndex (toolbar
, --old_count
);
6100 ShowHideWindowToolbar (FRAME_MAC_WINDOW (f
), true,
6101 !win_gravity
&& f
== mac_focus_frame (dpyinfo
));
6102 /* Mac OS X 10.3 does not issue kEventWindowBoundsChanged events on
6103 toolbar visibility change. */
6104 mac_handle_origin_change (f
);
6105 if (win_gravity
>= NorthWestGravity
&& win_gravity
<= SouthEastGravity
)
6107 mac_move_window_with_gravity (f
, win_gravity
, left
, top
);
6108 /* If the title bar is completely outside the screen, adjust the
6110 ConstrainWindowToScreen (FRAME_MAC_WINDOW (f
), kWindowTitleBarRgn
,
6111 kWindowConstrainMoveRegardlessOfFit
6112 | kWindowConstrainAllowPartial
, NULL
, NULL
);
6113 f
->output_data
.mac
->toolbar_win_gravity
= 0;
6120 /* Hide the tool bar on frame F. Unlike the counterpart on GTK+, it
6121 doesn't deallocate the resources. */
6124 free_frame_tool_bar (f
)
6127 if (IsWindowToolbarVisible (FRAME_MAC_WINDOW (f
)))
6129 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
6132 ShowHideWindowToolbar (FRAME_MAC_WINDOW (f
), false,
6133 (NILP (Fsymbol_value
6134 (intern ("frame-notice-user-settings")))
6135 && f
== mac_focus_frame (dpyinfo
)));
6136 /* Mac OS X 10.3 does not issue kEventWindowBoundsChanged events
6137 on toolbar visibility change. */
6138 mac_handle_origin_change (f
);
6144 mac_tool_bar_note_mouse_movement (f
, event
)
6149 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
6151 HIViewRef item_view
;
6154 mouse_down_p
= (dpyinfo
->grabbed
6155 && f
== last_mouse_frame
6156 && FRAME_LIVE_P (f
));
6160 err
= HIViewGetViewForMouseEvent (HIViewGetRoot (FRAME_MAC_WINDOW (f
)),
6162 /* This doesn't work on Mac OS X 10.2. On Mac OS X 10.3 and 10.4, a
6163 toolbar item view seems to have the same command ID with that of
6164 the toolbar item. */
6166 err
= GetControlCommandID (item_view
, &command_id
);
6167 if (err
== noErr
&& TOOLBAR_ITEM_COMMAND_ID_P (command_id
))
6169 int i
= TOOLBAR_ITEM_COMMAND_ID_VALUE (command_id
);
6171 if (i
< f
->n_tool_bar_items
)
6174 HIViewRef content_view
;
6176 err
= HIViewGetBounds (item_view
, &bounds
);
6178 err
= HIViewFindByID (HIViewGetRoot (FRAME_MAC_WINDOW (f
)),
6179 kHIViewWindowContentID
, &content_view
);
6181 err
= HIViewConvertRect (&bounds
, item_view
, content_view
);
6183 SetRect (&last_mouse_glyph
,
6184 CGRectGetMinX (bounds
), CGRectGetMinY (bounds
),
6185 CGRectGetMaxX (bounds
), CGRectGetMaxY (bounds
));
6187 help_echo_object
= help_echo_window
= Qnil
;
6189 help_echo_string
= PROP (TOOL_BAR_ITEM_HELP
);
6190 if (NILP (help_echo_string
))
6191 help_echo_string
= PROP (TOOL_BAR_ITEM_CAPTION
);
6197 mac_handle_toolbar_command_event (next_handler
, event
, data
)
6198 EventHandlerCallRef next_handler
;
6202 OSStatus err
, result
= eventNotHandledErr
;
6203 struct frame
*f
= (struct frame
*) data
;
6206 err
= GetEventParameter (event
, kEventParamDirectObject
,
6207 typeHICommand
, NULL
,
6208 sizeof (HICommand
), NULL
, &command
);
6212 switch (GetEventKind (event
))
6214 case kEventCommandProcess
:
6215 if (!TOOLBAR_ITEM_COMMAND_ID_P (command
.commandID
))
6216 result
= CallNextEventHandler (next_handler
, event
);
6219 int i
= TOOLBAR_ITEM_COMMAND_ID_VALUE (command
.commandID
);
6221 if (i
< f
->n_tool_bar_items
6222 && !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
)))
6225 struct input_event buf
;
6229 XSETFRAME (frame
, f
);
6230 buf
.kind
= TOOL_BAR_EVENT
;
6231 buf
.frame_or_window
= frame
;
6233 kbd_buffer_store_event (&buf
);
6235 buf
.kind
= TOOL_BAR_EVENT
;
6236 buf
.frame_or_window
= frame
;
6237 buf
.arg
= PROP (TOOL_BAR_ITEM_KEY
);
6238 buf
.modifiers
= mac_event_to_emacs_modifiers (event
);
6239 kbd_buffer_store_event (&buf
);
6253 #endif /* USE_MAC_TOOLBAR */
6256 /***********************************************************************
6258 ***********************************************************************/
6260 /* Set clipping for output in glyph row ROW. W is the window in which
6261 we operate. GC is the graphics context to set clipping in.
6263 ROW may be a text row or, e.g., a mode line. Text rows must be
6264 clipped to the interior of the window dedicated to text display,
6265 mode lines must be clipped to the whole window. */
6268 x_clip_to_row (w
, row
, area
, gc
)
6270 struct glyph_row
*row
;
6274 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
6276 int window_x
, window_y
, window_width
;
6278 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
6280 clip_rect
.left
= window_x
;
6281 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
6282 clip_rect
.top
= max (clip_rect
.top
, window_y
);
6283 clip_rect
.right
= clip_rect
.left
+ window_width
;
6284 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
6286 mac_set_clip_rectangles (FRAME_MAC_DISPLAY (f
), gc
, &clip_rect
, 1);
6290 /* Draw a hollow box cursor on window W in glyph row ROW. */
6293 x_draw_hollow_cursor (w
, row
)
6295 struct glyph_row
*row
;
6297 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
6298 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
6299 Display
*dpy
= FRAME_MAC_DISPLAY (f
);
6302 struct glyph
*cursor_glyph
;
6305 /* Get the glyph the cursor is on. If we can't tell because
6306 the current matrix is invalid or such, give up. */
6307 cursor_glyph
= get_phys_cursor_glyph (w
);
6308 if (cursor_glyph
== NULL
)
6311 /* Compute frame-relative coordinates for phys cursor. */
6312 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &x
, &y
, &h
);
6313 wd
= w
->phys_cursor_width
;
6315 /* The foreground of cursor_gc is typically the same as the normal
6316 background color, which can cause the cursor box to be invisible. */
6317 xgcv
.foreground
= f
->output_data
.mac
->cursor_pixel
;
6318 if (dpyinfo
->scratch_cursor_gc
)
6319 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
6321 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_MAC_WINDOW (f
),
6322 GCForeground
, &xgcv
);
6323 gc
= dpyinfo
->scratch_cursor_gc
;
6325 /* Set clipping, draw the rectangle, and reset clipping again. */
6326 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
6327 mac_draw_rectangle (f
, gc
, x
, y
, wd
, h
- 1);
6328 mac_reset_clip_rectangles (dpy
, gc
);
6332 /* Draw a bar cursor on window W in glyph row ROW.
6334 Implementation note: One would like to draw a bar cursor with an
6335 angle equal to the one given by the font property XA_ITALIC_ANGLE.
6336 Unfortunately, I didn't find a font yet that has this property set.
6340 x_draw_bar_cursor (w
, row
, width
, kind
)
6342 struct glyph_row
*row
;
6344 enum text_cursor_kinds kind
;
6346 struct frame
*f
= XFRAME (w
->frame
);
6347 struct glyph
*cursor_glyph
;
6349 /* If cursor is out of bounds, don't draw garbage. This can happen
6350 in mini-buffer windows when switching between echo area glyphs
6352 cursor_glyph
= get_phys_cursor_glyph (w
);
6353 if (cursor_glyph
== NULL
)
6356 /* If on an image, draw like a normal cursor. That's usually better
6357 visible than drawing a bar, esp. if the image is large so that
6358 the bar might not be in the window. */
6359 if (cursor_glyph
->type
== IMAGE_GLYPH
)
6361 struct glyph_row
*row
;
6362 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
6363 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
6367 Display
*dpy
= FRAME_MAC_DISPLAY (f
);
6368 Window window
= FRAME_MAC_WINDOW (f
);
6369 GC gc
= FRAME_MAC_DISPLAY_INFO (f
)->scratch_cursor_gc
;
6370 unsigned long mask
= GCForeground
| GCBackground
;
6371 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
6374 /* If the glyph's background equals the color we normally draw
6375 the bar cursor in, the bar cursor in its normal color is
6376 invisible. Use the glyph's foreground color instead in this
6377 case, on the assumption that the glyph's colors are chosen so
6378 that the glyph is legible. */
6379 if (face
->background
== f
->output_data
.mac
->cursor_pixel
)
6380 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
6382 xgcv
.background
= xgcv
.foreground
= f
->output_data
.mac
->cursor_pixel
;
6385 XChangeGC (dpy
, gc
, mask
, &xgcv
);
6388 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
6389 FRAME_MAC_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
6393 width
= FRAME_CURSOR_WIDTH (f
);
6394 width
= min (cursor_glyph
->pixel_width
, width
);
6396 w
->phys_cursor_width
= width
;
6397 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
6399 if (kind
== BAR_CURSOR
)
6400 mac_fill_rectangle (f
, gc
,
6401 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
6402 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
6403 width
, row
->height
);
6405 mac_fill_rectangle (f
, gc
,
6406 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
6407 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
6408 row
->height
- width
),
6409 cursor_glyph
->pixel_width
,
6412 mac_reset_clip_rectangles (dpy
, gc
);
6417 /* RIF: Define cursor CURSOR on frame F. */
6420 mac_define_frame_cursor (f
, cursor
)
6424 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
6426 if (dpyinfo
->x_focus_frame
== f
)
6427 SetThemeCursor (cursor
);
6431 /* RIF: Clear area on frame F. */
6434 mac_clear_frame_area (f
, x
, y
, width
, height
)
6436 int x
, y
, width
, height
;
6438 mac_clear_area (f
, x
, y
, width
, height
);
6442 /* RIF: Draw cursor on window W. */
6445 mac_draw_window_cursor (w
, glyph_row
, x
, y
, cursor_type
, cursor_width
, on_p
, active_p
)
6447 struct glyph_row
*glyph_row
;
6449 int cursor_type
, cursor_width
;
6454 w
->phys_cursor_type
= cursor_type
;
6455 w
->phys_cursor_on_p
= 1;
6457 if (glyph_row
->exact_window_width_line_p
6458 && w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])
6460 glyph_row
->cursor_in_fringe_p
= 1;
6461 draw_fringe_bitmap (w
, glyph_row
, 0);
6464 switch (cursor_type
)
6466 case HOLLOW_BOX_CURSOR
:
6467 x_draw_hollow_cursor (w
, glyph_row
);
6470 case FILLED_BOX_CURSOR
:
6471 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
6475 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
6479 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
6483 w
->phys_cursor_width
= 0;
6495 #if 0 /* MAC_TODO: no icon support yet. */
6497 x_bitmap_icon (f
, icon
)
6503 if (FRAME_W32_WINDOW (f
) == 0)
6507 hicon
= LoadIcon (hinst
, EMACS_CLASS
);
6508 else if (STRINGP (icon
))
6509 hicon
= LoadImage (NULL
, (LPCTSTR
) SDATA (icon
), IMAGE_ICON
, 0, 0,
6510 LR_DEFAULTSIZE
| LR_LOADFROMFILE
);
6511 else if (SYMBOLP (icon
))
6515 if (EQ (icon
, intern ("application")))
6516 name
= (LPCTSTR
) IDI_APPLICATION
;
6517 else if (EQ (icon
, intern ("hand")))
6518 name
= (LPCTSTR
) IDI_HAND
;
6519 else if (EQ (icon
, intern ("question")))
6520 name
= (LPCTSTR
) IDI_QUESTION
;
6521 else if (EQ (icon
, intern ("exclamation")))
6522 name
= (LPCTSTR
) IDI_EXCLAMATION
;
6523 else if (EQ (icon
, intern ("asterisk")))
6524 name
= (LPCTSTR
) IDI_ASTERISK
;
6525 else if (EQ (icon
, intern ("winlogo")))
6526 name
= (LPCTSTR
) IDI_WINLOGO
;
6530 hicon
= LoadIcon (NULL
, name
);
6538 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_BIG
,
6543 #endif /* MAC_TODO */
6545 /************************************************************************
6547 ************************************************************************/
6549 /* Display Error Handling functions not used on W32. Listing them here
6550 helps diff stay in step when comparing w32term.c with xterm.c.
6552 x_error_catcher (display, error)
6553 x_catch_errors (dpy)
6554 x_catch_errors_unwind (old_val)
6555 x_check_errors (dpy, format)
6556 x_had_errors_p (dpy)
6557 x_clear_errors (dpy)
6558 x_uncatch_errors (dpy, count)
6560 x_connection_signal (signalnum)
6561 x_connection_closed (dpy, error_message)
6562 x_error_quitter (display, error)
6563 x_error_handler (display, error)
6564 x_io_error_quitter (display)
6569 /* Changing the font of the frame. */
6571 /* Give frame F the font named FONTNAME as its default font, and
6572 return the full name of that font. FONTNAME may be a wildcard
6573 pattern; in that case, we choose some font that fits the pattern.
6574 The return value shows which font we chose. */
6577 x_new_font (f
, fontname
)
6579 register char *fontname
;
6581 struct font_info
*fontp
6582 = FS_LOAD_FONT (f
, fontname
);
6587 if (FRAME_FONT (f
) == (XFontStruct
*) (fontp
->font
))
6588 /* This font is already set in frame F. There's nothing more to
6590 return build_string (fontp
->full_name
);
6592 FRAME_FONT (f
) = (XFontStruct
*) (fontp
->font
);
6593 FRAME_BASELINE_OFFSET (f
) = fontp
->baseline_offset
;
6594 FRAME_FONTSET (f
) = -1;
6596 FRAME_COLUMN_WIDTH (f
) = fontp
->average_width
;
6597 FRAME_SPACE_WIDTH (f
) = fontp
->space_width
;
6598 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (FRAME_FONT (f
));
6600 compute_fringe_widths (f
, 1);
6602 /* Compute the scroll bar width in character columns. */
6603 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
6605 int wid
= FRAME_COLUMN_WIDTH (f
);
6606 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
6607 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
-1) / wid
;
6611 int wid
= FRAME_COLUMN_WIDTH (f
);
6612 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
6615 /* Now make the frame display the given font. */
6616 if (FRAME_MAC_WINDOW (f
) != 0)
6618 XSetFont (FRAME_MAC_DISPLAY (f
), f
->output_data
.mac
->normal_gc
,
6620 XSetFont (FRAME_MAC_DISPLAY (f
), f
->output_data
.mac
->reverse_gc
,
6622 XSetFont (FRAME_MAC_DISPLAY (f
), f
->output_data
.mac
->cursor_gc
,
6625 /* Don't change the size of a tip frame; there's no point in
6626 doing it because it's done in Fx_show_tip, and it leads to
6627 problems because the tip frame has no widget. */
6628 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
6629 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
6632 return build_string (fontp
->full_name
);
6635 /* Give frame F the fontset named FONTSETNAME as its default fontset,
6636 and return the full name of that fontset. FONTSETNAME may be a
6637 wildcard pattern; in that case, we choose some fontset that fits
6638 the pattern. FONTSETNAME may be a font name for ASCII characters;
6639 in that case, we create a fontset from that font name.
6641 The return value shows which fontset we chose.
6642 If FONTSETNAME specifies the default fontset, return Qt.
6643 If an ASCII font in the specified fontset can't be loaded, return
6647 x_new_fontset (f
, fontsetname
)
6649 Lisp_Object fontsetname
;
6651 int fontset
= fs_query_fontset (fontsetname
, 0);
6654 if (fontset
> 0 && FRAME_FONTSET(f
) == fontset
)
6655 /* This fontset is already set in frame F. There's nothing more
6657 return fontset_name (fontset
);
6658 else if (fontset
== 0)
6659 /* The default fontset can't be the default font. */
6663 result
= x_new_font (f
, (SDATA (fontset_ascii (fontset
))));
6665 result
= x_new_font (f
, SDATA (fontsetname
));
6667 if (!STRINGP (result
))
6668 /* Can't load ASCII font. */
6672 fontset
= new_fontset_from_font_name (result
);
6674 /* Since x_new_font doesn't update any fontset information, do it now. */
6675 FRAME_FONTSET (f
) = fontset
;
6677 return fontset_name (fontset
);
6681 /***********************************************************************
6682 TODO: W32 Input Methods
6683 ***********************************************************************/
6684 /* Listing missing functions from xterm.c helps diff stay in step.
6686 xim_destroy_callback (xim, client_data, call_data)
6687 xim_open_dpy (dpyinfo, resource_name)
6689 xim_instantiate_callback (display, client_data, call_data)
6690 xim_initialize (dpyinfo, resource_name)
6691 xim_close_dpy (dpyinfo)
6697 mac_get_window_bounds (f
, inner
, outer
)
6699 Rect
*inner
, *outer
;
6701 #if TARGET_API_MAC_CARBON
6702 GetWindowBounds (FRAME_MAC_WINDOW (f
), kWindowContentRgn
, inner
);
6703 GetWindowBounds (FRAME_MAC_WINDOW (f
), kWindowStructureRgn
, outer
);
6704 #else /* not TARGET_API_MAC_CARBON */
6705 RgnHandle region
= NewRgn ();
6707 GetWindowRegion (FRAME_MAC_WINDOW (f
), kWindowContentRgn
, region
);
6708 *inner
= (*region
)->rgnBBox
;
6709 GetWindowRegion (FRAME_MAC_WINDOW (f
), kWindowStructureRgn
, region
);
6710 *outer
= (*region
)->rgnBBox
;
6711 DisposeRgn (region
);
6712 #endif /* not TARGET_API_MAC_CARBON */
6716 mac_handle_origin_change (f
)
6719 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
6723 mac_handle_size_change (f
, pixelwidth
, pixelheight
)
6725 int pixelwidth
, pixelheight
;
6729 cols
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
6730 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
6732 if (cols
!= FRAME_COLS (f
)
6733 || rows
!= FRAME_LINES (f
)
6734 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
6735 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
6737 /* We pass 1 for DELAY since we can't run Lisp code inside of
6739 change_frame_size (f
, rows
, cols
, 0, 1, 0);
6740 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
6741 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
6742 SET_FRAME_GARBAGED (f
);
6744 /* If cursor was outside the new size, mark it as off. */
6745 mark_window_cursors_off (XWINDOW (f
->root_window
));
6747 /* Clear out any recollection of where the mouse highlighting
6748 was, since it might be in a place that's outside the new
6749 frame size. Actually checking whether it is outside is a
6750 pain in the neck, so don't try--just let the highlighting be
6751 done afresh with new size. */
6752 cancel_mouse_face (f
);
6754 #if TARGET_API_MAC_CARBON
6755 if (f
->output_data
.mac
->hourglass_control
)
6758 mac_prepare_for_quickdraw (f
);
6760 MoveControl (f
->output_data
.mac
->hourglass_control
,
6761 pixelwidth
- HOURGLASS_WIDTH
, 0);
6768 /* Calculate the absolute position in frame F
6769 from its current recorded position values and gravity. */
6772 x_calc_absolute_position (f
)
6775 int width_diff
= 0, height_diff
= 0;
6776 int flags
= f
->size_hint_flags
;
6779 /* We have nothing to do if the current position
6780 is already for the top-left corner. */
6781 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
6784 /* Find the offsets of the outside upper-left corner of
6785 the inner window, with respect to the outer window. */
6787 mac_get_window_bounds (f
, &inner
, &outer
);
6790 width_diff
= (outer
.right
- outer
.left
) - (inner
.right
- inner
.left
);
6791 height_diff
= (outer
.bottom
- outer
.top
) - (inner
.bottom
- inner
.top
);
6793 /* Treat negative positions as relative to the leftmost bottommost
6794 position that fits on the screen. */
6795 if (flags
& XNegative
)
6796 f
->left_pos
= (FRAME_MAC_DISPLAY_INFO (f
)->width
6798 - FRAME_PIXEL_WIDTH (f
)
6801 if (flags
& YNegative
)
6802 f
->top_pos
= (FRAME_MAC_DISPLAY_INFO (f
)->height
6804 - FRAME_PIXEL_HEIGHT (f
)
6807 /* The left_pos and top_pos
6808 are now relative to the top and left screen edges,
6809 so the flags should correspond. */
6810 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6813 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
6814 to really change the position, and 0 when calling from
6815 x_make_frame_visible (in that case, XOFF and YOFF are the current
6816 position values). It is -1 when calling from x_set_frame_parameters,
6817 which means, do adjust for borders but don't change the gravity. */
6820 x_set_offset (f
, xoff
, yoff
, change_gravity
)
6822 register int xoff
, yoff
;
6825 if (change_gravity
> 0)
6829 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6831 f
->size_hint_flags
|= XNegative
;
6833 f
->size_hint_flags
|= YNegative
;
6834 f
->win_gravity
= NorthWestGravity
;
6836 x_calc_absolute_position (f
);
6839 x_wm_set_size_hint (f
, (long) 0, 0);
6841 #if TARGET_API_MAC_CARBON
6842 MoveWindowStructure (FRAME_MAC_WINDOW (f
), f
->left_pos
, f
->top_pos
);
6843 /* If the title bar is completely outside the screen, adjust the
6845 ConstrainWindowToScreen (FRAME_MAC_WINDOW (f
), kWindowTitleBarRgn
,
6846 kWindowConstrainMoveRegardlessOfFit
6847 | kWindowConstrainAllowPartial
, NULL
, NULL
);
6848 if (!NILP (tip_frame
) && XFRAME (tip_frame
) == f
)
6849 mac_handle_origin_change (f
);
6852 Rect inner
, outer
, screen_rect
, dummy
;
6853 RgnHandle region
= NewRgn ();
6855 mac_get_window_bounds (f
, &inner
, &outer
);
6856 f
->x_pixels_diff
= inner
.left
- outer
.left
;
6857 f
->y_pixels_diff
= inner
.top
- outer
.top
;
6858 MoveWindow (FRAME_MAC_WINDOW (f
), f
->left_pos
+ f
->x_pixels_diff
,
6859 f
->top_pos
+ f
->y_pixels_diff
, false);
6861 /* If the title bar is completely outside the screen, adjust the
6862 position. The variable `outer' holds the title bar rectangle.
6863 The variable `inner' holds slightly smaller one than `outer',
6864 so that the calculation of overlapping may not become too
6866 GetWindowRegion (FRAME_MAC_WINDOW (f
), kWindowTitleBarRgn
, region
);
6867 outer
= (*region
)->rgnBBox
;
6868 DisposeRgn (region
);
6870 InsetRect (&inner
, 8, 8);
6871 screen_rect
= qd
.screenBits
.bounds
;
6872 screen_rect
.top
+= GetMBarHeight ();
6874 if (!SectRect (&inner
, &screen_rect
, &dummy
))
6876 if (inner
.right
<= screen_rect
.left
)
6877 f
->left_pos
= screen_rect
.left
;
6878 else if (inner
.left
>= screen_rect
.right
)
6879 f
->left_pos
= screen_rect
.right
- (outer
.right
- outer
.left
);
6881 if (inner
.bottom
<= screen_rect
.top
)
6882 f
->top_pos
= screen_rect
.top
;
6883 else if (inner
.top
>= screen_rect
.bottom
)
6884 f
->top_pos
= screen_rect
.bottom
- (outer
.bottom
- outer
.top
);
6886 MoveWindow (FRAME_MAC_WINDOW (f
), f
->left_pos
+ f
->x_pixels_diff
,
6887 f
->top_pos
+ f
->y_pixels_diff
, false);
6895 /* Call this to change the size of frame F's x-window.
6896 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
6897 for this size change and subsequent size changes.
6898 Otherwise we leave the window gravity unchanged. */
6901 x_set_window_size (f
, change_gravity
, cols
, rows
)
6906 int pixelwidth
, pixelheight
;
6910 check_frame_size (f
, &rows
, &cols
);
6911 f
->scroll_bar_actual_width
6912 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
6914 compute_fringe_widths (f
, 0);
6916 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
6917 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
);
6919 f
->win_gravity
= NorthWestGravity
;
6920 x_wm_set_size_hint (f
, (long) 0, 0);
6922 SizeWindow (FRAME_MAC_WINDOW (f
), pixelwidth
, pixelheight
, 0);
6924 #if TARGET_API_MAC_CARBON
6925 if (!NILP (tip_frame
) && f
== XFRAME (tip_frame
))
6927 mac_handle_size_change (f
, pixelwidth
, pixelheight
);
6929 if (f
->output_data
.mac
->internal_border_width
6930 != FRAME_INTERNAL_BORDER_WIDTH (f
))
6932 mac_clear_window (f
);
6933 f
->output_data
.mac
->internal_border_width
6934 = FRAME_INTERNAL_BORDER_WIDTH (f
);
6937 SET_FRAME_GARBAGED (f
);
6942 /* Mouse warping. */
6944 void x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
);
6947 x_set_mouse_position (f
, x
, y
)
6953 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
6954 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
6956 if (pix_x
< 0) pix_x
= 0;
6957 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
6959 if (pix_y
< 0) pix_y
= 0;
6960 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
6962 x_set_mouse_pixel_position (f
, pix_x
, pix_y
);
6966 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
6971 pix_x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
6972 pix_y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
6975 CGWarpMouseCursorPosition (CGPointMake (pix_x
, pix_y
));
6978 #if 0 /* MAC_TODO: LMSetMouseLocation and CursorDeviceMoveTo are non-Carbon */
6981 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
6982 0, 0, 0, 0, pix_x
, pix_y
);
6988 /* focus shifting, raising and lowering. */
6991 x_focus_on_frame (f
)
6994 #if 0 /* This proves to be unpleasant. */
6998 /* I don't think that the ICCCM allows programs to do things like this
6999 without the interaction of the window manager. Whatever you end up
7000 doing with this code, do it to x_unfocus_frame too. */
7001 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
7002 RevertToPointerRoot
, CurrentTime
);
7012 /* Raise frame F. */
7018 if (f
->async_visible
)
7021 BringToFront (FRAME_MAC_WINDOW (f
));
7026 /* Lower frame F. */
7032 if (f
->async_visible
)
7035 SendBehind (FRAME_MAC_WINDOW (f
), NULL
);
7041 XTframe_raise_lower (f
, raise_flag
)
7051 /* Change of visibility. */
7054 mac_handle_visibility_change (f
)
7057 WindowRef wp
= FRAME_MAC_WINDOW (f
);
7058 int visible
= 0, iconified
= 0;
7059 struct input_event buf
;
7061 if (IsWindowVisible (wp
))
7063 if (IsWindowCollapsed (wp
))
7069 if (!f
->async_visible
&& visible
)
7073 /* wait_reading_process_output will notice this and update
7074 the frame's display structures. If we were made
7075 invisible, we should not set garbaged, because that stops
7076 redrawing on Update events. */
7077 SET_FRAME_GARBAGED (f
);
7080 buf
.kind
= DEICONIFY_EVENT
;
7081 XSETFRAME (buf
.frame_or_window
, f
);
7083 kbd_buffer_store_event (&buf
);
7085 else if (! NILP (Vframe_list
) && ! NILP (XCDR (Vframe_list
)))
7086 /* Force a redisplay sooner or later to update the
7087 frame titles in case this is the second frame. */
7088 record_asynch_buffer_change ();
7090 else if (f
->async_visible
&& !visible
)
7094 buf
.kind
= ICONIFY_EVENT
;
7095 XSETFRAME (buf
.frame_or_window
, f
);
7097 kbd_buffer_store_event (&buf
);
7100 f
->async_visible
= visible
;
7101 f
->async_iconified
= iconified
;
7104 /* This tries to wait until the frame is really visible.
7105 However, if the window manager asks the user where to position
7106 the frame, this will return before the user finishes doing that.
7107 The frame will not actually be visible at that time,
7108 but it will become visible later when the window manager
7109 finishes with it. */
7112 x_make_frame_visible (f
)
7117 if (! FRAME_VISIBLE_P (f
))
7119 /* We test FRAME_GARBAGED_P here to make sure we don't
7120 call x_set_offset a second time
7121 if we get to x_make_frame_visible a second time
7122 before the window gets really visible. */
7123 if (! FRAME_ICONIFIED_P (f
)
7124 && ! f
->output_data
.mac
->asked_for_visible
)
7125 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
7127 f
->output_data
.mac
->asked_for_visible
= 1;
7129 CollapseWindow (FRAME_MAC_WINDOW (f
), false);
7130 ShowWindow (FRAME_MAC_WINDOW (f
));
7133 XFlush (FRAME_MAC_DISPLAY (f
));
7135 /* Synchronize to ensure Emacs knows the frame is visible
7136 before we do anything else. We do this loop with input not blocked
7137 so that incoming events are handled. */
7142 /* This must come after we set COUNT. */
7145 XSETFRAME (frame
, f
);
7147 /* Wait until the frame is visible. Process X events until a
7148 MapNotify event has been seen, or until we think we won't get a
7149 MapNotify at all.. */
7150 for (count
= input_signal_count
+ 10;
7151 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
7153 /* Force processing of queued events. */
7156 /* Machines that do polling rather than SIGIO have been
7157 observed to go into a busy-wait here. So we'll fake an
7158 alarm signal to let the handler know that there's something
7159 to be read. We used to raise a real alarm, but it seems
7160 that the handler isn't always enabled here. This is
7162 if (input_polling_used ())
7164 /* It could be confusing if a real alarm arrives while
7165 processing the fake one. Turn it off and let the
7166 handler reset it. */
7167 extern void poll_for_input_1
P_ ((void));
7168 int old_poll_suppress_count
= poll_suppress_count
;
7169 poll_suppress_count
= 1;
7170 poll_for_input_1 ();
7171 poll_suppress_count
= old_poll_suppress_count
;
7174 /* See if a MapNotify event has been processed. */
7175 FRAME_SAMPLE_VISIBILITY (f
);
7180 /* Change from mapped state to withdrawn state. */
7182 /* Make the frame visible (mapped and not iconified). */
7185 x_make_frame_invisible (f
)
7188 /* A deactivate event does not occur when the last visible frame is
7189 made invisible. So if we clear the highlight here, it will not
7190 be rehighlighted when it is made visible. */
7192 /* Don't keep the highlight on an invisible frame. */
7193 if (FRAME_MAC_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
7194 FRAME_MAC_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
7199 #if !TARGET_API_MAC_CARBON
7200 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
7201 that the current position of the window is user-specified, rather than
7202 program-specified, so that when the window is mapped again, it will be
7203 placed at the same location, without forcing the user to position it
7204 by hand again (they have already done that once for this window.) */
7205 x_wm_set_size_hint (f
, (long) 0, 1);
7208 HideWindow (FRAME_MAC_WINDOW (f
));
7212 #if !TARGET_API_MAC_CARBON
7213 mac_handle_visibility_change (f
);
7217 /* Change window state from mapped to iconified. */
7225 /* A deactivate event does not occur when the last visible frame is
7226 iconified. So if we clear the highlight here, it will not be
7227 rehighlighted when it is deiconified. */
7229 /* Don't keep the highlight on an invisible frame. */
7230 if (FRAME_MAC_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
7231 FRAME_MAC_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
7234 if (f
->async_iconified
)
7239 FRAME_SAMPLE_VISIBILITY (f
);
7241 if (! FRAME_VISIBLE_P (f
))
7242 ShowWindow (FRAME_MAC_WINDOW (f
));
7244 err
= CollapseWindow (FRAME_MAC_WINDOW (f
), true);
7249 error ("Can't notify window manager of iconification");
7251 #if !TARGET_API_MAC_CARBON
7252 mac_handle_visibility_change (f
);
7257 /* Free X resources of frame F. */
7260 x_free_frame_resources (f
)
7263 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
7264 WindowRef wp
= FRAME_MAC_WINDOW (f
);
7268 if (wp
!= tip_window
)
7269 remove_window_handler (wp
);
7272 mac_prepare_for_quickdraw (f
);
7275 if (wp
== tip_window
)
7276 /* Neither WaitNextEvent nor ReceiveNextEvent receives `window
7277 closed' event. So we reset tip_window here. */
7280 free_frame_menubar (f
);
7282 if (FRAME_FACE_CACHE (f
))
7283 free_frame_faces (f
);
7287 if (FRAME_SIZE_HINTS (f
))
7288 xfree (FRAME_SIZE_HINTS (f
));
7290 xfree (f
->output_data
.mac
);
7291 f
->output_data
.mac
= NULL
;
7293 if (f
== dpyinfo
->x_focus_frame
)
7295 dpyinfo
->x_focus_frame
= 0;
7296 #if USE_MAC_FONT_PANEL
7297 mac_set_font_info_for_selection (NULL
, DEFAULT_FACE_ID
, 0);
7300 if (f
== dpyinfo
->x_focus_event_frame
)
7301 dpyinfo
->x_focus_event_frame
= 0;
7302 if (f
== dpyinfo
->x_highlight_frame
)
7303 dpyinfo
->x_highlight_frame
= 0;
7305 if (f
== dpyinfo
->mouse_face_mouse_frame
)
7307 dpyinfo
->mouse_face_beg_row
7308 = dpyinfo
->mouse_face_beg_col
= -1;
7309 dpyinfo
->mouse_face_end_row
7310 = dpyinfo
->mouse_face_end_col
= -1;
7311 dpyinfo
->mouse_face_window
= Qnil
;
7312 dpyinfo
->mouse_face_deferred_gc
= 0;
7313 dpyinfo
->mouse_face_mouse_frame
= 0;
7320 /* Destroy the X window of frame F. */
7323 x_destroy_window (f
)
7326 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
7328 x_free_frame_resources (f
);
7330 dpyinfo
->reference_count
--;
7334 /* Setting window manager hints. */
7336 /* Set the normal size hints for the window manager, for frame F.
7337 FLAGS is the flags word to use--or 0 meaning preserve the flags
7338 that the window now has.
7339 If USER_POSITION is nonzero, we set the USPosition
7340 flag (this is useful when FLAGS is 0). */
7342 x_wm_set_size_hint (f
, flags
, user_position
)
7347 int base_width
, base_height
, width_inc
, height_inc
;
7348 int min_rows
= 0, min_cols
= 0;
7349 XSizeHints
*size_hints
;
7351 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
7352 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
7353 width_inc
= FRAME_COLUMN_WIDTH (f
);
7354 height_inc
= FRAME_LINE_HEIGHT (f
);
7356 check_frame_size (f
, &min_rows
, &min_cols
);
7358 size_hints
= FRAME_SIZE_HINTS (f
);
7359 if (size_hints
== NULL
)
7361 size_hints
= FRAME_SIZE_HINTS (f
) = xmalloc (sizeof (XSizeHints
));
7362 bzero (size_hints
, sizeof (XSizeHints
));
7365 size_hints
->flags
|= PResizeInc
| PMinSize
| PBaseSize
;
7366 size_hints
->width_inc
= width_inc
;
7367 size_hints
->height_inc
= height_inc
;
7368 size_hints
->min_width
= base_width
+ min_cols
* width_inc
;
7369 size_hints
->min_height
= base_height
+ min_rows
* height_inc
;
7370 size_hints
->base_width
= base_width
;
7371 size_hints
->base_height
= base_height
;
7374 size_hints
->flags
= flags
;
7375 else if (user_position
)
7377 size_hints
->flags
&= ~ PPosition
;
7378 size_hints
->flags
|= USPosition
;
7382 #if 0 /* MAC_TODO: hide application instead of iconify? */
7383 /* Used for IconicState or NormalState */
7386 x_wm_set_window_state (f
, state
)
7390 #ifdef USE_X_TOOLKIT
7393 XtSetArg (al
[0], XtNinitialState
, state
);
7394 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
7395 #else /* not USE_X_TOOLKIT */
7396 Window window
= FRAME_X_WINDOW (f
);
7398 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
7399 f
->output_data
.x
->wm_hints
.initial_state
= state
;
7401 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
7402 #endif /* not USE_X_TOOLKIT */
7406 x_wm_set_icon_pixmap (f
, pixmap_id
)
7412 #ifndef USE_X_TOOLKIT
7413 Window window
= FRAME_X_WINDOW (f
);
7418 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
7419 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
7423 /* It seems there is no way to turn off use of an icon pixmap.
7424 The following line does it, only if no icon has yet been created,
7425 for some window managers. But with mwm it crashes.
7426 Some people say it should clear the IconPixmapHint bit in this case,
7427 but that doesn't work, and the X consortium said it isn't the
7428 right thing at all. Since there is no way to win,
7429 best to explicitly give up. */
7431 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
7437 #ifdef USE_X_TOOLKIT /* same as in x_wm_set_window_state. */
7441 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
7442 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
7445 #else /* not USE_X_TOOLKIT */
7447 f
->output_data
.x
->wm_hints
.flags
|= IconPixmapHint
;
7448 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
7450 #endif /* not USE_X_TOOLKIT */
7453 #endif /* MAC_TODO */
7456 x_wm_set_icon_position (f
, icon_x
, icon_y
)
7460 #if 0 /* MAC_TODO: no icons on Mac */
7461 #ifdef USE_X_TOOLKIT
7462 Window window
= XtWindow (f
->output_data
.x
->widget
);
7464 Window window
= FRAME_X_WINDOW (f
);
7467 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
7468 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
7469 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
7471 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
7472 #endif /* MAC_TODO */
7476 /***********************************************************************
7478 ***********************************************************************/
7480 /* An XLFD pattern is divided into blocks delimited by '*'. This
7481 structure holds information for each block. */
7482 struct xlfdpat_block
7484 /* Length of the pattern string in this block. Non-zero except for
7485 the first and the last blocks. */
7488 /* Pattern string except the last character in this block. The last
7489 character is replaced with NUL in order to use it as a
7491 unsigned char *pattern
;
7493 /* Last character of the pattern string. Must not be '?'. */
7494 unsigned char last_char
;
7496 /* One of the tables for the Boyer-Moore string search. It
7497 specifies the number of positions to proceed for each character
7498 with which the match fails. */
7501 /* The skip value for the last character in the above `skip' is
7502 assigned to `infinity' in order to simplify a loop condition.
7503 The original value is saved here. */
7509 /* Normalized pattern string. "Normalized" means that capital
7510 letters are lowered, blocks are not empty except the first and
7511 the last ones, and trailing '?'s in a block that is not the last
7512 one are moved to the next one. The last character in each block
7513 is replaced with NUL. */
7516 /* Number of characters except '*'s and trailing '?'s in the
7517 normalized pattern string. */
7520 /* Number of trailing '?'s in the normalized pattern string. */
7521 int trailing_anychars
;
7523 /* Number of blocks and information for each block. The latter is
7524 NULL if the pattern is exact (no '*' or '?' in it). */
7526 struct xlfdpat_block
*blocks
;
7530 xlfdpat_destroy (pat
)
7531 struct xlfdpat
*pat
;
7538 xfree (pat
->blocks
);
7545 static struct xlfdpat
*
7546 xlfdpat_create (pattern
)
7547 const char *pattern
;
7549 struct xlfdpat
*pat
;
7550 int nblocks
, i
, skip
;
7551 unsigned char last_char
, *p
, *q
, *anychar_head
;
7552 const unsigned char *ptr
;
7553 struct xlfdpat_block
*blk
;
7555 pat
= xmalloc (sizeof (struct xlfdpat
));
7556 pat
->buf
= xmalloc (strlen (pattern
) + 1);
7558 /* Normalize the pattern string and store it to `pat->buf'. */
7560 anychar_head
= NULL
;
7563 for (ptr
= pattern
; *ptr
; ptr
++)
7565 unsigned char c
= *ptr
;
7568 if (last_char
== '*')
7569 /* ...a** -> ...a* */
7573 if (last_char
== '?')
7575 if (anychar_head
> pat
->buf
&& *(anychar_head
- 1) == '*')
7576 /* ...*??* -> ...*?? */
7579 /* ...a??* -> ...a*?? */
7581 *anychar_head
++ = '*';
7589 if (last_char
!= '?')
7593 /* On Mac OS X 10.3, tolower also converts non-ASCII
7594 characters for some locales. */
7598 *q
++ = last_char
= c
;
7602 pat
->nblocks
= nblocks
;
7603 if (last_char
!= '?')
7604 pat
->trailing_anychars
= 0;
7607 pat
->trailing_anychars
= q
- anychar_head
;
7610 pat
->nchars
= q
- pat
->buf
- (nblocks
- 1);
7612 if (anychar_head
== NULL
&& nblocks
== 1)
7614 /* The pattern is exact. */
7619 pat
->blocks
= xmalloc (sizeof (struct xlfdpat_block
) * nblocks
);
7621 /* Divide the normalized pattern into blocks. */
7623 for (blk
= pat
->blocks
; blk
< pat
->blocks
+ nblocks
- 1; blk
++)
7628 blk
->len
= p
- blk
->pattern
;
7632 blk
->len
= q
- blk
->pattern
;
7634 /* Setup a table for the Boyer-Moore string search. */
7635 for (blk
= pat
->blocks
; blk
< pat
->blocks
+ nblocks
; blk
++)
7638 blk
->last_char
= blk
->pattern
[blk
->len
- 1];
7639 blk
->pattern
[blk
->len
- 1] = '\0';
7641 for (skip
= 1; skip
< blk
->len
; skip
++)
7642 if (blk
->pattern
[blk
->len
- skip
- 1] == '?')
7645 for (i
= 0; i
< 256; i
++)
7646 blk
->skip
[i
] = skip
;
7648 p
= blk
->pattern
+ (blk
->len
- skip
);
7650 blk
->skip
[*p
++] = skip
;
7652 blk
->last_char_skip
= blk
->skip
[blk
->last_char
];
7659 xlfdpat_exact_p (pat
)
7660 struct xlfdpat
*pat
;
7662 return pat
->blocks
== NULL
;
7665 /* Return the first string in STRING + 0, ..., STRING + START_MAX such
7666 that the pattern in *BLK matches with its prefix. Return NULL
7667 there is no such strings. STRING must be lowered in advance. */
7670 xlfdpat_block_match_1 (blk
, string
, start_max
)
7671 struct xlfdpat_block
*blk
;
7672 const unsigned char *string
;
7675 int start
, infinity
;
7677 const unsigned char *s
;
7679 xassert (blk
->len
> 0);
7680 xassert (start_max
+ blk
->len
<= strlen (string
));
7681 xassert (blk
->last_char
!= '?');
7683 /* See the comments in the function `boyer_moore' (search.c) for the
7684 use of `infinity'. */
7685 infinity
= start_max
+ blk
->len
+ 1;
7686 blk
->skip
[blk
->last_char
] = infinity
;
7691 /* Check the last character of the pattern. */
7692 s
= string
+ blk
->len
- 1;
7695 start
+= blk
->skip
[*(s
+ start
)];
7697 while (start
<= start_max
);
7699 if (start
< infinity
)
7700 /* Couldn't find the last character. */
7703 /* No less than `infinity' means we could find the last
7704 character at `s[start - infinity]'. */
7707 /* Check the remaining characters. We prefer making no-'?'
7708 cases faster because the use of '?' is really rare. */
7713 while (*p
++ == *s
++)
7716 while (*(p
- 1) == '?');
7718 if (*(p
- 1) == '\0')
7720 return string
+ start
;
7723 start
+= blk
->last_char_skip
;
7725 while (start
<= start_max
);
7730 #define xlfdpat_block_match(b, s, m) \
7731 ((b)->len == 1 ? memchr ((s), (b)->last_char, (m) + 1) \
7732 : xlfdpat_block_match_1 (b, s, m))
7734 /* Check if XLFD pattern PAT, which is generated by `xlfdpat_create',
7735 matches with STRING. STRING must be lowered in advance. */
7738 xlfdpat_match (pat
, string
)
7739 struct xlfdpat
*pat
;
7740 const unsigned char *string
;
7742 int str_len
, nblocks
, i
, start_max
;
7743 struct xlfdpat_block
*blk
;
7744 const unsigned char *s
;
7746 xassert (pat
->nblocks
> 0);
7748 if (xlfdpat_exact_p (pat
))
7749 return strcmp (pat
->buf
, string
) == 0;
7751 /* The number of the characters in the string must not be smaller
7752 than that in the pattern. */
7753 str_len
= strlen (string
);
7754 if (str_len
< pat
->nchars
+ pat
->trailing_anychars
)
7757 /* Chop off the trailing '?'s. */
7758 str_len
-= pat
->trailing_anychars
;
7760 /* The last block. When it is non-empty, it must match at the end
7762 nblocks
= pat
->nblocks
;
7763 blk
= pat
->blocks
+ (nblocks
- 1);
7765 /* The last block is also the first one. */
7766 return (str_len
== blk
->len
7767 && (blk
->len
== 0 || xlfdpat_block_match (blk
, string
, 0)));
7768 else if (blk
->len
!= 0)
7769 if (!xlfdpat_block_match (blk
, string
+ (str_len
- blk
->len
), 0))
7772 /* The first block. When it is non-empty, it must match at the
7773 beginning of the string. */
7777 s
= xlfdpat_block_match (blk
, string
, 0);
7780 string
= s
+ blk
->len
;
7783 /* The rest of the blocks. */
7784 start_max
= str_len
- pat
->nchars
;
7785 for (i
= 1, blk
++; i
< nblocks
- 1; i
++, blk
++)
7787 s
= xlfdpat_block_match (blk
, string
, start_max
);
7790 start_max
-= s
- string
;
7791 string
= s
+ blk
->len
;
7798 /***********************************************************************
7800 ***********************************************************************/
7802 /* Return a pointer to struct font_info of font FONT_IDX of frame F. */
7805 x_get_font_info (f
, font_idx
)
7809 return (FRAME_MAC_FONT_TABLE (f
) + font_idx
);
7812 /* the global font name table */
7813 static char **font_name_table
= NULL
;
7814 static int font_name_table_size
= 0;
7815 static int font_name_count
= 0;
7817 /* Alist linking font family names to Font Manager font family
7818 references (which can also be used as QuickDraw font IDs). We use
7819 an alist because hash tables are not ready when the terminal frame
7820 for Mac OS Classic is created. */
7821 static Lisp_Object fm_font_family_alist
;
7823 /* Hash table linking font family names to ATSU font IDs. */
7824 static Lisp_Object atsu_font_id_hash
;
7825 /* Alist linking Font Manager style to face attributes. */
7826 static Lisp_Object fm_style_face_attributes_alist
;
7827 extern Lisp_Object QCfamily
, QCweight
, QCslant
, Qnormal
, Qbold
, Qitalic
;
7830 /* Alist linking character set strings to Mac text encoding and Emacs
7832 static Lisp_Object Vmac_charset_info_alist
;
7835 create_text_encoding_info_alist ()
7837 Lisp_Object result
= Qnil
, rest
;
7839 for (rest
= Vmac_charset_info_alist
; CONSP (rest
); rest
= XCDR (rest
))
7841 Lisp_Object charset_info
= XCAR (rest
);
7842 Lisp_Object charset
, coding_system
, text_encoding
;
7843 Lisp_Object existing_info
;
7845 if (!(CONSP (charset_info
)
7846 && (charset
= XCAR (charset_info
),
7848 && CONSP (XCDR (charset_info
))
7849 && (text_encoding
= XCAR (XCDR (charset_info
)),
7850 INTEGERP (text_encoding
))
7851 && CONSP (XCDR (XCDR (charset_info
)))
7852 && (coding_system
= XCAR (XCDR (XCDR (charset_info
))),
7853 SYMBOLP (coding_system
))))
7856 existing_info
= assq_no_quit (text_encoding
, result
);
7857 if (NILP (existing_info
))
7858 result
= Fcons (list3 (text_encoding
, coding_system
, charset
),
7861 if (NILP (Fmember (charset
, XCDR (XCDR (existing_info
)))))
7862 XSETCDR (XCDR (existing_info
),
7863 Fcons (charset
, XCDR (XCDR (existing_info
))));
7871 decode_mac_font_name (name
, size
, coding_system
)
7874 Lisp_Object coding_system
;
7876 struct coding_system coding
;
7879 if (!NILP (coding_system
) && !NILP (Fcoding_system_p (coding_system
)))
7881 for (p
= name
; *p
; p
++)
7882 if (!isascii (*p
) || iscntrl (*p
))
7887 setup_coding_system (coding_system
, &coding
);
7888 coding
.src_multibyte
= 0;
7889 coding
.dst_multibyte
= 1;
7890 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
7891 coding
.dst_bytes
= size
;
7892 coding
.destination
= (unsigned char *) alloca (coding
.dst_bytes
);
7894 decode_coding_c_string (&coding
, name
, strlen (name
), Qnil
);
7895 bcopy (coding
.destination
, name
, min (coding
.produced
, size
));
7896 name
[min (coding
.produced
, size
)] = '\0';
7900 /* If there's just one occurrence of '-' in the family name, it is
7901 replaced with '_'. (More than one occurrence of '-' means a
7902 "FOUNDRY-FAMILY-CHARSET"-style name.) */
7903 p
= strchr (name
, '-');
7904 if (p
&& strchr (p
+ 1, '-') == NULL
)
7907 for (p
= name
; *p
; p
++)
7908 /* On Mac OS X 10.3, tolower also converts non-ASCII characters
7909 for some locales. */
7916 mac_to_x_fontname (name
, size
, style
, charset
)
7924 char xf
[256], *result
;
7927 if (sscanf (name
, "%31[^-]-%255[^-]-%31s", foundry
, family
, cs
) == 3)
7931 strcpy(foundry
, "Apple");
7932 strcpy(family
, name
);
7935 sprintf (xf
, "%s-%c-normal--%d-%d-%d-%d-m-%d-%s",
7936 style
& bold
? "bold" : "medium", style
& italic
? 'i' : 'r',
7937 size
, size
* 10, size
? 72 : 0, size
? 72 : 0, size
* 10, charset
);
7939 result
= xmalloc (strlen (foundry
) + strlen (family
) + strlen (xf
) + 3 + 1);
7940 sprintf (result
, "-%s-%s-%s", foundry
, family
, xf
);
7941 for (p
= result
; *p
; p
++)
7942 /* On Mac OS X 10.3, tolower also converts non-ASCII characters
7943 for some locales. */
7950 /* Parse fully-specified and instantiated X11 font spec XF, and store
7951 the results to FAMILY, *SIZE, *STYLE, and CHARSET. Return 1 if the
7952 parsing succeeded, and 0 otherwise. For FAMILY and CHARSET, the
7953 caller must allocate at least 256 and 32 bytes respectively. For
7954 ordinary Mac fonts, the value stored to FAMILY should just be their
7955 names, like "monaco", "Taipei", etc. Fonts converted from the GNU
7956 intlfonts collection contain their charset designation in their
7957 names, like "ETL-Fixed-iso8859-1", "ETL-Fixed-koi8-r", etc. Both
7958 types of font names are handled accordingly. */
7960 const int kDefaultFontSize
= 12;
7963 parse_x_font_name (xf
, family
, size
, style
, charset
)
7970 Str31 foundry
, weight
;
7971 int point_size
, avgwidth
;
7974 if (sscanf (xf
, "-%31[^-]-%255[^-]-%31[^-]-%1[^-]-%*[^-]-%*[^-]-%d-%d-%*[^-]-%*[^-]-%*c-%d-%31s",
7975 foundry
, family
, weight
, slant
, size
,
7976 &point_size
, &avgwidth
, charset
) != 8
7977 && sscanf (xf
, "-%31[^-]-%255[^-]-%31[^-]-%1[^-]-%*[^-]--%d-%d-%*[^-]-%*[^-]-%*c-%d-%31s",
7978 foundry
, family
, weight
, slant
, size
,
7979 &point_size
, &avgwidth
, charset
) != 8)
7985 *size
= point_size
/ 10;
7986 else if (avgwidth
> 0)
7987 *size
= avgwidth
/ 10;
7990 *size
= kDefaultFontSize
;
7993 if (strcmp (weight
, "bold") == 0)
7998 if (NILP (Fassoc (build_string (charset
), Vmac_charset_info_alist
)))
8000 int foundry_len
= strlen (foundry
), family_len
= strlen (family
);
8002 if (foundry_len
+ family_len
+ strlen (charset
) + 2 < sizeof (Str255
))
8004 /* Like sprintf (family, "%s-%s-%s", foundry, family, charset),
8005 but take overlap into account. */
8006 memmove (family
+ foundry_len
+ 1, family
, family_len
);
8007 memcpy (family
, foundry
, foundry_len
);
8008 family
[foundry_len
] = '-';
8009 family
[foundry_len
+ 1 + family_len
] = '-';
8010 strcpy (family
+ foundry_len
+ 1 + family_len
+ 1, charset
);
8016 for (p
= family
; *p
; p
++)
8017 /* On Mac OS X 10.3, tolower also converts non-ASCII characters
8018 for some locales. */
8027 add_font_name_table_entry (char *font_name
)
8029 if (font_name_table_size
== 0)
8031 font_name_table_size
= 256;
8032 font_name_table
= (char **)
8033 xmalloc (font_name_table_size
* sizeof (char *));
8035 else if (font_name_count
+ 1 >= font_name_table_size
)
8037 font_name_table_size
*= 2;
8038 font_name_table
= (char **)
8039 xrealloc (font_name_table
,
8040 font_name_table_size
* sizeof (char *));
8043 font_name_table
[font_name_count
++] = font_name
;
8047 add_mac_font_name (name
, size
, style
, charset
)
8051 const char *charset
;
8054 add_font_name_table_entry (mac_to_x_fontname (name
, size
, style
, charset
));
8057 add_font_name_table_entry (mac_to_x_fontname (name
, 0, style
, charset
));
8058 add_font_name_table_entry (mac_to_x_fontname (name
, 0, italic
, charset
));
8059 add_font_name_table_entry (mac_to_x_fontname (name
, 0, bold
, charset
));
8060 add_font_name_table_entry (mac_to_x_fontname (name
, 0, italic
| bold
,
8067 fm_get_style_from_font (font
)
8071 FMFontStyle style
= normal
;
8074 FMFontFamily font_family
;
8075 #define FONT_HEADER_MAC_STYLE_OFFSET (4*4 + 2*2 + 8*2 + 2*4)
8077 /* FMGetFontFamilyInstanceFromFont returns `normal' as the style of
8078 some font (e.g., Optima) even if it is `bold'. */
8079 err
= FMGetFontTable (font
, 'head', FONT_HEADER_MAC_STYLE_OFFSET
,
8080 sizeof (mac_style
), &mac_style
, &len
);
8082 && len
>= FONT_HEADER_MAC_STYLE_OFFSET
+ sizeof (mac_style
))
8083 style
= EndianU16_BtoN (mac_style
);
8085 FMGetFontFamilyInstanceFromFont (font
, &font_family
, &style
);
8091 atsu_find_font_from_family_name (family
)
8094 struct Lisp_Hash_Table
*h
= XHASH_TABLE (atsu_font_id_hash
);
8097 Lisp_Object rest
, best
;
8098 FMFontStyle min_style
, style
;
8100 i
= hash_lookup (h
, make_unibyte_string (family
, strlen (family
)),
8103 return kATSUInvalidFontID
;
8105 rest
= HASH_VALUE (h
, i
);
8106 if (INTEGERP (rest
) || (CONSP (rest
) && INTEGERP (XCDR (rest
))))
8107 return cons_to_long (rest
);
8109 rest
= Fnreverse (rest
);
8113 && (min_style
= fm_get_style_from_font (cons_to_long (best
))) != normal
)
8116 style
= fm_get_style_from_font (cons_to_long (XCAR (rest
)));
8117 if (style
< min_style
)
8120 if (style
== normal
)
8127 while (!NILP (rest
));
8129 HASH_VALUE (h
, i
) = best
;
8130 return cons_to_long (best
);
8134 fm_style_to_face_attributes (fm_style
)
8135 FMFontStyle fm_style
;
8139 fm_style
&= (bold
| italic
);
8140 tem
= assq_no_quit (make_number (fm_style
),
8141 fm_style_face_attributes_alist
);
8145 tem
= list4 (QCweight
, fm_style
& bold
? Qbold
: Qnormal
,
8146 QCslant
, fm_style
& italic
? Qitalic
: Qnormal
);
8147 fm_style_face_attributes_alist
=
8148 Fcons (Fcons (make_number (fm_style
), tem
),
8149 fm_style_face_attributes_alist
);
8155 atsu_find_font_family_name (font_id
)
8160 Lisp_Object family
= Qnil
;
8162 err
= ATSUFindFontName (font_id
, kFontFamilyName
,
8163 kFontMacintoshPlatform
, kFontNoScript
,
8164 kFontNoLanguage
, 0, NULL
, &len
, NULL
);
8167 family
= make_uninit_string (len
);
8168 err
= ATSUFindFontName (font_id
, kFontFamilyName
,
8169 kFontMacintoshPlatform
, kFontNoScript
,
8170 kFontNoLanguage
, len
, SDATA (family
),
8174 decode_mac_font_name (SDATA (family
), len
+ 1, Qnil
);
8180 mac_atsu_font_face_attributes (font_id
)
8183 Lisp_Object family
, style_attrs
;
8185 family
= atsu_find_font_family_name (font_id
);
8188 style_attrs
= fm_style_to_face_attributes (fm_get_style_from_font (font_id
));
8189 return Fcons (QCfamily
, Fcons (family
, style_attrs
));
8193 /* Sets up the table font_name_table to contain the list of all fonts
8194 in the system the first time the table is used so that the Resource
8195 Manager need not be accessed every time this information is
8199 init_font_name_table ()
8201 #if TARGET_API_MAC_CARBON
8202 FMFontFamilyIterator ffi
;
8203 FMFontFamilyInstanceIterator ffii
;
8205 Lisp_Object text_encoding_info_alist
;
8206 struct gcpro gcpro1
;
8208 text_encoding_info_alist
= create_text_encoding_info_alist ();
8211 #if USE_CG_TEXT_DRAWING
8212 init_cg_text_anti_aliasing_threshold ();
8214 if (!NILP (assq_no_quit (make_number (kTextEncodingMacUnicode
),
8215 text_encoding_info_alist
)))
8218 struct Lisp_Hash_Table
*h
;
8220 ItemCount nfonts
, i
;
8221 ATSUFontID
*font_ids
= NULL
;
8222 Lisp_Object prev_family
= Qnil
;
8226 make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
8227 make_float (DEFAULT_REHASH_SIZE
),
8228 make_float (DEFAULT_REHASH_THRESHOLD
),
8230 h
= XHASH_TABLE (atsu_font_id_hash
);
8232 err
= ATSUFontCount (&nfonts
);
8235 font_ids
= xmalloc (sizeof (ATSUFontID
) * nfonts
);
8236 err
= ATSUGetFontIDs (font_ids
, nfonts
, NULL
);
8239 for (i
= 0; i
< nfonts
; i
++)
8243 family
= atsu_find_font_family_name (font_ids
[i
]);
8244 if (NILP (family
) || SREF (family
, 0) == '.')
8246 if (!NILP (Fequal (prev_family
, family
)))
8247 family
= prev_family
;
8249 j
= hash_lookup (h
, family
, &hash_code
);
8252 add_mac_font_name (SDATA (family
), 0, normal
, "iso10646-1");
8253 j
= hash_put (h
, family
, Fcons (long_to_cons (font_ids
[i
]),
8256 else if (EQ (prev_family
, family
))
8257 HASH_VALUE (h
, j
) = Fcons (long_to_cons (font_ids
[i
]),
8259 prev_family
= family
;
8266 /* Create a dummy instance iterator here to avoid creating and
8267 destroying it in the loop. */
8268 if (FMCreateFontFamilyInstanceIterator (0, &ffii
) != noErr
)
8270 /* Create an iterator to enumerate the font families. */
8271 if (FMCreateFontFamilyIterator (NULL
, NULL
, kFMDefaultOptions
, &ffi
)
8274 FMDisposeFontFamilyInstanceIterator (&ffii
);
8278 GCPRO1 (text_encoding_info_alist
);
8280 while (FMGetNextFontFamily (&ffi
, &ff
) == noErr
)
8286 TextEncoding encoding
;
8287 TextEncodingBase sc
;
8288 Lisp_Object text_encoding_info
, family
;
8290 if (FMGetFontFamilyName (ff
, name
) != noErr
)
8296 if (FMGetFontFamilyTextEncoding (ff
, &encoding
) != noErr
)
8298 sc
= GetTextEncodingBase (encoding
);
8299 text_encoding_info
= assq_no_quit (make_number (sc
),
8300 text_encoding_info_alist
);
8301 if (NILP (text_encoding_info
))
8302 text_encoding_info
= assq_no_quit (make_number (kTextEncodingMacRoman
),
8303 text_encoding_info_alist
);
8304 decode_mac_font_name (name
, sizeof (name
),
8305 XCAR (XCDR (text_encoding_info
)));
8306 family
= build_string (name
);
8307 if (!NILP (Fassoc (family
, fm_font_family_alist
)))
8309 fm_font_family_alist
= Fcons (Fcons (family
, make_number (ff
)),
8310 fm_font_family_alist
);
8312 /* Point the instance iterator at the current font family. */
8313 if (FMResetFontFamilyInstanceIterator (ff
, &ffii
) != noErr
)
8316 while (FMGetNextFontFamilyInstance (&ffii
, &font
, &style
, &size
)
8319 Lisp_Object rest
= XCDR (XCDR (text_encoding_info
));
8321 if (size
> 0 || style
== normal
)
8322 for (; CONSP (rest
); rest
= XCDR (rest
))
8323 add_mac_font_name (name
, size
, style
, SDATA (XCAR (rest
)));
8329 /* Dispose of the iterators. */
8330 FMDisposeFontFamilyIterator (&ffi
);
8331 FMDisposeFontFamilyInstanceIterator (&ffii
);
8332 #else /* !TARGET_API_MAC_CARBON */
8334 SInt16 fontnum
, old_fontnum
;
8335 int num_mac_fonts
= CountResources('FOND');
8337 Handle font_handle
, font_handle_2
;
8338 short id
, scriptcode
;
8341 struct FontAssoc
*fat
;
8342 struct AsscEntry
*assc_entry
;
8343 Lisp_Object text_encoding_info_alist
, text_encoding_info
, family
;
8344 struct gcpro gcpro1
;
8346 GetPort (&port
); /* save the current font number used */
8347 old_fontnum
= port
->txFont
;
8349 text_encoding_info_alist
= create_text_encoding_info_alist ();
8351 GCPRO1 (text_encoding_info_alist
);
8353 for (i
= 1; i
<= num_mac_fonts
; i
++) /* get all available fonts */
8355 font_handle
= GetIndResource ('FOND', i
);
8359 GetResInfo (font_handle
, &id
, &type
, name
);
8360 GetFNum (name
, &fontnum
);
8362 if (fontnum
== 0 || *name
== '.')
8366 scriptcode
= FontToScript (fontnum
);
8367 text_encoding_info
= assq_no_quit (make_number (scriptcode
),
8368 text_encoding_info_alist
);
8369 if (NILP (text_encoding_info
))
8370 text_encoding_info
= assq_no_quit (make_number (smRoman
),
8371 text_encoding_info_alist
);
8372 decode_mac_font_name (name
, sizeof (name
),
8373 XCAR (XCDR (text_encoding_info
)));
8374 family
= build_string (name
);
8375 if (!NILP (Fassoc (family
, fm_font_family_alist
)))
8377 fm_font_family_alist
= Fcons (Fcons (family
, make_number (fontnum
)),
8378 fm_font_family_alist
);
8381 HLock (font_handle
);
8383 if (GetResourceSizeOnDisk (font_handle
)
8384 >= sizeof (struct FamRec
))
8386 fat
= (struct FontAssoc
*) (*font_handle
8387 + sizeof (struct FamRec
));
8389 = (struct AsscEntry
*) (*font_handle
8390 + sizeof (struct FamRec
)
8391 + sizeof (struct FontAssoc
));
8393 for (j
= 0; j
<= fat
->numAssoc
; j
++, assc_entry
++)
8395 Lisp_Object rest
= XCDR (XCDR (text_encoding_info
));
8397 for (; CONSP (rest
); rest
= XCDR (rest
))
8398 add_mac_font_name (name
, assc_entry
->fontSize
,
8399 assc_entry
->fontStyle
,
8400 SDATA (XCAR (rest
)));
8404 HUnlock (font_handle
);
8405 font_handle_2
= GetNextFOND (font_handle
);
8406 ReleaseResource (font_handle
);
8407 font_handle
= font_handle_2
;
8409 while (ResError () == noErr
&& font_handle
);
8414 TextFont (old_fontnum
);
8415 #endif /* !TARGET_API_MAC_CARBON */
8420 mac_clear_font_name_table ()
8424 for (i
= 0; i
< font_name_count
; i
++)
8425 xfree (font_name_table
[i
]);
8426 xfree (font_name_table
);
8427 font_name_table
= NULL
;
8428 font_name_table_size
= font_name_count
= 0;
8429 fm_font_family_alist
= Qnil
;
8433 enum xlfd_scalable_field_index
8435 XLFD_SCL_PIXEL_SIZE
,
8436 XLFD_SCL_POINT_SIZE
,
8441 static const int xlfd_scalable_fields
[] =
8450 mac_do_list_fonts (pattern
, maxnames
)
8451 const char *pattern
;
8455 Lisp_Object font_list
= Qnil
;
8456 struct xlfdpat
*pat
;
8459 int scl_val
[XLFD_SCL_LAST
], *val
;
8463 if (font_name_table
== NULL
) /* Initialize when first used. */
8464 init_font_name_table ();
8466 for (i
= 0; i
< XLFD_SCL_LAST
; i
++)
8469 /* If the pattern contains 14 dashes and one of PIXEL_SIZE,
8470 POINT_SIZE, and AVGWIDTH fields is explicitly specified, scalable
8471 fonts are scaled according to the specified size. */
8474 field
= xlfd_scalable_fields
;
8482 if ('0' <= *ptr
&& *ptr
<= '9')
8484 *val
= *ptr
++ - '0';
8485 while ('0' <= *ptr
&& *ptr
<= '9' && *val
< 10000)
8486 *val
= *val
* 10 + *ptr
++ - '0';
8493 ptr
= strchr (ptr
, '-');
8496 while (ptr
&& i
< 14);
8498 if (i
== 14 && ptr
== NULL
)
8500 if (scl_val
[XLFD_SCL_PIXEL_SIZE
] < 0)
8501 scl_val
[XLFD_SCL_PIXEL_SIZE
] =
8502 (scl_val
[XLFD_SCL_POINT_SIZE
] > 0 ? scl_val
[XLFD_SCL_POINT_SIZE
] / 10
8503 : (scl_val
[XLFD_SCL_AVGWIDTH
] > 0 ? scl_val
[XLFD_SCL_AVGWIDTH
] / 10
8505 if (scl_val
[XLFD_SCL_POINT_SIZE
] < 0)
8506 scl_val
[XLFD_SCL_POINT_SIZE
] =
8507 (scl_val
[XLFD_SCL_PIXEL_SIZE
] > 0 ? scl_val
[XLFD_SCL_PIXEL_SIZE
] * 10
8508 : (scl_val
[XLFD_SCL_AVGWIDTH
] > 0 ? scl_val
[XLFD_SCL_AVGWIDTH
]
8510 if (scl_val
[XLFD_SCL_AVGWIDTH
] < 0)
8511 scl_val
[XLFD_SCL_AVGWIDTH
] =
8512 (scl_val
[XLFD_SCL_PIXEL_SIZE
] > 0 ? scl_val
[XLFD_SCL_PIXEL_SIZE
] * 10
8513 : (scl_val
[XLFD_SCL_POINT_SIZE
] > 0 ? scl_val
[XLFD_SCL_POINT_SIZE
]
8517 scl_val
[XLFD_SCL_PIXEL_SIZE
] = -1;
8519 pat
= xlfdpat_create (pattern
);
8523 exact
= xlfdpat_exact_p (pat
);
8525 for (i
= 0; i
< font_name_count
; i
++)
8527 if (xlfdpat_match (pat
, font_name_table
[i
]))
8529 font_list
= Fcons (build_string (font_name_table
[i
]), font_list
);
8530 if (exact
|| (maxnames
> 0 && ++n_fonts
>= maxnames
))
8533 else if (scl_val
[XLFD_SCL_PIXEL_SIZE
] > 0
8534 && (ptr
= strstr (font_name_table
[i
], "-0-0-0-0-m-0-")))
8536 int former_len
= ptr
- font_name_table
[i
];
8538 scaled
= xmalloc (strlen (font_name_table
[i
]) + 20 + 1);
8539 memcpy (scaled
, font_name_table
[i
], former_len
);
8540 sprintf (scaled
+ former_len
,
8541 "-%d-%d-72-72-m-%d-%s",
8542 scl_val
[XLFD_SCL_PIXEL_SIZE
],
8543 scl_val
[XLFD_SCL_POINT_SIZE
],
8544 scl_val
[XLFD_SCL_AVGWIDTH
],
8545 ptr
+ sizeof ("-0-0-0-0-m-0-") - 1);
8547 if (xlfdpat_match (pat
, scaled
))
8549 font_list
= Fcons (build_string (scaled
), font_list
);
8551 if (exact
|| (maxnames
> 0 && ++n_fonts
>= maxnames
))
8559 xlfdpat_destroy (pat
);
8564 /* Return a list of names of available fonts matching PATTERN on frame F.
8566 Frame F null means we have not yet created any frame on Mac, and
8567 consult the first display in x_display_list. MAXNAMES sets a limit
8568 on how many fonts to match. */
8571 x_list_fonts (f
, pattern
, size
, maxnames
)
8573 Lisp_Object pattern
;
8576 Lisp_Object list
= Qnil
, patterns
, tem
, key
;
8577 struct mac_display_info
*dpyinfo
8578 = f
? FRAME_MAC_DISPLAY_INFO (f
) : x_display_list
;
8580 xassert (size
<= 0);
8582 patterns
= Fassoc (pattern
, Valternate_fontname_alist
);
8583 if (NILP (patterns
))
8584 patterns
= Fcons (pattern
, Qnil
);
8586 for (; CONSP (patterns
); patterns
= XCDR (patterns
))
8588 pattern
= XCAR (patterns
);
8590 if (!STRINGP (pattern
))
8593 tem
= XCAR (XCDR (dpyinfo
->name_list_element
));
8594 key
= Fcons (pattern
, make_number (maxnames
));
8596 list
= Fassoc (key
, tem
);
8599 list
= Fcdr_safe (list
);
8600 /* We have a cashed list. Don't have to get the list again. */
8605 list
= mac_do_list_fonts (SDATA (pattern
), maxnames
);
8608 /* MAC_TODO: add code for matching outline fonts here */
8610 /* Now store the result in the cache. */
8611 XSETCAR (XCDR (dpyinfo
->name_list_element
),
8612 Fcons (Fcons (key
, list
),
8613 XCAR (XCDR (dpyinfo
->name_list_element
))));
8616 if (NILP (list
)) continue; /* Try the remaining alternatives. */
8625 /* Check that FONT is valid on frame F. It is if it can be found in F's
8629 x_check_font (f
, font
)
8634 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8636 xassert (font
!= NULL
);
8638 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
8639 if (dpyinfo
->font_table
[i
].name
8640 && font
== dpyinfo
->font_table
[i
].font
)
8643 xassert (i
< dpyinfo
->n_fonts
);
8646 #endif /* GLYPH_DEBUG != 0 */
8648 /* Set *W to the minimum width, *H to the minimum font height of FONT.
8649 Note: There are (broken) X fonts out there with invalid XFontStruct
8650 min_bounds contents. For example, handa@etl.go.jp reports that
8651 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
8652 have font->min_bounds.width == 0. */
8655 x_font_min_bounds (font
, w
, h
)
8656 MacFontStruct
*font
;
8659 *h
= FONT_HEIGHT (font
);
8660 *w
= font
->min_bounds
.width
;
8664 /* Compute the smallest character width and smallest font height over
8665 all fonts available on frame F. Set the members smallest_char_width
8666 and smallest_font_height in F's x_display_info structure to
8667 the values computed. Value is non-zero if smallest_font_height or
8668 smallest_char_width become smaller than they were before. */
8671 x_compute_min_glyph_bounds (f
)
8675 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
8676 MacFontStruct
*font
;
8677 int old_width
= dpyinfo
->smallest_char_width
;
8678 int old_height
= dpyinfo
->smallest_font_height
;
8680 dpyinfo
->smallest_font_height
= 100000;
8681 dpyinfo
->smallest_char_width
= 100000;
8683 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
8684 if (dpyinfo
->font_table
[i
].name
)
8686 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
8689 font
= (MacFontStruct
*) fontp
->font
;
8690 xassert (font
!= (MacFontStruct
*) ~0);
8691 x_font_min_bounds (font
, &w
, &h
);
8693 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
8694 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
8697 xassert (dpyinfo
->smallest_char_width
> 0
8698 && dpyinfo
->smallest_font_height
> 0);
8700 return (dpyinfo
->n_fonts
== 1
8701 || dpyinfo
->smallest_char_width
< old_width
8702 || dpyinfo
->smallest_font_height
< old_height
);
8706 /* Determine whether given string is a fully-specified XLFD: all 14
8707 fields are present, none is '*'. */
8710 is_fully_specified_xlfd (p
)
8719 for (i
= 0; i
< 13; i
++)
8721 q
= strchr (p
+ 1, '-');
8724 if (q
- p
== 2 && *(p
+ 1) == '*')
8729 if (strchr (p
+ 1, '-') != NULL
)
8732 if (*(p
+ 1) == '*' && *(p
+ 2) == '\0')
8739 /* mac_load_query_font creates and returns an internal representation
8740 for a font in a MacFontStruct struct. There is really no concept
8741 corresponding to "loading" a font on the Mac. But we check its
8742 existence and find the font number and all other information for it
8743 and store them in the returned MacFontStruct. */
8745 static MacFontStruct
*
8746 mac_load_query_font (f
, fontname
)
8756 static ATSUFontID font_id
;
8757 ATSUStyle mac_style
= NULL
;
8760 #if TARGET_API_MAC_CARBON
8761 TextEncoding encoding
;
8766 MacFontStruct
*font
;
8767 XCharStruct
*space_bounds
= NULL
, *pcm
;
8769 if (is_fully_specified_xlfd (fontname
))
8773 Lisp_Object matched_fonts
;
8775 matched_fonts
= mac_do_list_fonts (fontname
, 1);
8776 if (NILP (matched_fonts
))
8778 name
= SDATA (XCAR (matched_fonts
));
8781 if (parse_x_font_name (name
, family
, &size
, &fontface
, charset
) == 0)
8785 if (strcmp (charset
, "iso10646-1") == 0) /* XXX */
8788 static const ATSUAttributeTag tags
[] =
8789 {kATSUFontTag
, kATSUSizeTag
,
8790 kATSUQDBoldfaceTag
, kATSUQDItalicTag
};
8791 static const ByteCount sizes
[] =
8792 {sizeof (ATSUFontID
), sizeof (Fixed
),
8793 sizeof (Boolean
), sizeof (Boolean
)};
8794 static Fixed size_fixed
;
8795 static Boolean bold_p
, italic_p
;
8796 static const ATSUAttributeValuePtr values
[] =
8797 {&font_id
, &size_fixed
,
8798 &bold_p
, &italic_p
};
8799 static const ATSUFontFeatureType types
[] =
8800 {kAllTypographicFeaturesType
, kDiacriticsType
};
8801 static const ATSUFontFeatureSelector selectors
[] =
8802 {kAllTypeFeaturesOffSelector
, kDecomposeDiacriticsSelector
};
8805 font_id
= atsu_find_font_from_family_name (family
);
8806 if (font_id
== kATSUInvalidFontID
)
8808 size_fixed
= Long2Fix (size
);
8809 bold_p
= (fontface
& bold
) != 0;
8810 italic_p
= (fontface
& italic
) != 0;
8811 err
= ATSUCreateStyle (&mac_style
);
8814 err
= ATSUSetFontFeatures (mac_style
, sizeof (types
) / sizeof (types
[0]),
8818 err
= ATSUSetAttributes (mac_style
, sizeof (tags
) / sizeof (tags
[0]),
8819 tags
, sizes
, values
);
8822 err
= FMGetFontFamilyInstanceFromFont (font_id
, &fontnum
, &style
);
8825 scriptcode
= kTextEncodingMacUnicode
;
8830 Lisp_Object tmp
= Fassoc (build_string (family
), fm_font_family_alist
);
8834 fontnum
= XINT (XCDR (tmp
));
8835 #if TARGET_API_MAC_CARBON
8836 if (FMGetFontFamilyTextEncoding (fontnum
, &encoding
) != noErr
)
8838 scriptcode
= GetTextEncodingBase (encoding
);
8840 scriptcode
= FontToScript (fontnum
);
8844 font
= (MacFontStruct
*) xmalloc (sizeof (struct MacFontStruct
));
8846 font
->mac_fontnum
= fontnum
;
8847 font
->mac_fontsize
= size
;
8848 font
->mac_fontface
= fontface
;
8849 font
->mac_scriptcode
= scriptcode
;
8851 font
->mac_style
= mac_style
;
8852 #if USE_CG_TEXT_DRAWING
8853 font
->cg_font
= NULL
;
8854 font
->cg_glyphs
= NULL
;
8858 /* Apple Japanese (SJIS) font is listed as both
8859 "*-jisx0208.1983-sjis" (Japanese script) and "*-jisx0201.1976-0"
8860 (Roman script) in init_font_name_table (). The latter should be
8861 treated as a one-byte font. */
8862 if (scriptcode
== smJapanese
&& strcmp (charset
, "jisx0201.1976-0") == 0)
8863 font
->mac_scriptcode
= smRoman
;
8865 font
->full_name
= mac_to_x_fontname (family
, size
, fontface
, charset
);
8868 if (font
->mac_style
)
8873 font
->min_byte1
= 0;
8874 font
->max_byte1
= 0xff;
8875 font
->min_char_or_byte2
= 0;
8876 font
->max_char_or_byte2
= 0xff;
8878 font
->bounds
.rows
= xmalloc (sizeof (XCharStruct
*) * 0x100);
8879 bzero (font
->bounds
.rows
, sizeof (XCharStruct
*) * 0x100);
8880 font
->bounds
.rows
[0] = xmalloc (sizeof (XCharStruct
) * 0x100);
8881 pcm_init (font
->bounds
.rows
[0], 0x100);
8883 #if USE_CG_TEXT_DRAWING
8887 ATSFontRef ats_font
;
8889 err
= FMGetFontFromFontFamilyInstance (fontnum
, fontface
,
8891 /* Use CG text drawing if italic/bold is not synthesized. */
8892 if (err
== noErr
&& style
== fontface
)
8894 ats_font
= FMGetATSFontRefFromFont (font_id
);
8895 font
->cg_font
= CGFontCreateWithPlatformFont (&ats_font
);
8901 font
->cg_glyphs
= xmalloc (sizeof (CGGlyph
) * 0x100);
8902 bzero (font
->cg_glyphs
, sizeof (CGGlyph
) * 0x100);
8905 space_bounds
= font
->bounds
.rows
[0] + 0x20;
8906 err
= mac_query_char_extents (font
->mac_style
, 0x20,
8907 &font
->ascent
, &font
->descent
,
8909 #if USE_CG_TEXT_DRAWING
8910 (font
->cg_glyphs
? font
->cg_glyphs
+ 0x20
8917 || space_bounds
->width
<= 0 || FONT_HEIGHT (font
) <= 0)
8919 mac_unload_font (&one_mac_display_info
, font
);
8923 pcm
= font
->bounds
.rows
[0];
8924 for (c
= 0x21; c
<= 0xff; c
++)
8927 /* Soft hyphen is not supported in ATSUI. */
8931 #if USE_CG_TEXT_DRAWING
8932 if (font
->cg_glyphs
)
8942 mac_query_char_extents (font
->mac_style
, c
, NULL
, NULL
,
8943 pcm
? pcm
+ c
: NULL
,
8944 #if USE_CG_TEXT_DRAWING
8945 (font
->cg_glyphs
? font
->cg_glyphs
+ c
8952 #if USE_CG_TEXT_DRAWING
8953 if (font
->cg_glyphs
&& font
->cg_glyphs
[c
] == 0)
8955 /* Don't use CG text drawing if font substitution occurs in
8956 ASCII or Latin-1 characters. */
8957 CGFontRelease (font
->cg_font
);
8958 font
->cg_font
= NULL
;
8959 xfree (font
->cg_glyphs
);
8960 font
->cg_glyphs
= NULL
;
8971 FontInfo the_fontinfo
;
8972 int is_two_byte_font
;
8975 mac_prepare_for_quickdraw (f
);
8977 SetPortWindowPort (FRAME_MAC_WINDOW (f
));
8981 TextFace (fontface
);
8983 GetFontInfo (&the_fontinfo
);
8985 font
->ascent
= the_fontinfo
.ascent
;
8986 font
->descent
= the_fontinfo
.descent
;
8988 is_two_byte_font
= (font
->mac_scriptcode
== smJapanese
8989 || font
->mac_scriptcode
== smTradChinese
8990 || font
->mac_scriptcode
== smSimpChinese
8991 || font
->mac_scriptcode
== smKorean
);
8993 if (is_two_byte_font
)
8997 font
->min_byte1
= 0xa1;
8998 font
->max_byte1
= 0xfe;
8999 font
->min_char_or_byte2
= 0xa1;
9000 font
->max_char_or_byte2
= 0xfe;
9002 /* Use the width of an "ideographic space" of that font
9003 because the_fontinfo.widMax returns the wrong width for
9005 switch (font
->mac_scriptcode
)
9008 font
->min_byte1
= 0x81;
9009 font
->max_byte1
= 0xfc;
9010 font
->min_char_or_byte2
= 0x40;
9011 font
->max_char_or_byte2
= 0xfc;
9012 char_width
= StringWidth("\p\x81\x40");
9015 font
->min_char_or_byte2
= 0x40;
9016 char_width
= StringWidth("\p\xa1\x40");
9019 char_width
= StringWidth("\p\xa1\xa1");
9022 char_width
= StringWidth("\p\xa1\xa1");
9026 font
->bounds
.per_char
= NULL
;
9028 if (fontface
& italic
)
9029 font
->max_bounds
.rbearing
= char_width
+ 1;
9031 font
->max_bounds
.rbearing
= char_width
;
9032 font
->max_bounds
.lbearing
= 0;
9033 font
->max_bounds
.width
= char_width
;
9034 font
->max_bounds
.ascent
= the_fontinfo
.ascent
;
9035 font
->max_bounds
.descent
= the_fontinfo
.descent
;
9037 font
->min_bounds
= font
->max_bounds
;
9043 font
->min_byte1
= font
->max_byte1
= 0;
9044 font
->min_char_or_byte2
= 0x20;
9045 font
->max_char_or_byte2
= 0xff;
9047 font
->bounds
.per_char
=
9048 xmalloc (sizeof (XCharStruct
) * (0xff - 0x20 + 1));
9049 bzero (font
->bounds
.per_char
,
9050 sizeof (XCharStruct
) * (0xff - 0x20 + 1));
9052 space_bounds
= font
->bounds
.per_char
;
9053 err
= mac_query_char_extents (NULL
, 0x20, &font
->ascent
,
9054 &font
->descent
, space_bounds
, NULL
);
9055 if (err
!= noErr
|| space_bounds
->width
<= 0)
9057 mac_unload_font (&one_mac_display_info
, font
);
9061 for (c
= 0x21, pcm
= space_bounds
+ 1; c
<= 0xff; c
++, pcm
++)
9062 mac_query_char_extents (NULL
, c
, NULL
, NULL
, pcm
, NULL
);
9070 font
->min_bounds
= font
->max_bounds
= *space_bounds
;
9071 for (c
= 0x21, pcm
= space_bounds
+ 1; c
<= 0x7f; c
++, pcm
++)
9074 font
->min_bounds
.lbearing
= min (font
->min_bounds
.lbearing
,
9076 font
->min_bounds
.rbearing
= min (font
->min_bounds
.rbearing
,
9078 font
->min_bounds
.width
= min (font
->min_bounds
.width
,
9080 font
->min_bounds
.ascent
= min (font
->min_bounds
.ascent
,
9082 font
->min_bounds
.descent
= min (font
->min_bounds
.descent
,
9085 font
->max_bounds
.lbearing
= max (font
->max_bounds
.lbearing
,
9087 font
->max_bounds
.rbearing
= max (font
->max_bounds
.rbearing
,
9089 font
->max_bounds
.width
= max (font
->max_bounds
.width
,
9091 font
->max_bounds
.ascent
= max (font
->max_bounds
.ascent
,
9093 font
->max_bounds
.descent
= max (font
->max_bounds
.descent
,
9098 font
->mac_style
== NULL
&&
9100 font
->max_bounds
.width
== font
->min_bounds
.width
9101 && font
->min_bounds
.lbearing
>= 0
9102 && font
->max_bounds
.rbearing
<= font
->max_bounds
.width
)
9104 /* Fixed width and no overhangs. */
9105 xfree (font
->bounds
.per_char
);
9106 font
->bounds
.per_char
= NULL
;
9110 #if !defined (MAC_OS8) || USE_ATSUI
9111 /* AppKit and WebKit do some adjustment to the heights of Courier,
9112 Helvetica, and Times. This only works on the environments where
9113 srcCopy text transfer mode is never used. */
9115 #ifdef MAC_OS8 /* implies USE_ATSUI */
9118 (strcmp (family
, "courier") == 0 || strcmp (family
, "helvetica") == 0
9119 || strcmp (family
, "times") == 0))
9120 font
->ascent
+= (font
->ascent
+ font
->descent
) * .15 + 0.5;
9128 mac_unload_font (dpyinfo
, font
)
9129 struct mac_display_info
*dpyinfo
;
9132 xfree (font
->full_name
);
9134 if (font
->mac_style
)
9138 for (i
= font
->min_byte1
; i
<= font
->max_byte1
; i
++)
9139 if (font
->bounds
.rows
[i
])
9140 xfree (font
->bounds
.rows
[i
]);
9141 xfree (font
->bounds
.rows
);
9142 ATSUDisposeStyle (font
->mac_style
);
9146 if (font
->bounds
.per_char
)
9147 xfree (font
->bounds
.per_char
);
9148 #if USE_CG_TEXT_DRAWING
9150 CGFontRelease (font
->cg_font
);
9151 if (font
->cg_glyphs
)
9152 xfree (font
->cg_glyphs
);
9158 /* Load font named FONTNAME of the size SIZE for frame F, and return a
9159 pointer to the structure font_info while allocating it dynamically.
9160 If SIZE is 0, load any size of font.
9161 If loading is failed, return NULL. */
9164 x_load_font (f
, fontname
, size
)
9166 register char *fontname
;
9169 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
9170 Lisp_Object font_names
;
9172 /* Get a list of all the fonts that match this name. Once we
9173 have a list of matching fonts, we compare them against the fonts
9174 we already have by comparing names. */
9175 font_names
= x_list_fonts (f
, build_string (fontname
), size
, 1);
9177 if (!NILP (font_names
))
9182 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
9183 for (tail
= font_names
; CONSP (tail
); tail
= XCDR (tail
))
9184 if (dpyinfo
->font_table
[i
].name
9185 && (!strcmp (dpyinfo
->font_table
[i
].name
,
9186 SDATA (XCAR (tail
)))
9187 || !strcmp (dpyinfo
->font_table
[i
].full_name
,
9188 SDATA (XCAR (tail
)))))
9189 return (dpyinfo
->font_table
+ i
);
9194 /* Load the font and add it to the table. */
9196 struct MacFontStruct
*font
;
9197 struct font_info
*fontp
;
9200 fontname
= (char *) SDATA (XCAR (font_names
));
9203 font
= mac_load_query_font (f
, fontname
);
9208 /* Find a free slot in the font table. */
9209 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
9210 if (dpyinfo
->font_table
[i
].name
== NULL
)
9213 /* If no free slot found, maybe enlarge the font table. */
9214 if (i
== dpyinfo
->n_fonts
9215 && dpyinfo
->n_fonts
== dpyinfo
->font_table_size
)
9218 dpyinfo
->font_table_size
= max (16, 2 * dpyinfo
->font_table_size
);
9219 sz
= dpyinfo
->font_table_size
* sizeof *dpyinfo
->font_table
;
9221 = (struct font_info
*) xrealloc (dpyinfo
->font_table
, sz
);
9224 fontp
= dpyinfo
->font_table
+ i
;
9225 if (i
== dpyinfo
->n_fonts
)
9228 /* Now fill in the slots of *FONTP. */
9230 bzero (fontp
, sizeof (*fontp
));
9232 fontp
->font_idx
= i
;
9233 fontp
->charset
= -1; /* fs_load_font sets it. */
9234 fontp
->name
= (char *) xmalloc (strlen (fontname
) + 1);
9235 bcopy (fontname
, fontp
->name
, strlen (fontname
) + 1);
9237 if (font
->min_bounds
.width
== font
->max_bounds
.width
)
9239 /* Fixed width font. */
9240 fontp
->average_width
= fontp
->space_width
= font
->min_bounds
.width
;
9247 char2b
.byte1
= 0x00, char2b
.byte2
= 0x20;
9248 pcm
= mac_per_char_metric (font
, &char2b
, 0);
9250 fontp
->space_width
= pcm
->width
;
9252 fontp
->space_width
= FONT_WIDTH (font
);
9256 int width
= pcm
->width
;
9257 for (char2b
.byte2
= 33; char2b
.byte2
<= 126; char2b
.byte2
++)
9258 if ((pcm
= mac_per_char_metric (font
, &char2b
, 0)) != NULL
)
9259 width
+= pcm
->width
;
9260 fontp
->average_width
= width
/ 95;
9263 fontp
->average_width
= FONT_WIDTH (font
);
9266 fontp
->full_name
= (char *) xmalloc (strlen (font
->full_name
) + 1);
9267 bcopy (font
->full_name
, fontp
->full_name
, strlen (font
->full_name
) + 1);
9269 fontp
->size
= font
->max_bounds
.width
;
9270 fontp
->height
= FONT_HEIGHT (font
);
9272 /* For some font, ascent and descent in max_bounds field is
9273 larger than the above value. */
9274 int max_height
= font
->max_bounds
.ascent
+ font
->max_bounds
.descent
;
9275 if (max_height
> fontp
->height
)
9276 fontp
->height
= max_height
;
9279 /* MAC_TODO: The script encoding is irrelevant in unicode? */
9280 /* The slot `encoding' specifies how to map a character
9281 code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
9282 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
9283 (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
9284 2:0xA020..0xFF7F). For the moment, we don't know which charset
9285 uses this font. So, we set information in fontp->encoding_type
9286 which is never used by any charset. If mapping can't be
9287 decided, set FONT_ENCODING_NOT_DECIDED. */
9288 if (font
->mac_scriptcode
== smJapanese
)
9289 fontp
->encoding_type
= 4;
9292 fontp
->encoding_type
9293 = (font
->max_byte1
== 0
9295 ? (font
->min_char_or_byte2
< 0x80
9296 ? (font
->max_char_or_byte2
< 0x80
9297 ? 0 /* 0x20..0x7F */
9298 : FONT_ENCODING_NOT_DECIDED
) /* 0x20..0xFF */
9299 : 1) /* 0xA0..0xFF */
9301 : (font
->min_byte1
< 0x80
9302 ? (font
->max_byte1
< 0x80
9303 ? (font
->min_char_or_byte2
< 0x80
9304 ? (font
->max_char_or_byte2
< 0x80
9305 ? 0 /* 0x2020..0x7F7F */
9306 : FONT_ENCODING_NOT_DECIDED
) /* 0x2020..0x7FFF */
9307 : 3) /* 0x20A0..0x7FFF */
9308 : FONT_ENCODING_NOT_DECIDED
) /* 0x20??..0xA0?? */
9309 : (font
->min_char_or_byte2
< 0x80
9310 ? (font
->max_char_or_byte2
< 0x80
9311 ? 2 /* 0xA020..0xFF7F */
9312 : FONT_ENCODING_NOT_DECIDED
) /* 0xA020..0xFFFF */
9313 : 1))); /* 0xA0A0..0xFFFF */
9316 #if 0 /* MAC_TODO: fill these out with more reasonably values */
9317 fontp
->baseline_offset
9318 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_BASELINE_OFFSET
, &value
)
9319 ? (long) value
: 0);
9320 fontp
->relative_compose
9321 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
, &value
)
9322 ? (long) value
: 0);
9323 fontp
->default_ascent
9324 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
, &value
)
9325 ? (long) value
: 0);
9327 fontp
->baseline_offset
= 0;
9328 fontp
->relative_compose
= 0;
9329 fontp
->default_ascent
= 0;
9332 /* Set global flag fonts_changed_p to non-zero if the font loaded
9333 has a character with a smaller width than any other character
9334 before, or if the font loaded has a smaller height than any
9335 other font loaded before. If this happens, it will make a
9336 glyph matrix reallocation necessary. */
9337 fonts_changed_p
|= x_compute_min_glyph_bounds (f
);
9344 /* Return a pointer to struct font_info of a font named FONTNAME for
9345 frame F. If no such font is loaded, return NULL. */
9348 x_query_font (f
, fontname
)
9350 register char *fontname
;
9352 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
9355 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
9356 if (dpyinfo
->font_table
[i
].name
9357 && (!xstricmp (dpyinfo
->font_table
[i
].name
, fontname
)
9358 || !xstricmp (dpyinfo
->font_table
[i
].full_name
, fontname
)))
9359 return (dpyinfo
->font_table
+ i
);
9364 /* Find a CCL program for a font specified by FONTP, and set the member
9365 `encoder' of the structure. */
9368 x_find_ccl_program (fontp
)
9369 struct font_info
*fontp
;
9371 Lisp_Object list
, elt
;
9373 for (list
= Vfont_ccl_encoder_alist
; CONSP (list
); list
= XCDR (list
))
9377 && STRINGP (XCAR (elt
))
9378 && (fast_c_string_match_ignore_case (XCAR (elt
), fontp
->name
)
9384 struct ccl_program
*ccl
9385 = (struct ccl_program
*) xmalloc (sizeof (struct ccl_program
));
9387 if (setup_ccl_program (ccl
, XCDR (elt
)) < 0)
9390 fontp
->font_encoder
= ccl
;
9394 #if USE_MAC_FONT_PANEL
9395 /* Whether Font Panel has been shown before. The first call to font
9396 panel functions (FPIsFontPanelVisible, SetFontInfoForSelection) is
9397 slow. This variable is used for deferring such a call as much as
9399 static int font_panel_shown_p
= 0;
9401 extern Lisp_Object Qfont
;
9402 static Lisp_Object Qpanel_closed
, Qselection
;
9404 static OSStatus mac_store_event_ref_as_apple_event
P_ ((AEEventClass
, AEEventID
,
9408 const EventParamName
*,
9409 const EventParamType
*));
9412 mac_font_panel_visible_p ()
9414 return font_panel_shown_p
&& FPIsFontPanelVisible ();
9417 static pascal OSStatus
9418 mac_handle_font_event (next_handler
, event
, data
)
9419 EventHandlerCallRef next_handler
;
9423 OSStatus result
, err
;
9426 const EventParamName
*names
;
9427 const EventParamType
*types
;
9428 static const EventParamName names_sel
[] = {kEventParamATSUFontID
,
9429 kEventParamATSUFontSize
,
9430 kEventParamFMFontFamily
,
9431 kEventParamFMFontStyle
,
9432 kEventParamFMFontSize
,
9433 kEventParamFontColor
};
9434 static const EventParamType types_sel
[] = {typeATSUFontID
,
9441 result
= CallNextEventHandler (next_handler
, event
);
9442 if (result
!= eventNotHandledErr
)
9445 switch (GetEventKind (event
))
9447 case kEventFontPanelClosed
:
9448 id_key
= Qpanel_closed
;
9454 case kEventFontSelection
:
9455 id_key
= Qselection
;
9456 num_params
= sizeof (names_sel
) / sizeof (names_sel
[0]);
9462 err
= mac_store_event_ref_as_apple_event (0, 0, Qfont
, id_key
,
9472 mac_show_hide_font_panel ()
9474 if (!font_panel_shown_p
)
9478 static const EventTypeSpec specs
[] =
9479 {{kEventClassFont
, kEventFontPanelClosed
},
9480 {kEventClassFont
, kEventFontSelection
}};
9482 err
= InstallApplicationEventHandler (mac_handle_font_event
,
9483 GetEventTypeCount (specs
),
9488 font_panel_shown_p
= 1;
9491 return FPShowHideFontPanel ();
9495 mac_set_font_info_for_selection (f
, face_id
, c
)
9500 EventTargetRef target
= NULL
;
9501 XFontStruct
*font
= NULL
;
9503 if (!mac_font_panel_visible_p ())
9508 target
= GetWindowEventTarget (FRAME_MAC_WINDOW (f
));
9510 if (FRAME_FACE_CACHE (f
) && CHAR_VALID_P (c
, 0))
9514 face_id
= FACE_FOR_CHAR (f
, FACE_FROM_ID (f
, face_id
), c
);
9515 face
= FACE_FROM_ID (f
, face_id
);
9521 err
= SetFontInfoForSelection (kFontSelectionATSUIType
, 0, NULL
, target
);
9524 if (font
->mac_fontnum
!= -1)
9526 FontSelectionQDStyle qd_style
;
9528 qd_style
.version
= kFontSelectionQDStyleVersionZero
;
9529 qd_style
.instance
.fontFamily
= font
->mac_fontnum
;
9530 qd_style
.instance
.fontStyle
= font
->mac_fontface
;
9531 qd_style
.size
= font
->mac_fontsize
;
9532 qd_style
.hasColor
= false;
9534 err
= SetFontInfoForSelection (kFontSelectionQDType
,
9535 1, &qd_style
, target
);
9538 err
= SetFontInfoForSelection (kFontSelectionATSUIType
,
9539 1, &font
->mac_style
, target
);
9547 /* The Mac Event loop code */
9549 #if !TARGET_API_MAC_CARBON
9551 #include <Quickdraw.h>
9552 #include <Balloons.h>
9553 #include <Devices.h>
9555 #include <Gestalt.h>
9557 #include <Processes.h>
9559 #include <ToolUtils.h>
9560 #include <TextUtils.h>
9561 #include <Dialogs.h>
9564 #include <Resources.h>
9569 #endif /* ! TARGET_API_MAC_CARBON */
9574 #define DEFAULT_NUM_COLS 80
9576 #define MIN_DOC_SIZE 64
9577 #define MAX_DOC_SIZE 32767
9579 #define EXTRA_STACK_ALLOC (256 * 1024)
9581 #define ARGV_STRING_LIST_ID 129
9582 #define ABOUT_ALERT_ID 128
9583 #define RAM_TOO_LARGE_ALERT_ID 129
9585 /* Contains the string "reverse", which is a constant for mouse button emu.*/
9586 Lisp_Object Qreverse
;
9589 /* Modifier associated with the control key, or nil to ignore. */
9590 Lisp_Object Vmac_control_modifier
;
9592 /* Modifier associated with the option key, or nil to ignore. */
9593 Lisp_Object Vmac_option_modifier
;
9595 /* Modifier associated with the command key, or nil to ignore. */
9596 Lisp_Object Vmac_command_modifier
;
9598 /* Modifier associated with the function key, or nil to ignore. */
9599 Lisp_Object Vmac_function_modifier
;
9601 /* True if the option and command modifiers should be used to emulate
9602 a three button mouse */
9603 Lisp_Object Vmac_emulate_three_button_mouse
;
9605 #if TARGET_API_MAC_CARBON
9606 /* Non-zero if the mouse wheel button (i.e. button 4) should map to
9607 mouse-2, instead of mouse-3. */
9608 int mac_wheel_button_is_mouse_2
;
9610 /* If non-zero, the Mac "Command" key is passed on to the Mac Toolbox
9611 for processing before Emacs sees it. */
9612 int mac_pass_command_to_system
;
9614 /* If non-zero, the Mac "Control" key is passed on to the Mac Toolbox
9615 for processing before Emacs sees it. */
9616 int mac_pass_control_to_system
;
9619 /* Points to the variable `inev' in the function XTread_socket. It is
9620 used for passing an input event to the function back from
9621 Carbon/Apple event handlers. */
9622 static struct input_event
*read_socket_inev
= NULL
;
9624 /* Whether or not the screen configuration has changed. */
9625 static int mac_screen_config_changed
= 0;
9627 Point saved_menu_event_location
;
9630 #if TARGET_API_MAC_CARBON
9631 static Lisp_Object Qhi_command
;
9633 extern Lisp_Object Qwindow
;
9634 static Lisp_Object Qtoolbar_switch_mode
;
9637 static TSMDocumentID tsm_document_id
;
9638 static Lisp_Object Qtext_input
;
9639 static Lisp_Object Qupdate_active_input_area
, Qunicode_for_key_event
;
9640 static Lisp_Object Vmac_ts_active_input_overlay
;
9641 extern Lisp_Object Qbefore_string
;
9642 static Lisp_Object Vmac_ts_script_language_on_focus
;
9643 static Lisp_Object saved_ts_script_language_on_focus
;
9644 static ScriptLanguageRecord saved_ts_language
;
9645 static Component saved_ts_component
;
9647 #endif /* TARGET_API_MAC_CARBON */
9648 extern int mac_ready_for_apple_events
;
9649 extern Lisp_Object Qundefined
;
9650 extern void init_apple_event_handler
P_ ((void));
9651 extern void mac_find_apple_event_spec
P_ ((AEEventClass
, AEEventID
,
9652 Lisp_Object
*, Lisp_Object
*,
9654 extern OSErr init_coercion_handler
P_ ((void));
9657 extern OSErr install_drag_handler
P_ ((WindowRef
));
9658 extern void remove_drag_handler
P_ ((WindowRef
));
9660 #if TARGET_API_MAC_CARBON
9661 /* Showing help echo string during menu tracking */
9662 extern OSStatus install_menu_target_item_handler
P_ ((void));
9665 extern OSStatus
install_service_handler ();
9666 static Lisp_Object Qservice
, Qpaste
, Qperform
;
9670 extern void init_emacs_passwd_dir ();
9671 extern int emacs_main (int, char **, char **);
9673 extern void initialize_applescript();
9674 extern void terminate_applescript();
9676 /* Table for translating Mac keycode to X keysym values. Contributed
9678 Mapping for special keys is now identical to that in Apple X11
9679 except `clear' (-> <clear>) on the KeyPad, `enter' (-> <kp-enter>)
9680 on the right of the Cmd key on laptops, and fn + `enter' (->
9682 static const unsigned char keycode_to_xkeysym_table
[] = {
9683 /*0x00*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9684 /*0x10*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9685 /*0x20*/ 0, 0, 0, 0, 0x0d /*return*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9687 /*0x30*/ 0x09 /*tab*/, 0 /*0x0020 space*/, 0, 0x08 /*backspace*/,
9688 /*0x34*/ 0x8d /*enter on laptops*/, 0x1b /*escape*/, 0, 0,
9689 /*0x38*/ 0, 0, 0, 0,
9690 /*0x3C*/ 0, 0, 0, 0,
9692 /*0x40*/ 0, 0xae /*kp-decimal*/, 0, 0xaa /*kp-multiply*/,
9693 /*0x44*/ 0, 0xab /*kp-add*/, 0, 0x0b /*clear*/,
9694 /*0x48*/ 0, 0, 0, 0xaf /*kp-divide*/,
9695 /*0x4C*/ 0x8d /*kp-enter*/, 0, 0xad /*kp-subtract*/, 0,
9697 /*0x50*/ 0, 0xbd /*kp-equal*/, 0xb0 /*kp-0*/, 0xb1 /*kp-1*/,
9698 /*0x54*/ 0xb2 /*kp-2*/, 0xb3 /*kp-3*/, 0xb4 /*kp-4*/, 0xb5 /*kp-5*/,
9699 /*0x58*/ 0xb6 /*kp-6*/, 0xb7 /*kp-7*/, 0, 0xb8 /*kp-8*/,
9700 /*0x5C*/ 0xb9 /*kp-9*/, 0, 0, 0,
9702 /*0x60*/ 0xc2 /*f5*/, 0xc3 /*f6*/, 0xc4 /*f7*/, 0xc0 /*f3*/,
9703 /*0x64*/ 0xc5 /*f8*/, 0xc6 /*f9*/, 0, 0xc8 /*f11*/,
9704 /*0x68*/ 0, 0xca /*f13*/, 0xcd /*f16*/, 0xcb /*f14*/,
9705 /*0x6C*/ 0, 0xc7 /*f10*/, 0x0a /*fn+enter on laptops*/, 0xc9 /*f12*/,
9707 /*0x70*/ 0, 0xcc /*f15*/, 0x6a /*help*/, 0x50 /*home*/,
9708 /*0x74*/ 0x55 /*pgup*/, 0xff /*delete*/, 0xc1 /*f4*/, 0x57 /*end*/,
9709 /*0x78*/ 0xbf /*f2*/, 0x56 /*pgdown*/, 0xbe /*f1*/, 0x51 /*left*/,
9710 /*0x7C*/ 0x53 /*right*/, 0x54 /*down*/, 0x52 /*up*/, 0
9714 /* Table for translating Mac keycode with the laptop `fn' key to that
9715 without it. Destination symbols in comments are keys on US
9716 keyboard, and they may not be the same on other types of keyboards.
9717 If the destination is identical to the source (f1 ... f12), it
9718 doesn't map `fn' key to a modifier. */
9719 static const unsigned char fn_keycode_to_keycode_table
[] = {
9720 /*0x00*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9721 /*0x10*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9722 /*0x20*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9724 /*0x30*/ 0, 0, 0, 0,
9725 /*0x34*/ 0, 0, 0, 0,
9726 /*0x38*/ 0, 0, 0, 0,
9727 /*0x3C*/ 0, 0, 0, 0,
9729 /*0x40*/ 0, 0x2f /*kp-decimal -> '.'*/, 0, 0x23 /*kp-multiply -> 'p'*/,
9730 /*0x44*/ 0, 0x2c /*kp-add -> '/'*/, 0, 0x16 /*clear -> '6'*/,
9731 /*0x48*/ 0, 0, 0, 0x1d /*kp-/ -> '0'*/,
9732 /*0x4C*/ 0x24 /*kp-enter -> return*/, 0, 0x29 /*kp-subtract -> ';'*/, 0,
9734 /*0x50*/ 0, 0x1b /*kp-equal -> '-'*/, 0x2e /*kp-0 -> 'm'*/, 0x26 /*kp-1 -> 'j'*/,
9735 /*0x54*/ 0x28 /*kp-2 -> 'k'*/, 0x25 /*kp-3 -> 'l'*/, 0x20 /*kp-4 -> 'u'*/, 0x22 /*kp-5 ->'i'*/,
9736 /*0x58*/ 0x1f /*kp-6 -> 'o'*/, 0x1a /*kp-7 -> '7'*/, 0, 0x1c /*kp-8 -> '8'*/,
9737 /*0x5C*/ 0x19 /*kp-9 -> '9'*/, 0, 0, 0,
9739 /*0x60*/ 0x60 /*f5 = f5*/, 0x61 /*f6 = f6*/, 0x62 /*f7 = f7*/, 0x63 /*f3 = f3*/,
9740 /*0x64*/ 0x64 /*f8 = f8*/, 0x65 /*f9 = f9*/, 0, 0x67 /*f11 = f11*/,
9741 /*0x68*/ 0, 0, 0, 0,
9742 /*0x6C*/ 0, 0x6d /*f10 = f10*/, 0, 0x6f /*f12 = f12*/,
9744 /*0x70*/ 0, 0, 0, 0x7b /*home -> left*/,
9745 /*0x74*/ 0x7e /*pgup -> up*/, 0x33 /*delete -> backspace*/, 0x76 /*f4 = f4*/, 0x7c /*end -> right*/,
9746 /*0x78*/ 0x78 /*f2 = f2*/, 0x7d /*pgdown -> down*/, 0x7a /*f1 = f1*/, 0,
9749 #endif /* MAC_OSX */
9752 #if TARGET_API_MAC_CARBON
9753 mac_to_emacs_modifiers (UInt32 mods
)
9755 mac_to_emacs_modifiers (EventModifiers mods
)
9758 unsigned int result
= 0;
9759 if (mods
& shiftKey
)
9760 result
|= shift_modifier
;
9762 /* Deactivated to simplify configuration:
9763 if Vmac_option_modifier is non-NIL, we fully process the Option
9764 key. Otherwise, we only process it if an additional Ctrl or Command
9765 is pressed. That way the system may convert the character to a
9767 if ((mods & optionKey) &&
9768 (( !NILP(Vmac_option_modifier) ||
9769 ((mods & cmdKey) || (mods & controlKey))))) */
9771 if (!NILP (Vmac_option_modifier
) && (mods
& optionKey
)) {
9772 Lisp_Object val
= Fget(Vmac_option_modifier
, Qmodifier_value
);
9774 result
|= XUINT(val
);
9776 if (!NILP (Vmac_command_modifier
) && (mods
& cmdKey
)) {
9777 Lisp_Object val
= Fget(Vmac_command_modifier
, Qmodifier_value
);
9779 result
|= XUINT(val
);
9781 if (!NILP (Vmac_control_modifier
) && (mods
& controlKey
)) {
9782 Lisp_Object val
= Fget(Vmac_control_modifier
, Qmodifier_value
);
9784 result
|= XUINT(val
);
9788 if (!NILP (Vmac_function_modifier
) && (mods
& kEventKeyModifierFnMask
)) {
9789 Lisp_Object val
= Fget(Vmac_function_modifier
, Qmodifier_value
);
9791 result
|= XUINT(val
);
9799 mac_mapped_modifiers (modifiers
)
9802 UInt32 mapped_modifiers_all
=
9803 (NILP (Vmac_control_modifier
) ? 0 : controlKey
)
9804 | (NILP (Vmac_option_modifier
) ? 0 : optionKey
)
9805 | (NILP (Vmac_command_modifier
) ? 0 : cmdKey
);
9808 mapped_modifiers_all
|=
9809 (NILP (Vmac_function_modifier
) ? 0 : kEventKeyModifierFnMask
);
9812 return mapped_modifiers_all
& modifiers
;
9816 mac_get_emulated_btn ( UInt32 modifiers
)
9819 if (!NILP (Vmac_emulate_three_button_mouse
)) {
9820 int cmdIs3
= !EQ (Vmac_emulate_three_button_mouse
, Qreverse
);
9821 if (modifiers
& cmdKey
)
9822 result
= cmdIs3
? 2 : 1;
9823 else if (modifiers
& optionKey
)
9824 result
= cmdIs3
? 1 : 2;
9829 #if TARGET_API_MAC_CARBON
9830 /***** Code to handle C-g testing *****/
9831 extern int quit_char
;
9832 extern int make_ctrl_char
P_ ((int));
9835 mac_quit_char_key_p (modifiers
, key_code
)
9836 UInt32 modifiers
, key_code
;
9839 unsigned long some_state
= 0;
9840 Ptr kchr_ptr
= (Ptr
) GetScriptManagerVariable (smKCHRCache
);
9841 int c
, emacs_modifiers
;
9843 /* Mask off modifier keys that are mapped to some Emacs modifiers. */
9844 key_code
|= (modifiers
& ~(mac_mapped_modifiers (modifiers
)));
9845 char_code
= KeyTranslate (kchr_ptr
, key_code
, &some_state
);
9846 if (char_code
& ~0xff)
9849 emacs_modifiers
= mac_to_emacs_modifiers (modifiers
);
9850 if (emacs_modifiers
& ctrl_modifier
)
9851 c
= make_ctrl_char (char_code
);
9853 c
|= (emacs_modifiers
9854 & (meta_modifier
| alt_modifier
9855 | hyper_modifier
| super_modifier
));
9857 return c
== quit_char
;
9861 #if TARGET_API_MAC_CARBON
9862 /* Obtains the event modifiers from the event ref and then calls
9863 mac_to_emacs_modifiers. */
9865 mac_event_to_emacs_modifiers (EventRef eventRef
)
9867 UInt32 mods
= 0, class;
9869 GetEventParameter (eventRef
, kEventParamKeyModifiers
, typeUInt32
, NULL
,
9870 sizeof (UInt32
), NULL
, &mods
);
9871 class = GetEventClass (eventRef
);
9872 if (!NILP (Vmac_emulate_three_button_mouse
) &&
9873 (class == kEventClassMouse
|| class == kEventClassCommand
))
9875 mods
&= ~(optionKey
| cmdKey
);
9877 return mac_to_emacs_modifiers (mods
);
9880 /* Given an event ref, return the code to use for the mouse button
9881 code in the emacs input_event. */
9883 mac_get_mouse_btn (EventRef ref
)
9885 EventMouseButton result
= kEventMouseButtonPrimary
;
9886 GetEventParameter (ref
, kEventParamMouseButton
, typeMouseButton
, NULL
,
9887 sizeof (EventMouseButton
), NULL
, &result
);
9890 case kEventMouseButtonPrimary
:
9891 if (NILP (Vmac_emulate_three_button_mouse
))
9895 GetEventParameter (ref
, kEventParamKeyModifiers
, typeUInt32
, NULL
,
9896 sizeof (UInt32
), NULL
, &mods
);
9897 return mac_get_emulated_btn(mods
);
9899 case kEventMouseButtonSecondary
:
9900 return mac_wheel_button_is_mouse_2
? 2 : 1;
9901 case kEventMouseButtonTertiary
:
9902 case 4: /* 4 is the number for the mouse wheel button */
9903 return mac_wheel_button_is_mouse_2
? 1 : 2;
9909 /* Normally, ConvertEventRefToEventRecord will correctly handle all
9910 events. However the click of the mouse wheel is not converted to a
9911 mouseDown or mouseUp event. Likewise for dead key events. This
9912 calls ConvertEventRefToEventRecord, but then checks to see if it is
9913 a mouse up/down, or a dead key Carbon event that has not been
9914 converted, and if so, converts it by hand (to be picked up in the
9915 XTread_socket loop). */
9916 static Boolean
mac_convert_event_ref (EventRef eventRef
, EventRecord
*eventRec
)
9919 Boolean result
= ConvertEventRefToEventRecord (eventRef
, eventRec
);
9925 switch (GetEventClass (eventRef
))
9927 case kEventClassMouse
:
9928 switch (GetEventKind (eventRef
))
9930 case kEventMouseDown
:
9931 eventRec
->what
= mouseDown
;
9936 eventRec
->what
= mouseUp
;
9945 case kEventClassKeyboard
:
9946 switch (GetEventKind (eventRef
))
9948 case kEventRawKeyDown
:
9950 goto keystroke_common
;
9951 case kEventRawKeyRepeat
:
9953 goto keystroke_common
;
9954 case kEventRawKeyUp
:
9958 unsigned char char_codes
;
9961 err
= GetEventParameter (eventRef
, kEventParamKeyMacCharCodes
,
9962 typeChar
, NULL
, sizeof (char),
9965 err
= GetEventParameter (eventRef
, kEventParamKeyCode
,
9966 typeUInt32
, NULL
, sizeof (UInt32
),
9970 eventRec
->what
= action
;
9971 eventRec
->message
= char_codes
| ((key_code
& 0xff) << 8);
9988 /* Need where and when. */
9991 GetEventParameter (eventRef
, kEventParamMouseLocation
, typeQDPoint
,
9992 NULL
, sizeof (Point
), NULL
, &eventRec
->where
);
9993 /* Use two step process because new event modifiers are 32-bit
9994 and old are 16-bit. Currently, only loss is NumLock & Fn. */
9995 GetEventParameter (eventRef
, kEventParamKeyModifiers
, typeUInt32
,
9996 NULL
, sizeof (UInt32
), NULL
, &mods
);
9997 eventRec
->modifiers
= mods
;
9999 eventRec
->when
= EventTimeToTicks (GetEventTime (eventRef
));
10009 do_get_menus (void)
10011 Handle menubar_handle
;
10014 menubar_handle
= GetNewMBar (128);
10015 if(menubar_handle
== NULL
)
10017 SetMenuBar (menubar_handle
);
10020 #if !TARGET_API_MAC_CARBON
10021 menu
= GetMenuRef (M_APPLE
);
10023 AppendResMenu (menu
, 'DRVR');
10031 do_init_managers (void)
10033 #if !TARGET_API_MAC_CARBON
10034 InitGraf (&qd
.thePort
);
10036 FlushEvents (everyEvent
, 0);
10040 InitDialogs (NULL
);
10041 #endif /* !TARGET_API_MAC_CARBON */
10044 #if !TARGET_API_MAC_CARBON
10045 /* set up some extra stack space for use by emacs */
10046 SetApplLimit ((Ptr
) ((long) GetApplLimit () - EXTRA_STACK_ALLOC
));
10048 /* MaxApplZone must be called for AppleScript to execute more
10049 complicated scripts */
10052 #endif /* !TARGET_API_MAC_CARBON */
10056 do_check_ram_size (void)
10058 SInt32 physical_ram_size
, logical_ram_size
;
10060 if (Gestalt (gestaltPhysicalRAMSize
, &physical_ram_size
) != noErr
10061 || Gestalt (gestaltLogicalRAMSize
, &logical_ram_size
) != noErr
10062 || physical_ram_size
> (1 << VALBITS
)
10063 || logical_ram_size
> (1 << VALBITS
))
10065 StopAlert (RAM_TOO_LARGE_ALERT_ID
, NULL
);
10069 #endif /* MAC_OS8 */
10072 do_window_update (WindowRef win
)
10074 struct frame
*f
= mac_window_to_frame (win
);
10078 /* The tooltip has been drawn already. Avoid the SET_FRAME_GARBAGED
10080 if (win
!= tip_window
)
10082 if (f
->async_visible
== 0)
10084 /* Update events may occur when a frame gets iconified. */
10086 f
->async_visible
= 1;
10087 f
->async_iconified
= 0;
10088 SET_FRAME_GARBAGED (f
);
10094 #if TARGET_API_MAC_CARBON
10095 RgnHandle region
= NewRgn ();
10097 GetPortVisibleRegion (GetWindowPort (win
), region
);
10098 GetRegionBounds (region
, &r
);
10099 expose_frame (f
, r
.left
, r
.top
, r
.right
- r
.left
, r
.bottom
- r
.top
);
10101 mac_prepare_for_quickdraw (f
);
10103 UpdateControls (win
, region
);
10104 DisposeRgn (region
);
10106 r
= (*win
->visRgn
)->rgnBBox
;
10107 expose_frame (f
, r
.left
, r
.top
, r
.right
- r
.left
, r
.bottom
- r
.top
);
10108 UpdateControls (win
, win
->visRgn
);
10117 is_emacs_window (WindowRef win
)
10119 Lisp_Object tail
, frame
;
10124 FOR_EACH_FRAME (tail
, frame
)
10125 if (FRAME_MAC_P (XFRAME (frame
)))
10126 if (FRAME_MAC_WINDOW (XFRAME (frame
)) == win
)
10137 ScriptLanguageRecord slrec
, *slptr
= NULL
;
10139 err
= ActivateTSMDocument (tsm_document_id
);
10143 if (EQ (Vmac_ts_script_language_on_focus
, Qt
)
10144 && EQ (saved_ts_script_language_on_focus
, Qt
))
10145 slptr
= &saved_ts_language
;
10146 else if (CONSP (Vmac_ts_script_language_on_focus
)
10147 && INTEGERP (XCAR (Vmac_ts_script_language_on_focus
))
10148 && INTEGERP (XCDR (Vmac_ts_script_language_on_focus
))
10149 && CONSP (saved_ts_script_language_on_focus
)
10150 && EQ (XCAR (saved_ts_script_language_on_focus
),
10151 XCAR (Vmac_ts_script_language_on_focus
))
10152 && EQ (XCDR (saved_ts_script_language_on_focus
),
10153 XCDR (Vmac_ts_script_language_on_focus
)))
10155 slrec
.fScript
= XINT (XCAR (Vmac_ts_script_language_on_focus
));
10156 slrec
.fLanguage
= XINT (XCDR (Vmac_ts_script_language_on_focus
));
10163 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
10164 err
= SetDefaultInputMethodOfClass (saved_ts_component
, slptr
,
10165 kKeyboardInputMethodClass
);
10167 err
= SetDefaultInputMethod (saved_ts_component
, slptr
);
10170 err
= SetTextServiceLanguage (slptr
);
10172 /* Seems to be needed on Mac OS X 10.2. */
10174 KeyScript (slptr
->fScript
| smKeyForceKeyScriptMask
);
10184 ScriptLanguageRecord slrec
, *slptr
= NULL
;
10186 saved_ts_script_language_on_focus
= Vmac_ts_script_language_on_focus
;
10188 if (EQ (Vmac_ts_script_language_on_focus
, Qt
))
10190 err
= GetTextServiceLanguage (&saved_ts_language
);
10192 slptr
= &saved_ts_language
;
10194 else if (CONSP (Vmac_ts_script_language_on_focus
)
10195 && INTEGERP (XCAR (Vmac_ts_script_language_on_focus
))
10196 && INTEGERP (XCDR (Vmac_ts_script_language_on_focus
)))
10198 slrec
.fScript
= XINT (XCAR (Vmac_ts_script_language_on_focus
));
10199 slrec
.fLanguage
= XINT (XCDR (Vmac_ts_script_language_on_focus
));
10205 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
10206 GetDefaultInputMethodOfClass (&saved_ts_component
, slptr
,
10207 kKeyboardInputMethodClass
);
10209 GetDefaultInputMethod (&saved_ts_component
, slptr
);
10213 err
= DeactivateTSMDocument (tsm_document_id
);
10219 #if !TARGET_API_MAC_CARBON
10221 do_apple_menu (SInt16 menu_item
)
10224 SInt16 da_driver_refnum
;
10226 if (menu_item
== I_ABOUT
)
10227 NoteAlert (ABOUT_ALERT_ID
, NULL
);
10230 GetMenuItemText (GetMenuRef (M_APPLE
), menu_item
, item_name
);
10231 da_driver_refnum
= OpenDeskAcc (item_name
);
10234 #endif /* !TARGET_API_MAC_CARBON */
10236 /* Handle drags in size box. Based on code contributed by Ben
10237 Mesander and IM - Window Manager A. */
10240 do_grow_window (w
, e
)
10242 const EventRecord
*e
;
10245 int rows
, columns
, width
, height
;
10246 struct frame
*f
= mac_window_to_frame (w
);
10247 XSizeHints
*size_hints
= FRAME_SIZE_HINTS (f
);
10248 int min_width
= MIN_DOC_SIZE
, min_height
= MIN_DOC_SIZE
;
10249 #if TARGET_API_MAC_CARBON
10255 if (size_hints
->flags
& PMinSize
)
10257 min_width
= size_hints
->min_width
;
10258 min_height
= size_hints
->min_height
;
10260 SetRect (&limit_rect
, min_width
, min_height
, MAX_DOC_SIZE
, MAX_DOC_SIZE
);
10262 #if TARGET_API_MAC_CARBON
10263 if (!ResizeWindow (w
, e
->where
, &limit_rect
, &new_rect
))
10265 height
= new_rect
.bottom
- new_rect
.top
;
10266 width
= new_rect
.right
- new_rect
.left
;
10268 grow_size
= GrowWindow (w
, e
->where
, &limit_rect
);
10269 /* see if it really changed size */
10270 if (grow_size
== 0)
10272 height
= HiWord (grow_size
);
10273 width
= LoWord (grow_size
);
10276 if (width
!= FRAME_PIXEL_WIDTH (f
)
10277 || height
!= FRAME_PIXEL_HEIGHT (f
))
10279 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, height
);
10280 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, width
);
10282 x_set_window_size (f
, 0, columns
, rows
);
10287 #if TARGET_API_MAC_CARBON
10289 mac_get_ideal_size (f
)
10292 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
10293 WindowRef w
= FRAME_MAC_WINDOW (f
);
10295 Rect standard_rect
;
10296 int height
, width
, columns
, rows
;
10298 ideal_size
.h
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, DEFAULT_NUM_COLS
);
10299 ideal_size
.v
= dpyinfo
->height
;
10300 IsWindowInStandardState (w
, &ideal_size
, &standard_rect
);
10301 /* Adjust the standard size according to character boundaries. */
10302 width
= standard_rect
.right
- standard_rect
.left
;
10303 height
= standard_rect
.bottom
- standard_rect
.top
;
10304 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, width
);
10305 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, height
);
10306 ideal_size
.h
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, columns
);
10307 ideal_size
.v
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
);
10313 /* Handle clicks in zoom box. Calculation of "standard state" based
10314 on code in IM - Window Manager A and code contributed by Ben
10315 Mesander. The standard state of an Emacs window is 80-characters
10316 wide (DEFAULT_NUM_COLS) and as tall as will fit on the screen. */
10319 do_zoom_window (WindowRef w
, int zoom_in_or_out
)
10321 Rect zoom_rect
, port_rect
;
10323 struct frame
*f
= mac_window_to_frame (w
);
10324 #if TARGET_API_MAC_CARBON
10325 Point ideal_size
= mac_get_ideal_size (f
);
10327 GetWindowBounds (w
, kWindowContentRgn
, &port_rect
);
10328 if (IsWindowInStandardState (w
, &ideal_size
, &zoom_rect
)
10329 && port_rect
.left
== zoom_rect
.left
10330 && port_rect
.top
== zoom_rect
.top
)
10331 zoom_in_or_out
= inZoomIn
;
10333 zoom_in_or_out
= inZoomOut
;
10336 mac_clear_window (f
);
10338 ZoomWindowIdeal (w
, zoom_in_or_out
, &ideal_size
);
10339 #else /* not TARGET_API_MAC_CARBON */
10342 int w_title_height
, rows
;
10343 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
10345 GetPort (&save_port
);
10347 SetPortWindowPort (w
);
10349 /* Clear window to avoid flicker. */
10350 EraseRect (&(w
->portRect
));
10351 if (zoom_in_or_out
== inZoomOut
)
10353 SetPt (&top_left
, w
->portRect
.left
, w
->portRect
.top
);
10354 LocalToGlobal (&top_left
);
10356 /* calculate height of window's title bar */
10357 w_title_height
= top_left
.v
- 1
10358 - (**((WindowPeek
) w
)->strucRgn
).rgnBBox
.top
+ GetMBarHeight ();
10360 /* get maximum height of window into zoom_rect.bottom - zoom_rect.top */
10361 zoom_rect
= qd
.screenBits
.bounds
;
10362 zoom_rect
.top
+= w_title_height
;
10363 InsetRect (&zoom_rect
, 8, 4); /* not too tight */
10365 zoom_rect
.right
= zoom_rect
.left
10366 + FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, DEFAULT_NUM_COLS
);
10368 /* Adjust the standard size according to character boundaries. */
10369 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, zoom_rect
.bottom
- zoom_rect
.top
);
10371 zoom_rect
.top
+ FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
);
10373 (**((WStateDataHandle
) ((WindowPeek
) w
)->dataHandle
)).stdState
10377 ZoomWindow (w
, zoom_in_or_out
, f
== mac_focus_frame (dpyinfo
));
10379 SetPort (save_port
);
10380 #endif /* not TARGET_API_MAC_CARBON */
10382 #if !TARGET_API_MAC_CARBON
10383 /* retrieve window size and update application values */
10384 port_rect
= w
->portRect
;
10385 height
= port_rect
.bottom
- port_rect
.top
;
10386 width
= port_rect
.right
- port_rect
.left
;
10388 mac_handle_size_change (f
, width
, height
);
10389 mac_handle_origin_change (f
);
10394 mac_set_unicode_keystroke_event (code
, buf
)
10396 struct input_event
*buf
;
10398 int charset_id
, c1
, c2
;
10402 buf
->kind
= ASCII_KEYSTROKE_EVENT
;
10405 else if (code
< 0x100)
10408 charset_id
= CHARSET_8_BIT_CONTROL
;
10410 charset_id
= charset_latin_iso8859_1
;
10411 buf
->kind
= MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
10412 buf
->code
= MAKE_CHAR (charset_id
, code
, 0);
10417 charset_id
= charset_mule_unicode_0100_24ff
,
10419 else if (code
< 0x33FF)
10420 charset_id
= charset_mule_unicode_2500_33ff
,
10422 else if (code
>= 0xE000)
10423 charset_id
= charset_mule_unicode_e000_ffff
,
10425 c1
= (code
/ 96) + 32, c2
= (code
% 96) + 32;
10426 buf
->kind
= MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
10427 buf
->code
= MAKE_CHAR (charset_id
, c1
, c2
);
10432 do_keystroke (action
, char_code
, key_code
, modifiers
, timestamp
, buf
)
10434 unsigned char char_code
;
10435 UInt32 key_code
, modifiers
;
10436 unsigned long timestamp
;
10437 struct input_event
*buf
;
10439 static SInt16 last_key_script
= -1;
10440 SInt16 current_key_script
= GetScriptManagerVariable (smKeyScript
);
10441 UInt32 mapped_modifiers
= mac_mapped_modifiers (modifiers
);
10444 if (mapped_modifiers
& kEventKeyModifierFnMask
10445 && key_code
<= 0x7f
10446 && fn_keycode_to_keycode_table
[key_code
])
10447 key_code
= fn_keycode_to_keycode_table
[key_code
];
10450 if (key_code
<= 0x7f && keycode_to_xkeysym_table
[key_code
])
10452 buf
->kind
= NON_ASCII_KEYSTROKE_EVENT
;
10453 buf
->code
= 0xff00 | keycode_to_xkeysym_table
[key_code
];
10455 if (modifiers
& kEventKeyModifierFnMask
10456 && key_code
<= 0x7f
10457 && fn_keycode_to_keycode_table
[key_code
] == key_code
)
10458 modifiers
&= ~kEventKeyModifierFnMask
;
10461 else if (mapped_modifiers
)
10463 /* translate the keycode back to determine the original key */
10465 UCKeyboardLayout
*uchr_ptr
= NULL
;
10466 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
10468 KeyboardLayoutRef layout
;
10470 err
= KLGetCurrentKeyboardLayout (&layout
);
10472 err
= KLGetKeyboardLayoutProperty (layout
, kKLuchrData
,
10473 (const void **) &uchr_ptr
);
10475 static SInt16 last_key_layout_id
= 0;
10476 static Handle uchr_handle
= (Handle
)-1;
10477 SInt16 current_key_layout_id
=
10478 GetScriptVariable (current_key_script
, smScriptKeys
);
10480 if (uchr_handle
== (Handle
)-1
10481 || last_key_layout_id
!= current_key_layout_id
)
10483 uchr_handle
= GetResource ('uchr', current_key_layout_id
);
10484 last_key_layout_id
= current_key_layout_id
;
10487 uchr_ptr
= (UCKeyboardLayout
*)*uchr_handle
;
10493 UInt16 key_action
= action
- keyDown
;
10494 UInt32 modifier_key_state
= (modifiers
& ~mapped_modifiers
) >> 8;
10495 UInt32 keyboard_type
= LMGetKbdType ();
10496 SInt32 dead_key_state
= 0;
10498 UniCharCount actual_length
;
10500 status
= UCKeyTranslate (uchr_ptr
, key_code
, key_action
,
10501 modifier_key_state
, keyboard_type
,
10502 kUCKeyTranslateNoDeadKeysMask
,
10504 1, &actual_length
, &code
);
10505 if (status
== noErr
&& actual_length
== 1)
10506 mac_set_unicode_keystroke_event (code
, buf
);
10508 #endif /* MAC_OSX */
10510 if (buf
->kind
== NO_EVENT
)
10512 /* This code comes from Keyboard Resource, Appendix C of IM
10513 - Text. This is necessary since shift is ignored in KCHR
10514 table translation when option or command is pressed. It
10515 also does not translate correctly control-shift chars
10516 like C-% so mask off shift here also. */
10517 /* Mask off modifier keys that are mapped to some Emacs
10519 int new_modifiers
= modifiers
& ~mapped_modifiers
;
10520 /* set high byte of keycode to modifier high byte*/
10521 int new_key_code
= key_code
| new_modifiers
;
10522 Ptr kchr_ptr
= (Ptr
) GetScriptManagerVariable (smKCHRCache
);
10523 unsigned long some_state
= 0;
10524 UInt32 new_char_code
;
10526 new_char_code
= KeyTranslate (kchr_ptr
, new_key_code
, &some_state
);
10527 if (new_char_code
== 0)
10528 /* Seems like a dead key. Append up-stroke. */
10529 new_char_code
= KeyTranslate (kchr_ptr
, new_key_code
| 0x80,
10533 buf
->kind
= ASCII_KEYSTROKE_EVENT
;
10534 buf
->code
= new_char_code
& 0xff;
10539 if (buf
->kind
== NO_EVENT
)
10541 buf
->kind
= ASCII_KEYSTROKE_EVENT
;
10542 buf
->code
= char_code
;
10545 buf
->modifiers
= mac_to_emacs_modifiers (modifiers
);
10546 buf
->modifiers
|= (extra_keyboard_modifiers
10547 & (meta_modifier
| alt_modifier
10548 | hyper_modifier
| super_modifier
));
10550 #if TARGET_API_MAC_CARBON
10551 if (buf
->kind
== ASCII_KEYSTROKE_EVENT
10552 && buf
->code
>= 0x80 && buf
->modifiers
)
10555 TextEncoding encoding
= kTextEncodingMacRoman
;
10556 TextToUnicodeInfo ttu_info
;
10558 UpgradeScriptInfoToTextEncoding (current_key_script
,
10559 kTextLanguageDontCare
,
10560 kTextRegionDontCare
,
10562 err
= CreateTextToUnicodeInfoByEncoding (encoding
, &ttu_info
);
10567 ByteCount unicode_len
;
10570 pstr
[1] = buf
->code
;
10571 err
= ConvertFromPStringToUnicode (ttu_info
, pstr
,
10573 &unicode_len
, &code
);
10574 if (err
== noErr
&& unicode_len
== sizeof (UniChar
))
10575 mac_set_unicode_keystroke_event (code
, buf
);
10576 DisposeTextToUnicodeInfo (&ttu_info
);
10581 if (buf
->kind
== ASCII_KEYSTROKE_EVENT
10582 && buf
->code
>= 0x80
10583 && last_key_script
!= current_key_script
)
10585 struct input_event event
;
10587 EVENT_INIT (event
);
10588 event
.kind
= LANGUAGE_CHANGE_EVENT
;
10590 event
.code
= current_key_script
;
10591 event
.timestamp
= timestamp
;
10592 kbd_buffer_store_event (&event
);
10593 last_key_script
= current_key_script
;
10598 mac_store_apple_event (class, id
, desc
)
10599 Lisp_Object
class, id
;
10600 const AEDesc
*desc
;
10602 struct input_event buf
;
10606 buf
.kind
= MAC_APPLE_EVENT
;
10609 XSETFRAME (buf
.frame_or_window
,
10610 mac_focus_frame (&one_mac_display_info
));
10611 /* Now that Lisp object allocations are protected by BLOCK_INPUT, it
10612 is safe to use them during read_socket_hook. */
10613 buf
.arg
= mac_aedesc_to_lisp (desc
);
10614 kbd_buffer_store_event (&buf
);
10617 #if TARGET_API_MAC_CARBON
10619 mac_store_event_ref_as_apple_event (class, id
, class_key
, id_key
,
10620 event
, num_params
, names
, types
)
10621 AEEventClass
class;
10623 Lisp_Object class_key
, id_key
;
10626 const EventParamName
*names
;
10627 const EventParamType
*types
;
10629 OSStatus err
= eventNotHandledErr
;
10630 Lisp_Object binding
;
10632 mac_find_apple_event_spec (class, id
, &class_key
, &id_key
, &binding
);
10633 if (!NILP (binding
) && !EQ (binding
, Qundefined
))
10635 if (INTEGERP (binding
))
10636 err
= XINT (binding
);
10639 AppleEvent apple_event
;
10640 err
= create_apple_event_from_event_ref (event
, num_params
,
10645 mac_store_apple_event (class_key
, id_key
, &apple_event
);
10646 AEDisposeDesc (&apple_event
);
10647 mac_wakeup_from_rne ();
10656 mac_store_drag_event (window
, mouse_pos
, modifiers
, desc
)
10660 const AEDesc
*desc
;
10662 struct input_event buf
;
10666 buf
.kind
= DRAG_N_DROP_EVENT
;
10667 buf
.modifiers
= mac_to_emacs_modifiers (modifiers
);
10668 buf
.timestamp
= TickCount () * (1000 / 60);
10669 XSETINT (buf
.x
, mouse_pos
.h
);
10670 XSETINT (buf
.y
, mouse_pos
.v
);
10671 XSETFRAME (buf
.frame_or_window
, mac_window_to_frame (window
));
10672 buf
.arg
= mac_aedesc_to_lisp (desc
);
10673 kbd_buffer_store_event (&buf
);
10678 mac_store_service_event (event
)
10682 Lisp_Object id_key
;
10684 const EventParamName
*names
;
10685 const EventParamType
*types
;
10686 static const EventParamName names_pfm
[] =
10687 {kEventParamServiceMessageName
, kEventParamServiceUserData
};
10688 static const EventParamType types_pfm
[] =
10689 {typeCFStringRef
, typeCFStringRef
};
10691 switch (GetEventKind (event
))
10693 case kEventServicePaste
:
10700 case kEventServicePerform
:
10702 num_params
= sizeof (names_pfm
) / sizeof (names_pfm
[0]);
10711 err
= mac_store_event_ref_as_apple_event (0, 0, Qservice
, id_key
,
10717 #endif /* MAC_OSX */
10719 static pascal OSStatus
10720 mac_handle_window_event (next_handler
, event
, data
)
10721 EventHandlerCallRef next_handler
;
10726 OSStatus err
, result
= eventNotHandledErr
;
10729 XSizeHints
*size_hints
;
10731 err
= GetEventParameter (event
, kEventParamDirectObject
, typeWindowRef
,
10732 NULL
, sizeof (WindowRef
), NULL
, &wp
);
10734 return eventNotHandledErr
;
10736 f
= mac_window_to_frame (wp
);
10737 switch (GetEventKind (event
))
10739 /* -- window refresh events -- */
10741 case kEventWindowUpdate
:
10742 result
= CallNextEventHandler (next_handler
, event
);
10743 if (result
!= eventNotHandledErr
)
10746 do_window_update (wp
);
10750 /* -- window state change events -- */
10752 case kEventWindowShowing
:
10753 size_hints
= FRAME_SIZE_HINTS (f
);
10754 if (!(size_hints
->flags
& (USPosition
| PPosition
)))
10756 struct frame
*sf
= SELECTED_FRAME ();
10758 if (!(FRAME_MAC_P (sf
) && sf
->async_visible
))
10759 RepositionWindow (wp
, NULL
, kWindowCenterOnMainScreen
);
10762 RepositionWindow (wp
, FRAME_MAC_WINDOW (sf
),
10763 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
10764 kWindowCascadeStartAtParentWindowScreen
10766 kWindowCascadeOnParentWindowScreen
10769 #if USE_MAC_TOOLBAR
10770 /* This is a workaround. RepositionWindow fails to put
10771 a window at the cascading position when its parent
10772 window has a Carbon HIToolbar. */
10773 if ((f
->left_pos
== sf
->left_pos
10774 && f
->top_pos
== sf
->top_pos
)
10775 || (f
->left_pos
== sf
->left_pos
+ 10 * 2
10776 && f
->top_pos
== sf
->top_pos
+ 32 * 2))
10777 MoveWindowStructure (wp
, sf
->left_pos
+ 10, sf
->top_pos
+ 32);
10784 case kEventWindowHiding
:
10785 /* Before unmapping the window, update the WM_SIZE_HINTS
10786 property to claim that the current position of the window is
10787 user-specified, rather than program-specified, so that when
10788 the window is mapped again, it will be placed at the same
10789 location, without forcing the user to position it by hand
10790 again (they have already done that once for this window.) */
10791 x_wm_set_size_hint (f
, (long) 0, 1);
10795 case kEventWindowShown
:
10796 case kEventWindowHidden
:
10797 case kEventWindowCollapsed
:
10798 case kEventWindowExpanded
:
10799 mac_handle_visibility_change (f
);
10803 case kEventWindowBoundsChanging
:
10804 result
= CallNextEventHandler (next_handler
, event
);
10805 if (result
!= eventNotHandledErr
)
10808 err
= GetEventParameter (event
, kEventParamAttributes
, typeUInt32
,
10809 NULL
, sizeof (UInt32
), NULL
, &attributes
);
10813 size_hints
= FRAME_SIZE_HINTS (f
);
10814 if ((attributes
& kWindowBoundsChangeUserResize
)
10815 && ((size_hints
->flags
& (PResizeInc
| PBaseSize
| PMinSize
))
10816 == (PResizeInc
| PBaseSize
| PMinSize
)))
10821 err
= GetEventParameter (event
, kEventParamCurrentBounds
,
10822 typeQDRectangle
, NULL
, sizeof (Rect
),
10827 width
= bounds
.right
- bounds
.left
;
10828 height
= bounds
.bottom
- bounds
.top
;
10830 if (width
< size_hints
->min_width
)
10831 width
= size_hints
->min_width
;
10833 width
= size_hints
->base_width
10834 + (int) ((width
- size_hints
->base_width
)
10835 / (float) size_hints
->width_inc
+ .5)
10836 * size_hints
->width_inc
;
10838 if (height
< size_hints
->min_height
)
10839 height
= size_hints
->min_height
;
10841 height
= size_hints
->base_height
10842 + (int) ((height
- size_hints
->base_height
)
10843 / (float) size_hints
->height_inc
+ .5)
10844 * size_hints
->height_inc
;
10846 bounds
.right
= bounds
.left
+ width
;
10847 bounds
.bottom
= bounds
.top
+ height
;
10848 SetEventParameter (event
, kEventParamCurrentBounds
,
10849 typeQDRectangle
, sizeof (Rect
), &bounds
);
10854 case kEventWindowBoundsChanged
:
10855 err
= GetEventParameter (event
, kEventParamAttributes
, typeUInt32
,
10856 NULL
, sizeof (UInt32
), NULL
, &attributes
);
10860 if (attributes
& kWindowBoundsChangeSizeChanged
)
10864 err
= GetEventParameter (event
, kEventParamCurrentBounds
,
10865 typeQDRectangle
, NULL
, sizeof (Rect
),
10871 width
= bounds
.right
- bounds
.left
;
10872 height
= bounds
.bottom
- bounds
.top
;
10873 mac_handle_size_change (f
, width
, height
);
10874 mac_wakeup_from_rne ();
10878 if (attributes
& kWindowBoundsChangeOriginChanged
)
10879 mac_handle_origin_change (f
);
10884 /* -- window action events -- */
10886 case kEventWindowClose
:
10888 struct input_event buf
;
10891 buf
.kind
= DELETE_WINDOW_EVENT
;
10892 XSETFRAME (buf
.frame_or_window
, f
);
10894 kbd_buffer_store_event (&buf
);
10899 case kEventWindowGetIdealSize
:
10900 result
= CallNextEventHandler (next_handler
, event
);
10901 if (result
!= eventNotHandledErr
)
10905 Point ideal_size
= mac_get_ideal_size (f
);
10907 err
= SetEventParameter (event
, kEventParamDimensions
,
10908 typeQDPoint
, sizeof (Point
), &ideal_size
);
10915 case kEventWindowToolbarSwitchMode
:
10917 static const EventParamName names
[] = {kEventParamDirectObject
,
10918 kEventParamWindowMouseLocation
,
10919 kEventParamKeyModifiers
,
10920 kEventParamMouseButton
,
10921 kEventParamClickCount
,
10922 kEventParamMouseChord
};
10923 static const EventParamType types
[] = {typeWindowRef
,
10929 int num_params
= sizeof (names
) / sizeof (names
[0]);
10931 err
= mac_store_event_ref_as_apple_event (0, 0,
10933 Qtoolbar_switch_mode
,
10943 /* -- window focus events -- */
10945 case kEventWindowFocusAcquired
:
10946 err
= mac_tsm_resume ();
10951 case kEventWindowFocusRelinquish
:
10952 err
= mac_tsm_suspend ();
10965 static pascal OSStatus
10966 mac_handle_application_event (next_handler
, event
, data
)
10967 EventHandlerCallRef next_handler
;
10971 OSStatus err
, result
= eventNotHandledErr
;
10973 switch (GetEventKind (event
))
10976 case kEventAppActivated
:
10977 err
= mac_tsm_resume ();
10980 case kEventAppDeactivated
:
10981 err
= mac_tsm_suspend ();
10995 static pascal OSStatus
10996 mac_handle_keyboard_event (next_handler
, event
, data
)
10997 EventHandlerCallRef next_handler
;
11001 OSStatus err
, result
= eventNotHandledErr
;
11002 UInt32 event_kind
, key_code
, modifiers
;
11003 unsigned char char_code
;
11005 event_kind
= GetEventKind (event
);
11006 switch (event_kind
)
11008 case kEventRawKeyDown
:
11009 case kEventRawKeyRepeat
:
11010 case kEventRawKeyUp
:
11011 /* When using Carbon Events, we need to pass raw keyboard events
11012 to the TSM ourselves. If TSM handles it, it will pass back
11013 noErr, otherwise it will pass back "eventNotHandledErr" and
11014 we can process it normally. */
11015 result
= CallNextEventHandler (next_handler
, event
);
11016 if (result
!= eventNotHandledErr
)
11019 if (read_socket_inev
== NULL
)
11023 if (read_socket_inev
->kind
!= NO_EVENT
)
11030 if (event_kind
== kEventRawKeyUp
)
11033 err
= GetEventParameter (event
, kEventParamKeyMacCharCodes
,
11035 sizeof (char), NULL
, &char_code
);
11039 err
= GetEventParameter (event
, kEventParamKeyCode
,
11041 sizeof (UInt32
), NULL
, &key_code
);
11045 err
= GetEventParameter (event
, kEventParamKeyModifiers
,
11047 sizeof (UInt32
), NULL
, &modifiers
);
11051 do_keystroke ((event_kind
== kEventRawKeyDown
? keyDown
: autoKey
),
11052 char_code
, key_code
, modifiers
,
11054 (GetEventTime (event
) / kEventDurationMillisecond
)),
11066 static pascal OSStatus
11067 mac_handle_command_event (next_handler
, event
, data
)
11068 EventHandlerCallRef next_handler
;
11072 OSStatus err
, result
= eventNotHandledErr
;
11074 static const EventParamName names
[] =
11075 {kEventParamDirectObject
, kEventParamKeyModifiers
};
11076 static const EventParamType types
[] =
11077 {typeHICommand
, typeUInt32
};
11078 int num_params
= sizeof (names
) / sizeof (names
[0]);
11080 err
= GetEventParameter (event
, kEventParamDirectObject
, typeHICommand
,
11081 NULL
, sizeof (HICommand
), NULL
, &command
);
11083 return eventNotHandledErr
;
11085 switch (GetEventKind (event
))
11087 case kEventCommandProcess
:
11088 result
= CallNextEventHandler (next_handler
, event
);
11089 if (result
!= eventNotHandledErr
)
11092 err
= GetEventParameter (event
, kEventParamDirectObject
,
11093 typeHICommand
, NULL
,
11094 sizeof (HICommand
), NULL
, &command
);
11096 if (err
!= noErr
|| command
.commandID
== 0)
11099 /* A HI command event is mapped to an Apple event whose event
11100 class symbol is `hi-command' and event ID is its command
11102 err
= mac_store_event_ref_as_apple_event (0, command
.commandID
,
11117 static pascal OSStatus
11118 mac_handle_mouse_event (next_handler
, event
, data
)
11119 EventHandlerCallRef next_handler
;
11123 OSStatus err
, result
= eventNotHandledErr
;
11125 switch (GetEventKind (event
))
11127 case kEventMouseWheelMoved
:
11131 EventMouseWheelAxis axis
;
11135 result
= CallNextEventHandler (next_handler
, event
);
11136 if (result
!= eventNotHandledErr
|| read_socket_inev
== NULL
)
11139 f
= mac_focus_frame (&one_mac_display_info
);
11141 err
= GetEventParameter (event
, kEventParamWindowRef
, typeWindowRef
,
11142 NULL
, sizeof (WindowRef
), NULL
, &wp
);
11144 || wp
!= FRAME_MAC_WINDOW (f
))
11147 err
= GetEventParameter (event
, kEventParamMouseWheelAxis
,
11148 typeMouseWheelAxis
, NULL
,
11149 sizeof (EventMouseWheelAxis
), NULL
, &axis
);
11150 if (err
!= noErr
|| axis
!= kEventMouseWheelAxisY
)
11153 err
= GetEventParameter (event
, kEventParamMouseLocation
,
11154 typeQDPoint
, NULL
, sizeof (Point
),
11159 point
.h
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
11160 point
.v
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
11161 if (point
.h
< 0 || point
.v
< 0
11162 || EQ (window_from_coordinates (f
, point
.h
, point
.v
, 0, 0, 0, 1),
11163 f
->tool_bar_window
))
11166 err
= GetEventParameter (event
, kEventParamMouseWheelDelta
,
11167 typeSInt32
, NULL
, sizeof (SInt32
),
11172 read_socket_inev
->kind
= WHEEL_EVENT
;
11173 read_socket_inev
->code
= 0;
11174 read_socket_inev
->modifiers
=
11175 (mac_event_to_emacs_modifiers (event
)
11176 | ((delta
< 0) ? down_modifier
: up_modifier
));
11177 XSETINT (read_socket_inev
->x
, point
.h
);
11178 XSETINT (read_socket_inev
->y
, point
.v
);
11179 XSETFRAME (read_socket_inev
->frame_or_window
, f
);
11193 static pascal OSStatus
11194 mac_handle_text_input_event (next_handler
, event
, data
)
11195 EventHandlerCallRef next_handler
;
11199 OSStatus err
, result
;
11200 Lisp_Object id_key
= Qnil
;
11202 const EventParamName
*names
;
11203 const EventParamType
*types
;
11204 static UInt32 seqno_uaia
= 0;
11205 static const EventParamName names_uaia
[] =
11206 {kEventParamTextInputSendComponentInstance
,
11207 kEventParamTextInputSendRefCon
,
11208 kEventParamTextInputSendSLRec
,
11209 kEventParamTextInputSendFixLen
,
11210 kEventParamTextInputSendText
,
11211 kEventParamTextInputSendUpdateRng
,
11212 kEventParamTextInputSendHiliteRng
,
11213 kEventParamTextInputSendClauseRng
,
11214 kEventParamTextInputSendPinRng
,
11215 kEventParamTextInputSendTextServiceEncoding
,
11216 kEventParamTextInputSendTextServiceMacEncoding
,
11217 EVENT_PARAM_TEXT_INPUT_SEQUENCE_NUMBER
};
11218 static const EventParamType types_uaia
[] =
11219 {typeComponentInstance
,
11221 typeIntlWritingCode
,
11228 typeTextRangeArray
,
11229 typeTextRangeArray
,
11235 static const EventParamName names_ufke
[] =
11236 {kEventParamTextInputSendComponentInstance
,
11237 kEventParamTextInputSendRefCon
,
11238 kEventParamTextInputSendSLRec
,
11239 kEventParamTextInputSendText
};
11240 static const EventParamType types_ufke
[] =
11241 {typeComponentInstance
,
11243 typeIntlWritingCode
,
11246 result
= CallNextEventHandler (next_handler
, event
);
11247 if (result
!= eventNotHandledErr
)
11250 switch (GetEventKind (event
))
11252 case kEventTextInputUpdateActiveInputArea
:
11253 id_key
= Qupdate_active_input_area
;
11254 num_params
= sizeof (names_uaia
) / sizeof (names_uaia
[0]);
11255 names
= names_uaia
;
11256 types
= types_uaia
;
11257 SetEventParameter (event
, EVENT_PARAM_TEXT_INPUT_SEQUENCE_NUMBER
,
11258 typeUInt32
, sizeof (UInt32
), &seqno_uaia
);
11263 case kEventTextInputUnicodeForKeyEvent
:
11265 EventRef kbd_event
;
11266 UInt32 actual_size
, modifiers
;
11268 err
= GetEventParameter (event
, kEventParamTextInputSendKeyboardEvent
,
11269 typeEventRef
, NULL
, sizeof (EventRef
), NULL
,
11272 err
= GetEventParameter (kbd_event
, kEventParamKeyModifiers
,
11274 sizeof (UInt32
), NULL
, &modifiers
);
11275 if (err
== noErr
&& mac_mapped_modifiers (modifiers
))
11276 /* There're mapped modifier keys. Process it in
11280 err
= GetEventParameter (kbd_event
, kEventParamKeyUnicodes
,
11281 typeUnicodeText
, NULL
, 0, &actual_size
,
11283 if (err
== noErr
&& actual_size
== sizeof (UniChar
))
11287 err
= GetEventParameter (kbd_event
, kEventParamKeyUnicodes
,
11288 typeUnicodeText
, NULL
,
11289 sizeof (UniChar
), NULL
, &code
);
11290 if (err
== noErr
&& code
< 0x80)
11292 /* ASCII character. Process it in do_keystroke. */
11293 if (read_socket_inev
&& code
>= 0x20 && code
<= 0x7e)
11297 err
= GetEventParameter (kbd_event
, kEventParamKeyCode
,
11298 typeUInt32
, NULL
, sizeof (UInt32
),
11300 if (!(err
== noErr
&& key_code
<= 0x7f
11301 && keycode_to_xkeysym_table
[key_code
]))
11304 mac_focus_frame (&one_mac_display_info
);
11306 read_socket_inev
->kind
= ASCII_KEYSTROKE_EVENT
;
11307 read_socket_inev
->code
= code
;
11308 read_socket_inev
->modifiers
=
11309 mac_to_emacs_modifiers (modifiers
);
11310 read_socket_inev
->modifiers
|=
11311 (extra_keyboard_modifiers
11312 & (meta_modifier
| alt_modifier
11313 | hyper_modifier
| super_modifier
));
11314 XSETFRAME (read_socket_inev
->frame_or_window
, f
);
11322 /* Non-ASCII keystrokes without mapped modifiers are
11323 processed at the Lisp level. */
11324 id_key
= Qunicode_for_key_event
;
11325 num_params
= sizeof (names_ufke
) / sizeof (names_ufke
[0]);
11326 names
= names_ufke
;
11327 types
= types_ufke
;
11333 case kEventTextInputOffsetToPos
:
11339 if (!OVERLAYP (Vmac_ts_active_input_overlay
))
11342 /* Strictly speaking, this is not always correct because
11343 previous events may change some states about display. */
11344 if (!NILP (Foverlay_get (Vmac_ts_active_input_overlay
, Qbefore_string
)))
11346 /* Active input area is displayed around the current point. */
11347 f
= SELECTED_FRAME ();
11348 w
= XWINDOW (f
->selected_window
);
11350 else if (WINDOWP (echo_area_window
))
11352 /* Active input area is displayed in the echo area. */
11353 w
= XWINDOW (echo_area_window
);
11354 f
= WINDOW_XFRAME (w
);
11359 p
.h
= (WINDOW_TO_FRAME_PIXEL_X (w
, w
->cursor
.x
)
11360 + WINDOW_LEFT_FRINGE_WIDTH (w
)
11361 + f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
));
11362 p
.v
= (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->cursor
.y
)
11363 + FONT_BASE (FRAME_FONT (f
))
11364 + f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
));
11365 err
= SetEventParameter (event
, kEventParamTextInputReplyPoint
,
11366 typeQDPoint
, sizeof (typeQDPoint
), &p
);
11376 if (!NILP (id_key
))
11377 err
= mac_store_event_ref_as_apple_event (0, 0, Qtext_input
, id_key
,
11383 #endif /* TARGET_API_MAC_CARBON */
11387 install_window_handler (window
)
11390 OSStatus err
= noErr
;
11392 #if TARGET_API_MAC_CARBON
11395 static const EventTypeSpec specs
[] =
11397 /* -- window refresh events -- */
11398 {kEventClassWindow
, kEventWindowUpdate
},
11399 /* -- window state change events -- */
11400 {kEventClassWindow
, kEventWindowShowing
},
11401 {kEventClassWindow
, kEventWindowHiding
},
11402 {kEventClassWindow
, kEventWindowShown
},
11403 {kEventClassWindow
, kEventWindowHidden
},
11404 {kEventClassWindow
, kEventWindowCollapsed
},
11405 {kEventClassWindow
, kEventWindowExpanded
},
11406 {kEventClassWindow
, kEventWindowBoundsChanging
},
11407 {kEventClassWindow
, kEventWindowBoundsChanged
},
11408 /* -- window action events -- */
11409 {kEventClassWindow
, kEventWindowClose
},
11410 {kEventClassWindow
, kEventWindowGetIdealSize
},
11412 {kEventClassWindow
, kEventWindowToolbarSwitchMode
},
11415 /* -- window focus events -- */
11416 {kEventClassWindow
, kEventWindowFocusAcquired
},
11417 {kEventClassWindow
, kEventWindowFocusRelinquish
},
11420 static EventHandlerUPP handle_window_eventUPP
= NULL
;
11422 if (handle_window_eventUPP
== NULL
)
11423 handle_window_eventUPP
= NewEventHandlerUPP (mac_handle_window_event
);
11425 err
= InstallWindowEventHandler (window
, handle_window_eventUPP
,
11426 GetEventTypeCount (specs
),
11427 specs
, NULL
, NULL
);
11432 err
= install_drag_handler (window
);
11438 remove_window_handler (window
)
11441 remove_drag_handler (window
);
11444 #if TARGET_API_MAC_CARBON
11446 install_application_handler ()
11448 OSStatus err
= noErr
;
11452 static const EventTypeSpec specs
[] = {
11454 {kEventClassApplication
, kEventAppActivated
},
11455 {kEventClassApplication
, kEventAppDeactivated
},
11459 err
= InstallApplicationEventHandler (NewEventHandlerUPP
11460 (mac_handle_application_event
),
11461 GetEventTypeCount (specs
),
11462 specs
, NULL
, NULL
);
11467 static const EventTypeSpec specs
[] =
11468 {{kEventClassKeyboard
, kEventRawKeyDown
},
11469 {kEventClassKeyboard
, kEventRawKeyRepeat
},
11470 {kEventClassKeyboard
, kEventRawKeyUp
}};
11472 err
= InstallApplicationEventHandler (NewEventHandlerUPP
11473 (mac_handle_keyboard_event
),
11474 GetEventTypeCount (specs
),
11475 specs
, NULL
, NULL
);
11480 static const EventTypeSpec specs
[] =
11481 {{kEventClassCommand
, kEventCommandProcess
}};
11483 err
= InstallApplicationEventHandler (NewEventHandlerUPP
11484 (mac_handle_command_event
),
11485 GetEventTypeCount (specs
),
11486 specs
, NULL
, NULL
);
11491 static const EventTypeSpec specs
[] =
11492 {{kEventClassMouse
, kEventMouseWheelMoved
}};
11494 err
= InstallApplicationEventHandler (NewEventHandlerUPP
11495 (mac_handle_mouse_event
),
11496 GetEventTypeCount (specs
),
11497 specs
, NULL
, NULL
);
11503 static const EventTypeSpec spec
[] =
11504 {{kEventClassTextInput
, kEventTextInputUpdateActiveInputArea
},
11505 {kEventClassTextInput
, kEventTextInputUnicodeForKeyEvent
},
11506 {kEventClassTextInput
, kEventTextInputOffsetToPos
}};
11508 err
= InstallApplicationEventHandler (NewEventHandlerUPP
11509 (mac_handle_text_input_event
),
11510 GetEventTypeCount (spec
),
11516 err
= install_menu_target_item_handler ();
11520 err
= install_service_handler ();
11528 mac_handle_dm_notification (event
)
11531 mac_screen_config_changed
= 1;
11534 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
11536 mac_handle_cg_display_reconfig (display
, flags
, user_info
)
11537 CGDirectDisplayID display
;
11538 CGDisplayChangeSummaryFlags flags
;
11541 mac_screen_config_changed
= 1;
11546 init_dm_notification_handler ()
11550 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
11551 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
11552 if (CGDisplayRegisterReconfigurationCallback
!= NULL
)
11555 CGDisplayRegisterReconfigurationCallback (mac_handle_cg_display_reconfig
,
11558 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
11559 else /* CGDisplayRegisterReconfigurationCallback == NULL */
11561 #endif /* MAC_OS_X_VERSION_MAX_ALLOWED >= 1030 */
11562 #if MAC_OS_X_VERSION_MAX_ALLOWED < 1030 || MAC_OS_X_VERSION_MIN_REQUIRED == 1020
11564 static DMNotificationUPP handle_dm_notificationUPP
= NULL
;
11565 ProcessSerialNumber psn
;
11567 if (handle_dm_notificationUPP
== NULL
)
11568 handle_dm_notificationUPP
=
11569 NewDMNotificationUPP (mac_handle_dm_notification
);
11571 err
= GetCurrentProcess (&psn
);
11573 err
= DMRegisterNotifyProc (handle_dm_notificationUPP
, &psn
);
11581 mac_get_screen_info (dpyinfo
)
11582 struct mac_display_info
*dpyinfo
;
11585 /* HasDepth returns true if it is possible to have a 32 bit display,
11586 but this may not be what is actually used. Mac OSX can do better. */
11587 dpyinfo
->color_p
= CGDisplaySamplesPerPixel (kCGDirectMainDisplay
) > 1;
11588 dpyinfo
->n_planes
= CGDisplayBitsPerPixel (kCGDirectMainDisplay
);
11591 CGDisplayCount ndisps
;
11592 CGDirectDisplayID
*displays
;
11594 err
= CGGetActiveDisplayList (0, NULL
, &ndisps
);
11597 displays
= alloca (sizeof (CGDirectDisplayID
) * ndisps
);
11598 err
= CGGetActiveDisplayList (ndisps
, displays
, &ndisps
);
11602 CGRect bounds
= CGRectZero
;
11604 while (ndisps
-- > 0)
11605 bounds
= CGRectUnion (bounds
, CGDisplayBounds (displays
[ndisps
]));
11606 dpyinfo
->height
= CGRectGetHeight (bounds
);
11607 dpyinfo
->width
= CGRectGetWidth (bounds
);
11611 dpyinfo
->height
= CGDisplayPixelsHigh (kCGDirectMainDisplay
);
11612 dpyinfo
->width
= CGDisplayPixelsWide (kCGDirectMainDisplay
);
11615 #else /* !MAC_OSX */
11617 GDHandle gdh
= GetMainDevice ();
11618 Rect rect
= (**gdh
).gdRect
;
11620 dpyinfo
->color_p
= TestDeviceAttribute (gdh
, gdDevType
);
11621 for (dpyinfo
->n_planes
= 32; dpyinfo
->n_planes
> 0; dpyinfo
->n_planes
>>= 1)
11622 if (HasDepth (gdh
, dpyinfo
->n_planes
, gdDevType
, dpyinfo
->color_p
))
11625 for (gdh
= DMGetFirstScreenDevice (dmOnlyActiveDisplays
); gdh
;
11626 gdh
= DMGetNextScreenDevice (gdh
, dmOnlyActiveDisplays
))
11627 UnionRect (&rect
, &(**gdh
).gdRect
, &rect
);
11629 dpyinfo
->height
= rect
.bottom
- rect
.top
;
11630 dpyinfo
->width
= rect
.right
- rect
.left
;
11632 #endif /* !MAC_OSX */
11638 profiler_exit_proc ()
11640 ProfilerDump ("\pEmacs.prof");
11645 /* These few functions implement Emacs as a normal Mac application
11646 (almost): set up the heap and the Toolbox, handle necessary system
11647 events plus a few simple menu events. They also set up Emacs's
11648 access to functions defined in the rest of this file. Emacs uses
11649 function hooks to perform all its terminal I/O. A complete list of
11650 these functions appear in termhooks.h. For what they do, read the
11651 comments there and see also w32term.c and xterm.c. What's
11652 noticeably missing here is the event loop, which is normally
11653 present in most Mac application. After performing the necessary
11654 Mac initializations, main passes off control to emacs_main
11655 (corresponding to main in emacs.c). Emacs_main calls XTread_socket
11656 (defined further below) to read input. This is where
11657 WaitNextEvent/ReceiveNextEvent is called to process Mac events. */
11664 #if __profile__ /* is the profiler on? */
11665 if (ProfilerInit(collectDetailed
, bestTimeBase
, 5000, 200))
11670 /* set creator and type for files created by MSL */
11671 _fcreator
= MAC_EMACS_CREATOR_CODE
;
11675 do_init_managers ();
11679 #ifndef USE_LSB_TAG
11680 do_check_ram_size ();
11683 init_emacs_passwd_dir ();
11687 init_coercion_handler ();
11689 initialize_applescript ();
11691 init_apple_event_handler ();
11693 init_dm_notification_handler ();
11699 /* set up argv array from STR# resource */
11700 get_string_list (&argv
, ARGV_STRING_LIST_ID
);
11704 /* free up AppleScript resources on exit */
11705 atexit (terminate_applescript
);
11707 #if __profile__ /* is the profiler on? */
11708 atexit (profiler_exit_proc
);
11711 /* 3rd param "envp" never used in emacs_main */
11712 (void) emacs_main (argc
, argv
, 0);
11715 /* Never reached - real exit in Fkill_emacs */
11720 #if !TARGET_API_MAC_CARBON
11721 static RgnHandle mouse_region
= NULL
;
11724 mac_wait_next_event (er
, sleep_time
, dequeue
)
11729 static EventRecord er_buf
= {nullEvent
};
11730 UInt32 target_tick
, current_tick
;
11731 EventMask event_mask
;
11733 if (mouse_region
== NULL
)
11734 mouse_region
= NewRgn ();
11736 event_mask
= everyEvent
;
11737 if (!mac_ready_for_apple_events
)
11738 event_mask
-= highLevelEventMask
;
11740 current_tick
= TickCount ();
11741 target_tick
= current_tick
+ sleep_time
;
11743 if (er_buf
.what
== nullEvent
)
11744 while (!WaitNextEvent (event_mask
, &er_buf
,
11745 target_tick
- current_tick
, mouse_region
))
11747 current_tick
= TickCount ();
11748 if (target_tick
<= current_tick
)
11754 er_buf
.what
= nullEvent
;
11757 #endif /* not TARGET_API_MAC_CARBON */
11759 #if TARGET_API_MAC_CARBON
11761 mac_post_mouse_moved_event ()
11763 EventRef event
= NULL
;
11766 err
= CreateEvent (NULL
, kEventClassMouse
, kEventMouseMoved
, 0,
11767 kEventAttributeNone
, &event
);
11772 GetGlobalMouse (&mouse_pos
);
11773 err
= SetEventParameter (event
, kEventParamMouseLocation
, typeQDPoint
,
11774 sizeof (Point
), &mouse_pos
);
11778 UInt32 modifiers
= GetCurrentKeyModifiers ();
11780 err
= SetEventParameter (event
, kEventParamKeyModifiers
, typeUInt32
,
11781 sizeof (UInt32
), &modifiers
);
11784 err
= PostEventToQueue (GetCurrentEventQueue (), event
,
11785 kEventPriorityStandard
);
11787 ReleaseEvent (event
);
11793 /* Emacs calls this whenever it wants to read an input event from the
11796 XTread_socket (sd
, expected
, hold_quit
)
11798 struct input_event
*hold_quit
;
11800 struct input_event inev
;
11802 #if TARGET_API_MAC_CARBON
11804 EventTargetRef toolbox_dispatcher
;
11807 struct mac_display_info
*dpyinfo
= &one_mac_display_info
;
11809 if (interrupt_input_blocked
)
11811 interrupt_input_pending
= 1;
11815 interrupt_input_pending
= 0;
11818 /* So people can tell when we have read the available input. */
11819 input_signal_count
++;
11823 #if TARGET_API_MAC_CARBON
11824 toolbox_dispatcher
= GetEventDispatcherTarget ();
11828 mac_prepare_for_quickdraw (NULL
),
11830 !ReceiveNextEvent (0, NULL
, kEventDurationNoWait
,
11831 kEventRemoveFromQueue
, &eventRef
))
11832 #else /* !TARGET_API_MAC_CARBON */
11833 while (mac_wait_next_event (&er
, 0, true))
11834 #endif /* !TARGET_API_MAC_CARBON */
11838 unsigned long timestamp
;
11841 inev
.kind
= NO_EVENT
;
11844 #if TARGET_API_MAC_CARBON
11845 timestamp
= GetEventTime (eventRef
) / kEventDurationMillisecond
;
11847 if (!mac_convert_event_ref (eventRef
, &er
))
11849 #else /* !TARGET_API_MAC_CARBON */
11850 timestamp
= er
.when
* (1000 / 60); /* ticks to milliseconds */
11851 #endif /* !TARGET_API_MAC_CARBON */
11858 WindowRef window_ptr
;
11859 ControlPartCode part_code
;
11860 int tool_bar_p
= 0;
11862 #if TARGET_API_MAC_CARBON
11865 /* This is needed to send mouse events like aqua window
11866 buttons to the correct handler. */
11867 read_socket_inev
= &inev
;
11868 err
= SendEventToEventTarget (eventRef
, toolbox_dispatcher
);
11869 read_socket_inev
= NULL
;
11870 if (err
!= eventNotHandledErr
)
11873 last_mouse_glyph_frame
= 0;
11875 if (dpyinfo
->grabbed
&& last_mouse_frame
11876 && FRAME_LIVE_P (last_mouse_frame
))
11878 window_ptr
= FRAME_MAC_WINDOW (last_mouse_frame
);
11879 part_code
= inContent
;
11883 part_code
= FindWindow (er
.where
, &window_ptr
);
11884 if (tip_window
&& window_ptr
== tip_window
)
11886 HideWindow (tip_window
);
11887 part_code
= FindWindow (er
.where
, &window_ptr
);
11891 if (er
.what
!= mouseDown
&&
11892 (part_code
!= inContent
|| dpyinfo
->grabbed
== 0))
11898 f
= mac_focus_frame (dpyinfo
);
11899 saved_menu_event_location
= er
.where
;
11900 inev
.kind
= MENU_BAR_ACTIVATE_EVENT
;
11901 XSETFRAME (inev
.frame_or_window
, f
);
11906 #if TARGET_API_MAC_CARBON
11907 FrontNonFloatingWindow ()
11912 || (mac_window_to_frame (window_ptr
)
11913 != dpyinfo
->x_focus_frame
))
11914 SelectWindow (window_ptr
);
11917 ControlPartCode control_part_code
;
11921 ControlKind control_kind
;
11924 f
= mac_window_to_frame (window_ptr
);
11925 /* convert to local coordinates of new window */
11926 mouse_loc
.h
= (er
.where
.h
11928 + FRAME_OUTER_TO_INNER_DIFF_X (f
)));
11929 mouse_loc
.v
= (er
.where
.v
11931 + FRAME_OUTER_TO_INNER_DIFF_Y (f
)));
11932 #if TARGET_API_MAC_CARBON
11933 ch
= FindControlUnderMouse (mouse_loc
, window_ptr
,
11934 &control_part_code
);
11937 GetControlKind (ch
, &control_kind
);
11940 control_part_code
= FindControl (mouse_loc
, window_ptr
,
11944 #if TARGET_API_MAC_CARBON
11945 inev
.code
= mac_get_mouse_btn (eventRef
);
11946 inev
.modifiers
= mac_event_to_emacs_modifiers (eventRef
);
11948 inev
.code
= mac_get_emulated_btn (er
.modifiers
);
11949 inev
.modifiers
= mac_to_emacs_modifiers (er
.modifiers
);
11951 XSETINT (inev
.x
, mouse_loc
.h
);
11952 XSETINT (inev
.y
, mouse_loc
.v
);
11954 if ((dpyinfo
->grabbed
&& tracked_scroll_bar
)
11956 #ifndef USE_TOOLKIT_SCROLL_BARS
11957 /* control_part_code becomes kControlNoPart if
11958 a progress indicator is clicked. */
11959 && control_part_code
!= kControlNoPart
11960 #else /* USE_TOOLKIT_SCROLL_BARS */
11962 && control_kind
.kind
== kControlKindScrollBar
11963 #endif /* MAC_OSX */
11964 #endif /* USE_TOOLKIT_SCROLL_BARS */
11967 struct scroll_bar
*bar
;
11969 if (dpyinfo
->grabbed
&& tracked_scroll_bar
)
11971 bar
= tracked_scroll_bar
;
11972 #ifndef USE_TOOLKIT_SCROLL_BARS
11973 control_part_code
= kControlIndicatorPart
;
11977 bar
= (struct scroll_bar
*) GetControlReference (ch
);
11978 #ifdef USE_TOOLKIT_SCROLL_BARS
11979 /* Make the "Ctrl-Mouse-2 splits window" work
11980 for toolkit scroll bars. */
11981 if (inev
.modifiers
& ctrl_modifier
)
11982 x_scroll_bar_handle_click (bar
, control_part_code
,
11984 else if (er
.what
== mouseDown
)
11985 x_scroll_bar_handle_press (bar
, control_part_code
,
11988 x_scroll_bar_handle_release (bar
, &inev
);
11989 #else /* not USE_TOOLKIT_SCROLL_BARS */
11990 x_scroll_bar_handle_click (bar
, control_part_code
,
11992 if (er
.what
== mouseDown
11993 && control_part_code
== kControlIndicatorPart
)
11994 tracked_scroll_bar
= bar
;
11996 tracked_scroll_bar
= NULL
;
11997 #endif /* not USE_TOOLKIT_SCROLL_BARS */
12001 Lisp_Object window
;
12002 int x
= mouse_loc
.h
;
12003 int y
= mouse_loc
.v
;
12005 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 1);
12006 if (EQ (window
, f
->tool_bar_window
))
12008 if (er
.what
== mouseDown
)
12009 handle_tool_bar_click (f
, x
, y
, 1, 0);
12011 handle_tool_bar_click (f
, x
, y
, 0,
12017 XSETFRAME (inev
.frame_or_window
, f
);
12018 inev
.kind
= MOUSE_CLICK_EVENT
;
12022 if (er
.what
== mouseDown
)
12024 dpyinfo
->grabbed
|= (1 << inev
.code
);
12025 last_mouse_frame
= f
;
12028 last_tool_bar_item
= -1;
12032 if ((dpyinfo
->grabbed
& (1 << inev
.code
)) == 0)
12033 /* If a button is released though it was not
12034 previously pressed, that would be because
12035 of multi-button emulation. */
12036 dpyinfo
->grabbed
= 0;
12038 dpyinfo
->grabbed
&= ~(1 << inev
.code
);
12041 /* Ignore any mouse motion that happened before
12042 this event; any subsequent mouse-movement Emacs
12043 events should reflect only motion after the
12046 f
->mouse_moved
= 0;
12048 #ifdef USE_TOOLKIT_SCROLL_BARS
12049 if (inev
.kind
== MOUSE_CLICK_EVENT
12050 || (inev
.kind
== SCROLL_BAR_CLICK_EVENT
12051 && (inev
.modifiers
& ctrl_modifier
)))
12056 inev
.modifiers
|= down_modifier
;
12059 inev
.modifiers
|= up_modifier
;
12066 #if TARGET_API_MAC_CARBON
12068 if (IsWindowPathSelectClick (window_ptr
, &er
))
12070 WindowPathSelect (window_ptr
, NULL
, NULL
);
12073 if (part_code
== inProxyIcon
12074 && (TrackWindowProxyDrag (window_ptr
, er
.where
)
12075 != errUserWantsToDragWindow
))
12077 DragWindow (window_ptr
, er
.where
, NULL
);
12078 #else /* not TARGET_API_MAC_CARBON */
12079 DragWindow (window_ptr
, er
.where
, &qd
.screenBits
.bounds
);
12080 /* Update the frame parameters. */
12082 struct frame
*f
= mac_window_to_frame (window_ptr
);
12084 if (f
&& !f
->async_iconified
)
12085 mac_handle_origin_change (f
);
12087 #endif /* not TARGET_API_MAC_CARBON */
12091 if (TrackGoAway (window_ptr
, er
.where
))
12093 inev
.kind
= DELETE_WINDOW_EVENT
;
12094 XSETFRAME (inev
.frame_or_window
,
12095 mac_window_to_frame (window_ptr
));
12099 /* window resize handling added --ben */
12101 do_grow_window (window_ptr
, &er
);
12104 /* window zoom handling added --ben */
12107 if (TrackBox (window_ptr
, er
.where
, part_code
))
12108 do_zoom_window (window_ptr
, part_code
);
12111 #if USE_MAC_TOOLBAR
12117 err
= HIViewGetViewForMouseEvent (HIViewGetRoot (window_ptr
),
12119 /* This doesn't work on Mac OS X 10.2. */
12121 HIViewClick (ch
, eventRef
);
12124 #endif /* USE_MAC_TOOLBAR */
12132 #if !TARGET_API_MAC_CARBON
12134 do_window_update ((WindowRef
) er
.message
);
12139 switch ((er
.message
>> 24) & 0x000000FF)
12141 case mouseMovedMessage
:
12142 #if !TARGET_API_MAC_CARBON
12143 SetRectRgn (mouse_region
, er
.where
.h
, er
.where
.v
,
12144 er
.where
.h
+ 1, er
.where
.v
+ 1);
12146 previous_help_echo_string
= help_echo_string
;
12147 help_echo_string
= Qnil
;
12149 if (dpyinfo
->grabbed
&& last_mouse_frame
12150 && FRAME_LIVE_P (last_mouse_frame
))
12151 f
= last_mouse_frame
;
12153 f
= dpyinfo
->x_focus_frame
;
12155 if (dpyinfo
->mouse_face_hidden
)
12157 dpyinfo
->mouse_face_hidden
= 0;
12158 clear_mouse_face (dpyinfo
);
12163 WindowRef wp
= FRAME_MAC_WINDOW (f
);
12166 mouse_pos
.h
= (er
.where
.h
12168 + FRAME_OUTER_TO_INNER_DIFF_X (f
)));
12169 mouse_pos
.v
= (er
.where
.v
12171 + FRAME_OUTER_TO_INNER_DIFF_Y (f
)));
12172 if (dpyinfo
->grabbed
&& tracked_scroll_bar
)
12173 #ifdef USE_TOOLKIT_SCROLL_BARS
12174 x_scroll_bar_handle_drag (wp
, tracked_scroll_bar
,
12176 #else /* not USE_TOOLKIT_SCROLL_BARS */
12177 x_scroll_bar_note_movement (tracked_scroll_bar
,
12179 - XINT (tracked_scroll_bar
->top
),
12180 er
.when
* (1000 / 60));
12181 #endif /* not USE_TOOLKIT_SCROLL_BARS */
12184 /* Generate SELECT_WINDOW_EVENTs when needed. */
12185 if (!NILP (Vmouse_autoselect_window
))
12187 Lisp_Object window
;
12189 window
= window_from_coordinates (f
,
12194 /* Window will be selected only when it is
12195 not selected now and last mouse movement
12196 event was not in it. Minibuffer window
12197 will be selected only when it is active. */
12198 if (WINDOWP (window
)
12199 && !EQ (window
, last_window
)
12200 && !EQ (window
, selected_window
)
12201 /* For click-to-focus window managers
12202 create event iff we don't leave the
12204 && (focus_follows_mouse
12205 || (EQ (XWINDOW (window
)->frame
,
12206 XWINDOW (selected_window
)->frame
))))
12208 inev
.kind
= SELECT_WINDOW_EVENT
;
12209 inev
.frame_or_window
= window
;
12212 last_window
=window
;
12214 if (!note_mouse_movement (f
, &mouse_pos
))
12215 help_echo_string
= previous_help_echo_string
;
12216 #if USE_MAC_TOOLBAR
12218 mac_tool_bar_note_mouse_movement (f
, eventRef
);
12223 /* If the contents of the global variable
12224 help_echo_string has changed, generate a
12226 if (!NILP (help_echo_string
) || !NILP (previous_help_echo_string
))
12237 WindowRef window_ptr
= (WindowRef
) er
.message
;
12239 ControlRef root_control
;
12241 if (window_ptr
== tip_window
)
12243 HideWindow (tip_window
);
12247 if (!is_emacs_window (window_ptr
))
12250 f
= mac_window_to_frame (window_ptr
);
12252 if ((er
.modifiers
& activeFlag
) != 0)
12254 /* A window has been activated */
12257 err
= GetRootControl (FRAME_MAC_WINDOW (f
), &root_control
);
12259 ActivateControl (root_control
);
12261 x_detect_focus_change (dpyinfo
, &er
, &inev
);
12263 mouse_loc
.h
= (er
.where
.h
12265 + FRAME_OUTER_TO_INNER_DIFF_X (f
)));
12266 mouse_loc
.v
= (er
.where
.v
12268 + FRAME_OUTER_TO_INNER_DIFF_Y (f
)));
12269 /* Window-activated event counts as mouse movement,
12270 so update things that depend on mouse position. */
12271 note_mouse_movement (f
, &mouse_loc
);
12275 /* A window has been deactivated */
12276 err
= GetRootControl (FRAME_MAC_WINDOW (f
), &root_control
);
12278 DeactivateControl (root_control
);
12280 #ifdef USE_TOOLKIT_SCROLL_BARS
12281 if (dpyinfo
->grabbed
&& tracked_scroll_bar
)
12283 struct input_event event
;
12285 EVENT_INIT (event
);
12286 event
.kind
= NO_EVENT
;
12287 x_scroll_bar_handle_release (tracked_scroll_bar
, &event
);
12288 if (event
.kind
!= NO_EVENT
)
12290 event
.timestamp
= timestamp
;
12291 kbd_buffer_store_event_hold (&event
, hold_quit
);
12296 dpyinfo
->grabbed
= 0;
12298 x_detect_focus_change (dpyinfo
, &er
, &inev
);
12300 if (f
== dpyinfo
->mouse_face_mouse_frame
)
12302 /* If we move outside the frame, then we're
12303 certainly no longer on any text in the
12305 clear_mouse_face (dpyinfo
);
12306 dpyinfo
->mouse_face_mouse_frame
= 0;
12309 /* Generate a nil HELP_EVENT to cancel a help-echo.
12310 Do it only if there's something to cancel.
12311 Otherwise, the startup message is cleared when the
12312 mouse leaves the frame. */
12313 if (any_help_event_p
)
12324 f
= mac_focus_frame (dpyinfo
);
12325 XSETFRAME (inev
.frame_or_window
, f
);
12327 /* If mouse-highlight is an integer, input clears out mouse
12329 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
12330 && !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
))
12332 clear_mouse_face (dpyinfo
);
12333 dpyinfo
->mouse_face_hidden
= 1;
12337 UInt32 modifiers
= er
.modifiers
, mapped_modifiers
;
12340 GetEventParameter (eventRef
, kEventParamKeyModifiers
,
12342 sizeof (UInt32
), NULL
, &modifiers
);
12344 mapped_modifiers
= mac_mapped_modifiers (modifiers
);
12346 #if TARGET_API_MAC_CARBON
12347 if (!(mapped_modifiers
12348 & ~(mac_pass_command_to_system
? cmdKey
: 0)
12349 & ~(mac_pass_control_to_system
? controlKey
: 0)))
12353 if (er
.what
!= keyUp
)
12354 do_keystroke (er
.what
, er
.message
& charCodeMask
,
12355 (er
.message
& keyCodeMask
) >> 8,
12356 modifiers
, timestamp
, &inev
);
12360 case kHighLevelEvent
:
12361 AEProcessAppleEvent (&er
);
12366 #if TARGET_API_MAC_CARBON
12370 read_socket_inev
= &inev
;
12371 err
= SendEventToEventTarget (eventRef
, toolbox_dispatcher
);
12372 read_socket_inev
= NULL
;
12377 #if TARGET_API_MAC_CARBON
12378 ReleaseEvent (eventRef
);
12381 if (inev
.kind
!= NO_EVENT
)
12383 inev
.timestamp
= timestamp
;
12384 kbd_buffer_store_event_hold (&inev
, hold_quit
);
12389 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
12394 XSETFRAME (frame
, f
);
12400 any_help_event_p
= 1;
12401 gen_help_event (help_echo_string
, frame
, help_echo_window
,
12402 help_echo_object
, help_echo_pos
);
12406 help_echo_string
= Qnil
;
12407 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
12413 /* If the focus was just given to an autoraising frame,
12415 /* ??? This ought to be able to handle more than one such frame. */
12416 if (pending_autoraise_frame
)
12418 x_raise_frame (pending_autoraise_frame
);
12419 pending_autoraise_frame
= 0;
12422 if (mac_screen_config_changed
)
12424 mac_get_screen_info (dpyinfo
);
12425 mac_screen_config_changed
= 0;
12428 #if !TARGET_API_MAC_CARBON
12429 /* Check which frames are still visible. We do this here because
12430 there doesn't seem to be any direct notification from the Window
12431 Manager that the visibility of a window has changed (at least,
12432 not in all cases). */
12434 Lisp_Object tail
, frame
;
12436 FOR_EACH_FRAME (tail
, frame
)
12438 struct frame
*f
= XFRAME (frame
);
12440 /* The tooltip has been drawn already. Avoid the
12441 SET_FRAME_GARBAGED in mac_handle_visibility_change. */
12442 if (EQ (frame
, tip_frame
))
12445 if (FRAME_MAC_P (f
))
12446 mac_handle_visibility_change (f
);
12457 /* Need to override CodeWarrior's input function so no conversion is
12458 done on newlines Otherwise compiled functions in .elc files will be
12459 read incorrectly. Defined in ...:MSL C:MSL
12460 Common:Source:buffer_io.c. */
12463 __convert_to_newlines (unsigned char * p
, size_t * n
)
12465 #pragma unused(p,n)
12469 __convert_from_newlines (unsigned char * p
, size_t * n
)
12471 #pragma unused(p,n)
12477 make_mac_terminal_frame (struct frame
*f
)
12482 XSETFRAME (frame
, f
);
12484 f
->output_method
= output_mac
;
12485 f
->output_data
.mac
= (struct mac_output
*)
12486 xmalloc (sizeof (struct mac_output
));
12487 bzero (f
->output_data
.mac
, sizeof (struct mac_output
));
12489 XSETFRAME (FRAME_KBOARD (f
)->Vdefault_minibuffer_frame
, f
);
12491 FRAME_COLS (f
) = 96;
12492 FRAME_LINES (f
) = 4;
12494 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 1;
12495 FRAME_VERTICAL_SCROLL_BAR_TYPE (f
) = vertical_scroll_bar_right
;
12497 FRAME_DESIRED_CURSOR (f
) = FILLED_BOX_CURSOR
;
12499 f
->output_data
.mac
->cursor_pixel
= 0;
12500 f
->output_data
.mac
->border_pixel
= 0x00ff00;
12501 f
->output_data
.mac
->mouse_pixel
= 0xff00ff;
12502 f
->output_data
.mac
->cursor_foreground_pixel
= 0x0000ff;
12504 f
->output_data
.mac
->text_cursor
= kThemeIBeamCursor
;
12505 f
->output_data
.mac
->nontext_cursor
= kThemeArrowCursor
;
12506 f
->output_data
.mac
->modeline_cursor
= kThemeArrowCursor
;
12507 f
->output_data
.mac
->hand_cursor
= kThemePointingHandCursor
;
12508 f
->output_data
.mac
->hourglass_cursor
= kThemeWatchCursor
;
12509 f
->output_data
.mac
->horizontal_drag_cursor
= kThemeResizeLeftRightCursor
;
12511 FRAME_FONTSET (f
) = -1;
12512 f
->output_data
.mac
->explicit_parent
= 0;
12515 f
->border_width
= 0;
12517 f
->internal_border_width
= 0;
12522 f
->new_text_cols
= 0;
12523 f
->new_text_lines
= 0;
12525 SetRect (&r
, f
->left_pos
, f
->top_pos
,
12526 f
->left_pos
+ FRAME_PIXEL_WIDTH (f
),
12527 f
->top_pos
+ FRAME_PIXEL_HEIGHT (f
));
12531 if (!(FRAME_MAC_WINDOW (f
) =
12532 NewCWindow (NULL
, &r
, "\p", true, dBoxProc
,
12533 (WindowRef
) -1, 1, (long) f
->output_data
.mac
)))
12535 /* so that update events can find this mac_output struct */
12536 f
->output_data
.mac
->mFP
= f
; /* point back to emacs frame */
12542 /* Need to be initialized for unshow_buffer in window.c. */
12543 selected_window
= f
->selected_window
;
12545 Fmodify_frame_parameters (frame
,
12546 Fcons (Fcons (Qfont
,
12547 build_string ("-*-monaco-medium-r-*--*-90-*-*-*-*-mac-roman")), Qnil
));
12548 Fmodify_frame_parameters (frame
,
12549 Fcons (Fcons (Qforeground_color
,
12550 build_string ("black")), Qnil
));
12551 Fmodify_frame_parameters (frame
,
12552 Fcons (Fcons (Qbackground_color
,
12553 build_string ("white")), Qnil
));
12558 /***********************************************************************
12560 ***********************************************************************/
12562 static int mac_initialized
= 0;
12565 mac_make_rdb (xrm_option
)
12566 const char *xrm_option
;
12568 XrmDatabase database
;
12570 database
= xrm_get_preference_database (NULL
);
12572 xrm_merge_string_database (database
, xrm_option
);
12577 struct mac_display_info
*
12578 mac_term_init (display_name
, xrm_option
, resource_name
)
12579 Lisp_Object display_name
;
12581 char *resource_name
;
12583 struct mac_display_info
*dpyinfo
;
12584 struct terminal
*terminal
;
12588 if (!mac_initialized
)
12591 mac_initialized
= 1;
12594 if (x_display_list
)
12595 error ("Sorry, this version can only handle one display");
12597 dpyinfo
= &one_mac_display_info
;
12598 bzero (dpyinfo
, sizeof (*dpyinfo
));
12600 terminal
= mac_create_terminal (dpyinfo
);
12602 /* Set the name of the terminal. */
12603 terminal
->name
= (char *) xmalloc (SBYTES (display_name
) + 1);
12604 strncpy (terminal
->name
, SDATA (display_name
), SBYTES (display_name
));
12605 terminal
->name
[SBYTES (display_name
)] = 0;
12608 dpyinfo
->mac_id_name
12609 = (char *) xmalloc (SCHARS (Vinvocation_name
)
12610 + SCHARS (Vsystem_name
)
12612 sprintf (dpyinfo
->mac_id_name
, "%s@%s",
12613 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
12615 dpyinfo
->mac_id_name
= (char *) xmalloc (strlen ("Mac Display") + 1);
12616 strcpy (dpyinfo
->mac_id_name
, "Mac Display");
12619 dpyinfo
->reference_count
= 0;
12620 dpyinfo
->resx
= 72.0;
12621 dpyinfo
->resy
= 72.0;
12623 mac_get_screen_info (dpyinfo
);
12625 dpyinfo
->grabbed
= 0;
12626 dpyinfo
->root_window
= NULL
;
12627 dpyinfo
->image_cache
= make_image_cache ();
12629 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
12630 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
12631 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
12632 dpyinfo
->mouse_face_window
= Qnil
;
12633 dpyinfo
->mouse_face_overlay
= Qnil
;
12634 dpyinfo
->mouse_face_hidden
= 0;
12636 dpyinfo
->xrdb
= mac_make_rdb (xrm_option
);
12638 /* Put this display on the chain. */
12639 dpyinfo
->next
= x_display_list
;
12640 x_display_list
= dpyinfo
;
12642 /* Put it on x_display_name_list. */
12643 x_display_name_list
= Fcons (Fcons (display_name
,
12644 Fcons (Qnil
, dpyinfo
->xrdb
)),
12645 x_display_name_list
);
12646 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
12648 /* FIXME: Untested.
12649 Add the default keyboard. */
12650 add_keyboard_wait_descriptor (0);
12653 mac_init_fringe (terminal
->rif
);
12661 /* Get rid of display DPYINFO, assuming all frames are already gone. */
12664 x_delete_display (dpyinfo
)
12665 struct mac_display_info
*dpyinfo
;
12669 /* Discard this display from x_display_name_list and x_display_list.
12670 We can't use Fdelq because that can quit. */
12671 if (! NILP (x_display_name_list
)
12672 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
12673 x_display_name_list
= XCDR (x_display_name_list
);
12678 tail
= x_display_name_list
;
12679 while (CONSP (tail
) && CONSP (XCDR (tail
)))
12681 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
12683 XSETCDR (tail
, XCDR (XCDR (tail
)));
12686 tail
= XCDR (tail
);
12690 if (x_display_list
== dpyinfo
)
12691 x_display_list
= dpyinfo
->next
;
12694 struct x_display_info
*tail
;
12696 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
12697 if (tail
->next
== dpyinfo
)
12698 tail
->next
= tail
->next
->next
;
12701 /* Free the font names in the font table. */
12702 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
12703 if (dpyinfo
->font_table
[i
].name
)
12705 if (dpyinfo
->font_table
[i
].name
!= dpyinfo
->font_table
[i
].full_name
)
12706 xfree (dpyinfo
->font_table
[i
].full_name
);
12707 xfree (dpyinfo
->font_table
[i
].name
);
12710 if (dpyinfo
->font_table
)
12712 if (dpyinfo
->font_table
->font_encoder
)
12713 xfree (dpyinfo
->font_table
->font_encoder
);
12714 xfree (dpyinfo
->font_table
);
12716 if (dpyinfo
->mac_id_name
)
12717 xfree (dpyinfo
->mac_id_name
);
12719 if (x_display_list
== 0)
12721 mac_clear_font_name_table ();
12722 bzero (dpyinfo
, sizeof (*dpyinfo
));
12733 MenuItemIndex menu_index
;
12735 err
= GetIndMenuItemWithCommandID (NULL
, kHICommandQuit
, 1,
12736 &menu
, &menu_index
);
12738 SetMenuItemCommandKey (menu
, menu_index
, false, 0);
12739 EnableMenuCommand (NULL
, kHICommandPreferences
);
12740 err
= GetIndMenuItemWithCommandID (NULL
, kHICommandPreferences
, 1,
12741 &menu
, &menu_index
);
12744 SetMenuItemCommandKey (menu
, menu_index
, false, 0);
12745 InsertMenuItemTextWithCFString (menu
, NULL
,
12746 0, kMenuItemAttrSeparator
, 0);
12747 InsertMenuItemTextWithCFString (menu
, CFSTR ("About Emacs"),
12748 0, 0, kHICommandAbout
);
12750 #else /* !MAC_OSX */
12751 #if TARGET_API_MAC_CARBON
12752 SetMenuItemCommandID (GetMenuRef (M_APPLE
), I_ABOUT
, kHICommandAbout
);
12762 static InterfaceTypeList types
= {kUnicodeDocument
};
12764 static InterfaceTypeList types
= {kTextService
};
12767 NewTSMDocument (sizeof (types
) / sizeof (types
[0]), types
,
12768 &tsm_document_id
, 0);
12772 /* Set up use of X before we make the first connection. */
12774 extern frame_parm_handler mac_frame_parm_handlers
[];
12776 static struct redisplay_interface x_redisplay_interface
=
12778 mac_frame_parm_handlers
,
12782 x_clear_end_of_line
,
12784 x_after_update_window_line
,
12785 x_update_window_begin
,
12786 x_update_window_end
,
12790 mac_flush_display_optional
,
12792 0, /* flush_display_optional */
12794 x_clear_window_mouse_face
,
12795 x_get_glyph_overhangs
,
12796 x_fix_overlapping_area
,
12797 x_draw_fringe_bitmap
,
12799 mac_define_fringe_bitmap
,
12800 mac_destroy_fringe_bitmap
,
12802 0, /* define_fringe_bitmap */
12803 0, /* destroy_fringe_bitmap */
12805 mac_per_char_metric
,
12807 mac_compute_glyph_string_overhangs
,
12808 x_draw_glyph_string
,
12809 mac_define_frame_cursor
,
12810 mac_clear_frame_area
,
12811 mac_draw_window_cursor
,
12812 mac_draw_vertical_window_border
,
12813 mac_shift_glyphs_for_insert
12816 static struct terminal
*
12817 mac_create_terminal (struct mac_display_info
*dpyinfo
)
12819 struct terminal
*terminal
;
12821 terminal
= create_terminal ();
12823 terminal
->type
= output_mac
;
12824 terminal
->display_info
.mac
= dpyinfo
;
12825 dpyinfo
->terminal
= terminal
;
12827 terminal
->clear_frame_hook
= x_clear_frame
;
12828 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
12829 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
12830 terminal
->ring_bell_hook
= XTring_bell
;
12831 terminal
->reset_terminal_modes_hook
= XTreset_terminal_modes
;
12832 terminal
->set_terminal_modes_hook
= XTset_terminal_modes
;
12833 terminal
->update_begin_hook
= x_update_begin
;
12834 terminal
->update_end_hook
= x_update_end
;
12835 terminal
->set_terminal_window_hook
= XTset_terminal_window
;
12836 terminal
->read_socket_hook
= XTread_socket
;
12837 terminal
->frame_up_to_date_hook
= XTframe_up_to_date
;
12838 terminal
->mouse_position_hook
= XTmouse_position
;
12839 terminal
->frame_rehighlight_hook
= XTframe_rehighlight
;
12840 terminal
->frame_raise_lower_hook
= XTframe_raise_lower
;
12841 /* terminal->fullscreen_hook = XTfullscreen_hook; */
12842 terminal
->set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
12843 terminal
->condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
12844 terminal
->redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
12845 terminal
->judge_scroll_bars_hook
= XTjudge_scroll_bars
;
12846 terminal
->delete_frame_hook
= x_destroy_window
;
12847 /* terminal->delete_terminal_hook = x_delete_terminal; */
12849 terminal
->rif
= &x_redisplay_interface
;
12851 TTY_SCROLL_REGION_OK (CURTTY ()) = 1; /* we'll scroll partial frames */
12852 TTY_CHAR_INS_DEL_OK (CURTTY ()) = 1;
12853 TTY_LINE_INS_DEL_OK (CURTTY ()) = 1; /* we'll just blt 'em */
12854 TTY_FAST_CLEAR_END_OF_LINE (CURTTY ()) = 1; /* X does this well */
12855 TTY_MEMORY_BELOW_FRAME (CURTTY ()) = 0; /* we don't remember what
12859 terminal
->scroll_region_ok
= 1; /* We'll scroll partial frames. */
12860 terminal
->char_ins_del_ok
= 1;
12861 terminal
->line_ins_del_ok
= 1; /* We'll just blt 'em. */
12862 terminal
->fast_clear_end_of_line
= 1; /* X does this well. */
12863 terminal
->memory_below_frame
= 0; /* We don't remember what scrolls
12868 /* FIXME: This keyboard setup is 100% untested, just copied from
12869 w32_create_terminal in order to set window-system now that it's
12870 a keyboard object. */
12871 /* We don't yet support separate terminals on Mac, so don't try to share
12872 keyboards between virtual terminals that are on the same physical
12873 terminal like X does. */
12874 terminal
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
12875 init_kboard (terminal
->kboard
);
12876 terminal
->kboard
->Vwindow_system
= intern ("mac");
12877 terminal
->kboard
->next_kboard
= all_kboards
;
12878 all_kboards
= terminal
->kboard
;
12879 /* Don't let the initial kboard remain current longer than necessary.
12880 That would cause problems if a file loaded on startup tries to
12881 prompt in the mini-buffer. */
12882 if (current_kboard
== initial_kboard
)
12883 current_kboard
= terminal
->kboard
;
12884 terminal
->kboard
->reference_count
++;
12895 last_tool_bar_item
= -1;
12896 any_help_event_p
= 0;
12898 /* Try to use interrupt input; if we can't, then start polling. */
12899 Fset_input_interrupt_mode (Qt
);
12903 #if TARGET_API_MAC_CARBON
12905 install_application_handler ();
12914 init_coercion_handler ();
12916 init_apple_event_handler ();
12918 init_dm_notification_handler ();
12920 if (!inhibit_window_system
)
12922 static const ProcessSerialNumber psn
= {0, kCurrentProcess
};
12924 SetFrontProcess (&psn
);
12942 staticpro (&x_error_message_string
);
12943 x_error_message_string
= Qnil
;
12946 Qcontrol
= intern ("control"); staticpro (&Qcontrol
);
12947 Qmeta
= intern ("meta"); staticpro (&Qmeta
);
12948 Qalt
= intern ("alt"); staticpro (&Qalt
);
12949 Qhyper
= intern ("hyper"); staticpro (&Qhyper
);
12950 Qsuper
= intern ("super"); staticpro (&Qsuper
);
12951 Qmodifier_value
= intern ("modifier-value");
12952 staticpro (&Qmodifier_value
);
12954 Fput (Qcontrol
, Qmodifier_value
, make_number (ctrl_modifier
));
12955 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
12956 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
12957 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
12958 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
12960 #if TARGET_API_MAC_CARBON
12961 Qhi_command
= intern ("hi-command"); staticpro (&Qhi_command
);
12963 Qtoolbar_switch_mode
= intern ("toolbar-switch-mode");
12964 staticpro (&Qtoolbar_switch_mode
);
12965 #if USE_MAC_FONT_PANEL
12966 Qpanel_closed
= intern ("panel-closed"); staticpro (&Qpanel_closed
);
12967 Qselection
= intern ("selection"); staticpro (&Qselection
);
12970 Qservice
= intern ("service"); staticpro (&Qservice
);
12971 Qpaste
= intern ("paste"); staticpro (&Qpaste
);
12972 Qperform
= intern ("perform"); staticpro (&Qperform
);
12975 Qtext_input
= intern ("text-input"); staticpro (&Qtext_input
);
12976 Qupdate_active_input_area
= intern ("update-active-input-area");
12977 staticpro (&Qupdate_active_input_area
);
12978 Qunicode_for_key_event
= intern ("unicode-for-key-event");
12979 staticpro (&Qunicode_for_key_event
);
12984 Fprovide (intern ("mac-carbon"), Qnil
);
12987 staticpro (&Qreverse
);
12988 Qreverse
= intern ("reverse");
12990 staticpro (&x_display_name_list
);
12991 x_display_name_list
= Qnil
;
12993 staticpro (&last_mouse_scroll_bar
);
12994 last_mouse_scroll_bar
= Qnil
;
12996 staticpro (&fm_font_family_alist
);
12997 fm_font_family_alist
= Qnil
;
13000 staticpro (&atsu_font_id_hash
);
13001 atsu_font_id_hash
= Qnil
;
13003 staticpro (&fm_style_face_attributes_alist
);
13004 fm_style_face_attributes_alist
= Qnil
;
13008 staticpro (&saved_ts_script_language_on_focus
);
13009 saved_ts_script_language_on_focus
= Qnil
;
13012 /* We don't yet support this, but defining this here avoids whining
13013 from cus-start.el and other places, like "M-x set-variable". */
13014 DEFVAR_BOOL ("x-use-underline-position-properties",
13015 &x_use_underline_position_properties
,
13016 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
13017 A value of nil means ignore them. If you encounter fonts with bogus
13018 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
13019 to 4.1, set this to nil.
13021 NOTE: Not supported on Mac yet. */);
13022 x_use_underline_position_properties
= 0;
13024 DEFVAR_BOOL ("x-underline-at-descent-line",
13025 &x_underline_at_descent_line
,
13026 doc
: /* *Non-nil means to draw the underline at the same place as the descent line.
13027 A value of nil means to draw the underline according to the value of the
13028 variable `x-use-underline-position-properties', which is usually at the
13029 baseline level. The default value is nil. */);
13030 x_underline_at_descent_line
= 0;
13032 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
13033 doc
: /* If not nil, Emacs uses toolkit scroll bars. */);
13034 #ifdef USE_TOOLKIT_SCROLL_BARS
13035 Vx_toolkit_scroll_bars
= Qt
;
13037 Vx_toolkit_scroll_bars
= Qnil
;
13040 staticpro (&last_mouse_motion_frame
);
13041 last_mouse_motion_frame
= Qnil
;
13043 /* Variables to configure modifier key assignment. */
13045 DEFVAR_LISP ("mac-control-modifier", &Vmac_control_modifier
,
13046 doc
: /* *Modifier key assumed when the Mac control key is pressed.
13047 The value can be `control', `meta', `alt', `hyper', or `super' for the
13048 respective modifier. The default is `control'. */);
13049 Vmac_control_modifier
= Qcontrol
;
13051 DEFVAR_LISP ("mac-option-modifier", &Vmac_option_modifier
,
13052 doc
: /* *Modifier key assumed when the Mac alt/option key is pressed.
13053 The value can be `control', `meta', `alt', `hyper', or `super' for the
13054 respective modifier. If the value is nil then the key will act as the
13055 normal Mac control modifier, and the option key can be used to compose
13056 characters depending on the chosen Mac keyboard setting. */);
13057 Vmac_option_modifier
= Qnil
;
13059 DEFVAR_LISP ("mac-command-modifier", &Vmac_command_modifier
,
13060 doc
: /* *Modifier key assumed when the Mac command key is pressed.
13061 The value can be `control', `meta', `alt', `hyper', or `super' for the
13062 respective modifier. The default is `meta'. */);
13063 Vmac_command_modifier
= Qmeta
;
13065 DEFVAR_LISP ("mac-function-modifier", &Vmac_function_modifier
,
13066 doc
: /* *Modifier key assumed when the Mac function key is pressed.
13067 The value can be `control', `meta', `alt', `hyper', or `super' for the
13068 respective modifier. Note that remapping the function key may lead to
13069 unexpected results for some keys on non-US/GB keyboards. */);
13070 Vmac_function_modifier
= Qnil
;
13072 DEFVAR_LISP ("mac-emulate-three-button-mouse",
13073 &Vmac_emulate_three_button_mouse
,
13074 doc
: /* *Specify a way of three button mouse emulation.
13075 The value can be nil, t, or the symbol `reverse'.
13076 A value of nil means that no emulation should be done and the modifiers
13077 should be placed on the mouse-1 event.
13078 t means that when the option-key is held down while pressing the mouse
13079 button, the click will register as mouse-2 and while the command-key
13080 is held down, the click will register as mouse-3.
13081 The symbol `reverse' means that the option-key will register for
13082 mouse-3 and the command-key will register for mouse-2. */);
13083 Vmac_emulate_three_button_mouse
= Qnil
;
13085 #if TARGET_API_MAC_CARBON
13086 DEFVAR_BOOL ("mac-wheel-button-is-mouse-2", &mac_wheel_button_is_mouse_2
,
13087 doc
: /* *Non-nil if the wheel button is mouse-2 and the right click mouse-3.
13088 Otherwise, the right click will be treated as mouse-2 and the wheel
13089 button will be mouse-3. */);
13090 mac_wheel_button_is_mouse_2
= 1;
13092 DEFVAR_BOOL ("mac-pass-command-to-system", &mac_pass_command_to_system
,
13093 doc
: /* *Non-nil if command key presses are passed on to the Mac Toolbox. */);
13094 mac_pass_command_to_system
= 1;
13096 DEFVAR_BOOL ("mac-pass-control-to-system", &mac_pass_control_to_system
,
13097 doc
: /* *Non-nil if control key presses are passed on to the Mac Toolbox. */);
13098 mac_pass_control_to_system
= 1;
13102 DEFVAR_BOOL ("mac-allow-anti-aliasing", &mac_use_core_graphics
,
13103 doc
: /* *If non-nil, allow anti-aliasing.
13104 The text will be rendered using Core Graphics text rendering which
13105 may anti-alias the text. */);
13107 mac_use_core_graphics
= 1;
13109 mac_use_core_graphics
= 0;
13112 /* Register an entry for `mac-roman' so that it can be used when
13113 creating the terminal frame on Mac OS 9 before loading
13114 term/mac-win.elc. */
13115 DEFVAR_LISP ("mac-charset-info-alist", &Vmac_charset_info_alist
,
13116 doc
: /* Alist of Emacs character sets vs text encodings and coding systems.
13117 Each entry should be of the form:
13119 (CHARSET-NAME TEXT-ENCODING CODING-SYSTEM)
13121 where CHARSET-NAME is a string used in font names to identify the
13122 charset, TEXT-ENCODING is a TextEncodingBase value in Mac, and
13123 CODING_SYSTEM is a coding system corresponding to TEXT-ENCODING. */);
13124 Vmac_charset_info_alist
=
13125 Fcons (list3 (build_string ("mac-roman"),
13126 make_number (smRoman
), Qnil
), Qnil
);
13129 DEFVAR_LISP ("mac-ts-active-input-overlay", &Vmac_ts_active_input_overlay
,
13130 doc
: /* Overlay used to display Mac TSM active input area. */);
13131 Vmac_ts_active_input_overlay
= Qnil
;
13133 DEFVAR_LISP ("mac-ts-script-language-on-focus", &Vmac_ts_script_language_on_focus
,
13134 doc
: /* *How to change Mac TSM script/language when a frame gets focus.
13135 If the value is t, the input script and language are restored to those
13136 used in the last focus frame. If the value is a pair of integers, the
13137 input script and language codes, which are defined in the Script
13138 Manager, are set to its car and cdr parts, respectively. Otherwise,
13139 Emacs doesn't set them and thus follows the system default behavior. */);
13140 Vmac_ts_script_language_on_focus
= Qnil
;
13144 /* arch-tag: f2259165-4454-4c04-a029-a133c8af7b5b
13145 (do not change this comment) */