1 /* Implementation of GUI terminal on the Mac OS.
2 Copyright (C) 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007 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"
86 /* Non-nil means Emacs uses toolkit scroll bars. */
88 Lisp_Object Vx_toolkit_scroll_bars
;
90 /* If non-zero, the text will be rendered using Core Graphics text
91 rendering which may anti-alias the text. */
92 int mac_use_core_graphics
;
95 /* Non-zero means that a HELP_EVENT has been generated since Emacs
98 static int any_help_event_p
;
100 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
101 static Lisp_Object last_window
;
103 /* Non-zero means make use of UNDERLINE_POSITION font properties.
104 (Not yet supported.) */
105 int x_use_underline_position_properties
;
107 /* Non-zero means to draw the underline at the same place as the descent line. */
109 int x_underline_at_descent_line
;
111 /* This is a chain of structures for all the X displays currently in
114 struct x_display_info
*x_display_list
;
116 /* This is a list of cons cells, each of the form (NAME
117 FONT-LIST-CACHE . RESOURCE-DATABASE), one for each element of
118 x_display_list and in the same order. NAME is the name of the
119 frame. FONT-LIST-CACHE records previous values returned by
120 x-list-fonts. RESOURCE-DATABASE preserves the X Resource Database
121 equivalent, which is implemented with a Lisp object, for the
124 Lisp_Object x_display_name_list
;
126 /* This is display since Mac does not support multiple ones. */
127 struct mac_display_info one_mac_display_info
;
129 /* Frame being updated by update_frame. This is declared in term.c.
130 This is set by update_begin and looked at by all the XT functions.
131 It is zero while not inside an update. In that case, the XT
132 functions assume that `selected_frame' is the frame to apply to. */
134 extern struct frame
*updating_frame
;
136 /* This is a frame waiting to be auto-raised, within XTread_socket. */
138 struct frame
*pending_autoraise_frame
;
142 Formerly, we used PointerMotionHintMask (in standard_event_mask)
143 so that we would have to call XQueryPointer after each MotionNotify
144 event to ask for another such event. However, this made mouse tracking
145 slow, and there was a bug that made it eventually stop.
147 Simply asking for MotionNotify all the time seems to work better.
149 In order to avoid asking for motion events and then throwing most
150 of them away or busy-polling the server for mouse positions, we ask
151 the server for pointer motion hints. This means that we get only
152 one event per group of mouse movements. "Groups" are delimited by
153 other kinds of events (focus changes and button clicks, for
154 example), or by XQueryPointer calls; when one of these happens, we
155 get another MotionNotify event the next time the mouse moves. This
156 is at least as efficient as getting motion events when mouse
157 tracking is on, and I suspect only negligibly worse when tracking
160 /* Where the mouse was last time we reported a mouse event. */
162 static Rect last_mouse_glyph
;
163 static FRAME_PTR last_mouse_glyph_frame
;
165 /* The scroll bar in which the last X motion event occurred.
167 If the last X motion event occurred in a scroll bar, we set this so
168 XTmouse_position can know whether to report a scroll bar motion or
171 If the last X motion event didn't occur in a scroll bar, we set
172 this to Qnil, to tell XTmouse_position to return an ordinary motion
175 static Lisp_Object last_mouse_scroll_bar
;
177 /* This is a hack. We would really prefer that XTmouse_position would
178 return the time associated with the position it returns, but there
179 doesn't seem to be any way to wrest the time-stamp from the server
180 along with the position query. So, we just keep track of the time
181 of the last movement we received, and return that in hopes that
182 it's somewhat accurate. */
184 static Time last_mouse_movement_time
;
186 struct scroll_bar
*tracked_scroll_bar
= NULL
;
188 /* Incremented by XTread_socket whenever it really tries to read
192 static int volatile input_signal_count
;
194 static int input_signal_count
;
197 extern Lisp_Object Vsystem_name
;
199 extern Lisp_Object Qeql
;
201 /* A mask of extra modifier bits to put into every keyboard char. */
203 extern EMACS_INT extra_keyboard_modifiers
;
205 /* The keysyms to use for the various modifiers. */
207 static Lisp_Object Qalt
, Qhyper
, Qsuper
, Qcontrol
, Qmeta
, Qmodifier_value
;
209 extern int inhibit_window_system
;
211 #if __MRC__ && !TARGET_API_MAC_CARBON
212 QDGlobals qd
; /* QuickDraw global information structure. */
215 #define mac_window_to_frame(wp) (((mac_output *) GetWRefCon (wp))->mFP)
217 struct mac_display_info
*mac_display_info_for_display (Display
*);
218 static void x_update_window_end
P_ ((struct window
*, int, int));
219 int x_catch_errors
P_ ((Display
*));
220 void x_uncatch_errors
P_ ((Display
*, int));
221 void x_lower_frame
P_ ((struct frame
*));
222 void x_scroll_bar_clear
P_ ((struct frame
*));
223 int x_had_errors_p
P_ ((Display
*));
224 void x_wm_set_size_hint
P_ ((struct frame
*, long, int));
225 void x_raise_frame
P_ ((struct frame
*));
226 void x_set_window_size
P_ ((struct frame
*, int, int, int));
227 void x_wm_set_window_state
P_ ((struct frame
*, int));
228 void x_wm_set_icon_pixmap
P_ ((struct frame
*, int));
229 static void mac_initialize
P_ ((void));
230 static void x_font_min_bounds
P_ ((XFontStruct
*, int *, int *));
231 static int x_compute_min_glyph_bounds
P_ ((struct frame
*));
232 static void x_update_end
P_ ((struct frame
*));
233 static void XTframe_up_to_date
P_ ((struct frame
*));
234 static void XTset_terminal_modes
P_ ((struct terminal
*));
235 static void XTreset_terminal_modes
P_ ((struct terminal
*));
236 static void x_clear_frame
P_ ((struct frame
*));
237 static void frame_highlight
P_ ((struct frame
*));
238 static void frame_unhighlight
P_ ((struct frame
*));
239 static void x_new_focus_frame
P_ ((struct x_display_info
*, struct frame
*));
240 static void mac_focus_changed
P_ ((int, struct mac_display_info
*,
241 struct frame
*, struct input_event
*));
242 static void x_detect_focus_change
P_ ((struct mac_display_info
*,
244 struct input_event
*));
245 static void XTframe_rehighlight
P_ ((struct frame
*));
246 static void x_frame_rehighlight
P_ ((struct x_display_info
*));
247 static void x_draw_hollow_cursor
P_ ((struct window
*, struct glyph_row
*));
248 static void x_draw_bar_cursor
P_ ((struct window
*, struct glyph_row
*, int,
249 enum text_cursor_kinds
));
251 static void x_clip_to_row
P_ ((struct window
*, struct glyph_row
*, int, GC
));
252 static void x_flush
P_ ((struct frame
*f
));
253 static void x_update_begin
P_ ((struct frame
*));
254 static void x_update_window_begin
P_ ((struct window
*));
255 static void x_after_update_window_line
P_ ((struct glyph_row
*));
256 static void x_scroll_bar_report_motion
P_ ((struct frame
**, Lisp_Object
*,
257 enum scroll_bar_part
*,
258 Lisp_Object
*, Lisp_Object
*,
261 static int is_emacs_window
P_ ((WindowRef
));
262 static XCharStruct
*mac_per_char_metric
P_ ((XFontStruct
*, XChar2b
*, int));
263 static void XSetFont
P_ ((Display
*, GC
, XFontStruct
*));
264 static struct terminal
*mac_create_terminal
P_ ((struct mac_display_info
*dpyinfo
));
267 #define GC_FORE_COLOR(gc) (&(gc)->fore_color)
268 #define GC_BACK_COLOR(gc) (&(gc)->back_color)
269 #define GC_FONT(gc) ((gc)->xgcv.font)
270 #define FRAME_NORMAL_GC(f) ((f)->output_data.mac->normal_gc)
272 #define CG_SET_FILL_COLOR(context, color) \
273 CGContextSetRGBFillColor (context, \
274 RED_FROM_ULONG (color) / 255.0f, \
275 GREEN_FROM_ULONG (color) / 255.0f, \
276 BLUE_FROM_ULONG (color) / 255.0f, 1.0f)
277 #if USE_CG_DRAWING && MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
278 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
279 #define CG_SET_FILL_COLOR_MAYBE_WITH_CGCOLOR(context, color, cg_color) \
281 if (CGColorGetTypeID != NULL) \
282 CGContextSetFillColorWithColor (context, cg_color); \
284 CG_SET_FILL_COLOR (context, color); \
287 #define CG_SET_FILL_COLOR_MAYBE_WITH_CGCOLOR(context, color, cg_color) \
288 CGContextSetFillColorWithColor (context, cg_color)
291 #define CG_SET_FILL_COLOR_MAYBE_WITH_CGCOLOR(context, color, cg_color) \
292 CG_SET_FILL_COLOR (context, color)
294 #define CG_SET_FILL_COLOR_WITH_GC_FOREGROUND(context, gc) \
295 CG_SET_FILL_COLOR_MAYBE_WITH_CGCOLOR (context, (gc)->xgcv.foreground, \
297 #define CG_SET_FILL_COLOR_WITH_GC_BACKGROUND(context, gc) \
298 CG_SET_FILL_COLOR_MAYBE_WITH_CGCOLOR (context, (gc)->xgcv.background, \
302 #define CG_SET_STROKE_COLOR(context, color) \
303 CGContextSetRGBStrokeColor (context, \
304 RED_FROM_ULONG (color) / 255.0f, \
305 GREEN_FROM_ULONG (color) / 255.0f, \
306 BLUE_FROM_ULONG (color) / 255.0f, 1.0f)
307 #if USE_CG_DRAWING && MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
308 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
309 #define CG_SET_STROKE_COLOR_MAYBE_WITH_CGCOLOR(context, color, cg_color) \
311 if (CGColorGetTypeID != NULL) \
312 CGContextSetStrokeColorWithColor (context, cg_color); \
314 CG_SET_STROKE_COLOR (context, color); \
317 #define CG_SET_STROKE_COLOR_MAYBE_WITH_CGCOLOR(context, color, cg_color) \
318 CGContextSetStrokeColorWithColor (context, cg_color)
321 #define CG_SET_STROKE_COLOR_MAYBE_WITH_CGCOLOR(context, color, cg_color) \
322 CG_SET_STROKE_COLOR (context, color)
324 #define CG_SET_STROKE_COLOR_WITH_GC_FOREGROUND(context, gc) \
325 CG_SET_STROKE_COLOR_MAYBE_WITH_CGCOLOR (context, (gc)->xgcv.foreground, \
329 #define FRAME_CG_CONTEXT(f) ((f)->output_data.mac->cg_context)
331 /* Fringe bitmaps. */
333 static int max_fringe_bmp
= 0;
334 static CGImageRef
*fringe_bmp
= 0;
336 static CGColorSpaceRef mac_cg_color_space_rgb
;
337 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
338 static CGColorRef mac_cg_color_black
;
344 mac_cg_color_space_rgb
= CGColorSpaceCreateDeviceRGB ();
345 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
346 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
347 /* Don't check the availability of CGColorCreate; this symbol is
348 defined even in Mac OS X 10.1. */
349 if (CGColorGetTypeID
!= NULL
)
352 float rgba
[] = {0.0f
, 0.0f
, 0.0f
, 1.0f
};
354 mac_cg_color_black
= CGColorCreate (mac_cg_color_space_rgb
, rgba
);
360 mac_begin_cg_clip (f
, gc
)
364 CGContextRef context
= FRAME_CG_CONTEXT (f
);
368 QDBeginCGContext (GetWindowPort (FRAME_MAC_WINDOW (f
)), &context
);
369 FRAME_CG_CONTEXT (f
) = context
;
372 CGContextSaveGState (context
);
373 CGContextTranslateCTM (context
, 0, FRAME_PIXEL_HEIGHT (f
));
374 CGContextScaleCTM (context
, 1, -1);
375 if (gc
&& gc
->n_clip_rects
)
376 CGContextClipToRects (context
, gc
->clip_rects
, gc
->n_clip_rects
);
385 CGContextRestoreGState (FRAME_CG_CONTEXT (f
));
389 mac_prepare_for_quickdraw (f
)
394 Lisp_Object rest
, frame
;
395 FOR_EACH_FRAME (rest
, frame
)
396 if (FRAME_MAC_P (XFRAME (frame
)))
397 mac_prepare_for_quickdraw (XFRAME (frame
));
401 CGContextRef context
= FRAME_CG_CONTEXT (f
);
405 CGContextSynchronize (context
);
406 QDEndCGContext (GetWindowPort (FRAME_MAC_WINDOW (f
)),
407 &FRAME_CG_CONTEXT (f
));
413 static RgnHandle saved_port_clip_region
= NULL
;
416 mac_begin_clip (f
, gc
)
420 static RgnHandle new_region
= NULL
;
422 if (saved_port_clip_region
== NULL
)
423 saved_port_clip_region
= NewRgn ();
424 if (new_region
== NULL
)
425 new_region
= NewRgn ();
428 mac_prepare_for_quickdraw (f
);
430 SetPortWindowPort (FRAME_MAC_WINDOW (f
));
432 if (gc
->n_clip_rects
)
434 GetClip (saved_port_clip_region
);
435 SectRgn (saved_port_clip_region
, gc
->clip_region
, new_region
);
436 SetClip (new_region
);
444 if (gc
->n_clip_rects
)
445 SetClip (saved_port_clip_region
);
449 /* X display function emulation */
451 /* Mac version of XDrawLine. */
454 mac_draw_line (f
, gc
, x1
, y1
, x2
, y2
)
460 CGContextRef context
;
461 float gx1
= x1
, gy1
= y1
, gx2
= x2
, gy2
= y2
;
464 gx1
+= 0.5f
, gx2
+= 0.5f
;
466 gy1
+= 0.5f
, gy2
+= 0.5f
;
468 context
= mac_begin_cg_clip (f
, gc
);
469 CG_SET_STROKE_COLOR_WITH_GC_FOREGROUND (context
, gc
);
470 CGContextBeginPath (context
);
471 CGContextMoveToPoint (context
, gx1
, gy1
);
472 CGContextAddLineToPoint (context
, gx2
, gy2
);
473 CGContextClosePath (context
);
474 CGContextStrokePath (context
);
492 mac_begin_clip (f
, gc
);
493 RGBForeColor (GC_FORE_COLOR (gc
));
500 /* Mac version of XDrawLine (to Pixmap). */
503 XDrawLine (display
, p
, gc
, x1
, y1
, x2
, y2
)
527 GetGWorld (&old_port
, &old_gdh
);
530 RGBForeColor (GC_FORE_COLOR (gc
));
532 LockPixels (GetGWorldPixMap (p
));
535 UnlockPixels (GetGWorldPixMap (p
));
537 SetGWorld (old_port
, old_gdh
);
542 mac_erase_rectangle (f
, gc
, x
, y
, width
, height
)
546 unsigned int width
, height
;
550 CGContextRef context
;
552 context
= mac_begin_cg_clip (f
, gc
);
553 CG_SET_FILL_COLOR_WITH_GC_BACKGROUND (context
, gc
);
554 CGContextFillRect (context
, CGRectMake (x
, y
, width
, height
));
561 mac_begin_clip (f
, gc
);
562 RGBBackColor (GC_BACK_COLOR (gc
));
563 SetRect (&r
, x
, y
, x
+ width
, y
+ height
);
565 RGBBackColor (GC_BACK_COLOR (FRAME_NORMAL_GC (f
)));
572 /* Mac version of XClearArea. */
575 mac_clear_area (f
, x
, y
, width
, height
)
578 unsigned int width
, height
;
580 mac_erase_rectangle (f
, FRAME_NORMAL_GC (f
), x
, y
, width
, height
);
583 /* Mac version of XClearWindow. */
591 CGContextRef context
;
592 GC gc
= FRAME_NORMAL_GC (f
);
594 context
= mac_begin_cg_clip (f
, NULL
);
595 CG_SET_FILL_COLOR_WITH_GC_BACKGROUND (context
, gc
);
596 CGContextFillRect (context
, CGRectMake (0, 0, FRAME_PIXEL_WIDTH (f
),
597 FRAME_PIXEL_HEIGHT (f
)));
600 #else /* !USE_CG_DRAWING */
601 SetPortWindowPort (FRAME_MAC_WINDOW (f
));
603 RGBBackColor (GC_BACK_COLOR (FRAME_NORMAL_GC (f
)));
605 #if TARGET_API_MAC_CARBON
609 GetWindowPortBounds (FRAME_MAC_WINDOW (f
), &r
);
612 #else /* not TARGET_API_MAC_CARBON */
613 EraseRect (&(FRAME_MAC_WINDOW (f
)->portRect
));
614 #endif /* not TARGET_API_MAC_CARBON */
619 /* Mac replacement for XCopyArea. */
623 mac_draw_cg_image (image
, f
, gc
, src_x
, src_y
, width
, height
,
624 dest_x
, dest_y
, overlay_p
)
629 unsigned int width
, height
;
630 int dest_x
, dest_y
, overlay_p
;
632 CGContextRef context
;
633 float port_height
= FRAME_PIXEL_HEIGHT (f
);
634 CGRect dest_rect
= CGRectMake (dest_x
, dest_y
, width
, height
);
636 context
= mac_begin_cg_clip (f
, gc
);
639 CG_SET_FILL_COLOR_WITH_GC_BACKGROUND (context
, gc
);
640 CGContextFillRect (context
, dest_rect
);
642 CGContextClipToRect (context
, dest_rect
);
643 CGContextScaleCTM (context
, 1, -1);
644 CGContextTranslateCTM (context
, 0, -port_height
);
645 if (CGImageIsMask (image
))
646 CG_SET_FILL_COLOR_WITH_GC_FOREGROUND (context
, gc
);
647 CGContextDrawImage (context
,
648 CGRectMake (dest_x
- src_x
,
649 port_height
- (dest_y
- src_y
650 + CGImageGetHeight (image
)),
651 CGImageGetWidth (image
),
652 CGImageGetHeight (image
)),
657 #else /* !USE_CG_DRAWING */
660 mac_draw_bitmap (f
, gc
, x
, y
, width
, height
, bits
, overlay_p
)
663 int x
, y
, width
, height
;
664 unsigned short *bits
;
670 bitmap
.rowBytes
= sizeof(unsigned short);
671 bitmap
.baseAddr
= (char *)bits
;
672 SetRect (&(bitmap
.bounds
), 0, 0, width
, height
);
674 mac_begin_clip (f
, gc
);
675 RGBForeColor (GC_FORE_COLOR (gc
));
676 RGBBackColor (GC_BACK_COLOR (gc
));
677 SetRect (&r
, x
, y
, x
+ width
, y
+ height
);
678 #if TARGET_API_MAC_CARBON
684 CopyBits (&bitmap
, GetPortBitMapForCopyBits (port
),
685 &(bitmap
.bounds
), &r
, overlay_p
? srcOr
: srcCopy
, 0);
686 UnlockPortBits (port
);
688 #else /* not TARGET_API_MAC_CARBON */
689 CopyBits (&bitmap
, &(FRAME_MAC_WINDOW (f
)->portBits
), &(bitmap
.bounds
), &r
,
690 overlay_p
? srcOr
: srcCopy
, 0);
691 #endif /* not TARGET_API_MAC_CARBON */
692 RGBBackColor (GC_BACK_COLOR (FRAME_NORMAL_GC (f
)));
695 #endif /* !USE_CG_DRAWING */
698 /* Mac replacement for XCreateBitmapFromBitmapData. */
701 mac_create_bitmap_from_bitmap_data (bitmap
, bits
, w
, h
)
706 static const unsigned char swap_nibble
[16]
707 = { 0x0, 0x8, 0x4, 0xc, /* 0000 1000 0100 1100 */
708 0x2, 0xa, 0x6, 0xe, /* 0010 1010 0110 1110 */
709 0x1, 0x9, 0x5, 0xd, /* 0001 1001 0101 1101 */
710 0x3, 0xb, 0x7, 0xf }; /* 0011 1011 0111 1111 */
714 w1
= (w
+ 7) / 8; /* nb of 8bits elt in X bitmap */
715 bitmap
->rowBytes
= ((w
+ 15) / 16) * 2; /* nb of 16bits elt in Mac bitmap */
716 bitmap
->baseAddr
= xmalloc (bitmap
->rowBytes
* h
);
717 bzero (bitmap
->baseAddr
, bitmap
->rowBytes
* h
);
718 for (i
= 0; i
< h
; i
++)
720 p
= bitmap
->baseAddr
+ i
* bitmap
->rowBytes
;
721 for (j
= 0; j
< w1
; j
++)
723 /* Bitswap XBM bytes to match how Mac does things. */
724 unsigned char c
= *bits
++;
725 *p
++ = (unsigned char)((swap_nibble
[c
& 0xf] << 4)
726 | (swap_nibble
[(c
>>4) & 0xf]));
730 SetRect (&(bitmap
->bounds
), 0, 0, w
, h
);
735 mac_free_bitmap (bitmap
)
738 xfree (bitmap
->baseAddr
);
743 XCreatePixmap (display
, w
, width
, height
, depth
)
746 unsigned int width
, height
;
753 SetPortWindowPort (w
);
755 SetRect (&r
, 0, 0, width
, height
);
756 #if !defined (WORDS_BIG_ENDIAN) && USE_CG_DRAWING
759 err
= NewGWorld (&pixmap
, depth
, &r
, NULL
, NULL
, 0);
760 #if !defined (WORDS_BIG_ENDIAN) && USE_CG_DRAWING
762 /* CreateCGImageFromPixMaps requires ARGB format. */
763 err
= QTNewGWorld (&pixmap
, k32ARGBPixelFormat
, &r
, NULL
, NULL
, 0);
772 XCreatePixmapFromBitmapData (display
, w
, data
, width
, height
, fg
, bg
, depth
)
776 unsigned int width
, height
;
777 unsigned long fg
, bg
;
787 gc
= XCreateGC (display
, w
, 0, NULL
);
789 pixmap
= XCreatePixmap (display
, w
, width
, height
, depth
);
793 GetGWorld (&old_port
, &old_gdh
);
794 SetGWorld (pixmap
, NULL
);
795 mac_create_bitmap_from_bitmap_data (&bitmap
, data
, width
, height
);
796 XSetForeground (display
, gc
, fg
);
797 XSetBackground (display
, gc
, bg
);
798 RGBForeColor (GC_FORE_COLOR (gc
));
799 RGBBackColor (GC_BACK_COLOR (gc
));
800 LockPixels (GetGWorldPixMap (pixmap
));
801 #if TARGET_API_MAC_CARBON
802 CopyBits (&bitmap
, GetPortBitMapForCopyBits (pixmap
),
803 &bitmap
.bounds
, &bitmap
.bounds
, srcCopy
, 0);
804 #else /* not TARGET_API_MAC_CARBON */
805 CopyBits (&bitmap
, &(((GrafPtr
)pixmap
)->portBits
),
806 &bitmap
.bounds
, &bitmap
.bounds
, srcCopy
, 0);
807 #endif /* not TARGET_API_MAC_CARBON */
808 UnlockPixels (GetGWorldPixMap (pixmap
));
809 SetGWorld (old_port
, old_gdh
);
810 mac_free_bitmap (&bitmap
);
817 XFreePixmap (display
, pixmap
)
821 DisposeGWorld (pixmap
);
825 /* Mac replacement for XFillRectangle. */
828 mac_fill_rectangle (f
, gc
, x
, y
, width
, height
)
832 unsigned int width
, height
;
835 CGContextRef context
;
837 context
= mac_begin_cg_clip (f
, gc
);
838 CG_SET_FILL_COLOR_WITH_GC_FOREGROUND (context
, gc
);
839 CGContextFillRect (context
, CGRectMake (x
, y
, width
, height
));
844 mac_begin_clip (f
, gc
);
845 RGBForeColor (GC_FORE_COLOR (gc
));
846 SetRect (&r
, x
, y
, x
+ width
, y
+ height
);
847 PaintRect (&r
); /* using foreground color of gc */
853 /* Mac replacement for XDrawRectangle: dest is a window. */
856 mac_draw_rectangle (f
, gc
, x
, y
, width
, height
)
860 unsigned int width
, height
;
863 CGContextRef context
;
865 context
= mac_begin_cg_clip (f
, gc
);
866 CG_SET_STROKE_COLOR_WITH_GC_FOREGROUND (context
, gc
);
867 CGContextStrokeRect (context
,
868 CGRectMake (x
+ 0.5f
, y
+ 0.5f
, width
, height
));
873 mac_begin_clip (f
, gc
);
874 RGBForeColor (GC_FORE_COLOR (gc
));
875 SetRect (&r
, x
, y
, x
+ width
+ 1, y
+ height
+ 1);
876 FrameRect (&r
); /* using foreground color of gc */
883 mac_invert_rectangle (f
, x
, y
, width
, height
)
886 unsigned int width
, height
;
891 mac_prepare_for_quickdraw (f
);
893 SetPortWindowPort (FRAME_MAC_WINDOW (f
));
895 SetRect (&r
, x
, y
, x
+ width
, y
+ height
);
903 atsu_get_text_layout_with_text_ptr (text
, text_length
, style
, text_layout
)
904 ConstUniCharArrayPtr text
;
905 UniCharCount text_length
;
907 ATSUTextLayout
*text_layout
;
910 static ATSUTextLayout saved_text_layout
= NULL
;
912 if (saved_text_layout
== NULL
)
914 static const UniCharCount lengths
[] = {kATSUToTextEnd
};
915 static const ATSUAttributeTag tags
[] = {kATSULineLayoutOptionsTag
};
916 static const ByteCount sizes
[] = {sizeof (ATSLineLayoutOptions
)};
917 static ATSLineLayoutOptions line_layout
=
918 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
919 kATSLineDisableAllLayoutOperations
| kATSLineUseDeviceMetrics
920 | kATSLineUseQDRendering
922 kATSLineIsDisplayOnly
| kATSLineFractDisable
925 static const ATSUAttributeValuePtr values
[] = {&line_layout
};
927 err
= ATSUCreateTextLayoutWithTextPtr (text
,
928 kATSUFromTextBeginning
,
934 err
= ATSUSetLayoutControls (saved_text_layout
,
935 sizeof (tags
) / sizeof (tags
[0]),
936 tags
, sizes
, values
);
938 err
= ATSUSetTransientFontMatching (saved_text_layout
, true);
942 err
= ATSUSetRunStyle (saved_text_layout
, style
,
943 kATSUFromTextBeginning
, kATSUToTextEnd
);
945 err
= ATSUSetTextPointerLocation (saved_text_layout
, text
,
946 kATSUFromTextBeginning
,
952 *text_layout
= saved_text_layout
;
958 mac_draw_image_string_atsui (f
, gc
, x
, y
, buf
, nchars
, bg_width
,
959 overstrike_p
, bytes_per_char
)
964 int nchars
, bg_width
, overstrike_p
, bytes_per_char
;
967 ATSUTextLayout text_layout
;
969 xassert (bytes_per_char
== 2);
971 #ifndef WORDS_BIG_ENDIAN
974 UniChar
*text
= (UniChar
*)buf
;
976 for (i
= 0; i
< nchars
; i
++)
977 text
[i
] = EndianU16_BtoN (text
[i
]);
980 err
= atsu_get_text_layout_with_text_ptr ((ConstUniCharArrayPtr
)buf
,
982 GC_FONT (gc
)->mac_style
,
987 if (!mac_use_core_graphics
)
990 mac_begin_clip (f
, gc
);
991 RGBForeColor (GC_FORE_COLOR (gc
));
996 SetRect (&r
, x
, y
- FONT_BASE (GC_FONT (gc
)),
997 x
+ bg_width
, y
+ FONT_DESCENT (GC_FONT (gc
)));
998 RGBBackColor (GC_BACK_COLOR (gc
));
1000 RGBBackColor (GC_BACK_COLOR (FRAME_NORMAL_GC (f
)));
1003 ATSUDrawText (text_layout
,
1004 kATSUFromTextBeginning
, kATSUToTextEnd
,
1005 kATSUUseGrafPortPenLoc
, kATSUUseGrafPortPenLoc
);
1009 ATSUDrawText (text_layout
,
1010 kATSUFromTextBeginning
, kATSUToTextEnd
,
1011 kATSUUseGrafPortPenLoc
, kATSUUseGrafPortPenLoc
);
1018 static CGContextRef context
;
1019 float port_height
= FRAME_PIXEL_HEIGHT (f
);
1020 static const ATSUAttributeTag tags
[] = {kATSUCGContextTag
};
1021 static const ByteCount sizes
[] = {sizeof (CGContextRef
)};
1022 static const ATSUAttributeValuePtr values
[] = {&context
};
1025 context
= mac_begin_cg_clip (f
, gc
);
1030 QDBeginCGContext (port
, &context
);
1031 if (gc
->n_clip_rects
|| bg_width
)
1033 CGContextTranslateCTM (context
, 0, port_height
);
1034 CGContextScaleCTM (context
, 1, -1);
1035 if (gc
->n_clip_rects
)
1036 CGContextClipToRects (context
, gc
->clip_rects
,
1041 CG_SET_FILL_COLOR_WITH_GC_BACKGROUND (context
, gc
);
1042 CGContextFillRect (context
,
1043 CGRectMake (x
, y
- FONT_BASE (GC_FONT (gc
)),
1045 FONT_HEIGHT (GC_FONT (gc
))));
1047 CGContextScaleCTM (context
, 1, -1);
1048 CGContextTranslateCTM (context
, 0, -port_height
);
1052 CG_SET_FILL_COLOR_WITH_GC_FOREGROUND (context
, gc
);
1053 err
= ATSUSetLayoutControls (text_layout
,
1054 sizeof (tags
) / sizeof (tags
[0]),
1055 tags
, sizes
, values
);
1058 ATSUDrawText (text_layout
,
1059 kATSUFromTextBeginning
, kATSUToTextEnd
,
1060 Long2Fix (x
), Long2Fix (port_height
- y
));
1062 ATSUDrawText (text_layout
,
1063 kATSUFromTextBeginning
, kATSUToTextEnd
,
1064 Long2Fix (x
+ 1), Long2Fix (port_height
- y
));
1067 mac_end_cg_clip (f
);
1070 CGContextSynchronize (context
);
1071 QDEndCGContext (port
, &context
);
1074 /* This doesn't work on Mac OS X 10.1. */
1075 ATSUClearLayoutControls (text_layout
,
1076 sizeof (tags
) / sizeof (tags
[0]), tags
);
1078 ATSUSetLayoutControls (text_layout
,
1079 sizeof (tags
) / sizeof (tags
[0]),
1080 tags
, sizes
, values
);
1083 #endif /* MAC_OSX */
1085 #endif /* USE_ATSUI */
1089 mac_draw_image_string_qd (f
, gc
, x
, y
, buf
, nchars
, bg_width
,
1090 overstrike_p
, bytes_per_char
)
1095 int nchars
, bg_width
, overstrike_p
, bytes_per_char
;
1097 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
1101 mac_begin_clip (f
, gc
);
1102 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
1103 if (mac_use_core_graphics
)
1104 savedFlags
= SwapQDTextFlags (kQDUseCGTextRendering
);
1106 RGBForeColor (GC_FORE_COLOR (gc
));
1110 RGBBackColor (GC_BACK_COLOR (gc
));
1116 /* We prefer not to use srcCopy text transfer mode on Mac OS X
1118 - Screen is double-buffered. (In srcCopy mode, a text is drawn
1119 into an offscreen graphics world first. So performance gain
1120 cannot be expected.)
1121 - It lowers rendering quality.
1122 - Some fonts leave garbage on cursor movement. */
1127 RGBBackColor (GC_BACK_COLOR (gc
));
1128 SetRect (&r
, x
, y
- FONT_BASE (GC_FONT (gc
)),
1129 x
+ bg_width
, y
+ FONT_DESCENT (GC_FONT (gc
)));
1134 TextFont (GC_FONT (gc
)->mac_fontnum
);
1135 TextSize (GC_FONT (gc
)->mac_fontsize
);
1136 TextFace (GC_FONT (gc
)->mac_fontface
);
1138 DrawText (buf
, 0, nchars
* bytes_per_char
);
1143 DrawText (buf
, 0, nchars
* bytes_per_char
);
1146 RGBBackColor (GC_BACK_COLOR (FRAME_NORMAL_GC (f
)));
1149 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
1150 if (mac_use_core_graphics
)
1151 SwapQDTextFlags(savedFlags
);
1157 mac_draw_string_common (f
, gc
, x
, y
, buf
, nchars
, bg_width
,
1158 overstrike_p
, bytes_per_char
)
1163 int nchars
, bg_width
, overstrike_p
, bytes_per_char
;
1166 if (GC_FONT (gc
)->mac_style
)
1167 mac_draw_image_string_atsui (f
, gc
, x
, y
, buf
, nchars
, bg_width
,
1168 overstrike_p
, bytes_per_char
);
1170 #endif /* USE_ATSUI */
1171 mac_draw_image_string_qd (f
, gc
, x
, y
, buf
, nchars
, bg_width
,
1172 overstrike_p
, bytes_per_char
);
1176 /* Mac replacement for XDrawImageString. */
1179 mac_draw_image_string (f
, gc
, x
, y
, buf
, nchars
, bg_width
, overstrike_p
)
1184 int nchars
, bg_width
, overstrike_p
;
1186 mac_draw_string_common (f
, gc
, x
, y
, buf
, nchars
, bg_width
,
1191 /* Mac replacement for XDrawImageString16. */
1194 mac_draw_image_string_16 (f
, gc
, x
, y
, buf
, nchars
, bg_width
, overstrike_p
)
1199 int nchars
, bg_width
, overstrike_p
;
1201 mac_draw_string_common (f
, gc
, x
, y
, (char *) buf
, nchars
, bg_width
,
1206 /* Mac replacement for XQueryTextExtents, but takes a character. If
1207 STYLE is NULL, measurement is done by QuickDraw Text routines for
1208 the font of the current graphics port. If CG_GLYPH is not NULL,
1209 *CG_GLYPH is set to the glyph ID or 0 if it cannot be obtained. */
1212 mac_query_char_extents (style
, c
,
1213 font_ascent_return
, font_descent_return
,
1214 overall_return
, cg_glyph
)
1221 int *font_ascent_return
, *font_descent_return
;
1222 XCharStruct
*overall_return
;
1223 #if USE_CG_TEXT_DRAWING
1229 OSStatus err
= noErr
;
1236 ATSUTextLayout text_layout
;
1239 err
= atsu_get_text_layout_with_text_ptr (&ch
, 1, style
, &text_layout
);
1241 && (font_ascent_return
|| font_descent_return
|| overall_return
))
1243 ATSTrapezoid glyph_bounds
;
1245 err
= ATSUGetGlyphBounds (text_layout
, 0, 0,
1246 kATSUFromTextBeginning
, kATSUToTextEnd
,
1247 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
1248 kATSUseFractionalOrigins
,
1250 kATSUseDeviceOrigins
,
1252 1, &glyph_bounds
, NULL
);
1255 xassert (glyph_bounds
.lowerRight
.x
- glyph_bounds
.lowerLeft
.x
1256 == glyph_bounds
.upperRight
.x
- glyph_bounds
.upperLeft
.x
);
1258 width
= Fix2Long (glyph_bounds
.upperRight
.x
1259 - glyph_bounds
.upperLeft
.x
);
1260 if (font_ascent_return
)
1261 *font_ascent_return
= -Fix2Long (glyph_bounds
.upperLeft
.y
);
1262 if (font_descent_return
)
1263 *font_descent_return
= Fix2Long (glyph_bounds
.lowerLeft
.y
);
1266 if (err
== noErr
&& overall_return
)
1268 err
= ATSUMeasureTextImage (text_layout
,
1269 kATSUFromTextBeginning
, kATSUToTextEnd
,
1270 0, 0, &char_bounds
);
1272 STORE_XCHARSTRUCT (*overall_return
, width
, char_bounds
);
1273 #if USE_CG_TEXT_DRAWING
1274 if (err
== noErr
&& cg_glyph
)
1277 ATSUGlyphInfoArray glyph_info_array
;
1278 ByteCount count
= sizeof (ATSUGlyphInfoArray
);
1280 err1
= ATSUMatchFontsToText (text_layout
, kATSUFromTextBeginning
,
1281 kATSUToTextEnd
, NULL
, NULL
, NULL
);
1283 err1
= ATSUGetGlyphInfo (text_layout
, kATSUFromTextBeginning
,
1284 kATSUToTextEnd
, &count
,
1287 /* Make sure that we don't have to make layout
1289 && glyph_info_array
.glyphs
[0].deltaY
== 0.0f
1290 && glyph_info_array
.glyphs
[0].idealX
== 0.0f
1291 && glyph_info_array
.glyphs
[0].screenX
== 0)
1293 xassert (glyph_info_array
.glyphs
[0].glyphID
);
1294 *cg_glyph
= glyph_info_array
.glyphs
[0].glyphID
;
1305 if (font_ascent_return
|| font_descent_return
)
1309 GetFontInfo (&font_info
);
1310 if (font_ascent_return
)
1311 *font_ascent_return
= font_info
.ascent
;
1312 if (font_descent_return
)
1313 *font_descent_return
= font_info
.descent
;
1319 width
= CharWidth (ch
);
1320 QDTextBounds (1, &ch
, &char_bounds
);
1321 STORE_XCHARSTRUCT (*overall_return
, width
, char_bounds
);
1329 /* Mac replacement for XTextExtents16. Only sets horizontal metrics. */
1332 mac_text_extents_16 (font_struct
, string
, nchars
, overall_return
)
1333 XFontStruct
*font_struct
;
1336 XCharStruct
*overall_return
;
1339 short width
= 0, lbearing
= 0, rbearing
= 0;
1342 for (i
= 0; i
< nchars
; i
++)
1344 pcm
= mac_per_char_metric (font_struct
, string
, 0);
1346 width
+= FONT_WIDTH (font_struct
);
1349 lbearing
= min (lbearing
, width
+ pcm
->lbearing
);
1350 rbearing
= max (rbearing
, width
+ pcm
->rbearing
);
1351 width
+= pcm
->width
;
1356 overall_return
->lbearing
= lbearing
;
1357 overall_return
->rbearing
= rbearing
;
1358 overall_return
->width
= width
;
1360 /* What's the meaning of the return value of XTextExtents16? */
1364 #if USE_CG_TEXT_DRAWING
1365 static int cg_text_anti_aliasing_threshold
= 8;
1368 init_cg_text_anti_aliasing_threshold ()
1374 CFPreferencesGetAppIntegerValue (CFSTR ("AppleAntiAliasingThreshold"),
1375 kCFPreferencesCurrentApplication
,
1378 cg_text_anti_aliasing_threshold
= threshold
;
1382 mac_draw_image_string_cg (f
, gc
, x
, y
, buf
, nchars
, bg_width
, overstrike_p
)
1387 int nchars
, bg_width
, overstrike_p
;
1389 float port_height
, gx
, gy
;
1391 CGContextRef context
;
1395 if (!mac_use_core_graphics
|| GC_FONT (gc
)->cg_font
== NULL
)
1398 port_height
= FRAME_PIXEL_HEIGHT (f
);
1400 gy
= port_height
- y
;
1401 glyphs
= (CGGlyph
*)buf
;
1402 advances
= alloca (sizeof (CGSize
) * nchars
);
1403 if (advances
== NULL
)
1405 for (i
= 0; i
< nchars
; i
++)
1407 XCharStruct
*pcm
= mac_per_char_metric (GC_FONT (gc
), buf
, 0);
1409 advances
[i
].width
= pcm
->width
;
1410 advances
[i
].height
= 0;
1411 glyphs
[i
] = GC_FONT (gc
)->cg_glyphs
[buf
->byte2
];
1416 context
= mac_begin_cg_clip (f
, gc
);
1418 QDBeginCGContext (GetWindowPort (FRAME_MAC_WINDOW (f
)), &context
);
1419 if (gc
->n_clip_rects
|| bg_width
)
1421 CGContextTranslateCTM (context
, 0, port_height
);
1422 CGContextScaleCTM (context
, 1, -1);
1423 if (gc
->n_clip_rects
)
1424 CGContextClipToRects (context
, gc
->clip_rects
, gc
->n_clip_rects
);
1428 CG_SET_FILL_COLOR_WITH_GC_BACKGROUND (context
, gc
);
1431 CGRectMake (gx
, y
- FONT_BASE (GC_FONT (gc
)),
1432 bg_width
, FONT_HEIGHT (GC_FONT (gc
))));
1434 CGContextScaleCTM (context
, 1, -1);
1435 CGContextTranslateCTM (context
, 0, -port_height
);
1439 CG_SET_FILL_COLOR_WITH_GC_FOREGROUND (context
, gc
);
1440 CGContextSetFont (context
, GC_FONT (gc
)->cg_font
);
1441 CGContextSetFontSize (context
, GC_FONT (gc
)->mac_fontsize
);
1442 if (GC_FONT (gc
)->mac_fontsize
<= cg_text_anti_aliasing_threshold
)
1443 CGContextSetShouldAntialias (context
, false);
1444 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
1445 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
1446 if (CGContextShowGlyphsWithAdvances
!= NULL
)
1449 CGContextSetTextPosition (context
, gx
, gy
);
1450 CGContextShowGlyphsWithAdvances (context
, glyphs
, advances
, nchars
);
1453 CGContextSetTextPosition (context
, gx
+ 1.0f
, gy
);
1454 CGContextShowGlyphsWithAdvances (context
, glyphs
, advances
, nchars
);
1457 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
1458 else /* CGContextShowGlyphsWithAdvances == NULL */
1460 #endif /* MAC_OS_X_VERSION_MAX_ALLOWED >= 1030 */
1461 #if MAC_OS_X_VERSION_MAX_ALLOWED < 1030 || MAC_OS_X_VERSION_MIN_REQUIRED == 1020
1463 for (i
= 0; i
< nchars
; i
++)
1465 CGContextShowGlyphsAtPoint (context
, gx
, gy
, glyphs
+ i
, 1);
1467 CGContextShowGlyphsAtPoint (context
, gx
+ 1.0f
, gy
, glyphs
+ i
, 1);
1468 gx
+= advances
[i
].width
;
1473 mac_end_cg_clip (f
);
1475 CGContextSynchronize (context
);
1476 QDEndCGContext (GetWindowPort (FRAME_MAC_WINDOW (f
)), &context
);
1485 /* Mac replacement for XCopyArea: dest must be window. */
1488 mac_copy_area (src
, f
, gc
, src_x
, src_y
, width
, height
, dest_x
, dest_y
)
1493 unsigned int width
, height
;
1498 mac_begin_clip (f
, gc
);
1500 SetRect (&src_r
, src_x
, src_y
, src_x
+ width
, src_y
+ height
);
1501 SetRect (&dest_r
, dest_x
, dest_y
, dest_x
+ width
, dest_y
+ height
);
1503 ForeColor (blackColor
);
1504 BackColor (whiteColor
);
1506 LockPixels (GetGWorldPixMap (src
));
1507 #if TARGET_API_MAC_CARBON
1512 LockPortBits (port
);
1513 CopyBits (GetPortBitMapForCopyBits (src
),
1514 GetPortBitMapForCopyBits (port
),
1515 &src_r
, &dest_r
, srcCopy
, 0);
1516 UnlockPortBits (port
);
1518 #else /* not TARGET_API_MAC_CARBON */
1519 CopyBits (&(((GrafPtr
)src
)->portBits
), &(FRAME_MAC_WINDOW (f
)->portBits
),
1520 &src_r
, &dest_r
, srcCopy
, 0);
1521 #endif /* not TARGET_API_MAC_CARBON */
1522 UnlockPixels (GetGWorldPixMap (src
));
1524 RGBBackColor (GC_BACK_COLOR (FRAME_NORMAL_GC (f
)));
1531 mac_copy_area_with_mask (src
, mask
, f
, gc
, src_x
, src_y
,
1532 width
, height
, dest_x
, dest_y
)
1537 unsigned int width
, height
;
1542 mac_begin_clip (f
, gc
);
1544 SetRect (&src_r
, src_x
, src_y
, src_x
+ width
, src_y
+ height
);
1545 SetRect (&dest_r
, dest_x
, dest_y
, dest_x
+ width
, dest_y
+ height
);
1547 ForeColor (blackColor
);
1548 BackColor (whiteColor
);
1550 LockPixels (GetGWorldPixMap (src
));
1551 LockPixels (GetGWorldPixMap (mask
));
1552 #if TARGET_API_MAC_CARBON
1557 LockPortBits (port
);
1558 CopyMask (GetPortBitMapForCopyBits (src
), GetPortBitMapForCopyBits (mask
),
1559 GetPortBitMapForCopyBits (port
),
1560 &src_r
, &src_r
, &dest_r
);
1561 UnlockPortBits (port
);
1563 #else /* not TARGET_API_MAC_CARBON */
1564 CopyMask (&(((GrafPtr
)src
)->portBits
), &(((GrafPtr
)mask
)->portBits
),
1565 &(FRAME_MAC_WINDOW (f
)->portBits
), &src_r
, &src_r
, &dest_r
);
1566 #endif /* not TARGET_API_MAC_CARBON */
1567 UnlockPixels (GetGWorldPixMap (mask
));
1568 UnlockPixels (GetGWorldPixMap (src
));
1570 RGBBackColor (GC_BACK_COLOR (FRAME_NORMAL_GC (f
)));
1574 #endif /* !USE_CG_DRAWING */
1577 /* Mac replacement for XCopyArea: used only for scrolling. */
1580 mac_scroll_area (f
, gc
, src_x
, src_y
, width
, height
, dest_x
, dest_y
)
1584 unsigned int width
, height
;
1587 #if TARGET_API_MAC_CARBON
1589 RgnHandle dummy
= NewRgn (); /* For avoiding update events. */
1591 SetRect (&src_r
, src_x
, src_y
, src_x
+ width
, src_y
+ height
);
1593 mac_prepare_for_quickdraw (f
);
1595 ScrollWindowRect (FRAME_MAC_WINDOW (f
),
1596 &src_r
, dest_x
- src_x
, dest_y
- src_y
,
1597 kScrollWindowNoOptions
, dummy
);
1599 #else /* not TARGET_API_MAC_CARBON */
1601 WindowRef w
= FRAME_MAC_WINDOW (f
);
1603 mac_begin_clip (f
, gc
);
1605 SetRect (&src_r
, src_x
, src_y
, src_x
+ width
, src_y
+ height
);
1606 SetRect (&dest_r
, dest_x
, dest_y
, dest_x
+ width
, dest_y
+ height
);
1608 /* In Color QuickDraw, set ForeColor and BackColor as follows to avoid
1609 color mapping in CopyBits. Otherwise, it will be slow. */
1610 ForeColor (blackColor
);
1611 BackColor (whiteColor
);
1612 CopyBits (&(w
->portBits
), &(w
->portBits
), &src_r
, &dest_r
, srcCopy
, 0);
1614 RGBBackColor (GC_BACK_COLOR (FRAME_NORMAL_GC (f
)));
1617 #endif /* not TARGET_API_MAC_CARBON */
1621 /* Mac replacement for XChangeGC. */
1624 XChangeGC (display
, gc
, mask
, xgcv
)
1630 if (mask
& GCForeground
)
1631 XSetForeground (display
, gc
, xgcv
->foreground
);
1632 if (mask
& GCBackground
)
1633 XSetBackground (display
, gc
, xgcv
->background
);
1635 XSetFont (display
, gc
, xgcv
->font
);
1639 /* Mac replacement for XCreateGC. */
1642 XCreateGC (display
, d
, mask
, xgcv
)
1648 GC gc
= xmalloc (sizeof (*gc
));
1650 bzero (gc
, sizeof (*gc
));
1651 #if USE_CG_DRAWING && MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
1652 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
1653 if (CGColorGetTypeID
!= NULL
)
1656 gc
->cg_fore_color
= gc
->cg_back_color
= mac_cg_color_black
;
1657 CGColorRetain (gc
->cg_fore_color
);
1658 CGColorRetain (gc
->cg_back_color
);
1661 XChangeGC (display
, gc
, mask
, xgcv
);
1667 /* Used in xfaces.c. */
1670 XFreeGC (display
, gc
)
1674 if (gc
->clip_region
)
1675 DisposeRgn (gc
->clip_region
);
1676 #if USE_CG_DRAWING && MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
1677 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
1678 if (CGColorGetTypeID
!= NULL
)
1681 CGColorRelease (gc
->cg_fore_color
);
1682 CGColorRelease (gc
->cg_back_color
);
1689 /* Mac replacement for XGetGCValues. */
1692 XGetGCValues (display
, gc
, mask
, xgcv
)
1698 if (mask
& GCForeground
)
1699 xgcv
->foreground
= gc
->xgcv
.foreground
;
1700 if (mask
& GCBackground
)
1701 xgcv
->background
= gc
->xgcv
.background
;
1703 xgcv
->font
= gc
->xgcv
.font
;
1707 /* Mac replacement for XSetForeground. */
1710 XSetForeground (display
, gc
, color
)
1713 unsigned long color
;
1715 if (gc
->xgcv
.foreground
!= color
)
1717 gc
->xgcv
.foreground
= color
;
1718 gc
->fore_color
.red
= RED16_FROM_ULONG (color
);
1719 gc
->fore_color
.green
= GREEN16_FROM_ULONG (color
);
1720 gc
->fore_color
.blue
= BLUE16_FROM_ULONG (color
);
1721 #if USE_CG_DRAWING && MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
1722 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
1723 if (CGColorGetTypeID
!= NULL
)
1726 CGColorRelease (gc
->cg_fore_color
);
1729 gc
->cg_fore_color
= mac_cg_color_black
;
1730 CGColorRetain (gc
->cg_fore_color
);
1736 rgba
[0] = gc
->fore_color
.red
/ 65535.0f
;
1737 rgba
[1] = gc
->fore_color
.green
/ 65535.0f
;
1738 rgba
[2] = gc
->fore_color
.blue
/ 65535.0f
;
1740 gc
->cg_fore_color
= CGColorCreate (mac_cg_color_space_rgb
, rgba
);
1748 /* Mac replacement for XSetBackground. */
1751 XSetBackground (display
, gc
, color
)
1754 unsigned long color
;
1756 if (gc
->xgcv
.background
!= color
)
1758 gc
->xgcv
.background
= color
;
1759 gc
->back_color
.red
= RED16_FROM_ULONG (color
);
1760 gc
->back_color
.green
= GREEN16_FROM_ULONG (color
);
1761 gc
->back_color
.blue
= BLUE16_FROM_ULONG (color
);
1762 #if USE_CG_DRAWING && MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
1763 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
1764 if (CGColorGetTypeID
!= NULL
)
1767 CGColorRelease (gc
->cg_back_color
);
1770 gc
->cg_back_color
= mac_cg_color_black
;
1771 CGColorRetain (gc
->cg_back_color
);
1777 rgba
[0] = gc
->back_color
.red
/ 65535.0f
;
1778 rgba
[1] = gc
->back_color
.green
/ 65535.0f
;
1779 rgba
[2] = gc
->back_color
.blue
/ 65535.0f
;
1781 gc
->cg_back_color
= CGColorCreate (mac_cg_color_space_rgb
, rgba
);
1789 /* Mac replacement for XSetFont. */
1792 XSetFont (display
, gc
, font
)
1797 gc
->xgcv
.font
= font
;
1801 /* Mac replacement for XSetClipRectangles. */
1804 mac_set_clip_rectangles (display
, gc
, rectangles
, n
)
1812 xassert (n
>= 0 && n
<= MAX_CLIP_RECTS
);
1814 gc
->n_clip_rects
= n
;
1817 if (gc
->clip_region
== NULL
)
1818 gc
->clip_region
= NewRgn ();
1819 RectRgn (gc
->clip_region
, rectangles
);
1822 RgnHandle region
= NewRgn ();
1824 for (i
= 1; i
< n
; i
++)
1826 RectRgn (region
, rectangles
+ i
);
1827 UnionRgn (gc
->clip_region
, region
, gc
->clip_region
);
1829 DisposeRgn (region
);
1832 #if defined (MAC_OSX) && (USE_ATSUI || USE_CG_DRAWING)
1833 for (i
= 0; i
< n
; i
++)
1835 Rect
*rect
= rectangles
+ i
;
1837 gc
->clip_rects
[i
] = CGRectMake (rect
->left
, rect
->top
,
1838 rect
->right
- rect
->left
,
1839 rect
->bottom
- rect
->top
);
1845 /* Mac replacement for XSetClipMask. */
1848 mac_reset_clip_rectangles (display
, gc
)
1852 gc
->n_clip_rects
= 0;
1856 /* Mac replacement for XSetWindowBackground. */
1859 XSetWindowBackground (display
, w
, color
)
1862 unsigned long color
;
1864 #if !TARGET_API_MAC_CARBON
1865 AuxWinHandle aw_handle
;
1866 CTabHandle ctab_handle
;
1867 ColorSpecPtr ct_table
;
1872 bg_color
.red
= RED16_FROM_ULONG (color
);
1873 bg_color
.green
= GREEN16_FROM_ULONG (color
);
1874 bg_color
.blue
= BLUE16_FROM_ULONG (color
);
1876 #if TARGET_API_MAC_CARBON
1877 SetWindowContentColor (w
, &bg_color
);
1879 if (GetAuxWin (w
, &aw_handle
))
1881 ctab_handle
= (*aw_handle
)->awCTable
;
1882 HandToHand ((Handle
*) &ctab_handle
);
1883 ct_table
= (*ctab_handle
)->ctTable
;
1884 ct_size
= (*ctab_handle
)->ctSize
;
1885 while (ct_size
> -1)
1887 if (ct_table
->value
== 0)
1889 ct_table
->rgb
= bg_color
;
1890 CTabChanged (ctab_handle
);
1891 SetWinColor (w
, (WCTabHandle
) ctab_handle
);
1899 /* Flush display of frame F, or of all frames if F is null. */
1905 #if TARGET_API_MAC_CARBON
1908 mac_prepare_for_quickdraw (f
);
1911 QDFlushPortBuffer (GetWindowPort (FRAME_MAC_WINDOW (f
)), NULL
);
1913 QDFlushPortBuffer (GetQDGlobalsThePort (), NULL
);
1919 /* Remove calls to XFlush by defining XFlush to an empty replacement.
1920 Calls to XFlush should be unnecessary because the X output buffer
1921 is flushed automatically as needed by calls to XPending,
1922 XNextEvent, or XWindowEvent according to the XFlush man page.
1923 XTread_socket calls XPending. Removing XFlush improves
1926 #define XFlush(DISPLAY) (void) 0
1930 mac_flush_display_optional (f
)
1934 mac_prepare_for_quickdraw (f
);
1939 /***********************************************************************
1940 Starting and ending an update
1941 ***********************************************************************/
1943 /* Start an update of frame F. This function is installed as a hook
1944 for update_begin, i.e. it is called when update_begin is called.
1945 This function is called prior to calls to x_update_window_begin for
1946 each window being updated. */
1952 #if TARGET_API_MAC_CARBON
1953 /* During update of a frame, availability of input events is
1954 periodically checked with ReceiveNextEvent if
1955 redisplay-dont-pause is nil. That normally flushes window buffer
1956 changes for every check, and thus screen update looks waving even
1957 if no input is available. So we disable screen updates during
1958 update of a frame. */
1960 DisableScreenUpdates ();
1966 /* Start update of window W. Set the global variable updated_window
1967 to the window being updated and set output_cursor to the cursor
1971 x_update_window_begin (w
)
1974 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1975 struct mac_display_info
*display_info
= FRAME_MAC_DISPLAY_INFO (f
);
1978 set_output_cursor (&w
->cursor
);
1982 if (f
== display_info
->mouse_face_mouse_frame
)
1984 /* Don't do highlighting for mouse motion during the update. */
1985 display_info
->mouse_face_defer
= 1;
1987 /* If F needs to be redrawn, simply forget about any prior mouse
1989 if (FRAME_GARBAGED_P (f
))
1990 display_info
->mouse_face_window
= Qnil
;
1992 #if 0 /* Rows in a current matrix containing glyphs in mouse-face have
1993 their mouse_face_p flag set, which means that they are always
1994 unequal to rows in a desired matrix which never have that
1995 flag set. So, rows containing mouse-face glyphs are never
1996 scrolled, and we don't have to switch the mouse highlight off
1997 here to prevent it from being scrolled. */
1999 /* Can we tell that this update does not affect the window
2000 where the mouse highlight is? If so, no need to turn off.
2001 Likewise, don't do anything if the frame is garbaged;
2002 in that case, the frame's current matrix that we would use
2003 is all wrong, and we will redisplay that line anyway. */
2004 if (!NILP (display_info
->mouse_face_window
)
2005 && w
== XWINDOW (display_info
->mouse_face_window
))
2009 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
2010 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
2013 if (i
< w
->desired_matrix
->nrows
)
2014 clear_mouse_face (display_info
);
2023 /* Draw a vertical window border from (x,y0) to (x,y1) */
2026 mac_draw_vertical_window_border (w
, x
, y0
, y1
)
2030 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2033 face
= FACE_FROM_ID (f
, VERTICAL_BORDER_FACE_ID
);
2035 XSetForeground (FRAME_MAC_DISPLAY (f
), f
->output_data
.mac
->normal_gc
,
2038 mac_draw_line (f
, f
->output_data
.mac
->normal_gc
, x
, y0
, x
, y1
);
2041 /* End update of window W (which is equal to updated_window).
2043 Draw vertical borders between horizontally adjacent windows, and
2044 display W's cursor if CURSOR_ON_P is non-zero.
2046 MOUSE_FACE_OVERWRITTEN_P non-zero means that some row containing
2047 glyphs in mouse-face were overwritten. In that case we have to
2048 make sure that the mouse-highlight is properly redrawn.
2050 W may be a menu bar pseudo-window in case we don't have X toolkit
2051 support. Such windows don't have a cursor, so don't display it
2055 x_update_window_end (w
, cursor_on_p
, mouse_face_overwritten_p
)
2057 int cursor_on_p
, mouse_face_overwritten_p
;
2059 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (XFRAME (w
->frame
));
2061 if (!w
->pseudo_window_p
)
2066 display_and_set_cursor (w
, 1, output_cursor
.hpos
,
2068 output_cursor
.x
, output_cursor
.y
);
2070 if (draw_window_fringes (w
, 1))
2071 x_draw_vertical_border (w
);
2076 /* If a row with mouse-face was overwritten, arrange for
2077 XTframe_up_to_date to redisplay the mouse highlight. */
2078 if (mouse_face_overwritten_p
)
2080 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
2081 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
2082 dpyinfo
->mouse_face_window
= Qnil
;
2085 updated_window
= NULL
;
2089 /* End update of frame F. This function is installed as a hook in
2096 /* Mouse highlight may be displayed again. */
2097 FRAME_MAC_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
2100 #if TARGET_API_MAC_CARBON
2101 EnableScreenUpdates ();
2103 XFlush (FRAME_MAC_DISPLAY (f
));
2108 /* This function is called from various places in xdisp.c whenever a
2109 complete update has been performed. The global variable
2110 updated_window is not available here. */
2113 XTframe_up_to_date (f
)
2116 if (FRAME_MAC_P (f
))
2118 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
2120 if (dpyinfo
->mouse_face_deferred_gc
2121 || f
== dpyinfo
->mouse_face_mouse_frame
)
2124 if (dpyinfo
->mouse_face_mouse_frame
)
2125 note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
2126 dpyinfo
->mouse_face_mouse_x
,
2127 dpyinfo
->mouse_face_mouse_y
);
2128 dpyinfo
->mouse_face_deferred_gc
= 0;
2135 /* Draw truncation mark bitmaps, continuation mark bitmaps, overlay
2136 arrow bitmaps, or clear the fringes if no bitmaps are required
2137 before DESIRED_ROW is made current. The window being updated is
2138 found in updated_window. This function is called from
2139 update_window_line only if it is known that there are differences
2140 between bitmaps to be drawn between current row and DESIRED_ROW. */
2143 x_after_update_window_line (desired_row
)
2144 struct glyph_row
*desired_row
;
2146 struct window
*w
= updated_window
;
2152 if (!desired_row
->mode_line_p
&& !w
->pseudo_window_p
)
2153 desired_row
->redraw_fringe_bitmaps_p
= 1;
2155 /* When a window has disappeared, make sure that no rest of
2156 full-width rows stays visible in the internal border. Could
2157 check here if updated_window is the leftmost/rightmost window,
2158 but I guess it's not worth doing since vertically split windows
2159 are almost never used, internal border is rarely set, and the
2160 overhead is very small. */
2161 if (windows_or_buffers_changed
2162 && desired_row
->full_width_p
2163 && (f
= XFRAME (w
->frame
),
2164 width
= FRAME_INTERNAL_BORDER_WIDTH (f
),
2166 && (height
= desired_row
->visible_height
,
2169 int y
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (0, desired_row
->y
));
2171 /* Internal border is drawn below the tool bar. */
2172 if (WINDOWP (f
->tool_bar_window
)
2173 && w
== XWINDOW (f
->tool_bar_window
))
2177 mac_clear_area (f
, 0, y
, width
, height
);
2178 mac_clear_area (f
, FRAME_PIXEL_WIDTH (f
) - width
, y
, width
, height
);
2184 /* Draw the bitmap WHICH in one of the left or right fringes of
2185 window W. ROW is the glyph row for which to display the bitmap; it
2186 determines the vertical position at which the bitmap has to be
2190 x_draw_fringe_bitmap (w
, row
, p
)
2192 struct glyph_row
*row
;
2193 struct draw_fringe_bitmap_params
*p
;
2195 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2196 Display
*display
= FRAME_MAC_DISPLAY (f
);
2197 struct face
*face
= p
->face
;
2199 int overlay_p
= p
->overlay_p
;
2204 int bx
= p
->bx
, by
= p
->by
, nx
= p
->nx
, ny
= p
->ny
;
2206 #if 0 /* MAC_TODO: stipple */
2207 /* In case the same realized face is used for fringes and
2208 for something displayed in the text (e.g. face `region' on
2209 mono-displays, the fill style may have been changed to
2210 FillSolid in x_draw_glyph_string_background. */
2212 XSetFillStyle (FRAME_X_DISPLAY (f
), face
->gc
, FillOpaqueStippled
);
2214 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->background
);
2217 /* If the fringe is adjacent to the left (right) scroll bar of a
2218 leftmost (rightmost, respectively) window, then extend its
2219 background to the gap between the fringe and the bar. */
2220 if ((WINDOW_LEFTMOST_P (w
)
2221 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
2222 || (WINDOW_RIGHTMOST_P (w
)
2223 && WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
)))
2225 int sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
2229 int left
= WINDOW_SCROLL_BAR_AREA_X (w
);
2230 int width
= (WINDOW_CONFIG_SCROLL_BAR_COLS (w
)
2231 * FRAME_COLUMN_WIDTH (f
));
2234 && (left
+ width
== p
->x
2235 || p
->x
+ p
->wd
== left
))
2237 /* Bitmap fills the fringe and we need background
2239 int header_line_height
= WINDOW_HEADER_LINE_HEIGHT (w
);
2243 by
= WINDOW_TO_FRAME_PIXEL_Y (w
, max (header_line_height
,
2245 ny
= row
->visible_height
;
2250 if (left
+ width
== bx
)
2252 bx
= left
+ sb_width
;
2253 nx
+= width
- sb_width
;
2255 else if (bx
+ nx
== left
)
2256 nx
+= width
- sb_width
;
2263 mac_erase_rectangle (f
, face
->gc
, bx
, by
, nx
, ny
);
2264 /* The fringe background has already been filled. */
2268 #if 0 /* MAC_TODO: stipple */
2270 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->foreground
);
2273 #endif /* MAC_OSX */
2275 /* Must clip because of partially visible lines. */
2276 rowY
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
2279 /* Adjust position of "bottom aligned" bitmap on partially
2280 visible last row. */
2282 int oldVH
= row
->visible_height
;
2283 row
->visible_height
= p
->h
;
2284 row
->y
-= rowY
- p
->y
;
2285 x_clip_to_row (w
, row
, -1, face
->gc
);
2287 row
->visible_height
= oldVH
;
2290 x_clip_to_row (w
, row
, -1, face
->gc
);
2293 if (p
->bx
>= 0 && !p
->overlay_p
)
2295 #if 0 /* MAC_TODO: stipple */
2296 /* In case the same realized face is used for fringes and
2297 for something displayed in the text (e.g. face `region' on
2298 mono-displays, the fill style may have been changed to
2299 FillSolid in x_draw_glyph_string_background. */
2301 XSetFillStyle (FRAME_X_DISPLAY (f
), face
->gc
, FillOpaqueStippled
);
2303 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->background
);
2306 mac_erase_rectangle (f
, face
->gc
, p
->bx
, p
->by
, p
->nx
, p
->ny
);
2308 #if 0 /* MAC_TODO: stipple */
2310 XSetForeground (FRAME_X_DISPLAY (f
), face
->gc
, face
->foreground
);
2313 #endif /* !MAC_OSX */
2317 && p
->which
< max_fringe_bmp
2323 XGetGCValues (display
, face
->gc
, GCForeground
, &gcv
);
2324 XSetForeground (display
, face
->gc
,
2326 ? (p
->overlay_p
? face
->background
2327 : f
->output_data
.mac
->cursor_pixel
)
2328 : face
->foreground
));
2330 mac_draw_cg_image (fringe_bmp
[p
->which
], f
, face
->gc
, 0, p
->dh
,
2331 p
->wd
, p
->h
, p
->x
, p
->y
, overlay_p
);
2333 mac_draw_bitmap (f
, face
->gc
, p
->x
, p
->y
,
2334 p
->wd
, p
->h
, p
->bits
+ p
->dh
, overlay_p
);
2336 XSetForeground (display
, face
->gc
, gcv
.foreground
);
2339 mac_reset_clip_rectangles (display
, face
->gc
);
2344 mac_define_fringe_bitmap (which
, bits
, h
, wd
)
2346 unsigned short *bits
;
2350 CGDataProviderRef provider
;
2352 if (which
>= max_fringe_bmp
)
2355 max_fringe_bmp
= which
+ 20;
2356 fringe_bmp
= (CGImageRef
*) xrealloc (fringe_bmp
, max_fringe_bmp
* sizeof (CGImageRef
));
2357 while (i
< max_fringe_bmp
)
2358 fringe_bmp
[i
++] = 0;
2361 for (i
= 0; i
< h
; i
++)
2366 provider
= CGDataProviderCreateWithData (NULL
, bits
,
2367 sizeof (unsigned short) * h
, NULL
);
2370 fringe_bmp
[which
] = CGImageMaskCreate (wd
, h
, 1, 1,
2371 sizeof (unsigned short),
2373 CGDataProviderRelease (provider
);
2380 mac_destroy_fringe_bitmap (which
)
2383 if (which
>= max_fringe_bmp
)
2386 if (fringe_bmp
[which
])
2389 CGImageRelease (fringe_bmp
[which
]);
2392 fringe_bmp
[which
] = 0;
2397 /* This is called when starting Emacs and when restarting after
2398 suspend. When starting Emacs, no window is mapped. And nothing
2399 must be done to Emacs's own window if it is suspended (though that
2403 XTset_terminal_modes (struct terminal
*t
)
2407 /* This is called when exiting or suspending Emacs. Exiting will make
2408 the windows go away, and suspending requires no action. */
2411 XTreset_terminal_modes (struct terminal
*t
)
2417 /***********************************************************************
2419 ***********************************************************************/
2421 /* Function prototypes of this page. */
2423 static XCharStruct
*x_per_char_metric
P_ ((XFontStruct
*, XChar2b
*));
2424 static int mac_encode_char
P_ ((int, XChar2b
*, struct font_info
*, int *));
2428 pcm_init (pcm
, count
)
2432 bzero (pcm
, sizeof (XCharStruct
) * count
);
2433 while (--count
>= 0)
2435 pcm
->descent
= PCM_INVALID
;
2440 static enum pcm_status
2441 pcm_get_status (pcm
)
2442 const XCharStruct
*pcm
;
2444 int height
= pcm
->ascent
+ pcm
->descent
;
2446 /* Negative height means some special status. */
2447 return height
>= 0 ? PCM_VALID
: height
;
2450 /* Get metrics of character CHAR2B in FONT. Value is null if CHAR2B
2451 is not contained in the font. */
2453 static INLINE XCharStruct
*
2454 x_per_char_metric (font
, char2b
)
2458 /* The result metric information. */
2459 XCharStruct
*pcm
= NULL
;
2461 xassert (font
&& char2b
);
2464 if (font
->mac_style
)
2466 XCharStruct
**row
= font
->bounds
.rows
+ char2b
->byte1
;
2470 *row
= xmalloc (sizeof (XCharStruct
) * 0x100);
2471 pcm_init (*row
, 0x100);
2473 pcm
= *row
+ char2b
->byte2
;
2474 if (pcm_get_status (pcm
) != PCM_VALID
)
2477 mac_query_char_extents (font
->mac_style
,
2478 (char2b
->byte1
<< 8) + char2b
->byte2
,
2479 NULL
, NULL
, pcm
, NULL
);
2486 if (font
->bounds
.per_char
!= NULL
)
2488 if (font
->min_byte1
== 0 && font
->max_byte1
== 0)
2490 /* min_char_or_byte2 specifies the linear character index
2491 corresponding to the first element of the per_char array,
2492 max_char_or_byte2 is the index of the last character. A
2493 character with non-zero CHAR2B->byte1 is not in the font.
2494 A character with byte2 less than min_char_or_byte2 or
2495 greater max_char_or_byte2 is not in the font. */
2496 if (char2b
->byte1
== 0
2497 && char2b
->byte2
>= font
->min_char_or_byte2
2498 && char2b
->byte2
<= font
->max_char_or_byte2
)
2499 pcm
= font
->bounds
.per_char
2500 + (char2b
->byte2
- font
->min_char_or_byte2
);
2504 /* If either min_byte1 or max_byte1 are nonzero, both
2505 min_char_or_byte2 and max_char_or_byte2 are less than
2506 256, and the 2-byte character index values corresponding
2507 to the per_char array element N (counting from 0) are:
2509 byte1 = N/D + min_byte1
2510 byte2 = N\D + min_char_or_byte2
2514 D = max_char_or_byte2 - min_char_or_byte2 + 1
2515 / = integer division
2516 \ = integer modulus */
2517 if (char2b
->byte1
>= font
->min_byte1
2518 && char2b
->byte1
<= font
->max_byte1
2519 && char2b
->byte2
>= font
->min_char_or_byte2
2520 && char2b
->byte2
<= font
->max_char_or_byte2
)
2522 pcm
= (font
->bounds
.per_char
2523 + ((font
->max_char_or_byte2
- font
->min_char_or_byte2
+ 1)
2524 * (char2b
->byte1
- font
->min_byte1
))
2525 + (char2b
->byte2
- font
->min_char_or_byte2
));
2531 /* If the per_char pointer is null, all glyphs between the first
2532 and last character indexes inclusive have the same
2533 information, as given by both min_bounds and max_bounds. */
2534 if (char2b
->byte2
>= font
->min_char_or_byte2
2535 && char2b
->byte2
<= font
->max_char_or_byte2
)
2536 pcm
= &font
->max_bounds
;
2542 return ((pcm
== NULL
2544 #if 0 /* Show hollow boxes for zero-width glyphs such as combining diacritics. */
2545 && (pcm
->rbearing
- pcm
->lbearing
) == 0
2554 static XCharStruct
*
2555 mac_per_char_metric (font
, char2b
, font_type
)
2560 return x_per_char_metric (font
, char2b
);
2564 Encode CHAR2B using encoding information from FONT_INFO. CHAR2B is
2565 the two-byte form of C. Encoding is returned in *CHAR2B. */
2568 mac_encode_char (c
, char2b
, font_info
, two_byte_p
)
2571 struct font_info
*font_info
;
2574 int charset
= CHAR_CHARSET (c
);
2575 XFontStruct
*font
= font_info
->font
;
2577 /* FONT_INFO may define a scheme by which to encode byte1 and byte2.
2578 This may be either a program in a special encoder language or a
2580 if (font_info
->font_encoder
)
2582 /* It's a program. */
2583 struct ccl_program
*ccl
= font_info
->font_encoder
;
2585 check_ccl_update (ccl
);
2586 if (CHARSET_DIMENSION (charset
) == 1)
2588 ccl
->reg
[0] = charset
;
2589 ccl
->reg
[1] = char2b
->byte2
;
2594 ccl
->reg
[0] = charset
;
2595 ccl
->reg
[1] = char2b
->byte1
;
2596 ccl
->reg
[2] = char2b
->byte2
;
2599 ccl_driver (ccl
, NULL
, NULL
, 0, 0, NULL
);
2601 /* We assume that MSBs are appropriately set/reset by CCL
2603 if (font
->max_byte1
== 0) /* 1-byte font */
2604 char2b
->byte1
= 0, char2b
->byte2
= ccl
->reg
[1];
2606 char2b
->byte1
= ccl
->reg
[1], char2b
->byte2
= ccl
->reg
[2];
2608 else if (font_info
->encoding
[charset
])
2610 /* Fixed encoding scheme. See fontset.h for the meaning of the
2611 encoding numbers. */
2612 int enc
= font_info
->encoding
[charset
];
2614 if ((enc
== 1 || enc
== 2)
2615 && CHARSET_DIMENSION (charset
) == 2)
2616 char2b
->byte1
|= 0x80;
2618 if (enc
== 1 || enc
== 3)
2619 char2b
->byte2
|= 0x80;
2625 ENCODE_SJIS (char2b
->byte1
, char2b
->byte2
, sjis1
, sjis2
);
2626 char2b
->byte1
= sjis1
;
2627 char2b
->byte2
= sjis2
;
2632 *two_byte_p
= ((XFontStruct
*) (font_info
->font
))->max_byte1
> 0;
2634 return FONT_TYPE_UNKNOWN
;
2639 /***********************************************************************
2641 ***********************************************************************/
2645 static void x_set_glyph_string_clipping
P_ ((struct glyph_string
*));
2646 static void x_set_glyph_string_gc
P_ ((struct glyph_string
*));
2647 static void x_draw_glyph_string_background
P_ ((struct glyph_string
*,
2649 static void x_draw_glyph_string_foreground
P_ ((struct glyph_string
*));
2650 static void x_draw_composite_glyph_string_foreground
P_ ((struct glyph_string
*));
2651 static void x_draw_glyph_string_box
P_ ((struct glyph_string
*));
2652 static void x_draw_glyph_string
P_ ((struct glyph_string
*));
2653 static void mac_compute_glyph_string_overhangs
P_ ((struct glyph_string
*));
2654 static void x_set_cursor_gc
P_ ((struct glyph_string
*));
2655 static void x_set_mode_line_face_gc
P_ ((struct glyph_string
*));
2656 static void x_set_mouse_face_gc
P_ ((struct glyph_string
*));
2657 /*static int x_alloc_lighter_color P_ ((struct frame *, Display *, Colormap,
2658 unsigned long *, double, int));*/
2659 static void x_setup_relief_color
P_ ((struct frame
*, struct relief
*,
2660 double, int, unsigned long));
2661 static void x_setup_relief_colors
P_ ((struct glyph_string
*));
2662 static void x_draw_image_glyph_string
P_ ((struct glyph_string
*));
2663 static void x_draw_image_relief
P_ ((struct glyph_string
*));
2664 static void x_draw_image_foreground
P_ ((struct glyph_string
*));
2665 static void x_clear_glyph_string_rect
P_ ((struct glyph_string
*, int,
2667 static void x_draw_relief_rect
P_ ((struct frame
*, int, int, int, int,
2668 int, int, int, int, int, int,
2670 static void x_draw_box_rect
P_ ((struct glyph_string
*, int, int, int, int,
2671 int, int, int, Rect
*));
2674 static void x_check_font
P_ ((struct frame
*, XFontStruct
*));
2678 /* Set S->gc to a suitable GC for drawing glyph string S in cursor
2683 struct glyph_string
*s
;
2685 if (s
->font
== FRAME_FONT (s
->f
)
2686 && s
->face
->background
== FRAME_BACKGROUND_PIXEL (s
->f
)
2687 && s
->face
->foreground
== FRAME_FOREGROUND_PIXEL (s
->f
)
2689 s
->gc
= s
->f
->output_data
.mac
->cursor_gc
;
2692 /* Cursor on non-default face: must merge. */
2696 xgcv
.background
= s
->f
->output_data
.mac
->cursor_pixel
;
2697 xgcv
.foreground
= s
->face
->background
;
2699 /* If the glyph would be invisible, try a different foreground. */
2700 if (xgcv
.foreground
== xgcv
.background
)
2701 xgcv
.foreground
= s
->face
->foreground
;
2702 if (xgcv
.foreground
== xgcv
.background
)
2703 xgcv
.foreground
= s
->f
->output_data
.mac
->cursor_foreground_pixel
;
2704 if (xgcv
.foreground
== xgcv
.background
)
2705 xgcv
.foreground
= s
->face
->foreground
;
2707 /* Make sure the cursor is distinct from text in this face. */
2708 if (xgcv
.background
== s
->face
->background
2709 && xgcv
.foreground
== s
->face
->foreground
)
2711 xgcv
.background
= s
->face
->foreground
;
2712 xgcv
.foreground
= s
->face
->background
;
2715 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2716 xgcv
.font
= s
->font
;
2717 mask
= GCForeground
| GCBackground
| GCFont
;
2719 if (FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2720 XChangeGC (s
->display
, FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2723 FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2724 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
2726 s
->gc
= FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2731 /* Set up S->gc of glyph string S for drawing text in mouse face. */
2734 x_set_mouse_face_gc (s
)
2735 struct glyph_string
*s
;
2740 /* What face has to be used last for the mouse face? */
2741 face_id
= FRAME_X_DISPLAY_INFO (s
->f
)->mouse_face_face_id
;
2742 face
= FACE_FROM_ID (s
->f
, face_id
);
2744 face
= FACE_FROM_ID (s
->f
, MOUSE_FACE_ID
);
2746 if (s
->first_glyph
->type
== CHAR_GLYPH
)
2747 face_id
= FACE_FOR_CHAR (s
->f
, face
, s
->first_glyph
->u
.ch
);
2749 face_id
= FACE_FOR_CHAR (s
->f
, face
, 0);
2750 s
->face
= FACE_FROM_ID (s
->f
, face_id
);
2751 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
2753 /* If font in this face is same as S->font, use it. */
2754 if (s
->font
== s
->face
->font
)
2755 s
->gc
= s
->face
->gc
;
2758 /* Otherwise construct scratch_cursor_gc with values from FACE
2763 xgcv
.background
= s
->face
->background
;
2764 xgcv
.foreground
= s
->face
->foreground
;
2765 IF_DEBUG (x_check_font (s
->f
, s
->font
));
2766 xgcv
.font
= s
->font
;
2767 mask
= GCForeground
| GCBackground
| GCFont
;
2769 if (FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
)
2770 XChangeGC (s
->display
, FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
,
2773 FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
2774 = XCreateGC (s
->display
, s
->window
, mask
, &xgcv
);
2776 s
->gc
= FRAME_MAC_DISPLAY_INFO (s
->f
)->scratch_cursor_gc
;
2779 xassert (s
->gc
!= 0);
2783 /* Set S->gc of glyph string S to a GC suitable for drawing a mode line.
2784 Faces to use in the mode line have already been computed when the
2785 matrix was built, so there isn't much to do, here. */
2788 x_set_mode_line_face_gc (s
)
2789 struct glyph_string
*s
;
2791 s
->gc
= s
->face
->gc
;
2795 /* Set S->gc of glyph string S for drawing that glyph string. Set
2796 S->stippled_p to a non-zero value if the face of S has a stipple
2800 x_set_glyph_string_gc (s
)
2801 struct glyph_string
*s
;
2803 PREPARE_FACE_FOR_DISPLAY (s
->f
, s
->face
);
2805 if (s
->hl
== DRAW_NORMAL_TEXT
)
2807 s
->gc
= s
->face
->gc
;
2808 s
->stippled_p
= s
->face
->stipple
!= 0;
2810 else if (s
->hl
== DRAW_INVERSE_VIDEO
)
2812 x_set_mode_line_face_gc (s
);
2813 s
->stippled_p
= s
->face
->stipple
!= 0;
2815 else if (s
->hl
== DRAW_CURSOR
)
2817 x_set_cursor_gc (s
);
2820 else if (s
->hl
== DRAW_MOUSE_FACE
)
2822 x_set_mouse_face_gc (s
);
2823 s
->stippled_p
= s
->face
->stipple
!= 0;
2825 else if (s
->hl
== DRAW_IMAGE_RAISED
2826 || s
->hl
== DRAW_IMAGE_SUNKEN
)
2828 s
->gc
= s
->face
->gc
;
2829 s
->stippled_p
= s
->face
->stipple
!= 0;
2833 s
->gc
= s
->face
->gc
;
2834 s
->stippled_p
= s
->face
->stipple
!= 0;
2837 /* GC must have been set. */
2838 xassert (s
->gc
!= 0);
2842 /* Set clipping for output of glyph string S. S may be part of a mode
2843 line or menu if we don't have X toolkit support. */
2846 x_set_glyph_string_clipping (s
)
2847 struct glyph_string
*s
;
2849 Rect rects
[MAX_CLIP_RECTS
];
2852 n
= get_glyph_string_clip_rects (s
, rects
, MAX_CLIP_RECTS
);
2853 mac_set_clip_rectangles (s
->display
, s
->gc
, rects
, n
);
2858 Compute left and right overhang of glyph string S. If S is a glyph
2859 string for a composition, assume overhangs don't exist. */
2862 mac_compute_glyph_string_overhangs (s
)
2863 struct glyph_string
*s
;
2865 if (!(s
->cmp
== NULL
2866 && s
->first_glyph
->type
== CHAR_GLYPH
))
2871 || s
->font
->mac_style
2877 mac_text_extents_16 (s
->font
, s
->char2b
, s
->nchars
, &cs
);
2878 s
->right_overhang
= cs
.rbearing
> cs
.width
? cs
.rbearing
- cs
.width
: 0;
2879 s
->left_overhang
= cs
.lbearing
< 0 ? -cs
.lbearing
: 0;
2884 MacFontStruct
*font
= s
->font
;
2887 mac_prepare_for_quickdraw (s
->f
);
2889 SetPortWindowPort (FRAME_MAC_WINDOW (s
->f
));
2891 TextFont (font
->mac_fontnum
);
2892 TextSize (font
->mac_fontsize
);
2893 TextFace (font
->mac_fontface
);
2895 QDTextBounds (s
->nchars
* 2, (char *)s
->char2b
, &r
);
2897 s
->right_overhang
= r
.right
> s
->width
? r
.right
- s
->width
: 0;
2898 s
->left_overhang
= r
.left
< 0 ? -r
.left
: 0;
2903 /* Fill rectangle X, Y, W, H with background color of glyph string S. */
2906 x_clear_glyph_string_rect (s
, x
, y
, w
, h
)
2907 struct glyph_string
*s
;
2910 mac_erase_rectangle (s
->f
, s
->gc
, x
, y
, w
, h
);
2914 /* Draw the background of glyph_string S. If S->background_filled_p
2915 is non-zero don't draw it. FORCE_P non-zero means draw the
2916 background even if it wouldn't be drawn normally. This is used
2917 when a string preceding S draws into the background of S, or S
2918 contains the first component of a composition. */
2921 x_draw_glyph_string_background (s
, force_p
)
2922 struct glyph_string
*s
;
2925 /* Nothing to do if background has already been drawn or if it
2926 shouldn't be drawn in the first place. */
2927 if (!s
->background_filled_p
)
2929 int box_line_width
= max (s
->face
->box_line_width
, 0);
2931 #if 0 /* MAC_TODO: stipple */
2934 /* Fill background with a stipple pattern. */
2935 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
2936 XFillRectangle (s
->display
, s
->window
, s
->gc
, s
->x
,
2937 s
->y
+ box_line_width
,
2938 s
->background_width
,
2939 s
->height
- 2 * box_line_width
);
2940 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
2941 s
->background_filled_p
= 1;
2945 if (FONT_HEIGHT (s
->font
) < s
->height
- 2 * box_line_width
2946 || s
->font_not_found_p
2947 || s
->extends_to_end_of_line_p
2950 x_clear_glyph_string_rect (s
, s
->x
, s
->y
+ box_line_width
,
2951 s
->background_width
,
2952 s
->height
- 2 * box_line_width
);
2953 s
->background_filled_p
= 1;
2959 /* Draw the foreground of glyph string S. */
2962 x_draw_glyph_string_foreground (s
)
2963 struct glyph_string
*s
;
2967 /* If first glyph of S has a left box line, start drawing the text
2968 of S to the right of that box line. */
2969 if (s
->face
->box
!= FACE_NO_BOX
2970 && s
->first_glyph
->left_box_line_p
)
2971 x
= s
->x
+ eabs (s
->face
->box_line_width
);
2975 /* Draw characters of S as rectangles if S's font could not be
2977 if (s
->font_not_found_p
)
2979 for (i
= 0; i
< s
->nchars
; ++i
)
2981 struct glyph
*g
= s
->first_glyph
+ i
;
2982 mac_draw_rectangle (s
->f
, s
->gc
, x
, s
->y
,
2983 g
->pixel_width
- 1, s
->height
- 1);
2984 x
+= g
->pixel_width
;
2989 char *char1b
= (char *) s
->char2b
;
2990 int boff
= s
->font_info
->baseline_offset
;
2992 if (s
->font_info
->vertical_centering
)
2993 boff
= VCENTER_BASELINE_OFFSET (s
->font
, s
->f
) - boff
;
2995 /* If we can use 8-bit functions, condense S->char2b. */
2998 && GC_FONT (s
->gc
)->mac_style
== NULL
3001 for (i
= 0; i
< s
->nchars
; ++i
)
3002 char1b
[i
] = s
->char2b
[i
].byte2
;
3004 /* Draw text with XDrawString if background has already been
3005 filled. Otherwise, use XDrawImageString. (Note that
3006 XDrawImageString is usually faster than XDrawString.) Always
3007 use XDrawImageString when drawing the cursor so that there is
3008 no chance that characters under a box cursor are invisible. */
3010 || (s
->background_filled_p
&& s
->hl
!= DRAW_CURSOR
))
3011 bg_width
= 0; /* Corresponds to XDrawString. */
3013 bg_width
= s
->background_width
; /* Corresponds to XDrawImageString. */
3017 || GC_FONT (s
->gc
)->mac_style
3020 #if USE_CG_TEXT_DRAWING
3022 && mac_draw_image_string_cg (s
->f
, s
->gc
, x
, s
->ybase
- boff
,
3023 s
->char2b
, s
->nchars
, bg_width
,
3024 s
->face
->overstrike
))
3028 mac_draw_image_string_16 (s
->f
, s
->gc
, x
, s
->ybase
- boff
,
3029 s
->char2b
, s
->nchars
, bg_width
,
3030 s
->face
->overstrike
);
3032 mac_draw_image_string (s
->f
, s
->gc
, x
, s
->ybase
- boff
,
3033 char1b
, s
->nchars
, bg_width
,
3034 s
->face
->overstrike
);
3038 /* Draw the foreground of composite glyph string S. */
3041 x_draw_composite_glyph_string_foreground (s
)
3042 struct glyph_string
*s
;
3046 /* If first glyph of S has a left box line, start drawing the text
3047 of S to the right of that box line. */
3048 if (s
->face
->box
!= FACE_NO_BOX
3049 && s
->first_glyph
->left_box_line_p
)
3050 x
= s
->x
+ eabs (s
->face
->box_line_width
);
3054 /* S is a glyph string for a composition. S->gidx is the index of
3055 the first character drawn for glyphs of this composition.
3056 S->gidx == 0 means we are drawing the very first character of
3057 this composition. */
3059 /* Draw a rectangle for the composition if the font for the very
3060 first character of the composition could not be loaded. */
3061 if (s
->font_not_found_p
)
3064 mac_draw_rectangle (s
->f
, s
->gc
, x
, s
->y
,
3065 s
->width
- 1, s
->height
- 1);
3069 for (i
= 0; i
< s
->nchars
; i
++, ++s
->gidx
)
3070 if (mac_per_char_metric (GC_FONT (s
->gc
), s
->char2b
+ i
, 0) == NULL
)
3071 /* This is a nonexistent or zero-width glyph such as a
3072 combining diacritic. Draw a rectangle. */
3073 mac_draw_rectangle (s
->f
, s
->gc
,
3074 x
+ s
->cmp
->offsets
[s
->gidx
* 2], s
->y
,
3075 FONT_WIDTH (GC_FONT (s
->gc
)) - 1, s
->height
- 1);
3077 mac_draw_image_string_16 (s
->f
, s
->gc
,
3078 x
+ s
->cmp
->offsets
[s
->gidx
* 2],
3079 s
->ybase
- s
->cmp
->offsets
[s
->gidx
* 2 + 1],
3080 s
->char2b
+ i
, 1, 0, s
->face
->overstrike
);
3085 #ifdef USE_X_TOOLKIT
3087 static struct frame
*x_frame_of_widget
P_ ((Widget
));
3090 /* Return the frame on which widget WIDGET is used.. Abort if frame
3091 cannot be determined. */
3093 static struct frame
*
3094 x_frame_of_widget (widget
)
3097 struct x_display_info
*dpyinfo
;
3101 dpyinfo
= x_display_info_for_display (XtDisplay (widget
));
3103 /* Find the top-level shell of the widget. Note that this function
3104 can be called when the widget is not yet realized, so XtWindow
3105 (widget) == 0. That's the reason we can't simply use
3106 x_any_window_to_frame. */
3107 while (!XtIsTopLevelShell (widget
))
3108 widget
= XtParent (widget
);
3110 /* Look for a frame with that top-level widget. Allocate the color
3111 on that frame to get the right gamma correction value. */
3112 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
3113 if (GC_FRAMEP (XCAR (tail
))
3114 && (f
= XFRAME (XCAR (tail
)),
3115 (f
->output_data
.nothing
!= 1
3116 && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
))
3117 && f
->output_data
.x
->widget
== widget
)
3124 /* Allocate the color COLOR->pixel on the screen and display of
3125 widget WIDGET in colormap CMAP. If an exact match cannot be
3126 allocated, try the nearest color available. Value is non-zero
3127 if successful. This is called from lwlib. */
3130 x_alloc_nearest_color_for_widget (widget
, cmap
, color
)
3135 struct frame
*f
= x_frame_of_widget (widget
);
3136 return x_alloc_nearest_color (f
, cmap
, color
);
3140 #endif /* USE_X_TOOLKIT */
3142 #if 0 /* MAC_TODO */
3144 /* Allocate the color COLOR->pixel on SCREEN of DISPLAY, colormap
3145 CMAP. If an exact match can't be allocated, try the nearest color
3146 available. Value is non-zero if successful. Set *COLOR to the
3150 x_alloc_nearest_color (f
, cmap
, color
)
3155 Display
*display
= FRAME_X_DISPLAY (f
);
3156 Screen
*screen
= FRAME_X_SCREEN (f
);
3159 gamma_correct (f
, color
);
3160 rc
= XAllocColor (display
, cmap
, color
);
3163 /* If we got to this point, the colormap is full, so we're going
3164 to try to get the next closest color. The algorithm used is
3165 a least-squares matching, which is what X uses for closest
3166 color matching with StaticColor visuals. */
3168 unsigned long nearest_delta
= ~0;
3169 int ncells
= XDisplayCells (display
, XScreenNumberOfScreen (screen
));
3170 XColor
*cells
= (XColor
*) alloca (ncells
* sizeof *cells
);
3172 for (i
= 0; i
< ncells
; ++i
)
3174 XQueryColors (display
, cmap
, cells
, ncells
);
3176 for (nearest
= i
= 0; i
< ncells
; ++i
)
3178 long dred
= (color
->red
>> 8) - (cells
[i
].red
>> 8);
3179 long dgreen
= (color
->green
>> 8) - (cells
[i
].green
>> 8);
3180 long dblue
= (color
->blue
>> 8) - (cells
[i
].blue
>> 8);
3181 unsigned long delta
= dred
* dred
+ dgreen
* dgreen
+ dblue
* dblue
;
3183 if (delta
< nearest_delta
)
3186 nearest_delta
= delta
;
3190 color
->red
= cells
[nearest
].red
;
3191 color
->green
= cells
[nearest
].green
;
3192 color
->blue
= cells
[nearest
].blue
;
3193 rc
= XAllocColor (display
, cmap
, color
);
3196 #ifdef DEBUG_X_COLORS
3198 register_color (color
->pixel
);
3199 #endif /* DEBUG_X_COLORS */
3205 /* Allocate color PIXEL on frame F. PIXEL must already be allocated.
3206 It's necessary to do this instead of just using PIXEL directly to
3207 get color reference counts right. */
3210 x_copy_color (f
, pixel
)
3212 unsigned long pixel
;
3216 color
.pixel
= pixel
;
3218 XQueryColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
3219 XAllocColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
), &color
);
3221 #ifdef DEBUG_X_COLORS
3222 register_color (pixel
);
3228 /* Allocate color PIXEL on display DPY. PIXEL must already be allocated.
3229 It's necessary to do this instead of just using PIXEL directly to
3230 get color reference counts right. */
3233 x_copy_dpy_color (dpy
, cmap
, pixel
)
3236 unsigned long pixel
;
3240 color
.pixel
= pixel
;
3242 XQueryColor (dpy
, cmap
, &color
);
3243 XAllocColor (dpy
, cmap
, &color
);
3245 #ifdef DEBUG_X_COLORS
3246 register_color (pixel
);
3251 #endif /* MAC_TODO */
3254 /* Brightness beyond which a color won't have its highlight brightness
3257 Nominally, highlight colors for `3d' faces are calculated by
3258 brightening an object's color by a constant scale factor, but this
3259 doesn't yield good results for dark colors, so for colors who's
3260 brightness is less than this value (on a scale of 0-255) have to
3261 use an additional additive factor.
3263 The value here is set so that the default menu-bar/mode-line color
3264 (grey75) will not have its highlights changed at all. */
3265 #define HIGHLIGHT_COLOR_DARK_BOOST_LIMIT 187
3268 /* Allocate a color which is lighter or darker than *COLOR by FACTOR
3269 or DELTA. Try a color with RGB values multiplied by FACTOR first.
3270 If this produces the same color as COLOR, try a color where all RGB
3271 values have DELTA added. Return the allocated color in *COLOR.
3272 DISPLAY is the X display, CMAP is the colormap to operate on.
3273 Value is non-zero if successful. */
3276 mac_alloc_lighter_color (f
, color
, factor
, delta
)
3278 unsigned long *color
;
3285 /* On Mac, RGB values are 0-255, not 0-65535, so scale delta. */
3288 /* Change RGB values by specified FACTOR. Avoid overflow! */
3289 xassert (factor
>= 0);
3290 new = RGB_TO_ULONG (min (0xff, (int) (factor
* RED_FROM_ULONG (*color
))),
3291 min (0xff, (int) (factor
* GREEN_FROM_ULONG (*color
))),
3292 min (0xff, (int) (factor
* BLUE_FROM_ULONG (*color
))));
3294 /* Calculate brightness of COLOR. */
3295 bright
= (2 * RED_FROM_ULONG (*color
) + 3 * GREEN_FROM_ULONG (*color
)
3296 + BLUE_FROM_ULONG (*color
)) / 6;
3298 /* We only boost colors that are darker than
3299 HIGHLIGHT_COLOR_DARK_BOOST_LIMIT. */
3300 if (bright
< HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
)
3301 /* Make an additive adjustment to NEW, because it's dark enough so
3302 that scaling by FACTOR alone isn't enough. */
3304 /* How far below the limit this color is (0 - 1, 1 being darker). */
3305 double dimness
= 1 - (double)bright
/ HIGHLIGHT_COLOR_DARK_BOOST_LIMIT
;
3306 /* The additive adjustment. */
3307 int min_delta
= delta
* dimness
* factor
/ 2;
3310 new = RGB_TO_ULONG (max (0, min (0xff, (int) (RED_FROM_ULONG (*color
)) - min_delta
)),
3311 max (0, min (0xff, (int) (GREEN_FROM_ULONG (*color
)) - min_delta
)),
3312 max (0, min (0xff, (int) (BLUE_FROM_ULONG (*color
)) - min_delta
)));
3314 new = RGB_TO_ULONG (max (0, min (0xff, (int) (min_delta
+ RED_FROM_ULONG (*color
)))),
3315 max (0, min (0xff, (int) (min_delta
+ GREEN_FROM_ULONG (*color
)))),
3316 max (0, min (0xff, (int) (min_delta
+ BLUE_FROM_ULONG (*color
)))));
3320 new = RGB_TO_ULONG (max (0, min (0xff, (int) (delta
+ RED_FROM_ULONG (*color
)))),
3321 max (0, min (0xff, (int) (delta
+ GREEN_FROM_ULONG (*color
)))),
3322 max (0, min (0xff, (int) (delta
+ BLUE_FROM_ULONG (*color
)))));
3324 /* MAC_TODO: Map to palette and retry with delta if same? */
3325 /* MAC_TODO: Free colors (if using palette)? */
3336 /* Set up the foreground color for drawing relief lines of glyph
3337 string S. RELIEF is a pointer to a struct relief containing the GC
3338 with which lines will be drawn. Use a color that is FACTOR or
3339 DELTA lighter or darker than the relief's background which is found
3340 in S->f->output_data.x->relief_background. If such a color cannot
3341 be allocated, use DEFAULT_PIXEL, instead. */
3344 x_setup_relief_color (f
, relief
, factor
, delta
, default_pixel
)
3346 struct relief
*relief
;
3349 unsigned long default_pixel
;
3352 struct mac_output
*di
= f
->output_data
.mac
;
3353 unsigned long mask
= GCForeground
;
3354 unsigned long pixel
;
3355 unsigned long background
= di
->relief_background
;
3356 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
3358 /* MAC_TODO: Free colors (if using palette)? */
3360 /* Allocate new color. */
3361 xgcv
.foreground
= default_pixel
;
3363 if (dpyinfo
->n_planes
!= 1
3364 && mac_alloc_lighter_color (f
, &pixel
, factor
, delta
))
3366 relief
->allocated_p
= 1;
3367 xgcv
.foreground
= relief
->pixel
= pixel
;
3370 if (relief
->gc
== 0)
3372 #if 0 /* MAC_TODO: stipple */
3373 xgcv
.stipple
= dpyinfo
->gray
;
3376 relief
->gc
= XCreateGC (NULL
, FRAME_MAC_WINDOW (f
), mask
, &xgcv
);
3379 XChangeGC (NULL
, relief
->gc
, mask
, &xgcv
);
3383 /* Set up colors for the relief lines around glyph string S. */
3386 x_setup_relief_colors (s
)
3387 struct glyph_string
*s
;
3389 struct mac_output
*di
= s
->f
->output_data
.mac
;
3390 unsigned long color
;
3392 if (s
->face
->use_box_color_for_shadows_p
)
3393 color
= s
->face
->box_color
;
3394 else if (s
->first_glyph
->type
== IMAGE_GLYPH
3396 && !IMAGE_BACKGROUND_TRANSPARENT (s
->img
, s
->f
, 0))
3397 color
= IMAGE_BACKGROUND (s
->img
, s
->f
, 0);
3402 /* Get the background color of the face. */
3403 XGetGCValues (s
->display
, s
->gc
, GCBackground
, &xgcv
);
3404 color
= xgcv
.background
;
3407 if (di
->white_relief
.gc
== 0
3408 || color
!= di
->relief_background
)
3410 di
->relief_background
= color
;
3411 x_setup_relief_color (s
->f
, &di
->white_relief
, 1.2, 0x8000,
3412 WHITE_PIX_DEFAULT (s
->f
));
3413 x_setup_relief_color (s
->f
, &di
->black_relief
, 0.6, 0x4000,
3414 BLACK_PIX_DEFAULT (s
->f
));
3419 /* Draw a relief on frame F inside the rectangle given by LEFT_X,
3420 TOP_Y, RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the relief
3421 to draw, it must be >= 0. RAISED_P non-zero means draw a raised
3422 relief. LEFT_P non-zero means draw a relief on the left side of
3423 the rectangle. RIGHT_P non-zero means draw a relief on the right
3424 side of the rectangle. CLIP_RECT is the clipping rectangle to use
3428 x_draw_relief_rect (f
, left_x
, top_y
, right_x
, bottom_y
, width
,
3429 raised_p
, top_p
, bot_p
, left_p
, right_p
, clip_rect
)
3431 int left_x
, top_y
, right_x
, bottom_y
, width
;
3432 int top_p
, bot_p
, left_p
, right_p
, raised_p
;
3435 Display
*dpy
= FRAME_MAC_DISPLAY (f
);
3440 gc
= f
->output_data
.mac
->white_relief
.gc
;
3442 gc
= f
->output_data
.mac
->black_relief
.gc
;
3443 mac_set_clip_rectangles (dpy
, gc
, clip_rect
, 1);
3447 for (i
= 0; i
< width
; ++i
)
3448 mac_draw_line (f
, gc
,
3449 left_x
+ i
* left_p
, top_y
+ i
,
3450 right_x
+ 1 - i
* right_p
, top_y
+ i
);
3454 for (i
= 0; i
< width
; ++i
)
3455 mac_draw_line (f
, gc
,
3456 left_x
+ i
, top_y
+ i
, left_x
+ i
, bottom_y
- i
+ 1);
3458 mac_reset_clip_rectangles (dpy
, gc
);
3460 gc
= f
->output_data
.mac
->black_relief
.gc
;
3462 gc
= f
->output_data
.mac
->white_relief
.gc
;
3463 mac_set_clip_rectangles (dpy
, gc
, clip_rect
, 1);
3467 for (i
= 0; i
< width
; ++i
)
3468 mac_draw_line (f
, gc
,
3469 left_x
+ i
* left_p
, bottom_y
- i
,
3470 right_x
+ 1 - i
* right_p
, bottom_y
- i
);
3474 for (i
= 0; i
< width
; ++i
)
3475 mac_draw_line (f
, gc
,
3476 right_x
- i
, top_y
+ i
+ 1, right_x
- i
, bottom_y
- i
);
3478 mac_reset_clip_rectangles (dpy
, gc
);
3482 /* Draw a box on frame F inside the rectangle given by LEFT_X, TOP_Y,
3483 RIGHT_X, and BOTTOM_Y. WIDTH is the thickness of the lines to
3484 draw, it must be >= 0. LEFT_P non-zero means draw a line on the
3485 left side of the rectangle. RIGHT_P non-zero means draw a line
3486 on the right side of the rectangle. CLIP_RECT is the clipping
3487 rectangle to use when drawing. */
3490 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3491 left_p
, right_p
, clip_rect
)
3492 struct glyph_string
*s
;
3493 int left_x
, top_y
, right_x
, bottom_y
, width
, left_p
, right_p
;
3498 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3499 XSetForeground (s
->display
, s
->gc
, s
->face
->box_color
);
3500 mac_set_clip_rectangles (s
->display
, s
->gc
, clip_rect
, 1);
3503 mac_fill_rectangle (s
->f
, s
->gc
, left_x
, top_y
,
3504 right_x
- left_x
+ 1, width
);
3508 mac_fill_rectangle (s
->f
, s
->gc
, left_x
, top_y
,
3509 width
, bottom_y
- top_y
+ 1);
3512 mac_fill_rectangle (s
->f
, s
->gc
, left_x
, bottom_y
- width
+ 1,
3513 right_x
- left_x
+ 1, width
);
3517 mac_fill_rectangle (s
->f
, s
->gc
, right_x
- width
+ 1,
3518 top_y
, width
, bottom_y
- top_y
+ 1);
3520 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3521 mac_reset_clip_rectangles (s
->display
, s
->gc
);
3525 /* Draw a box around glyph string S. */
3528 x_draw_glyph_string_box (s
)
3529 struct glyph_string
*s
;
3531 int width
, left_x
, right_x
, top_y
, bottom_y
, last_x
, raised_p
;
3532 int left_p
, right_p
;
3533 struct glyph
*last_glyph
;
3536 last_x
= ((s
->row
->full_width_p
&& !s
->w
->pseudo_window_p
)
3537 ? WINDOW_RIGHT_EDGE_X (s
->w
)
3538 : window_box_right (s
->w
, s
->area
));
3540 /* The glyph that may have a right box line. */
3541 last_glyph
= (s
->cmp
|| s
->img
3543 : s
->first_glyph
+ s
->nchars
- 1);
3545 width
= eabs (s
->face
->box_line_width
);
3546 raised_p
= s
->face
->box
== FACE_RAISED_BOX
;
3548 right_x
= (s
->row
->full_width_p
&& s
->extends_to_end_of_line_p
3550 : min (last_x
, s
->x
+ s
->background_width
) - 1);
3552 bottom_y
= top_y
+ s
->height
- 1;
3554 left_p
= (s
->first_glyph
->left_box_line_p
3555 || (s
->hl
== DRAW_MOUSE_FACE
3557 || s
->prev
->hl
!= s
->hl
)));
3558 right_p
= (last_glyph
->right_box_line_p
3559 || (s
->hl
== DRAW_MOUSE_FACE
3561 || s
->next
->hl
!= s
->hl
)));
3563 get_glyph_string_clip_rect (s
, &clip_rect
);
3565 if (s
->face
->box
== FACE_SIMPLE_BOX
)
3566 x_draw_box_rect (s
, left_x
, top_y
, right_x
, bottom_y
, width
,
3567 left_p
, right_p
, &clip_rect
);
3570 x_setup_relief_colors (s
);
3571 x_draw_relief_rect (s
->f
, left_x
, top_y
, right_x
, bottom_y
,
3572 width
, raised_p
, 1, 1, left_p
, right_p
, &clip_rect
);
3577 /* Draw foreground of image glyph string S. */
3580 x_draw_image_foreground (s
)
3581 struct glyph_string
*s
;
3584 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
3586 /* If first glyph of S has a left box line, start drawing it to the
3587 right of that line. */
3588 if (s
->face
->box
!= FACE_NO_BOX
3589 && s
->first_glyph
->left_box_line_p
3591 x
+= eabs (s
->face
->box_line_width
);
3593 /* If there is a margin around the image, adjust x- and y-position
3595 if (s
->slice
.x
== 0)
3596 x
+= s
->img
->hmargin
;
3597 if (s
->slice
.y
== 0)
3598 y
+= s
->img
->vmargin
;
3602 x_set_glyph_string_clipping (s
);
3605 mac_draw_cg_image (s
->img
->data
.ptr_val
,
3606 s
->f
, s
->gc
, s
->slice
.x
, s
->slice
.y
,
3607 s
->slice
.width
, s
->slice
.height
, x
, y
, 1);
3611 mac_copy_area_with_mask (s
->img
->pixmap
, s
->img
->mask
,
3612 s
->f
, s
->gc
, s
->slice
.x
, s
->slice
.y
,
3613 s
->slice
.width
, s
->slice
.height
, x
, y
);
3620 mac_copy_area (s
->img
->pixmap
,
3621 s
->f
, s
->gc
, s
->slice
.x
, s
->slice
.y
,
3622 s
->slice
.width
, s
->slice
.height
, x
, y
);
3625 /* When the image has a mask, we can expect that at
3626 least part of a mouse highlight or a block cursor will
3627 be visible. If the image doesn't have a mask, make
3628 a block cursor visible by drawing a rectangle around
3629 the image. I believe it's looking better if we do
3630 nothing here for mouse-face. */
3631 if (s
->hl
== DRAW_CURSOR
)
3633 int r
= s
->img
->relief
;
3635 mac_draw_rectangle (s
->f
, s
->gc
, x
- r
, y
- r
,
3636 s
->slice
.width
+ r
*2 - 1,
3637 s
->slice
.height
+ r
*2 - 1);
3642 /* Draw a rectangle if image could not be loaded. */
3643 mac_draw_rectangle (s
->f
, s
->gc
, x
, y
,
3644 s
->slice
.width
- 1, s
->slice
.height
- 1);
3648 /* Draw a relief around the image glyph string S. */
3651 x_draw_image_relief (s
)
3652 struct glyph_string
*s
;
3654 int x0
, y0
, x1
, y1
, thick
, raised_p
;
3657 int y
= s
->ybase
- image_ascent (s
->img
, s
->face
, &s
->slice
);
3659 /* If first glyph of S has a left box line, start drawing it to the
3660 right of that line. */
3661 if (s
->face
->box
!= FACE_NO_BOX
3662 && s
->first_glyph
->left_box_line_p
3664 x
+= eabs (s
->face
->box_line_width
);
3666 /* If there is a margin around the image, adjust x- and y-position
3668 if (s
->slice
.x
== 0)
3669 x
+= s
->img
->hmargin
;
3670 if (s
->slice
.y
== 0)
3671 y
+= s
->img
->vmargin
;
3673 if (s
->hl
== DRAW_IMAGE_SUNKEN
3674 || s
->hl
== DRAW_IMAGE_RAISED
)
3676 thick
= tool_bar_button_relief
>= 0 ? tool_bar_button_relief
: DEFAULT_TOOL_BAR_BUTTON_RELIEF
;
3677 raised_p
= s
->hl
== DRAW_IMAGE_RAISED
;
3681 thick
= eabs (s
->img
->relief
);
3682 raised_p
= s
->img
->relief
> 0;
3687 x1
= x
+ s
->slice
.width
+ thick
- 1;
3688 y1
= y
+ s
->slice
.height
+ thick
- 1;
3690 x_setup_relief_colors (s
);
3691 get_glyph_string_clip_rect (s
, &r
);
3692 x_draw_relief_rect (s
->f
, x0
, y0
, x1
, y1
, thick
, raised_p
,
3694 s
->slice
.y
+ s
->slice
.height
== s
->img
->height
,
3696 s
->slice
.x
+ s
->slice
.width
== s
->img
->width
,
3701 /* Draw part of the background of glyph string S. X, Y, W, and H
3702 give the rectangle to draw. */
3705 x_draw_glyph_string_bg_rect (s
, x
, y
, w
, h
)
3706 struct glyph_string
*s
;
3709 #if 0 /* MAC_TODO: stipple */
3712 /* Fill background with a stipple pattern. */
3713 XSetFillStyle (s
->display
, s
->gc
, FillOpaqueStippled
);
3714 XFillRectangle (s
->display
, s
->window
, s
->gc
, x
, y
, w
, h
);
3715 XSetFillStyle (s
->display
, s
->gc
, FillSolid
);
3718 #endif /* MAC_TODO */
3719 x_clear_glyph_string_rect (s
, x
, y
, w
, h
);
3723 /* Draw image glyph string S.
3726 s->x +-------------------------
3729 | +-------------------------
3732 | | +-------------------
3738 x_draw_image_glyph_string (s
)
3739 struct glyph_string
*s
;
3742 int box_line_hwidth
= eabs (s
->face
->box_line_width
);
3743 int box_line_vwidth
= max (s
->face
->box_line_width
, 0);
3746 height
= s
->height
- 2 * box_line_vwidth
;
3749 /* Fill background with face under the image. Do it only if row is
3750 taller than image or if image has a clip mask to reduce
3752 s
->stippled_p
= s
->face
->stipple
!= 0;
3753 if (height
> s
->slice
.height
3757 || s
->img
->pixmap
== 0
3758 || s
->width
!= s
->background_width
)
3761 if (s
->first_glyph
->left_box_line_p
3763 x
+= box_line_hwidth
;
3766 if (s
->slice
.y
== 0)
3767 y
+= box_line_vwidth
;
3769 x_draw_glyph_string_bg_rect (s
, x
, y
, s
->background_width
, height
);
3771 s
->background_filled_p
= 1;
3774 /* Draw the foreground. */
3775 x_draw_image_foreground (s
);
3777 /* If we must draw a relief around the image, do it. */
3779 || s
->hl
== DRAW_IMAGE_RAISED
3780 || s
->hl
== DRAW_IMAGE_SUNKEN
)
3781 x_draw_image_relief (s
);
3785 /* Draw stretch glyph string S. */
3788 x_draw_stretch_glyph_string (s
)
3789 struct glyph_string
*s
;
3791 xassert (s
->first_glyph
->type
== STRETCH_GLYPH
);
3792 s
->stippled_p
= s
->face
->stipple
!= 0;
3794 if (s
->hl
== DRAW_CURSOR
3795 && !x_stretch_cursor_p
)
3797 /* If `x-stretch-block-cursor' is nil, don't draw a block cursor
3798 as wide as the stretch glyph. */
3799 int width
, background_width
= s
->background_width
;
3800 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
3804 background_width
-= left_x
- x
;
3807 width
= min (FRAME_COLUMN_WIDTH (s
->f
), background_width
);
3810 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, width
, s
->height
);
3812 /* Clear rest using the GC of the original non-cursor face. */
3813 if (width
< background_width
)
3816 int w
= background_width
- width
, h
= s
->height
;
3821 if (s
->row
->mouse_face_p
3822 && cursor_in_mouse_face_p (s
->w
))
3824 x_set_mouse_face_gc (s
);
3830 get_glyph_string_clip_rect (s
, &r
);
3831 mac_set_clip_rectangles (s
->display
, gc
, &r
, 1);
3833 #if 0 /* MAC_TODO: stipple */
3834 if (s
->face
->stipple
)
3836 /* Fill background with a stipple pattern. */
3837 XSetFillStyle (s
->display
, gc
, FillOpaqueStippled
);
3838 XFillRectangle (s
->display
, s
->window
, gc
, x
, y
, w
, h
);
3839 XSetFillStyle (s
->display
, gc
, FillSolid
);
3842 #endif /* MAC_TODO */
3843 mac_erase_rectangle (s
->f
, gc
, x
, y
, w
, h
);
3846 else if (!s
->background_filled_p
)
3848 int background_width
= s
->background_width
;
3849 int x
= s
->x
, left_x
= window_box_left_offset (s
->w
, TEXT_AREA
);
3851 /* Don't draw into left margin, fringe or scrollbar area
3852 except for header line and mode line. */
3853 if (x
< left_x
&& !s
->row
->mode_line_p
)
3855 background_width
-= left_x
- x
;
3858 if (background_width
> 0)
3859 x_draw_glyph_string_bg_rect (s
, x
, s
->y
, background_width
, s
->height
);
3862 s
->background_filled_p
= 1;
3866 /* Draw glyph string S. */
3869 x_draw_glyph_string (s
)
3870 struct glyph_string
*s
;
3872 int relief_drawn_p
= 0;
3874 /* If S draws into the background of its successor that does not
3875 draw a cursor, draw the background of the successor first so that
3876 S can draw into it. This makes S->next use XDrawString instead
3877 of XDrawImageString. */
3878 if (s
->next
&& s
->right_overhang
&& !s
->for_overlaps
3879 && s
->next
->hl
!= DRAW_CURSOR
)
3881 xassert (s
->next
->img
== NULL
);
3882 x_set_glyph_string_gc (s
->next
);
3883 x_set_glyph_string_clipping (s
->next
);
3884 x_draw_glyph_string_background (s
->next
, 1);
3887 /* Set up S->gc, set clipping and draw S. */
3888 x_set_glyph_string_gc (s
);
3890 /* Draw relief (if any) in advance for char/composition so that the
3891 glyph string can be drawn over it. */
3892 if (!s
->for_overlaps
3893 && s
->face
->box
!= FACE_NO_BOX
3894 && (s
->first_glyph
->type
== CHAR_GLYPH
3895 || s
->first_glyph
->type
== COMPOSITE_GLYPH
))
3898 x_set_glyph_string_clipping (s
);
3899 x_draw_glyph_string_background (s
, 1);
3900 x_draw_glyph_string_box (s
);
3901 x_set_glyph_string_clipping (s
);
3905 x_set_glyph_string_clipping (s
);
3907 switch (s
->first_glyph
->type
)
3910 x_draw_image_glyph_string (s
);
3914 x_draw_stretch_glyph_string (s
);
3918 if (s
->for_overlaps
)
3919 s
->background_filled_p
= 1;
3921 x_draw_glyph_string_background (s
, 0);
3922 x_draw_glyph_string_foreground (s
);
3925 case COMPOSITE_GLYPH
:
3926 if (s
->for_overlaps
|| s
->gidx
> 0)
3927 s
->background_filled_p
= 1;
3929 x_draw_glyph_string_background (s
, 1);
3930 x_draw_composite_glyph_string_foreground (s
);
3937 if (!s
->for_overlaps
)
3939 /* Draw underline. */
3940 if (s
->face
->underline_p
)
3942 unsigned long tem
, h
;
3946 /* Get the underline thickness. Default is 1 pixel. */
3947 if (!XGetFontProperty (s
->font
, XA_UNDERLINE_THICKNESS
, &h
))
3951 y
= s
->y
+ s
->height
- h
;
3952 if (!x_underline_at_descent_line
)
3954 /* Get the underline position. This is the recommended
3955 vertical offset in pixels from the baseline to the top of
3956 the underline. This is a signed value according to the
3957 specs, and its default is
3959 ROUND ((maximum descent) / 2), with
3960 ROUND(x) = floor (x + 0.5) */
3963 if (x_use_underline_position_properties
3964 && XGetFontProperty (s
->font
, XA_UNDERLINE_POSITION
, &tem
))
3965 y
= s
->ybase
+ (long) tem
;
3969 y
= s
->ybase
+ (s
->face
->font
->max_bounds
.descent
+ 1) / 2;
3972 if (s
->face
->underline_defaulted_p
)
3973 mac_fill_rectangle (s
->f
, s
->gc
, s
->x
, y
,
3974 s
->background_width
, h
);
3978 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3979 XSetForeground (s
->display
, s
->gc
, s
->face
->underline_color
);
3980 mac_fill_rectangle (s
->f
, s
->gc
, s
->x
, y
,
3981 s
->background_width
, h
);
3982 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
3986 /* Draw overline. */
3987 if (s
->face
->overline_p
)
3989 unsigned long dy
= 0, h
= 1;
3991 if (s
->face
->overline_color_defaulted_p
)
3992 mac_fill_rectangle (s
->f
, s
->gc
, s
->x
, s
->y
+ dy
,
3993 s
->background_width
, h
);
3997 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
3998 XSetForeground (s
->display
, s
->gc
, s
->face
->overline_color
);
3999 mac_fill_rectangle (s
->f
, s
->gc
, s
->x
, s
->y
+ dy
,
4000 s
->background_width
, h
);
4001 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4005 /* Draw strike-through. */
4006 if (s
->face
->strike_through_p
)
4008 unsigned long h
= 1;
4009 unsigned long dy
= (s
->height
- h
) / 2;
4011 if (s
->face
->strike_through_color_defaulted_p
)
4012 mac_fill_rectangle (s
->f
, s
->gc
, s
->x
, s
->y
+ dy
,
4017 XGetGCValues (s
->display
, s
->gc
, GCForeground
, &xgcv
);
4018 XSetForeground (s
->display
, s
->gc
, s
->face
->strike_through_color
);
4019 mac_fill_rectangle (s
->f
, s
->gc
, s
->x
, s
->y
+ dy
,
4021 XSetForeground (s
->display
, s
->gc
, xgcv
.foreground
);
4025 /* Draw relief if not yet drawn. */
4026 if (!relief_drawn_p
&& s
->face
->box
!= FACE_NO_BOX
)
4027 x_draw_glyph_string_box (s
);
4030 /* Reset clipping. */
4031 mac_reset_clip_rectangles (s
->display
, s
->gc
);
4034 /* Shift display to make room for inserted glyphs. */
4037 mac_shift_glyphs_for_insert (f
, x
, y
, width
, height
, shift_by
)
4039 int x
, y
, width
, height
, shift_by
;
4041 mac_scroll_area (f
, f
->output_data
.mac
->normal_gc
,
4042 x
, y
, width
, height
,
4046 /* Delete N glyphs at the nominal cursor position. Not implemented
4057 /* Clear entire frame. If updating_frame is non-null, clear that
4058 frame. Otherwise clear the selected frame. */
4061 x_clear_frame (struct frame
*f
)
4063 /* Clearing the frame will erase any cursor, so mark them all as no
4065 mark_window_cursors_off (XWINDOW (FRAME_ROOT_WINDOW (f
)));
4066 output_cursor
.hpos
= output_cursor
.vpos
= 0;
4067 output_cursor
.x
= -1;
4069 /* We don't set the output cursor here because there will always
4070 follow an explicit cursor_to. */
4072 mac_clear_window (f
);
4074 /* We have to clear the scroll bars, too. If we have changed
4075 colors or something like that, then they should be notified. */
4076 x_scroll_bar_clear (f
);
4078 XFlush (FRAME_MAC_DISPLAY (f
));
4084 /* Invert the middle quarter of the frame for .15 sec. */
4086 /* We use the select system call to do the waiting, so we have to make
4087 sure it's available. If it isn't, we just won't do visual bells. */
4089 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
4092 /* Subtract the `struct timeval' values X and Y, storing the result in
4093 *RESULT. Return 1 if the difference is negative, otherwise 0. */
4096 timeval_subtract (result
, x
, y
)
4097 struct timeval
*result
, x
, y
;
4099 /* Perform the carry for the later subtraction by updating y. This
4100 is safer because on some systems the tv_sec member is unsigned. */
4101 if (x
.tv_usec
< y
.tv_usec
)
4103 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000 + 1;
4104 y
.tv_usec
-= 1000000 * nsec
;
4108 if (x
.tv_usec
- y
.tv_usec
> 1000000)
4110 int nsec
= (y
.tv_usec
- x
.tv_usec
) / 1000000;
4111 y
.tv_usec
+= 1000000 * nsec
;
4115 /* Compute the time remaining to wait. tv_usec is certainly
4117 result
->tv_sec
= x
.tv_sec
- y
.tv_sec
;
4118 result
->tv_usec
= x
.tv_usec
- y
.tv_usec
;
4120 /* Return indication of whether the result should be considered
4122 return x
.tv_sec
< y
.tv_sec
;
4129 /* Get the height not including a menu bar widget. */
4130 int height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, FRAME_LINES (f
));
4131 /* Height of each line to flash. */
4132 int flash_height
= FRAME_LINE_HEIGHT (f
);
4133 /* These will be the left and right margins of the rectangles. */
4134 int flash_left
= FRAME_INTERNAL_BORDER_WIDTH (f
);
4135 int flash_right
= FRAME_PIXEL_WIDTH (f
) - FRAME_INTERNAL_BORDER_WIDTH (f
);
4139 /* Don't flash the area between a scroll bar and the frame
4140 edge it is next to. */
4141 switch (FRAME_VERTICAL_SCROLL_BAR_TYPE (f
))
4143 case vertical_scroll_bar_left
:
4144 flash_left
+= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
4147 case vertical_scroll_bar_right
:
4148 flash_right
-= VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
4155 width
= flash_right
- flash_left
;
4159 /* If window is tall, flash top and bottom line. */
4160 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
4162 mac_invert_rectangle (f
, flash_left
,
4163 (FRAME_INTERNAL_BORDER_WIDTH (f
)
4164 + FRAME_TOOL_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
)),
4165 width
, flash_height
);
4166 mac_invert_rectangle (f
, flash_left
,
4167 (height
- flash_height
4168 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
4169 width
, flash_height
);
4172 /* If it is short, flash it all. */
4173 mac_invert_rectangle (f
, flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
4174 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
4179 struct timeval wakeup
;
4181 EMACS_GET_TIME (wakeup
);
4183 /* Compute time to wait until, propagating carry from usecs. */
4184 wakeup
.tv_usec
+= 150000;
4185 wakeup
.tv_sec
+= (wakeup
.tv_usec
/ 1000000);
4186 wakeup
.tv_usec
%= 1000000;
4188 /* Keep waiting until past the time wakeup or any input gets
4190 while (! detect_input_pending ())
4192 struct timeval current
;
4193 struct timeval timeout
;
4195 EMACS_GET_TIME (current
);
4197 /* Break if result would be negative. */
4198 if (timeval_subtract (¤t
, wakeup
, current
))
4201 /* How long `select' should wait. */
4203 timeout
.tv_usec
= 10000;
4205 /* Try to wait that long--but we might wake up sooner. */
4206 select (0, NULL
, NULL
, NULL
, &timeout
);
4210 /* If window is tall, flash top and bottom line. */
4211 if (height
> 3 * FRAME_LINE_HEIGHT (f
))
4213 mac_invert_rectangle (f
, flash_left
,
4214 (FRAME_INTERNAL_BORDER_WIDTH (f
)
4215 + FRAME_TOOL_BAR_LINES (f
) * FRAME_LINE_HEIGHT (f
)),
4216 width
, flash_height
);
4217 mac_invert_rectangle (f
, flash_left
,
4218 (height
- flash_height
4219 - FRAME_INTERNAL_BORDER_WIDTH (f
)),
4220 width
, flash_height
);
4223 /* If it is short, flash it all. */
4224 mac_invert_rectangle (f
, flash_left
, FRAME_INTERNAL_BORDER_WIDTH (f
),
4225 width
, height
- 2 * FRAME_INTERNAL_BORDER_WIDTH (f
));
4232 #endif /* defined (HAVE_TIMEVAL) && defined (HAVE_SELECT) */
4235 /* Make audible bell. */
4240 struct frame
*f
= SELECTED_FRAME ();
4242 #if defined (HAVE_TIMEVAL) && defined (HAVE_SELECT)
4250 XFlush (FRAME_MAC_DISPLAY (f
));
4256 /* Specify how many text lines, from the top of the window,
4257 should be affected by insert-lines and delete-lines operations.
4258 This, and those operations, are used only within an update
4259 that is bounded by calls to x_update_begin and x_update_end. */
4262 XTset_terminal_window (n
)
4265 /* This function intentionally left blank. */
4270 /***********************************************************************
4272 ***********************************************************************/
4274 /* Perform an insert-lines or delete-lines operation, inserting N
4275 lines or deleting -N lines at vertical position VPOS. */
4278 x_ins_del_lines (vpos
, n
)
4285 /* Scroll part of the display as described by RUN. */
4288 x_scroll_run (w
, run
)
4292 struct frame
*f
= XFRAME (w
->frame
);
4293 int x
, y
, width
, height
, from_y
, to_y
, bottom_y
;
4295 /* Get frame-relative bounding box of the text display area of W,
4296 without mode lines. Include in this box the left and right
4298 window_box (w
, -1, &x
, &y
, &width
, &height
);
4300 from_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->current_y
);
4301 to_y
= WINDOW_TO_FRAME_PIXEL_Y (w
, run
->desired_y
);
4302 bottom_y
= y
+ height
;
4306 /* Scrolling up. Make sure we don't copy part of the mode
4307 line at the bottom. */
4308 if (from_y
+ run
->height
> bottom_y
)
4309 height
= bottom_y
- from_y
;
4311 height
= run
->height
;
4315 /* Scolling down. Make sure we don't copy over the mode line.
4317 if (to_y
+ run
->height
> bottom_y
)
4318 height
= bottom_y
- to_y
;
4320 height
= run
->height
;
4325 /* Cursor off. Will be switched on again in x_update_window_end. */
4329 mac_scroll_area (f
, f
->output_data
.mac
->normal_gc
,
4339 /***********************************************************************
4341 ***********************************************************************/
4348 x_update_cursor (f
, 1);
4352 frame_unhighlight (f
)
4355 x_update_cursor (f
, 1);
4358 /* The focus has changed. Update the frames as necessary to reflect
4359 the new situation. Note that we can't change the selected frame
4360 here, because the Lisp code we are interrupting might become confused.
4361 Each event gets marked with the frame in which it occurred, so the
4362 Lisp code can tell when the switch took place by examining the events. */
4365 x_new_focus_frame (dpyinfo
, frame
)
4366 struct x_display_info
*dpyinfo
;
4367 struct frame
*frame
;
4369 struct frame
*old_focus
= dpyinfo
->x_focus_frame
;
4371 if (frame
!= dpyinfo
->x_focus_frame
)
4373 /* Set this before calling other routines, so that they see
4374 the correct value of x_focus_frame. */
4375 dpyinfo
->x_focus_frame
= frame
;
4377 if (old_focus
&& old_focus
->auto_lower
)
4378 x_lower_frame (old_focus
);
4381 selected_frame
= frame
;
4382 XSETFRAME (XWINDOW (selected_frame
->selected_window
)->frame
,
4384 Fselect_window (selected_frame
->selected_window
, Qnil
);
4385 choose_minibuf_frame ();
4388 if (dpyinfo
->x_focus_frame
&& dpyinfo
->x_focus_frame
->auto_raise
)
4389 pending_autoraise_frame
= dpyinfo
->x_focus_frame
;
4391 pending_autoraise_frame
= 0;
4393 #if USE_MAC_FONT_PANEL
4395 mac_set_font_info_for_selection (frame
, DEFAULT_FACE_ID
, 0);
4399 x_frame_rehighlight (dpyinfo
);
4402 /* Handle FocusIn and FocusOut state changes for FRAME.
4403 If FRAME has focus and there exists more than one frame, puts
4404 a FOCUS_IN_EVENT into *BUFP. */
4407 mac_focus_changed (type
, dpyinfo
, frame
, bufp
)
4409 struct mac_display_info
*dpyinfo
;
4410 struct frame
*frame
;
4411 struct input_event
*bufp
;
4413 if (type
== activeFlag
)
4415 if (dpyinfo
->x_focus_event_frame
!= frame
)
4417 x_new_focus_frame (dpyinfo
, frame
);
4418 dpyinfo
->x_focus_event_frame
= frame
;
4420 /* Don't stop displaying the initial startup message
4421 for a switch-frame event we don't need. */
4422 if (GC_NILP (Vterminal_frame
)
4423 && GC_CONSP (Vframe_list
)
4424 && !GC_NILP (XCDR (Vframe_list
)))
4426 bufp
->kind
= FOCUS_IN_EVENT
;
4427 XSETFRAME (bufp
->frame_or_window
, frame
);
4433 if (dpyinfo
->x_focus_event_frame
== frame
)
4435 dpyinfo
->x_focus_event_frame
= 0;
4436 x_new_focus_frame (dpyinfo
, 0);
4441 /* The focus may have changed. Figure out if it is a real focus change,
4442 by checking both FocusIn/Out and Enter/LeaveNotify events.
4444 Returns FOCUS_IN_EVENT event in *BUFP. */
4447 x_detect_focus_change (dpyinfo
, event
, bufp
)
4448 struct mac_display_info
*dpyinfo
;
4449 const EventRecord
*event
;
4450 struct input_event
*bufp
;
4452 struct frame
*frame
;
4454 frame
= mac_window_to_frame ((WindowRef
) event
->message
);
4458 /* On Mac, this is only called from focus events, so no switch needed. */
4459 mac_focus_changed ((event
->modifiers
& activeFlag
),
4460 dpyinfo
, frame
, bufp
);
4464 /* Handle an event saying the mouse has moved out of an Emacs frame. */
4467 x_mouse_leave (dpyinfo
)
4468 struct x_display_info
*dpyinfo
;
4470 x_new_focus_frame (dpyinfo
, dpyinfo
->x_focus_event_frame
);
4473 /* The focus has changed, or we have redirected a frame's focus to
4474 another frame (this happens when a frame uses a surrogate
4475 mini-buffer frame). Shift the highlight as appropriate.
4477 The FRAME argument doesn't necessarily have anything to do with which
4478 frame is being highlighted or un-highlighted; we only use it to find
4479 the appropriate X display info. */
4482 XTframe_rehighlight (frame
)
4483 struct frame
*frame
;
4485 x_frame_rehighlight (FRAME_X_DISPLAY_INFO (frame
));
4489 x_frame_rehighlight (dpyinfo
)
4490 struct x_display_info
*dpyinfo
;
4492 struct frame
*old_highlight
= dpyinfo
->x_highlight_frame
;
4494 if (dpyinfo
->x_focus_frame
)
4496 dpyinfo
->x_highlight_frame
4497 = ((GC_FRAMEP (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
)))
4498 ? XFRAME (FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
))
4499 : dpyinfo
->x_focus_frame
);
4500 if (! FRAME_LIVE_P (dpyinfo
->x_highlight_frame
))
4502 FRAME_FOCUS_FRAME (dpyinfo
->x_focus_frame
) = Qnil
;
4503 dpyinfo
->x_highlight_frame
= dpyinfo
->x_focus_frame
;
4507 dpyinfo
->x_highlight_frame
= 0;
4509 if (dpyinfo
->x_highlight_frame
!= old_highlight
)
4512 frame_unhighlight (old_highlight
);
4513 if (dpyinfo
->x_highlight_frame
)
4514 frame_highlight (dpyinfo
->x_highlight_frame
);
4520 /* Convert a keysym to its name. */
4523 x_get_keysym_name (keysym
)
4530 value
= XKeysymToString (keysym
);
4541 /* Function to report a mouse movement to the mainstream Emacs code.
4542 The input handler calls this.
4544 We have received a mouse movement event, which is given in *event.
4545 If the mouse is over a different glyph than it was last time, tell
4546 the mainstream emacs code by setting mouse_moved. If not, ask for
4547 another motion event, so we can check again the next time it moves. */
4549 static Point last_mouse_motion_position
;
4550 static Lisp_Object last_mouse_motion_frame
;
4553 note_mouse_movement (frame
, pos
)
4557 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (frame
);
4558 #if TARGET_API_MAC_CARBON
4562 last_mouse_movement_time
= TickCount () * (1000 / 60); /* to milliseconds */
4563 last_mouse_motion_position
= *pos
;
4564 XSETFRAME (last_mouse_motion_frame
, frame
);
4566 if (frame
== dpyinfo
->mouse_face_mouse_frame
4567 #if TARGET_API_MAC_CARBON
4568 && !PtInRect (*pos
, GetWindowPortBounds (FRAME_MAC_WINDOW (frame
), &r
))
4570 && !PtInRect (*pos
, &FRAME_MAC_WINDOW (frame
)->portRect
)
4574 /* This case corresponds to LeaveNotify in X11. If we move
4575 outside the frame, then we're certainly no longer on any text
4577 clear_mouse_face (dpyinfo
);
4578 dpyinfo
->mouse_face_mouse_frame
= 0;
4579 if (!dpyinfo
->grabbed
)
4580 FRAME_RIF (frame
)->define_frame_cursor (frame
,
4581 frame
->output_data
.mac
->nontext_cursor
);
4584 /* Has the mouse moved off the glyph it was on at the last sighting? */
4585 if (frame
!= last_mouse_glyph_frame
4586 || !PtInRect (*pos
, &last_mouse_glyph
))
4588 frame
->mouse_moved
= 1;
4589 last_mouse_scroll_bar
= Qnil
;
4590 note_mouse_highlight (frame
, pos
->h
, pos
->v
);
4591 /* Remember which glyph we're now on. */
4592 remember_mouse_glyph (frame
, pos
->h
, pos
->v
, &last_mouse_glyph
);
4593 last_mouse_glyph_frame
= frame
;
4601 /************************************************************************
4603 ************************************************************************/
4605 /* MAC TODO: This should be called from somewhere (or removed) ++KFS */
4608 redo_mouse_highlight ()
4610 if (!NILP (last_mouse_motion_frame
)
4611 && FRAME_LIVE_P (XFRAME (last_mouse_motion_frame
)))
4612 note_mouse_highlight (XFRAME (last_mouse_motion_frame
),
4613 last_mouse_motion_position
.h
,
4614 last_mouse_motion_position
.v
);
4618 static struct frame
*
4619 mac_focus_frame (dpyinfo
)
4620 struct mac_display_info
*dpyinfo
;
4622 if (dpyinfo
->x_focus_frame
)
4623 return dpyinfo
->x_focus_frame
;
4625 /* Mac version may get events, such as a menu bar click, even when
4626 all the frames are invisible. In this case, we regard the
4627 event came to the selected frame. */
4628 return SELECTED_FRAME ();
4632 /* Return the current position of the mouse.
4633 *FP should be a frame which indicates which display to ask about.
4635 If the mouse movement started in a scroll bar, set *FP, *BAR_WINDOW,
4636 and *PART to the frame, window, and scroll bar part that the mouse
4637 is over. Set *X and *Y to the portion and whole of the mouse's
4638 position on the scroll bar.
4640 If the mouse movement started elsewhere, set *FP to the frame the
4641 mouse is on, *BAR_WINDOW to nil, and *X and *Y to the character cell
4644 Set *TIME to the server time-stamp for the time at which the mouse
4645 was at this position.
4647 Don't store anything if we don't have a valid set of values to report.
4649 This clears the mouse_moved flag, so we can wait for the next mouse
4653 XTmouse_position (fp
, insist
, bar_window
, part
, x
, y
, time
)
4656 Lisp_Object
*bar_window
;
4657 enum scroll_bar_part
*part
;
4659 unsigned long *time
;
4665 if (! NILP (last_mouse_scroll_bar
) && insist
== 0)
4666 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
);
4669 Lisp_Object frame
, tail
;
4671 /* Clear the mouse-moved flag for every frame on this display. */
4672 FOR_EACH_FRAME (tail
, frame
)
4673 XFRAME (frame
)->mouse_moved
= 0;
4675 last_mouse_scroll_bar
= Qnil
;
4677 if (FRAME_MAC_DISPLAY_INFO (*fp
)->grabbed
&& last_mouse_frame
4678 && FRAME_LIVE_P (last_mouse_frame
))
4679 f1
= last_mouse_frame
;
4681 f1
= mac_focus_frame (FRAME_MAC_DISPLAY_INFO (*fp
));
4685 /* Ok, we found a frame. Store all the values.
4686 last_mouse_glyph is a rectangle used to reduce the
4687 generation of mouse events. To not miss any motion
4688 events, we must divide the frame into rectangles of the
4689 size of the smallest character that could be displayed
4690 on it, i.e. into the same rectangles that matrices on
4691 the frame are divided into. */
4694 #if TARGET_API_MAC_CARBON
4695 GetGlobalMouse (&mouse_pos
);
4696 mouse_pos
.h
-= f1
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f1
);
4697 mouse_pos
.v
-= f1
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f1
);
4699 SetPortWindowPort (FRAME_MAC_WINDOW (f1
));
4700 GetMouse (&mouse_pos
);
4702 remember_mouse_glyph (f1
, mouse_pos
.h
, mouse_pos
.v
,
4704 last_mouse_glyph_frame
= f1
;
4709 XSETINT (*x
, mouse_pos
.h
);
4710 XSETINT (*y
, mouse_pos
.v
);
4711 *time
= last_mouse_movement_time
;
4719 /************************************************************************
4721 ************************************************************************/
4723 #ifdef USE_TOOLKIT_SCROLL_BARS
4725 static pascal void scroll_bar_timer_callback
P_ ((EventLoopTimerRef
, void *));
4726 static OSStatus install_scroll_bar_timer
P_ ((void));
4727 static OSStatus set_scroll_bar_timer
P_ ((EventTimerInterval
));
4728 static int control_part_code_to_scroll_bar_part
P_ ((ControlPartCode
));
4729 static void construct_scroll_bar_click
P_ ((struct scroll_bar
*, int,
4730 struct input_event
*));
4731 static OSStatus get_control_part_bounds
P_ ((ControlRef
, ControlPartCode
,
4733 static void x_scroll_bar_handle_press
P_ ((struct scroll_bar
*,
4734 ControlPartCode
, Point
,
4735 struct input_event
*));
4736 static void x_scroll_bar_handle_release
P_ ((struct scroll_bar
*,
4737 struct input_event
*));
4738 static void x_scroll_bar_handle_drag
P_ ((WindowRef
, struct scroll_bar
*,
4739 Point
, struct input_event
*));
4740 static void x_set_toolkit_scroll_bar_thumb
P_ ((struct scroll_bar
*,
4743 /* Last scroll bar part sent in x_scroll_bar_handle_*. */
4745 static int last_scroll_bar_part
;
4747 static EventLoopTimerRef scroll_bar_timer
;
4749 static int scroll_bar_timer_event_posted_p
;
4751 #define SCROLL_BAR_FIRST_DELAY 0.5
4752 #define SCROLL_BAR_CONTINUOUS_DELAY (1.0 / 15)
4755 scroll_bar_timer_callback (timer
, data
)
4756 EventLoopTimerRef timer
;
4761 err
= mac_post_mouse_moved_event ();
4763 scroll_bar_timer_event_posted_p
= 1;
4767 install_scroll_bar_timer ()
4769 static EventLoopTimerUPP scroll_bar_timer_callbackUPP
= NULL
;
4771 if (scroll_bar_timer_callbackUPP
== NULL
)
4772 scroll_bar_timer_callbackUPP
=
4773 NewEventLoopTimerUPP (scroll_bar_timer_callback
);
4775 if (scroll_bar_timer
== NULL
)
4776 /* Mac OS X and CarbonLib 1.5 and later allow us to specify
4777 kEventDurationForever as delays. */
4779 InstallEventLoopTimer (GetCurrentEventLoop (),
4780 kEventDurationForever
, kEventDurationForever
,
4781 scroll_bar_timer_callbackUPP
, NULL
,
4786 set_scroll_bar_timer (delay
)
4787 EventTimerInterval delay
;
4789 if (scroll_bar_timer
== NULL
)
4790 install_scroll_bar_timer ();
4792 scroll_bar_timer_event_posted_p
= 0;
4794 return SetEventLoopTimerNextFireTime (scroll_bar_timer
, delay
);
4798 control_part_code_to_scroll_bar_part (part_code
)
4799 ControlPartCode part_code
;
4803 case kControlUpButtonPart
: return scroll_bar_up_arrow
;
4804 case kControlDownButtonPart
: return scroll_bar_down_arrow
;
4805 case kControlPageUpPart
: return scroll_bar_above_handle
;
4806 case kControlPageDownPart
: return scroll_bar_below_handle
;
4807 case kControlIndicatorPart
: return scroll_bar_handle
;
4814 construct_scroll_bar_click (bar
, part
, bufp
)
4815 struct scroll_bar
*bar
;
4817 struct input_event
*bufp
;
4819 bufp
->kind
= SCROLL_BAR_CLICK_EVENT
;
4820 bufp
->frame_or_window
= bar
->window
;
4824 XSETINT (bufp
->x
, 0);
4825 XSETINT (bufp
->y
, 0);
4826 bufp
->modifiers
= 0;
4830 get_control_part_bounds (ch
, part_code
, rect
)
4832 ControlPartCode part_code
;
4835 RgnHandle region
= NewRgn ();
4838 err
= GetControlRegion (ch
, part_code
, region
);
4840 GetRegionBounds (region
, rect
);
4841 DisposeRgn (region
);
4847 x_scroll_bar_handle_press (bar
, part_code
, mouse_pos
, bufp
)
4848 struct scroll_bar
*bar
;
4849 ControlPartCode part_code
;
4851 struct input_event
*bufp
;
4853 int part
= control_part_code_to_scroll_bar_part (part_code
);
4858 if (part
!= scroll_bar_handle
)
4860 construct_scroll_bar_click (bar
, part
, bufp
);
4861 HiliteControl (SCROLL_BAR_CONTROL_REF (bar
), part_code
);
4862 set_scroll_bar_timer (SCROLL_BAR_FIRST_DELAY
);
4863 bar
->dragging
= Qnil
;
4869 get_control_part_bounds (SCROLL_BAR_CONTROL_REF (bar
),
4870 kControlIndicatorPart
, &r
);
4871 XSETINT (bar
->dragging
, - (mouse_pos
.v
- r
.top
) - 1);
4874 last_scroll_bar_part
= part
;
4875 tracked_scroll_bar
= bar
;
4879 x_scroll_bar_handle_release (bar
, bufp
)
4880 struct scroll_bar
*bar
;
4881 struct input_event
*bufp
;
4883 if (last_scroll_bar_part
!= scroll_bar_handle
4884 || (INTEGERP (bar
->dragging
) && XINT (bar
->dragging
) >= 0))
4885 construct_scroll_bar_click (bar
, scroll_bar_end_scroll
, bufp
);
4887 HiliteControl (SCROLL_BAR_CONTROL_REF (bar
), 0);
4888 set_scroll_bar_timer (kEventDurationForever
);
4890 last_scroll_bar_part
= -1;
4891 bar
->dragging
= Qnil
;
4892 tracked_scroll_bar
= NULL
;
4896 x_scroll_bar_handle_drag (win
, bar
, mouse_pos
, bufp
)
4898 struct scroll_bar
*bar
;
4900 struct input_event
*bufp
;
4902 ControlRef ch
= SCROLL_BAR_CONTROL_REF (bar
);
4904 if (last_scroll_bar_part
== scroll_bar_handle
)
4909 get_control_part_bounds (SCROLL_BAR_CONTROL_REF (bar
),
4910 kControlIndicatorPart
, &r
);
4912 if (INTEGERP (bar
->dragging
) && XINT (bar
->dragging
) < 0)
4913 XSETINT (bar
->dragging
, - (XINT (bar
->dragging
) + 1));
4915 top
= mouse_pos
.v
- XINT (bar
->dragging
) - XINT (bar
->track_top
);
4916 top_range
= XINT (bar
->track_height
) - XINT (bar
->min_handle
);
4920 if (top
> top_range
)
4923 construct_scroll_bar_click (bar
, scroll_bar_handle
, bufp
);
4924 XSETINT (bufp
->x
, top
);
4925 XSETINT (bufp
->y
, top_range
);
4929 ControlPartCode part_code
;
4930 int unhilite_p
= 0, part
;
4932 if (ch
!= FindControlUnderMouse (mouse_pos
, win
, &part_code
))
4936 part
= control_part_code_to_scroll_bar_part (part_code
);
4938 switch (last_scroll_bar_part
)
4940 case scroll_bar_above_handle
:
4941 case scroll_bar_below_handle
:
4942 if (part
!= scroll_bar_above_handle
4943 && part
!= scroll_bar_below_handle
)
4947 case scroll_bar_up_arrow
:
4948 case scroll_bar_down_arrow
:
4949 if (part
!= scroll_bar_up_arrow
4950 && part
!= scroll_bar_down_arrow
)
4957 HiliteControl (SCROLL_BAR_CONTROL_REF (bar
), 0);
4958 else if (part
!= last_scroll_bar_part
4959 || scroll_bar_timer_event_posted_p
)
4961 construct_scroll_bar_click (bar
, part
, bufp
);
4962 last_scroll_bar_part
= part
;
4963 HiliteControl (SCROLL_BAR_CONTROL_REF (bar
), part_code
);
4964 set_scroll_bar_timer (SCROLL_BAR_CONTINUOUS_DELAY
);
4969 /* Set the thumb size and position of scroll bar BAR. We are currently
4970 displaying PORTION out of a whole WHOLE, and our position POSITION. */
4973 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
)
4974 struct scroll_bar
*bar
;
4975 int portion
, position
, whole
;
4977 ControlRef ch
= SCROLL_BAR_CONTROL_REF (bar
);
4978 int value
, viewsize
, maximum
;
4980 if (XINT (bar
->track_height
) == 0)
4983 if (whole
<= portion
)
4984 value
= 0, viewsize
= 1, maximum
= 0;
4989 maximum
= XINT (bar
->track_height
) - XINT (bar
->min_handle
);
4990 scale
= (float) maximum
/ (whole
- portion
);
4991 value
= position
* scale
+ 0.5f
;
4992 viewsize
= (int) (portion
* scale
+ 0.5f
) + XINT (bar
->min_handle
);
4997 if (GetControlViewSize (ch
) != viewsize
4998 || GetControl32BitValue (ch
) != value
4999 || GetControl32BitMaximum (ch
) != maximum
)
5001 /* Temporarily hide the scroll bar to avoid multiple redraws. */
5002 SetControlVisibility (ch
, false, false);
5004 SetControl32BitMaximum (ch
, maximum
);
5005 SetControl32BitValue (ch
, value
);
5006 SetControlViewSize (ch
, viewsize
);
5008 SetControlVisibility (ch
, true, true);
5014 #endif /* USE_TOOLKIT_SCROLL_BARS */
5018 /************************************************************************
5019 Scroll bars, general
5020 ************************************************************************/
5022 /* Create a scroll bar and return the scroll bar vector for it. W is
5023 the Emacs window on which to create the scroll bar. TOP, LEFT,
5024 WIDTH and HEIGHT are the pixel coordinates and dimensions of the
5027 static struct scroll_bar
*
5028 x_scroll_bar_create (w
, top
, left
, width
, height
, disp_top
, disp_height
)
5030 int top
, left
, width
, height
, disp_top
, disp_height
;
5032 struct frame
*f
= XFRAME (w
->frame
);
5033 struct scroll_bar
*bar
5034 = XSCROLL_BAR (Fmake_vector (make_number (SCROLL_BAR_VEC_SIZE
), Qnil
));
5042 r
.right
= left
+ width
;
5043 r
.bottom
= disp_top
+ disp_height
;
5046 mac_prepare_for_quickdraw (f
);
5048 #if TARGET_API_MAC_CARBON
5049 ch
= NewControl (FRAME_MAC_WINDOW (f
), &r
, "\p",
5050 #ifdef USE_TOOLKIT_SCROLL_BARS
5053 width
< disp_height
,
5055 0, 0, 0, kControlScrollBarProc
, (long) bar
);
5057 ch
= NewControl (FRAME_MAC_WINDOW (f
), &r
, "\p", width
< disp_height
,
5058 0, 0, 0, scrollBarProc
, (long) bar
);
5060 SET_SCROLL_BAR_CONTROL_REF (bar
, ch
);
5062 XSETWINDOW (bar
->window
, w
);
5063 XSETINT (bar
->top
, top
);
5064 XSETINT (bar
->left
, left
);
5065 XSETINT (bar
->width
, width
);
5066 XSETINT (bar
->height
, height
);
5067 XSETINT (bar
->start
, 0);
5068 XSETINT (bar
->end
, 0);
5069 bar
->dragging
= Qnil
;
5071 bar
->fringe_extended_p
= Qnil
;
5073 #ifdef USE_TOOLKIT_SCROLL_BARS
5074 bar
->track_top
= Qnil
;
5075 bar
->track_height
= Qnil
;
5076 bar
->min_handle
= Qnil
;
5079 /* Add bar to its frame's list of scroll bars. */
5080 bar
->next
= FRAME_SCROLL_BARS (f
);
5082 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
5083 if (!NILP (bar
->next
))
5084 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
5091 /* Draw BAR's handle in the proper position.
5093 If the handle is already drawn from START to END, don't bother
5094 redrawing it, unless REBUILD is non-zero; in that case, always
5095 redraw it. (REBUILD is handy for drawing the handle after expose
5098 Normally, we want to constrain the start and end of the handle to
5099 fit inside its rectangle, but if the user is dragging the scroll
5100 bar handle, we want to let them drag it down all the way, so that
5101 the bar's top is as far down as it goes; otherwise, there's no way
5102 to move to the very end of the buffer. */
5104 #ifndef USE_TOOLKIT_SCROLL_BARS
5107 x_scroll_bar_set_handle (bar
, start
, end
, rebuild
)
5108 struct scroll_bar
*bar
;
5112 int dragging
= ! NILP (bar
->dragging
);
5113 ControlRef ch
= SCROLL_BAR_CONTROL_REF (bar
);
5114 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5115 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
5116 int length
= end
- start
;
5118 /* If the display is already accurate, do nothing. */
5120 && start
== XINT (bar
->start
)
5121 && end
== XINT (bar
->end
))
5126 /* Make sure the values are reasonable, and try to preserve the
5127 distance between start and end. */
5130 else if (start
> top_range
)
5132 end
= start
+ length
;
5136 else if (end
> top_range
&& ! dragging
)
5139 /* Store the adjusted setting in the scroll bar. */
5140 XSETINT (bar
->start
, start
);
5141 XSETINT (bar
->end
, end
);
5143 /* Clip the end position, just for display. */
5144 if (end
> top_range
)
5147 /* Draw bottom positions VERTICAL_SCROLL_BAR_MIN_HANDLE pixels below
5148 top positions, to make sure the handle is always at least that
5149 many pixels tall. */
5150 end
+= VERTICAL_SCROLL_BAR_MIN_HANDLE
;
5152 SetControlMinimum (ch
, 0);
5153 /* Don't inadvertently activate deactivated scroll bars */
5154 if (GetControlMaximum (ch
) != -1)
5155 SetControlMaximum (ch
, top_range
+ VERTICAL_SCROLL_BAR_MIN_HANDLE
5157 SetControlValue (ch
, start
);
5158 #if TARGET_API_MAC_CARBON
5159 SetControlViewSize (ch
, end
- start
);
5165 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5167 /* Destroy scroll bar BAR, and set its Emacs window's scroll bar to
5171 x_scroll_bar_remove (bar
)
5172 struct scroll_bar
*bar
;
5174 FRAME_PTR f
= XFRAME (WINDOW_FRAME (XWINDOW (bar
->window
)));
5179 mac_prepare_for_quickdraw (f
);
5181 /* Destroy the Mac scroll bar control */
5182 DisposeControl (SCROLL_BAR_CONTROL_REF (bar
));
5184 /* Disassociate this scroll bar from its window. */
5185 XWINDOW (bar
->window
)->vertical_scroll_bar
= Qnil
;
5191 /* Set the handle of the vertical scroll bar for WINDOW to indicate
5192 that we are displaying PORTION characters out of a total of WHOLE
5193 characters, starting at POSITION. If WINDOW has no scroll bar,
5197 XTset_vertical_scroll_bar (w
, portion
, whole
, position
)
5199 int portion
, whole
, position
;
5201 struct frame
*f
= XFRAME (w
->frame
);
5202 struct scroll_bar
*bar
;
5203 int top
, height
, left
, sb_left
, width
, sb_width
, disp_top
, disp_height
;
5204 int window_y
, window_height
;
5206 int fringe_extended_p
;
5209 /* Get window dimensions. */
5210 window_box (w
, -1, 0, &window_y
, 0, &window_height
);
5212 width
= WINDOW_CONFIG_SCROLL_BAR_COLS (w
) * FRAME_COLUMN_WIDTH (f
);
5213 height
= window_height
;
5215 /* Compute the left edge of the scroll bar area. */
5216 left
= WINDOW_SCROLL_BAR_AREA_X (w
);
5218 /* Compute the width of the scroll bar which might be less than
5219 the width of the area reserved for the scroll bar. */
5220 if (WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
) > 0)
5221 sb_width
= WINDOW_CONFIG_SCROLL_BAR_WIDTH (w
);
5225 /* Compute the left edge of the scroll bar. */
5226 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_RIGHT (w
))
5227 sb_left
= left
+ (WINDOW_RIGHTMOST_P (w
) ? width
- sb_width
: 0);
5229 sb_left
= left
+ (WINDOW_LEFTMOST_P (w
) ? 0 : width
- sb_width
);
5231 /* Adjustments according to Inside Macintosh to make it look nice */
5233 disp_height
= height
;
5240 else if (disp_top
== FRAME_PIXEL_HEIGHT (f
) - 16)
5246 if (sb_left
+ sb_width
== FRAME_PIXEL_WIDTH (f
))
5251 if (WINDOW_HAS_VERTICAL_SCROLL_BAR_ON_LEFT (w
))
5252 fringe_extended_p
= (WINDOW_LEFTMOST_P (w
)
5253 && WINDOW_LEFT_FRINGE_WIDTH (w
)
5254 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5255 || WINDOW_LEFT_MARGIN_COLS (w
) == 0));
5257 fringe_extended_p
= (WINDOW_RIGHTMOST_P (w
)
5258 && WINDOW_RIGHT_FRINGE_WIDTH (w
)
5259 && (WINDOW_HAS_FRINGES_OUTSIDE_MARGINS (w
)
5260 || WINDOW_RIGHT_MARGIN_COLS (w
) == 0));
5263 /* Does the scroll bar exist yet? */
5264 if (NILP (w
->vertical_scroll_bar
))
5268 if (fringe_extended_p
)
5269 mac_clear_area (f
, sb_left
, top
, sb_width
, height
);
5272 mac_clear_area (f
, left
, top
, width
, height
);
5274 bar
= x_scroll_bar_create (w
, top
, sb_left
, sb_width
, height
, disp_top
,
5276 XSETVECTOR (w
->vertical_scroll_bar
, bar
);
5280 /* It may just need to be moved and resized. */
5283 bar
= XSCROLL_BAR (w
->vertical_scroll_bar
);
5284 ch
= SCROLL_BAR_CONTROL_REF (bar
);
5288 /* If already correctly positioned, do nothing. */
5289 if (!(XINT (bar
->left
) == sb_left
5290 && XINT (bar
->top
) == top
5291 && XINT (bar
->width
) == sb_width
5292 && XINT (bar
->height
) == height
5294 && !NILP (bar
->fringe_extended_p
) == fringe_extended_p
5298 /* Since toolkit scroll bars are smaller than the space reserved
5299 for them on the frame, we have to clear "under" them. */
5301 if (fringe_extended_p
)
5302 mac_clear_area (f
, sb_left
, top
, sb_width
, height
);
5305 mac_clear_area (f
, left
, top
, width
, height
);
5308 mac_prepare_for_quickdraw (f
);
5311 MoveControl (ch
, sb_left
+ VERTICAL_SCROLL_BAR_WIDTH_TRIM
, disp_top
);
5312 SizeControl (ch
, sb_width
- VERTICAL_SCROLL_BAR_WIDTH_TRIM
* 2,
5314 #ifndef USE_TOOLKIT_SCROLL_BARS
5315 if (sb_width
< disp_height
)
5319 /* Remember new settings. */
5320 XSETINT (bar
->left
, sb_left
);
5321 XSETINT (bar
->top
, top
);
5322 XSETINT (bar
->width
, sb_width
);
5323 XSETINT (bar
->height
, height
);
5324 #ifdef USE_TOOLKIT_SCROLL_BARS
5325 bar
->track_top
= Qnil
;
5326 bar
->track_height
= Qnil
;
5327 bar
->min_handle
= Qnil
;
5335 bar
->fringe_extended_p
= fringe_extended_p
? Qt
: Qnil
;
5338 #ifdef USE_TOOLKIT_SCROLL_BARS
5339 if (NILP (bar
->track_top
))
5341 if (sb_width
>= disp_height
5343 || sb_width
< MAC_AQUA_SMALL_VERTICAL_SCROLL_BAR_WIDTH
5347 XSETINT (bar
->track_top
, 0);
5348 XSETINT (bar
->track_height
, 0);
5349 XSETINT (bar
->min_handle
, 0);
5353 ControlRef ch
= SCROLL_BAR_CONTROL_REF (bar
);
5358 SetControl32BitMinimum (ch
, 0);
5359 SetControl32BitMaximum (ch
, 1 << 30);
5360 SetControlViewSize (ch
, 1);
5362 /* Move the scroll bar thumb to the top. */
5363 SetControl32BitValue (ch
, 0);
5364 get_control_part_bounds (ch
, kControlIndicatorPart
, &r0
);
5366 /* Move the scroll bar thumb to the bottom. */
5367 SetControl32BitValue (ch
, 1 << 30);
5368 get_control_part_bounds (ch
, kControlIndicatorPart
, &r1
);
5370 UnionRect (&r0
, &r1
, &r0
);
5371 XSETINT (bar
->track_top
, r0
.top
);
5372 XSETINT (bar
->track_height
, r0
.bottom
- r0
.top
);
5373 XSETINT (bar
->min_handle
, r1
.bottom
- r1
.top
);
5375 /* Don't show the scroll bar if its height is not enough to
5376 display the scroll bar thumb. */
5377 if (r0
.bottom
- r0
.top
> 0)
5384 x_set_toolkit_scroll_bar_thumb (bar
, portion
, position
, whole
);
5385 #else /* not USE_TOOLKIT_SCROLL_BARS */
5386 /* Set the scroll bar's current state, unless we're currently being
5388 if (NILP (bar
->dragging
))
5390 int top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, height
);
5393 x_scroll_bar_set_handle (bar
, 0, top_range
, 0);
5396 int start
= ((double) position
* top_range
) / whole
;
5397 int end
= ((double) (position
+ portion
) * top_range
) / whole
;
5398 x_scroll_bar_set_handle (bar
, start
, end
, 0);
5401 #endif /* not USE_TOOLKIT_SCROLL_BARS */
5405 /* The following three hooks are used when we're doing a thorough
5406 redisplay of the frame. We don't explicitly know which scroll bars
5407 are going to be deleted, because keeping track of when windows go
5408 away is a real pain - "Can you say set-window-configuration, boys
5409 and girls?" Instead, we just assert at the beginning of redisplay
5410 that *all* scroll bars are to be removed, and then save a scroll bar
5411 from the fiery pit when we actually redisplay its window. */
5413 /* Arrange for all scroll bars on FRAME to be removed at the next call
5414 to `*judge_scroll_bars_hook'. A scroll bar may be spared if
5415 `*redeem_scroll_bar_hook' is applied to its window before the judgment. */
5418 XTcondemn_scroll_bars (frame
)
5421 /* Transfer all the scroll bars to FRAME_CONDEMNED_SCROLL_BARS. */
5422 while (! NILP (FRAME_SCROLL_BARS (frame
)))
5425 bar
= FRAME_SCROLL_BARS (frame
);
5426 FRAME_SCROLL_BARS (frame
) = XSCROLL_BAR (bar
)->next
;
5427 XSCROLL_BAR (bar
)->next
= FRAME_CONDEMNED_SCROLL_BARS (frame
);
5428 XSCROLL_BAR (bar
)->prev
= Qnil
;
5429 if (! NILP (FRAME_CONDEMNED_SCROLL_BARS (frame
)))
5430 XSCROLL_BAR (FRAME_CONDEMNED_SCROLL_BARS (frame
))->prev
= bar
;
5431 FRAME_CONDEMNED_SCROLL_BARS (frame
) = bar
;
5436 /* Un-mark WINDOW's scroll bar for deletion in this judgment cycle.
5437 Note that WINDOW isn't necessarily condemned at all. */
5440 XTredeem_scroll_bar (window
)
5441 struct window
*window
;
5443 struct scroll_bar
*bar
;
5446 /* We can't redeem this window's scroll bar if it doesn't have one. */
5447 if (NILP (window
->vertical_scroll_bar
))
5450 bar
= XSCROLL_BAR (window
->vertical_scroll_bar
);
5452 /* Unlink it from the condemned list. */
5453 f
= XFRAME (WINDOW_FRAME (window
));
5454 if (NILP (bar
->prev
))
5456 /* If the prev pointer is nil, it must be the first in one of
5458 if (EQ (FRAME_SCROLL_BARS (f
), window
->vertical_scroll_bar
))
5459 /* It's not condemned. Everything's fine. */
5461 else if (EQ (FRAME_CONDEMNED_SCROLL_BARS (f
),
5462 window
->vertical_scroll_bar
))
5463 FRAME_CONDEMNED_SCROLL_BARS (f
) = bar
->next
;
5465 /* If its prev pointer is nil, it must be at the front of
5466 one or the other! */
5470 XSCROLL_BAR (bar
->prev
)->next
= bar
->next
;
5472 if (! NILP (bar
->next
))
5473 XSCROLL_BAR (bar
->next
)->prev
= bar
->prev
;
5475 bar
->next
= FRAME_SCROLL_BARS (f
);
5477 XSETVECTOR (FRAME_SCROLL_BARS (f
), bar
);
5478 if (! NILP (bar
->next
))
5479 XSETVECTOR (XSCROLL_BAR (bar
->next
)->prev
, bar
);
5482 /* Remove all scroll bars on FRAME that haven't been saved since the
5483 last call to `*condemn_scroll_bars_hook'. */
5486 XTjudge_scroll_bars (f
)
5489 Lisp_Object bar
, next
;
5491 bar
= FRAME_CONDEMNED_SCROLL_BARS (f
);
5493 /* Clear out the condemned list now so we won't try to process any
5494 more events on the hapless scroll bars. */
5495 FRAME_CONDEMNED_SCROLL_BARS (f
) = Qnil
;
5497 for (; ! NILP (bar
); bar
= next
)
5499 struct scroll_bar
*b
= XSCROLL_BAR (bar
);
5501 x_scroll_bar_remove (b
);
5504 b
->next
= b
->prev
= Qnil
;
5507 /* Now there should be no references to the condemned scroll bars,
5508 and they should get garbage-collected. */
5512 /* Handle a mouse click on the scroll bar BAR. If *EMACS_EVENT's kind
5513 is set to something other than NO_EVENT, it is enqueued.
5515 This may be called from a signal handler, so we have to ignore GC
5519 x_scroll_bar_handle_click (bar
, part_code
, er
, bufp
)
5520 struct scroll_bar
*bar
;
5521 ControlPartCode part_code
;
5522 const EventRecord
*er
;
5523 struct input_event
*bufp
;
5525 int win_y
, top_range
;
5527 if (! GC_WINDOWP (bar
->window
))
5530 bufp
->kind
= SCROLL_BAR_CLICK_EVENT
;
5531 bufp
->frame_or_window
= bar
->window
;
5534 bar
->dragging
= Qnil
;
5538 case kControlUpButtonPart
:
5539 bufp
->part
= scroll_bar_up_arrow
;
5541 case kControlDownButtonPart
:
5542 bufp
->part
= scroll_bar_down_arrow
;
5544 case kControlPageUpPart
:
5545 bufp
->part
= scroll_bar_above_handle
;
5547 case kControlPageDownPart
:
5548 bufp
->part
= scroll_bar_below_handle
;
5550 #if TARGET_API_MAC_CARBON
5553 case kControlIndicatorPart
:
5555 if (er
->what
== mouseDown
)
5556 bar
->dragging
= make_number (0);
5557 XSETVECTOR (last_mouse_scroll_bar
, bar
);
5558 bufp
->part
= scroll_bar_handle
;
5562 win_y
= XINT (bufp
->y
) - XINT (bar
->top
);
5563 top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (0/*dummy*/, XINT (bar
->height
));
5565 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
5569 if (! NILP (bar
->dragging
))
5570 win_y
-= XINT (bar
->dragging
);
5574 if (win_y
> top_range
)
5577 XSETINT (bufp
->x
, win_y
);
5578 XSETINT (bufp
->y
, top_range
);
5581 #ifndef USE_TOOLKIT_SCROLL_BARS
5583 /* Handle some mouse motion while someone is dragging the scroll bar.
5585 This may be called from a signal handler, so we have to ignore GC
5589 x_scroll_bar_note_movement (bar
, y_pos
, t
)
5590 struct scroll_bar
*bar
;
5594 FRAME_PTR f
= XFRAME (XWINDOW (bar
->window
)->frame
);
5596 last_mouse_movement_time
= t
;
5599 XSETVECTOR (last_mouse_scroll_bar
, bar
);
5601 /* If we're dragging the bar, display it. */
5602 if (! GC_NILP (bar
->dragging
))
5604 /* Where should the handle be now? */
5605 int new_start
= y_pos
- 24;
5607 if (new_start
!= XINT (bar
->start
))
5609 int new_end
= new_start
+ (XINT (bar
->end
) - XINT (bar
->start
));
5611 x_scroll_bar_set_handle (bar
, new_start
, new_end
, 0);
5616 #endif /* !USE_TOOLKIT_SCROLL_BARS */
5618 /* Return information to the user about the current position of the mouse
5619 on the scroll bar. */
5622 x_scroll_bar_report_motion (fp
, bar_window
, part
, x
, y
, time
)
5624 Lisp_Object
*bar_window
;
5625 enum scroll_bar_part
*part
;
5627 unsigned long *time
;
5629 struct scroll_bar
*bar
= XSCROLL_BAR (last_mouse_scroll_bar
);
5630 ControlRef ch
= SCROLL_BAR_CONTROL_REF (bar
);
5631 #if TARGET_API_MAC_CARBON
5632 WindowRef wp
= GetControlOwner (ch
);
5634 WindowRef wp
= (*ch
)->contrlOwner
;
5637 struct frame
*f
= mac_window_to_frame (wp
);
5638 int win_y
, top_range
;
5640 #if TARGET_API_MAC_CARBON
5641 GetGlobalMouse (&mouse_pos
);
5642 mouse_pos
.h
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
5643 mouse_pos
.v
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
5645 SetPortWindowPort (wp
);
5646 GetMouse (&mouse_pos
);
5649 win_y
= mouse_pos
.v
- XINT (bar
->top
);
5650 top_range
= VERTICAL_SCROLL_BAR_TOP_RANGE (f
, XINT (bar
->height
));
5652 win_y
-= VERTICAL_SCROLL_BAR_TOP_BORDER
;
5656 if (! NILP (bar
->dragging
))
5657 win_y
-= XINT (bar
->dragging
);
5661 if (win_y
> top_range
)
5665 *bar_window
= bar
->window
;
5667 if (! NILP (bar
->dragging
))
5668 *part
= scroll_bar_handle
;
5669 else if (win_y
< XINT (bar
->start
))
5670 *part
= scroll_bar_above_handle
;
5671 else if (win_y
< XINT (bar
->end
) + VERTICAL_SCROLL_BAR_MIN_HANDLE
)
5672 *part
= scroll_bar_handle
;
5674 *part
= scroll_bar_below_handle
;
5676 XSETINT (*x
, win_y
);
5677 XSETINT (*y
, top_range
);
5680 last_mouse_scroll_bar
= Qnil
;
5682 *time
= last_mouse_movement_time
;
5686 /* The screen has been cleared so we may have changed foreground or
5687 background colors, and the scroll bars may need to be redrawn.
5688 Clear out the scroll bars, and ask for expose events, so we can
5692 x_scroll_bar_clear (f
)
5695 XTcondemn_scroll_bars (f
);
5696 XTjudge_scroll_bars (f
);
5700 /***********************************************************************
5702 ***********************************************************************/
5705 /* In identifiers such as function/variable names, Emacs tool bar is
5706 referred to as `tool_bar', and Carbon HIToolbar as `toolbar'. */
5708 #define TOOLBAR_IDENTIFIER (CFSTR ("org.gnu.Emacs.toolbar"))
5709 #define TOOLBAR_ICON_ITEM_IDENTIFIER (CFSTR ("org.gnu.Emacs.toolbar.icon"))
5711 #define TOOLBAR_ITEM_COMMAND_ID_OFFSET 'Tb\0\0'
5712 #define TOOLBAR_ITEM_COMMAND_ID_P(id) \
5713 (((id) & ~0xffff) == TOOLBAR_ITEM_COMMAND_ID_OFFSET)
5714 #define TOOLBAR_ITEM_COMMAND_ID_VALUE(id) \
5715 ((id) - TOOLBAR_ITEM_COMMAND_ID_OFFSET)
5716 #define TOOLBAR_ITEM_MAKE_COMMAND_ID(value) \
5717 ((value) + TOOLBAR_ITEM_COMMAND_ID_OFFSET)
5719 static int mac_event_to_emacs_modifiers
P_ ((EventRef
));
5720 static void mac_handle_origin_change
P_ ((struct frame
*));
5721 static OSStatus mac_handle_toolbar_command_event
P_ ((EventHandlerCallRef
,
5725 mac_move_window_with_gravity (f
, win_gravity
, left
, top
)
5732 mac_get_window_bounds (f
, &inner
, &outer
);
5734 switch (win_gravity
)
5736 case NorthWestGravity
:
5738 case SouthWestGravity
:
5739 left
+= inner
.left
- outer
.left
;
5745 left
+= ((inner
.left
- outer
.left
) + (inner
.right
- outer
.right
)) / 2;
5748 case NorthEastGravity
:
5750 case SouthEastGravity
:
5751 left
+= inner
.right
- outer
.right
;
5755 switch (win_gravity
)
5757 case NorthWestGravity
:
5759 case NorthEastGravity
:
5760 top
+= inner
.top
- outer
.top
;
5766 top
+= ((inner
.top
- outer
.top
) + (inner
.bottom
- outer
.bottom
)) / 2;
5769 case SouthWestGravity
:
5771 case SouthEastGravity
:
5772 top
+= inner
.bottom
- outer
.bottom
;
5776 MoveWindow (FRAME_MAC_WINDOW (f
), left
, top
, false);
5780 mac_get_window_origin_with_gravity (f
, win_gravity
, left
, top
)
5787 mac_get_window_bounds (f
, &inner
, &outer
);
5789 switch (win_gravity
)
5791 case NorthWestGravity
:
5793 case SouthWestGravity
:
5800 *left
= outer
.left
+ ((outer
.right
- outer
.left
)
5801 - (inner
.right
- inner
.left
)) / 2;
5804 case NorthEastGravity
:
5806 case SouthEastGravity
:
5807 *left
= outer
.right
- (inner
.right
- inner
.left
);
5811 switch (win_gravity
)
5813 case NorthWestGravity
:
5815 case NorthEastGravity
:
5822 *top
= outer
.top
+ ((outer
.bottom
- outer
.top
)
5823 - (inner
.bottom
- inner
.top
)) / 2;
5826 case SouthWestGravity
:
5828 case SouthEastGravity
:
5829 *top
= outer
.bottom
- (inner
.bottom
- inner
.top
);
5835 mac_handle_toolbar_event (next_handler
, event
, data
)
5836 EventHandlerCallRef next_handler
;
5840 OSStatus err
, result
= eventNotHandledErr
;
5842 switch (GetEventKind (event
))
5844 case kEventToolbarGetDefaultIdentifiers
:
5848 case kEventToolbarGetAllowedIdentifiers
:
5850 CFMutableArrayRef array
;
5852 GetEventParameter (event
, kEventParamMutableArray
,
5853 typeCFMutableArrayRef
, NULL
,
5854 sizeof (CFMutableArrayRef
), NULL
, &array
);
5855 CFArrayAppendValue (array
, TOOLBAR_ICON_ITEM_IDENTIFIER
);
5860 case kEventToolbarCreateItemWithIdentifier
:
5862 CFStringRef identifier
;
5863 HIToolbarItemRef item
= NULL
;
5865 GetEventParameter (event
, kEventParamToolbarItemIdentifier
,
5866 typeCFStringRef
, NULL
,
5867 sizeof (CFStringRef
), NULL
, &identifier
);
5869 if (CFStringCompare (identifier
, TOOLBAR_ICON_ITEM_IDENTIFIER
, 0)
5870 == kCFCompareEqualTo
)
5871 HIToolbarItemCreate (identifier
,
5872 kHIToolbarItemAllowDuplicates
5873 | kHIToolbarItemCantBeRemoved
, &item
);
5877 SetEventParameter (event
, kEventParamToolbarItem
,
5878 typeHIToolbarItemRef
,
5879 sizeof (HIToolbarItemRef
), &item
);
5893 mac_image_spec_to_cg_image (f
, image
)
5897 if (!valid_image_p (image
))
5901 int img_id
= lookup_image (f
, image
);
5902 struct image
*img
= IMAGE_FROM_ID (f
, img_id
);
5904 prepare_image_for_display (f
, img
);
5906 return img
->data
.ptr_val
;
5910 /* Create a tool bar for frame F. */
5913 mac_create_frame_tool_bar (f
)
5917 HIToolbarRef toolbar
;
5919 err
= HIToolbarCreate (TOOLBAR_IDENTIFIER
, kHIToolbarNoAttributes
,
5923 static const EventTypeSpec specs
[] =
5924 {{kEventClassToolbar
, kEventToolbarGetDefaultIdentifiers
},
5925 {kEventClassToolbar
, kEventToolbarGetAllowedIdentifiers
},
5926 {kEventClassToolbar
, kEventToolbarCreateItemWithIdentifier
}};
5928 err
= InstallEventHandler (HIObjectGetEventTarget (toolbar
),
5929 mac_handle_toolbar_event
,
5930 GetEventTypeCount (specs
), specs
,
5935 err
= HIToolbarSetDisplayMode (toolbar
, kHIToolbarDisplayModeIconOnly
);
5938 static const EventTypeSpec specs
[] =
5939 {{kEventClassCommand
, kEventCommandProcess
}};
5941 err
= InstallWindowEventHandler (FRAME_MAC_WINDOW (f
),
5942 mac_handle_toolbar_command_event
,
5943 GetEventTypeCount (specs
),
5947 err
= SetWindowToolbar (FRAME_MAC_WINDOW (f
), toolbar
);
5950 CFRelease (toolbar
);
5955 /* Update the tool bar for frame F. Add new buttons and remove old. */
5958 update_frame_tool_bar (f
)
5961 HIToolbarRef toolbar
= NULL
;
5963 CFArrayRef old_items
= NULL
;
5965 int i
, pos
, win_gravity
= f
->output_data
.mac
->toolbar_win_gravity
;
5966 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
5970 GetWindowToolbar (FRAME_MAC_WINDOW (f
), &toolbar
);
5971 if (toolbar
== NULL
)
5973 mac_create_frame_tool_bar (f
);
5974 GetWindowToolbar (FRAME_MAC_WINDOW (f
), &toolbar
);
5975 if (toolbar
== NULL
)
5977 if (win_gravity
>= NorthWestGravity
&& win_gravity
<= SouthEastGravity
)
5978 mac_get_window_origin_with_gravity (f
, win_gravity
, &left
, &top
);
5981 HIToolbarCopyItems (toolbar
, &old_items
);
5982 if (old_items
== NULL
)
5985 old_count
= CFArrayGetCount (old_items
);
5987 for (i
= 0; i
< f
->n_tool_bar_items
; ++i
)
5989 #define PROP(IDX) AREF (f->tool_bar_items, i * TOOL_BAR_ITEM_NSLOTS + (IDX))
5991 int enabled_p
= !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
));
5992 int selected_p
= !NILP (PROP (TOOL_BAR_ITEM_SELECTED_P
));
5995 CGImageRef cg_image
;
5997 HIToolbarItemRef item
;
5999 /* If image is a vector, choose the image according to the
6001 image
= PROP (TOOL_BAR_ITEM_IMAGES
);
6002 if (VECTORP (image
))
6006 ? TOOL_BAR_IMAGE_ENABLED_SELECTED
6007 : TOOL_BAR_IMAGE_ENABLED_DESELECTED
);
6010 ? TOOL_BAR_IMAGE_DISABLED_SELECTED
6011 : TOOL_BAR_IMAGE_DISABLED_DESELECTED
);
6013 xassert (ASIZE (image
) >= idx
);
6014 image
= AREF (image
, idx
);
6019 cg_image
= mac_image_spec_to_cg_image (f
, image
);
6020 /* Ignore invalid image specifications. */
6021 if (cg_image
== NULL
)
6024 label
= cfstring_create_with_string (PROP (TOOL_BAR_ITEM_CAPTION
));
6028 if (pos
< old_count
)
6030 CGImageRef old_cg_image
= NULL
;
6031 CFStringRef old_label
= NULL
;
6032 Boolean old_enabled_p
;
6034 item
= (HIToolbarItemRef
) CFArrayGetValueAtIndex (old_items
, pos
);
6036 HIToolbarItemCopyImage (item
, &old_cg_image
);
6037 if (cg_image
!= old_cg_image
)
6038 HIToolbarItemSetImage (item
, cg_image
);
6039 CGImageRelease (old_cg_image
);
6041 HIToolbarItemCopyLabel (item
, &old_label
);
6042 if (CFStringCompare (label
, old_label
, 0) != kCFCompareEqualTo
)
6043 HIToolbarItemSetLabel (item
, label
);
6044 CFRelease (old_label
);
6046 old_enabled_p
= HIToolbarItemIsEnabled (item
);
6047 if ((enabled_p
|| idx
>= 0) != old_enabled_p
)
6048 HIToolbarItemSetEnabled (item
, (enabled_p
|| idx
>= 0));
6053 HIToolbarCreateItemWithIdentifier (toolbar
,
6054 TOOLBAR_ICON_ITEM_IDENTIFIER
,
6058 HIToolbarItemSetImage (item
, cg_image
);
6059 HIToolbarItemSetLabel (item
, label
);
6060 HIToolbarItemSetEnabled (item
, (enabled_p
|| idx
>= 0));
6061 HIToolbarAppendItem (toolbar
, item
);
6069 HIToolbarItemSetCommandID (item
, TOOLBAR_ITEM_MAKE_COMMAND_ID (i
));
6074 CFRelease (old_items
);
6076 while (pos
< old_count
)
6077 HIToolbarRemoveItemAtIndex (toolbar
, --old_count
);
6079 ShowHideWindowToolbar (FRAME_MAC_WINDOW (f
), true,
6080 !win_gravity
&& f
== mac_focus_frame (dpyinfo
));
6081 /* Mac OS X 10.3 does not issue kEventWindowBoundsChanged events on
6082 toolbar visibility change. */
6083 mac_handle_origin_change (f
);
6084 if (win_gravity
>= NorthWestGravity
&& win_gravity
<= SouthEastGravity
)
6086 mac_move_window_with_gravity (f
, win_gravity
, left
, top
);
6087 /* If the title bar is completely outside the screen, adjust the
6089 ConstrainWindowToScreen (FRAME_MAC_WINDOW (f
), kWindowTitleBarRgn
,
6090 kWindowConstrainMoveRegardlessOfFit
6091 | kWindowConstrainAllowPartial
, NULL
, NULL
);
6092 f
->output_data
.mac
->toolbar_win_gravity
= 0;
6099 /* Hide the tool bar on frame F. Unlike the counterpart on GTK+, it
6100 doesn't deallocate the resources. */
6103 free_frame_tool_bar (f
)
6106 if (IsWindowToolbarVisible (FRAME_MAC_WINDOW (f
)))
6108 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
6111 ShowHideWindowToolbar (FRAME_MAC_WINDOW (f
), false,
6112 (NILP (Fsymbol_value
6113 (intern ("frame-notice-user-settings")))
6114 && f
== mac_focus_frame (dpyinfo
)));
6115 /* Mac OS X 10.3 does not issue kEventWindowBoundsChanged events
6116 on toolbar visibility change. */
6117 mac_handle_origin_change (f
);
6123 mac_tool_bar_note_mouse_movement (f
, event
)
6128 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
6130 HIViewRef item_view
;
6133 mouse_down_p
= (dpyinfo
->grabbed
6134 && f
== last_mouse_frame
6135 && FRAME_LIVE_P (f
));
6139 err
= HIViewGetViewForMouseEvent (HIViewGetRoot (FRAME_MAC_WINDOW (f
)),
6141 /* This doesn't work on Mac OS X 10.2. On Mac OS X 10.3 and 10.4, a
6142 toolbar item view seems to have the same command ID with that of
6143 the toolbar item. */
6145 err
= GetControlCommandID (item_view
, &command_id
);
6146 if (err
== noErr
&& TOOLBAR_ITEM_COMMAND_ID_P (command_id
))
6148 int i
= TOOLBAR_ITEM_COMMAND_ID_VALUE (command_id
);
6150 if (i
< f
->n_tool_bar_items
)
6153 HIViewRef content_view
;
6155 err
= HIViewGetBounds (item_view
, &bounds
);
6157 err
= HIViewFindByID (HIViewGetRoot (FRAME_MAC_WINDOW (f
)),
6158 kHIViewWindowContentID
, &content_view
);
6160 err
= HIViewConvertRect (&bounds
, item_view
, content_view
);
6162 SetRect (&last_mouse_glyph
,
6163 CGRectGetMinX (bounds
), CGRectGetMinY (bounds
),
6164 CGRectGetMaxX (bounds
), CGRectGetMaxY (bounds
));
6166 help_echo_object
= help_echo_window
= Qnil
;
6168 help_echo_string
= PROP (TOOL_BAR_ITEM_HELP
);
6169 if (NILP (help_echo_string
))
6170 help_echo_string
= PROP (TOOL_BAR_ITEM_CAPTION
);
6176 mac_handle_toolbar_command_event (next_handler
, event
, data
)
6177 EventHandlerCallRef next_handler
;
6181 OSStatus err
, result
= eventNotHandledErr
;
6182 struct frame
*f
= (struct frame
*) data
;
6185 err
= GetEventParameter (event
, kEventParamDirectObject
,
6186 typeHICommand
, NULL
,
6187 sizeof (HICommand
), NULL
, &command
);
6191 switch (GetEventKind (event
))
6193 case kEventCommandProcess
:
6194 if (!TOOLBAR_ITEM_COMMAND_ID_P (command
.commandID
))
6195 result
= CallNextEventHandler (next_handler
, event
);
6198 int i
= TOOLBAR_ITEM_COMMAND_ID_VALUE (command
.commandID
);
6200 if (i
< f
->n_tool_bar_items
6201 && !NILP (PROP (TOOL_BAR_ITEM_ENABLED_P
)))
6204 struct input_event buf
;
6208 XSETFRAME (frame
, f
);
6209 buf
.kind
= TOOL_BAR_EVENT
;
6210 buf
.frame_or_window
= frame
;
6212 kbd_buffer_store_event (&buf
);
6214 buf
.kind
= TOOL_BAR_EVENT
;
6215 buf
.frame_or_window
= frame
;
6216 buf
.arg
= PROP (TOOL_BAR_ITEM_KEY
);
6217 buf
.modifiers
= mac_event_to_emacs_modifiers (event
);
6218 kbd_buffer_store_event (&buf
);
6232 #endif /* USE_MAC_TOOLBAR */
6235 /***********************************************************************
6237 ***********************************************************************/
6239 /* Set clipping for output in glyph row ROW. W is the window in which
6240 we operate. GC is the graphics context to set clipping in.
6242 ROW may be a text row or, e.g., a mode line. Text rows must be
6243 clipped to the interior of the window dedicated to text display,
6244 mode lines must be clipped to the whole window. */
6247 x_clip_to_row (w
, row
, area
, gc
)
6249 struct glyph_row
*row
;
6253 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
6255 int window_x
, window_y
, window_width
;
6257 window_box (w
, area
, &window_x
, &window_y
, &window_width
, 0);
6259 clip_rect
.left
= window_x
;
6260 clip_rect
.top
= WINDOW_TO_FRAME_PIXEL_Y (w
, row
->y
);
6261 clip_rect
.top
= max (clip_rect
.top
, window_y
);
6262 clip_rect
.right
= clip_rect
.left
+ window_width
;
6263 clip_rect
.bottom
= clip_rect
.top
+ row
->visible_height
;
6265 mac_set_clip_rectangles (FRAME_MAC_DISPLAY (f
), gc
, &clip_rect
, 1);
6269 /* Draw a hollow box cursor on window W in glyph row ROW. */
6272 x_draw_hollow_cursor (w
, row
)
6274 struct glyph_row
*row
;
6276 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
6277 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
6278 Display
*dpy
= FRAME_MAC_DISPLAY (f
);
6281 struct glyph
*cursor_glyph
;
6284 /* Get the glyph the cursor is on. If we can't tell because
6285 the current matrix is invalid or such, give up. */
6286 cursor_glyph
= get_phys_cursor_glyph (w
);
6287 if (cursor_glyph
== NULL
)
6290 /* Compute frame-relative coordinates for phys cursor. */
6291 get_phys_cursor_geometry (w
, row
, cursor_glyph
, &x
, &y
, &h
);
6292 wd
= w
->phys_cursor_width
;
6294 /* The foreground of cursor_gc is typically the same as the normal
6295 background color, which can cause the cursor box to be invisible. */
6296 xgcv
.foreground
= f
->output_data
.mac
->cursor_pixel
;
6297 if (dpyinfo
->scratch_cursor_gc
)
6298 XChangeGC (dpy
, dpyinfo
->scratch_cursor_gc
, GCForeground
, &xgcv
);
6300 dpyinfo
->scratch_cursor_gc
= XCreateGC (dpy
, FRAME_MAC_WINDOW (f
),
6301 GCForeground
, &xgcv
);
6302 gc
= dpyinfo
->scratch_cursor_gc
;
6304 /* Set clipping, draw the rectangle, and reset clipping again. */
6305 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
6306 mac_draw_rectangle (f
, gc
, x
, y
, wd
, h
- 1);
6307 mac_reset_clip_rectangles (dpy
, gc
);
6311 /* Draw a bar cursor on window W in glyph row ROW.
6313 Implementation note: One would like to draw a bar cursor with an
6314 angle equal to the one given by the font property XA_ITALIC_ANGLE.
6315 Unfortunately, I didn't find a font yet that has this property set.
6319 x_draw_bar_cursor (w
, row
, width
, kind
)
6321 struct glyph_row
*row
;
6323 enum text_cursor_kinds kind
;
6325 struct frame
*f
= XFRAME (w
->frame
);
6326 struct glyph
*cursor_glyph
;
6328 /* If cursor is out of bounds, don't draw garbage. This can happen
6329 in mini-buffer windows when switching between echo area glyphs
6331 cursor_glyph
= get_phys_cursor_glyph (w
);
6332 if (cursor_glyph
== NULL
)
6335 /* If on an image, draw like a normal cursor. That's usually better
6336 visible than drawing a bar, esp. if the image is large so that
6337 the bar might not be in the window. */
6338 if (cursor_glyph
->type
== IMAGE_GLYPH
)
6340 struct glyph_row
*row
;
6341 row
= MATRIX_ROW (w
->current_matrix
, w
->phys_cursor
.vpos
);
6342 draw_phys_cursor_glyph (w
, row
, DRAW_CURSOR
);
6346 Display
*dpy
= FRAME_MAC_DISPLAY (f
);
6347 Window window
= FRAME_MAC_WINDOW (f
);
6348 GC gc
= FRAME_MAC_DISPLAY_INFO (f
)->scratch_cursor_gc
;
6349 unsigned long mask
= GCForeground
| GCBackground
;
6350 struct face
*face
= FACE_FROM_ID (f
, cursor_glyph
->face_id
);
6353 /* If the glyph's background equals the color we normally draw
6354 the bar cursor in, the bar cursor in its normal color is
6355 invisible. Use the glyph's foreground color instead in this
6356 case, on the assumption that the glyph's colors are chosen so
6357 that the glyph is legible. */
6358 if (face
->background
== f
->output_data
.mac
->cursor_pixel
)
6359 xgcv
.background
= xgcv
.foreground
= face
->foreground
;
6361 xgcv
.background
= xgcv
.foreground
= f
->output_data
.mac
->cursor_pixel
;
6364 XChangeGC (dpy
, gc
, mask
, &xgcv
);
6367 gc
= XCreateGC (dpy
, window
, mask
, &xgcv
);
6368 FRAME_MAC_DISPLAY_INFO (f
)->scratch_cursor_gc
= gc
;
6372 width
= FRAME_CURSOR_WIDTH (f
);
6373 width
= min (cursor_glyph
->pixel_width
, width
);
6375 w
->phys_cursor_width
= width
;
6376 x_clip_to_row (w
, row
, TEXT_AREA
, gc
);
6378 if (kind
== BAR_CURSOR
)
6379 mac_fill_rectangle (f
, gc
,
6380 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
6381 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
),
6382 width
, row
->height
);
6384 mac_fill_rectangle (f
, gc
,
6385 WINDOW_TEXT_TO_FRAME_PIXEL_X (w
, w
->phys_cursor
.x
),
6386 WINDOW_TO_FRAME_PIXEL_Y (w
, w
->phys_cursor
.y
+
6387 row
->height
- width
),
6388 cursor_glyph
->pixel_width
,
6391 mac_reset_clip_rectangles (dpy
, gc
);
6396 /* RIF: Define cursor CURSOR on frame F. */
6399 mac_define_frame_cursor (f
, cursor
)
6403 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
6405 if (dpyinfo
->x_focus_frame
== f
)
6406 SetThemeCursor (cursor
);
6410 /* RIF: Clear area on frame F. */
6413 mac_clear_frame_area (f
, x
, y
, width
, height
)
6415 int x
, y
, width
, height
;
6417 mac_clear_area (f
, x
, y
, width
, height
);
6421 /* RIF: Draw cursor on window W. */
6424 mac_draw_window_cursor (w
, glyph_row
, x
, y
, cursor_type
, cursor_width
, on_p
, active_p
)
6426 struct glyph_row
*glyph_row
;
6428 int cursor_type
, cursor_width
;
6433 w
->phys_cursor_type
= cursor_type
;
6434 w
->phys_cursor_on_p
= 1;
6436 if (glyph_row
->exact_window_width_line_p
6437 && w
->phys_cursor
.hpos
>= glyph_row
->used
[TEXT_AREA
])
6439 glyph_row
->cursor_in_fringe_p
= 1;
6440 draw_fringe_bitmap (w
, glyph_row
, 0);
6443 switch (cursor_type
)
6445 case HOLLOW_BOX_CURSOR
:
6446 x_draw_hollow_cursor (w
, glyph_row
);
6449 case FILLED_BOX_CURSOR
:
6450 draw_phys_cursor_glyph (w
, glyph_row
, DRAW_CURSOR
);
6454 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, BAR_CURSOR
);
6458 x_draw_bar_cursor (w
, glyph_row
, cursor_width
, HBAR_CURSOR
);
6462 w
->phys_cursor_width
= 0;
6474 #if 0 /* MAC_TODO: no icon support yet. */
6476 x_bitmap_icon (f
, icon
)
6482 if (FRAME_W32_WINDOW (f
) == 0)
6486 hicon
= LoadIcon (hinst
, EMACS_CLASS
);
6487 else if (STRINGP (icon
))
6488 hicon
= LoadImage (NULL
, (LPCTSTR
) SDATA (icon
), IMAGE_ICON
, 0, 0,
6489 LR_DEFAULTSIZE
| LR_LOADFROMFILE
);
6490 else if (SYMBOLP (icon
))
6494 if (EQ (icon
, intern ("application")))
6495 name
= (LPCTSTR
) IDI_APPLICATION
;
6496 else if (EQ (icon
, intern ("hand")))
6497 name
= (LPCTSTR
) IDI_HAND
;
6498 else if (EQ (icon
, intern ("question")))
6499 name
= (LPCTSTR
) IDI_QUESTION
;
6500 else if (EQ (icon
, intern ("exclamation")))
6501 name
= (LPCTSTR
) IDI_EXCLAMATION
;
6502 else if (EQ (icon
, intern ("asterisk")))
6503 name
= (LPCTSTR
) IDI_ASTERISK
;
6504 else if (EQ (icon
, intern ("winlogo")))
6505 name
= (LPCTSTR
) IDI_WINLOGO
;
6509 hicon
= LoadIcon (NULL
, name
);
6517 PostMessage (FRAME_W32_WINDOW (f
), WM_SETICON
, (WPARAM
) ICON_BIG
,
6522 #endif /* MAC_TODO */
6524 /************************************************************************
6526 ************************************************************************/
6528 /* Display Error Handling functions not used on W32. Listing them here
6529 helps diff stay in step when comparing w32term.c with xterm.c.
6531 x_error_catcher (display, error)
6532 x_catch_errors (dpy)
6533 x_catch_errors_unwind (old_val)
6534 x_check_errors (dpy, format)
6535 x_had_errors_p (dpy)
6536 x_clear_errors (dpy)
6537 x_uncatch_errors (dpy, count)
6539 x_connection_signal (signalnum)
6540 x_connection_closed (dpy, error_message)
6541 x_error_quitter (display, error)
6542 x_error_handler (display, error)
6543 x_io_error_quitter (display)
6548 /* Changing the font of the frame. */
6550 /* Give frame F the font named FONTNAME as its default font, and
6551 return the full name of that font. FONTNAME may be a wildcard
6552 pattern; in that case, we choose some font that fits the pattern.
6553 The return value shows which font we chose. */
6556 x_new_font (f
, fontname
)
6558 register char *fontname
;
6560 struct font_info
*fontp
6561 = FS_LOAD_FONT (f
, 0, fontname
, -1);
6566 FRAME_FONT (f
) = (XFontStruct
*) (fontp
->font
);
6567 FRAME_BASELINE_OFFSET (f
) = fontp
->baseline_offset
;
6568 FRAME_FONTSET (f
) = -1;
6570 FRAME_COLUMN_WIDTH (f
) = fontp
->average_width
;
6571 FRAME_SPACE_WIDTH (f
) = fontp
->space_width
;
6572 FRAME_LINE_HEIGHT (f
) = FONT_HEIGHT (FRAME_FONT (f
));
6574 compute_fringe_widths (f
, 1);
6576 /* Compute the scroll bar width in character columns. */
6577 if (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) > 0)
6579 int wid
= FRAME_COLUMN_WIDTH (f
);
6580 FRAME_CONFIG_SCROLL_BAR_COLS (f
)
6581 = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) + wid
-1) / wid
;
6585 int wid
= FRAME_COLUMN_WIDTH (f
);
6586 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
6589 /* Now make the frame display the given font. */
6590 if (FRAME_MAC_WINDOW (f
) != 0)
6592 XSetFont (FRAME_MAC_DISPLAY (f
), f
->output_data
.mac
->normal_gc
,
6594 XSetFont (FRAME_MAC_DISPLAY (f
), f
->output_data
.mac
->reverse_gc
,
6596 XSetFont (FRAME_MAC_DISPLAY (f
), f
->output_data
.mac
->cursor_gc
,
6599 /* Don't change the size of a tip frame; there's no point in
6600 doing it because it's done in Fx_show_tip, and it leads to
6601 problems because the tip frame has no widget. */
6602 if (NILP (tip_frame
) || XFRAME (tip_frame
) != f
)
6603 x_set_window_size (f
, 0, FRAME_COLS (f
), FRAME_LINES (f
));
6606 return build_string (fontp
->full_name
);
6609 /* Give frame F the fontset named FONTSETNAME as its default font, and
6610 return the full name of that fontset. FONTSETNAME may be a wildcard
6611 pattern; in that case, we choose some fontset that fits the pattern.
6612 The return value shows which fontset we chose. */
6615 x_new_fontset (f
, fontsetname
)
6619 int fontset
= fs_query_fontset (build_string (fontsetname
), 0);
6625 if (FRAME_FONTSET (f
) == fontset
)
6626 /* This fontset is already set in frame F. There's nothing more
6628 return fontset_name (fontset
);
6630 result
= x_new_font (f
, (SDATA (fontset_ascii (fontset
))));
6632 if (!STRINGP (result
))
6633 /* Can't load ASCII font. */
6636 /* Since x_new_font doesn't update any fontset information, do it now. */
6637 FRAME_FONTSET (f
) = fontset
;
6639 return build_string (fontsetname
);
6643 /***********************************************************************
6644 TODO: W32 Input Methods
6645 ***********************************************************************/
6646 /* Listing missing functions from xterm.c helps diff stay in step.
6648 xim_destroy_callback (xim, client_data, call_data)
6649 xim_open_dpy (dpyinfo, resource_name)
6651 xim_instantiate_callback (display, client_data, call_data)
6652 xim_initialize (dpyinfo, resource_name)
6653 xim_close_dpy (dpyinfo)
6659 mac_get_window_bounds (f
, inner
, outer
)
6661 Rect
*inner
, *outer
;
6663 #if TARGET_API_MAC_CARBON
6664 GetWindowBounds (FRAME_MAC_WINDOW (f
), kWindowContentRgn
, inner
);
6665 GetWindowBounds (FRAME_MAC_WINDOW (f
), kWindowStructureRgn
, outer
);
6666 #else /* not TARGET_API_MAC_CARBON */
6667 RgnHandle region
= NewRgn ();
6669 GetWindowRegion (FRAME_MAC_WINDOW (f
), kWindowContentRgn
, region
);
6670 *inner
= (*region
)->rgnBBox
;
6671 GetWindowRegion (FRAME_MAC_WINDOW (f
), kWindowStructureRgn
, region
);
6672 *outer
= (*region
)->rgnBBox
;
6673 DisposeRgn (region
);
6674 #endif /* not TARGET_API_MAC_CARBON */
6678 mac_handle_origin_change (f
)
6681 x_real_positions (f
, &f
->left_pos
, &f
->top_pos
);
6685 mac_handle_size_change (f
, pixelwidth
, pixelheight
)
6687 int pixelwidth
, pixelheight
;
6691 cols
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, pixelwidth
);
6692 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, pixelheight
);
6694 if (cols
!= FRAME_COLS (f
)
6695 || rows
!= FRAME_LINES (f
)
6696 || pixelwidth
!= FRAME_PIXEL_WIDTH (f
)
6697 || pixelheight
!= FRAME_PIXEL_HEIGHT (f
))
6699 /* We pass 1 for DELAY since we can't run Lisp code inside of
6701 change_frame_size (f
, rows
, cols
, 0, 1, 0);
6702 FRAME_PIXEL_WIDTH (f
) = pixelwidth
;
6703 FRAME_PIXEL_HEIGHT (f
) = pixelheight
;
6704 SET_FRAME_GARBAGED (f
);
6706 /* If cursor was outside the new size, mark it as off. */
6707 mark_window_cursors_off (XWINDOW (f
->root_window
));
6709 /* Clear out any recollection of where the mouse highlighting
6710 was, since it might be in a place that's outside the new
6711 frame size. Actually checking whether it is outside is a
6712 pain in the neck, so don't try--just let the highlighting be
6713 done afresh with new size. */
6714 cancel_mouse_face (f
);
6716 #if TARGET_API_MAC_CARBON
6717 if (f
->output_data
.mac
->hourglass_control
)
6720 mac_prepare_for_quickdraw (f
);
6722 MoveControl (f
->output_data
.mac
->hourglass_control
,
6723 pixelwidth
- HOURGLASS_WIDTH
, 0);
6730 /* Calculate the absolute position in frame F
6731 from its current recorded position values and gravity. */
6734 x_calc_absolute_position (f
)
6737 int width_diff
= 0, height_diff
= 0;
6738 int flags
= f
->size_hint_flags
;
6741 /* We have nothing to do if the current position
6742 is already for the top-left corner. */
6743 if (! ((flags
& XNegative
) || (flags
& YNegative
)))
6746 /* Find the offsets of the outside upper-left corner of
6747 the inner window, with respect to the outer window. */
6749 mac_get_window_bounds (f
, &inner
, &outer
);
6752 width_diff
= (outer
.right
- outer
.left
) - (inner
.right
- inner
.left
);
6753 height_diff
= (outer
.bottom
- outer
.top
) - (inner
.bottom
- inner
.top
);
6755 /* Treat negative positions as relative to the leftmost bottommost
6756 position that fits on the screen. */
6757 if (flags
& XNegative
)
6758 f
->left_pos
= (FRAME_MAC_DISPLAY_INFO (f
)->width
6760 - FRAME_PIXEL_WIDTH (f
)
6763 if (flags
& YNegative
)
6764 f
->top_pos
= (FRAME_MAC_DISPLAY_INFO (f
)->height
6766 - FRAME_PIXEL_HEIGHT (f
)
6769 /* The left_pos and top_pos
6770 are now relative to the top and left screen edges,
6771 so the flags should correspond. */
6772 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6775 /* CHANGE_GRAVITY is 1 when calling from Fset_frame_position,
6776 to really change the position, and 0 when calling from
6777 x_make_frame_visible (in that case, XOFF and YOFF are the current
6778 position values). It is -1 when calling from x_set_frame_parameters,
6779 which means, do adjust for borders but don't change the gravity. */
6782 x_set_offset (f
, xoff
, yoff
, change_gravity
)
6784 register int xoff
, yoff
;
6787 if (change_gravity
> 0)
6791 f
->size_hint_flags
&= ~ (XNegative
| YNegative
);
6793 f
->size_hint_flags
|= XNegative
;
6795 f
->size_hint_flags
|= YNegative
;
6796 f
->win_gravity
= NorthWestGravity
;
6798 x_calc_absolute_position (f
);
6801 x_wm_set_size_hint (f
, (long) 0, 0);
6803 #if TARGET_API_MAC_CARBON
6804 MoveWindowStructure (FRAME_MAC_WINDOW (f
), f
->left_pos
, f
->top_pos
);
6805 /* If the title bar is completely outside the screen, adjust the
6807 ConstrainWindowToScreen (FRAME_MAC_WINDOW (f
), kWindowTitleBarRgn
,
6808 kWindowConstrainMoveRegardlessOfFit
6809 | kWindowConstrainAllowPartial
, NULL
, NULL
);
6810 if (!NILP (tip_frame
) && XFRAME (tip_frame
) == f
)
6811 mac_handle_origin_change (f
);
6814 Rect inner
, outer
, screen_rect
, dummy
;
6815 RgnHandle region
= NewRgn ();
6817 mac_get_window_bounds (f
, &inner
, &outer
);
6818 f
->x_pixels_diff
= inner
.left
- outer
.left
;
6819 f
->y_pixels_diff
= inner
.top
- outer
.top
;
6820 MoveWindow (FRAME_MAC_WINDOW (f
), f
->left_pos
+ f
->x_pixels_diff
,
6821 f
->top_pos
+ f
->y_pixels_diff
, false);
6823 /* If the title bar is completely outside the screen, adjust the
6824 position. The variable `outer' holds the title bar rectangle.
6825 The variable `inner' holds slightly smaller one than `outer',
6826 so that the calculation of overlapping may not become too
6828 GetWindowRegion (FRAME_MAC_WINDOW (f
), kWindowTitleBarRgn
, region
);
6829 outer
= (*region
)->rgnBBox
;
6830 DisposeRgn (region
);
6832 InsetRect (&inner
, 8, 8);
6833 screen_rect
= qd
.screenBits
.bounds
;
6834 screen_rect
.top
+= GetMBarHeight ();
6836 if (!SectRect (&inner
, &screen_rect
, &dummy
))
6838 if (inner
.right
<= screen_rect
.left
)
6839 f
->left_pos
= screen_rect
.left
;
6840 else if (inner
.left
>= screen_rect
.right
)
6841 f
->left_pos
= screen_rect
.right
- (outer
.right
- outer
.left
);
6843 if (inner
.bottom
<= screen_rect
.top
)
6844 f
->top_pos
= screen_rect
.top
;
6845 else if (inner
.top
>= screen_rect
.bottom
)
6846 f
->top_pos
= screen_rect
.bottom
- (outer
.bottom
- outer
.top
);
6848 MoveWindow (FRAME_MAC_WINDOW (f
), f
->left_pos
+ f
->x_pixels_diff
,
6849 f
->top_pos
+ f
->y_pixels_diff
, false);
6857 /* Call this to change the size of frame F's x-window.
6858 If CHANGE_GRAVITY is 1, we change to top-left-corner window gravity
6859 for this size change and subsequent size changes.
6860 Otherwise we leave the window gravity unchanged. */
6863 x_set_window_size (f
, change_gravity
, cols
, rows
)
6868 int pixelwidth
, pixelheight
;
6872 check_frame_size (f
, &rows
, &cols
);
6873 f
->scroll_bar_actual_width
6874 = FRAME_SCROLL_BAR_COLS (f
) * FRAME_COLUMN_WIDTH (f
);
6876 compute_fringe_widths (f
, 0);
6878 pixelwidth
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, cols
);
6879 pixelheight
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
);
6881 f
->win_gravity
= NorthWestGravity
;
6882 x_wm_set_size_hint (f
, (long) 0, 0);
6884 SizeWindow (FRAME_MAC_WINDOW (f
), pixelwidth
, pixelheight
, 0);
6886 #if TARGET_API_MAC_CARBON
6887 if (!NILP (tip_frame
) && f
== XFRAME (tip_frame
))
6889 mac_handle_size_change (f
, pixelwidth
, pixelheight
);
6891 if (f
->output_data
.mac
->internal_border_width
6892 != FRAME_INTERNAL_BORDER_WIDTH (f
))
6894 mac_clear_window (f
);
6895 f
->output_data
.mac
->internal_border_width
6896 = FRAME_INTERNAL_BORDER_WIDTH (f
);
6899 SET_FRAME_GARBAGED (f
);
6904 /* Mouse warping. */
6906 void x_set_mouse_pixel_position (struct frame
*f
, int pix_x
, int pix_y
);
6909 x_set_mouse_position (f
, x
, y
)
6915 pix_x
= FRAME_COL_TO_PIXEL_X (f
, x
) + FRAME_COLUMN_WIDTH (f
) / 2;
6916 pix_y
= FRAME_LINE_TO_PIXEL_Y (f
, y
) + FRAME_LINE_HEIGHT (f
) / 2;
6918 if (pix_x
< 0) pix_x
= 0;
6919 if (pix_x
> FRAME_PIXEL_WIDTH (f
)) pix_x
= FRAME_PIXEL_WIDTH (f
);
6921 if (pix_y
< 0) pix_y
= 0;
6922 if (pix_y
> FRAME_PIXEL_HEIGHT (f
)) pix_y
= FRAME_PIXEL_HEIGHT (f
);
6924 x_set_mouse_pixel_position (f
, pix_x
, pix_y
);
6928 x_set_mouse_pixel_position (f
, pix_x
, pix_y
)
6933 pix_x
+= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
6934 pix_y
+= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
6937 CGWarpMouseCursorPosition (CGPointMake (pix_x
, pix_y
));
6940 #if 0 /* MAC_TODO: LMSetMouseLocation and CursorDeviceMoveTo are non-Carbon */
6943 XWarpPointer (FRAME_X_DISPLAY (f
), None
, FRAME_X_WINDOW (f
),
6944 0, 0, 0, 0, pix_x
, pix_y
);
6950 /* focus shifting, raising and lowering. */
6953 x_focus_on_frame (f
)
6956 #if 0 /* This proves to be unpleasant. */
6960 /* I don't think that the ICCCM allows programs to do things like this
6961 without the interaction of the window manager. Whatever you end up
6962 doing with this code, do it to x_unfocus_frame too. */
6963 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6964 RevertToPointerRoot
, CurrentTime
);
6974 /* Raise frame F. */
6980 if (f
->async_visible
)
6983 BringToFront (FRAME_MAC_WINDOW (f
));
6988 /* Lower frame F. */
6994 if (f
->async_visible
)
6997 SendBehind (FRAME_MAC_WINDOW (f
), NULL
);
7003 XTframe_raise_lower (f
, raise_flag
)
7013 /* Change of visibility. */
7016 mac_handle_visibility_change (f
)
7019 WindowRef wp
= FRAME_MAC_WINDOW (f
);
7020 int visible
= 0, iconified
= 0;
7021 struct input_event buf
;
7023 if (IsWindowVisible (wp
))
7025 if (IsWindowCollapsed (wp
))
7031 if (!f
->async_visible
&& visible
)
7035 /* wait_reading_process_output will notice this and update
7036 the frame's display structures. If we were made
7037 invisible, we should not set garbaged, because that stops
7038 redrawing on Update events. */
7039 SET_FRAME_GARBAGED (f
);
7042 buf
.kind
= DEICONIFY_EVENT
;
7043 XSETFRAME (buf
.frame_or_window
, f
);
7045 kbd_buffer_store_event (&buf
);
7047 else if (! NILP (Vframe_list
) && ! NILP (XCDR (Vframe_list
)))
7048 /* Force a redisplay sooner or later to update the
7049 frame titles in case this is the second frame. */
7050 record_asynch_buffer_change ();
7052 else if (f
->async_visible
&& !visible
)
7056 buf
.kind
= ICONIFY_EVENT
;
7057 XSETFRAME (buf
.frame_or_window
, f
);
7059 kbd_buffer_store_event (&buf
);
7062 f
->async_visible
= visible
;
7063 f
->async_iconified
= iconified
;
7066 /* This tries to wait until the frame is really visible.
7067 However, if the window manager asks the user where to position
7068 the frame, this will return before the user finishes doing that.
7069 The frame will not actually be visible at that time,
7070 but it will become visible later when the window manager
7071 finishes with it. */
7074 x_make_frame_visible (f
)
7079 if (! FRAME_VISIBLE_P (f
))
7081 /* We test FRAME_GARBAGED_P here to make sure we don't
7082 call x_set_offset a second time
7083 if we get to x_make_frame_visible a second time
7084 before the window gets really visible. */
7085 if (! FRAME_ICONIFIED_P (f
)
7086 && ! f
->output_data
.mac
->asked_for_visible
)
7087 x_set_offset (f
, f
->left_pos
, f
->top_pos
, 0);
7089 f
->output_data
.mac
->asked_for_visible
= 1;
7091 CollapseWindow (FRAME_MAC_WINDOW (f
), false);
7092 ShowWindow (FRAME_MAC_WINDOW (f
));
7095 XFlush (FRAME_MAC_DISPLAY (f
));
7097 /* Synchronize to ensure Emacs knows the frame is visible
7098 before we do anything else. We do this loop with input not blocked
7099 so that incoming events are handled. */
7104 /* This must come after we set COUNT. */
7107 XSETFRAME (frame
, f
);
7109 /* Wait until the frame is visible. Process X events until a
7110 MapNotify event has been seen, or until we think we won't get a
7111 MapNotify at all.. */
7112 for (count
= input_signal_count
+ 10;
7113 input_signal_count
< count
&& !FRAME_VISIBLE_P (f
);)
7115 /* Force processing of queued events. */
7118 /* Machines that do polling rather than SIGIO have been
7119 observed to go into a busy-wait here. So we'll fake an
7120 alarm signal to let the handler know that there's something
7121 to be read. We used to raise a real alarm, but it seems
7122 that the handler isn't always enabled here. This is
7124 if (input_polling_used ())
7126 /* It could be confusing if a real alarm arrives while
7127 processing the fake one. Turn it off and let the
7128 handler reset it. */
7129 extern void poll_for_input_1
P_ ((void));
7130 int old_poll_suppress_count
= poll_suppress_count
;
7131 poll_suppress_count
= 1;
7132 poll_for_input_1 ();
7133 poll_suppress_count
= old_poll_suppress_count
;
7136 /* See if a MapNotify event has been processed. */
7137 FRAME_SAMPLE_VISIBILITY (f
);
7142 /* Change from mapped state to withdrawn state. */
7144 /* Make the frame visible (mapped and not iconified). */
7147 x_make_frame_invisible (f
)
7150 /* A deactivate event does not occur when the last visible frame is
7151 made invisible. So if we clear the highlight here, it will not
7152 be rehighlighted when it is made visible. */
7154 /* Don't keep the highlight on an invisible frame. */
7155 if (FRAME_MAC_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
7156 FRAME_MAC_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
7161 #if !TARGET_API_MAC_CARBON
7162 /* Before unmapping the window, update the WM_SIZE_HINTS property to claim
7163 that the current position of the window is user-specified, rather than
7164 program-specified, so that when the window is mapped again, it will be
7165 placed at the same location, without forcing the user to position it
7166 by hand again (they have already done that once for this window.) */
7167 x_wm_set_size_hint (f
, (long) 0, 1);
7170 HideWindow (FRAME_MAC_WINDOW (f
));
7174 #if !TARGET_API_MAC_CARBON
7175 mac_handle_visibility_change (f
);
7179 /* Change window state from mapped to iconified. */
7187 /* A deactivate event does not occur when the last visible frame is
7188 iconified. So if we clear the highlight here, it will not be
7189 rehighlighted when it is deiconified. */
7191 /* Don't keep the highlight on an invisible frame. */
7192 if (FRAME_MAC_DISPLAY_INFO (f
)->x_highlight_frame
== f
)
7193 FRAME_MAC_DISPLAY_INFO (f
)->x_highlight_frame
= 0;
7196 if (f
->async_iconified
)
7201 FRAME_SAMPLE_VISIBILITY (f
);
7203 if (! FRAME_VISIBLE_P (f
))
7204 ShowWindow (FRAME_MAC_WINDOW (f
));
7206 err
= CollapseWindow (FRAME_MAC_WINDOW (f
), true);
7211 error ("Can't notify window manager of iconification");
7213 #if !TARGET_API_MAC_CARBON
7214 mac_handle_visibility_change (f
);
7219 /* Free X resources of frame F. */
7222 x_free_frame_resources (f
)
7225 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
7226 WindowRef wp
= FRAME_MAC_WINDOW (f
);
7230 if (wp
!= tip_window
)
7231 remove_window_handler (wp
);
7234 mac_prepare_for_quickdraw (f
);
7237 if (wp
== tip_window
)
7238 /* Neither WaitNextEvent nor ReceiveNextEvent receives `window
7239 closed' event. So we reset tip_window here. */
7242 free_frame_menubar (f
);
7244 if (FRAME_FACE_CACHE (f
))
7245 free_frame_faces (f
);
7249 if (FRAME_SIZE_HINTS (f
))
7250 xfree (FRAME_SIZE_HINTS (f
));
7252 xfree (f
->output_data
.mac
);
7253 f
->output_data
.mac
= NULL
;
7255 if (f
== dpyinfo
->x_focus_frame
)
7257 dpyinfo
->x_focus_frame
= 0;
7258 #if USE_MAC_FONT_PANEL
7259 mac_set_font_info_for_selection (NULL
, DEFAULT_FACE_ID
, 0);
7262 if (f
== dpyinfo
->x_focus_event_frame
)
7263 dpyinfo
->x_focus_event_frame
= 0;
7264 if (f
== dpyinfo
->x_highlight_frame
)
7265 dpyinfo
->x_highlight_frame
= 0;
7267 if (f
== dpyinfo
->mouse_face_mouse_frame
)
7269 dpyinfo
->mouse_face_beg_row
7270 = dpyinfo
->mouse_face_beg_col
= -1;
7271 dpyinfo
->mouse_face_end_row
7272 = dpyinfo
->mouse_face_end_col
= -1;
7273 dpyinfo
->mouse_face_window
= Qnil
;
7274 dpyinfo
->mouse_face_deferred_gc
= 0;
7275 dpyinfo
->mouse_face_mouse_frame
= 0;
7282 /* Destroy the X window of frame F. */
7285 x_destroy_window (f
)
7288 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
7290 x_free_frame_resources (f
);
7292 dpyinfo
->reference_count
--;
7296 /* Setting window manager hints. */
7298 /* Set the normal size hints for the window manager, for frame F.
7299 FLAGS is the flags word to use--or 0 meaning preserve the flags
7300 that the window now has.
7301 If USER_POSITION is nonzero, we set the USPosition
7302 flag (this is useful when FLAGS is 0). */
7304 x_wm_set_size_hint (f
, flags
, user_position
)
7309 int base_width
, base_height
, width_inc
, height_inc
;
7310 int min_rows
= 0, min_cols
= 0;
7311 XSizeHints
*size_hints
;
7313 base_width
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, 0);
7314 base_height
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, 0);
7315 width_inc
= FRAME_COLUMN_WIDTH (f
);
7316 height_inc
= FRAME_LINE_HEIGHT (f
);
7318 check_frame_size (f
, &min_rows
, &min_cols
);
7320 size_hints
= FRAME_SIZE_HINTS (f
);
7321 if (size_hints
== NULL
)
7323 size_hints
= FRAME_SIZE_HINTS (f
) = xmalloc (sizeof (XSizeHints
));
7324 bzero (size_hints
, sizeof (XSizeHints
));
7327 size_hints
->flags
|= PResizeInc
| PMinSize
| PBaseSize
;
7328 size_hints
->width_inc
= width_inc
;
7329 size_hints
->height_inc
= height_inc
;
7330 size_hints
->min_width
= base_width
+ min_cols
* width_inc
;
7331 size_hints
->min_height
= base_height
+ min_rows
* height_inc
;
7332 size_hints
->base_width
= base_width
;
7333 size_hints
->base_height
= base_height
;
7336 size_hints
->flags
= flags
;
7337 else if (user_position
)
7339 size_hints
->flags
&= ~ PPosition
;
7340 size_hints
->flags
|= USPosition
;
7344 #if 0 /* MAC_TODO: hide application instead of iconify? */
7345 /* Used for IconicState or NormalState */
7348 x_wm_set_window_state (f
, state
)
7352 #ifdef USE_X_TOOLKIT
7355 XtSetArg (al
[0], XtNinitialState
, state
);
7356 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
7357 #else /* not USE_X_TOOLKIT */
7358 Window window
= FRAME_X_WINDOW (f
);
7360 f
->output_data
.x
->wm_hints
.flags
|= StateHint
;
7361 f
->output_data
.x
->wm_hints
.initial_state
= state
;
7363 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
7364 #endif /* not USE_X_TOOLKIT */
7368 x_wm_set_icon_pixmap (f
, pixmap_id
)
7374 #ifndef USE_X_TOOLKIT
7375 Window window
= FRAME_X_WINDOW (f
);
7380 icon_pixmap
= x_bitmap_pixmap (f
, pixmap_id
);
7381 f
->output_data
.x
->wm_hints
.icon_pixmap
= icon_pixmap
;
7385 /* It seems there is no way to turn off use of an icon pixmap.
7386 The following line does it, only if no icon has yet been created,
7387 for some window managers. But with mwm it crashes.
7388 Some people say it should clear the IconPixmapHint bit in this case,
7389 but that doesn't work, and the X consortium said it isn't the
7390 right thing at all. Since there is no way to win,
7391 best to explicitly give up. */
7393 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
7399 #ifdef USE_X_TOOLKIT /* same as in x_wm_set_window_state. */
7403 XtSetArg (al
[0], XtNiconPixmap
, icon_pixmap
);
7404 XtSetValues (f
->output_data
.x
->widget
, al
, 1);
7407 #else /* not USE_X_TOOLKIT */
7409 f
->output_data
.x
->wm_hints
.flags
|= IconPixmapHint
;
7410 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
7412 #endif /* not USE_X_TOOLKIT */
7415 #endif /* MAC_TODO */
7418 x_wm_set_icon_position (f
, icon_x
, icon_y
)
7422 #if 0 /* MAC_TODO: no icons on Mac */
7423 #ifdef USE_X_TOOLKIT
7424 Window window
= XtWindow (f
->output_data
.x
->widget
);
7426 Window window
= FRAME_X_WINDOW (f
);
7429 f
->output_data
.x
->wm_hints
.flags
|= IconPositionHint
;
7430 f
->output_data
.x
->wm_hints
.icon_x
= icon_x
;
7431 f
->output_data
.x
->wm_hints
.icon_y
= icon_y
;
7433 XSetWMHints (FRAME_X_DISPLAY (f
), window
, &f
->output_data
.x
->wm_hints
);
7434 #endif /* MAC_TODO */
7438 /***********************************************************************
7440 ***********************************************************************/
7442 /* An XLFD pattern is divided into blocks delimited by '*'. This
7443 structure holds information for each block. */
7444 struct xlfdpat_block
7446 /* Length of the pattern string in this block. Non-zero except for
7447 the first and the last blocks. */
7450 /* Pattern string except the last character in this block. The last
7451 character is replaced with NUL in order to use it as a
7453 unsigned char *pattern
;
7455 /* Last character of the pattern string. Must not be '?'. */
7456 unsigned char last_char
;
7458 /* One of the tables for the Boyer-Moore string search. It
7459 specifies the number of positions to proceed for each character
7460 with which the match fails. */
7463 /* The skip value for the last character in the above `skip' is
7464 assigned to `infinity' in order to simplify a loop condition.
7465 The original value is saved here. */
7471 /* Normalized pattern string. "Normalized" means that capital
7472 letters are lowered, blocks are not empty except the first and
7473 the last ones, and trailing '?'s in a block that is not the last
7474 one are moved to the next one. The last character in each block
7475 is replaced with NUL. */
7478 /* Number of characters except '*'s and trailing '?'s in the
7479 normalized pattern string. */
7482 /* Number of trailing '?'s in the normalized pattern string. */
7483 int trailing_anychars
;
7485 /* Number of blocks and information for each block. The latter is
7486 NULL if the pattern is exact (no '*' or '?' in it). */
7488 struct xlfdpat_block
*blocks
;
7492 xlfdpat_destroy (pat
)
7493 struct xlfdpat
*pat
;
7500 xfree (pat
->blocks
);
7507 static struct xlfdpat
*
7508 xlfdpat_create (pattern
)
7509 const char *pattern
;
7511 struct xlfdpat
*pat
;
7512 int nblocks
, i
, skip
;
7513 unsigned char last_char
, *p
, *q
, *anychar_head
;
7514 const unsigned char *ptr
;
7515 struct xlfdpat_block
*blk
;
7517 pat
= xmalloc (sizeof (struct xlfdpat
));
7518 pat
->buf
= xmalloc (strlen (pattern
) + 1);
7520 /* Normalize the pattern string and store it to `pat->buf'. */
7522 anychar_head
= NULL
;
7525 for (ptr
= pattern
; *ptr
; ptr
++)
7527 unsigned char c
= *ptr
;
7530 if (last_char
== '*')
7531 /* ...a** -> ...a* */
7535 if (last_char
== '?')
7537 if (anychar_head
> pat
->buf
&& *(anychar_head
- 1) == '*')
7538 /* ...*??* -> ...*?? */
7541 /* ...a??* -> ...a*?? */
7543 *anychar_head
++ = '*';
7551 if (last_char
!= '?')
7555 /* On Mac OS X 10.3, tolower also converts non-ASCII
7556 characters for some locales. */
7560 *q
++ = last_char
= c
;
7564 pat
->nblocks
= nblocks
;
7565 if (last_char
!= '?')
7566 pat
->trailing_anychars
= 0;
7569 pat
->trailing_anychars
= q
- anychar_head
;
7572 pat
->nchars
= q
- pat
->buf
- (nblocks
- 1);
7574 if (anychar_head
== NULL
&& nblocks
== 1)
7576 /* The pattern is exact. */
7581 pat
->blocks
= xmalloc (sizeof (struct xlfdpat_block
) * nblocks
);
7583 /* Divide the normalized pattern into blocks. */
7585 for (blk
= pat
->blocks
; blk
< pat
->blocks
+ nblocks
- 1; blk
++)
7590 blk
->len
= p
- blk
->pattern
;
7594 blk
->len
= q
- blk
->pattern
;
7596 /* Setup a table for the Boyer-Moore string search. */
7597 for (blk
= pat
->blocks
; blk
< pat
->blocks
+ nblocks
; blk
++)
7600 blk
->last_char
= blk
->pattern
[blk
->len
- 1];
7601 blk
->pattern
[blk
->len
- 1] = '\0';
7603 for (skip
= 1; skip
< blk
->len
; skip
++)
7604 if (blk
->pattern
[blk
->len
- skip
- 1] == '?')
7607 for (i
= 0; i
< 256; i
++)
7608 blk
->skip
[i
] = skip
;
7610 p
= blk
->pattern
+ (blk
->len
- skip
);
7612 blk
->skip
[*p
++] = skip
;
7614 blk
->last_char_skip
= blk
->skip
[blk
->last_char
];
7621 xlfdpat_exact_p (pat
)
7622 struct xlfdpat
*pat
;
7624 return pat
->blocks
== NULL
;
7627 /* Return the first string in STRING + 0, ..., STRING + START_MAX such
7628 that the pattern in *BLK matches with its prefix. Return NULL
7629 there is no such strings. STRING must be lowered in advance. */
7632 xlfdpat_block_match_1 (blk
, string
, start_max
)
7633 struct xlfdpat_block
*blk
;
7634 const unsigned char *string
;
7637 int start
, infinity
;
7639 const unsigned char *s
;
7641 xassert (blk
->len
> 0);
7642 xassert (start_max
+ blk
->len
<= strlen (string
));
7643 xassert (blk
->last_char
!= '?');
7645 /* See the comments in the function `boyer_moore' (search.c) for the
7646 use of `infinity'. */
7647 infinity
= start_max
+ blk
->len
+ 1;
7648 blk
->skip
[blk
->last_char
] = infinity
;
7653 /* Check the last character of the pattern. */
7654 s
= string
+ blk
->len
- 1;
7657 start
+= blk
->skip
[*(s
+ start
)];
7659 while (start
<= start_max
);
7661 if (start
< infinity
)
7662 /* Couldn't find the last character. */
7665 /* No less than `infinity' means we could find the last
7666 character at `s[start - infinity]'. */
7669 /* Check the remaining characters. We prefer making no-'?'
7670 cases faster because the use of '?' is really rare. */
7675 while (*p
++ == *s
++)
7678 while (*(p
- 1) == '?');
7680 if (*(p
- 1) == '\0')
7682 return string
+ start
;
7685 start
+= blk
->last_char_skip
;
7687 while (start
<= start_max
);
7692 #define xlfdpat_block_match(b, s, m) \
7693 ((b)->len == 1 ? memchr ((s), (b)->last_char, (m) + 1) \
7694 : xlfdpat_block_match_1 (b, s, m))
7696 /* Check if XLFD pattern PAT, which is generated by `xlfdpat_create',
7697 matches with STRING. STRING must be lowered in advance. */
7700 xlfdpat_match (pat
, string
)
7701 struct xlfdpat
*pat
;
7702 const unsigned char *string
;
7704 int str_len
, nblocks
, i
, start_max
;
7705 struct xlfdpat_block
*blk
;
7706 const unsigned char *s
;
7708 xassert (pat
->nblocks
> 0);
7710 if (xlfdpat_exact_p (pat
))
7711 return strcmp (pat
->buf
, string
) == 0;
7713 /* The number of the characters in the string must not be smaller
7714 than that in the pattern. */
7715 str_len
= strlen (string
);
7716 if (str_len
< pat
->nchars
+ pat
->trailing_anychars
)
7719 /* Chop off the trailing '?'s. */
7720 str_len
-= pat
->trailing_anychars
;
7722 /* The last block. When it is non-empty, it must match at the end
7724 nblocks
= pat
->nblocks
;
7725 blk
= pat
->blocks
+ (nblocks
- 1);
7727 /* The last block is also the first one. */
7728 return (str_len
== blk
->len
7729 && (blk
->len
== 0 || xlfdpat_block_match (blk
, string
, 0)));
7730 else if (blk
->len
!= 0)
7731 if (!xlfdpat_block_match (blk
, string
+ (str_len
- blk
->len
), 0))
7734 /* The first block. When it is non-empty, it must match at the
7735 beginning of the string. */
7739 s
= xlfdpat_block_match (blk
, string
, 0);
7742 string
= s
+ blk
->len
;
7745 /* The rest of the blocks. */
7746 start_max
= str_len
- pat
->nchars
;
7747 for (i
= 1, blk
++; i
< nblocks
- 1; i
++, blk
++)
7749 s
= xlfdpat_block_match (blk
, string
, start_max
);
7752 start_max
-= s
- string
;
7753 string
= s
+ blk
->len
;
7760 /***********************************************************************
7762 ***********************************************************************/
7764 /* Return a pointer to struct font_info of font FONT_IDX of frame F. */
7767 x_get_font_info (f
, font_idx
)
7771 return (FRAME_MAC_FONT_TABLE (f
) + font_idx
);
7774 /* the global font name table */
7775 static char **font_name_table
= NULL
;
7776 static int font_name_table_size
= 0;
7777 static int font_name_count
= 0;
7779 /* Alist linking font family names to Font Manager font family
7780 references (which can also be used as QuickDraw font IDs). We use
7781 an alist because hash tables are not ready when the terminal frame
7782 for Mac OS Classic is created. */
7783 static Lisp_Object fm_font_family_alist
;
7785 /* Hash table linking font family names to ATSU font IDs. */
7786 static Lisp_Object atsu_font_id_hash
;
7787 /* Alist linking Font Manager style to face attributes. */
7788 static Lisp_Object fm_style_face_attributes_alist
;
7789 extern Lisp_Object QCfamily
, QCweight
, QCslant
, Qnormal
, Qbold
, Qitalic
;
7792 /* Alist linking character set strings to Mac text encoding and Emacs
7794 static Lisp_Object Vmac_charset_info_alist
;
7797 create_text_encoding_info_alist ()
7799 Lisp_Object result
= Qnil
, rest
;
7801 for (rest
= Vmac_charset_info_alist
; CONSP (rest
); rest
= XCDR (rest
))
7803 Lisp_Object charset_info
= XCAR (rest
);
7804 Lisp_Object charset
, coding_system
, text_encoding
;
7805 Lisp_Object existing_info
;
7807 if (!(CONSP (charset_info
)
7808 && (charset
= XCAR (charset_info
),
7810 && CONSP (XCDR (charset_info
))
7811 && (text_encoding
= XCAR (XCDR (charset_info
)),
7812 INTEGERP (text_encoding
))
7813 && CONSP (XCDR (XCDR (charset_info
)))
7814 && (coding_system
= XCAR (XCDR (XCDR (charset_info
))),
7815 SYMBOLP (coding_system
))))
7818 existing_info
= assq_no_quit (text_encoding
, result
);
7819 if (NILP (existing_info
))
7820 result
= Fcons (list3 (text_encoding
, coding_system
, charset
),
7823 if (NILP (Fmember (charset
, XCDR (XCDR (existing_info
)))))
7824 XSETCDR (XCDR (existing_info
),
7825 Fcons (charset
, XCDR (XCDR (existing_info
))));
7833 decode_mac_font_name (name
, size
, coding_system
)
7836 Lisp_Object coding_system
;
7838 struct coding_system coding
;
7841 if (!NILP (coding_system
) && !NILP (Fcoding_system_p (coding_system
)))
7843 for (p
= name
; *p
; p
++)
7844 if (!isascii (*p
) || iscntrl (*p
))
7849 setup_coding_system (coding_system
, &coding
);
7850 coding
.src_multibyte
= 0;
7851 coding
.dst_multibyte
= 1;
7852 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
7853 coding
.composing
= COMPOSITION_DISABLED
;
7854 buf
= (char *) alloca (size
);
7856 decode_coding (&coding
, name
, buf
, strlen (name
), size
- 1);
7857 bcopy (buf
, name
, coding
.produced
);
7858 name
[coding
.produced
] = '\0';
7862 /* If there's just one occurrence of '-' in the family name, it is
7863 replaced with '_'. (More than one occurrence of '-' means a
7864 "FOUNDRY-FAMILY-CHARSET"-style name.) */
7865 p
= strchr (name
, '-');
7866 if (p
&& strchr (p
+ 1, '-') == NULL
)
7869 for (p
= name
; *p
; p
++)
7870 /* On Mac OS X 10.3, tolower also converts non-ASCII characters
7871 for some locales. */
7878 mac_to_x_fontname (name
, size
, style
, charset
)
7886 char xf
[256], *result
;
7889 if (sscanf (name
, "%31[^-]-%255[^-]-%31s", foundry
, family
, cs
) == 3)
7893 strcpy(foundry
, "Apple");
7894 strcpy(family
, name
);
7897 sprintf (xf
, "%s-%c-normal--%d-%d-%d-%d-m-%d-%s",
7898 style
& bold
? "bold" : "medium", style
& italic
? 'i' : 'r',
7899 size
, size
* 10, size
? 72 : 0, size
? 72 : 0, size
* 10, charset
);
7901 result
= xmalloc (strlen (foundry
) + strlen (family
) + strlen (xf
) + 3 + 1);
7902 sprintf (result
, "-%s-%s-%s", foundry
, family
, xf
);
7903 for (p
= result
; *p
; p
++)
7904 /* On Mac OS X 10.3, tolower also converts non-ASCII characters
7905 for some locales. */
7912 /* Parse fully-specified and instantiated X11 font spec XF, and store
7913 the results to FAMILY, *SIZE, *STYLE, and CHARSET. Return 1 if the
7914 parsing succeeded, and 0 otherwise. For FAMILY and CHARSET, the
7915 caller must allocate at least 256 and 32 bytes respectively. For
7916 ordinary Mac fonts, the value stored to FAMILY should just be their
7917 names, like "monaco", "Taipei", etc. Fonts converted from the GNU
7918 intlfonts collection contain their charset designation in their
7919 names, like "ETL-Fixed-iso8859-1", "ETL-Fixed-koi8-r", etc. Both
7920 types of font names are handled accordingly. */
7922 const int kDefaultFontSize
= 12;
7925 parse_x_font_name (xf
, family
, size
, style
, charset
)
7932 Str31 foundry
, weight
;
7933 int point_size
, avgwidth
;
7936 if (sscanf (xf
, "-%31[^-]-%255[^-]-%31[^-]-%1[^-]-%*[^-]-%*[^-]-%d-%d-%*[^-]-%*[^-]-%*c-%d-%31s",
7937 foundry
, family
, weight
, slant
, size
,
7938 &point_size
, &avgwidth
, charset
) != 8
7939 && sscanf (xf
, "-%31[^-]-%255[^-]-%31[^-]-%1[^-]-%*[^-]--%d-%d-%*[^-]-%*[^-]-%*c-%d-%31s",
7940 foundry
, family
, weight
, slant
, size
,
7941 &point_size
, &avgwidth
, charset
) != 8)
7947 *size
= point_size
/ 10;
7948 else if (avgwidth
> 0)
7949 *size
= avgwidth
/ 10;
7952 *size
= kDefaultFontSize
;
7955 if (strcmp (weight
, "bold") == 0)
7960 if (NILP (Fassoc (build_string (charset
), Vmac_charset_info_alist
)))
7962 int foundry_len
= strlen (foundry
), family_len
= strlen (family
);
7964 if (foundry_len
+ family_len
+ strlen (charset
) + 2 < sizeof (Str255
))
7966 /* Like sprintf (family, "%s-%s-%s", foundry, family, charset),
7967 but take overlap into account. */
7968 memmove (family
+ foundry_len
+ 1, family
, family_len
);
7969 memcpy (family
, foundry
, foundry_len
);
7970 family
[foundry_len
] = '-';
7971 family
[foundry_len
+ 1 + family_len
] = '-';
7972 strcpy (family
+ foundry_len
+ 1 + family_len
+ 1, charset
);
7978 for (p
= family
; *p
; p
++)
7979 /* On Mac OS X 10.3, tolower also converts non-ASCII characters
7980 for some locales. */
7989 add_font_name_table_entry (char *font_name
)
7991 if (font_name_table_size
== 0)
7993 font_name_table_size
= 256;
7994 font_name_table
= (char **)
7995 xmalloc (font_name_table_size
* sizeof (char *));
7997 else if (font_name_count
+ 1 >= font_name_table_size
)
7999 font_name_table_size
*= 2;
8000 font_name_table
= (char **)
8001 xrealloc (font_name_table
,
8002 font_name_table_size
* sizeof (char *));
8005 font_name_table
[font_name_count
++] = font_name
;
8009 add_mac_font_name (name
, size
, style
, charset
)
8013 const char *charset
;
8016 add_font_name_table_entry (mac_to_x_fontname (name
, size
, style
, charset
));
8019 add_font_name_table_entry (mac_to_x_fontname (name
, 0, style
, charset
));
8020 add_font_name_table_entry (mac_to_x_fontname (name
, 0, italic
, charset
));
8021 add_font_name_table_entry (mac_to_x_fontname (name
, 0, bold
, charset
));
8022 add_font_name_table_entry (mac_to_x_fontname (name
, 0, italic
| bold
,
8029 fm_get_style_from_font (font
)
8033 FMFontStyle style
= normal
;
8036 FMFontFamily font_family
;
8037 #define FONT_HEADER_MAC_STYLE_OFFSET (4*4 + 2*2 + 8*2 + 2*4)
8039 /* FMGetFontFamilyInstanceFromFont returns `normal' as the style of
8040 some font (e.g., Optima) even if it is `bold'. */
8041 err
= FMGetFontTable (font
, 'head', FONT_HEADER_MAC_STYLE_OFFSET
,
8042 sizeof (mac_style
), &mac_style
, &len
);
8044 && len
>= FONT_HEADER_MAC_STYLE_OFFSET
+ sizeof (mac_style
))
8045 style
= EndianU16_BtoN (mac_style
);
8047 FMGetFontFamilyInstanceFromFont (font
, &font_family
, &style
);
8053 atsu_find_font_from_family_name (family
)
8056 struct Lisp_Hash_Table
*h
= XHASH_TABLE (atsu_font_id_hash
);
8059 Lisp_Object rest
, best
;
8060 FMFontStyle min_style
, style
;
8062 i
= hash_lookup (h
, make_unibyte_string (family
, strlen (family
)),
8065 return kATSUInvalidFontID
;
8067 rest
= HASH_VALUE (h
, i
);
8068 if (INTEGERP (rest
) || (CONSP (rest
) && INTEGERP (XCDR (rest
))))
8069 return cons_to_long (rest
);
8071 rest
= Fnreverse (rest
);
8075 && (min_style
= fm_get_style_from_font (cons_to_long (best
))) != normal
)
8078 style
= fm_get_style_from_font (cons_to_long (XCAR (rest
)));
8079 if (style
< min_style
)
8082 if (style
== normal
)
8089 while (!NILP (rest
));
8091 HASH_VALUE (h
, i
) = best
;
8092 return cons_to_long (best
);
8096 fm_style_to_face_attributes (fm_style
)
8097 FMFontStyle fm_style
;
8101 fm_style
&= (bold
| italic
);
8102 tem
= assq_no_quit (make_number (fm_style
),
8103 fm_style_face_attributes_alist
);
8107 tem
= list4 (QCweight
, fm_style
& bold
? Qbold
: Qnormal
,
8108 QCslant
, fm_style
& italic
? Qitalic
: Qnormal
);
8109 fm_style_face_attributes_alist
=
8110 Fcons (Fcons (make_number (fm_style
), tem
),
8111 fm_style_face_attributes_alist
);
8117 atsu_find_font_family_name (font_id
)
8122 Lisp_Object family
= Qnil
;
8124 err
= ATSUFindFontName (font_id
, kFontFamilyName
,
8125 kFontMacintoshPlatform
, kFontNoScript
,
8126 kFontNoLanguage
, 0, NULL
, &len
, NULL
);
8129 family
= make_uninit_string (len
);
8130 err
= ATSUFindFontName (font_id
, kFontFamilyName
,
8131 kFontMacintoshPlatform
, kFontNoScript
,
8132 kFontNoLanguage
, len
, SDATA (family
),
8136 decode_mac_font_name (SDATA (family
), len
+ 1, Qnil
);
8142 mac_atsu_font_face_attributes (font_id
)
8145 Lisp_Object family
, style_attrs
;
8147 family
= atsu_find_font_family_name (font_id
);
8150 style_attrs
= fm_style_to_face_attributes (fm_get_style_from_font (font_id
));
8151 return Fcons (QCfamily
, Fcons (family
, style_attrs
));
8155 /* Sets up the table font_name_table to contain the list of all fonts
8156 in the system the first time the table is used so that the Resource
8157 Manager need not be accessed every time this information is
8161 init_font_name_table ()
8163 #if TARGET_API_MAC_CARBON
8164 FMFontFamilyIterator ffi
;
8165 FMFontFamilyInstanceIterator ffii
;
8167 Lisp_Object text_encoding_info_alist
;
8168 struct gcpro gcpro1
;
8170 text_encoding_info_alist
= create_text_encoding_info_alist ();
8173 #if USE_CG_TEXT_DRAWING
8174 init_cg_text_anti_aliasing_threshold ();
8176 if (!NILP (assq_no_quit (make_number (kTextEncodingMacUnicode
),
8177 text_encoding_info_alist
)))
8180 struct Lisp_Hash_Table
*h
;
8182 ItemCount nfonts
, i
;
8183 ATSUFontID
*font_ids
= NULL
;
8184 Lisp_Object prev_family
= Qnil
;
8188 make_hash_table (Qequal
, make_number (DEFAULT_HASH_SIZE
),
8189 make_float (DEFAULT_REHASH_SIZE
),
8190 make_float (DEFAULT_REHASH_THRESHOLD
),
8192 h
= XHASH_TABLE (atsu_font_id_hash
);
8194 err
= ATSUFontCount (&nfonts
);
8197 font_ids
= xmalloc (sizeof (ATSUFontID
) * nfonts
);
8198 err
= ATSUGetFontIDs (font_ids
, nfonts
, NULL
);
8201 for (i
= 0; i
< nfonts
; i
++)
8205 family
= atsu_find_font_family_name (font_ids
[i
]);
8206 if (NILP (family
) || SREF (family
, 0) == '.')
8208 if (!NILP (Fequal (prev_family
, family
)))
8209 family
= prev_family
;
8211 j
= hash_lookup (h
, family
, &hash_code
);
8214 add_mac_font_name (SDATA (family
), 0, normal
, "iso10646-1");
8215 j
= hash_put (h
, family
, Fcons (long_to_cons (font_ids
[i
]),
8218 else if (EQ (prev_family
, family
))
8219 HASH_VALUE (h
, j
) = Fcons (long_to_cons (font_ids
[i
]),
8221 prev_family
= family
;
8228 /* Create a dummy instance iterator here to avoid creating and
8229 destroying it in the loop. */
8230 if (FMCreateFontFamilyInstanceIterator (0, &ffii
) != noErr
)
8232 /* Create an iterator to enumerate the font families. */
8233 if (FMCreateFontFamilyIterator (NULL
, NULL
, kFMDefaultOptions
, &ffi
)
8236 FMDisposeFontFamilyInstanceIterator (&ffii
);
8240 GCPRO1 (text_encoding_info_alist
);
8242 while (FMGetNextFontFamily (&ffi
, &ff
) == noErr
)
8248 TextEncoding encoding
;
8249 TextEncodingBase sc
;
8250 Lisp_Object text_encoding_info
, family
;
8252 if (FMGetFontFamilyName (ff
, name
) != noErr
)
8258 if (FMGetFontFamilyTextEncoding (ff
, &encoding
) != noErr
)
8260 sc
= GetTextEncodingBase (encoding
);
8261 text_encoding_info
= assq_no_quit (make_number (sc
),
8262 text_encoding_info_alist
);
8263 if (NILP (text_encoding_info
))
8264 text_encoding_info
= assq_no_quit (make_number (kTextEncodingMacRoman
),
8265 text_encoding_info_alist
);
8266 decode_mac_font_name (name
, sizeof (name
),
8267 XCAR (XCDR (text_encoding_info
)));
8268 family
= build_string (name
);
8269 if (!NILP (Fassoc (family
, fm_font_family_alist
)))
8271 fm_font_family_alist
= Fcons (Fcons (family
, make_number (ff
)),
8272 fm_font_family_alist
);
8274 /* Point the instance iterator at the current font family. */
8275 if (FMResetFontFamilyInstanceIterator (ff
, &ffii
) != noErr
)
8278 while (FMGetNextFontFamilyInstance (&ffii
, &font
, &style
, &size
)
8281 Lisp_Object rest
= XCDR (XCDR (text_encoding_info
));
8283 if (size
> 0 || style
== normal
)
8284 for (; !NILP (rest
); rest
= XCDR (rest
))
8285 add_mac_font_name (name
, size
, style
, SDATA (XCAR (rest
)));
8291 /* Dispose of the iterators. */
8292 FMDisposeFontFamilyIterator (&ffi
);
8293 FMDisposeFontFamilyInstanceIterator (&ffii
);
8294 #else /* !TARGET_API_MAC_CARBON */
8296 SInt16 fontnum
, old_fontnum
;
8297 int num_mac_fonts
= CountResources('FOND');
8299 Handle font_handle
, font_handle_2
;
8300 short id
, scriptcode
;
8303 struct FontAssoc
*fat
;
8304 struct AsscEntry
*assc_entry
;
8305 Lisp_Object text_encoding_info_alist
, text_encoding_info
, family
;
8306 struct gcpro gcpro1
;
8308 GetPort (&port
); /* save the current font number used */
8309 old_fontnum
= port
->txFont
;
8311 text_encoding_info_alist
= create_text_encoding_info_alist ();
8313 GCPRO1 (text_encoding_info_alist
);
8315 for (i
= 1; i
<= num_mac_fonts
; i
++) /* get all available fonts */
8317 font_handle
= GetIndResource ('FOND', i
);
8321 GetResInfo (font_handle
, &id
, &type
, name
);
8322 GetFNum (name
, &fontnum
);
8324 if (fontnum
== 0 || *name
== '.')
8328 scriptcode
= FontToScript (fontnum
);
8329 text_encoding_info
= assq_no_quit (make_number (scriptcode
),
8330 text_encoding_info_alist
);
8331 if (NILP (text_encoding_info
))
8332 text_encoding_info
= assq_no_quit (make_number (smRoman
),
8333 text_encoding_info_alist
);
8334 decode_mac_font_name (name
, sizeof (name
),
8335 XCAR (XCDR (text_encoding_info
)));
8336 family
= build_string (name
);
8337 if (!NILP (Fassoc (family
, fm_font_family_alist
)))
8339 fm_font_family_alist
= Fcons (Fcons (family
, make_number (fontnum
)),
8340 fm_font_family_alist
);
8343 HLock (font_handle
);
8345 if (GetResourceSizeOnDisk (font_handle
)
8346 >= sizeof (struct FamRec
))
8348 fat
= (struct FontAssoc
*) (*font_handle
8349 + sizeof (struct FamRec
));
8351 = (struct AsscEntry
*) (*font_handle
8352 + sizeof (struct FamRec
)
8353 + sizeof (struct FontAssoc
));
8355 for (j
= 0; j
<= fat
->numAssoc
; j
++, assc_entry
++)
8357 Lisp_Object rest
= XCDR (XCDR (text_encoding_info
));
8359 for (; !NILP (rest
); rest
= XCDR (rest
))
8360 add_mac_font_name (name
, assc_entry
->fontSize
,
8361 assc_entry
->fontStyle
,
8362 SDATA (XCAR (rest
)));
8366 HUnlock (font_handle
);
8367 font_handle_2
= GetNextFOND (font_handle
);
8368 ReleaseResource (font_handle
);
8369 font_handle
= font_handle_2
;
8371 while (ResError () == noErr
&& font_handle
);
8376 TextFont (old_fontnum
);
8377 #endif /* !TARGET_API_MAC_CARBON */
8382 mac_clear_font_name_table ()
8386 for (i
= 0; i
< font_name_count
; i
++)
8387 xfree (font_name_table
[i
]);
8388 xfree (font_name_table
);
8389 font_name_table
= NULL
;
8390 font_name_table_size
= font_name_count
= 0;
8391 fm_font_family_alist
= Qnil
;
8395 enum xlfd_scalable_field_index
8397 XLFD_SCL_PIXEL_SIZE
,
8398 XLFD_SCL_POINT_SIZE
,
8403 static const int xlfd_scalable_fields
[] =
8412 mac_do_list_fonts (pattern
, maxnames
)
8413 const char *pattern
;
8417 Lisp_Object font_list
= Qnil
;
8418 struct xlfdpat
*pat
;
8421 int scl_val
[XLFD_SCL_LAST
], *val
;
8425 if (font_name_table
== NULL
) /* Initialize when first used. */
8426 init_font_name_table ();
8428 for (i
= 0; i
< XLFD_SCL_LAST
; i
++)
8431 /* If the pattern contains 14 dashes and one of PIXEL_SIZE,
8432 POINT_SIZE, and AVGWIDTH fields is explicitly specified, scalable
8433 fonts are scaled according to the specified size. */
8436 field
= xlfd_scalable_fields
;
8444 if ('0' <= *ptr
&& *ptr
<= '9')
8446 *val
= *ptr
++ - '0';
8447 while ('0' <= *ptr
&& *ptr
<= '9' && *val
< 10000)
8448 *val
= *val
* 10 + *ptr
++ - '0';
8455 ptr
= strchr (ptr
, '-');
8458 while (ptr
&& i
< 14);
8460 if (i
== 14 && ptr
== NULL
)
8462 if (scl_val
[XLFD_SCL_PIXEL_SIZE
] < 0)
8463 scl_val
[XLFD_SCL_PIXEL_SIZE
] =
8464 (scl_val
[XLFD_SCL_POINT_SIZE
] > 0 ? scl_val
[XLFD_SCL_POINT_SIZE
] / 10
8465 : (scl_val
[XLFD_SCL_AVGWIDTH
] > 0 ? scl_val
[XLFD_SCL_AVGWIDTH
] / 10
8467 if (scl_val
[XLFD_SCL_POINT_SIZE
] < 0)
8468 scl_val
[XLFD_SCL_POINT_SIZE
] =
8469 (scl_val
[XLFD_SCL_PIXEL_SIZE
] > 0 ? scl_val
[XLFD_SCL_PIXEL_SIZE
] * 10
8470 : (scl_val
[XLFD_SCL_AVGWIDTH
] > 0 ? scl_val
[XLFD_SCL_AVGWIDTH
]
8472 if (scl_val
[XLFD_SCL_AVGWIDTH
] < 0)
8473 scl_val
[XLFD_SCL_AVGWIDTH
] =
8474 (scl_val
[XLFD_SCL_PIXEL_SIZE
] > 0 ? scl_val
[XLFD_SCL_PIXEL_SIZE
] * 10
8475 : (scl_val
[XLFD_SCL_POINT_SIZE
] > 0 ? scl_val
[XLFD_SCL_POINT_SIZE
]
8479 scl_val
[XLFD_SCL_PIXEL_SIZE
] = -1;
8481 pat
= xlfdpat_create (pattern
);
8485 exact
= xlfdpat_exact_p (pat
);
8487 for (i
= 0; i
< font_name_count
; i
++)
8489 if (xlfdpat_match (pat
, font_name_table
[i
]))
8491 font_list
= Fcons (build_string (font_name_table
[i
]), font_list
);
8492 if (exact
|| (maxnames
> 0 && ++n_fonts
>= maxnames
))
8495 else if (scl_val
[XLFD_SCL_PIXEL_SIZE
] > 0
8496 && (ptr
= strstr (font_name_table
[i
], "-0-0-0-0-m-0-")))
8498 int former_len
= ptr
- font_name_table
[i
];
8500 scaled
= xmalloc (strlen (font_name_table
[i
]) + 20 + 1);
8501 memcpy (scaled
, font_name_table
[i
], former_len
);
8502 sprintf (scaled
+ former_len
,
8503 "-%d-%d-72-72-m-%d-%s",
8504 scl_val
[XLFD_SCL_PIXEL_SIZE
],
8505 scl_val
[XLFD_SCL_POINT_SIZE
],
8506 scl_val
[XLFD_SCL_AVGWIDTH
],
8507 ptr
+ sizeof ("-0-0-0-0-m-0-") - 1);
8509 if (xlfdpat_match (pat
, scaled
))
8511 font_list
= Fcons (build_string (scaled
), font_list
);
8513 if (exact
|| (maxnames
> 0 && ++n_fonts
>= maxnames
))
8521 xlfdpat_destroy (pat
);
8526 /* Return a list of names of available fonts matching PATTERN on frame F.
8528 Frame F null means we have not yet created any frame on Mac, and
8529 consult the first display in x_display_list. MAXNAMES sets a limit
8530 on how many fonts to match. */
8533 x_list_fonts (f
, pattern
, size
, maxnames
)
8535 Lisp_Object pattern
;
8538 Lisp_Object list
= Qnil
, patterns
, tem
, key
;
8539 struct mac_display_info
*dpyinfo
8540 = f
? FRAME_MAC_DISPLAY_INFO (f
) : x_display_list
;
8542 xassert (size
<= 0);
8544 patterns
= Fassoc (pattern
, Valternate_fontname_alist
);
8545 if (NILP (patterns
))
8546 patterns
= Fcons (pattern
, Qnil
);
8548 for (; CONSP (patterns
); patterns
= XCDR (patterns
))
8550 pattern
= XCAR (patterns
);
8552 if (!STRINGP (pattern
))
8555 tem
= XCAR (XCDR (dpyinfo
->name_list_element
));
8556 key
= Fcons (pattern
, make_number (maxnames
));
8558 list
= Fassoc (key
, tem
);
8561 list
= Fcdr_safe (list
);
8562 /* We have a cashed list. Don't have to get the list again. */
8567 list
= mac_do_list_fonts (SDATA (pattern
), maxnames
);
8570 /* MAC_TODO: add code for matching outline fonts here */
8572 /* Now store the result in the cache. */
8573 XSETCAR (XCDR (dpyinfo
->name_list_element
),
8574 Fcons (Fcons (key
, list
),
8575 XCAR (XCDR (dpyinfo
->name_list_element
))));
8578 if (NILP (list
)) continue; /* Try the remaining alternatives. */
8587 /* Check that FONT is valid on frame F. It is if it can be found in F's
8591 x_check_font (f
, font
)
8596 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
8598 xassert (font
!= NULL
);
8600 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
8601 if (dpyinfo
->font_table
[i
].name
8602 && font
== dpyinfo
->font_table
[i
].font
)
8605 xassert (i
< dpyinfo
->n_fonts
);
8608 #endif /* GLYPH_DEBUG != 0 */
8610 /* Set *W to the minimum width, *H to the minimum font height of FONT.
8611 Note: There are (broken) X fonts out there with invalid XFontStruct
8612 min_bounds contents. For example, handa@etl.go.jp reports that
8613 "-adobe-courier-medium-r-normal--*-180-*-*-m-*-iso8859-1" fonts
8614 have font->min_bounds.width == 0. */
8617 x_font_min_bounds (font
, w
, h
)
8618 MacFontStruct
*font
;
8621 *h
= FONT_HEIGHT (font
);
8622 *w
= font
->min_bounds
.width
;
8626 /* Compute the smallest character width and smallest font height over
8627 all fonts available on frame F. Set the members smallest_char_width
8628 and smallest_font_height in F's x_display_info structure to
8629 the values computed. Value is non-zero if smallest_font_height or
8630 smallest_char_width become smaller than they were before. */
8633 x_compute_min_glyph_bounds (f
)
8637 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
8638 MacFontStruct
*font
;
8639 int old_width
= dpyinfo
->smallest_char_width
;
8640 int old_height
= dpyinfo
->smallest_font_height
;
8642 dpyinfo
->smallest_font_height
= 100000;
8643 dpyinfo
->smallest_char_width
= 100000;
8645 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
8646 if (dpyinfo
->font_table
[i
].name
)
8648 struct font_info
*fontp
= dpyinfo
->font_table
+ i
;
8651 font
= (MacFontStruct
*) fontp
->font
;
8652 xassert (font
!= (MacFontStruct
*) ~0);
8653 x_font_min_bounds (font
, &w
, &h
);
8655 dpyinfo
->smallest_font_height
= min (dpyinfo
->smallest_font_height
, h
);
8656 dpyinfo
->smallest_char_width
= min (dpyinfo
->smallest_char_width
, w
);
8659 xassert (dpyinfo
->smallest_char_width
> 0
8660 && dpyinfo
->smallest_font_height
> 0);
8662 return (dpyinfo
->n_fonts
== 1
8663 || dpyinfo
->smallest_char_width
< old_width
8664 || dpyinfo
->smallest_font_height
< old_height
);
8668 /* Determine whether given string is a fully-specified XLFD: all 14
8669 fields are present, none is '*'. */
8672 is_fully_specified_xlfd (p
)
8681 for (i
= 0; i
< 13; i
++)
8683 q
= strchr (p
+ 1, '-');
8686 if (q
- p
== 2 && *(p
+ 1) == '*')
8691 if (strchr (p
+ 1, '-') != NULL
)
8694 if (*(p
+ 1) == '*' && *(p
+ 2) == '\0')
8701 /* mac_load_query_font creates and returns an internal representation
8702 for a font in a MacFontStruct struct. There is really no concept
8703 corresponding to "loading" a font on the Mac. But we check its
8704 existence and find the font number and all other information for it
8705 and store them in the returned MacFontStruct. */
8707 static MacFontStruct
*
8708 mac_load_query_font (f
, fontname
)
8718 static ATSUFontID font_id
;
8719 ATSUStyle mac_style
= NULL
;
8722 #if TARGET_API_MAC_CARBON
8723 TextEncoding encoding
;
8728 MacFontStruct
*font
;
8729 XCharStruct
*space_bounds
= NULL
, *pcm
;
8731 if (is_fully_specified_xlfd (fontname
))
8735 Lisp_Object matched_fonts
;
8737 matched_fonts
= mac_do_list_fonts (fontname
, 1);
8738 if (NILP (matched_fonts
))
8740 name
= SDATA (XCAR (matched_fonts
));
8743 if (parse_x_font_name (name
, family
, &size
, &fontface
, charset
) == 0)
8747 if (strcmp (charset
, "iso10646-1") == 0) /* XXX */
8750 static const ATSUAttributeTag tags
[] =
8751 {kATSUFontTag
, kATSUSizeTag
,
8752 kATSUQDBoldfaceTag
, kATSUQDItalicTag
};
8753 static const ByteCount sizes
[] =
8754 {sizeof (ATSUFontID
), sizeof (Fixed
),
8755 sizeof (Boolean
), sizeof (Boolean
)};
8756 static Fixed size_fixed
;
8757 static Boolean bold_p
, italic_p
;
8758 static const ATSUAttributeValuePtr values
[] =
8759 {&font_id
, &size_fixed
,
8760 &bold_p
, &italic_p
};
8761 static const ATSUFontFeatureType types
[] =
8762 {kAllTypographicFeaturesType
, kDiacriticsType
};
8763 static const ATSUFontFeatureSelector selectors
[] =
8764 {kAllTypeFeaturesOffSelector
, kDecomposeDiacriticsSelector
};
8767 font_id
= atsu_find_font_from_family_name (family
);
8768 if (font_id
== kATSUInvalidFontID
)
8770 size_fixed
= Long2Fix (size
);
8771 bold_p
= (fontface
& bold
) != 0;
8772 italic_p
= (fontface
& italic
) != 0;
8773 err
= ATSUCreateStyle (&mac_style
);
8776 err
= ATSUSetFontFeatures (mac_style
, sizeof (types
) / sizeof (types
[0]),
8780 err
= ATSUSetAttributes (mac_style
, sizeof (tags
) / sizeof (tags
[0]),
8781 tags
, sizes
, values
);
8784 err
= FMGetFontFamilyInstanceFromFont (font_id
, &fontnum
, &style
);
8787 scriptcode
= kTextEncodingMacUnicode
;
8792 Lisp_Object tmp
= Fassoc (build_string (family
), fm_font_family_alist
);
8796 fontnum
= XINT (XCDR (tmp
));
8797 #if TARGET_API_MAC_CARBON
8798 if (FMGetFontFamilyTextEncoding (fontnum
, &encoding
) != noErr
)
8800 scriptcode
= GetTextEncodingBase (encoding
);
8802 scriptcode
= FontToScript (fontnum
);
8806 font
= (MacFontStruct
*) xmalloc (sizeof (struct MacFontStruct
));
8808 font
->mac_fontnum
= fontnum
;
8809 font
->mac_fontsize
= size
;
8810 font
->mac_fontface
= fontface
;
8811 font
->mac_scriptcode
= scriptcode
;
8813 font
->mac_style
= mac_style
;
8814 #if USE_CG_TEXT_DRAWING
8815 font
->cg_font
= NULL
;
8816 font
->cg_glyphs
= NULL
;
8820 /* Apple Japanese (SJIS) font is listed as both
8821 "*-jisx0208.1983-sjis" (Japanese script) and "*-jisx0201.1976-0"
8822 (Roman script) in init_font_name_table (). The latter should be
8823 treated as a one-byte font. */
8824 if (scriptcode
== smJapanese
&& strcmp (charset
, "jisx0201.1976-0") == 0)
8825 font
->mac_scriptcode
= smRoman
;
8827 font
->full_name
= mac_to_x_fontname (family
, size
, fontface
, charset
);
8830 if (font
->mac_style
)
8835 font
->min_byte1
= 0;
8836 font
->max_byte1
= 0xff;
8837 font
->min_char_or_byte2
= 0;
8838 font
->max_char_or_byte2
= 0xff;
8840 font
->bounds
.rows
= xmalloc (sizeof (XCharStruct
*) * 0x100);
8841 bzero (font
->bounds
.rows
, sizeof (XCharStruct
*) * 0x100);
8842 font
->bounds
.rows
[0] = xmalloc (sizeof (XCharStruct
) * 0x100);
8843 pcm_init (font
->bounds
.rows
[0], 0x100);
8845 #if USE_CG_TEXT_DRAWING
8849 ATSFontRef ats_font
;
8851 err
= FMGetFontFromFontFamilyInstance (fontnum
, fontface
,
8853 /* Use CG text drawing if italic/bold is not synthesized. */
8854 if (err
== noErr
&& style
== fontface
)
8856 ats_font
= FMGetATSFontRefFromFont (font_id
);
8857 font
->cg_font
= CGFontCreateWithPlatformFont (&ats_font
);
8863 font
->cg_glyphs
= xmalloc (sizeof (CGGlyph
) * 0x100);
8864 bzero (font
->cg_glyphs
, sizeof (CGGlyph
) * 0x100);
8867 space_bounds
= font
->bounds
.rows
[0] + 0x20;
8868 err
= mac_query_char_extents (font
->mac_style
, 0x20,
8869 &font
->ascent
, &font
->descent
,
8871 #if USE_CG_TEXT_DRAWING
8872 (font
->cg_glyphs
? font
->cg_glyphs
+ 0x20
8879 || space_bounds
->width
<= 0 || FONT_HEIGHT (font
) <= 0)
8881 mac_unload_font (&one_mac_display_info
, font
);
8885 pcm
= font
->bounds
.rows
[0];
8886 for (c
= 0x21; c
<= 0xff; c
++)
8889 /* Soft hyphen is not supported in ATSUI. */
8893 #if USE_CG_TEXT_DRAWING
8894 if (font
->cg_glyphs
)
8904 mac_query_char_extents (font
->mac_style
, c
, NULL
, NULL
,
8905 pcm
? pcm
+ c
: NULL
,
8906 #if USE_CG_TEXT_DRAWING
8907 (font
->cg_glyphs
? font
->cg_glyphs
+ c
8914 #if USE_CG_TEXT_DRAWING
8915 if (font
->cg_glyphs
&& font
->cg_glyphs
[c
] == 0)
8917 /* Don't use CG text drawing if font substitution occurs in
8918 ASCII or Latin-1 characters. */
8919 CGFontRelease (font
->cg_font
);
8920 font
->cg_font
= NULL
;
8921 xfree (font
->cg_glyphs
);
8922 font
->cg_glyphs
= NULL
;
8933 FontInfo the_fontinfo
;
8934 int is_two_byte_font
;
8937 mac_prepare_for_quickdraw (f
);
8939 SetPortWindowPort (FRAME_MAC_WINDOW (f
));
8943 TextFace (fontface
);
8945 GetFontInfo (&the_fontinfo
);
8947 font
->ascent
= the_fontinfo
.ascent
;
8948 font
->descent
= the_fontinfo
.descent
;
8950 is_two_byte_font
= (font
->mac_scriptcode
== smJapanese
8951 || font
->mac_scriptcode
== smTradChinese
8952 || font
->mac_scriptcode
== smSimpChinese
8953 || font
->mac_scriptcode
== smKorean
);
8955 if (is_two_byte_font
)
8959 font
->min_byte1
= 0xa1;
8960 font
->max_byte1
= 0xfe;
8961 font
->min_char_or_byte2
= 0xa1;
8962 font
->max_char_or_byte2
= 0xfe;
8964 /* Use the width of an "ideographic space" of that font
8965 because the_fontinfo.widMax returns the wrong width for
8967 switch (font
->mac_scriptcode
)
8970 font
->min_byte1
= 0x81;
8971 font
->max_byte1
= 0xfc;
8972 font
->min_char_or_byte2
= 0x40;
8973 font
->max_char_or_byte2
= 0xfc;
8974 char_width
= StringWidth("\p\x81\x40");
8977 font
->min_char_or_byte2
= 0x40;
8978 char_width
= StringWidth("\p\xa1\x40");
8981 char_width
= StringWidth("\p\xa1\xa1");
8984 char_width
= StringWidth("\p\xa1\xa1");
8988 font
->bounds
.per_char
= NULL
;
8990 if (fontface
& italic
)
8991 font
->max_bounds
.rbearing
= char_width
+ 1;
8993 font
->max_bounds
.rbearing
= char_width
;
8994 font
->max_bounds
.lbearing
= 0;
8995 font
->max_bounds
.width
= char_width
;
8996 font
->max_bounds
.ascent
= the_fontinfo
.ascent
;
8997 font
->max_bounds
.descent
= the_fontinfo
.descent
;
8999 font
->min_bounds
= font
->max_bounds
;
9005 font
->min_byte1
= font
->max_byte1
= 0;
9006 font
->min_char_or_byte2
= 0x20;
9007 font
->max_char_or_byte2
= 0xff;
9009 font
->bounds
.per_char
=
9010 xmalloc (sizeof (XCharStruct
) * (0xff - 0x20 + 1));
9011 bzero (font
->bounds
.per_char
,
9012 sizeof (XCharStruct
) * (0xff - 0x20 + 1));
9014 space_bounds
= font
->bounds
.per_char
;
9015 err
= mac_query_char_extents (NULL
, 0x20, &font
->ascent
,
9016 &font
->descent
, space_bounds
, NULL
);
9017 if (err
!= noErr
|| space_bounds
->width
<= 0)
9019 mac_unload_font (&one_mac_display_info
, font
);
9023 for (c
= 0x21, pcm
= space_bounds
+ 1; c
<= 0xff; c
++, pcm
++)
9024 mac_query_char_extents (NULL
, c
, NULL
, NULL
, pcm
, NULL
);
9032 font
->min_bounds
= font
->max_bounds
= *space_bounds
;
9033 for (c
= 0x21, pcm
= space_bounds
+ 1; c
<= 0x7f; c
++, pcm
++)
9036 font
->min_bounds
.lbearing
= min (font
->min_bounds
.lbearing
,
9038 font
->min_bounds
.rbearing
= min (font
->min_bounds
.rbearing
,
9040 font
->min_bounds
.width
= min (font
->min_bounds
.width
,
9042 font
->min_bounds
.ascent
= min (font
->min_bounds
.ascent
,
9044 font
->min_bounds
.descent
= min (font
->min_bounds
.descent
,
9047 font
->max_bounds
.lbearing
= max (font
->max_bounds
.lbearing
,
9049 font
->max_bounds
.rbearing
= max (font
->max_bounds
.rbearing
,
9051 font
->max_bounds
.width
= max (font
->max_bounds
.width
,
9053 font
->max_bounds
.ascent
= max (font
->max_bounds
.ascent
,
9055 font
->max_bounds
.descent
= max (font
->max_bounds
.descent
,
9060 font
->mac_style
== NULL
&&
9062 font
->max_bounds
.width
== font
->min_bounds
.width
9063 && font
->min_bounds
.lbearing
>= 0
9064 && font
->max_bounds
.rbearing
<= font
->max_bounds
.width
)
9066 /* Fixed width and no overhangs. */
9067 xfree (font
->bounds
.per_char
);
9068 font
->bounds
.per_char
= NULL
;
9072 #if !defined (MAC_OS8) || USE_ATSUI
9073 /* AppKit and WebKit do some adjustment to the heights of Courier,
9074 Helvetica, and Times. This only works on the environments where
9075 srcCopy text transfer mode is never used. */
9077 #ifdef MAC_OS8 /* implies USE_ATSUI */
9080 (strcmp (family
, "courier") == 0 || strcmp (family
, "helvetica") == 0
9081 || strcmp (family
, "times") == 0))
9082 font
->ascent
+= (font
->ascent
+ font
->descent
) * .15 + 0.5;
9090 mac_unload_font (dpyinfo
, font
)
9091 struct mac_display_info
*dpyinfo
;
9094 xfree (font
->full_name
);
9096 if (font
->mac_style
)
9100 for (i
= font
->min_byte1
; i
<= font
->max_byte1
; i
++)
9101 if (font
->bounds
.rows
[i
])
9102 xfree (font
->bounds
.rows
[i
]);
9103 xfree (font
->bounds
.rows
);
9104 ATSUDisposeStyle (font
->mac_style
);
9108 if (font
->bounds
.per_char
)
9109 xfree (font
->bounds
.per_char
);
9110 #if USE_CG_TEXT_DRAWING
9112 CGFontRelease (font
->cg_font
);
9113 if (font
->cg_glyphs
)
9114 xfree (font
->cg_glyphs
);
9120 /* Load font named FONTNAME of the size SIZE for frame F, and return a
9121 pointer to the structure font_info while allocating it dynamically.
9122 If SIZE is 0, load any size of font.
9123 If loading is failed, return NULL. */
9126 x_load_font (f
, fontname
, size
)
9128 register char *fontname
;
9131 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
9132 Lisp_Object font_names
;
9134 /* Get a list of all the fonts that match this name. Once we
9135 have a list of matching fonts, we compare them against the fonts
9136 we already have by comparing names. */
9137 font_names
= x_list_fonts (f
, build_string (fontname
), size
, 1);
9139 if (!NILP (font_names
))
9144 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
9145 for (tail
= font_names
; CONSP (tail
); tail
= XCDR (tail
))
9146 if (dpyinfo
->font_table
[i
].name
9147 && (!strcmp (dpyinfo
->font_table
[i
].name
,
9148 SDATA (XCAR (tail
)))
9149 || !strcmp (dpyinfo
->font_table
[i
].full_name
,
9150 SDATA (XCAR (tail
)))))
9151 return (dpyinfo
->font_table
+ i
);
9156 /* Load the font and add it to the table. */
9158 struct MacFontStruct
*font
;
9159 struct font_info
*fontp
;
9162 fontname
= (char *) SDATA (XCAR (font_names
));
9165 font
= mac_load_query_font (f
, fontname
);
9170 /* Find a free slot in the font table. */
9171 for (i
= 0; i
< dpyinfo
->n_fonts
; ++i
)
9172 if (dpyinfo
->font_table
[i
].name
== NULL
)
9175 /* If no free slot found, maybe enlarge the font table. */
9176 if (i
== dpyinfo
->n_fonts
9177 && dpyinfo
->n_fonts
== dpyinfo
->font_table_size
)
9180 dpyinfo
->font_table_size
= max (16, 2 * dpyinfo
->font_table_size
);
9181 sz
= dpyinfo
->font_table_size
* sizeof *dpyinfo
->font_table
;
9183 = (struct font_info
*) xrealloc (dpyinfo
->font_table
, sz
);
9186 fontp
= dpyinfo
->font_table
+ i
;
9187 if (i
== dpyinfo
->n_fonts
)
9190 /* Now fill in the slots of *FONTP. */
9192 bzero (fontp
, sizeof (*fontp
));
9194 fontp
->font_idx
= i
;
9195 fontp
->name
= (char *) xmalloc (strlen (fontname
) + 1);
9196 bcopy (fontname
, fontp
->name
, strlen (fontname
) + 1);
9198 if (font
->min_bounds
.width
== font
->max_bounds
.width
)
9200 /* Fixed width font. */
9201 fontp
->average_width
= fontp
->space_width
= font
->min_bounds
.width
;
9208 char2b
.byte1
= 0x00, char2b
.byte2
= 0x20;
9209 pcm
= mac_per_char_metric (font
, &char2b
, 0);
9211 fontp
->space_width
= pcm
->width
;
9213 fontp
->space_width
= FONT_WIDTH (font
);
9217 int width
= pcm
->width
;
9218 for (char2b
.byte2
= 33; char2b
.byte2
<= 126; char2b
.byte2
++)
9219 if ((pcm
= mac_per_char_metric (font
, &char2b
, 0)) != NULL
)
9220 width
+= pcm
->width
;
9221 fontp
->average_width
= width
/ 95;
9224 fontp
->average_width
= FONT_WIDTH (font
);
9227 fontp
->full_name
= (char *) xmalloc (strlen (font
->full_name
) + 1);
9228 bcopy (font
->full_name
, fontp
->full_name
, strlen (font
->full_name
) + 1);
9230 fontp
->size
= font
->max_bounds
.width
;
9231 fontp
->height
= FONT_HEIGHT (font
);
9233 /* For some font, ascent and descent in max_bounds field is
9234 larger than the above value. */
9235 int max_height
= font
->max_bounds
.ascent
+ font
->max_bounds
.descent
;
9236 if (max_height
> fontp
->height
)
9237 fontp
->height
= max_height
;
9240 /* The slot `encoding' specifies how to map a character
9241 code-points (0x20..0x7F or 0x2020..0x7F7F) of each charset to
9242 the font code-points (0:0x20..0x7F, 1:0xA0..0xFF), or
9243 (0:0x2020..0x7F7F, 1:0xA0A0..0xFFFF, 3:0x20A0..0x7FFF,
9244 2:0xA020..0xFF7F). For the moment, we don't know which charset
9245 uses this font. So, we set information in fontp->encoding[1]
9246 which is never used by any charset. If mapping can't be
9247 decided, set FONT_ENCODING_NOT_DECIDED. */
9248 if (font
->mac_scriptcode
== smJapanese
)
9249 fontp
->encoding
[1] = 4;
9253 = (font
->max_byte1
== 0
9255 ? (font
->min_char_or_byte2
< 0x80
9256 ? (font
->max_char_or_byte2
< 0x80
9257 ? 0 /* 0x20..0x7F */
9258 : FONT_ENCODING_NOT_DECIDED
) /* 0x20..0xFF */
9259 : 1) /* 0xA0..0xFF */
9261 : (font
->min_byte1
< 0x80
9262 ? (font
->max_byte1
< 0x80
9263 ? (font
->min_char_or_byte2
< 0x80
9264 ? (font
->max_char_or_byte2
< 0x80
9265 ? 0 /* 0x2020..0x7F7F */
9266 : FONT_ENCODING_NOT_DECIDED
) /* 0x2020..0x7FFF */
9267 : 3) /* 0x20A0..0x7FFF */
9268 : FONT_ENCODING_NOT_DECIDED
) /* 0x20??..0xA0?? */
9269 : (font
->min_char_or_byte2
< 0x80
9270 ? (font
->max_char_or_byte2
< 0x80
9271 ? 2 /* 0xA020..0xFF7F */
9272 : FONT_ENCODING_NOT_DECIDED
) /* 0xA020..0xFFFF */
9273 : 1))); /* 0xA0A0..0xFFFF */
9276 #if 0 /* MAC_TODO: fill these out with more reasonably values */
9277 fontp
->baseline_offset
9278 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_BASELINE_OFFSET
, &value
)
9279 ? (long) value
: 0);
9280 fontp
->relative_compose
9281 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_RELATIVE_COMPOSE
, &value
)
9282 ? (long) value
: 0);
9283 fontp
->default_ascent
9284 = (XGetFontProperty (font
, dpyinfo
->Xatom_MULE_DEFAULT_ASCENT
, &value
)
9285 ? (long) value
: 0);
9287 fontp
->baseline_offset
= 0;
9288 fontp
->relative_compose
= 0;
9289 fontp
->default_ascent
= 0;
9292 /* Set global flag fonts_changed_p to non-zero if the font loaded
9293 has a character with a smaller width than any other character
9294 before, or if the font loaded has a smaller height than any
9295 other font loaded before. If this happens, it will make a
9296 glyph matrix reallocation necessary. */
9297 fonts_changed_p
|= x_compute_min_glyph_bounds (f
);
9304 /* Return a pointer to struct font_info of a font named FONTNAME for
9305 frame F. If no such font is loaded, return NULL. */
9308 x_query_font (f
, fontname
)
9310 register char *fontname
;
9312 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
9315 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
9316 if (dpyinfo
->font_table
[i
].name
9317 && (!xstricmp (dpyinfo
->font_table
[i
].name
, fontname
)
9318 || !xstricmp (dpyinfo
->font_table
[i
].full_name
, fontname
)))
9319 return (dpyinfo
->font_table
+ i
);
9324 /* Find a CCL program for a font specified by FONTP, and set the member
9325 `encoder' of the structure. */
9328 x_find_ccl_program (fontp
)
9329 struct font_info
*fontp
;
9331 Lisp_Object list
, elt
;
9333 for (list
= Vfont_ccl_encoder_alist
; CONSP (list
); list
= XCDR (list
))
9337 && STRINGP (XCAR (elt
))
9338 && (fast_c_string_match_ignore_case (XCAR (elt
), fontp
->name
)
9344 struct ccl_program
*ccl
9345 = (struct ccl_program
*) xmalloc (sizeof (struct ccl_program
));
9347 if (setup_ccl_program (ccl
, XCDR (elt
)) < 0)
9350 fontp
->font_encoder
= ccl
;
9354 #if USE_MAC_FONT_PANEL
9355 /* Whether Font Panel has been shown before. The first call to font
9356 panel functions (FPIsFontPanelVisible, SetFontInfoForSelection) is
9357 slow. This variable is used for deferring such a call as much as
9359 static int font_panel_shown_p
= 0;
9361 extern Lisp_Object Qfont
;
9362 static Lisp_Object Qpanel_closed
, Qselection
;
9364 static OSStatus mac_store_event_ref_as_apple_event
P_ ((AEEventClass
, AEEventID
,
9368 const EventParamName
*,
9369 const EventParamType
*));
9372 mac_font_panel_visible_p ()
9374 return font_panel_shown_p
&& FPIsFontPanelVisible ();
9377 static pascal OSStatus
9378 mac_handle_font_event (next_handler
, event
, data
)
9379 EventHandlerCallRef next_handler
;
9383 OSStatus result
, err
;
9386 const EventParamName
*names
;
9387 const EventParamType
*types
;
9388 static const EventParamName names_sel
[] = {kEventParamATSUFontID
,
9389 kEventParamATSUFontSize
,
9390 kEventParamFMFontFamily
,
9391 kEventParamFMFontStyle
,
9392 kEventParamFMFontSize
,
9393 kEventParamFontColor
};
9394 static const EventParamType types_sel
[] = {typeATSUFontID
,
9401 result
= CallNextEventHandler (next_handler
, event
);
9402 if (result
!= eventNotHandledErr
)
9405 switch (GetEventKind (event
))
9407 case kEventFontPanelClosed
:
9408 id_key
= Qpanel_closed
;
9414 case kEventFontSelection
:
9415 id_key
= Qselection
;
9416 num_params
= sizeof (names_sel
) / sizeof (names_sel
[0]);
9422 err
= mac_store_event_ref_as_apple_event (0, 0, Qfont
, id_key
,
9432 mac_show_hide_font_panel ()
9434 if (!font_panel_shown_p
)
9438 static const EventTypeSpec specs
[] =
9439 {{kEventClassFont
, kEventFontPanelClosed
},
9440 {kEventClassFont
, kEventFontSelection
}};
9442 err
= InstallApplicationEventHandler (mac_handle_font_event
,
9443 GetEventTypeCount (specs
),
9448 font_panel_shown_p
= 1;
9451 return FPShowHideFontPanel ();
9455 mac_set_font_info_for_selection (f
, face_id
, c
)
9460 EventTargetRef target
= NULL
;
9461 XFontStruct
*font
= NULL
;
9463 if (!mac_font_panel_visible_p ())
9468 target
= GetWindowEventTarget (FRAME_MAC_WINDOW (f
));
9470 if (FRAME_FACE_CACHE (f
) && CHAR_VALID_P (c
, 0))
9474 face_id
= FACE_FOR_CHAR (f
, FACE_FROM_ID (f
, face_id
), c
);
9475 face
= FACE_FROM_ID (f
, face_id
);
9481 err
= SetFontInfoForSelection (kFontSelectionATSUIType
, 0, NULL
, target
);
9484 if (font
->mac_fontnum
!= -1)
9486 FontSelectionQDStyle qd_style
;
9488 qd_style
.version
= kFontSelectionQDStyleVersionZero
;
9489 qd_style
.instance
.fontFamily
= font
->mac_fontnum
;
9490 qd_style
.instance
.fontStyle
= font
->mac_fontface
;
9491 qd_style
.size
= font
->mac_fontsize
;
9492 qd_style
.hasColor
= false;
9494 err
= SetFontInfoForSelection (kFontSelectionQDType
,
9495 1, &qd_style
, target
);
9498 err
= SetFontInfoForSelection (kFontSelectionATSUIType
,
9499 1, &font
->mac_style
, target
);
9507 /* The Mac Event loop code */
9509 #if !TARGET_API_MAC_CARBON
9511 #include <Quickdraw.h>
9512 #include <Balloons.h>
9513 #include <Devices.h>
9515 #include <Gestalt.h>
9517 #include <Processes.h>
9519 #include <ToolUtils.h>
9520 #include <TextUtils.h>
9521 #include <Dialogs.h>
9524 #include <Resources.h>
9529 #endif /* ! TARGET_API_MAC_CARBON */
9534 #define DEFAULT_NUM_COLS 80
9536 #define MIN_DOC_SIZE 64
9537 #define MAX_DOC_SIZE 32767
9539 #define EXTRA_STACK_ALLOC (256 * 1024)
9541 #define ARGV_STRING_LIST_ID 129
9542 #define ABOUT_ALERT_ID 128
9543 #define RAM_TOO_LARGE_ALERT_ID 129
9545 /* Contains the string "reverse", which is a constant for mouse button emu.*/
9546 Lisp_Object Qreverse
;
9549 /* Modifier associated with the control key, or nil to ignore. */
9550 Lisp_Object Vmac_control_modifier
;
9552 /* Modifier associated with the option key, or nil to ignore. */
9553 Lisp_Object Vmac_option_modifier
;
9555 /* Modifier associated with the command key, or nil to ignore. */
9556 Lisp_Object Vmac_command_modifier
;
9558 /* Modifier associated with the function key, or nil to ignore. */
9559 Lisp_Object Vmac_function_modifier
;
9561 /* True if the option and command modifiers should be used to emulate
9562 a three button mouse */
9563 Lisp_Object Vmac_emulate_three_button_mouse
;
9565 #if TARGET_API_MAC_CARBON
9566 /* Non-zero if the mouse wheel button (i.e. button 4) should map to
9567 mouse-2, instead of mouse-3. */
9568 int mac_wheel_button_is_mouse_2
;
9570 /* If non-zero, the Mac "Command" key is passed on to the Mac Toolbox
9571 for processing before Emacs sees it. */
9572 int mac_pass_command_to_system
;
9574 /* If non-zero, the Mac "Control" key is passed on to the Mac Toolbox
9575 for processing before Emacs sees it. */
9576 int mac_pass_control_to_system
;
9579 /* Points to the variable `inev' in the function XTread_socket. It is
9580 used for passing an input event to the function back from
9581 Carbon/Apple event handlers. */
9582 static struct input_event
*read_socket_inev
= NULL
;
9584 /* Whether or not the screen configuration has changed. */
9585 static int mac_screen_config_changed
= 0;
9587 Point saved_menu_event_location
;
9590 #if TARGET_API_MAC_CARBON
9591 static Lisp_Object Qhi_command
;
9593 extern Lisp_Object Qwindow
;
9594 static Lisp_Object Qtoolbar_switch_mode
;
9597 static TSMDocumentID tsm_document_id
;
9598 static Lisp_Object Qtext_input
;
9599 static Lisp_Object Qupdate_active_input_area
, Qunicode_for_key_event
;
9600 static Lisp_Object Vmac_ts_active_input_overlay
;
9601 extern Lisp_Object Qbefore_string
;
9602 static Lisp_Object Vmac_ts_script_language_on_focus
;
9603 static Lisp_Object saved_ts_script_language_on_focus
;
9604 static ScriptLanguageRecord saved_ts_language
;
9605 static Component saved_ts_component
;
9607 #endif /* TARGET_API_MAC_CARBON */
9608 extern int mac_ready_for_apple_events
;
9609 extern Lisp_Object Qundefined
;
9610 extern void init_apple_event_handler
P_ ((void));
9611 extern void mac_find_apple_event_spec
P_ ((AEEventClass
, AEEventID
,
9612 Lisp_Object
*, Lisp_Object
*,
9614 extern OSErr init_coercion_handler
P_ ((void));
9617 extern OSErr install_drag_handler
P_ ((WindowRef
));
9618 extern void remove_drag_handler
P_ ((WindowRef
));
9620 #if TARGET_API_MAC_CARBON
9621 /* Showing help echo string during menu tracking */
9622 extern OSStatus install_menu_target_item_handler
P_ ((void));
9625 extern OSStatus
install_service_handler ();
9626 static Lisp_Object Qservice
, Qpaste
, Qperform
;
9630 extern void init_emacs_passwd_dir ();
9631 extern int emacs_main (int, char **, char **);
9633 extern void initialize_applescript();
9634 extern void terminate_applescript();
9636 /* Table for translating Mac keycode to X keysym values. Contributed
9638 Mapping for special keys is now identical to that in Apple X11
9639 except `clear' (-> <clear>) on the KeyPad, `enter' (-> <kp-enter>)
9640 on the right of the Cmd key on laptops, and fn + `enter' (->
9642 static const unsigned char keycode_to_xkeysym_table
[] = {
9643 /*0x00*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9644 /*0x10*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9645 /*0x20*/ 0, 0, 0, 0, 0x0d /*return*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9647 /*0x30*/ 0x09 /*tab*/, 0 /*0x0020 space*/, 0, 0x08 /*backspace*/,
9648 /*0x34*/ 0x8d /*enter on laptops*/, 0x1b /*escape*/, 0, 0,
9649 /*0x38*/ 0, 0, 0, 0,
9650 /*0x3C*/ 0, 0, 0, 0,
9652 /*0x40*/ 0, 0xae /*kp-decimal*/, 0, 0xaa /*kp-multiply*/,
9653 /*0x44*/ 0, 0xab /*kp-add*/, 0, 0x0b /*clear*/,
9654 /*0x48*/ 0, 0, 0, 0xaf /*kp-divide*/,
9655 /*0x4C*/ 0x8d /*kp-enter*/, 0, 0xad /*kp-subtract*/, 0,
9657 /*0x50*/ 0, 0xbd /*kp-equal*/, 0xb0 /*kp-0*/, 0xb1 /*kp-1*/,
9658 /*0x54*/ 0xb2 /*kp-2*/, 0xb3 /*kp-3*/, 0xb4 /*kp-4*/, 0xb5 /*kp-5*/,
9659 /*0x58*/ 0xb6 /*kp-6*/, 0xb7 /*kp-7*/, 0, 0xb8 /*kp-8*/,
9660 /*0x5C*/ 0xb9 /*kp-9*/, 0, 0, 0,
9662 /*0x60*/ 0xc2 /*f5*/, 0xc3 /*f6*/, 0xc4 /*f7*/, 0xc0 /*f3*/,
9663 /*0x64*/ 0xc5 /*f8*/, 0xc6 /*f9*/, 0, 0xc8 /*f11*/,
9664 /*0x68*/ 0, 0xca /*f13*/, 0xcd /*f16*/, 0xcb /*f14*/,
9665 /*0x6C*/ 0, 0xc7 /*f10*/, 0x0a /*fn+enter on laptops*/, 0xc9 /*f12*/,
9667 /*0x70*/ 0, 0xcc /*f15*/, 0x6a /*help*/, 0x50 /*home*/,
9668 /*0x74*/ 0x55 /*pgup*/, 0xff /*delete*/, 0xc1 /*f4*/, 0x57 /*end*/,
9669 /*0x78*/ 0xbf /*f2*/, 0x56 /*pgdown*/, 0xbe /*f1*/, 0x51 /*left*/,
9670 /*0x7C*/ 0x53 /*right*/, 0x54 /*down*/, 0x52 /*up*/, 0
9674 /* Table for translating Mac keycode with the laptop `fn' key to that
9675 without it. Destination symbols in comments are keys on US
9676 keyboard, and they may not be the same on other types of keyboards.
9677 If the destination is identical to the source (f1 ... f12), it
9678 doesn't map `fn' key to a modifier. */
9679 static const unsigned char fn_keycode_to_keycode_table
[] = {
9680 /*0x00*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9681 /*0x10*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9682 /*0x20*/ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
9684 /*0x30*/ 0, 0, 0, 0,
9685 /*0x34*/ 0, 0, 0, 0,
9686 /*0x38*/ 0, 0, 0, 0,
9687 /*0x3C*/ 0, 0, 0, 0,
9689 /*0x40*/ 0, 0x2f /*kp-decimal -> '.'*/, 0, 0x23 /*kp-multiply -> 'p'*/,
9690 /*0x44*/ 0, 0x2c /*kp-add -> '/'*/, 0, 0x16 /*clear -> '6'*/,
9691 /*0x48*/ 0, 0, 0, 0x1d /*kp-/ -> '0'*/,
9692 /*0x4C*/ 0x24 /*kp-enter -> return*/, 0, 0x29 /*kp-subtract -> ';'*/, 0,
9694 /*0x50*/ 0, 0x1b /*kp-equal -> '-'*/, 0x2e /*kp-0 -> 'm'*/, 0x26 /*kp-1 -> 'j'*/,
9695 /*0x54*/ 0x28 /*kp-2 -> 'k'*/, 0x25 /*kp-3 -> 'l'*/, 0x20 /*kp-4 -> 'u'*/, 0x22 /*kp-5 ->'i'*/,
9696 /*0x58*/ 0x1f /*kp-6 -> 'o'*/, 0x1a /*kp-7 -> '7'*/, 0, 0x1c /*kp-8 -> '8'*/,
9697 /*0x5C*/ 0x19 /*kp-9 -> '9'*/, 0, 0, 0,
9699 /*0x60*/ 0x60 /*f5 = f5*/, 0x61 /*f6 = f6*/, 0x62 /*f7 = f7*/, 0x63 /*f3 = f3*/,
9700 /*0x64*/ 0x64 /*f8 = f8*/, 0x65 /*f9 = f9*/, 0, 0x67 /*f11 = f11*/,
9701 /*0x68*/ 0, 0, 0, 0,
9702 /*0x6C*/ 0, 0x6d /*f10 = f10*/, 0, 0x6f /*f12 = f12*/,
9704 /*0x70*/ 0, 0, 0, 0x7b /*home -> left*/,
9705 /*0x74*/ 0x7e /*pgup -> up*/, 0x33 /*delete -> backspace*/, 0x76 /*f4 = f4*/, 0x7c /*end -> right*/,
9706 /*0x78*/ 0x78 /*f2 = f2*/, 0x7d /*pgdown -> down*/, 0x7a /*f1 = f1*/, 0,
9709 #endif /* MAC_OSX */
9712 #if TARGET_API_MAC_CARBON
9713 mac_to_emacs_modifiers (UInt32 mods
)
9715 mac_to_emacs_modifiers (EventModifiers mods
)
9718 unsigned int result
= 0;
9719 if (mods
& shiftKey
)
9720 result
|= shift_modifier
;
9722 /* Deactivated to simplify configuration:
9723 if Vmac_option_modifier is non-NIL, we fully process the Option
9724 key. Otherwise, we only process it if an additional Ctrl or Command
9725 is pressed. That way the system may convert the character to a
9727 if ((mods & optionKey) &&
9728 (( !NILP(Vmac_option_modifier) ||
9729 ((mods & cmdKey) || (mods & controlKey))))) */
9731 if (!NILP (Vmac_option_modifier
) && (mods
& optionKey
)) {
9732 Lisp_Object val
= Fget(Vmac_option_modifier
, Qmodifier_value
);
9734 result
|= XUINT(val
);
9736 if (!NILP (Vmac_command_modifier
) && (mods
& cmdKey
)) {
9737 Lisp_Object val
= Fget(Vmac_command_modifier
, Qmodifier_value
);
9739 result
|= XUINT(val
);
9741 if (!NILP (Vmac_control_modifier
) && (mods
& controlKey
)) {
9742 Lisp_Object val
= Fget(Vmac_control_modifier
, Qmodifier_value
);
9744 result
|= XUINT(val
);
9748 if (!NILP (Vmac_function_modifier
) && (mods
& kEventKeyModifierFnMask
)) {
9749 Lisp_Object val
= Fget(Vmac_function_modifier
, Qmodifier_value
);
9751 result
|= XUINT(val
);
9759 mac_mapped_modifiers (modifiers
)
9762 UInt32 mapped_modifiers_all
=
9763 (NILP (Vmac_control_modifier
) ? 0 : controlKey
)
9764 | (NILP (Vmac_option_modifier
) ? 0 : optionKey
)
9765 | (NILP (Vmac_command_modifier
) ? 0 : cmdKey
);
9768 mapped_modifiers_all
|=
9769 (NILP (Vmac_function_modifier
) ? 0 : kEventKeyModifierFnMask
);
9772 return mapped_modifiers_all
& modifiers
;
9776 mac_get_emulated_btn ( UInt32 modifiers
)
9779 if (!NILP (Vmac_emulate_three_button_mouse
)) {
9780 int cmdIs3
= !EQ (Vmac_emulate_three_button_mouse
, Qreverse
);
9781 if (modifiers
& cmdKey
)
9782 result
= cmdIs3
? 2 : 1;
9783 else if (modifiers
& optionKey
)
9784 result
= cmdIs3
? 1 : 2;
9789 #if TARGET_API_MAC_CARBON
9790 /***** Code to handle C-g testing *****/
9791 extern int quit_char
;
9792 extern int make_ctrl_char
P_ ((int));
9795 mac_quit_char_key_p (modifiers
, key_code
)
9796 UInt32 modifiers
, key_code
;
9799 unsigned long some_state
= 0;
9800 Ptr kchr_ptr
= (Ptr
) GetScriptManagerVariable (smKCHRCache
);
9801 int c
, emacs_modifiers
;
9803 /* Mask off modifier keys that are mapped to some Emacs modifiers. */
9804 key_code
|= (modifiers
& ~(mac_mapped_modifiers (modifiers
)));
9805 char_code
= KeyTranslate (kchr_ptr
, key_code
, &some_state
);
9806 if (char_code
& ~0xff)
9809 emacs_modifiers
= mac_to_emacs_modifiers (modifiers
);
9810 if (emacs_modifiers
& ctrl_modifier
)
9811 c
= make_ctrl_char (char_code
);
9813 c
|= (emacs_modifiers
9814 & (meta_modifier
| alt_modifier
9815 | hyper_modifier
| super_modifier
));
9817 return c
== quit_char
;
9821 #if TARGET_API_MAC_CARBON
9822 /* Obtains the event modifiers from the event ref and then calls
9823 mac_to_emacs_modifiers. */
9825 mac_event_to_emacs_modifiers (EventRef eventRef
)
9827 UInt32 mods
= 0, class;
9829 GetEventParameter (eventRef
, kEventParamKeyModifiers
, typeUInt32
, NULL
,
9830 sizeof (UInt32
), NULL
, &mods
);
9831 class = GetEventClass (eventRef
);
9832 if (!NILP (Vmac_emulate_three_button_mouse
) &&
9833 (class == kEventClassMouse
|| class == kEventClassCommand
))
9835 mods
&= ~(optionKey
| cmdKey
);
9837 return mac_to_emacs_modifiers (mods
);
9840 /* Given an event ref, return the code to use for the mouse button
9841 code in the emacs input_event. */
9843 mac_get_mouse_btn (EventRef ref
)
9845 EventMouseButton result
= kEventMouseButtonPrimary
;
9846 GetEventParameter (ref
, kEventParamMouseButton
, typeMouseButton
, NULL
,
9847 sizeof (EventMouseButton
), NULL
, &result
);
9850 case kEventMouseButtonPrimary
:
9851 if (NILP (Vmac_emulate_three_button_mouse
))
9855 GetEventParameter (ref
, kEventParamKeyModifiers
, typeUInt32
, NULL
,
9856 sizeof (UInt32
), NULL
, &mods
);
9857 return mac_get_emulated_btn(mods
);
9859 case kEventMouseButtonSecondary
:
9860 return mac_wheel_button_is_mouse_2
? 2 : 1;
9861 case kEventMouseButtonTertiary
:
9862 case 4: /* 4 is the number for the mouse wheel button */
9863 return mac_wheel_button_is_mouse_2
? 1 : 2;
9869 /* Normally, ConvertEventRefToEventRecord will correctly handle all
9870 events. However the click of the mouse wheel is not converted to a
9871 mouseDown or mouseUp event. Likewise for dead key events. This
9872 calls ConvertEventRefToEventRecord, but then checks to see if it is
9873 a mouse up/down, or a dead key Carbon event that has not been
9874 converted, and if so, converts it by hand (to be picked up in the
9875 XTread_socket loop). */
9876 static Boolean
mac_convert_event_ref (EventRef eventRef
, EventRecord
*eventRec
)
9879 Boolean result
= ConvertEventRefToEventRecord (eventRef
, eventRec
);
9885 switch (GetEventClass (eventRef
))
9887 case kEventClassMouse
:
9888 switch (GetEventKind (eventRef
))
9890 case kEventMouseDown
:
9891 eventRec
->what
= mouseDown
;
9896 eventRec
->what
= mouseUp
;
9905 case kEventClassKeyboard
:
9906 switch (GetEventKind (eventRef
))
9908 case kEventRawKeyDown
:
9910 goto keystroke_common
;
9911 case kEventRawKeyRepeat
:
9913 goto keystroke_common
;
9914 case kEventRawKeyUp
:
9918 unsigned char char_codes
;
9921 err
= GetEventParameter (eventRef
, kEventParamKeyMacCharCodes
,
9922 typeChar
, NULL
, sizeof (char),
9925 err
= GetEventParameter (eventRef
, kEventParamKeyCode
,
9926 typeUInt32
, NULL
, sizeof (UInt32
),
9930 eventRec
->what
= action
;
9931 eventRec
->message
= char_codes
| ((key_code
& 0xff) << 8);
9948 /* Need where and when. */
9951 GetEventParameter (eventRef
, kEventParamMouseLocation
, typeQDPoint
,
9952 NULL
, sizeof (Point
), NULL
, &eventRec
->where
);
9953 /* Use two step process because new event modifiers are 32-bit
9954 and old are 16-bit. Currently, only loss is NumLock & Fn. */
9955 GetEventParameter (eventRef
, kEventParamKeyModifiers
, typeUInt32
,
9956 NULL
, sizeof (UInt32
), NULL
, &mods
);
9957 eventRec
->modifiers
= mods
;
9959 eventRec
->when
= EventTimeToTicks (GetEventTime (eventRef
));
9971 Handle menubar_handle
;
9974 menubar_handle
= GetNewMBar (128);
9975 if(menubar_handle
== NULL
)
9977 SetMenuBar (menubar_handle
);
9980 #if !TARGET_API_MAC_CARBON
9981 menu
= GetMenuRef (M_APPLE
);
9983 AppendResMenu (menu
, 'DRVR');
9991 do_init_managers (void)
9993 #if !TARGET_API_MAC_CARBON
9994 InitGraf (&qd
.thePort
);
9996 FlushEvents (everyEvent
, 0);
10000 InitDialogs (NULL
);
10001 #endif /* !TARGET_API_MAC_CARBON */
10004 #if !TARGET_API_MAC_CARBON
10005 /* set up some extra stack space for use by emacs */
10006 SetApplLimit ((Ptr
) ((long) GetApplLimit () - EXTRA_STACK_ALLOC
));
10008 /* MaxApplZone must be called for AppleScript to execute more
10009 complicated scripts */
10012 #endif /* !TARGET_API_MAC_CARBON */
10016 do_check_ram_size (void)
10018 SInt32 physical_ram_size
, logical_ram_size
;
10020 if (Gestalt (gestaltPhysicalRAMSize
, &physical_ram_size
) != noErr
10021 || Gestalt (gestaltLogicalRAMSize
, &logical_ram_size
) != noErr
10022 || physical_ram_size
> (1 << VALBITS
)
10023 || logical_ram_size
> (1 << VALBITS
))
10025 StopAlert (RAM_TOO_LARGE_ALERT_ID
, NULL
);
10029 #endif /* MAC_OS8 */
10032 do_window_update (WindowRef win
)
10034 struct frame
*f
= mac_window_to_frame (win
);
10038 /* The tooltip has been drawn already. Avoid the SET_FRAME_GARBAGED
10040 if (win
!= tip_window
)
10042 if (f
->async_visible
== 0)
10044 /* Update events may occur when a frame gets iconified. */
10046 f
->async_visible
= 1;
10047 f
->async_iconified
= 0;
10048 SET_FRAME_GARBAGED (f
);
10054 #if TARGET_API_MAC_CARBON
10055 RgnHandle region
= NewRgn ();
10057 GetPortVisibleRegion (GetWindowPort (win
), region
);
10058 GetRegionBounds (region
, &r
);
10059 expose_frame (f
, r
.left
, r
.top
, r
.right
- r
.left
, r
.bottom
- r
.top
);
10061 mac_prepare_for_quickdraw (f
);
10063 UpdateControls (win
, region
);
10064 DisposeRgn (region
);
10066 r
= (*win
->visRgn
)->rgnBBox
;
10067 expose_frame (f
, r
.left
, r
.top
, r
.right
- r
.left
, r
.bottom
- r
.top
);
10068 UpdateControls (win
, win
->visRgn
);
10077 is_emacs_window (WindowRef win
)
10079 Lisp_Object tail
, frame
;
10084 FOR_EACH_FRAME (tail
, frame
)
10085 if (FRAME_MAC_P (XFRAME (frame
)))
10086 if (FRAME_MAC_WINDOW (XFRAME (frame
)) == win
)
10097 ScriptLanguageRecord slrec
, *slptr
= NULL
;
10099 err
= ActivateTSMDocument (tsm_document_id
);
10103 if (EQ (Vmac_ts_script_language_on_focus
, Qt
)
10104 && EQ (saved_ts_script_language_on_focus
, Qt
))
10105 slptr
= &saved_ts_language
;
10106 else if (CONSP (Vmac_ts_script_language_on_focus
)
10107 && INTEGERP (XCAR (Vmac_ts_script_language_on_focus
))
10108 && INTEGERP (XCDR (Vmac_ts_script_language_on_focus
))
10109 && CONSP (saved_ts_script_language_on_focus
)
10110 && EQ (XCAR (saved_ts_script_language_on_focus
),
10111 XCAR (Vmac_ts_script_language_on_focus
))
10112 && EQ (XCDR (saved_ts_script_language_on_focus
),
10113 XCDR (Vmac_ts_script_language_on_focus
)))
10115 slrec
.fScript
= XINT (XCAR (Vmac_ts_script_language_on_focus
));
10116 slrec
.fLanguage
= XINT (XCDR (Vmac_ts_script_language_on_focus
));
10123 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
10124 err
= SetDefaultInputMethodOfClass (saved_ts_component
, slptr
,
10125 kKeyboardInputMethodClass
);
10127 err
= SetDefaultInputMethod (saved_ts_component
, slptr
);
10130 err
= SetTextServiceLanguage (slptr
);
10132 /* Seems to be needed on Mac OS X 10.2. */
10134 KeyScript (slptr
->fScript
| smKeyForceKeyScriptMask
);
10144 ScriptLanguageRecord slrec
, *slptr
= NULL
;
10146 saved_ts_script_language_on_focus
= Vmac_ts_script_language_on_focus
;
10148 if (EQ (Vmac_ts_script_language_on_focus
, Qt
))
10150 err
= GetTextServiceLanguage (&saved_ts_language
);
10152 slptr
= &saved_ts_language
;
10154 else if (CONSP (Vmac_ts_script_language_on_focus
)
10155 && INTEGERP (XCAR (Vmac_ts_script_language_on_focus
))
10156 && INTEGERP (XCDR (Vmac_ts_script_language_on_focus
)))
10158 slrec
.fScript
= XINT (XCAR (Vmac_ts_script_language_on_focus
));
10159 slrec
.fLanguage
= XINT (XCDR (Vmac_ts_script_language_on_focus
));
10165 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
10166 GetDefaultInputMethodOfClass (&saved_ts_component
, slptr
,
10167 kKeyboardInputMethodClass
);
10169 GetDefaultInputMethod (&saved_ts_component
, slptr
);
10173 err
= DeactivateTSMDocument (tsm_document_id
);
10179 #if !TARGET_API_MAC_CARBON
10181 do_apple_menu (SInt16 menu_item
)
10184 SInt16 da_driver_refnum
;
10186 if (menu_item
== I_ABOUT
)
10187 NoteAlert (ABOUT_ALERT_ID
, NULL
);
10190 GetMenuItemText (GetMenuRef (M_APPLE
), menu_item
, item_name
);
10191 da_driver_refnum
= OpenDeskAcc (item_name
);
10194 #endif /* !TARGET_API_MAC_CARBON */
10196 /* Handle drags in size box. Based on code contributed by Ben
10197 Mesander and IM - Window Manager A. */
10200 do_grow_window (w
, e
)
10202 const EventRecord
*e
;
10205 int rows
, columns
, width
, height
;
10206 struct frame
*f
= mac_window_to_frame (w
);
10207 XSizeHints
*size_hints
= FRAME_SIZE_HINTS (f
);
10208 int min_width
= MIN_DOC_SIZE
, min_height
= MIN_DOC_SIZE
;
10209 #if TARGET_API_MAC_CARBON
10215 if (size_hints
->flags
& PMinSize
)
10217 min_width
= size_hints
->min_width
;
10218 min_height
= size_hints
->min_height
;
10220 SetRect (&limit_rect
, min_width
, min_height
, MAX_DOC_SIZE
, MAX_DOC_SIZE
);
10222 #if TARGET_API_MAC_CARBON
10223 if (!ResizeWindow (w
, e
->where
, &limit_rect
, &new_rect
))
10225 height
= new_rect
.bottom
- new_rect
.top
;
10226 width
= new_rect
.right
- new_rect
.left
;
10228 grow_size
= GrowWindow (w
, e
->where
, &limit_rect
);
10229 /* see if it really changed size */
10230 if (grow_size
== 0)
10232 height
= HiWord (grow_size
);
10233 width
= LoWord (grow_size
);
10236 if (width
!= FRAME_PIXEL_WIDTH (f
)
10237 || height
!= FRAME_PIXEL_HEIGHT (f
))
10239 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, height
);
10240 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, width
);
10242 x_set_window_size (f
, 0, columns
, rows
);
10247 #if TARGET_API_MAC_CARBON
10249 mac_get_ideal_size (f
)
10252 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
10253 WindowRef w
= FRAME_MAC_WINDOW (f
);
10255 Rect standard_rect
;
10256 int height
, width
, columns
, rows
;
10258 ideal_size
.h
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, DEFAULT_NUM_COLS
);
10259 ideal_size
.v
= dpyinfo
->height
;
10260 IsWindowInStandardState (w
, &ideal_size
, &standard_rect
);
10261 /* Adjust the standard size according to character boundaries. */
10262 width
= standard_rect
.right
- standard_rect
.left
;
10263 height
= standard_rect
.bottom
- standard_rect
.top
;
10264 columns
= FRAME_PIXEL_WIDTH_TO_TEXT_COLS (f
, width
);
10265 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, height
);
10266 ideal_size
.h
= FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, columns
);
10267 ideal_size
.v
= FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
);
10273 /* Handle clicks in zoom box. Calculation of "standard state" based
10274 on code in IM - Window Manager A and code contributed by Ben
10275 Mesander. The standard state of an Emacs window is 80-characters
10276 wide (DEFAULT_NUM_COLS) and as tall as will fit on the screen. */
10279 do_zoom_window (WindowRef w
, int zoom_in_or_out
)
10281 Rect zoom_rect
, port_rect
;
10283 struct frame
*f
= mac_window_to_frame (w
);
10284 #if TARGET_API_MAC_CARBON
10285 Point ideal_size
= mac_get_ideal_size (f
);
10287 GetWindowBounds (w
, kWindowContentRgn
, &port_rect
);
10288 if (IsWindowInStandardState (w
, &ideal_size
, &zoom_rect
)
10289 && port_rect
.left
== zoom_rect
.left
10290 && port_rect
.top
== zoom_rect
.top
)
10291 zoom_in_or_out
= inZoomIn
;
10293 zoom_in_or_out
= inZoomOut
;
10296 mac_clear_window (f
);
10298 ZoomWindowIdeal (w
, zoom_in_or_out
, &ideal_size
);
10299 #else /* not TARGET_API_MAC_CARBON */
10302 int w_title_height
, rows
;
10303 struct mac_display_info
*dpyinfo
= FRAME_MAC_DISPLAY_INFO (f
);
10305 GetPort (&save_port
);
10307 SetPortWindowPort (w
);
10309 /* Clear window to avoid flicker. */
10310 EraseRect (&(w
->portRect
));
10311 if (zoom_in_or_out
== inZoomOut
)
10313 SetPt (&top_left
, w
->portRect
.left
, w
->portRect
.top
);
10314 LocalToGlobal (&top_left
);
10316 /* calculate height of window's title bar */
10317 w_title_height
= top_left
.v
- 1
10318 - (**((WindowPeek
) w
)->strucRgn
).rgnBBox
.top
+ GetMBarHeight ();
10320 /* get maximum height of window into zoom_rect.bottom - zoom_rect.top */
10321 zoom_rect
= qd
.screenBits
.bounds
;
10322 zoom_rect
.top
+= w_title_height
;
10323 InsetRect (&zoom_rect
, 8, 4); /* not too tight */
10325 zoom_rect
.right
= zoom_rect
.left
10326 + FRAME_TEXT_COLS_TO_PIXEL_WIDTH (f
, DEFAULT_NUM_COLS
);
10328 /* Adjust the standard size according to character boundaries. */
10329 rows
= FRAME_PIXEL_HEIGHT_TO_TEXT_LINES (f
, zoom_rect
.bottom
- zoom_rect
.top
);
10331 zoom_rect
.top
+ FRAME_TEXT_LINES_TO_PIXEL_HEIGHT (f
, rows
);
10333 (**((WStateDataHandle
) ((WindowPeek
) w
)->dataHandle
)).stdState
10337 ZoomWindow (w
, zoom_in_or_out
, f
== mac_focus_frame (dpyinfo
));
10339 SetPort (save_port
);
10340 #endif /* not TARGET_API_MAC_CARBON */
10342 #if !TARGET_API_MAC_CARBON
10343 /* retrieve window size and update application values */
10344 port_rect
= w
->portRect
;
10345 height
= port_rect
.bottom
- port_rect
.top
;
10346 width
= port_rect
.right
- port_rect
.left
;
10348 mac_handle_size_change (f
, width
, height
);
10349 mac_handle_origin_change (f
);
10354 mac_set_unicode_keystroke_event (code
, buf
)
10356 struct input_event
*buf
;
10358 int charset_id
, c1
, c2
;
10362 buf
->kind
= ASCII_KEYSTROKE_EVENT
;
10365 else if (code
< 0x100)
10368 charset_id
= CHARSET_8_BIT_CONTROL
;
10370 charset_id
= charset_latin_iso8859_1
;
10371 buf
->kind
= MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
10372 buf
->code
= MAKE_CHAR (charset_id
, code
, 0);
10377 charset_id
= charset_mule_unicode_0100_24ff
,
10379 else if (code
< 0x33FF)
10380 charset_id
= charset_mule_unicode_2500_33ff
,
10382 else if (code
>= 0xE000)
10383 charset_id
= charset_mule_unicode_e000_ffff
,
10385 c1
= (code
/ 96) + 32, c2
= (code
% 96) + 32;
10386 buf
->kind
= MULTIBYTE_CHAR_KEYSTROKE_EVENT
;
10387 buf
->code
= MAKE_CHAR (charset_id
, c1
, c2
);
10392 do_keystroke (action
, char_code
, key_code
, modifiers
, timestamp
, buf
)
10394 unsigned char char_code
;
10395 UInt32 key_code
, modifiers
;
10396 unsigned long timestamp
;
10397 struct input_event
*buf
;
10399 static SInt16 last_key_script
= -1;
10400 SInt16 current_key_script
= GetScriptManagerVariable (smKeyScript
);
10401 UInt32 mapped_modifiers
= mac_mapped_modifiers (modifiers
);
10404 if (mapped_modifiers
& kEventKeyModifierFnMask
10405 && key_code
<= 0x7f
10406 && fn_keycode_to_keycode_table
[key_code
])
10407 key_code
= fn_keycode_to_keycode_table
[key_code
];
10410 if (key_code
<= 0x7f && keycode_to_xkeysym_table
[key_code
])
10412 buf
->kind
= NON_ASCII_KEYSTROKE_EVENT
;
10413 buf
->code
= 0xff00 | keycode_to_xkeysym_table
[key_code
];
10415 if (modifiers
& kEventKeyModifierFnMask
10416 && key_code
<= 0x7f
10417 && fn_keycode_to_keycode_table
[key_code
] == key_code
)
10418 modifiers
&= ~kEventKeyModifierFnMask
;
10421 else if (mapped_modifiers
)
10423 /* translate the keycode back to determine the original key */
10425 UCKeyboardLayout
*uchr_ptr
= NULL
;
10426 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
10428 KeyboardLayoutRef layout
;
10430 err
= KLGetCurrentKeyboardLayout (&layout
);
10432 err
= KLGetKeyboardLayoutProperty (layout
, kKLuchrData
,
10433 (const void **) &uchr_ptr
);
10435 static SInt16 last_key_layout_id
= 0;
10436 static Handle uchr_handle
= (Handle
)-1;
10437 SInt16 current_key_layout_id
=
10438 GetScriptVariable (current_key_script
, smScriptKeys
);
10440 if (uchr_handle
== (Handle
)-1
10441 || last_key_layout_id
!= current_key_layout_id
)
10443 uchr_handle
= GetResource ('uchr', current_key_layout_id
);
10444 last_key_layout_id
= current_key_layout_id
;
10447 uchr_ptr
= (UCKeyboardLayout
*)*uchr_handle
;
10453 UInt16 key_action
= action
- keyDown
;
10454 UInt32 modifier_key_state
= (modifiers
& ~mapped_modifiers
) >> 8;
10455 UInt32 keyboard_type
= LMGetKbdType ();
10456 SInt32 dead_key_state
= 0;
10458 UniCharCount actual_length
;
10460 status
= UCKeyTranslate (uchr_ptr
, key_code
, key_action
,
10461 modifier_key_state
, keyboard_type
,
10462 kUCKeyTranslateNoDeadKeysMask
,
10464 1, &actual_length
, &code
);
10465 if (status
== noErr
&& actual_length
== 1)
10466 mac_set_unicode_keystroke_event (code
, buf
);
10468 #endif /* MAC_OSX */
10470 if (buf
->kind
== NO_EVENT
)
10472 /* This code comes from Keyboard Resource, Appendix C of IM
10473 - Text. This is necessary since shift is ignored in KCHR
10474 table translation when option or command is pressed. It
10475 also does not translate correctly control-shift chars
10476 like C-% so mask off shift here also. */
10477 /* Mask off modifier keys that are mapped to some Emacs
10479 int new_modifiers
= modifiers
& ~mapped_modifiers
;
10480 /* set high byte of keycode to modifier high byte*/
10481 int new_key_code
= key_code
| new_modifiers
;
10482 Ptr kchr_ptr
= (Ptr
) GetScriptManagerVariable (smKCHRCache
);
10483 unsigned long some_state
= 0;
10484 UInt32 new_char_code
;
10486 new_char_code
= KeyTranslate (kchr_ptr
, new_key_code
, &some_state
);
10487 if (new_char_code
== 0)
10488 /* Seems like a dead key. Append up-stroke. */
10489 new_char_code
= KeyTranslate (kchr_ptr
, new_key_code
| 0x80,
10493 buf
->kind
= ASCII_KEYSTROKE_EVENT
;
10494 buf
->code
= new_char_code
& 0xff;
10499 if (buf
->kind
== NO_EVENT
)
10501 buf
->kind
= ASCII_KEYSTROKE_EVENT
;
10502 buf
->code
= char_code
;
10505 buf
->modifiers
= mac_to_emacs_modifiers (modifiers
);
10506 buf
->modifiers
|= (extra_keyboard_modifiers
10507 & (meta_modifier
| alt_modifier
10508 | hyper_modifier
| super_modifier
));
10510 #if TARGET_API_MAC_CARBON
10511 if (buf
->kind
== ASCII_KEYSTROKE_EVENT
10512 && buf
->code
>= 0x80 && buf
->modifiers
)
10515 TextEncoding encoding
= kTextEncodingMacRoman
;
10516 TextToUnicodeInfo ttu_info
;
10518 UpgradeScriptInfoToTextEncoding (current_key_script
,
10519 kTextLanguageDontCare
,
10520 kTextRegionDontCare
,
10522 err
= CreateTextToUnicodeInfoByEncoding (encoding
, &ttu_info
);
10527 ByteCount unicode_len
;
10530 pstr
[1] = buf
->code
;
10531 err
= ConvertFromPStringToUnicode (ttu_info
, pstr
,
10533 &unicode_len
, &code
);
10534 if (err
== noErr
&& unicode_len
== sizeof (UniChar
))
10535 mac_set_unicode_keystroke_event (code
, buf
);
10536 DisposeTextToUnicodeInfo (&ttu_info
);
10541 if (buf
->kind
== ASCII_KEYSTROKE_EVENT
10542 && buf
->code
>= 0x80
10543 && last_key_script
!= current_key_script
)
10545 struct input_event event
;
10547 EVENT_INIT (event
);
10548 event
.kind
= LANGUAGE_CHANGE_EVENT
;
10550 event
.code
= current_key_script
;
10551 event
.timestamp
= timestamp
;
10552 kbd_buffer_store_event (&event
);
10553 last_key_script
= current_key_script
;
10558 mac_store_apple_event (class, id
, desc
)
10559 Lisp_Object
class, id
;
10560 const AEDesc
*desc
;
10562 struct input_event buf
;
10566 buf
.kind
= MAC_APPLE_EVENT
;
10569 XSETFRAME (buf
.frame_or_window
,
10570 mac_focus_frame (&one_mac_display_info
));
10571 /* Now that Lisp object allocations are protected by BLOCK_INPUT, it
10572 is safe to use them during read_socket_hook. */
10573 buf
.arg
= mac_aedesc_to_lisp (desc
);
10574 kbd_buffer_store_event (&buf
);
10577 #if TARGET_API_MAC_CARBON
10579 mac_store_event_ref_as_apple_event (class, id
, class_key
, id_key
,
10580 event
, num_params
, names
, types
)
10581 AEEventClass
class;
10583 Lisp_Object class_key
, id_key
;
10586 const EventParamName
*names
;
10587 const EventParamType
*types
;
10589 OSStatus err
= eventNotHandledErr
;
10590 Lisp_Object binding
;
10592 mac_find_apple_event_spec (class, id
, &class_key
, &id_key
, &binding
);
10593 if (!NILP (binding
) && !EQ (binding
, Qundefined
))
10595 if (INTEGERP (binding
))
10596 err
= XINT (binding
);
10599 AppleEvent apple_event
;
10600 err
= create_apple_event_from_event_ref (event
, num_params
,
10605 mac_store_apple_event (class_key
, id_key
, &apple_event
);
10606 AEDisposeDesc (&apple_event
);
10607 mac_wakeup_from_rne ();
10616 mac_store_drag_event (window
, mouse_pos
, modifiers
, desc
)
10620 const AEDesc
*desc
;
10622 struct input_event buf
;
10626 buf
.kind
= DRAG_N_DROP_EVENT
;
10627 buf
.modifiers
= mac_to_emacs_modifiers (modifiers
);
10628 buf
.timestamp
= TickCount () * (1000 / 60);
10629 XSETINT (buf
.x
, mouse_pos
.h
);
10630 XSETINT (buf
.y
, mouse_pos
.v
);
10631 XSETFRAME (buf
.frame_or_window
, mac_window_to_frame (window
));
10632 buf
.arg
= mac_aedesc_to_lisp (desc
);
10633 kbd_buffer_store_event (&buf
);
10638 mac_store_service_event (event
)
10642 Lisp_Object id_key
;
10644 const EventParamName
*names
;
10645 const EventParamType
*types
;
10646 static const EventParamName names_pfm
[] =
10647 {kEventParamServiceMessageName
, kEventParamServiceUserData
};
10648 static const EventParamType types_pfm
[] =
10649 {typeCFStringRef
, typeCFStringRef
};
10651 switch (GetEventKind (event
))
10653 case kEventServicePaste
:
10660 case kEventServicePerform
:
10662 num_params
= sizeof (names_pfm
) / sizeof (names_pfm
[0]);
10671 err
= mac_store_event_ref_as_apple_event (0, 0, Qservice
, id_key
,
10677 #endif /* MAC_OSX */
10679 static pascal OSStatus
10680 mac_handle_window_event (next_handler
, event
, data
)
10681 EventHandlerCallRef next_handler
;
10686 OSStatus err
, result
= eventNotHandledErr
;
10689 XSizeHints
*size_hints
;
10691 err
= GetEventParameter (event
, kEventParamDirectObject
, typeWindowRef
,
10692 NULL
, sizeof (WindowRef
), NULL
, &wp
);
10694 return eventNotHandledErr
;
10696 f
= mac_window_to_frame (wp
);
10697 switch (GetEventKind (event
))
10699 /* -- window refresh events -- */
10701 case kEventWindowUpdate
:
10702 result
= CallNextEventHandler (next_handler
, event
);
10703 if (result
!= eventNotHandledErr
)
10706 do_window_update (wp
);
10710 /* -- window state change events -- */
10712 case kEventWindowShowing
:
10713 size_hints
= FRAME_SIZE_HINTS (f
);
10714 if (!(size_hints
->flags
& (USPosition
| PPosition
)))
10716 struct frame
*sf
= SELECTED_FRAME ();
10718 if (!(FRAME_MAC_P (sf
) && sf
->async_visible
))
10719 RepositionWindow (wp
, NULL
, kWindowCenterOnMainScreen
);
10722 RepositionWindow (wp
, FRAME_MAC_WINDOW (sf
),
10723 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
10724 kWindowCascadeStartAtParentWindowScreen
10726 kWindowCascadeOnParentWindowScreen
10729 #if USE_MAC_TOOLBAR
10730 /* This is a workaround. RepositionWindow fails to put
10731 a window at the cascading position when its parent
10732 window has a Carbon HIToolbar. */
10733 if ((f
->left_pos
== sf
->left_pos
10734 && f
->top_pos
== sf
->top_pos
)
10735 || (f
->left_pos
== sf
->left_pos
+ 10 * 2
10736 && f
->top_pos
== sf
->top_pos
+ 32 * 2))
10737 MoveWindowStructure (wp
, sf
->left_pos
+ 10, sf
->top_pos
+ 32);
10744 case kEventWindowHiding
:
10745 /* Before unmapping the window, update the WM_SIZE_HINTS
10746 property to claim that the current position of the window is
10747 user-specified, rather than program-specified, so that when
10748 the window is mapped again, it will be placed at the same
10749 location, without forcing the user to position it by hand
10750 again (they have already done that once for this window.) */
10751 x_wm_set_size_hint (f
, (long) 0, 1);
10755 case kEventWindowShown
:
10756 case kEventWindowHidden
:
10757 case kEventWindowCollapsed
:
10758 case kEventWindowExpanded
:
10759 mac_handle_visibility_change (f
);
10763 case kEventWindowBoundsChanging
:
10764 result
= CallNextEventHandler (next_handler
, event
);
10765 if (result
!= eventNotHandledErr
)
10768 err
= GetEventParameter (event
, kEventParamAttributes
, typeUInt32
,
10769 NULL
, sizeof (UInt32
), NULL
, &attributes
);
10773 size_hints
= FRAME_SIZE_HINTS (f
);
10774 if ((attributes
& kWindowBoundsChangeUserResize
)
10775 && ((size_hints
->flags
& (PResizeInc
| PBaseSize
| PMinSize
))
10776 == (PResizeInc
| PBaseSize
| PMinSize
)))
10781 err
= GetEventParameter (event
, kEventParamCurrentBounds
,
10782 typeQDRectangle
, NULL
, sizeof (Rect
),
10787 width
= bounds
.right
- bounds
.left
;
10788 height
= bounds
.bottom
- bounds
.top
;
10790 if (width
< size_hints
->min_width
)
10791 width
= size_hints
->min_width
;
10793 width
= size_hints
->base_width
10794 + (int) ((width
- size_hints
->base_width
)
10795 / (float) size_hints
->width_inc
+ .5)
10796 * size_hints
->width_inc
;
10798 if (height
< size_hints
->min_height
)
10799 height
= size_hints
->min_height
;
10801 height
= size_hints
->base_height
10802 + (int) ((height
- size_hints
->base_height
)
10803 / (float) size_hints
->height_inc
+ .5)
10804 * size_hints
->height_inc
;
10806 bounds
.right
= bounds
.left
+ width
;
10807 bounds
.bottom
= bounds
.top
+ height
;
10808 SetEventParameter (event
, kEventParamCurrentBounds
,
10809 typeQDRectangle
, sizeof (Rect
), &bounds
);
10814 case kEventWindowBoundsChanged
:
10815 err
= GetEventParameter (event
, kEventParamAttributes
, typeUInt32
,
10816 NULL
, sizeof (UInt32
), NULL
, &attributes
);
10820 if (attributes
& kWindowBoundsChangeSizeChanged
)
10824 err
= GetEventParameter (event
, kEventParamCurrentBounds
,
10825 typeQDRectangle
, NULL
, sizeof (Rect
),
10831 width
= bounds
.right
- bounds
.left
;
10832 height
= bounds
.bottom
- bounds
.top
;
10833 mac_handle_size_change (f
, width
, height
);
10834 mac_wakeup_from_rne ();
10838 if (attributes
& kWindowBoundsChangeOriginChanged
)
10839 mac_handle_origin_change (f
);
10844 /* -- window action events -- */
10846 case kEventWindowClose
:
10848 struct input_event buf
;
10851 buf
.kind
= DELETE_WINDOW_EVENT
;
10852 XSETFRAME (buf
.frame_or_window
, f
);
10854 kbd_buffer_store_event (&buf
);
10859 case kEventWindowGetIdealSize
:
10860 result
= CallNextEventHandler (next_handler
, event
);
10861 if (result
!= eventNotHandledErr
)
10865 Point ideal_size
= mac_get_ideal_size (f
);
10867 err
= SetEventParameter (event
, kEventParamDimensions
,
10868 typeQDPoint
, sizeof (Point
), &ideal_size
);
10875 case kEventWindowToolbarSwitchMode
:
10877 static const EventParamName names
[] = {kEventParamDirectObject
,
10878 kEventParamWindowMouseLocation
,
10879 kEventParamKeyModifiers
,
10880 kEventParamMouseButton
,
10881 kEventParamClickCount
,
10882 kEventParamMouseChord
};
10883 static const EventParamType types
[] = {typeWindowRef
,
10889 int num_params
= sizeof (names
) / sizeof (names
[0]);
10891 err
= mac_store_event_ref_as_apple_event (0, 0,
10893 Qtoolbar_switch_mode
,
10903 /* -- window focus events -- */
10905 case kEventWindowFocusAcquired
:
10906 err
= mac_tsm_resume ();
10911 case kEventWindowFocusRelinquish
:
10912 err
= mac_tsm_suspend ();
10925 static pascal OSStatus
10926 mac_handle_application_event (next_handler
, event
, data
)
10927 EventHandlerCallRef next_handler
;
10931 OSStatus err
, result
= eventNotHandledErr
;
10933 switch (GetEventKind (event
))
10936 case kEventAppActivated
:
10937 err
= mac_tsm_resume ();
10940 case kEventAppDeactivated
:
10941 err
= mac_tsm_suspend ();
10955 static pascal OSStatus
10956 mac_handle_keyboard_event (next_handler
, event
, data
)
10957 EventHandlerCallRef next_handler
;
10961 OSStatus err
, result
= eventNotHandledErr
;
10962 UInt32 event_kind
, key_code
, modifiers
;
10963 unsigned char char_code
;
10965 event_kind
= GetEventKind (event
);
10966 switch (event_kind
)
10968 case kEventRawKeyDown
:
10969 case kEventRawKeyRepeat
:
10970 case kEventRawKeyUp
:
10971 /* When using Carbon Events, we need to pass raw keyboard events
10972 to the TSM ourselves. If TSM handles it, it will pass back
10973 noErr, otherwise it will pass back "eventNotHandledErr" and
10974 we can process it normally. */
10975 result
= CallNextEventHandler (next_handler
, event
);
10976 if (result
!= eventNotHandledErr
)
10979 if (read_socket_inev
== NULL
)
10983 if (read_socket_inev
->kind
!= NO_EVENT
)
10990 if (event_kind
== kEventRawKeyUp
)
10993 err
= GetEventParameter (event
, kEventParamKeyMacCharCodes
,
10995 sizeof (char), NULL
, &char_code
);
10999 err
= GetEventParameter (event
, kEventParamKeyCode
,
11001 sizeof (UInt32
), NULL
, &key_code
);
11005 err
= GetEventParameter (event
, kEventParamKeyModifiers
,
11007 sizeof (UInt32
), NULL
, &modifiers
);
11011 do_keystroke ((event_kind
== kEventRawKeyDown
? keyDown
: autoKey
),
11012 char_code
, key_code
, modifiers
,
11014 (GetEventTime (event
) / kEventDurationMillisecond
)),
11026 static pascal OSStatus
11027 mac_handle_command_event (next_handler
, event
, data
)
11028 EventHandlerCallRef next_handler
;
11032 OSStatus err
, result
= eventNotHandledErr
;
11034 static const EventParamName names
[] =
11035 {kEventParamDirectObject
, kEventParamKeyModifiers
};
11036 static const EventParamType types
[] =
11037 {typeHICommand
, typeUInt32
};
11038 int num_params
= sizeof (names
) / sizeof (names
[0]);
11040 err
= GetEventParameter (event
, kEventParamDirectObject
, typeHICommand
,
11041 NULL
, sizeof (HICommand
), NULL
, &command
);
11043 return eventNotHandledErr
;
11045 switch (GetEventKind (event
))
11047 case kEventCommandProcess
:
11048 result
= CallNextEventHandler (next_handler
, event
);
11049 if (result
!= eventNotHandledErr
)
11052 err
= GetEventParameter (event
, kEventParamDirectObject
,
11053 typeHICommand
, NULL
,
11054 sizeof (HICommand
), NULL
, &command
);
11056 if (err
!= noErr
|| command
.commandID
== 0)
11059 /* A HI command event is mapped to an Apple event whose event
11060 class symbol is `hi-command' and event ID is its command
11062 err
= mac_store_event_ref_as_apple_event (0, command
.commandID
,
11077 static pascal OSStatus
11078 mac_handle_mouse_event (next_handler
, event
, data
)
11079 EventHandlerCallRef next_handler
;
11083 OSStatus err
, result
= eventNotHandledErr
;
11085 switch (GetEventKind (event
))
11087 case kEventMouseWheelMoved
:
11091 EventMouseWheelAxis axis
;
11095 result
= CallNextEventHandler (next_handler
, event
);
11096 if (result
!= eventNotHandledErr
|| read_socket_inev
== NULL
)
11099 f
= mac_focus_frame (&one_mac_display_info
);
11101 err
= GetEventParameter (event
, kEventParamWindowRef
, typeWindowRef
,
11102 NULL
, sizeof (WindowRef
), NULL
, &wp
);
11104 || wp
!= FRAME_MAC_WINDOW (f
))
11107 err
= GetEventParameter (event
, kEventParamMouseWheelAxis
,
11108 typeMouseWheelAxis
, NULL
,
11109 sizeof (EventMouseWheelAxis
), NULL
, &axis
);
11110 if (err
!= noErr
|| axis
!= kEventMouseWheelAxisY
)
11113 err
= GetEventParameter (event
, kEventParamMouseLocation
,
11114 typeQDPoint
, NULL
, sizeof (Point
),
11119 point
.h
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
11120 point
.v
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
11121 if (point
.h
< 0 || point
.v
< 0
11122 || EQ (window_from_coordinates (f
, point
.h
, point
.v
, 0, 0, 0, 1),
11123 f
->tool_bar_window
))
11126 err
= GetEventParameter (event
, kEventParamMouseWheelDelta
,
11127 typeSInt32
, NULL
, sizeof (SInt32
),
11132 read_socket_inev
->kind
= WHEEL_EVENT
;
11133 read_socket_inev
->code
= 0;
11134 read_socket_inev
->modifiers
=
11135 (mac_event_to_emacs_modifiers (event
)
11136 | ((delta
< 0) ? down_modifier
: up_modifier
));
11137 XSETINT (read_socket_inev
->x
, point
.h
);
11138 XSETINT (read_socket_inev
->y
, point
.v
);
11139 XSETFRAME (read_socket_inev
->frame_or_window
, f
);
11153 static pascal OSStatus
11154 mac_handle_text_input_event (next_handler
, event
, data
)
11155 EventHandlerCallRef next_handler
;
11159 OSStatus err
, result
;
11160 Lisp_Object id_key
= Qnil
;
11162 const EventParamName
*names
;
11163 const EventParamType
*types
;
11164 static UInt32 seqno_uaia
= 0;
11165 static const EventParamName names_uaia
[] =
11166 {kEventParamTextInputSendComponentInstance
,
11167 kEventParamTextInputSendRefCon
,
11168 kEventParamTextInputSendSLRec
,
11169 kEventParamTextInputSendFixLen
,
11170 kEventParamTextInputSendText
,
11171 kEventParamTextInputSendUpdateRng
,
11172 kEventParamTextInputSendHiliteRng
,
11173 kEventParamTextInputSendClauseRng
,
11174 kEventParamTextInputSendPinRng
,
11175 kEventParamTextInputSendTextServiceEncoding
,
11176 kEventParamTextInputSendTextServiceMacEncoding
,
11177 EVENT_PARAM_TEXT_INPUT_SEQUENCE_NUMBER
};
11178 static const EventParamType types_uaia
[] =
11179 {typeComponentInstance
,
11181 typeIntlWritingCode
,
11188 typeTextRangeArray
,
11189 typeTextRangeArray
,
11195 static const EventParamName names_ufke
[] =
11196 {kEventParamTextInputSendComponentInstance
,
11197 kEventParamTextInputSendRefCon
,
11198 kEventParamTextInputSendSLRec
,
11199 kEventParamTextInputSendText
};
11200 static const EventParamType types_ufke
[] =
11201 {typeComponentInstance
,
11203 typeIntlWritingCode
,
11206 result
= CallNextEventHandler (next_handler
, event
);
11207 if (result
!= eventNotHandledErr
)
11210 switch (GetEventKind (event
))
11212 case kEventTextInputUpdateActiveInputArea
:
11213 id_key
= Qupdate_active_input_area
;
11214 num_params
= sizeof (names_uaia
) / sizeof (names_uaia
[0]);
11215 names
= names_uaia
;
11216 types
= types_uaia
;
11217 SetEventParameter (event
, EVENT_PARAM_TEXT_INPUT_SEQUENCE_NUMBER
,
11218 typeUInt32
, sizeof (UInt32
), &seqno_uaia
);
11223 case kEventTextInputUnicodeForKeyEvent
:
11225 EventRef kbd_event
;
11226 UInt32 actual_size
, modifiers
;
11228 err
= GetEventParameter (event
, kEventParamTextInputSendKeyboardEvent
,
11229 typeEventRef
, NULL
, sizeof (EventRef
), NULL
,
11232 err
= GetEventParameter (kbd_event
, kEventParamKeyModifiers
,
11234 sizeof (UInt32
), NULL
, &modifiers
);
11235 if (err
== noErr
&& mac_mapped_modifiers (modifiers
))
11236 /* There're mapped modifier keys. Process it in
11240 err
= GetEventParameter (kbd_event
, kEventParamKeyUnicodes
,
11241 typeUnicodeText
, NULL
, 0, &actual_size
,
11243 if (err
== noErr
&& actual_size
== sizeof (UniChar
))
11247 err
= GetEventParameter (kbd_event
, kEventParamKeyUnicodes
,
11248 typeUnicodeText
, NULL
,
11249 sizeof (UniChar
), NULL
, &code
);
11250 if (err
== noErr
&& code
< 0x80)
11252 /* ASCII character. Process it in do_keystroke. */
11253 if (read_socket_inev
&& code
>= 0x20 && code
<= 0x7e)
11257 err
= GetEventParameter (kbd_event
, kEventParamKeyCode
,
11258 typeUInt32
, NULL
, sizeof (UInt32
),
11260 if (!(err
== noErr
&& key_code
<= 0x7f
11261 && keycode_to_xkeysym_table
[key_code
]))
11264 mac_focus_frame (&one_mac_display_info
);
11266 read_socket_inev
->kind
= ASCII_KEYSTROKE_EVENT
;
11267 read_socket_inev
->code
= code
;
11268 read_socket_inev
->modifiers
=
11269 mac_to_emacs_modifiers (modifiers
);
11270 read_socket_inev
->modifiers
|=
11271 (extra_keyboard_modifiers
11272 & (meta_modifier
| alt_modifier
11273 | hyper_modifier
| super_modifier
));
11274 XSETFRAME (read_socket_inev
->frame_or_window
, f
);
11282 /* Non-ASCII keystrokes without mapped modifiers are
11283 processed at the Lisp level. */
11284 id_key
= Qunicode_for_key_event
;
11285 num_params
= sizeof (names_ufke
) / sizeof (names_ufke
[0]);
11286 names
= names_ufke
;
11287 types
= types_ufke
;
11293 case kEventTextInputOffsetToPos
:
11299 if (!OVERLAYP (Vmac_ts_active_input_overlay
))
11302 /* Strictly speaking, this is not always correct because
11303 previous events may change some states about display. */
11304 if (!NILP (Foverlay_get (Vmac_ts_active_input_overlay
, Qbefore_string
)))
11306 /* Active input area is displayed around the current point. */
11307 f
= SELECTED_FRAME ();
11308 w
= XWINDOW (f
->selected_window
);
11310 else if (WINDOWP (echo_area_window
))
11312 /* Active input area is displayed in the echo area. */
11313 w
= XWINDOW (echo_area_window
);
11314 f
= WINDOW_XFRAME (w
);
11319 p
.h
= (WINDOW_TO_FRAME_PIXEL_X (w
, w
->cursor
.x
)
11320 + WINDOW_LEFT_FRINGE_WIDTH (w
)
11321 + f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
));
11322 p
.v
= (WINDOW_TO_FRAME_PIXEL_Y (w
, w
->cursor
.y
)
11323 + FONT_BASE (FRAME_FONT (f
))
11324 + f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
));
11325 err
= SetEventParameter (event
, kEventParamTextInputReplyPoint
,
11326 typeQDPoint
, sizeof (typeQDPoint
), &p
);
11336 if (!NILP (id_key
))
11337 err
= mac_store_event_ref_as_apple_event (0, 0, Qtext_input
, id_key
,
11343 #endif /* TARGET_API_MAC_CARBON */
11347 install_window_handler (window
)
11350 OSStatus err
= noErr
;
11352 #if TARGET_API_MAC_CARBON
11355 static const EventTypeSpec specs
[] =
11357 /* -- window refresh events -- */
11358 {kEventClassWindow
, kEventWindowUpdate
},
11359 /* -- window state change events -- */
11360 {kEventClassWindow
, kEventWindowShowing
},
11361 {kEventClassWindow
, kEventWindowHiding
},
11362 {kEventClassWindow
, kEventWindowShown
},
11363 {kEventClassWindow
, kEventWindowHidden
},
11364 {kEventClassWindow
, kEventWindowCollapsed
},
11365 {kEventClassWindow
, kEventWindowExpanded
},
11366 {kEventClassWindow
, kEventWindowBoundsChanging
},
11367 {kEventClassWindow
, kEventWindowBoundsChanged
},
11368 /* -- window action events -- */
11369 {kEventClassWindow
, kEventWindowClose
},
11370 {kEventClassWindow
, kEventWindowGetIdealSize
},
11372 {kEventClassWindow
, kEventWindowToolbarSwitchMode
},
11375 /* -- window focus events -- */
11376 {kEventClassWindow
, kEventWindowFocusAcquired
},
11377 {kEventClassWindow
, kEventWindowFocusRelinquish
},
11380 static EventHandlerUPP handle_window_eventUPP
= NULL
;
11382 if (handle_window_eventUPP
== NULL
)
11383 handle_window_eventUPP
= NewEventHandlerUPP (mac_handle_window_event
);
11385 err
= InstallWindowEventHandler (window
, handle_window_eventUPP
,
11386 GetEventTypeCount (specs
),
11387 specs
, NULL
, NULL
);
11392 err
= install_drag_handler (window
);
11398 remove_window_handler (window
)
11401 remove_drag_handler (window
);
11404 #if TARGET_API_MAC_CARBON
11406 install_application_handler ()
11408 OSStatus err
= noErr
;
11412 static const EventTypeSpec specs
[] = {
11414 {kEventClassApplication
, kEventAppActivated
},
11415 {kEventClassApplication
, kEventAppDeactivated
},
11419 err
= InstallApplicationEventHandler (NewEventHandlerUPP
11420 (mac_handle_application_event
),
11421 GetEventTypeCount (specs
),
11422 specs
, NULL
, NULL
);
11427 static const EventTypeSpec specs
[] =
11428 {{kEventClassKeyboard
, kEventRawKeyDown
},
11429 {kEventClassKeyboard
, kEventRawKeyRepeat
},
11430 {kEventClassKeyboard
, kEventRawKeyUp
}};
11432 err
= InstallApplicationEventHandler (NewEventHandlerUPP
11433 (mac_handle_keyboard_event
),
11434 GetEventTypeCount (specs
),
11435 specs
, NULL
, NULL
);
11440 static const EventTypeSpec specs
[] =
11441 {{kEventClassCommand
, kEventCommandProcess
}};
11443 err
= InstallApplicationEventHandler (NewEventHandlerUPP
11444 (mac_handle_command_event
),
11445 GetEventTypeCount (specs
),
11446 specs
, NULL
, NULL
);
11451 static const EventTypeSpec specs
[] =
11452 {{kEventClassMouse
, kEventMouseWheelMoved
}};
11454 err
= InstallApplicationEventHandler (NewEventHandlerUPP
11455 (mac_handle_mouse_event
),
11456 GetEventTypeCount (specs
),
11457 specs
, NULL
, NULL
);
11463 static const EventTypeSpec spec
[] =
11464 {{kEventClassTextInput
, kEventTextInputUpdateActiveInputArea
},
11465 {kEventClassTextInput
, kEventTextInputUnicodeForKeyEvent
},
11466 {kEventClassTextInput
, kEventTextInputOffsetToPos
}};
11468 err
= InstallApplicationEventHandler (NewEventHandlerUPP
11469 (mac_handle_text_input_event
),
11470 GetEventTypeCount (spec
),
11476 err
= install_menu_target_item_handler ();
11480 err
= install_service_handler ();
11488 mac_handle_dm_notification (event
)
11491 mac_screen_config_changed
= 1;
11494 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
11496 mac_handle_cg_display_reconfig (display
, flags
, user_info
)
11497 CGDirectDisplayID display
;
11498 CGDisplayChangeSummaryFlags flags
;
11501 mac_screen_config_changed
= 1;
11506 init_dm_notification_handler ()
11510 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
11511 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
11512 if (CGDisplayRegisterReconfigurationCallback
!= NULL
)
11515 CGDisplayRegisterReconfigurationCallback (mac_handle_cg_display_reconfig
,
11518 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
11519 else /* CGDisplayRegisterReconfigurationCallback == NULL */
11521 #endif /* MAC_OS_X_VERSION_MAX_ALLOWED >= 1030 */
11522 #if MAC_OS_X_VERSION_MAX_ALLOWED < 1030 || MAC_OS_X_VERSION_MIN_REQUIRED == 1020
11524 static DMNotificationUPP handle_dm_notificationUPP
= NULL
;
11525 ProcessSerialNumber psn
;
11527 if (handle_dm_notificationUPP
== NULL
)
11528 handle_dm_notificationUPP
=
11529 NewDMNotificationUPP (mac_handle_dm_notification
);
11531 err
= GetCurrentProcess (&psn
);
11533 err
= DMRegisterNotifyProc (handle_dm_notificationUPP
, &psn
);
11541 mac_get_screen_info (dpyinfo
)
11542 struct mac_display_info
*dpyinfo
;
11545 /* HasDepth returns true if it is possible to have a 32 bit display,
11546 but this may not be what is actually used. Mac OSX can do better. */
11547 dpyinfo
->color_p
= CGDisplaySamplesPerPixel (kCGDirectMainDisplay
) > 1;
11548 dpyinfo
->n_planes
= CGDisplayBitsPerPixel (kCGDirectMainDisplay
);
11551 CGDisplayCount ndisps
;
11552 CGDirectDisplayID
*displays
;
11554 err
= CGGetActiveDisplayList (0, NULL
, &ndisps
);
11557 displays
= alloca (sizeof (CGDirectDisplayID
) * ndisps
);
11558 err
= CGGetActiveDisplayList (ndisps
, displays
, &ndisps
);
11562 CGRect bounds
= CGRectZero
;
11564 while (ndisps
-- > 0)
11565 bounds
= CGRectUnion (bounds
, CGDisplayBounds (displays
[ndisps
]));
11566 dpyinfo
->height
= CGRectGetHeight (bounds
);
11567 dpyinfo
->width
= CGRectGetWidth (bounds
);
11571 dpyinfo
->height
= CGDisplayPixelsHigh (kCGDirectMainDisplay
);
11572 dpyinfo
->width
= CGDisplayPixelsWide (kCGDirectMainDisplay
);
11575 #else /* !MAC_OSX */
11577 GDHandle gdh
= GetMainDevice ();
11578 Rect rect
= (**gdh
).gdRect
;
11580 dpyinfo
->color_p
= TestDeviceAttribute (gdh
, gdDevType
);
11581 for (dpyinfo
->n_planes
= 32; dpyinfo
->n_planes
> 0; dpyinfo
->n_planes
>>= 1)
11582 if (HasDepth (gdh
, dpyinfo
->n_planes
, gdDevType
, dpyinfo
->color_p
))
11585 for (gdh
= DMGetFirstScreenDevice (dmOnlyActiveDisplays
); gdh
;
11586 gdh
= DMGetNextScreenDevice (gdh
, dmOnlyActiveDisplays
))
11587 UnionRect (&rect
, &(**gdh
).gdRect
, &rect
);
11589 dpyinfo
->height
= rect
.bottom
- rect
.top
;
11590 dpyinfo
->width
= rect
.right
- rect
.left
;
11592 #endif /* !MAC_OSX */
11598 profiler_exit_proc ()
11600 ProfilerDump ("\pEmacs.prof");
11605 /* These few functions implement Emacs as a normal Mac application
11606 (almost): set up the heap and the Toolbox, handle necessary system
11607 events plus a few simple menu events. They also set up Emacs's
11608 access to functions defined in the rest of this file. Emacs uses
11609 function hooks to perform all its terminal I/O. A complete list of
11610 these functions appear in termhooks.h. For what they do, read the
11611 comments there and see also w32term.c and xterm.c. What's
11612 noticeably missing here is the event loop, which is normally
11613 present in most Mac application. After performing the necessary
11614 Mac initializations, main passes off control to emacs_main
11615 (corresponding to main in emacs.c). Emacs_main calls XTread_socket
11616 (defined further below) to read input. This is where
11617 WaitNextEvent/ReceiveNextEvent is called to process Mac events. */
11624 #if __profile__ /* is the profiler on? */
11625 if (ProfilerInit(collectDetailed
, bestTimeBase
, 5000, 200))
11630 /* set creator and type for files created by MSL */
11631 _fcreator
= MAC_EMACS_CREATOR_CODE
;
11635 do_init_managers ();
11639 #ifndef USE_LSB_TAG
11640 do_check_ram_size ();
11643 init_emacs_passwd_dir ();
11647 init_coercion_handler ();
11649 initialize_applescript ();
11651 init_apple_event_handler ();
11653 init_dm_notification_handler ();
11659 /* set up argv array from STR# resource */
11660 get_string_list (&argv
, ARGV_STRING_LIST_ID
);
11664 /* free up AppleScript resources on exit */
11665 atexit (terminate_applescript
);
11667 #if __profile__ /* is the profiler on? */
11668 atexit (profiler_exit_proc
);
11671 /* 3rd param "envp" never used in emacs_main */
11672 (void) emacs_main (argc
, argv
, 0);
11675 /* Never reached - real exit in Fkill_emacs */
11680 #if !TARGET_API_MAC_CARBON
11681 static RgnHandle mouse_region
= NULL
;
11684 mac_wait_next_event (er
, sleep_time
, dequeue
)
11689 static EventRecord er_buf
= {nullEvent
};
11690 UInt32 target_tick
, current_tick
;
11691 EventMask event_mask
;
11693 if (mouse_region
== NULL
)
11694 mouse_region
= NewRgn ();
11696 event_mask
= everyEvent
;
11697 if (!mac_ready_for_apple_events
)
11698 event_mask
-= highLevelEventMask
;
11700 current_tick
= TickCount ();
11701 target_tick
= current_tick
+ sleep_time
;
11703 if (er_buf
.what
== nullEvent
)
11704 while (!WaitNextEvent (event_mask
, &er_buf
,
11705 target_tick
- current_tick
, mouse_region
))
11707 current_tick
= TickCount ();
11708 if (target_tick
<= current_tick
)
11714 er_buf
.what
= nullEvent
;
11717 #endif /* not TARGET_API_MAC_CARBON */
11719 #if TARGET_API_MAC_CARBON
11721 mac_post_mouse_moved_event ()
11723 EventRef event
= NULL
;
11726 err
= CreateEvent (NULL
, kEventClassMouse
, kEventMouseMoved
, 0,
11727 kEventAttributeNone
, &event
);
11732 GetGlobalMouse (&mouse_pos
);
11733 err
= SetEventParameter (event
, kEventParamMouseLocation
, typeQDPoint
,
11734 sizeof (Point
), &mouse_pos
);
11738 UInt32 modifiers
= GetCurrentKeyModifiers ();
11740 err
= SetEventParameter (event
, kEventParamKeyModifiers
, typeUInt32
,
11741 sizeof (UInt32
), &modifiers
);
11744 err
= PostEventToQueue (GetCurrentEventQueue (), event
,
11745 kEventPriorityStandard
);
11747 ReleaseEvent (event
);
11753 /* Emacs calls this whenever it wants to read an input event from the
11756 XTread_socket (sd
, expected
, hold_quit
)
11758 struct input_event
*hold_quit
;
11760 struct input_event inev
;
11762 #if TARGET_API_MAC_CARBON
11764 EventTargetRef toolbox_dispatcher
;
11767 struct mac_display_info
*dpyinfo
= &one_mac_display_info
;
11769 if (interrupt_input_blocked
)
11771 interrupt_input_pending
= 1;
11775 interrupt_input_pending
= 0;
11778 /* So people can tell when we have read the available input. */
11779 input_signal_count
++;
11783 #if TARGET_API_MAC_CARBON
11784 toolbox_dispatcher
= GetEventDispatcherTarget ();
11788 mac_prepare_for_quickdraw (NULL
),
11790 !ReceiveNextEvent (0, NULL
, kEventDurationNoWait
,
11791 kEventRemoveFromQueue
, &eventRef
))
11792 #else /* !TARGET_API_MAC_CARBON */
11793 while (mac_wait_next_event (&er
, 0, true))
11794 #endif /* !TARGET_API_MAC_CARBON */
11798 unsigned long timestamp
;
11801 inev
.kind
= NO_EVENT
;
11804 #if TARGET_API_MAC_CARBON
11805 timestamp
= GetEventTime (eventRef
) / kEventDurationMillisecond
;
11807 if (!mac_convert_event_ref (eventRef
, &er
))
11809 #else /* !TARGET_API_MAC_CARBON */
11810 timestamp
= er
.when
* (1000 / 60); /* ticks to milliseconds */
11811 #endif /* !TARGET_API_MAC_CARBON */
11818 WindowRef window_ptr
;
11819 ControlPartCode part_code
;
11820 int tool_bar_p
= 0;
11822 #if TARGET_API_MAC_CARBON
11825 /* This is needed to send mouse events like aqua window
11826 buttons to the correct handler. */
11827 read_socket_inev
= &inev
;
11828 err
= SendEventToEventTarget (eventRef
, toolbox_dispatcher
);
11829 read_socket_inev
= NULL
;
11830 if (err
!= eventNotHandledErr
)
11833 last_mouse_glyph_frame
= 0;
11835 if (dpyinfo
->grabbed
&& last_mouse_frame
11836 && FRAME_LIVE_P (last_mouse_frame
))
11838 window_ptr
= FRAME_MAC_WINDOW (last_mouse_frame
);
11839 part_code
= inContent
;
11843 part_code
= FindWindow (er
.where
, &window_ptr
);
11844 if (tip_window
&& window_ptr
== tip_window
)
11846 HideWindow (tip_window
);
11847 part_code
= FindWindow (er
.where
, &window_ptr
);
11851 if (er
.what
!= mouseDown
&&
11852 (part_code
!= inContent
|| dpyinfo
->grabbed
== 0))
11858 f
= mac_focus_frame (dpyinfo
);
11859 saved_menu_event_location
= er
.where
;
11860 inev
.kind
= MENU_BAR_ACTIVATE_EVENT
;
11861 XSETFRAME (inev
.frame_or_window
, f
);
11866 #if TARGET_API_MAC_CARBON
11867 FrontNonFloatingWindow ()
11872 || (mac_window_to_frame (window_ptr
)
11873 != dpyinfo
->x_focus_frame
))
11874 SelectWindow (window_ptr
);
11877 ControlPartCode control_part_code
;
11881 ControlKind control_kind
;
11884 f
= mac_window_to_frame (window_ptr
);
11885 /* convert to local coordinates of new window */
11886 mouse_loc
.h
= (er
.where
.h
11888 + FRAME_OUTER_TO_INNER_DIFF_X (f
)));
11889 mouse_loc
.v
= (er
.where
.v
11891 + FRAME_OUTER_TO_INNER_DIFF_Y (f
)));
11892 #if TARGET_API_MAC_CARBON
11893 ch
= FindControlUnderMouse (mouse_loc
, window_ptr
,
11894 &control_part_code
);
11897 GetControlKind (ch
, &control_kind
);
11900 control_part_code
= FindControl (mouse_loc
, window_ptr
,
11904 #if TARGET_API_MAC_CARBON
11905 inev
.code
= mac_get_mouse_btn (eventRef
);
11906 inev
.modifiers
= mac_event_to_emacs_modifiers (eventRef
);
11908 inev
.code
= mac_get_emulated_btn (er
.modifiers
);
11909 inev
.modifiers
= mac_to_emacs_modifiers (er
.modifiers
);
11911 XSETINT (inev
.x
, mouse_loc
.h
);
11912 XSETINT (inev
.y
, mouse_loc
.v
);
11914 if ((dpyinfo
->grabbed
&& tracked_scroll_bar
)
11916 #ifndef USE_TOOLKIT_SCROLL_BARS
11917 /* control_part_code becomes kControlNoPart if
11918 a progress indicator is clicked. */
11919 && control_part_code
!= kControlNoPart
11920 #else /* USE_TOOLKIT_SCROLL_BARS */
11922 && control_kind
.kind
== kControlKindScrollBar
11923 #endif /* MAC_OSX */
11924 #endif /* USE_TOOLKIT_SCROLL_BARS */
11927 struct scroll_bar
*bar
;
11929 if (dpyinfo
->grabbed
&& tracked_scroll_bar
)
11931 bar
= tracked_scroll_bar
;
11932 #ifndef USE_TOOLKIT_SCROLL_BARS
11933 control_part_code
= kControlIndicatorPart
;
11937 bar
= (struct scroll_bar
*) GetControlReference (ch
);
11938 #ifdef USE_TOOLKIT_SCROLL_BARS
11939 /* Make the "Ctrl-Mouse-2 splits window" work
11940 for toolkit scroll bars. */
11941 if (inev
.modifiers
& ctrl_modifier
)
11942 x_scroll_bar_handle_click (bar
, control_part_code
,
11944 else if (er
.what
== mouseDown
)
11945 x_scroll_bar_handle_press (bar
, control_part_code
,
11948 x_scroll_bar_handle_release (bar
, &inev
);
11949 #else /* not USE_TOOLKIT_SCROLL_BARS */
11950 x_scroll_bar_handle_click (bar
, control_part_code
,
11952 if (er
.what
== mouseDown
11953 && control_part_code
== kControlIndicatorPart
)
11954 tracked_scroll_bar
= bar
;
11956 tracked_scroll_bar
= NULL
;
11957 #endif /* not USE_TOOLKIT_SCROLL_BARS */
11961 Lisp_Object window
;
11962 int x
= mouse_loc
.h
;
11963 int y
= mouse_loc
.v
;
11965 window
= window_from_coordinates (f
, x
, y
, 0, 0, 0, 1);
11966 if (EQ (window
, f
->tool_bar_window
))
11968 if (er
.what
== mouseDown
)
11969 handle_tool_bar_click (f
, x
, y
, 1, 0);
11971 handle_tool_bar_click (f
, x
, y
, 0,
11977 XSETFRAME (inev
.frame_or_window
, f
);
11978 inev
.kind
= MOUSE_CLICK_EVENT
;
11982 if (er
.what
== mouseDown
)
11984 dpyinfo
->grabbed
|= (1 << inev
.code
);
11985 last_mouse_frame
= f
;
11988 last_tool_bar_item
= -1;
11992 if ((dpyinfo
->grabbed
& (1 << inev
.code
)) == 0)
11993 /* If a button is released though it was not
11994 previously pressed, that would be because
11995 of multi-button emulation. */
11996 dpyinfo
->grabbed
= 0;
11998 dpyinfo
->grabbed
&= ~(1 << inev
.code
);
12001 /* Ignore any mouse motion that happened before
12002 this event; any subsequent mouse-movement Emacs
12003 events should reflect only motion after the
12006 f
->mouse_moved
= 0;
12008 #ifdef USE_TOOLKIT_SCROLL_BARS
12009 if (inev
.kind
== MOUSE_CLICK_EVENT
12010 || (inev
.kind
== SCROLL_BAR_CLICK_EVENT
12011 && (inev
.modifiers
& ctrl_modifier
)))
12016 inev
.modifiers
|= down_modifier
;
12019 inev
.modifiers
|= up_modifier
;
12026 #if TARGET_API_MAC_CARBON
12028 if (IsWindowPathSelectClick (window_ptr
, &er
))
12030 WindowPathSelect (window_ptr
, NULL
, NULL
);
12033 if (part_code
== inProxyIcon
12034 && (TrackWindowProxyDrag (window_ptr
, er
.where
)
12035 != errUserWantsToDragWindow
))
12037 DragWindow (window_ptr
, er
.where
, NULL
);
12038 #else /* not TARGET_API_MAC_CARBON */
12039 DragWindow (window_ptr
, er
.where
, &qd
.screenBits
.bounds
);
12040 /* Update the frame parameters. */
12042 struct frame
*f
= mac_window_to_frame (window_ptr
);
12044 if (f
&& !f
->async_iconified
)
12045 mac_handle_origin_change (f
);
12047 #endif /* not TARGET_API_MAC_CARBON */
12051 if (TrackGoAway (window_ptr
, er
.where
))
12053 inev
.kind
= DELETE_WINDOW_EVENT
;
12054 XSETFRAME (inev
.frame_or_window
,
12055 mac_window_to_frame (window_ptr
));
12059 /* window resize handling added --ben */
12061 do_grow_window (window_ptr
, &er
);
12064 /* window zoom handling added --ben */
12067 if (TrackBox (window_ptr
, er
.where
, part_code
))
12068 do_zoom_window (window_ptr
, part_code
);
12071 #if USE_MAC_TOOLBAR
12077 err
= HIViewGetViewForMouseEvent (HIViewGetRoot (window_ptr
),
12079 /* This doesn't work on Mac OS X 10.2. */
12081 HIViewClick (ch
, eventRef
);
12084 #endif /* USE_MAC_TOOLBAR */
12092 #if !TARGET_API_MAC_CARBON
12094 do_window_update ((WindowRef
) er
.message
);
12099 switch ((er
.message
>> 24) & 0x000000FF)
12101 case mouseMovedMessage
:
12102 #if !TARGET_API_MAC_CARBON
12103 SetRectRgn (mouse_region
, er
.where
.h
, er
.where
.v
,
12104 er
.where
.h
+ 1, er
.where
.v
+ 1);
12106 previous_help_echo_string
= help_echo_string
;
12107 help_echo_string
= Qnil
;
12109 if (dpyinfo
->grabbed
&& last_mouse_frame
12110 && FRAME_LIVE_P (last_mouse_frame
))
12111 f
= last_mouse_frame
;
12113 f
= dpyinfo
->x_focus_frame
;
12115 if (dpyinfo
->mouse_face_hidden
)
12117 dpyinfo
->mouse_face_hidden
= 0;
12118 clear_mouse_face (dpyinfo
);
12123 WindowRef wp
= FRAME_MAC_WINDOW (f
);
12126 mouse_pos
.h
= (er
.where
.h
12128 + FRAME_OUTER_TO_INNER_DIFF_X (f
)));
12129 mouse_pos
.v
= (er
.where
.v
12131 + FRAME_OUTER_TO_INNER_DIFF_Y (f
)));
12132 if (dpyinfo
->grabbed
&& tracked_scroll_bar
)
12133 #ifdef USE_TOOLKIT_SCROLL_BARS
12134 x_scroll_bar_handle_drag (wp
, tracked_scroll_bar
,
12136 #else /* not USE_TOOLKIT_SCROLL_BARS */
12137 x_scroll_bar_note_movement (tracked_scroll_bar
,
12139 - XINT (tracked_scroll_bar
->top
),
12140 er
.when
* (1000 / 60));
12141 #endif /* not USE_TOOLKIT_SCROLL_BARS */
12144 /* Generate SELECT_WINDOW_EVENTs when needed. */
12145 if (!NILP (Vmouse_autoselect_window
))
12147 Lisp_Object window
;
12149 window
= window_from_coordinates (f
,
12154 /* Window will be selected only when it is
12155 not selected now and last mouse movement
12156 event was not in it. Minibuffer window
12157 will be selected only when it is active. */
12158 if (WINDOWP (window
)
12159 && !EQ (window
, last_window
)
12160 && !EQ (window
, selected_window
)
12161 /* For click-to-focus window managers
12162 create event iff we don't leave the
12164 && (focus_follows_mouse
12165 || (EQ (XWINDOW (window
)->frame
,
12166 XWINDOW (selected_window
)->frame
))))
12168 inev
.kind
= SELECT_WINDOW_EVENT
;
12169 inev
.frame_or_window
= window
;
12172 last_window
=window
;
12174 if (!note_mouse_movement (f
, &mouse_pos
))
12175 help_echo_string
= previous_help_echo_string
;
12176 #if USE_MAC_TOOLBAR
12178 mac_tool_bar_note_mouse_movement (f
, eventRef
);
12183 /* If the contents of the global variable
12184 help_echo_string has changed, generate a
12186 if (!NILP (help_echo_string
) || !NILP (previous_help_echo_string
))
12197 WindowRef window_ptr
= (WindowRef
) er
.message
;
12199 ControlRef root_control
;
12201 if (window_ptr
== tip_window
)
12203 HideWindow (tip_window
);
12207 if (!is_emacs_window (window_ptr
))
12210 f
= mac_window_to_frame (window_ptr
);
12212 if ((er
.modifiers
& activeFlag
) != 0)
12214 /* A window has been activated */
12217 err
= GetRootControl (FRAME_MAC_WINDOW (f
), &root_control
);
12219 ActivateControl (root_control
);
12221 x_detect_focus_change (dpyinfo
, &er
, &inev
);
12223 mouse_loc
.h
= (er
.where
.h
12225 + FRAME_OUTER_TO_INNER_DIFF_X (f
)));
12226 mouse_loc
.v
= (er
.where
.v
12228 + FRAME_OUTER_TO_INNER_DIFF_Y (f
)));
12229 /* Window-activated event counts as mouse movement,
12230 so update things that depend on mouse position. */
12231 note_mouse_movement (f
, &mouse_loc
);
12235 /* A window has been deactivated */
12236 err
= GetRootControl (FRAME_MAC_WINDOW (f
), &root_control
);
12238 DeactivateControl (root_control
);
12240 #ifdef USE_TOOLKIT_SCROLL_BARS
12241 if (dpyinfo
->grabbed
&& tracked_scroll_bar
)
12243 struct input_event event
;
12245 EVENT_INIT (event
);
12246 event
.kind
= NO_EVENT
;
12247 x_scroll_bar_handle_release (tracked_scroll_bar
, &event
);
12248 if (event
.kind
!= NO_EVENT
)
12250 event
.timestamp
= timestamp
;
12251 kbd_buffer_store_event_hold (&event
, hold_quit
);
12256 dpyinfo
->grabbed
= 0;
12258 x_detect_focus_change (dpyinfo
, &er
, &inev
);
12260 if (f
== dpyinfo
->mouse_face_mouse_frame
)
12262 /* If we move outside the frame, then we're
12263 certainly no longer on any text in the
12265 clear_mouse_face (dpyinfo
);
12266 dpyinfo
->mouse_face_mouse_frame
= 0;
12269 /* Generate a nil HELP_EVENT to cancel a help-echo.
12270 Do it only if there's something to cancel.
12271 Otherwise, the startup message is cleared when the
12272 mouse leaves the frame. */
12273 if (any_help_event_p
)
12284 f
= mac_focus_frame (dpyinfo
);
12285 XSETFRAME (inev
.frame_or_window
, f
);
12287 /* If mouse-highlight is an integer, input clears out mouse
12289 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
)
12290 && !EQ (f
->tool_bar_window
, dpyinfo
->mouse_face_window
))
12292 clear_mouse_face (dpyinfo
);
12293 dpyinfo
->mouse_face_hidden
= 1;
12297 UInt32 modifiers
= er
.modifiers
, mapped_modifiers
;
12300 GetEventParameter (eventRef
, kEventParamKeyModifiers
,
12302 sizeof (UInt32
), NULL
, &modifiers
);
12304 mapped_modifiers
= mac_mapped_modifiers (modifiers
);
12306 #if TARGET_API_MAC_CARBON
12307 if (!(mapped_modifiers
12308 & ~(mac_pass_command_to_system
? cmdKey
: 0)
12309 & ~(mac_pass_control_to_system
? controlKey
: 0)))
12313 if (er
.what
!= keyUp
)
12314 do_keystroke (er
.what
, er
.message
& charCodeMask
,
12315 (er
.message
& keyCodeMask
) >> 8,
12316 modifiers
, timestamp
, &inev
);
12320 case kHighLevelEvent
:
12321 AEProcessAppleEvent (&er
);
12326 #if TARGET_API_MAC_CARBON
12330 read_socket_inev
= &inev
;
12331 err
= SendEventToEventTarget (eventRef
, toolbox_dispatcher
);
12332 read_socket_inev
= NULL
;
12337 #if TARGET_API_MAC_CARBON
12338 ReleaseEvent (eventRef
);
12341 if (inev
.kind
!= NO_EVENT
)
12343 inev
.timestamp
= timestamp
;
12344 kbd_buffer_store_event_hold (&inev
, hold_quit
);
12349 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
12354 XSETFRAME (frame
, f
);
12360 any_help_event_p
= 1;
12361 gen_help_event (help_echo_string
, frame
, help_echo_window
,
12362 help_echo_object
, help_echo_pos
);
12366 help_echo_string
= Qnil
;
12367 gen_help_event (Qnil
, frame
, Qnil
, Qnil
, 0);
12373 /* If the focus was just given to an autoraising frame,
12375 /* ??? This ought to be able to handle more than one such frame. */
12376 if (pending_autoraise_frame
)
12378 x_raise_frame (pending_autoraise_frame
);
12379 pending_autoraise_frame
= 0;
12382 if (mac_screen_config_changed
)
12384 mac_get_screen_info (dpyinfo
);
12385 mac_screen_config_changed
= 0;
12388 #if !TARGET_API_MAC_CARBON
12389 /* Check which frames are still visible. We do this here because
12390 there doesn't seem to be any direct notification from the Window
12391 Manager that the visibility of a window has changed (at least,
12392 not in all cases). */
12394 Lisp_Object tail
, frame
;
12396 FOR_EACH_FRAME (tail
, frame
)
12398 struct frame
*f
= XFRAME (frame
);
12400 /* The tooltip has been drawn already. Avoid the
12401 SET_FRAME_GARBAGED in mac_handle_visibility_change. */
12402 if (EQ (frame
, tip_frame
))
12405 if (FRAME_MAC_P (f
))
12406 mac_handle_visibility_change (f
);
12417 /* Need to override CodeWarrior's input function so no conversion is
12418 done on newlines Otherwise compiled functions in .elc files will be
12419 read incorrectly. Defined in ...:MSL C:MSL
12420 Common:Source:buffer_io.c. */
12423 __convert_to_newlines (unsigned char * p
, size_t * n
)
12425 #pragma unused(p,n)
12429 __convert_from_newlines (unsigned char * p
, size_t * n
)
12431 #pragma unused(p,n)
12437 make_mac_terminal_frame (struct frame
*f
)
12442 XSETFRAME (frame
, f
);
12444 f
->output_method
= output_mac
;
12445 f
->output_data
.mac
= (struct mac_output
*)
12446 xmalloc (sizeof (struct mac_output
));
12447 bzero (f
->output_data
.mac
, sizeof (struct mac_output
));
12449 XSETFRAME (FRAME_KBOARD (f
)->Vdefault_minibuffer_frame
, f
);
12451 FRAME_COLS (f
) = 96;
12452 FRAME_LINES (f
) = 4;
12454 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 1;
12455 FRAME_VERTICAL_SCROLL_BAR_TYPE (f
) = vertical_scroll_bar_right
;
12457 FRAME_DESIRED_CURSOR (f
) = FILLED_BOX_CURSOR
;
12459 f
->output_data
.mac
->cursor_pixel
= 0;
12460 f
->output_data
.mac
->border_pixel
= 0x00ff00;
12461 f
->output_data
.mac
->mouse_pixel
= 0xff00ff;
12462 f
->output_data
.mac
->cursor_foreground_pixel
= 0x0000ff;
12464 f
->output_data
.mac
->text_cursor
= kThemeIBeamCursor
;
12465 f
->output_data
.mac
->nontext_cursor
= kThemeArrowCursor
;
12466 f
->output_data
.mac
->modeline_cursor
= kThemeArrowCursor
;
12467 f
->output_data
.mac
->hand_cursor
= kThemePointingHandCursor
;
12468 f
->output_data
.mac
->hourglass_cursor
= kThemeWatchCursor
;
12469 f
->output_data
.mac
->horizontal_drag_cursor
= kThemeResizeLeftRightCursor
;
12471 FRAME_FONTSET (f
) = -1;
12472 f
->output_data
.mac
->explicit_parent
= 0;
12475 f
->border_width
= 0;
12477 f
->internal_border_width
= 0;
12482 f
->new_text_cols
= 0;
12483 f
->new_text_lines
= 0;
12485 SetRect (&r
, f
->left_pos
, f
->top_pos
,
12486 f
->left_pos
+ FRAME_PIXEL_WIDTH (f
),
12487 f
->top_pos
+ FRAME_PIXEL_HEIGHT (f
));
12491 if (!(FRAME_MAC_WINDOW (f
) =
12492 NewCWindow (NULL
, &r
, "\p", true, dBoxProc
,
12493 (WindowRef
) -1, 1, (long) f
->output_data
.mac
)))
12495 /* so that update events can find this mac_output struct */
12496 f
->output_data
.mac
->mFP
= f
; /* point back to emacs frame */
12502 /* Need to be initialized for unshow_buffer in window.c. */
12503 selected_window
= f
->selected_window
;
12505 Fmodify_frame_parameters (frame
,
12506 Fcons (Fcons (Qfont
,
12507 build_string ("-*-monaco-medium-r-*--*-90-*-*-*-*-mac-roman")), Qnil
));
12508 Fmodify_frame_parameters (frame
,
12509 Fcons (Fcons (Qforeground_color
,
12510 build_string ("black")), Qnil
));
12511 Fmodify_frame_parameters (frame
,
12512 Fcons (Fcons (Qbackground_color
,
12513 build_string ("white")), Qnil
));
12518 /***********************************************************************
12520 ***********************************************************************/
12522 static int mac_initialized
= 0;
12525 mac_make_rdb (xrm_option
)
12526 const char *xrm_option
;
12528 XrmDatabase database
;
12530 database
= xrm_get_preference_database (NULL
);
12532 xrm_merge_string_database (database
, xrm_option
);
12537 struct mac_display_info
*
12538 mac_term_init (display_name
, xrm_option
, resource_name
)
12539 Lisp_Object display_name
;
12541 char *resource_name
;
12543 struct mac_display_info
*dpyinfo
;
12544 struct terminal
*terminal
;
12548 if (!mac_initialized
)
12551 mac_initialized
= 1;
12554 if (x_display_list
)
12555 error ("Sorry, this version can only handle one display");
12557 dpyinfo
= &one_mac_display_info
;
12558 bzero (dpyinfo
, sizeof (*dpyinfo
));
12560 terminal
= mac_create_terminal (dpyinfo
);
12562 /* Set the name of the terminal. */
12563 terminal
->name
= (char *) xmalloc (SBYTES (display_name
) + 1);
12564 strncpy (terminal
->name
, SDATA (display_name
), SBYTES (display_name
));
12565 terminal
->name
[SBYTES (display_name
)] = 0;
12568 dpyinfo
->mac_id_name
12569 = (char *) xmalloc (SCHARS (Vinvocation_name
)
12570 + SCHARS (Vsystem_name
)
12572 sprintf (dpyinfo
->mac_id_name
, "%s@%s",
12573 SDATA (Vinvocation_name
), SDATA (Vsystem_name
));
12575 dpyinfo
->mac_id_name
= (char *) xmalloc (strlen ("Mac Display") + 1);
12576 strcpy (dpyinfo
->mac_id_name
, "Mac Display");
12579 dpyinfo
->reference_count
= 0;
12580 dpyinfo
->resx
= 72.0;
12581 dpyinfo
->resy
= 72.0;
12583 mac_get_screen_info (dpyinfo
);
12585 dpyinfo
->grabbed
= 0;
12586 dpyinfo
->root_window
= NULL
;
12587 dpyinfo
->image_cache
= make_image_cache ();
12589 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
12590 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
12591 dpyinfo
->mouse_face_face_id
= DEFAULT_FACE_ID
;
12592 dpyinfo
->mouse_face_window
= Qnil
;
12593 dpyinfo
->mouse_face_overlay
= Qnil
;
12594 dpyinfo
->mouse_face_hidden
= 0;
12596 dpyinfo
->xrdb
= mac_make_rdb (xrm_option
);
12598 /* Put this display on the chain. */
12599 dpyinfo
->next
= x_display_list
;
12600 x_display_list
= dpyinfo
;
12602 /* Put it on x_display_name_list. */
12603 x_display_name_list
= Fcons (Fcons (display_name
,
12604 Fcons (Qnil
, dpyinfo
->xrdb
)),
12605 x_display_name_list
);
12606 dpyinfo
->name_list_element
= XCAR (x_display_name_list
);
12609 mac_init_fringe (terminal
->rif
);
12617 /* Get rid of display DPYINFO, assuming all frames are already gone. */
12620 x_delete_display (dpyinfo
)
12621 struct mac_display_info
*dpyinfo
;
12625 /* Discard this display from x_display_name_list and x_display_list.
12626 We can't use Fdelq because that can quit. */
12627 if (! NILP (x_display_name_list
)
12628 && EQ (XCAR (x_display_name_list
), dpyinfo
->name_list_element
))
12629 x_display_name_list
= XCDR (x_display_name_list
);
12634 tail
= x_display_name_list
;
12635 while (CONSP (tail
) && CONSP (XCDR (tail
)))
12637 if (EQ (XCAR (XCDR (tail
)), dpyinfo
->name_list_element
))
12639 XSETCDR (tail
, XCDR (XCDR (tail
)));
12642 tail
= XCDR (tail
);
12646 if (x_display_list
== dpyinfo
)
12647 x_display_list
= dpyinfo
->next
;
12650 struct x_display_info
*tail
;
12652 for (tail
= x_display_list
; tail
; tail
= tail
->next
)
12653 if (tail
->next
== dpyinfo
)
12654 tail
->next
= tail
->next
->next
;
12657 /* Free the font names in the font table. */
12658 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
12659 if (dpyinfo
->font_table
[i
].name
)
12661 if (dpyinfo
->font_table
[i
].name
!= dpyinfo
->font_table
[i
].full_name
)
12662 xfree (dpyinfo
->font_table
[i
].full_name
);
12663 xfree (dpyinfo
->font_table
[i
].name
);
12666 if (dpyinfo
->font_table
)
12668 if (dpyinfo
->font_table
->font_encoder
)
12669 xfree (dpyinfo
->font_table
->font_encoder
);
12670 xfree (dpyinfo
->font_table
);
12672 if (dpyinfo
->mac_id_name
)
12673 xfree (dpyinfo
->mac_id_name
);
12675 if (x_display_list
== 0)
12677 mac_clear_font_name_table ();
12678 bzero (dpyinfo
, sizeof (*dpyinfo
));
12689 MenuItemIndex menu_index
;
12691 err
= GetIndMenuItemWithCommandID (NULL
, kHICommandQuit
, 1,
12692 &menu
, &menu_index
);
12694 SetMenuItemCommandKey (menu
, menu_index
, false, 0);
12695 EnableMenuCommand (NULL
, kHICommandPreferences
);
12696 err
= GetIndMenuItemWithCommandID (NULL
, kHICommandPreferences
, 1,
12697 &menu
, &menu_index
);
12700 SetMenuItemCommandKey (menu
, menu_index
, false, 0);
12701 InsertMenuItemTextWithCFString (menu
, NULL
,
12702 0, kMenuItemAttrSeparator
, 0);
12703 InsertMenuItemTextWithCFString (menu
, CFSTR ("About Emacs"),
12704 0, 0, kHICommandAbout
);
12706 #else /* !MAC_OSX */
12707 #if TARGET_API_MAC_CARBON
12708 SetMenuItemCommandID (GetMenuRef (M_APPLE
), I_ABOUT
, kHICommandAbout
);
12718 static InterfaceTypeList types
= {kUnicodeDocument
};
12720 static InterfaceTypeList types
= {kTextService
};
12723 NewTSMDocument (sizeof (types
) / sizeof (types
[0]), types
,
12724 &tsm_document_id
, 0);
12728 /* Set up use of X before we make the first connection. */
12730 extern frame_parm_handler mac_frame_parm_handlers
[];
12732 static struct redisplay_interface x_redisplay_interface
=
12734 mac_frame_parm_handlers
,
12738 x_clear_end_of_line
,
12740 x_after_update_window_line
,
12741 x_update_window_begin
,
12742 x_update_window_end
,
12746 mac_flush_display_optional
,
12748 0, /* flush_display_optional */
12750 x_clear_window_mouse_face
,
12751 x_get_glyph_overhangs
,
12752 x_fix_overlapping_area
,
12753 x_draw_fringe_bitmap
,
12755 mac_define_fringe_bitmap
,
12756 mac_destroy_fringe_bitmap
,
12758 0, /* define_fringe_bitmap */
12759 0, /* destroy_fringe_bitmap */
12761 mac_per_char_metric
,
12763 mac_compute_glyph_string_overhangs
,
12764 x_draw_glyph_string
,
12765 mac_define_frame_cursor
,
12766 mac_clear_frame_area
,
12767 mac_draw_window_cursor
,
12768 mac_draw_vertical_window_border
,
12769 mac_shift_glyphs_for_insert
12772 static struct terminal
*
12773 mac_create_terminal (struct mac_display_info
*dpyinfo
)
12775 struct terminal
*terminal
;
12777 terminal
= create_terminal ();
12779 terminal
->type
= output_mac
;
12780 terminal
->display_info
.mac
= dpyinfo
;
12781 dpyinfo
->terminal
= terminal
;
12783 terminal
->clear_frame_hook
= x_clear_frame
;
12784 terminal
->ins_del_lines_hook
= x_ins_del_lines
;
12785 terminal
->delete_glyphs_hook
= x_delete_glyphs
;
12786 terminal
->ring_bell_hook
= XTring_bell
;
12787 terminal
->reset_terminal_modes_hook
= XTreset_terminal_modes
;
12788 terminal
->set_terminal_modes_hook
= XTset_terminal_modes
;
12789 terminal
->update_begin_hook
= x_update_begin
;
12790 terminal
->update_end_hook
= x_update_end
;
12791 terminal
->set_terminal_window_hook
= XTset_terminal_window
;
12792 terminal
->read_socket_hook
= XTread_socket
;
12793 terminal
->frame_up_to_date_hook
= XTframe_up_to_date
;
12794 terminal
->mouse_position_hook
= XTmouse_position
;
12795 terminal
->frame_rehighlight_hook
= XTframe_rehighlight
;
12796 terminal
->frame_raise_lower_hook
= XTframe_raise_lower
;
12797 /* terminal->fullscreen_hook = XTfullscreen_hook; */
12798 terminal
->set_vertical_scroll_bar_hook
= XTset_vertical_scroll_bar
;
12799 terminal
->condemn_scroll_bars_hook
= XTcondemn_scroll_bars
;
12800 terminal
->redeem_scroll_bar_hook
= XTredeem_scroll_bar
;
12801 terminal
->judge_scroll_bars_hook
= XTjudge_scroll_bars
;
12802 terminal
->delete_frame_hook
= x_destroy_window
;
12803 /* terminal->delete_terminal_hook = x_delete_terminal; */
12805 terminal
->rif
= &x_redisplay_interface
;
12807 TTY_SCROLL_REGION_OK (CURTTY ()) = 1; /* we'll scroll partial frames */
12808 TTY_CHAR_INS_DEL_OK (CURTTY ()) = 1;
12809 TTY_LINE_INS_DEL_OK (CURTTY ()) = 1; /* we'll just blt 'em */
12810 TTY_FAST_CLEAR_END_OF_LINE (CURTTY ()) = 1; /* X does this well */
12811 TTY_MEMORY_BELOW_FRAME (CURTTY ()) = 0; /* we don't remember what
12815 terminal
->scroll_region_ok
= 1; /* We'll scroll partial frames. */
12816 terminal
->char_ins_del_ok
= 1;
12817 terminal
->line_ins_del_ok
= 1; /* We'll just blt 'em. */
12818 terminal
->fast_clear_end_of_line
= 1; /* X does this well. */
12819 terminal
->memory_below_frame
= 0; /* We don't remember what scrolls
12833 last_tool_bar_item
= -1;
12834 any_help_event_p
= 0;
12836 /* Try to use interrupt input; if we can't, then start polling. */
12837 Fset_input_interrupt_mode (Qt
);
12841 #if TARGET_API_MAC_CARBON
12843 install_application_handler ();
12852 init_coercion_handler ();
12854 init_apple_event_handler ();
12856 init_dm_notification_handler ();
12858 if (!inhibit_window_system
)
12860 static const ProcessSerialNumber psn
= {0, kCurrentProcess
};
12862 SetFrontProcess (&psn
);
12880 staticpro (&x_error_message_string
);
12881 x_error_message_string
= Qnil
;
12884 Qcontrol
= intern ("control"); staticpro (&Qcontrol
);
12885 Qmeta
= intern ("meta"); staticpro (&Qmeta
);
12886 Qalt
= intern ("alt"); staticpro (&Qalt
);
12887 Qhyper
= intern ("hyper"); staticpro (&Qhyper
);
12888 Qsuper
= intern ("super"); staticpro (&Qsuper
);
12889 Qmodifier_value
= intern ("modifier-value");
12890 staticpro (&Qmodifier_value
);
12892 Fput (Qcontrol
, Qmodifier_value
, make_number (ctrl_modifier
));
12893 Fput (Qmeta
, Qmodifier_value
, make_number (meta_modifier
));
12894 Fput (Qalt
, Qmodifier_value
, make_number (alt_modifier
));
12895 Fput (Qhyper
, Qmodifier_value
, make_number (hyper_modifier
));
12896 Fput (Qsuper
, Qmodifier_value
, make_number (super_modifier
));
12898 #if TARGET_API_MAC_CARBON
12899 Qhi_command
= intern ("hi-command"); staticpro (&Qhi_command
);
12901 Qtoolbar_switch_mode
= intern ("toolbar-switch-mode");
12902 staticpro (&Qtoolbar_switch_mode
);
12903 #if USE_MAC_FONT_PANEL
12904 Qpanel_closed
= intern ("panel-closed"); staticpro (&Qpanel_closed
);
12905 Qselection
= intern ("selection"); staticpro (&Qselection
);
12908 Qservice
= intern ("service"); staticpro (&Qservice
);
12909 Qpaste
= intern ("paste"); staticpro (&Qpaste
);
12910 Qperform
= intern ("perform"); staticpro (&Qperform
);
12913 Qtext_input
= intern ("text-input"); staticpro (&Qtext_input
);
12914 Qupdate_active_input_area
= intern ("update-active-input-area");
12915 staticpro (&Qupdate_active_input_area
);
12916 Qunicode_for_key_event
= intern ("unicode-for-key-event");
12917 staticpro (&Qunicode_for_key_event
);
12922 Fprovide (intern ("mac-carbon"), Qnil
);
12925 staticpro (&Qreverse
);
12926 Qreverse
= intern ("reverse");
12928 staticpro (&x_display_name_list
);
12929 x_display_name_list
= Qnil
;
12931 staticpro (&last_mouse_scroll_bar
);
12932 last_mouse_scroll_bar
= Qnil
;
12934 staticpro (&fm_font_family_alist
);
12935 fm_font_family_alist
= Qnil
;
12938 staticpro (&atsu_font_id_hash
);
12939 atsu_font_id_hash
= Qnil
;
12941 staticpro (&fm_style_face_attributes_alist
);
12942 fm_style_face_attributes_alist
= Qnil
;
12946 staticpro (&saved_ts_script_language_on_focus
);
12947 saved_ts_script_language_on_focus
= Qnil
;
12950 /* We don't yet support this, but defining this here avoids whining
12951 from cus-start.el and other places, like "M-x set-variable". */
12952 DEFVAR_BOOL ("x-use-underline-position-properties",
12953 &x_use_underline_position_properties
,
12954 doc
: /* *Non-nil means make use of UNDERLINE_POSITION font properties.
12955 A value of nil means ignore them. If you encounter fonts with bogus
12956 UNDERLINE_POSITION font properties, for example 7x13 on XFree prior
12957 to 4.1, set this to nil.
12959 NOTE: Not supported on Mac yet. */);
12960 x_use_underline_position_properties
= 0;
12962 DEFVAR_BOOL ("x-underline-at-descent-line",
12963 &x_underline_at_descent_line
,
12964 doc
: /* *Non-nil means to draw the underline at the same place as the descent line.
12965 A value of nil means to draw the underline according to the value of the
12966 variable `x-use-underline-position-properties', which is usually at the
12967 baseline level. The default value is nil. */);
12968 x_underline_at_descent_line
= 0;
12970 DEFVAR_LISP ("x-toolkit-scroll-bars", &Vx_toolkit_scroll_bars
,
12971 doc
: /* If not nil, Emacs uses toolkit scroll bars. */);
12972 #ifdef USE_TOOLKIT_SCROLL_BARS
12973 Vx_toolkit_scroll_bars
= Qt
;
12975 Vx_toolkit_scroll_bars
= Qnil
;
12978 staticpro (&last_mouse_motion_frame
);
12979 last_mouse_motion_frame
= Qnil
;
12981 /* Variables to configure modifier key assignment. */
12983 DEFVAR_LISP ("mac-control-modifier", &Vmac_control_modifier
,
12984 doc
: /* *Modifier key assumed when the Mac control key is pressed.
12985 The value can be `control', `meta', `alt', `hyper', or `super' for the
12986 respective modifier. The default is `control'. */);
12987 Vmac_control_modifier
= Qcontrol
;
12989 DEFVAR_LISP ("mac-option-modifier", &Vmac_option_modifier
,
12990 doc
: /* *Modifier key assumed when the Mac alt/option key is pressed.
12991 The value can be `control', `meta', `alt', `hyper', or `super' for the
12992 respective modifier. If the value is nil then the key will act as the
12993 normal Mac control modifier, and the option key can be used to compose
12994 characters depending on the chosen Mac keyboard setting. */);
12995 Vmac_option_modifier
= Qnil
;
12997 DEFVAR_LISP ("mac-command-modifier", &Vmac_command_modifier
,
12998 doc
: /* *Modifier key assumed when the Mac command key is pressed.
12999 The value can be `control', `meta', `alt', `hyper', or `super' for the
13000 respective modifier. The default is `meta'. */);
13001 Vmac_command_modifier
= Qmeta
;
13003 DEFVAR_LISP ("mac-function-modifier", &Vmac_function_modifier
,
13004 doc
: /* *Modifier key assumed when the Mac function key is pressed.
13005 The value can be `control', `meta', `alt', `hyper', or `super' for the
13006 respective modifier. Note that remapping the function key may lead to
13007 unexpected results for some keys on non-US/GB keyboards. */);
13008 Vmac_function_modifier
= Qnil
;
13010 DEFVAR_LISP ("mac-emulate-three-button-mouse",
13011 &Vmac_emulate_three_button_mouse
,
13012 doc
: /* *Specify a way of three button mouse emulation.
13013 The value can be nil, t, or the symbol `reverse'.
13014 A value of nil means that no emulation should be done and the modifiers
13015 should be placed on the mouse-1 event.
13016 t means that when the option-key is held down while pressing the mouse
13017 button, the click will register as mouse-2 and while the command-key
13018 is held down, the click will register as mouse-3.
13019 The symbol `reverse' means that the option-key will register for
13020 mouse-3 and the command-key will register for mouse-2. */);
13021 Vmac_emulate_three_button_mouse
= Qnil
;
13023 #if TARGET_API_MAC_CARBON
13024 DEFVAR_BOOL ("mac-wheel-button-is-mouse-2", &mac_wheel_button_is_mouse_2
,
13025 doc
: /* *Non-nil if the wheel button is mouse-2 and the right click mouse-3.
13026 Otherwise, the right click will be treated as mouse-2 and the wheel
13027 button will be mouse-3. */);
13028 mac_wheel_button_is_mouse_2
= 1;
13030 DEFVAR_BOOL ("mac-pass-command-to-system", &mac_pass_command_to_system
,
13031 doc
: /* *Non-nil if command key presses are passed on to the Mac Toolbox. */);
13032 mac_pass_command_to_system
= 1;
13034 DEFVAR_BOOL ("mac-pass-control-to-system", &mac_pass_control_to_system
,
13035 doc
: /* *Non-nil if control key presses are passed on to the Mac Toolbox. */);
13036 mac_pass_control_to_system
= 1;
13040 DEFVAR_BOOL ("mac-allow-anti-aliasing", &mac_use_core_graphics
,
13041 doc
: /* *If non-nil, allow anti-aliasing.
13042 The text will be rendered using Core Graphics text rendering which
13043 may anti-alias the text. */);
13045 mac_use_core_graphics
= 1;
13047 mac_use_core_graphics
= 0;
13050 /* Register an entry for `mac-roman' so that it can be used when
13051 creating the terminal frame on Mac OS 9 before loading
13052 term/mac-win.elc. */
13053 DEFVAR_LISP ("mac-charset-info-alist", &Vmac_charset_info_alist
,
13054 doc
: /* Alist of Emacs character sets vs text encodings and coding systems.
13055 Each entry should be of the form:
13057 (CHARSET-NAME TEXT-ENCODING CODING-SYSTEM)
13059 where CHARSET-NAME is a string used in font names to identify the
13060 charset, TEXT-ENCODING is a TextEncodingBase value in Mac, and
13061 CODING_SYSTEM is a coding system corresponding to TEXT-ENCODING. */);
13062 Vmac_charset_info_alist
=
13063 Fcons (list3 (build_string ("mac-roman"),
13064 make_number (smRoman
), Qnil
), Qnil
);
13067 DEFVAR_LISP ("mac-ts-active-input-overlay", &Vmac_ts_active_input_overlay
,
13068 doc
: /* Overlay used to display Mac TSM active input area. */);
13069 Vmac_ts_active_input_overlay
= Qnil
;
13071 DEFVAR_LISP ("mac-ts-script-language-on-focus", &Vmac_ts_script_language_on_focus
,
13072 doc
: /* *How to change Mac TSM script/language when a frame gets focus.
13073 If the value is t, the input script and language are restored to those
13074 used in the last focus frame. If the value is a pair of integers, the
13075 input script and language codes, which are defined in the Script
13076 Manager, are set to its car and cdr parts, respectively. Otherwise,
13077 Emacs doesn't set them and thus follows the system default behavior. */);
13078 Vmac_ts_script_language_on_focus
= Qnil
;
13082 /* arch-tag: f2259165-4454-4c04-a029-a133c8af7b5b
13083 (do not change this comment) */