]> code.delx.au - gnu-emacs/blob - src/macfns.c
delx.au / code / gnu-emacs / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
(replace-highlight): Bind search-whitespace-regexp to nil.
[gnu-emacs] / src / macfns.c
1 /* Graphical user interface functions for Mac OS.
2 Copyright (C) 2000, 2001, 2002, 2003, 2004,
3 2005, 2006, 2007 Free Software Foundation, Inc.
4
5 This file is part of GNU Emacs.
6
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
21
22 /* Contributed by Andrew Choi (akochoi@mac.com). */
23
24 #include <config.h>
25 #include <stdio.h>
26 #include <math.h>
27
28 #include "lisp.h"
29 #include "macterm.h"
30 #include "frame.h"
31 #include "window.h"
32 #include "buffer.h"
33 #include "intervals.h"
34 #include "dispextern.h"
35 #include "keyboard.h"
36 #include "blockinput.h"
37 #include <epaths.h>
38 #include "charset.h"
39 #include "coding.h"
40 #include "fontset.h"
41 #include "systime.h"
42 #include "termhooks.h"
43 #include "atimer.h"
44
45 #include <ctype.h>
46 #include <sys/types.h>
47 #include <sys/stat.h>
48 #include <limits.h>
49 #include <errno.h>
50 #include <sys/param.h>
51
52 extern void free_frame_menubar ();
53
54 #if TARGET_API_MAC_CARBON
55
56 /* Carbon version info */
57
58 static Lisp_Object Vmac_carbon_version_string;
59
60 #endif /* TARGET_API_MAC_CARBON */
61
62 /* Non-zero means we're allowed to display an hourglass cursor. */
63
64 int display_hourglass_p;
65
66 /* The background and shape of the mouse pointer, and shape when not
67 over text or in the modeline. */
68
69 Lisp_Object Vx_pointer_shape, Vx_nontext_pointer_shape, Vx_mode_pointer_shape;
70 Lisp_Object Vx_hourglass_pointer_shape;
71
72 /* The shape when over mouse-sensitive text. */
73
74 Lisp_Object Vx_sensitive_text_pointer_shape;
75
76 /* If non-nil, the pointer shape to indicate that windows can be
77 dragged horizontally. */
78
79 Lisp_Object Vx_window_horizontal_drag_shape;
80
81 /* Color of chars displayed in cursor box. */
82
83 Lisp_Object Vx_cursor_fore_pixel;
84
85 /* Nonzero if using Windows. */
86
87 static int mac_in_use;
88
89 /* Non nil if no window manager is in use. */
90
91 Lisp_Object Vx_no_window_manager;
92
93 /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'. */
94
95 Lisp_Object Vx_pixel_size_width_font_regexp;
96
97 Lisp_Object Qnone;
98 Lisp_Object Qsuppress_icon;
99 Lisp_Object Qundefined_color;
100 Lisp_Object Qcancel_timer;
101
102 /* In dispnew.c */
103
104 extern Lisp_Object Vwindow_system_version;
105
106 #if GLYPH_DEBUG
107 int image_cache_refcount, dpyinfo_refcount;
108 #endif
109
110
111 #if 0 /* Use xstricmp instead. */
112 /* compare two strings ignoring case */
113
114 static int
115 stricmp (const char *s, const char *t)
116 {
117 for ( ; tolower (*s) == tolower (*t); s++, t++)
118 if (*s == '\0')
119 return 0;
120 return tolower (*s) - tolower (*t);
121 }
122 #endif
123
124 /* compare two strings up to n characters, ignoring case */
125
126 static int
127 strnicmp (const char *s, const char *t, unsigned int n)
128 {
129 for ( ; n > 0 && tolower (*s) == tolower (*t); n--, s++, t++)
130 if (*s == '\0')
131 return 0;
132 return n == 0 ? 0 : tolower (*s) - tolower (*t);
133 }
134
135 \f
136 /* Error if we are not running on Mac OS. */
137
138 void
139 check_mac ()
140 {
141 if (! mac_in_use)
142 error ("Mac native windows not in use or not initialized");
143 }
144
145 /* Nonzero if we can use mouse menus.
146 You should not call this unless HAVE_MENUS is defined. */
147
148 int
149 have_menus_p ()
150 {
151 return mac_in_use;
152 }
153
154 /* Extract a frame as a FRAME_PTR, defaulting to the selected frame
155 and checking validity for Mac. */
156
157 FRAME_PTR
158 check_x_frame (frame)
159 Lisp_Object frame;
160 {
161 FRAME_PTR f;
162
163 if (NILP (frame))
164 frame = selected_frame;
165 CHECK_LIVE_FRAME (frame);
166 f = XFRAME (frame);
167 if (! FRAME_MAC_P (f))
168 error ("Non-Mac frame used");
169 return f;
170 }
171
172 /* Let the user specify a display with a frame.
173 nil stands for the selected frame--or, if that is not a mac frame,
174 the first display on the list. */
175
176 struct mac_display_info *
177 check_x_display_info (frame)
178 Lisp_Object frame;
179 {
180 struct mac_display_info *dpyinfo = NULL;
181
182 if (NILP (frame))
183 {
184 struct frame *sf = XFRAME (selected_frame);
185
186 if (FRAME_MAC_P (sf) && FRAME_LIVE_P (sf))
187 dpyinfo = FRAME_MAC_DISPLAY_INFO (sf);
188 else if (x_display_list != 0)
189 dpyinfo = x_display_list;
190 else
191 error ("Mac native windows are not in use or not initialized");
192 }
193 else if (STRINGP (frame))
194 dpyinfo = x_display_info_for_name (frame);
195 else
196 {
197 FRAME_PTR f = check_x_frame (frame);
198 dpyinfo = FRAME_MAC_DISPLAY_INFO (f);
199 }
200
201 return dpyinfo;
202 }
203
204 \f
205
206 static Lisp_Object unwind_create_frame P_ ((Lisp_Object));
207 static Lisp_Object unwind_create_tip_frame P_ ((Lisp_Object));
208
209 void x_set_foreground_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
210 void x_set_background_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
211 void x_set_mouse_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
212 void x_set_cursor_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
213 void x_set_border_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
214 void x_set_cursor_type P_ ((struct frame *, Lisp_Object, Lisp_Object));
215 void x_set_icon_type P_ ((struct frame *, Lisp_Object, Lisp_Object));
216 void x_set_icon_name P_ ((struct frame *, Lisp_Object, Lisp_Object));
217 void x_explicitly_set_name P_ ((struct frame *, Lisp_Object, Lisp_Object));
218 void x_set_menu_bar_lines P_ ((struct frame *, Lisp_Object, Lisp_Object));
219 void x_set_title P_ ((struct frame *, Lisp_Object, Lisp_Object));
220 void x_set_tool_bar_lines P_ ((struct frame *, Lisp_Object, Lisp_Object));
221
222 extern void mac_get_window_bounds P_ ((struct frame *, Rect *, Rect *));
223
224 \f
225
226 /* Store the screen positions of frame F into XPTR and YPTR.
227 These are the positions of the containing window manager window,
228 not Emacs's own window. */
229
230 void
231 x_real_positions (f, xptr, yptr)
232 FRAME_PTR f;
233 int *xptr, *yptr;
234 {
235 Rect inner, outer;
236
237 mac_get_window_bounds (f, &inner, &outer);
238
239 f->x_pixels_diff = inner.left - outer.left;
240 f->y_pixels_diff = inner.top - outer.top;
241
242 *xptr = outer.left;
243 *yptr = outer.top;
244 }
245
246 \f
247 /* The default colors for the Mac color map */
248 typedef struct colormap_t
249 {
250 unsigned long color;
251 char *name;
252 } colormap_t;
253
254 static const colormap_t mac_color_map[] =
255 {
256 { RGB_TO_ULONG(255, 250, 250), "snow" },
257 { RGB_TO_ULONG(248, 248, 255), "ghost white" },
258 { RGB_TO_ULONG(248, 248, 255), "GhostWhite" },
259 { RGB_TO_ULONG(245, 245, 245), "white smoke" },
260 { RGB_TO_ULONG(245, 245, 245), "WhiteSmoke" },
261 { RGB_TO_ULONG(220, 220, 220), "gainsboro" },
262 { RGB_TO_ULONG(255, 250, 240), "floral white" },
263 { RGB_TO_ULONG(255, 250, 240), "FloralWhite" },
264 { RGB_TO_ULONG(253, 245, 230), "old lace" },
265 { RGB_TO_ULONG(253, 245, 230), "OldLace" },
266 { RGB_TO_ULONG(250, 240, 230), "linen" },
267 { RGB_TO_ULONG(250, 235, 215), "antique white" },
268 { RGB_TO_ULONG(250, 235, 215), "AntiqueWhite" },
269 { RGB_TO_ULONG(255, 239, 213), "papaya whip" },
270 { RGB_TO_ULONG(255, 239, 213), "PapayaWhip" },
271 { RGB_TO_ULONG(255, 235, 205), "blanched almond" },
272 { RGB_TO_ULONG(255, 235, 205), "BlanchedAlmond" },
273 { RGB_TO_ULONG(255, 228, 196), "bisque" },
274 { RGB_TO_ULONG(255, 218, 185), "peach puff" },
275 { RGB_TO_ULONG(255, 218, 185), "PeachPuff" },
276 { RGB_TO_ULONG(255, 222, 173), "navajo white" },
277 { RGB_TO_ULONG(255, 222, 173), "NavajoWhite" },
278 { RGB_TO_ULONG(255, 228, 181), "moccasin" },
279 { RGB_TO_ULONG(255, 248, 220), "cornsilk" },
280 { RGB_TO_ULONG(255, 255, 240), "ivory" },
281 { RGB_TO_ULONG(255, 250, 205), "lemon chiffon" },
282 { RGB_TO_ULONG(255, 250, 205), "LemonChiffon" },
283 { RGB_TO_ULONG(255, 245, 238), "seashell" },
284 { RGB_TO_ULONG(240, 255, 240), "honeydew" },
285 { RGB_TO_ULONG(245, 255, 250), "mint cream" },
286 { RGB_TO_ULONG(245, 255, 250), "MintCream" },
287 { RGB_TO_ULONG(240, 255, 255), "azure" },
288 { RGB_TO_ULONG(240, 248, 255), "alice blue" },
289 { RGB_TO_ULONG(240, 248, 255), "AliceBlue" },
290 { RGB_TO_ULONG(230, 230, 250), "lavender" },
291 { RGB_TO_ULONG(255, 240, 245), "lavender blush" },
292 { RGB_TO_ULONG(255, 240, 245), "LavenderBlush" },
293 { RGB_TO_ULONG(255, 228, 225), "misty rose" },
294 { RGB_TO_ULONG(255, 228, 225), "MistyRose" },
295 { RGB_TO_ULONG(255, 255, 255), "white" },
296 { RGB_TO_ULONG(0 , 0 , 0 ), "black" },
297 { RGB_TO_ULONG(47 , 79 , 79 ), "dark slate gray" },
298 { RGB_TO_ULONG(47 , 79 , 79 ), "DarkSlateGray" },
299 { RGB_TO_ULONG(47 , 79 , 79 ), "dark slate grey" },
300 { RGB_TO_ULONG(47 , 79 , 79 ), "DarkSlateGrey" },
301 { RGB_TO_ULONG(105, 105, 105), "dim gray" },
302 { RGB_TO_ULONG(105, 105, 105), "DimGray" },
303 { RGB_TO_ULONG(105, 105, 105), "dim grey" },
304 { RGB_TO_ULONG(105, 105, 105), "DimGrey" },
305 { RGB_TO_ULONG(112, 128, 144), "slate gray" },
306 { RGB_TO_ULONG(112, 128, 144), "SlateGray" },
307 { RGB_TO_ULONG(112, 128, 144), "slate grey" },
308 { RGB_TO_ULONG(112, 128, 144), "SlateGrey" },
309 { RGB_TO_ULONG(119, 136, 153), "light slate gray" },
310 { RGB_TO_ULONG(119, 136, 153), "LightSlateGray" },
311 { RGB_TO_ULONG(119, 136, 153), "light slate grey" },
312 { RGB_TO_ULONG(119, 136, 153), "LightSlateGrey" },
313 { RGB_TO_ULONG(190, 190, 190), "gray" },
314 { RGB_TO_ULONG(190, 190, 190), "grey" },
315 { RGB_TO_ULONG(211, 211, 211), "light grey" },
316 { RGB_TO_ULONG(211, 211, 211), "LightGrey" },
317 { RGB_TO_ULONG(211, 211, 211), "light gray" },
318 { RGB_TO_ULONG(211, 211, 211), "LightGray" },
319 { RGB_TO_ULONG(25 , 25 , 112), "midnight blue" },
320 { RGB_TO_ULONG(25 , 25 , 112), "MidnightBlue" },
321 { RGB_TO_ULONG(0 , 0 , 128), "navy" },
322 { RGB_TO_ULONG(0 , 0 , 128), "navy blue" },
323 { RGB_TO_ULONG(0 , 0 , 128), "NavyBlue" },
324 { RGB_TO_ULONG(100, 149, 237), "cornflower blue" },
325 { RGB_TO_ULONG(100, 149, 237), "CornflowerBlue" },
326 { RGB_TO_ULONG(72 , 61 , 139), "dark slate blue" },
327 { RGB_TO_ULONG(72 , 61 , 139), "DarkSlateBlue" },
328 { RGB_TO_ULONG(106, 90 , 205), "slate blue" },
329 { RGB_TO_ULONG(106, 90 , 205), "SlateBlue" },
330 { RGB_TO_ULONG(123, 104, 238), "medium slate blue" },
331 { RGB_TO_ULONG(123, 104, 238), "MediumSlateBlue" },
332 { RGB_TO_ULONG(132, 112, 255), "light slate blue" },
333 { RGB_TO_ULONG(132, 112, 255), "LightSlateBlue" },
334 { RGB_TO_ULONG(0 , 0 , 205), "medium blue" },
335 { RGB_TO_ULONG(0 , 0 , 205), "MediumBlue" },
336 { RGB_TO_ULONG(65 , 105, 225), "royal blue" },
337 { RGB_TO_ULONG(65 , 105, 225), "RoyalBlue" },
338 { RGB_TO_ULONG(0 , 0 , 255), "blue" },
339 { RGB_TO_ULONG(30 , 144, 255), "dodger blue" },
340 { RGB_TO_ULONG(30 , 144, 255), "DodgerBlue" },
341 { RGB_TO_ULONG(0 , 191, 255), "deep sky blue" },
342 { RGB_TO_ULONG(0 , 191, 255), "DeepSkyBlue" },
343 { RGB_TO_ULONG(135, 206, 235), "sky blue" },
344 { RGB_TO_ULONG(135, 206, 235), "SkyBlue" },
345 { RGB_TO_ULONG(135, 206, 250), "light sky blue" },
346 { RGB_TO_ULONG(135, 206, 250), "LightSkyBlue" },
347 { RGB_TO_ULONG(70 , 130, 180), "steel blue" },
348 { RGB_TO_ULONG(70 , 130, 180), "SteelBlue" },
349 { RGB_TO_ULONG(176, 196, 222), "light steel blue" },
350 { RGB_TO_ULONG(176, 196, 222), "LightSteelBlue" },
351 { RGB_TO_ULONG(173, 216, 230), "light blue" },
352 { RGB_TO_ULONG(173, 216, 230), "LightBlue" },
353 { RGB_TO_ULONG(176, 224, 230), "powder blue" },
354 { RGB_TO_ULONG(176, 224, 230), "PowderBlue" },
355 { RGB_TO_ULONG(175, 238, 238), "pale turquoise" },
356 { RGB_TO_ULONG(175, 238, 238), "PaleTurquoise" },
357 { RGB_TO_ULONG(0 , 206, 209), "dark turquoise" },
358 { RGB_TO_ULONG(0 , 206, 209), "DarkTurquoise" },
359 { RGB_TO_ULONG(72 , 209, 204), "medium turquoise" },
360 { RGB_TO_ULONG(72 , 209, 204), "MediumTurquoise" },
361 { RGB_TO_ULONG(64 , 224, 208), "turquoise" },
362 { RGB_TO_ULONG(0 , 255, 255), "cyan" },
363 { RGB_TO_ULONG(224, 255, 255), "light cyan" },
364 { RGB_TO_ULONG(224, 255, 255), "LightCyan" },
365 { RGB_TO_ULONG(95 , 158, 160), "cadet blue" },
366 { RGB_TO_ULONG(95 , 158, 160), "CadetBlue" },
367 { RGB_TO_ULONG(102, 205, 170), "medium aquamarine" },
368 { RGB_TO_ULONG(102, 205, 170), "MediumAquamarine" },
369 { RGB_TO_ULONG(127, 255, 212), "aquamarine" },
370 { RGB_TO_ULONG(0 , 100, 0 ), "dark green" },
371 { RGB_TO_ULONG(0 , 100, 0 ), "DarkGreen" },
372 { RGB_TO_ULONG(85 , 107, 47 ), "dark olive green" },
373 { RGB_TO_ULONG(85 , 107, 47 ), "DarkOliveGreen" },
374 { RGB_TO_ULONG(143, 188, 143), "dark sea green" },
375 { RGB_TO_ULONG(143, 188, 143), "DarkSeaGreen" },
376 { RGB_TO_ULONG(46 , 139, 87 ), "sea green" },
377 { RGB_TO_ULONG(46 , 139, 87 ), "SeaGreen" },
378 { RGB_TO_ULONG(60 , 179, 113), "medium sea green" },
379 { RGB_TO_ULONG(60 , 179, 113), "MediumSeaGreen" },
380 { RGB_TO_ULONG(32 , 178, 170), "light sea green" },
381 { RGB_TO_ULONG(32 , 178, 170), "LightSeaGreen" },
382 { RGB_TO_ULONG(152, 251, 152), "pale green" },
383 { RGB_TO_ULONG(152, 251, 152), "PaleGreen" },
384 { RGB_TO_ULONG(0 , 255, 127), "spring green" },
385 { RGB_TO_ULONG(0 , 255, 127), "SpringGreen" },
386 { RGB_TO_ULONG(124, 252, 0 ), "lawn green" },
387 { RGB_TO_ULONG(124, 252, 0 ), "LawnGreen" },
388 { RGB_TO_ULONG(0 , 255, 0 ), "green" },
389 { RGB_TO_ULONG(127, 255, 0 ), "chartreuse" },
390 { RGB_TO_ULONG(0 , 250, 154), "medium spring green" },
391 { RGB_TO_ULONG(0 , 250, 154), "MediumSpringGreen" },
392 { RGB_TO_ULONG(173, 255, 47 ), "green yellow" },
393 { RGB_TO_ULONG(173, 255, 47 ), "GreenYellow" },
394 { RGB_TO_ULONG(50 , 205, 50 ), "lime green" },
395 { RGB_TO_ULONG(50 , 205, 50 ), "LimeGreen" },
396 { RGB_TO_ULONG(154, 205, 50 ), "yellow green" },
397 { RGB_TO_ULONG(154, 205, 50 ), "YellowGreen" },
398 { RGB_TO_ULONG(34 , 139, 34 ), "forest green" },
399 { RGB_TO_ULONG(34 , 139, 34 ), "ForestGreen" },
400 { RGB_TO_ULONG(107, 142, 35 ), "olive drab" },
401 { RGB_TO_ULONG(107, 142, 35 ), "OliveDrab" },
402 { RGB_TO_ULONG(189, 183, 107), "dark khaki" },
403 { RGB_TO_ULONG(189, 183, 107), "DarkKhaki" },
404 { RGB_TO_ULONG(240, 230, 140), "khaki" },
405 { RGB_TO_ULONG(238, 232, 170), "pale goldenrod" },
406 { RGB_TO_ULONG(238, 232, 170), "PaleGoldenrod" },
407 { RGB_TO_ULONG(250, 250, 210), "light goldenrod yellow" },
408 { RGB_TO_ULONG(250, 250, 210), "LightGoldenrodYellow" },
409 { RGB_TO_ULONG(255, 255, 224), "light yellow" },
410 { RGB_TO_ULONG(255, 255, 224), "LightYellow" },
411 { RGB_TO_ULONG(255, 255, 0 ), "yellow" },
412 { RGB_TO_ULONG(255, 215, 0 ), "gold" },
413 { RGB_TO_ULONG(238, 221, 130), "light goldenrod" },
414 { RGB_TO_ULONG(238, 221, 130), "LightGoldenrod" },
415 { RGB_TO_ULONG(218, 165, 32 ), "goldenrod" },
416 { RGB_TO_ULONG(184, 134, 11 ), "dark goldenrod" },
417 { RGB_TO_ULONG(184, 134, 11 ), "DarkGoldenrod" },
418 { RGB_TO_ULONG(188, 143, 143), "rosy brown" },
419 { RGB_TO_ULONG(188, 143, 143), "RosyBrown" },
420 { RGB_TO_ULONG(205, 92 , 92 ), "indian red" },
421 { RGB_TO_ULONG(205, 92 , 92 ), "IndianRed" },
422 { RGB_TO_ULONG(139, 69 , 19 ), "saddle brown" },
423 { RGB_TO_ULONG(139, 69 , 19 ), "SaddleBrown" },
424 { RGB_TO_ULONG(160, 82 , 45 ), "sienna" },
425 { RGB_TO_ULONG(205, 133, 63 ), "peru" },
426 { RGB_TO_ULONG(222, 184, 135), "burlywood" },
427 { RGB_TO_ULONG(245, 245, 220), "beige" },
428 { RGB_TO_ULONG(245, 222, 179), "wheat" },
429 { RGB_TO_ULONG(244, 164, 96 ), "sandy brown" },
430 { RGB_TO_ULONG(244, 164, 96 ), "SandyBrown" },
431 { RGB_TO_ULONG(210, 180, 140), "tan" },
432 { RGB_TO_ULONG(210, 105, 30 ), "chocolate" },
433 { RGB_TO_ULONG(178, 34 , 34 ), "firebrick" },
434 { RGB_TO_ULONG(165, 42 , 42 ), "brown" },
435 { RGB_TO_ULONG(233, 150, 122), "dark salmon" },
436 { RGB_TO_ULONG(233, 150, 122), "DarkSalmon" },
437 { RGB_TO_ULONG(250, 128, 114), "salmon" },
438 { RGB_TO_ULONG(255, 160, 122), "light salmon" },
439 { RGB_TO_ULONG(255, 160, 122), "LightSalmon" },
440 { RGB_TO_ULONG(255, 165, 0 ), "orange" },
441 { RGB_TO_ULONG(255, 140, 0 ), "dark orange" },
442 { RGB_TO_ULONG(255, 140, 0 ), "DarkOrange" },
443 { RGB_TO_ULONG(255, 127, 80 ), "coral" },
444 { RGB_TO_ULONG(240, 128, 128), "light coral" },
445 { RGB_TO_ULONG(240, 128, 128), "LightCoral" },
446 { RGB_TO_ULONG(255, 99 , 71 ), "tomato" },
447 { RGB_TO_ULONG(255, 69 , 0 ), "orange red" },
448 { RGB_TO_ULONG(255, 69 , 0 ), "OrangeRed" },
449 { RGB_TO_ULONG(255, 0 , 0 ), "red" },
450 { RGB_TO_ULONG(255, 105, 180), "hot pink" },
451 { RGB_TO_ULONG(255, 105, 180), "HotPink" },
452 { RGB_TO_ULONG(255, 20 , 147), "deep pink" },
453 { RGB_TO_ULONG(255, 20 , 147), "DeepPink" },
454 { RGB_TO_ULONG(255, 192, 203), "pink" },
455 { RGB_TO_ULONG(255, 182, 193), "light pink" },
456 { RGB_TO_ULONG(255, 182, 193), "LightPink" },
457 { RGB_TO_ULONG(219, 112, 147), "pale violet red" },
458 { RGB_TO_ULONG(219, 112, 147), "PaleVioletRed" },
459 { RGB_TO_ULONG(176, 48 , 96 ), "maroon" },
460 { RGB_TO_ULONG(199, 21 , 133), "medium violet red" },
461 { RGB_TO_ULONG(199, 21 , 133), "MediumVioletRed" },
462 { RGB_TO_ULONG(208, 32 , 144), "violet red" },
463 { RGB_TO_ULONG(208, 32 , 144), "VioletRed" },
464 { RGB_TO_ULONG(255, 0 , 255), "magenta" },
465 { RGB_TO_ULONG(238, 130, 238), "violet" },
466 { RGB_TO_ULONG(221, 160, 221), "plum" },
467 { RGB_TO_ULONG(218, 112, 214), "orchid" },
468 { RGB_TO_ULONG(186, 85 , 211), "medium orchid" },
469 { RGB_TO_ULONG(186, 85 , 211), "MediumOrchid" },
470 { RGB_TO_ULONG(153, 50 , 204), "dark orchid" },
471 { RGB_TO_ULONG(153, 50 , 204), "DarkOrchid" },
472 { RGB_TO_ULONG(148, 0 , 211), "dark violet" },
473 { RGB_TO_ULONG(148, 0 , 211), "DarkViolet" },
474 { RGB_TO_ULONG(138, 43 , 226), "blue violet" },
475 { RGB_TO_ULONG(138, 43 , 226), "BlueViolet" },
476 { RGB_TO_ULONG(160, 32 , 240), "purple" },
477 { RGB_TO_ULONG(147, 112, 219), "medium purple" },
478 { RGB_TO_ULONG(147, 112, 219), "MediumPurple" },
479 { RGB_TO_ULONG(216, 191, 216), "thistle" },
480 { RGB_TO_ULONG(255, 250, 250), "snow1" },
481 { RGB_TO_ULONG(238, 233, 233), "snow2" },
482 { RGB_TO_ULONG(205, 201, 201), "snow3" },
483 { RGB_TO_ULONG(139, 137, 137), "snow4" },
484 { RGB_TO_ULONG(255, 245, 238), "seashell1" },
485 { RGB_TO_ULONG(238, 229, 222), "seashell2" },
486 { RGB_TO_ULONG(205, 197, 191), "seashell3" },
487 { RGB_TO_ULONG(139, 134, 130), "seashell4" },
488 { RGB_TO_ULONG(255, 239, 219), "AntiqueWhite1" },
489 { RGB_TO_ULONG(238, 223, 204), "AntiqueWhite2" },
490 { RGB_TO_ULONG(205, 192, 176), "AntiqueWhite3" },
491 { RGB_TO_ULONG(139, 131, 120), "AntiqueWhite4" },
492 { RGB_TO_ULONG(255, 228, 196), "bisque1" },
493 { RGB_TO_ULONG(238, 213, 183), "bisque2" },
494 { RGB_TO_ULONG(205, 183, 158), "bisque3" },
495 { RGB_TO_ULONG(139, 125, 107), "bisque4" },
496 { RGB_TO_ULONG(255, 218, 185), "PeachPuff1" },
497 { RGB_TO_ULONG(238, 203, 173), "PeachPuff2" },
498 { RGB_TO_ULONG(205, 175, 149), "PeachPuff3" },
499 { RGB_TO_ULONG(139, 119, 101), "PeachPuff4" },
500 { RGB_TO_ULONG(255, 222, 173), "NavajoWhite1" },
501 { RGB_TO_ULONG(238, 207, 161), "NavajoWhite2" },
502 { RGB_TO_ULONG(205, 179, 139), "NavajoWhite3" },
503 { RGB_TO_ULONG(139, 121, 94), "NavajoWhite4" },
504 { RGB_TO_ULONG(255, 250, 205), "LemonChiffon1" },
505 { RGB_TO_ULONG(238, 233, 191), "LemonChiffon2" },
506 { RGB_TO_ULONG(205, 201, 165), "LemonChiffon3" },
507 { RGB_TO_ULONG(139, 137, 112), "LemonChiffon4" },
508 { RGB_TO_ULONG(255, 248, 220), "cornsilk1" },
509 { RGB_TO_ULONG(238, 232, 205), "cornsilk2" },
510 { RGB_TO_ULONG(205, 200, 177), "cornsilk3" },
511 { RGB_TO_ULONG(139, 136, 120), "cornsilk4" },
512 { RGB_TO_ULONG(255, 255, 240), "ivory1" },
513 { RGB_TO_ULONG(238, 238, 224), "ivory2" },
514 { RGB_TO_ULONG(205, 205, 193), "ivory3" },
515 { RGB_TO_ULONG(139, 139, 131), "ivory4" },
516 { RGB_TO_ULONG(240, 255, 240), "honeydew1" },
517 { RGB_TO_ULONG(224, 238, 224), "honeydew2" },
518 { RGB_TO_ULONG(193, 205, 193), "honeydew3" },
519 { RGB_TO_ULONG(131, 139, 131), "honeydew4" },
520 { RGB_TO_ULONG(255, 240, 245), "LavenderBlush1" },
521 { RGB_TO_ULONG(238, 224, 229), "LavenderBlush2" },
522 { RGB_TO_ULONG(205, 193, 197), "LavenderBlush3" },
523 { RGB_TO_ULONG(139, 131, 134), "LavenderBlush4" },
524 { RGB_TO_ULONG(255, 228, 225), "MistyRose1" },
525 { RGB_TO_ULONG(238, 213, 210), "MistyRose2" },
526 { RGB_TO_ULONG(205, 183, 181), "MistyRose3" },
527 { RGB_TO_ULONG(139, 125, 123), "MistyRose4" },
528 { RGB_TO_ULONG(240, 255, 255), "azure1" },
529 { RGB_TO_ULONG(224, 238, 238), "azure2" },
530 { RGB_TO_ULONG(193, 205, 205), "azure3" },
531 { RGB_TO_ULONG(131, 139, 139), "azure4" },
532 { RGB_TO_ULONG(131, 111, 255), "SlateBlue1" },
533 { RGB_TO_ULONG(122, 103, 238), "SlateBlue2" },
534 { RGB_TO_ULONG(105, 89 , 205), "SlateBlue3" },
535 { RGB_TO_ULONG(71 , 60 , 139), "SlateBlue4" },
536 { RGB_TO_ULONG(72 , 118, 255), "RoyalBlue1" },
537 { RGB_TO_ULONG(67 , 110, 238), "RoyalBlue2" },
538 { RGB_TO_ULONG(58 , 95 , 205), "RoyalBlue3" },
539 { RGB_TO_ULONG(39 , 64 , 139), "RoyalBlue4" },
540 { RGB_TO_ULONG(0 , 0 , 255), "blue1" },
541 { RGB_TO_ULONG(0 , 0 , 238), "blue2" },
542 { RGB_TO_ULONG(0 , 0 , 205), "blue3" },
543 { RGB_TO_ULONG(0 , 0 , 139), "blue4" },
544 { RGB_TO_ULONG(30 , 144, 255), "DodgerBlue1" },
545 { RGB_TO_ULONG(28 , 134, 238), "DodgerBlue2" },
546 { RGB_TO_ULONG(24 , 116, 205), "DodgerBlue3" },
547 { RGB_TO_ULONG(16 , 78 , 139), "DodgerBlue4" },
548 { RGB_TO_ULONG(99 , 184, 255), "SteelBlue1" },
549 { RGB_TO_ULONG(92 , 172, 238), "SteelBlue2" },
550 { RGB_TO_ULONG(79 , 148, 205), "SteelBlue3" },
551 { RGB_TO_ULONG(54 , 100, 139), "SteelBlue4" },
552 { RGB_TO_ULONG(0 , 191, 255), "DeepSkyBlue1" },
553 { RGB_TO_ULONG(0 , 178, 238), "DeepSkyBlue2" },
554 { RGB_TO_ULONG(0 , 154, 205), "DeepSkyBlue3" },
555 { RGB_TO_ULONG(0 , 104, 139), "DeepSkyBlue4" },
556 { RGB_TO_ULONG(135, 206, 255), "SkyBlue1" },
557 { RGB_TO_ULONG(126, 192, 238), "SkyBlue2" },
558 { RGB_TO_ULONG(108, 166, 205), "SkyBlue3" },
559 { RGB_TO_ULONG(74 , 112, 139), "SkyBlue4" },
560 { RGB_TO_ULONG(176, 226, 255), "LightSkyBlue1" },
561 { RGB_TO_ULONG(164, 211, 238), "LightSkyBlue2" },
562 { RGB_TO_ULONG(141, 182, 205), "LightSkyBlue3" },
563 { RGB_TO_ULONG(96 , 123, 139), "LightSkyBlue4" },
564 { RGB_TO_ULONG(198, 226, 255), "SlateGray1" },
565 { RGB_TO_ULONG(185, 211, 238), "SlateGray2" },
566 { RGB_TO_ULONG(159, 182, 205), "SlateGray3" },
567 { RGB_TO_ULONG(108, 123, 139), "SlateGray4" },
568 { RGB_TO_ULONG(202, 225, 255), "LightSteelBlue1" },
569 { RGB_TO_ULONG(188, 210, 238), "LightSteelBlue2" },
570 { RGB_TO_ULONG(162, 181, 205), "LightSteelBlue3" },
571 { RGB_TO_ULONG(110, 123, 139), "LightSteelBlue4" },
572 { RGB_TO_ULONG(191, 239, 255), "LightBlue1" },
573 { RGB_TO_ULONG(178, 223, 238), "LightBlue2" },
574 { RGB_TO_ULONG(154, 192, 205), "LightBlue3" },
575 { RGB_TO_ULONG(104, 131, 139), "LightBlue4" },
576 { RGB_TO_ULONG(224, 255, 255), "LightCyan1" },
577 { RGB_TO_ULONG(209, 238, 238), "LightCyan2" },
578 { RGB_TO_ULONG(180, 205, 205), "LightCyan3" },
579 { RGB_TO_ULONG(122, 139, 139), "LightCyan4" },
580 { RGB_TO_ULONG(187, 255, 255), "PaleTurquoise1" },
581 { RGB_TO_ULONG(174, 238, 238), "PaleTurquoise2" },
582 { RGB_TO_ULONG(150, 205, 205), "PaleTurquoise3" },
583 { RGB_TO_ULONG(102, 139, 139), "PaleTurquoise4" },
584 { RGB_TO_ULONG(152, 245, 255), "CadetBlue1" },
585 { RGB_TO_ULONG(142, 229, 238), "CadetBlue2" },
586 { RGB_TO_ULONG(122, 197, 205), "CadetBlue3" },
587 { RGB_TO_ULONG(83 , 134, 139), "CadetBlue4" },
588 { RGB_TO_ULONG(0 , 245, 255), "turquoise1" },
589 { RGB_TO_ULONG(0 , 229, 238), "turquoise2" },
590 { RGB_TO_ULONG(0 , 197, 205), "turquoise3" },
591 { RGB_TO_ULONG(0 , 134, 139), "turquoise4" },
592 { RGB_TO_ULONG(0 , 255, 255), "cyan1" },
593 { RGB_TO_ULONG(0 , 238, 238), "cyan2" },
594 { RGB_TO_ULONG(0 , 205, 205), "cyan3" },
595 { RGB_TO_ULONG(0 , 139, 139), "cyan4" },
596 { RGB_TO_ULONG(151, 255, 255), "DarkSlateGray1" },
597 { RGB_TO_ULONG(141, 238, 238), "DarkSlateGray2" },
598 { RGB_TO_ULONG(121, 205, 205), "DarkSlateGray3" },
599 { RGB_TO_ULONG(82 , 139, 139), "DarkSlateGray4" },
600 { RGB_TO_ULONG(127, 255, 212), "aquamarine1" },
601 { RGB_TO_ULONG(118, 238, 198), "aquamarine2" },
602 { RGB_TO_ULONG(102, 205, 170), "aquamarine3" },
603 { RGB_TO_ULONG(69 , 139, 116), "aquamarine4" },
604 { RGB_TO_ULONG(193, 255, 193), "DarkSeaGreen1" },
605 { RGB_TO_ULONG(180, 238, 180), "DarkSeaGreen2" },
606 { RGB_TO_ULONG(155, 205, 155), "DarkSeaGreen3" },
607 { RGB_TO_ULONG(105, 139, 105), "DarkSeaGreen4" },
608 { RGB_TO_ULONG(84 , 255, 159), "SeaGreen1" },
609 { RGB_TO_ULONG(78 , 238, 148), "SeaGreen2" },
610 { RGB_TO_ULONG(67 , 205, 128), "SeaGreen3" },
611 { RGB_TO_ULONG(46 , 139, 87 ), "SeaGreen4" },
612 { RGB_TO_ULONG(154, 255, 154), "PaleGreen1" },
613 { RGB_TO_ULONG(144, 238, 144), "PaleGreen2" },
614 { RGB_TO_ULONG(124, 205, 124), "PaleGreen3" },
615 { RGB_TO_ULONG(84 , 139, 84 ), "PaleGreen4" },
616 { RGB_TO_ULONG(0 , 255, 127), "SpringGreen1" },
617 { RGB_TO_ULONG(0 , 238, 118), "SpringGreen2" },
618 { RGB_TO_ULONG(0 , 205, 102), "SpringGreen3" },
619 { RGB_TO_ULONG(0 , 139, 69 ), "SpringGreen4" },
620 { RGB_TO_ULONG(0 , 255, 0 ), "green1" },
621 { RGB_TO_ULONG(0 , 238, 0 ), "green2" },
622 { RGB_TO_ULONG(0 , 205, 0 ), "green3" },
623 { RGB_TO_ULONG(0 , 139, 0 ), "green4" },
624 { RGB_TO_ULONG(127, 255, 0 ), "chartreuse1" },
625 { RGB_TO_ULONG(118, 238, 0 ), "chartreuse2" },
626 { RGB_TO_ULONG(102, 205, 0 ), "chartreuse3" },
627 { RGB_TO_ULONG(69 , 139, 0 ), "chartreuse4" },
628 { RGB_TO_ULONG(192, 255, 62 ), "OliveDrab1" },
629 { RGB_TO_ULONG(179, 238, 58 ), "OliveDrab2" },
630 { RGB_TO_ULONG(154, 205, 50 ), "OliveDrab3" },
631 { RGB_TO_ULONG(105, 139, 34 ), "OliveDrab4" },
632 { RGB_TO_ULONG(202, 255, 112), "DarkOliveGreen1" },
633 { RGB_TO_ULONG(188, 238, 104), "DarkOliveGreen2" },
634 { RGB_TO_ULONG(162, 205, 90 ), "DarkOliveGreen3" },
635 { RGB_TO_ULONG(110, 139, 61 ), "DarkOliveGreen4" },
636 { RGB_TO_ULONG(255, 246, 143), "khaki1" },
637 { RGB_TO_ULONG(238, 230, 133), "khaki2" },
638 { RGB_TO_ULONG(205, 198, 115), "khaki3" },
639 { RGB_TO_ULONG(139, 134, 78 ), "khaki4" },
640 { RGB_TO_ULONG(255, 236, 139), "LightGoldenrod1" },
641 { RGB_TO_ULONG(238, 220, 130), "LightGoldenrod2" },
642 { RGB_TO_ULONG(205, 190, 112), "LightGoldenrod3" },
643 { RGB_TO_ULONG(139, 129, 76 ), "LightGoldenrod4" },
644 { RGB_TO_ULONG(255, 255, 224), "LightYellow1" },
645 { RGB_TO_ULONG(238, 238, 209), "LightYellow2" },
646 { RGB_TO_ULONG(205, 205, 180), "LightYellow3" },
647 { RGB_TO_ULONG(139, 139, 122), "LightYellow4" },
648 { RGB_TO_ULONG(255, 255, 0 ), "yellow1" },
649 { RGB_TO_ULONG(238, 238, 0 ), "yellow2" },
650 { RGB_TO_ULONG(205, 205, 0 ), "yellow3" },
651 { RGB_TO_ULONG(139, 139, 0 ), "yellow4" },
652 { RGB_TO_ULONG(255, 215, 0 ), "gold1" },
653 { RGB_TO_ULONG(238, 201, 0 ), "gold2" },
654 { RGB_TO_ULONG(205, 173, 0 ), "gold3" },
655 { RGB_TO_ULONG(139, 117, 0 ), "gold4" },
656 { RGB_TO_ULONG(255, 193, 37 ), "goldenrod1" },
657 { RGB_TO_ULONG(238, 180, 34 ), "goldenrod2" },
658 { RGB_TO_ULONG(205, 155, 29 ), "goldenrod3" },
659 { RGB_TO_ULONG(139, 105, 20 ), "goldenrod4" },
660 { RGB_TO_ULONG(255, 185, 15 ), "DarkGoldenrod1" },
661 { RGB_TO_ULONG(238, 173, 14 ), "DarkGoldenrod2" },
662 { RGB_TO_ULONG(205, 149, 12 ), "DarkGoldenrod3" },
663 { RGB_TO_ULONG(139, 101, 8 ), "DarkGoldenrod4" },
664 { RGB_TO_ULONG(255, 193, 193), "RosyBrown1" },
665 { RGB_TO_ULONG(238, 180, 180), "RosyBrown2" },
666 { RGB_TO_ULONG(205, 155, 155), "RosyBrown3" },
667 { RGB_TO_ULONG(139, 105, 105), "RosyBrown4" },
668 { RGB_TO_ULONG(255, 106, 106), "IndianRed1" },
669 { RGB_TO_ULONG(238, 99 , 99 ), "IndianRed2" },
670 { RGB_TO_ULONG(205, 85 , 85 ), "IndianRed3" },
671 { RGB_TO_ULONG(139, 58 , 58 ), "IndianRed4" },
672 { RGB_TO_ULONG(255, 130, 71 ), "sienna1" },
673 { RGB_TO_ULONG(238, 121, 66 ), "sienna2" },
674 { RGB_TO_ULONG(205, 104, 57 ), "sienna3" },
675 { RGB_TO_ULONG(139, 71 , 38 ), "sienna4" },
676 { RGB_TO_ULONG(255, 211, 155), "burlywood1" },
677 { RGB_TO_ULONG(238, 197, 145), "burlywood2" },
678 { RGB_TO_ULONG(205, 170, 125), "burlywood3" },
679 { RGB_TO_ULONG(139, 115, 85 ), "burlywood4" },
680 { RGB_TO_ULONG(255, 231, 186), "wheat1" },
681 { RGB_TO_ULONG(238, 216, 174), "wheat2" },
682 { RGB_TO_ULONG(205, 186, 150), "wheat3" },
683 { RGB_TO_ULONG(139, 126, 102), "wheat4" },
684 { RGB_TO_ULONG(255, 165, 79 ), "tan1" },
685 { RGB_TO_ULONG(238, 154, 73 ), "tan2" },
686 { RGB_TO_ULONG(205, 133, 63 ), "tan3" },
687 { RGB_TO_ULONG(139, 90 , 43 ), "tan4" },
688 { RGB_TO_ULONG(255, 127, 36 ), "chocolate1" },
689 { RGB_TO_ULONG(238, 118, 33 ), "chocolate2" },
690 { RGB_TO_ULONG(205, 102, 29 ), "chocolate3" },
691 { RGB_TO_ULONG(139, 69 , 19 ), "chocolate4" },
692 { RGB_TO_ULONG(255, 48 , 48 ), "firebrick1" },
693 { RGB_TO_ULONG(238, 44 , 44 ), "firebrick2" },
694 { RGB_TO_ULONG(205, 38 , 38 ), "firebrick3" },
695 { RGB_TO_ULONG(139, 26 , 26 ), "firebrick4" },
696 { RGB_TO_ULONG(255, 64 , 64 ), "brown1" },
697 { RGB_TO_ULONG(238, 59 , 59 ), "brown2" },
698 { RGB_TO_ULONG(205, 51 , 51 ), "brown3" },
699 { RGB_TO_ULONG(139, 35 , 35 ), "brown4" },
700 { RGB_TO_ULONG(255, 140, 105), "salmon1" },
701 { RGB_TO_ULONG(238, 130, 98 ), "salmon2" },
702 { RGB_TO_ULONG(205, 112, 84 ), "salmon3" },
703 { RGB_TO_ULONG(139, 76 , 57 ), "salmon4" },
704 { RGB_TO_ULONG(255, 160, 122), "LightSalmon1" },
705 { RGB_TO_ULONG(238, 149, 114), "LightSalmon2" },
706 { RGB_TO_ULONG(205, 129, 98 ), "LightSalmon3" },
707 { RGB_TO_ULONG(139, 87 , 66 ), "LightSalmon4" },
708 { RGB_TO_ULONG(255, 165, 0 ), "orange1" },
709 { RGB_TO_ULONG(238, 154, 0 ), "orange2" },
710 { RGB_TO_ULONG(205, 133, 0 ), "orange3" },
711 { RGB_TO_ULONG(139, 90 , 0 ), "orange4" },
712 { RGB_TO_ULONG(255, 127, 0 ), "DarkOrange1" },
713 { RGB_TO_ULONG(238, 118, 0 ), "DarkOrange2" },
714 { RGB_TO_ULONG(205, 102, 0 ), "DarkOrange3" },
715 { RGB_TO_ULONG(139, 69 , 0 ), "DarkOrange4" },
716 { RGB_TO_ULONG(255, 114, 86 ), "coral1" },
717 { RGB_TO_ULONG(238, 106, 80 ), "coral2" },
718 { RGB_TO_ULONG(205, 91 , 69 ), "coral3" },
719 { RGB_TO_ULONG(139, 62 , 47 ), "coral4" },
720 { RGB_TO_ULONG(255, 99 , 71 ), "tomato1" },
721 { RGB_TO_ULONG(238, 92 , 66 ), "tomato2" },
722 { RGB_TO_ULONG(205, 79 , 57 ), "tomato3" },
723 { RGB_TO_ULONG(139, 54 , 38 ), "tomato4" },
724 { RGB_TO_ULONG(255, 69 , 0 ), "OrangeRed1" },
725 { RGB_TO_ULONG(238, 64 , 0 ), "OrangeRed2" },
726 { RGB_TO_ULONG(205, 55 , 0 ), "OrangeRed3" },
727 { RGB_TO_ULONG(139, 37 , 0 ), "OrangeRed4" },
728 { RGB_TO_ULONG(255, 0 , 0 ), "red1" },
729 { RGB_TO_ULONG(238, 0 , 0 ), "red2" },
730 { RGB_TO_ULONG(205, 0 , 0 ), "red3" },
731 { RGB_TO_ULONG(139, 0 , 0 ), "red4" },
732 { RGB_TO_ULONG(255, 20 , 147), "DeepPink1" },
733 { RGB_TO_ULONG(238, 18 , 137), "DeepPink2" },
734 { RGB_TO_ULONG(205, 16 , 118), "DeepPink3" },
735 { RGB_TO_ULONG(139, 10 , 80 ), "DeepPink4" },
736 { RGB_TO_ULONG(255, 110, 180), "HotPink1" },
737 { RGB_TO_ULONG(238, 106, 167), "HotPink2" },
738 { RGB_TO_ULONG(205, 96 , 144), "HotPink3" },
739 { RGB_TO_ULONG(139, 58 , 98 ), "HotPink4" },
740 { RGB_TO_ULONG(255, 181, 197), "pink1" },
741 { RGB_TO_ULONG(238, 169, 184), "pink2" },
742 { RGB_TO_ULONG(205, 145, 158), "pink3" },
743 { RGB_TO_ULONG(139, 99 , 108), "pink4" },
744 { RGB_TO_ULONG(255, 174, 185), "LightPink1" },
745 { RGB_TO_ULONG(238, 162, 173), "LightPink2" },
746 { RGB_TO_ULONG(205, 140, 149), "LightPink3" },
747 { RGB_TO_ULONG(139, 95 , 101), "LightPink4" },
748 { RGB_TO_ULONG(255, 130, 171), "PaleVioletRed1" },
749 { RGB_TO_ULONG(238, 121, 159), "PaleVioletRed2" },
750 { RGB_TO_ULONG(205, 104, 137), "PaleVioletRed3" },
751 { RGB_TO_ULONG(139, 71 , 93 ), "PaleVioletRed4" },
752 { RGB_TO_ULONG(255, 52 , 179), "maroon1" },
753 { RGB_TO_ULONG(238, 48 , 167), "maroon2" },
754 { RGB_TO_ULONG(205, 41 , 144), "maroon3" },
755 { RGB_TO_ULONG(139, 28 , 98 ), "maroon4" },
756 { RGB_TO_ULONG(255, 62 , 150), "VioletRed1" },
757 { RGB_TO_ULONG(238, 58 , 140), "VioletRed2" },
758 { RGB_TO_ULONG(205, 50 , 120), "VioletRed3" },
759 { RGB_TO_ULONG(139, 34 , 82 ), "VioletRed4" },
760 { RGB_TO_ULONG(255, 0 , 255), "magenta1" },
761 { RGB_TO_ULONG(238, 0 , 238), "magenta2" },
762 { RGB_TO_ULONG(205, 0 , 205), "magenta3" },
763 { RGB_TO_ULONG(139, 0 , 139), "magenta4" },
764 { RGB_TO_ULONG(255, 131, 250), "orchid1" },
765 { RGB_TO_ULONG(238, 122, 233), "orchid2" },
766 { RGB_TO_ULONG(205, 105, 201), "orchid3" },
767 { RGB_TO_ULONG(139, 71 , 137), "orchid4" },
768 { RGB_TO_ULONG(255, 187, 255), "plum1" },
769 { RGB_TO_ULONG(238, 174, 238), "plum2" },
770 { RGB_TO_ULONG(205, 150, 205), "plum3" },
771 { RGB_TO_ULONG(139, 102, 139), "plum4" },
772 { RGB_TO_ULONG(224, 102, 255), "MediumOrchid1" },
773 { RGB_TO_ULONG(209, 95 , 238), "MediumOrchid2" },
774 { RGB_TO_ULONG(180, 82 , 205), "MediumOrchid3" },
775 { RGB_TO_ULONG(122, 55 , 139), "MediumOrchid4" },
776 { RGB_TO_ULONG(191, 62 , 255), "DarkOrchid1" },
777 { RGB_TO_ULONG(178, 58 , 238), "DarkOrchid2" },
778 { RGB_TO_ULONG(154, 50 , 205), "DarkOrchid3" },
779 { RGB_TO_ULONG(104, 34 , 139), "DarkOrchid4" },
780 { RGB_TO_ULONG(155, 48 , 255), "purple1" },
781 { RGB_TO_ULONG(145, 44 , 238), "purple2" },
782 { RGB_TO_ULONG(125, 38 , 205), "purple3" },
783 { RGB_TO_ULONG(85 , 26 , 139), "purple4" },
784 { RGB_TO_ULONG(171, 130, 255), "MediumPurple1" },
785 { RGB_TO_ULONG(159, 121, 238), "MediumPurple2" },
786 { RGB_TO_ULONG(137, 104, 205), "MediumPurple3" },
787 { RGB_TO_ULONG(93 , 71 , 139), "MediumPurple4" },
788 { RGB_TO_ULONG(255, 225, 255), "thistle1" },
789 { RGB_TO_ULONG(238, 210, 238), "thistle2" },
790 { RGB_TO_ULONG(205, 181, 205), "thistle3" },
791 { RGB_TO_ULONG(139, 123, 139), "thistle4" },
792 { RGB_TO_ULONG(0 , 0 , 0 ), "gray0" },
793 { RGB_TO_ULONG(0 , 0 , 0 ), "grey0" },
794 { RGB_TO_ULONG(3 , 3 , 3 ), "gray1" },
795 { RGB_TO_ULONG(3 , 3 , 3 ), "grey1" },
796 { RGB_TO_ULONG(5 , 5 , 5 ), "gray2" },
797 { RGB_TO_ULONG(5 , 5 , 5 ), "grey2" },
798 { RGB_TO_ULONG(8 , 8 , 8 ), "gray3" },
799 { RGB_TO_ULONG(8 , 8 , 8 ), "grey3" },
800 { RGB_TO_ULONG(10 , 10 , 10 ), "gray4" },
801 { RGB_TO_ULONG(10 , 10 , 10 ), "grey4" },
802 { RGB_TO_ULONG(13 , 13 , 13 ), "gray5" },
803 { RGB_TO_ULONG(13 , 13 , 13 ), "grey5" },
804 { RGB_TO_ULONG(15 , 15 , 15 ), "gray6" },
805 { RGB_TO_ULONG(15 , 15 , 15 ), "grey6" },
806 { RGB_TO_ULONG(18 , 18 , 18 ), "gray7" },
807 { RGB_TO_ULONG(18 , 18 , 18 ), "grey7" },
808 { RGB_TO_ULONG(20 , 20 , 20 ), "gray8" },
809 { RGB_TO_ULONG(20 , 20 , 20 ), "grey8" },
810 { RGB_TO_ULONG(23 , 23 , 23 ), "gray9" },
811 { RGB_TO_ULONG(23 , 23 , 23 ), "grey9" },
812 { RGB_TO_ULONG(26 , 26 , 26 ), "gray10" },
813 { RGB_TO_ULONG(26 , 26 , 26 ), "grey10" },
814 { RGB_TO_ULONG(28 , 28 , 28 ), "gray11" },
815 { RGB_TO_ULONG(28 , 28 , 28 ), "grey11" },
816 { RGB_TO_ULONG(31 , 31 , 31 ), "gray12" },
817 { RGB_TO_ULONG(31 , 31 , 31 ), "grey12" },
818 { RGB_TO_ULONG(33 , 33 , 33 ), "gray13" },
819 { RGB_TO_ULONG(33 , 33 , 33 ), "grey13" },
820 { RGB_TO_ULONG(36 , 36 , 36 ), "gray14" },
821 { RGB_TO_ULONG(36 , 36 , 36 ), "grey14" },
822 { RGB_TO_ULONG(38 , 38 , 38 ), "gray15" },
823 { RGB_TO_ULONG(38 , 38 , 38 ), "grey15" },
824 { RGB_TO_ULONG(41 , 41 , 41 ), "gray16" },
825 { RGB_TO_ULONG(41 , 41 , 41 ), "grey16" },
826 { RGB_TO_ULONG(43 , 43 , 43 ), "gray17" },
827 { RGB_TO_ULONG(43 , 43 , 43 ), "grey17" },
828 { RGB_TO_ULONG(46 , 46 , 46 ), "gray18" },
829 { RGB_TO_ULONG(46 , 46 , 46 ), "grey18" },
830 { RGB_TO_ULONG(48 , 48 , 48 ), "gray19" },
831 { RGB_TO_ULONG(48 , 48 , 48 ), "grey19" },
832 { RGB_TO_ULONG(51 , 51 , 51 ), "gray20" },
833 { RGB_TO_ULONG(51 , 51 , 51 ), "grey20" },
834 { RGB_TO_ULONG(54 , 54 , 54 ), "gray21" },
835 { RGB_TO_ULONG(54 , 54 , 54 ), "grey21" },
836 { RGB_TO_ULONG(56 , 56 , 56 ), "gray22" },
837 { RGB_TO_ULONG(56 , 56 , 56 ), "grey22" },
838 { RGB_TO_ULONG(59 , 59 , 59 ), "gray23" },
839 { RGB_TO_ULONG(59 , 59 , 59 ), "grey23" },
840 { RGB_TO_ULONG(61 , 61 , 61 ), "gray24" },
841 { RGB_TO_ULONG(61 , 61 , 61 ), "grey24" },
842 { RGB_TO_ULONG(64 , 64 , 64 ), "gray25" },
843 { RGB_TO_ULONG(64 , 64 , 64 ), "grey25" },
844 { RGB_TO_ULONG(66 , 66 , 66 ), "gray26" },
845 { RGB_TO_ULONG(66 , 66 , 66 ), "grey26" },
846 { RGB_TO_ULONG(69 , 69 , 69 ), "gray27" },
847 { RGB_TO_ULONG(69 , 69 , 69 ), "grey27" },
848 { RGB_TO_ULONG(71 , 71 , 71 ), "gray28" },
849 { RGB_TO_ULONG(71 , 71 , 71 ), "grey28" },
850 { RGB_TO_ULONG(74 , 74 , 74 ), "gray29" },
851 { RGB_TO_ULONG(74 , 74 , 74 ), "grey29" },
852 { RGB_TO_ULONG(77 , 77 , 77 ), "gray30" },
853 { RGB_TO_ULONG(77 , 77 , 77 ), "grey30" },
854 { RGB_TO_ULONG(79 , 79 , 79 ), "gray31" },
855 { RGB_TO_ULONG(79 , 79 , 79 ), "grey31" },
856 { RGB_TO_ULONG(82 , 82 , 82 ), "gray32" },
857 { RGB_TO_ULONG(82 , 82 , 82 ), "grey32" },
858 { RGB_TO_ULONG(84 , 84 , 84 ), "gray33" },
859 { RGB_TO_ULONG(84 , 84 , 84 ), "grey33" },
860 { RGB_TO_ULONG(87 , 87 , 87 ), "gray34" },
861 { RGB_TO_ULONG(87 , 87 , 87 ), "grey34" },
862 { RGB_TO_ULONG(89 , 89 , 89 ), "gray35" },
863 { RGB_TO_ULONG(89 , 89 , 89 ), "grey35" },
864 { RGB_TO_ULONG(92 , 92 , 92 ), "gray36" },
865 { RGB_TO_ULONG(92 , 92 , 92 ), "grey36" },
866 { RGB_TO_ULONG(94 , 94 , 94 ), "gray37" },
867 { RGB_TO_ULONG(94 , 94 , 94 ), "grey37" },
868 { RGB_TO_ULONG(97 , 97 , 97 ), "gray38" },
869 { RGB_TO_ULONG(97 , 97 , 97 ), "grey38" },
870 { RGB_TO_ULONG(99 , 99 , 99 ), "gray39" },
871 { RGB_TO_ULONG(99 , 99 , 99 ), "grey39" },
872 { RGB_TO_ULONG(102, 102, 102), "gray40" },
873 { RGB_TO_ULONG(102, 102, 102), "grey40" },
874 { RGB_TO_ULONG(105, 105, 105), "gray41" },
875 { RGB_TO_ULONG(105, 105, 105), "grey41" },
876 { RGB_TO_ULONG(107, 107, 107), "gray42" },
877 { RGB_TO_ULONG(107, 107, 107), "grey42" },
878 { RGB_TO_ULONG(110, 110, 110), "gray43" },
879 { RGB_TO_ULONG(110, 110, 110), "grey43" },
880 { RGB_TO_ULONG(112, 112, 112), "gray44" },
881 { RGB_TO_ULONG(112, 112, 112), "grey44" },
882 { RGB_TO_ULONG(115, 115, 115), "gray45" },
883 { RGB_TO_ULONG(115, 115, 115), "grey45" },
884 { RGB_TO_ULONG(117, 117, 117), "gray46" },
885 { RGB_TO_ULONG(117, 117, 117), "grey46" },
886 { RGB_TO_ULONG(120, 120, 120), "gray47" },
887 { RGB_TO_ULONG(120, 120, 120), "grey47" },
888 { RGB_TO_ULONG(122, 122, 122), "gray48" },
889 { RGB_TO_ULONG(122, 122, 122), "grey48" },
890 { RGB_TO_ULONG(125, 125, 125), "gray49" },
891 { RGB_TO_ULONG(125, 125, 125), "grey49" },
892 { RGB_TO_ULONG(127, 127, 127), "gray50" },
893 { RGB_TO_ULONG(127, 127, 127), "grey50" },
894 { RGB_TO_ULONG(130, 130, 130), "gray51" },
895 { RGB_TO_ULONG(130, 130, 130), "grey51" },
896 { RGB_TO_ULONG(133, 133, 133), "gray52" },
897 { RGB_TO_ULONG(133, 133, 133), "grey52" },
898 { RGB_TO_ULONG(135, 135, 135), "gray53" },
899 { RGB_TO_ULONG(135, 135, 135), "grey53" },
900 { RGB_TO_ULONG(138, 138, 138), "gray54" },
901 { RGB_TO_ULONG(138, 138, 138), "grey54" },
902 { RGB_TO_ULONG(140, 140, 140), "gray55" },
903 { RGB_TO_ULONG(140, 140, 140), "grey55" },
904 { RGB_TO_ULONG(143, 143, 143), "gray56" },
905 { RGB_TO_ULONG(143, 143, 143), "grey56" },
906 { RGB_TO_ULONG(145, 145, 145), "gray57" },
907 { RGB_TO_ULONG(145, 145, 145), "grey57" },
908 { RGB_TO_ULONG(148, 148, 148), "gray58" },
909 { RGB_TO_ULONG(148, 148, 148), "grey58" },
910 { RGB_TO_ULONG(150, 150, 150), "gray59" },
911 { RGB_TO_ULONG(150, 150, 150), "grey59" },
912 { RGB_TO_ULONG(153, 153, 153), "gray60" },
913 { RGB_TO_ULONG(153, 153, 153), "grey60" },
914 { RGB_TO_ULONG(156, 156, 156), "gray61" },
915 { RGB_TO_ULONG(156, 156, 156), "grey61" },
916 { RGB_TO_ULONG(158, 158, 158), "gray62" },
917 { RGB_TO_ULONG(158, 158, 158), "grey62" },
918 { RGB_TO_ULONG(161, 161, 161), "gray63" },
919 { RGB_TO_ULONG(161, 161, 161), "grey63" },
920 { RGB_TO_ULONG(163, 163, 163), "gray64" },
921 { RGB_TO_ULONG(163, 163, 163), "grey64" },
922 { RGB_TO_ULONG(166, 166, 166), "gray65" },
923 { RGB_TO_ULONG(166, 166, 166), "grey65" },
924 { RGB_TO_ULONG(168, 168, 168), "gray66" },
925 { RGB_TO_ULONG(168, 168, 168), "grey66" },
926 { RGB_TO_ULONG(171, 171, 171), "gray67" },
927 { RGB_TO_ULONG(171, 171, 171), "grey67" },
928 { RGB_TO_ULONG(173, 173, 173), "gray68" },
929 { RGB_TO_ULONG(173, 173, 173), "grey68" },
930 { RGB_TO_ULONG(176, 176, 176), "gray69" },
931 { RGB_TO_ULONG(176, 176, 176), "grey69" },
932 { RGB_TO_ULONG(179, 179, 179), "gray70" },
933 { RGB_TO_ULONG(179, 179, 179), "grey70" },
934 { RGB_TO_ULONG(181, 181, 181), "gray71" },
935 { RGB_TO_ULONG(181, 181, 181), "grey71" },
936 { RGB_TO_ULONG(184, 184, 184), "gray72" },
937 { RGB_TO_ULONG(184, 184, 184), "grey72" },
938 { RGB_TO_ULONG(186, 186, 186), "gray73" },
939 { RGB_TO_ULONG(186, 186, 186), "grey73" },
940 { RGB_TO_ULONG(189, 189, 189), "gray74" },
941 { RGB_TO_ULONG(189, 189, 189), "grey74" },
942 { RGB_TO_ULONG(191, 191, 191), "gray75" },
943 { RGB_TO_ULONG(191, 191, 191), "grey75" },
944 { RGB_TO_ULONG(194, 194, 194), "gray76" },
945 { RGB_TO_ULONG(194, 194, 194), "grey76" },
946 { RGB_TO_ULONG(196, 196, 196), "gray77" },
947 { RGB_TO_ULONG(196, 196, 196), "grey77" },
948 { RGB_TO_ULONG(199, 199, 199), "gray78" },
949 { RGB_TO_ULONG(199, 199, 199), "grey78" },
950 { RGB_TO_ULONG(201, 201, 201), "gray79" },
951 { RGB_TO_ULONG(201, 201, 201), "grey79" },
952 { RGB_TO_ULONG(204, 204, 204), "gray80" },
953 { RGB_TO_ULONG(204, 204, 204), "grey80" },
954 { RGB_TO_ULONG(207, 207, 207), "gray81" },
955 { RGB_TO_ULONG(207, 207, 207), "grey81" },
956 { RGB_TO_ULONG(209, 209, 209), "gray82" },
957 { RGB_TO_ULONG(209, 209, 209), "grey82" },
958 { RGB_TO_ULONG(212, 212, 212), "gray83" },
959 { RGB_TO_ULONG(212, 212, 212), "grey83" },
960 { RGB_TO_ULONG(214, 214, 214), "gray84" },
961 { RGB_TO_ULONG(214, 214, 214), "grey84" },
962 { RGB_TO_ULONG(217, 217, 217), "gray85" },
963 { RGB_TO_ULONG(217, 217, 217), "grey85" },
964 { RGB_TO_ULONG(219, 219, 219), "gray86" },
965 { RGB_TO_ULONG(219, 219, 219), "grey86" },
966 { RGB_TO_ULONG(222, 222, 222), "gray87" },
967 { RGB_TO_ULONG(222, 222, 222), "grey87" },
968 { RGB_TO_ULONG(224, 224, 224), "gray88" },
969 { RGB_TO_ULONG(224, 224, 224), "grey88" },
970 { RGB_TO_ULONG(227, 227, 227), "gray89" },
971 { RGB_TO_ULONG(227, 227, 227), "grey89" },
972 { RGB_TO_ULONG(229, 229, 229), "gray90" },
973 { RGB_TO_ULONG(229, 229, 229), "grey90" },
974 { RGB_TO_ULONG(232, 232, 232), "gray91" },
975 { RGB_TO_ULONG(232, 232, 232), "grey91" },
976 { RGB_TO_ULONG(235, 235, 235), "gray92" },
977 { RGB_TO_ULONG(235, 235, 235), "grey92" },
978 { RGB_TO_ULONG(237, 237, 237), "gray93" },
979 { RGB_TO_ULONG(237, 237, 237), "grey93" },
980 { RGB_TO_ULONG(240, 240, 240), "gray94" },
981 { RGB_TO_ULONG(240, 240, 240), "grey94" },
982 { RGB_TO_ULONG(242, 242, 242), "gray95" },
983 { RGB_TO_ULONG(242, 242, 242), "grey95" },
984 { RGB_TO_ULONG(245, 245, 245), "gray96" },
985 { RGB_TO_ULONG(245, 245, 245), "grey96" },
986 { RGB_TO_ULONG(247, 247, 247), "gray97" },
987 { RGB_TO_ULONG(247, 247, 247), "grey97" },
988 { RGB_TO_ULONG(250, 250, 250), "gray98" },
989 { RGB_TO_ULONG(250, 250, 250), "grey98" },
990 { RGB_TO_ULONG(252, 252, 252), "gray99" },
991 { RGB_TO_ULONG(252, 252, 252), "grey99" },
992 { RGB_TO_ULONG(255, 255, 255), "gray100" },
993 { RGB_TO_ULONG(255, 255, 255), "grey100" },
994 { RGB_TO_ULONG(169, 169, 169), "dark grey" },
995 { RGB_TO_ULONG(169, 169, 169), "DarkGrey" },
996 { RGB_TO_ULONG(169, 169, 169), "dark gray" },
997 { RGB_TO_ULONG(169, 169, 169), "DarkGray" },
998 { RGB_TO_ULONG(0 , 0 , 139), "dark blue" },
999 { RGB_TO_ULONG(0 , 0 , 139), "DarkBlue" },
1000 { RGB_TO_ULONG(0 , 139, 139), "dark cyan" },
1001 { RGB_TO_ULONG(0 , 139, 139), "DarkCyan" },
1002 { RGB_TO_ULONG(139, 0 , 139), "dark magenta" },
1003 { RGB_TO_ULONG(139, 0 , 139), "DarkMagenta" },
1004 { RGB_TO_ULONG(139, 0 , 0 ), "dark red" },
1005 { RGB_TO_ULONG(139, 0 , 0 ), "DarkRed" },
1006 { RGB_TO_ULONG(144, 238, 144), "light green" },
1007 { RGB_TO_ULONG(144, 238, 144), "LightGreen" }
1008 };
1009
1010 Lisp_Object
1011 mac_color_map_lookup (colorname)
1012 const char *colorname;
1013 {
1014 Lisp_Object ret = Qnil;
1015 int i;
1016
1017 BLOCK_INPUT;
1018
1019 for (i = 0; i < sizeof (mac_color_map) / sizeof (mac_color_map[0]); i++)
1020 if (xstricmp (colorname, mac_color_map[i].name) == 0)
1021 {
1022 ret = make_number (mac_color_map[i].color);
1023 break;
1024 }
1025
1026 UNBLOCK_INPUT;
1027
1028 return ret;
1029 }
1030
1031 Lisp_Object
1032 x_to_mac_color (colorname)
1033 char * colorname;
1034 {
1035 register Lisp_Object ret = Qnil;
1036
1037 BLOCK_INPUT;
1038
1039 if (colorname[0] == '#')
1040 {
1041 /* Could be an old-style RGB Device specification. */
1042 char *color;
1043 int size;
1044 color = colorname + 1;
1045
1046 size = strlen(color);
1047 if (size == 3 || size == 6 || size == 9 || size == 12)
1048 {
1049 unsigned long colorval;
1050 int i, pos;
1051 pos = 16;
1052 size /= 3;
1053 colorval = 0;
1054
1055 for (i = 0; i < 3; i++)
1056 {
1057 char *end;
1058 char t;
1059 unsigned long value;
1060
1061 /* The check for 'x' in the following conditional takes into
1062 account the fact that strtol allows a "0x" in front of
1063 our numbers, and we don't. */
1064 if (!isxdigit(color[0]) || color[1] == 'x')
1065 break;
1066 t = color[size];
1067 color[size] = '\0';
1068 value = strtoul(color, &end, 16);
1069 color[size] = t;
1070 if (errno == ERANGE || end - color != size)
1071 break;
1072 switch (size)
1073 {
1074 case 1:
1075 value = value * 0x10;
1076 break;
1077 case 2:
1078 break;
1079 case 3:
1080 value /= 0x10;
1081 break;
1082 case 4:
1083 value /= 0x100;
1084 break;
1085 }
1086 colorval |= (value << pos);
1087 pos -= 8;
1088 if (i == 2)
1089 {
1090 UNBLOCK_INPUT;
1091 return make_number (colorval);
1092 }
1093 color = end;
1094 }
1095 }
1096 }
1097 else if (strnicmp(colorname, "rgb:", 4) == 0)
1098 {
1099 char *color;
1100 unsigned long colorval;
1101 int i, pos;
1102 pos = 16;
1103
1104 colorval = 0;
1105 color = colorname + 4;
1106 for (i = 0; i < 3; i++)
1107 {
1108 char *end;
1109 unsigned long value;
1110
1111 /* The check for 'x' in the following conditional takes into
1112 account the fact that strtol allows a "0x" in front of
1113 our numbers, and we don't. */
1114 if (!isxdigit(color[0]) || color[1] == 'x')
1115 break;
1116 value = strtoul(color, &end, 16);
1117 if (errno == ERANGE)
1118 break;
1119 switch (end - color)
1120 {
1121 case 1:
1122 value = value * 0x10 + value;
1123 break;
1124 case 2:
1125 break;
1126 case 3:
1127 value /= 0x10;
1128 break;
1129 case 4:
1130 value /= 0x100;
1131 break;
1132 default:
1133 value = ULONG_MAX;
1134 }
1135 if (value == ULONG_MAX)
1136 break;
1137 colorval |= (value << pos);
1138 pos -= 0x8;
1139 if (i == 2)
1140 {
1141 if (*end != '\0')
1142 break;
1143 UNBLOCK_INPUT;
1144 return make_number (colorval);
1145 }
1146 if (*end != '/')
1147 break;
1148 color = end + 1;
1149 }
1150 }
1151 else if (strnicmp(colorname, "rgbi:", 5) == 0)
1152 {
1153 /* This is an RGB Intensity specification. */
1154 char *color;
1155 unsigned long colorval;
1156 int i, pos;
1157 pos = 16;
1158
1159 colorval = 0;
1160 color = colorname + 5;
1161 for (i = 0; i < 3; i++)
1162 {
1163 char *end;
1164 double value;
1165 unsigned long val;
1166
1167 value = strtod(color, &end);
1168 if (errno == ERANGE)
1169 break;
1170 if (value < 0.0 || value > 1.0)
1171 break;
1172 val = (unsigned long)(0x100 * value);
1173 /* We used 0x100 instead of 0xFF to give a continuous
1174 range between 0.0 and 1.0 inclusive. The next statement
1175 fixes the 1.0 case. */
1176 if (val == 0x100)
1177 val = 0xFF;
1178 colorval |= (val << pos);
1179 pos -= 0x8;
1180 if (i == 2)
1181 {
1182 if (*end != '\0')
1183 break;
1184 UNBLOCK_INPUT;
1185 return make_number (colorval);
1186 }
1187 if (*end != '/')
1188 break;
1189 color = end + 1;
1190 }
1191 }
1192
1193 ret = mac_color_map_lookup (colorname);
1194
1195 UNBLOCK_INPUT;
1196 return ret;
1197 }
1198
1199 /* Gamma-correct COLOR on frame F. */
1200
1201 void
1202 gamma_correct (f, color)
1203 struct frame *f;
1204 unsigned long *color;
1205 {
1206 if (f->gamma)
1207 {
1208 unsigned long red, green, blue;
1209
1210 red = pow (RED_FROM_ULONG (*color) / 255.0, f->gamma) * 255.0 + 0.5;
1211 green = pow (GREEN_FROM_ULONG (*color) / 255.0, f->gamma) * 255.0 + 0.5;
1212 blue = pow (BLUE_FROM_ULONG (*color) / 255.0, f->gamma) * 255.0 + 0.5;
1213 *color = RGB_TO_ULONG (red, green, blue);
1214 }
1215 }
1216
1217 /* Decide if color named COLOR is valid for the display associated
1218 with the selected frame; if so, return the rgb values in COLOR_DEF.
1219 If ALLOC is nonzero, allocate a new colormap cell. */
1220
1221 int
1222 mac_defined_color (f, color, color_def, alloc)
1223 FRAME_PTR f;
1224 char *color;
1225 XColor *color_def;
1226 int alloc;
1227 {
1228 register Lisp_Object tem;
1229 unsigned long mac_color_ref;
1230
1231 tem = x_to_mac_color (color);
1232
1233 if (!NILP (tem))
1234 {
1235 if (f)
1236 {
1237 /* Apply gamma correction. */
1238 mac_color_ref = XUINT (tem);
1239 gamma_correct (f, &mac_color_ref);
1240 XSETINT (tem, mac_color_ref);
1241 }
1242
1243 color_def->pixel = mac_color_ref;
1244 color_def->red = RED16_FROM_ULONG (mac_color_ref);
1245 color_def->green = GREEN16_FROM_ULONG (mac_color_ref);
1246 color_def->blue = BLUE16_FROM_ULONG (mac_color_ref);
1247
1248 return 1;
1249 }
1250 else
1251 {
1252 return 0;
1253 }
1254 }
1255
1256 /* Given a string ARG naming a color, compute a pixel value from it
1257 suitable for screen F.
1258 If F is not a color screen, return DEF (default) regardless of what
1259 ARG says. */
1260
1261 int
1262 x_decode_color (f, arg, def)
1263 FRAME_PTR f;
1264 Lisp_Object arg;
1265 int def;
1266 {
1267 XColor cdef;
1268
1269 CHECK_STRING (arg);
1270
1271 if (strcmp (SDATA (arg), "black") == 0)
1272 return BLACK_PIX_DEFAULT (f);
1273 else if (strcmp (SDATA (arg), "white") == 0)
1274 return WHITE_PIX_DEFAULT (f);
1275
1276 #if 0
1277 if (FRAME_MAC_DISPLAY_INFO (f)->n_planes) == 1)
1278 return def;
1279 #endif
1280
1281 if (mac_defined_color (f, SDATA (arg), &cdef, 1))
1282 return cdef.pixel;
1283
1284 /* defined_color failed; return an ultimate default. */
1285 return def;
1286 }
1287 \f
1288 /* Functions called only from `x_set_frame_param'
1289 to set individual parameters.
1290
1291 If FRAME_MAC_WINDOW (f) is 0,
1292 the frame is being created and its window does not exist yet.
1293 In that case, just record the parameter's new value
1294 in the standard place; do not attempt to change the window. */
1295
1296 void
1297 x_set_foreground_color (f, arg, oldval)
1298 struct frame *f;
1299 Lisp_Object arg, oldval;
1300 {
1301 struct mac_output *mac = f->output_data.mac;
1302 unsigned long fg, old_fg;
1303
1304 fg = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
1305 old_fg = FRAME_FOREGROUND_PIXEL (f);
1306 FRAME_FOREGROUND_PIXEL (f) = fg;
1307
1308 if (FRAME_MAC_WINDOW (f) != 0)
1309 {
1310 Display *dpy = FRAME_MAC_DISPLAY (f);
1311
1312 BLOCK_INPUT;
1313 XSetForeground (dpy, mac->normal_gc, fg);
1314 XSetBackground (dpy, mac->reverse_gc, fg);
1315
1316 if (mac->cursor_pixel == old_fg)
1317 {
1318 unload_color (f, mac->cursor_pixel);
1319 mac->cursor_pixel = fg;
1320 XSetBackground (dpy, mac->cursor_gc, mac->cursor_pixel);
1321 }
1322
1323 UNBLOCK_INPUT;
1324
1325 update_face_from_frame_parameter (f, Qforeground_color, arg);
1326
1327 if (FRAME_VISIBLE_P (f))
1328 redraw_frame (f);
1329 }
1330
1331 unload_color (f, old_fg);
1332 }
1333
1334 void
1335 x_set_background_color (f, arg, oldval)
1336 struct frame *f;
1337 Lisp_Object arg, oldval;
1338 {
1339 struct mac_output *mac = f->output_data.mac;
1340 unsigned long bg;
1341
1342 bg = x_decode_color (f, arg, WHITE_PIX_DEFAULT (f));
1343 unload_color (f, FRAME_BACKGROUND_PIXEL (f));
1344 FRAME_BACKGROUND_PIXEL (f) = bg;
1345
1346 if (FRAME_MAC_WINDOW (f) != 0)
1347 {
1348 Display *dpy = FRAME_MAC_DISPLAY (f);
1349
1350 BLOCK_INPUT;
1351 XSetBackground (dpy, mac->normal_gc, bg);
1352 XSetForeground (dpy, mac->reverse_gc, bg);
1353 XSetWindowBackground (dpy, FRAME_MAC_WINDOW (f), bg);
1354 XSetForeground (dpy, mac->cursor_gc, bg);
1355
1356 UNBLOCK_INPUT;
1357 update_face_from_frame_parameter (f, Qbackground_color, arg);
1358
1359 if (FRAME_VISIBLE_P (f))
1360 redraw_frame (f);
1361 }
1362 }
1363
1364 void
1365 x_set_mouse_color (f, arg, oldval)
1366 struct frame *f;
1367 Lisp_Object arg, oldval;
1368 {
1369 struct x_output *x = f->output_data.x;
1370 Cursor cursor, nontext_cursor, mode_cursor, hand_cursor;
1371 Cursor hourglass_cursor, horizontal_drag_cursor;
1372 unsigned long pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
1373 unsigned long mask_color = x->background_pixel;
1374
1375 /* Don't let pointers be invisible. */
1376 if (mask_color == pixel)
1377 pixel = x->foreground_pixel;
1378
1379 f->output_data.mac->mouse_pixel = pixel;
1380
1381 if (!NILP (Vx_pointer_shape))
1382 {
1383 CHECK_NUMBER (Vx_pointer_shape);
1384 cursor = XINT (Vx_pointer_shape);
1385 }
1386 else
1387 cursor = kThemeIBeamCursor;
1388
1389 if (!NILP (Vx_nontext_pointer_shape))
1390 {
1391 CHECK_NUMBER (Vx_nontext_pointer_shape);
1392 nontext_cursor = XINT (Vx_nontext_pointer_shape);
1393 }
1394 else
1395 nontext_cursor = kThemeArrowCursor;
1396
1397 if (!NILP (Vx_hourglass_pointer_shape))
1398 {
1399 CHECK_NUMBER (Vx_hourglass_pointer_shape);
1400 hourglass_cursor = XINT (Vx_hourglass_pointer_shape);
1401 }
1402 else
1403 hourglass_cursor = kThemeWatchCursor;
1404
1405 if (!NILP (Vx_mode_pointer_shape))
1406 {
1407 CHECK_NUMBER (Vx_mode_pointer_shape);
1408 mode_cursor = XINT (Vx_mode_pointer_shape);
1409 }
1410 else
1411 mode_cursor = kThemeArrowCursor;
1412
1413 if (!NILP (Vx_sensitive_text_pointer_shape))
1414 {
1415 CHECK_NUMBER (Vx_sensitive_text_pointer_shape);
1416 hand_cursor = XINT (Vx_sensitive_text_pointer_shape);
1417 }
1418 else
1419 hand_cursor = kThemePointingHandCursor;
1420
1421 if (!NILP (Vx_window_horizontal_drag_shape))
1422 {
1423 CHECK_NUMBER (Vx_window_horizontal_drag_shape);
1424 horizontal_drag_cursor = XINT (Vx_window_horizontal_drag_shape);
1425 }
1426 else
1427 horizontal_drag_cursor = kThemeResizeLeftRightCursor;
1428
1429 #if 0 /* MAC_TODO: cursor color changes */
1430 {
1431 XColor fore_color, back_color;
1432
1433 fore_color.pixel = f->output_data.mac->mouse_pixel;
1434 x_query_color (f, &fore_color);
1435 back_color.pixel = mask_color;
1436 x_query_color (f, &back_color);
1437
1438 XRecolorCursor (dpy, cursor, &fore_color, &back_color);
1439 XRecolorCursor (dpy, nontext_cursor, &fore_color, &back_color);
1440 XRecolorCursor (dpy, mode_cursor, &fore_color, &back_color);
1441 XRecolorCursor (dpy, hand_cursor, &fore_color, &back_color);
1442 XRecolorCursor (dpy, hourglass_cursor, &fore_color, &back_color);
1443 XRecolorCursor (dpy, horizontal_drag_cursor, &fore_color, &back_color);
1444 }
1445 #endif
1446
1447 BLOCK_INPUT;
1448
1449 if (FRAME_MAC_WINDOW (f) != 0)
1450 rif->define_frame_cursor (f, cursor);
1451
1452 f->output_data.mac->text_cursor = cursor;
1453 f->output_data.mac->nontext_cursor = nontext_cursor;
1454 f->output_data.mac->hourglass_cursor = hourglass_cursor;
1455 f->output_data.mac->modeline_cursor = mode_cursor;
1456 f->output_data.mac->hand_cursor = hand_cursor;
1457 f->output_data.mac->horizontal_drag_cursor = horizontal_drag_cursor;
1458
1459 UNBLOCK_INPUT;
1460
1461 update_face_from_frame_parameter (f, Qmouse_color, arg);
1462 }
1463
1464 void
1465 x_set_cursor_color (f, arg, oldval)
1466 struct frame *f;
1467 Lisp_Object arg, oldval;
1468 {
1469 unsigned long fore_pixel, pixel;
1470
1471 if (!NILP (Vx_cursor_fore_pixel))
1472 fore_pixel = x_decode_color (f, Vx_cursor_fore_pixel,
1473 WHITE_PIX_DEFAULT (f));
1474 else
1475 fore_pixel = FRAME_BACKGROUND_PIXEL (f);
1476
1477 pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
1478
1479 /* Make sure that the cursor color differs from the background color. */
1480 if (pixel == FRAME_BACKGROUND_PIXEL (f))
1481 {
1482 pixel = f->output_data.mac->mouse_pixel;
1483 if (pixel == fore_pixel)
1484 fore_pixel = FRAME_BACKGROUND_PIXEL (f);
1485 }
1486
1487 f->output_data.mac->cursor_foreground_pixel = fore_pixel;
1488 f->output_data.mac->cursor_pixel = pixel;
1489
1490 if (FRAME_MAC_WINDOW (f) != 0)
1491 {
1492 BLOCK_INPUT;
1493 /* Update frame's cursor_gc. */
1494 XSetBackground (FRAME_MAC_DISPLAY (f),
1495 f->output_data.mac->cursor_gc, pixel);
1496 XSetForeground (FRAME_MAC_DISPLAY (f),
1497 f->output_data.mac->cursor_gc, fore_pixel);
1498 UNBLOCK_INPUT;
1499
1500 if (FRAME_VISIBLE_P (f))
1501 {
1502 x_update_cursor (f, 0);
1503 x_update_cursor (f, 1);
1504 }
1505 }
1506
1507 update_face_from_frame_parameter (f, Qcursor_color, arg);
1508 }
1509
1510 /* Set the border-color of frame F to pixel value PIX.
1511 Note that this does not fully take effect if done before
1512 F has a window. */
1513
1514 void
1515 x_set_border_pixel (f, pix)
1516 struct frame *f;
1517 int pix;
1518 {
1519
1520 f->output_data.mac->border_pixel = pix;
1521
1522 if (FRAME_MAC_WINDOW (f) != 0 && f->border_width > 0)
1523 {
1524 if (FRAME_VISIBLE_P (f))
1525 redraw_frame (f);
1526 }
1527 }
1528
1529 /* Set the border-color of frame F to value described by ARG.
1530 ARG can be a string naming a color.
1531 The border-color is used for the border that is drawn by the server.
1532 Note that this does not fully take effect if done before
1533 F has a window; it must be redone when the window is created. */
1534
1535 void
1536 x_set_border_color (f, arg, oldval)
1537 struct frame *f;
1538 Lisp_Object arg, oldval;
1539 {
1540 int pix;
1541
1542 CHECK_STRING (arg);
1543 pix = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
1544 x_set_border_pixel (f, pix);
1545 update_face_from_frame_parameter (f, Qborder_color, arg);
1546 }
1547
1548
1549 void
1550 x_set_cursor_type (f, arg, oldval)
1551 FRAME_PTR f;
1552 Lisp_Object arg, oldval;
1553 {
1554 set_frame_cursor_types (f, arg);
1555
1556 /* Make sure the cursor gets redrawn. */
1557 cursor_type_changed = 1;
1558 }
1559 \f
1560 #if 0 /* MAC_TODO: really no icon for Mac */
1561 void
1562 x_set_icon_type (f, arg, oldval)
1563 struct frame *f;
1564 Lisp_Object arg, oldval;
1565 {
1566 int result;
1567
1568 if (NILP (arg) && NILP (oldval))
1569 return;
1570
1571 if (STRINGP (arg) && STRINGP (oldval)
1572 && EQ (Fstring_equal (oldval, arg), Qt))
1573 return;
1574
1575 if (SYMBOLP (arg) && SYMBOLP (oldval) && EQ (arg, oldval))
1576 return;
1577
1578 BLOCK_INPUT;
1579
1580 result = x_bitmap_icon (f, arg);
1581 if (result)
1582 {
1583 UNBLOCK_INPUT;
1584 error ("No icon window available");
1585 }
1586
1587 UNBLOCK_INPUT;
1588 }
1589 #endif /* MAC_TODO */
1590
1591 void
1592 x_set_icon_name (f, arg, oldval)
1593 struct frame *f;
1594 Lisp_Object arg, oldval;
1595 {
1596 int result;
1597
1598 if (STRINGP (arg))
1599 {
1600 if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
1601 return;
1602 }
1603 else if (!NILP (arg) || NILP (oldval))
1604 return;
1605
1606 f->icon_name = arg;
1607
1608 #if 0 /* MAC_TODO */
1609 if (f->output_data.w32->icon_bitmap != 0)
1610 return;
1611
1612 BLOCK_INPUT;
1613
1614 result = x_text_icon (f,
1615 (char *) SDATA ((!NILP (f->icon_name)
1616 ? f->icon_name
1617 : !NILP (f->title)
1618 ? f->title
1619 : f->name)));
1620
1621 if (result)
1622 {
1623 UNBLOCK_INPUT;
1624 error ("No icon window available");
1625 }
1626
1627 /* If the window was unmapped (and its icon was mapped),
1628 the new icon is not mapped, so map the window in its stead. */
1629 if (FRAME_VISIBLE_P (f))
1630 {
1631 #ifdef USE_X_TOOLKIT
1632 XtPopup (f->output_data.w32->widget, XtGrabNone);
1633 #endif
1634 XMapWindow (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f));
1635 }
1636
1637 XFlush (FRAME_W32_DISPLAY (f));
1638 UNBLOCK_INPUT;
1639 #endif /* MAC_TODO */
1640 }
1641
1642 \f
1643 void
1644 x_set_menu_bar_lines (f, value, oldval)
1645 struct frame *f;
1646 Lisp_Object value, oldval;
1647 {
1648 /* Make sure we redisplay all windows in this frame. */
1649 windows_or_buffers_changed++;
1650
1651 FRAME_MENU_BAR_LINES (f) = 0;
1652 /* The menu bar is always shown. */
1653 FRAME_EXTERNAL_MENU_BAR (f) = 1;
1654 if (FRAME_MAC_P (f) && f->output_data.mac->menubar_widget == 0)
1655 /* Make sure next redisplay shows the menu bar. */
1656 XWINDOW (FRAME_SELECTED_WINDOW (f))->update_mode_line = Qt;
1657 adjust_glyphs (f);
1658 }
1659
1660
1661 /* Set the number of lines used for the tool bar of frame F to VALUE.
1662 VALUE not an integer, or < 0 means set the lines to zero. OLDVAL
1663 is the old number of tool bar lines. This function changes the
1664 height of all windows on frame F to match the new tool bar height.
1665 The frame's height doesn't change. */
1666
1667 void
1668 x_set_tool_bar_lines (f, value, oldval)
1669 struct frame *f;
1670 Lisp_Object value, oldval;
1671 {
1672 int delta, nlines, root_height;
1673 Lisp_Object root_window;
1674
1675 /* Treat tool bars like menu bars. */
1676 if (FRAME_MINIBUF_ONLY_P (f))
1677 return;
1678
1679 /* Use VALUE only if an integer >= 0. */
1680 if (INTEGERP (value) && XINT (value) >= 0)
1681 nlines = XFASTINT (value);
1682 else
1683 nlines = 0;
1684
1685 /* Make sure we redisplay all windows in this frame. */
1686 ++windows_or_buffers_changed;
1687
1688 delta = nlines - FRAME_TOOL_BAR_LINES (f);
1689
1690 /* Don't resize the tool-bar to more than we have room for. */
1691 root_window = FRAME_ROOT_WINDOW (f);
1692 root_height = WINDOW_TOTAL_LINES (XWINDOW (root_window));
1693 if (root_height - delta < 1)
1694 {
1695 delta = root_height - 1;
1696 nlines = FRAME_TOOL_BAR_LINES (f) + delta;
1697 }
1698
1699 FRAME_TOOL_BAR_LINES (f) = nlines;
1700 change_window_heights (root_window, delta);
1701 adjust_glyphs (f);
1702
1703 /* We also have to make sure that the internal border at the top of
1704 the frame, below the menu bar or tool bar, is redrawn when the
1705 tool bar disappears. This is so because the internal border is
1706 below the tool bar if one is displayed, but is below the menu bar
1707 if there isn't a tool bar. The tool bar draws into the area
1708 below the menu bar. */
1709 if (FRAME_MAC_WINDOW (f) && FRAME_TOOL_BAR_LINES (f) == 0)
1710 {
1711 updating_frame = f;
1712 clear_frame ();
1713 clear_current_matrices (f);
1714 updating_frame = NULL;
1715 }
1716
1717 /* If the tool bar gets smaller, the internal border below it
1718 has to be cleared. It was formerly part of the display
1719 of the larger tool bar, and updating windows won't clear it. */
1720 if (delta < 0)
1721 {
1722 int height = FRAME_INTERNAL_BORDER_WIDTH (f);
1723 int width = FRAME_PIXEL_WIDTH (f);
1724 int y = nlines * FRAME_LINE_HEIGHT (f);
1725
1726 BLOCK_INPUT;
1727 mac_clear_area (f, 0, y, width, height);
1728 UNBLOCK_INPUT;
1729
1730 if (WINDOWP (f->tool_bar_window))
1731 clear_glyph_matrix (XWINDOW (f->tool_bar_window)->current_matrix);
1732 }
1733 }
1734
1735
1736 \f
1737 /* Set the Mac window title to NAME for frame F. */
1738
1739 static void
1740 x_set_name_internal (f, name)
1741 FRAME_PTR f;
1742 Lisp_Object name;
1743 {
1744 if (FRAME_MAC_WINDOW (f))
1745 {
1746 if (STRING_MULTIBYTE (name))
1747 #if TARGET_API_MAC_CARBON
1748 name = ENCODE_UTF_8 (name);
1749 #else
1750 name = ENCODE_SYSTEM (name);
1751 #endif
1752
1753 BLOCK_INPUT;
1754
1755 {
1756 #if TARGET_API_MAC_CARBON
1757 CFStringRef windowTitle =
1758 cfstring_create_with_utf8_cstring (SDATA (name));
1759
1760 SetWindowTitleWithCFString (FRAME_MAC_WINDOW (f), windowTitle);
1761 CFRelease (windowTitle);
1762 #else
1763 Str255 windowTitle;
1764 if (strlen (SDATA (name)) < 255)
1765 {
1766 strcpy (windowTitle, SDATA (name));
1767 c2pstr (windowTitle);
1768 SetWTitle (FRAME_MAC_WINDOW (f), windowTitle);
1769 }
1770 #endif
1771 }
1772
1773 UNBLOCK_INPUT;
1774 }
1775 }
1776
1777 /* Change the name of frame F to NAME. If NAME is nil, set F's name to
1778 mac_id_name.
1779
1780 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1781 name; if NAME is a string, set F's name to NAME and set
1782 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1783
1784 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1785 suggesting a new name, which lisp code should override; if
1786 F->explicit_name is set, ignore the new name; otherwise, set it. */
1787
1788 void
1789 x_set_name (f, name, explicit)
1790 struct frame *f;
1791 Lisp_Object name;
1792 int explicit;
1793 {
1794 /* Make sure that requests from lisp code override requests from
1795 Emacs redisplay code. */
1796 if (explicit)
1797 {
1798 /* If we're switching from explicit to implicit, we had better
1799 update the mode lines and thereby update the title. */
1800 if (f->explicit_name && NILP (name))
1801 update_mode_lines = 1;
1802
1803 f->explicit_name = ! NILP (name);
1804 }
1805 else if (f->explicit_name)
1806 return;
1807
1808 /* If NAME is nil, set the name to the mac_id_name. */
1809 if (NILP (name))
1810 {
1811 /* Check for no change needed in this very common case
1812 before we do any consing. */
1813 if (!strcmp (FRAME_MAC_DISPLAY_INFO (f)->mac_id_name,
1814 SDATA (f->name)))
1815 return;
1816 name = build_string (FRAME_MAC_DISPLAY_INFO (f)->mac_id_name);
1817 }
1818 else
1819 CHECK_STRING (name);
1820
1821 /* Don't change the name if it's already NAME. */
1822 if (! NILP (Fstring_equal (name, f->name)))
1823 return;
1824
1825 f->name = name;
1826
1827 /* For setting the frame title, the title parameter should override
1828 the name parameter. */
1829 if (! NILP (f->title))
1830 name = f->title;
1831
1832 x_set_name_internal (f, name);
1833 }
1834
1835 /* This function should be called when the user's lisp code has
1836 specified a name for the frame; the name will override any set by the
1837 redisplay code. */
1838 void
1839 x_explicitly_set_name (f, arg, oldval)
1840 FRAME_PTR f;
1841 Lisp_Object arg, oldval;
1842 {
1843 x_set_name (f, arg, 1);
1844 }
1845
1846 /* This function should be called by Emacs redisplay code to set the
1847 name; names set this way will never override names set by the user's
1848 lisp code. */
1849 void
1850 x_implicitly_set_name (f, arg, oldval)
1851 FRAME_PTR f;
1852 Lisp_Object arg, oldval;
1853 {
1854 x_set_name (f, arg, 0);
1855 }
1856 \f
1857 /* Change the title of frame F to NAME.
1858 If NAME is nil, use the frame name as the title.
1859
1860 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1861 name; if NAME is a string, set F's name to NAME and set
1862 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1863
1864 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1865 suggesting a new name, which lisp code should override; if
1866 F->explicit_name is set, ignore the new name; otherwise, set it. */
1867
1868 void
1869 x_set_title (f, name, old_name)
1870 struct frame *f;
1871 Lisp_Object name, old_name;
1872 {
1873 /* Don't change the title if it's already NAME. */
1874 if (EQ (name, f->title))
1875 return;
1876
1877 update_mode_lines = 1;
1878
1879 f->title = name;
1880
1881 if (NILP (name))
1882 name = f->name;
1883 else
1884 CHECK_STRING (name);
1885
1886 x_set_name_internal (f, name);
1887 }
1888
1889 void
1890 x_set_scroll_bar_default_width (f)
1891 struct frame *f;
1892 {
1893 /* Imitate X without X Toolkit */
1894
1895 int wid = FRAME_COLUMN_WIDTH (f);
1896
1897 #ifdef MAC_OSX
1898 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = MAC_AQUA_VERTICAL_SCROLL_BAR_WIDTH;
1899 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (FRAME_CONFIG_SCROLL_BAR_WIDTH (f) +
1900 wid - 1) / wid;
1901 #else /* not MAC_OSX */
1902 /* Make the actual width at least 14 pixels and a multiple of a
1903 character width. */
1904 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
1905
1906 /* Use all of that space (aside from required margins) for the
1907 scroll bar. */
1908 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = 0;
1909 #endif /* not MAC_OSX */
1910 }
1911
1912 void
1913 mac_set_scroll_bar_width (f, arg, oldval)
1914 struct frame *f;
1915 Lisp_Object arg, oldval;
1916 {
1917 #ifdef MAC_OSX
1918 if (INTEGERP (arg) && XINT (arg) > 0)
1919 {
1920 if (XINT (arg) < (MAC_AQUA_SMALL_VERTICAL_SCROLL_BAR_WIDTH
1921 + MAC_AQUA_VERTICAL_SCROLL_BAR_WIDTH) / 2)
1922 XSETINT (arg, MAC_AQUA_SMALL_VERTICAL_SCROLL_BAR_WIDTH);
1923 else
1924 XSETINT (arg, MAC_AQUA_VERTICAL_SCROLL_BAR_WIDTH);
1925 }
1926 #endif
1927 x_set_scroll_bar_width (f, arg, oldval);
1928 }
1929
1930 static void
1931 mac_set_font (f, arg, oldval)
1932 struct frame *f;
1933 Lisp_Object arg, oldval;
1934 {
1935 x_set_font (f, arg, oldval);
1936 #if USE_MAC_FONT_PANEL
1937 {
1938 Lisp_Object focus_frame = x_get_focus_frame (f);
1939
1940 if ((NILP (focus_frame) && f == SELECTED_FRAME ())
1941 || XFRAME (focus_frame) == f)
1942 {
1943 BLOCK_INPUT;
1944 mac_set_font_info_for_selection (f, DEFAULT_FACE_ID, 0);
1945 UNBLOCK_INPUT;
1946 }
1947 }
1948 #endif
1949 }
1950
1951 #if TARGET_API_MAC_CARBON
1952 static void
1953 mac_update_proxy_icon (f)
1954 struct frame *f;
1955 {
1956 OSStatus err;
1957 Lisp_Object file_name =
1958 XBUFFER (XWINDOW (FRAME_SELECTED_WINDOW (f))->buffer)->filename;
1959 Window w = FRAME_MAC_WINDOW (f);
1960 AliasHandle alias = NULL;
1961
1962 BLOCK_INPUT;
1963
1964 err = GetWindowProxyAlias (w, &alias);
1965 if (err == errWindowDoesNotHaveProxy && !STRINGP (file_name))
1966 goto out;
1967
1968 if (STRINGP (file_name))
1969 {
1970 AEDesc desc;
1971 #ifdef MAC_OSX
1972 FSRef fref, fref_proxy;
1973 #else
1974 FSSpec fss, fss_proxy;
1975 #endif
1976 Boolean changed;
1977 Lisp_Object encoded_file_name = ENCODE_FILE (file_name);
1978
1979 #ifdef MAC_OSX
1980 err = AECoercePtr (TYPE_FILE_NAME, SDATA (encoded_file_name),
1981 SBYTES (encoded_file_name), typeFSRef, &desc);
1982 #else
1983 SetPortWindowPort (w);
1984 err = AECoercePtr (TYPE_FILE_NAME, SDATA (encoded_file_name),
1985 SBYTES (encoded_file_name), typeFSS, &desc);
1986 #endif
1987 if (err == noErr)
1988 {
1989 #ifdef MAC_OSX
1990 err = AEGetDescData (&desc, &fref, sizeof (FSRef));
1991 #else
1992 err = AEGetDescData (&desc, &fss, sizeof (FSSpec));
1993 #endif
1994 AEDisposeDesc (&desc);
1995 }
1996 if (err == noErr)
1997 {
1998 if (alias)
1999 {
2000 /* (FS)ResolveAlias never sets `changed' to true if
2001 `alias' is minimal. */
2002 #ifdef MAC_OSX
2003 err = FSResolveAlias (NULL, alias, &fref_proxy, &changed);
2004 if (err == noErr)
2005 err = FSCompareFSRefs (&fref, &fref_proxy);
2006 #else
2007 err = ResolveAlias (NULL, alias, &fss_proxy, &changed);
2008 if (err == noErr)
2009 err = !(fss.vRefNum == fss_proxy.vRefNum
2010 && fss.parID == fss_proxy.parID
2011 && EqualString (fss.name, fss_proxy.name,
2012 false, true));
2013 #endif
2014 }
2015 if (err != noErr || alias == NULL)
2016 {
2017 if (alias)
2018 DisposeHandle ((Handle) alias);
2019 #ifdef MAC_OSX
2020 err = FSNewAliasMinimal (&fref, &alias);
2021 #else
2022 err = NewAliasMinimal (&fss, &alias);
2023 #endif
2024 changed = true;
2025 }
2026 }
2027 if (err == noErr)
2028 if (changed)
2029 err = SetWindowProxyAlias (w, alias);
2030 }
2031
2032 if (alias)
2033 DisposeHandle ((Handle) alias);
2034
2035 if (err != noErr || !STRINGP (file_name))
2036 RemoveWindowProxy (w);
2037
2038 out:
2039 UNBLOCK_INPUT;
2040 }
2041 #endif
2042
2043 void
2044 mac_update_title_bar (f, save_match_data)
2045 struct frame *f;
2046 int save_match_data;
2047 {
2048 #if TARGET_API_MAC_CARBON
2049 struct window *w;
2050 int modified_p;
2051
2052 if (!FRAME_MAC_P (f))
2053 return;
2054
2055 w = XWINDOW (FRAME_SELECTED_WINDOW (f));
2056 modified_p = (BUF_SAVE_MODIFF (XBUFFER (w->buffer))
2057 < BUF_MODIFF (XBUFFER (w->buffer)));
2058 if (windows_or_buffers_changed
2059 /* Minibuffer modification status shown in the close button is
2060 confusing. */
2061 || (!MINI_WINDOW_P (w)
2062 && (modified_p != !NILP (w->last_had_star))))
2063 {
2064 SetWindowModified (FRAME_MAC_WINDOW (f),
2065 !MINI_WINDOW_P (w) && modified_p);
2066 mac_update_proxy_icon (f);
2067 }
2068 #endif
2069 }
2070
2071 \f
2072 /* Subroutines of creating a frame. */
2073
2074 /* Retrieve the string resource specified by NAME with CLASS from
2075 database RDB.
2076
2077 The return value points to the contents of a Lisp string. So it
2078 will not be valid after the next GC where string compaction will
2079 occur. */
2080
2081 char *
2082 x_get_string_resource (rdb, name, class)
2083 XrmDatabase rdb;
2084 char *name, *class;
2085 {
2086 Lisp_Object value = xrm_get_resource (rdb, name, class);
2087
2088 if (STRINGP (value))
2089 return SDATA (value);
2090 else
2091 return NULL;
2092 }
2093
2094 /* Return the value of parameter PARAM.
2095
2096 First search ALIST, then Vdefault_frame_alist, then the X defaults
2097 database, using ATTRIBUTE as the attribute name and CLASS as its class.
2098
2099 Convert the resource to the type specified by desired_type.
2100
2101 If no default is specified, return Qunbound. If you call
2102 mac_get_arg, make sure you deal with Qunbound in a reasonable way,
2103 and don't let it get stored in any Lisp-visible variables! */
2104
2105 static Lisp_Object
2106 mac_get_arg (alist, param, attribute, class, type)
2107 Lisp_Object alist, param;
2108 char *attribute;
2109 char *class;
2110 enum resource_types type;
2111 {
2112 return x_get_arg (check_x_display_info (Qnil),
2113 alist, param, attribute, class, type);
2114 }
2115
2116 \f
2117 /* XParseGeometry copied from w32xfns.c */
2118
2119 /*
2120 * XParseGeometry parses strings of the form
2121 * "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
2122 * width, height, xoffset, and yoffset are unsigned integers.
2123 * Example: "=80x24+300-49"
2124 * The equal sign is optional.
2125 * It returns a bitmask that indicates which of the four values
2126 * were actually found in the string. For each value found,
2127 * the corresponding argument is updated; for each value
2128 * not found, the corresponding argument is left unchanged.
2129 */
2130
2131 static int
2132 read_integer (string, NextString)
2133 register char *string;
2134 char **NextString;
2135 {
2136 register int Result = 0;
2137 int Sign = 1;
2138
2139 if (*string == '+')
2140 string++;
2141 else if (*string == '-')
2142 {
2143 string++;
2144 Sign = -1;
2145 }
2146 for (; (*string >= '0') && (*string <= '9'); string++)
2147 {
2148 Result = (Result * 10) + (*string - '0');
2149 }
2150 *NextString = string;
2151 if (Sign >= 0)
2152 return (Result);
2153 else
2154 return (-Result);
2155 }
2156
2157 int
2158 XParseGeometry (string, x, y, width, height)
2159 char *string;
2160 int *x, *y;
2161 unsigned int *width, *height; /* RETURN */
2162 {
2163 int mask = NoValue;
2164 register char *strind;
2165 unsigned int tempWidth, tempHeight;
2166 int tempX, tempY;
2167 char *nextCharacter;
2168
2169 if ((string == NULL) || (*string == '\0')) return (mask);
2170 if (*string == '=')
2171 string++; /* ignore possible '=' at beg of geometry spec */
2172
2173 strind = (char *)string;
2174 if (*strind != '+' && *strind != '-' && *strind != 'x')
2175 {
2176 tempWidth = read_integer (strind, &nextCharacter);
2177 if (strind == nextCharacter)
2178 return (0);
2179 strind = nextCharacter;
2180 mask |= WidthValue;
2181 }
2182
2183 if (*strind == 'x' || *strind == 'X')
2184 {
2185 strind++;
2186 tempHeight = read_integer (strind, &nextCharacter);
2187 if (strind == nextCharacter)
2188 return (0);
2189 strind = nextCharacter;
2190 mask |= HeightValue;
2191 }
2192
2193 if ((*strind == '+') || (*strind == '-'))
2194 {
2195 if (*strind == '-')
2196 {
2197 strind++;
2198 tempX = -read_integer (strind, &nextCharacter);
2199 if (strind == nextCharacter)
2200 return (0);
2201 strind = nextCharacter;
2202 mask |= XNegative;
2203
2204 }
2205 else
2206 {
2207 strind++;
2208 tempX = read_integer (strind, &nextCharacter);
2209 if (strind == nextCharacter)
2210 return (0);
2211 strind = nextCharacter;
2212 }
2213 mask |= XValue;
2214 if ((*strind == '+') || (*strind == '-'))
2215 {
2216 if (*strind == '-')
2217 {
2218 strind++;
2219 tempY = -read_integer (strind, &nextCharacter);
2220 if (strind == nextCharacter)
2221 return (0);
2222 strind = nextCharacter;
2223 mask |= YNegative;
2224
2225 }
2226 else
2227 {
2228 strind++;
2229 tempY = read_integer (strind, &nextCharacter);
2230 if (strind == nextCharacter)
2231 return (0);
2232 strind = nextCharacter;
2233 }
2234 mask |= YValue;
2235 }
2236 }
2237
2238 /* If strind isn't at the end of the string the it's an invalid
2239 geometry specification. */
2240
2241 if (*strind != '\0') return (0);
2242
2243 if (mask & XValue)
2244 *x = tempX;
2245 if (mask & YValue)
2246 *y = tempY;
2247 if (mask & WidthValue)
2248 *width = tempWidth;
2249 if (mask & HeightValue)
2250 *height = tempHeight;
2251 return (mask);
2252 }
2253
2254 \f
2255 /* Create and set up the Mac window for frame F. */
2256
2257 static void
2258 mac_window (f)
2259 struct frame *f;
2260 {
2261 Rect r;
2262
2263 BLOCK_INPUT;
2264
2265 SetRect (&r, f->left_pos, f->top_pos,
2266 f->left_pos + FRAME_PIXEL_WIDTH (f),
2267 f->top_pos + FRAME_PIXEL_HEIGHT (f));
2268 #if TARGET_API_MAC_CARBON
2269 CreateNewWindow (kDocumentWindowClass,
2270 kWindowStandardDocumentAttributes
2271 #ifdef MAC_OSX
2272 | kWindowToolbarButtonAttribute
2273 #endif
2274 , &r, &FRAME_MAC_WINDOW (f));
2275 if (FRAME_MAC_WINDOW (f))
2276 {
2277 SetWRefCon (FRAME_MAC_WINDOW (f), (long) f->output_data.mac);
2278 if (install_window_handler (FRAME_MAC_WINDOW (f)) != noErr)
2279 {
2280 DisposeWindow (FRAME_MAC_WINDOW (f));
2281 FRAME_MAC_WINDOW (f) = NULL;
2282 }
2283 }
2284 #else
2285 FRAME_MAC_WINDOW (f)
2286 = NewCWindow (NULL, &r, "\p", false, zoomDocProc,
2287 (WindowPtr) -1, 1, (long) f->output_data.mac);
2288 #endif
2289 /* so that update events can find this mac_output struct */
2290 f->output_data.mac->mFP = f; /* point back to emacs frame */
2291
2292 #ifndef MAC_OSX
2293 if (FRAME_MAC_WINDOW (f))
2294 {
2295 ControlRef root_control;
2296
2297 if (CreateRootControl (FRAME_MAC_WINDOW (f), &root_control) != noErr)
2298 {
2299 DisposeWindow (FRAME_MAC_WINDOW (f));
2300 FRAME_MAC_WINDOW (f) = NULL;
2301 }
2302 }
2303 #endif
2304 if (FRAME_MAC_WINDOW (f))
2305 XSetWindowBackground (FRAME_MAC_DISPLAY(f), FRAME_MAC_WINDOW (f),
2306 FRAME_BACKGROUND_PIXEL (f));
2307
2308 validate_x_resource_name ();
2309
2310 /* x_set_name normally ignores requests to set the name if the
2311 requested name is the same as the current name. This is the one
2312 place where that assumption isn't correct; f->name is set, but
2313 the server hasn't been told. */
2314 {
2315 Lisp_Object name;
2316 int explicit = f->explicit_name;
2317
2318 f->explicit_name = 0;
2319 name = f->name;
2320 f->name = Qnil;
2321 x_set_name (f, name, explicit);
2322 }
2323
2324 UNBLOCK_INPUT;
2325
2326 if (FRAME_MAC_WINDOW (f) == 0)
2327 error ("Unable to create window");
2328 }
2329
2330 /* Handle the icon stuff for this window. Perhaps later we might
2331 want an x_set_icon_position which can be called interactively as
2332 well. */
2333
2334 static void
2335 x_icon (f, parms)
2336 struct frame *f;
2337 Lisp_Object parms;
2338 {
2339 Lisp_Object icon_x, icon_y;
2340
2341 /* Set the position of the icon. Note that Windows 95 groups all
2342 icons in the tray. */
2343 icon_x = mac_get_arg (parms, Qicon_left, 0, 0, RES_TYPE_NUMBER);
2344 icon_y = mac_get_arg (parms, Qicon_top, 0, 0, RES_TYPE_NUMBER);
2345 if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
2346 {
2347 CHECK_NUMBER (icon_x);
2348 CHECK_NUMBER (icon_y);
2349 }
2350 else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
2351 error ("Both left and top icon corners of icon must be specified");
2352
2353 BLOCK_INPUT;
2354
2355 if (! EQ (icon_x, Qunbound))
2356 x_wm_set_icon_position (f, XINT (icon_x), XINT (icon_y));
2357
2358 #if 0 /* TODO */
2359 /* Start up iconic or window? */
2360 x_wm_set_window_state
2361 (f, (EQ (w32_get_arg (parms, Qvisibility, 0, 0, RES_TYPE_SYMBOL), Qicon)
2362 ? IconicState
2363 : NormalState));
2364
2365 x_text_icon (f, (char *) SDATA ((!NILP (f->icon_name)
2366 ? f->icon_name
2367 : f->name)));
2368 #endif
2369
2370 UNBLOCK_INPUT;
2371 }
2372
2373
2374 void
2375 x_make_gc (f)
2376 struct frame *f;
2377 {
2378 XGCValues gc_values;
2379
2380 BLOCK_INPUT;
2381
2382 /* Create the GCs of this frame.
2383 Note that many default values are used. */
2384
2385 /* Normal video */
2386 gc_values.font = FRAME_FONT (f);
2387 gc_values.foreground = FRAME_FOREGROUND_PIXEL (f);
2388 gc_values.background = FRAME_BACKGROUND_PIXEL (f);
2389 f->output_data.mac->normal_gc = XCreateGC (FRAME_MAC_DISPLAY (f),
2390 FRAME_MAC_WINDOW (f),
2391 GCFont | GCForeground | GCBackground,
2392 &gc_values);
2393
2394 /* Reverse video style. */
2395 gc_values.foreground = FRAME_BACKGROUND_PIXEL (f);
2396 gc_values.background = FRAME_FOREGROUND_PIXEL (f);
2397 f->output_data.mac->reverse_gc = XCreateGC (FRAME_MAC_DISPLAY (f),
2398 FRAME_MAC_WINDOW (f),
2399 GCFont | GCForeground | GCBackground,
2400 &gc_values);
2401
2402 /* Cursor has cursor-color background, background-color foreground. */
2403 gc_values.foreground = FRAME_BACKGROUND_PIXEL (f);
2404 gc_values.background = f->output_data.mac->cursor_pixel;
2405 f->output_data.mac->cursor_gc = XCreateGC (FRAME_MAC_DISPLAY (f),
2406 FRAME_MAC_WINDOW (f),
2407 GCFont | GCForeground | GCBackground,
2408 &gc_values);
2409
2410 /* Reliefs. */
2411 f->output_data.mac->white_relief.gc = 0;
2412 f->output_data.mac->black_relief.gc = 0;
2413
2414 #if 0
2415 /* Create the gray border tile used when the pointer is not in
2416 the frame. Since this depends on the frame's pixel values,
2417 this must be done on a per-frame basis. */
2418 f->output_data.x->border_tile
2419 = (XCreatePixmapFromBitmapData
2420 (FRAME_X_DISPLAY (f), FRAME_X_DISPLAY_INFO (f)->root_window,
2421 gray_bits, gray_width, gray_height,
2422 f->output_data.x->foreground_pixel,
2423 f->output_data.x->background_pixel,
2424 DefaultDepth (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f))));
2425 #endif
2426
2427 UNBLOCK_INPUT;
2428 }
2429
2430
2431 /* Free what was was allocated in x_make_gc. */
2432
2433 void
2434 x_free_gcs (f)
2435 struct frame *f;
2436 {
2437 Display *dpy = FRAME_MAC_DISPLAY (f);
2438
2439 BLOCK_INPUT;
2440
2441 if (f->output_data.mac->normal_gc)
2442 {
2443 XFreeGC (dpy, f->output_data.mac->normal_gc);
2444 f->output_data.mac->normal_gc = 0;
2445 }
2446
2447 if (f->output_data.mac->reverse_gc)
2448 {
2449 XFreeGC (dpy, f->output_data.mac->reverse_gc);
2450 f->output_data.mac->reverse_gc = 0;
2451 }
2452
2453 if (f->output_data.mac->cursor_gc)
2454 {
2455 XFreeGC (dpy, f->output_data.mac->cursor_gc);
2456 f->output_data.mac->cursor_gc = 0;
2457 }
2458
2459 #if 0
2460 if (f->output_data.mac->border_tile)
2461 {
2462 XFreePixmap (dpy, f->output_data.mac->border_tile);
2463 f->output_data.mac->border_tile = 0;
2464 }
2465 #endif
2466
2467 if (f->output_data.mac->white_relief.gc)
2468 {
2469 XFreeGC (dpy, f->output_data.mac->white_relief.gc);
2470 f->output_data.mac->white_relief.gc = 0;
2471 }
2472
2473 if (f->output_data.mac->black_relief.gc)
2474 {
2475 XFreeGC (dpy, f->output_data.mac->black_relief.gc);
2476 f->output_data.mac->black_relief.gc = 0;
2477 }
2478
2479 UNBLOCK_INPUT;
2480 }
2481
2482
2483 /* Handler for signals raised during x_create_frame and
2484 x_create_top_frame. FRAME is the frame which is partially
2485 constructed. */
2486
2487 static Lisp_Object
2488 unwind_create_frame (frame)
2489 Lisp_Object frame;
2490 {
2491 struct frame *f = XFRAME (frame);
2492
2493 /* If frame is ``official'', nothing to do. */
2494 if (!CONSP (Vframe_list) || !EQ (XCAR (Vframe_list), frame))
2495 {
2496 #if GLYPH_DEBUG
2497 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
2498 #endif
2499
2500 x_free_frame_resources (f);
2501
2502 #if GLYPH_DEBUG
2503 /* Check that reference counts are indeed correct. */
2504 xassert (dpyinfo->reference_count == dpyinfo_refcount);
2505 xassert (dpyinfo->image_cache->refcount == image_cache_refcount);
2506 #endif
2507 return Qt;
2508 }
2509
2510 return Qnil;
2511 }
2512
2513
2514 DEFUN ("x-create-frame", Fx_create_frame, Sx_create_frame,
2515 1, 1, 0,
2516 doc: /* Make a new window, which is called a "frame" in Emacs terms.
2517 Returns an Emacs frame object.
2518 ALIST is an alist of frame parameters.
2519 If the parameters specify that the frame should not have a minibuffer,
2520 and do not specify a specific minibuffer window to use,
2521 then `default-minibuffer-frame' must be a frame whose minibuffer can
2522 be shared by the new frame.
2523
2524 This function is an internal primitive--use `make-frame' instead. */)
2525 (parms)
2526 Lisp_Object parms;
2527 {
2528 struct frame *f;
2529 Lisp_Object frame, tem;
2530 Lisp_Object name;
2531 int minibuffer_only = 0;
2532 long window_prompting = 0;
2533 int width, height;
2534 int count = SPECPDL_INDEX ();
2535 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
2536 Lisp_Object display;
2537 struct mac_display_info *dpyinfo = NULL;
2538 Lisp_Object parent;
2539 struct kboard *kb;
2540
2541 check_mac ();
2542
2543 parms = Fcopy_alist (parms);
2544
2545 /* Use this general default value to start with
2546 until we know if this frame has a specified name. */
2547 Vx_resource_name = Vinvocation_name;
2548
2549 display = mac_get_arg (parms, Qdisplay, 0, 0, RES_TYPE_STRING);
2550 if (EQ (display, Qunbound))
2551 display = Qnil;
2552 dpyinfo = check_x_display_info (display);
2553 #ifdef MULTI_KBOARD
2554 kb = dpyinfo->kboard;
2555 #else
2556 kb = &the_only_kboard;
2557 #endif
2558
2559 name = mac_get_arg (parms, Qname, "name", "Name", RES_TYPE_STRING);
2560 if (!STRINGP (name)
2561 && ! EQ (name, Qunbound)
2562 && ! NILP (name))
2563 error ("Invalid frame name--not a string or nil");
2564
2565 if (STRINGP (name))
2566 Vx_resource_name = name;
2567
2568 /* See if parent window is specified. */
2569 parent = mac_get_arg (parms, Qparent_id, NULL, NULL, RES_TYPE_NUMBER);
2570 if (EQ (parent, Qunbound))
2571 parent = Qnil;
2572 if (! NILP (parent))
2573 CHECK_NUMBER (parent);
2574
2575 /* make_frame_without_minibuffer can run Lisp code and garbage collect. */
2576 /* No need to protect DISPLAY because that's not used after passing
2577 it to make_frame_without_minibuffer. */
2578 frame = Qnil;
2579 GCPRO4 (parms, parent, name, frame);
2580 tem = mac_get_arg (parms, Qminibuffer, "minibuffer", "Minibuffer",
2581 RES_TYPE_SYMBOL);
2582 if (EQ (tem, Qnone) || NILP (tem))
2583 f = make_frame_without_minibuffer (Qnil, kb, display);
2584 else if (EQ (tem, Qonly))
2585 {
2586 f = make_minibuffer_frame ();
2587 minibuffer_only = 1;
2588 }
2589 else if (WINDOWP (tem))
2590 f = make_frame_without_minibuffer (tem, kb, display);
2591 else
2592 f = make_frame (1);
2593
2594 XSETFRAME (frame, f);
2595
2596 /* Note that X Windows does support scroll bars. */
2597 FRAME_CAN_HAVE_SCROLL_BARS (f) = 1;
2598
2599 f->output_method = output_mac;
2600 f->output_data.mac = (struct mac_output *) xmalloc (sizeof (struct mac_output));
2601 bzero (f->output_data.mac, sizeof (struct mac_output));
2602 FRAME_FONTSET (f) = -1;
2603
2604 f->icon_name
2605 = mac_get_arg (parms, Qicon_name, "iconName", "Title", RES_TYPE_STRING);
2606 if (! STRINGP (f->icon_name))
2607 f->icon_name = Qnil;
2608
2609 /* FRAME_MAC_DISPLAY_INFO (f) = dpyinfo; */
2610
2611 /* With FRAME_MAC_DISPLAY_INFO set up, this unwind-protect is safe. */
2612 record_unwind_protect (unwind_create_frame, frame);
2613 #if GLYPH_DEBUG
2614 image_cache_refcount = FRAME_X_IMAGE_CACHE (f)->refcount;
2615 dpyinfo_refcount = dpyinfo->reference_count;
2616 #endif /* GLYPH_DEBUG */
2617 #ifdef MULTI_KBOARD
2618 FRAME_KBOARD (f) = kb;
2619 #endif
2620
2621 /* Specify the parent under which to make this window. */
2622
2623 if (!NILP (parent))
2624 {
2625 f->output_data.mac->parent_desc = (Window) XFASTINT (parent);
2626 f->output_data.mac->explicit_parent = 1;
2627 }
2628 else
2629 {
2630 f->output_data.mac->parent_desc = FRAME_MAC_DISPLAY_INFO (f)->root_window;
2631 f->output_data.mac->explicit_parent = 0;
2632 }
2633
2634 /* Set the name; the functions to which we pass f expect the name to
2635 be set. */
2636 if (EQ (name, Qunbound) || NILP (name))
2637 {
2638 f->name = build_string (dpyinfo->mac_id_name);
2639 f->explicit_name = 0;
2640 }
2641 else
2642 {
2643 f->name = name;
2644 f->explicit_name = 1;
2645 /* use the frame's title when getting resources for this frame. */
2646 specbind (Qx_resource_name, name);
2647 }
2648
2649 /* Extract the window parameters from the supplied values
2650 that are needed to determine window geometry. */
2651 {
2652 Lisp_Object font;
2653
2654 font = mac_get_arg (parms, Qfont, "font", "Font", RES_TYPE_STRING);
2655
2656 BLOCK_INPUT;
2657 /* First, try whatever font the caller has specified. */
2658 if (STRINGP (font))
2659 {
2660 tem = Fquery_fontset (font, Qnil);
2661 if (STRINGP (tem))
2662 font = x_new_fontset (f, SDATA (tem));
2663 else
2664 font = x_new_font (f, SDATA (font));
2665 }
2666
2667 /* Try out a font which we hope has bold and italic variations. */
2668 #if USE_ATSUI
2669 if (! STRINGP (font))
2670 font = x_new_font (f, "-*-monaco-medium-r-normal--12-*-*-*-*-*-iso10646-1");
2671 #endif
2672 if (! STRINGP (font))
2673 font = x_new_font (f, "-ETL-fixed-medium-r-*--*-160-*-*-*-*-iso8859-1");
2674 /* If those didn't work, look for something which will at least work. */
2675 if (! STRINGP (font))
2676 font = x_new_fontset (f, "fontset-standard");
2677 if (! STRINGP (font))
2678 font = x_new_font (f, "-*-monaco-*-12-*-mac-roman");
2679 if (! STRINGP (font))
2680 font = x_new_font (f, "-*-courier-*-10-*-mac-roman");
2681 if (! STRINGP (font))
2682 error ("Cannot find any usable font");
2683 UNBLOCK_INPUT;
2684
2685 x_set_frame_parameters (f, Fcons (Fcons (Qfont, font), Qnil));
2686 }
2687
2688 x_default_parameter (f, parms, Qborder_width, make_number (0),
2689 "borderwidth", "BorderWidth", RES_TYPE_NUMBER);
2690 /* This defaults to 2 in order to match xterm. We recognize either
2691 internalBorderWidth or internalBorder (which is what xterm calls
2692 it). */
2693 if (NILP (Fassq (Qinternal_border_width, parms)))
2694 {
2695 Lisp_Object value;
2696
2697 value = mac_get_arg (parms, Qinternal_border_width,
2698 "internalBorder", "InternalBorder", RES_TYPE_NUMBER);
2699 if (! EQ (value, Qunbound))
2700 parms = Fcons (Fcons (Qinternal_border_width, value),
2701 parms);
2702 }
2703 /* Default internalBorderWidth to 0 on Windows to match other programs. */
2704 x_default_parameter (f, parms, Qinternal_border_width, make_number (0),
2705 "internalBorderWidth", "InternalBorder", RES_TYPE_NUMBER);
2706 x_default_parameter (f, parms, Qvertical_scroll_bars, Qright,
2707 "verticalScrollBars", "ScrollBars", RES_TYPE_SYMBOL);
2708
2709 /* Also do the stuff which must be set before the window exists. */
2710 x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
2711 "foreground", "Foreground", RES_TYPE_STRING);
2712 x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
2713 "background", "Background", RES_TYPE_STRING);
2714 x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
2715 "pointerColor", "Foreground", RES_TYPE_STRING);
2716 x_default_parameter (f, parms, Qcursor_color, build_string ("black"),
2717 "cursorColor", "Foreground", RES_TYPE_STRING);
2718 x_default_parameter (f, parms, Qborder_color, build_string ("black"),
2719 "borderColor", "BorderColor", RES_TYPE_STRING);
2720 x_default_parameter (f, parms, Qscreen_gamma, Qnil,
2721 "screenGamma", "ScreenGamma", RES_TYPE_FLOAT);
2722 x_default_parameter (f, parms, Qline_spacing, Qnil,
2723 "lineSpacing", "LineSpacing", RES_TYPE_NUMBER);
2724 x_default_parameter (f, parms, Qleft_fringe, Qnil,
2725 "leftFringe", "LeftFringe", RES_TYPE_NUMBER);
2726 x_default_parameter (f, parms, Qright_fringe, Qnil,
2727 "rightFringe", "RightFringe", RES_TYPE_NUMBER);
2728
2729
2730 /* Init faces before x_default_parameter is called for scroll-bar
2731 parameters because that function calls x_set_scroll_bar_width,
2732 which calls change_frame_size, which calls Fset_window_buffer,
2733 which runs hooks, which call Fvertical_motion. At the end, we
2734 end up in init_iterator with a null face cache, which should not
2735 happen. */
2736 init_frame_faces (f);
2737
2738 x_default_parameter (f, parms, Qmenu_bar_lines, make_number (1),
2739 "menuBar", "MenuBar", RES_TYPE_NUMBER);
2740 x_default_parameter (f, parms, Qtool_bar_lines, make_number (1),
2741 "toolBar", "ToolBar", RES_TYPE_NUMBER);
2742 x_default_parameter (f, parms, Qbuffer_predicate, Qnil,
2743 "bufferPredicate", "BufferPredicate",
2744 RES_TYPE_SYMBOL);
2745 x_default_parameter (f, parms, Qtitle, Qnil,
2746 "title", "Title", RES_TYPE_STRING);
2747 x_default_parameter (f, parms, Qfullscreen, Qnil,
2748 "fullscreen", "Fullscreen", RES_TYPE_SYMBOL);
2749
2750 f->output_data.mac->parent_desc = FRAME_MAC_DISPLAY_INFO (f)->root_window;
2751
2752 /* Compute the size of the window. */
2753 window_prompting = x_figure_window_size (f, parms, 1);
2754
2755 tem = mac_get_arg (parms, Qunsplittable, 0, 0, RES_TYPE_BOOLEAN);
2756 f->no_split = minibuffer_only || EQ (tem, Qt);
2757
2758 mac_window (f);
2759
2760 x_icon (f, parms);
2761 x_make_gc (f);
2762
2763 /* Now consider the frame official. */
2764 FRAME_MAC_DISPLAY_INFO (f)->reference_count++;
2765 Vframe_list = Fcons (frame, Vframe_list);
2766
2767 /* We need to do this after creating the window, so that the
2768 icon-creation functions can say whose icon they're describing. */
2769 x_default_parameter (f, parms, Qicon_type, Qnil,
2770 "bitmapIcon", "BitmapIcon", RES_TYPE_SYMBOL);
2771
2772 x_default_parameter (f, parms, Qauto_raise, Qnil,
2773 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
2774 x_default_parameter (f, parms, Qauto_lower, Qnil,
2775 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
2776 x_default_parameter (f, parms, Qcursor_type, Qbox,
2777 "cursorType", "CursorType", RES_TYPE_SYMBOL);
2778 x_default_parameter (f, parms, Qscroll_bar_width, Qnil,
2779 "scrollBarWidth", "ScrollBarWidth",
2780 RES_TYPE_NUMBER);
2781
2782 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
2783 Change will not be effected unless different from the current
2784 FRAME_LINES (f). */
2785 width = FRAME_COLS (f);
2786 height = FRAME_LINES (f);
2787
2788 SET_FRAME_COLS (f, 0);
2789 FRAME_LINES (f) = 0;
2790 change_frame_size (f, height, width, 1, 0, 0);
2791
2792 /* Tell the server what size and position, etc, we want, and how
2793 badly we want them. This should be done after we have the menu
2794 bar so that its size can be taken into account. */
2795 BLOCK_INPUT;
2796 x_wm_set_size_hint (f, window_prompting, 0);
2797 UNBLOCK_INPUT;
2798
2799 /* Make the window appear on the frame and enable display, unless
2800 the caller says not to. However, with explicit parent, Emacs
2801 cannot control visibility, so don't try. */
2802 if (! f->output_data.mac->explicit_parent)
2803 {
2804 Lisp_Object visibility;
2805
2806 visibility = mac_get_arg (parms, Qvisibility, 0, 0, RES_TYPE_SYMBOL);
2807 if (EQ (visibility, Qunbound))
2808 visibility = Qt;
2809
2810 if (EQ (visibility, Qicon))
2811 x_iconify_frame (f);
2812 else if (! NILP (visibility))
2813 x_make_frame_visible (f);
2814 else
2815 /* Must have been Qnil. */
2816 ;
2817 }
2818
2819 /* Initialize `default-minibuffer-frame' in case this is the first
2820 frame on this display device. */
2821 if (FRAME_HAS_MINIBUF_P (f)
2822 && (!FRAMEP (kb->Vdefault_minibuffer_frame)
2823 || !FRAME_LIVE_P (XFRAME (kb->Vdefault_minibuffer_frame))))
2824 kb->Vdefault_minibuffer_frame = frame;
2825
2826 /* All remaining specified parameters, which have not been "used"
2827 by x_get_arg and friends, now go in the misc. alist of the frame. */
2828 for (tem = parms; !NILP (tem); tem = XCDR (tem))
2829 if (CONSP (XCAR (tem)) && !NILP (XCAR (XCAR (tem))))
2830 f->param_alist = Fcons (XCAR (tem), f->param_alist);
2831
2832 UNGCPRO;
2833
2834 /* Make sure windows on this frame appear in calls to next-window
2835 and similar functions. */
2836 Vwindow_list = Qnil;
2837
2838 return unbind_to (count, frame);
2839 }
2840
2841
2842 /* FRAME is used only to get a handle on the X display. We don't pass the
2843 display info directly because we're called from frame.c, which doesn't
2844 know about that structure. */
2845
2846 Lisp_Object
2847 x_get_focus_frame (frame)
2848 struct frame *frame;
2849 {
2850 struct mac_display_info *dpyinfo = FRAME_MAC_DISPLAY_INFO (frame);
2851 Lisp_Object xfocus;
2852 if (! dpyinfo->x_focus_frame)
2853 return Qnil;
2854
2855 XSETFRAME (xfocus, dpyinfo->x_focus_frame);
2856 return xfocus;
2857 }
2858
2859
2860 DEFUN ("x-focus-frame", Fx_focus_frame, Sx_focus_frame, 1, 1, 0,
2861 doc: /* Set the input focus to FRAME.
2862 FRAME nil means use the selected frame. */)
2863 (frame)
2864 Lisp_Object frame;
2865 {
2866 OSErr err;
2867 ProcessSerialNumber front_psn;
2868 static const ProcessSerialNumber current_psn = {0, kCurrentProcess};
2869 Boolean front_p;
2870 struct frame *f = check_x_frame (frame);
2871
2872 BLOCK_INPUT;
2873 /* Move the current process to the foreground if it is not. Don't
2874 call SetFrontProcess if the current process is already running in
2875 the foreground so as not to change the z-order of windows. */
2876 err = GetFrontProcess (&front_psn);
2877 if (err == noErr)
2878 err = SameProcess (&front_psn, &current_psn, &front_p);
2879 if (err == noErr)
2880 if (!front_p)
2881 {
2882 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
2883 if (FrontNonFloatingWindow () == FRAME_MAC_WINDOW (f))
2884 SetFrontProcessWithOptions (&current_psn,
2885 kSetFrontProcessFrontWindowOnly);
2886 else
2887 #endif
2888 SetFrontProcess (&current_psn);
2889 }
2890
2891 #ifdef MAC_OSX
2892 ActivateWindow (ActiveNonFloatingWindow (), false);
2893 ActivateWindow (FRAME_MAC_WINDOW (f), true);
2894 #else
2895 #if !TARGET_API_MAC_CARBON
2896 /* SelectWindow (Non-Carbon) does not issue deactivate events if the
2897 possibly inactive window that is to be selected is already the
2898 frontmost one. */
2899 SendBehind (FRAME_MAC_WINDOW (f), NULL);
2900 #endif
2901 /* This brings the window to the front. */
2902 SelectWindow (FRAME_MAC_WINDOW (f));
2903 #endif
2904 UNBLOCK_INPUT;
2905
2906 return Qnil;
2907 }
2908
2909 \f
2910 DEFUN ("xw-color-defined-p", Fxw_color_defined_p, Sxw_color_defined_p, 1, 2, 0,
2911 doc: /* Internal function called by `color-defined-p', which see. */)
2912 (color, frame)
2913 Lisp_Object color, frame;
2914 {
2915 XColor foo;
2916 FRAME_PTR f = check_x_frame (frame);
2917
2918 CHECK_STRING (color);
2919
2920 if (mac_defined_color (f, SDATA (color), &foo, 0))
2921 return Qt;
2922 else
2923 return Qnil;
2924 }
2925
2926 DEFUN ("xw-color-values", Fxw_color_values, Sxw_color_values, 1, 2, 0,
2927 doc: /* Internal function called by `color-values', which see. */)
2928 (color, frame)
2929 Lisp_Object color, frame;
2930 {
2931 XColor foo;
2932 FRAME_PTR f = check_x_frame (frame);
2933
2934 CHECK_STRING (color);
2935
2936 if (mac_defined_color (f, SDATA (color), &foo, 0))
2937 return list3 (make_number (foo.red),
2938 make_number (foo.green),
2939 make_number (foo.blue));
2940 else
2941 return Qnil;
2942 }
2943
2944 DEFUN ("xw-display-color-p", Fxw_display_color_p, Sxw_display_color_p, 0, 1, 0,
2945 doc: /* Internal function called by `display-color-p', which see. */)
2946 (display)
2947 Lisp_Object display;
2948 {
2949 struct mac_display_info *dpyinfo = check_x_display_info (display);
2950
2951 if (!dpyinfo->color_p)
2952 return Qnil;
2953
2954 return Qt;
2955 }
2956
2957 DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p, Sx_display_grayscale_p,
2958 0, 1, 0,
2959 doc: /* Return t if DISPLAY supports shades of gray.
2960 Note that color displays do support shades of gray.
2961 The optional argument DISPLAY specifies which display to ask about.
2962 DISPLAY should be either a frame or a display name (a string).
2963 If omitted or nil, that stands for the selected frame's display. */)
2964 (display)
2965 Lisp_Object display;
2966 {
2967 struct mac_display_info *dpyinfo = check_x_display_info (display);
2968
2969 if (dpyinfo->n_planes <= 1)
2970 return Qnil;
2971
2972 return Qt;
2973 }
2974
2975 DEFUN ("x-display-pixel-width", Fx_display_pixel_width, Sx_display_pixel_width,
2976 0, 1, 0,
2977 doc: /* Returns the width in pixels of DISPLAY.
2978 The optional argument DISPLAY specifies which display to ask about.
2979 DISPLAY should be either a frame or a display name (a string).
2980 If omitted or nil, that stands for the selected frame's display. */)
2981 (display)
2982 Lisp_Object display;
2983 {
2984 struct mac_display_info *dpyinfo = check_x_display_info (display);
2985
2986 return make_number (dpyinfo->width);
2987 }
2988
2989 DEFUN ("x-display-pixel-height", Fx_display_pixel_height,
2990 Sx_display_pixel_height, 0, 1, 0,
2991 doc: /* Returns the height in pixels of DISPLAY.
2992 The optional argument DISPLAY specifies which display to ask about.
2993 DISPLAY should be either a frame or a display name (a string).
2994 If omitted or nil, that stands for the selected frame's display. */)
2995 (display)
2996 Lisp_Object display;
2997 {
2998 struct mac_display_info *dpyinfo = check_x_display_info (display);
2999
3000 return make_number (dpyinfo->height);
3001 }
3002
3003 DEFUN ("x-display-planes", Fx_display_planes, Sx_display_planes,
3004 0, 1, 0,
3005 doc: /* Returns the number of bitplanes of DISPLAY.
3006 The optional argument DISPLAY specifies which display to ask about.
3007 DISPLAY should be either a frame or a display name (a string).
3008 If omitted or nil, that stands for the selected frame's display. */)
3009 (display)
3010 Lisp_Object display;
3011 {
3012 struct mac_display_info *dpyinfo = check_x_display_info (display);
3013
3014 return make_number (dpyinfo->n_planes);
3015 }
3016
3017 DEFUN ("x-display-color-cells", Fx_display_color_cells, Sx_display_color_cells,
3018 0, 1, 0,
3019 doc: /* Returns the number of color cells of DISPLAY.
3020 The optional argument DISPLAY specifies which display to ask about.
3021 DISPLAY should be either a frame or a display name (a string).
3022 If omitted or nil, that stands for the selected frame's display. */)
3023 (display)
3024 Lisp_Object display;
3025 {
3026 struct mac_display_info *dpyinfo = check_x_display_info (display);
3027
3028 /* We force 24+ bit depths to 24-bit to prevent an overflow. */
3029 return make_number (1 << min (dpyinfo->n_planes, 24));
3030 }
3031
3032 DEFUN ("x-server-max-request-size", Fx_server_max_request_size,
3033 Sx_server_max_request_size,
3034 0, 1, 0,
3035 doc: /* Returns the maximum request size of the server of DISPLAY.
3036 The optional argument DISPLAY specifies which display to ask about.
3037 DISPLAY should be either a frame or a display name (a string).
3038 If omitted or nil, that stands for the selected frame's display. */)
3039 (display)
3040 Lisp_Object display;
3041 {
3042 struct mac_display_info *dpyinfo = check_x_display_info (display);
3043
3044 return make_number (1);
3045 }
3046
3047 DEFUN ("x-server-vendor", Fx_server_vendor, Sx_server_vendor, 0, 1, 0,
3048 doc: /* Returns the "vendor ID" string of the Mac OS system (Apple).
3049 The optional argument DISPLAY specifies which display to ask about.
3050 DISPLAY should be either a frame or a display name (a string).
3051 If omitted or nil, that stands for the selected frame's display. */)
3052 (display)
3053 Lisp_Object display;
3054 {
3055 return build_string ("Apple Computers");
3056 }
3057
3058 DEFUN ("x-server-version", Fx_server_version, Sx_server_version, 0, 1, 0,
3059 doc: /* Returns the version numbers of the Mac OS system.
3060 The value is a list of three integers: the major and minor
3061 version numbers, and the vendor-specific release
3062 number. See also the function `x-server-vendor'.
3063
3064 The optional argument DISPLAY specifies which display to ask about.
3065 DISPLAY should be either a frame or a display name (a string).
3066 If omitted or nil, that stands for the selected frame's display. */)
3067 (display)
3068 Lisp_Object display;
3069 {
3070 UInt32 response, major, minor, bugfix;
3071 OSErr err;
3072
3073 BLOCK_INPUT;
3074 err = Gestalt (gestaltSystemVersion, &response);
3075 if (err == noErr)
3076 {
3077 if (response >= 0x00001040)
3078 {
3079 err = Gestalt (gestaltSystemVersionMajor, &major);
3080 if (err == noErr)
3081 err = Gestalt (gestaltSystemVersionMinor, &minor);
3082 if (err == noErr)
3083 err = Gestalt (gestaltSystemVersionBugFix, &bugfix);
3084 }
3085 else
3086 {
3087 bugfix = response & 0xf;
3088 response >>= 4;
3089 minor = response & 0xf;
3090 response >>= 4;
3091 /* convert BCD to int */
3092 major = response - (response >> 4) * 6;
3093 }
3094 }
3095 UNBLOCK_INPUT;
3096
3097 if (err != noErr)
3098 error ("Cannot get Mac OS version");
3099
3100 return Fcons (make_number (major),
3101 Fcons (make_number (minor),
3102 Fcons (make_number (bugfix),
3103 Qnil)));
3104 }
3105
3106 DEFUN ("x-display-screens", Fx_display_screens, Sx_display_screens, 0, 1, 0,
3107 doc: /* Return the number of screens on the server of DISPLAY.
3108 The optional argument DISPLAY specifies which display to ask about.
3109 DISPLAY should be either a frame or a display name (a string).
3110 If omitted or nil, that stands for the selected frame's display. */)
3111 (display)
3112 Lisp_Object display;
3113 {
3114 return make_number (1);
3115 }
3116
3117 DEFUN ("x-display-mm-height", Fx_display_mm_height, Sx_display_mm_height, 0, 1, 0,
3118 doc: /* Return the height in millimeters of DISPLAY.
3119 The optional argument DISPLAY specifies which display to ask about.
3120 DISPLAY should be either a frame or a display name (a string).
3121 If omitted or nil, that stands for the selected frame's display. */)
3122 (display)
3123 Lisp_Object display;
3124 {
3125 struct mac_display_info *dpyinfo = check_x_display_info (display);
3126
3127 /* Only of the main display. */
3128 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
3129 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
3130 if (CGDisplayScreenSize != NULL)
3131 #endif
3132 {
3133 CGSize size;
3134
3135 BLOCK_INPUT;
3136 size = CGDisplayScreenSize (kCGDirectMainDisplay);
3137 UNBLOCK_INPUT;
3138
3139 return make_number ((int) (size.height + .5f));
3140 }
3141 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
3142 else
3143 #endif
3144 #endif /* MAC_OS_X_VERSION_MAX_ALLOWED >= 1030 */
3145 #if MAC_OS_X_VERSION_MAX_ALLOWED < 1030 || MAC_OS_X_VERSION_MIN_REQUIRED == 1020
3146 {
3147 /* This is an approximation. */
3148 return make_number ((int) (dpyinfo->height * 25.4 / dpyinfo->resy));
3149 }
3150 #endif
3151 }
3152
3153 DEFUN ("x-display-mm-width", Fx_display_mm_width, Sx_display_mm_width, 0, 1, 0,
3154 doc: /* Return the width in millimeters of DISPLAY.
3155 The optional argument DISPLAY specifies which display to ask about.
3156 DISPLAY should be either a frame or a display name (a string).
3157 If omitted or nil, that stands for the selected frame's display. */)
3158 (display)
3159 Lisp_Object display;
3160 {
3161 struct mac_display_info *dpyinfo = check_x_display_info (display);
3162
3163 /* Only of the main display. */
3164 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
3165 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
3166 if (CGDisplayScreenSize != NULL)
3167 #endif
3168 {
3169 CGSize size;
3170
3171 BLOCK_INPUT;
3172 size = CGDisplayScreenSize (kCGDirectMainDisplay);
3173 UNBLOCK_INPUT;
3174
3175 return make_number ((int) (size.width + .5f));
3176 }
3177 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
3178 else
3179 #endif
3180 #endif /* MAC_OS_X_VERSION_MAX_ALLOWED >= 1030 */
3181 #if MAC_OS_X_VERSION_MAX_ALLOWED < 1030 || MAC_OS_X_VERSION_MIN_REQUIRED == 1020
3182 {
3183 /* This is an approximation. */
3184 return make_number ((int) (dpyinfo->width * 25.4 / dpyinfo->resx));
3185 }
3186 #endif
3187 }
3188
3189 DEFUN ("x-display-backing-store", Fx_display_backing_store,
3190 Sx_display_backing_store, 0, 1, 0,
3191 doc: /* Returns an indication of whether DISPLAY does backing store.
3192 The value may be `always', `when-mapped', or `not-useful'.
3193 The optional argument DISPLAY specifies which display to ask about.
3194 DISPLAY should be either a frame or a display name (a string).
3195 If omitted or nil, that stands for the selected frame's display. */)
3196 (display)
3197 Lisp_Object display;
3198 {
3199 return intern ("not-useful");
3200 }
3201
3202 DEFUN ("x-display-visual-class", Fx_display_visual_class,
3203 Sx_display_visual_class, 0, 1, 0,
3204 doc: /* Returns the visual class of DISPLAY.
3205 The value is one of the symbols `static-gray', `gray-scale',
3206 `static-color', `pseudo-color', `true-color', or `direct-color'.
3207
3208 The optional argument DISPLAY specifies which display to ask about.
3209 DISPLAY should be either a frame or a display name (a string).
3210 If omitted or nil, that stands for the selected frame's display. */)
3211 (display)
3212 Lisp_Object display;
3213 {
3214 struct mac_display_info *dpyinfo = check_x_display_info (display);
3215
3216 #if 0
3217 switch (dpyinfo->visual->class)
3218 {
3219 case StaticGray: return (intern ("static-gray"));
3220 case GrayScale: return (intern ("gray-scale"));
3221 case StaticColor: return (intern ("static-color"));
3222 case PseudoColor: return (intern ("pseudo-color"));
3223 case TrueColor: return (intern ("true-color"));
3224 case DirectColor: return (intern ("direct-color"));
3225 default:
3226 error ("Display has an unknown visual class");
3227 }
3228 #endif /* 0 */
3229
3230 return (intern ("true-color"));
3231 }
3232
3233 DEFUN ("x-display-save-under", Fx_display_save_under,
3234 Sx_display_save_under, 0, 1, 0,
3235 doc: /* Returns t if DISPLAY supports the save-under feature.
3236 The optional argument DISPLAY specifies which display to ask about.
3237 DISPLAY should be either a frame or a display name (a string).
3238 If omitted or nil, that stands for the selected frame's display. */)
3239 (display)
3240 Lisp_Object display;
3241 {
3242 return Qnil;
3243 }
3244 \f
3245 int
3246 x_pixel_width (f)
3247 register struct frame *f;
3248 {
3249 return FRAME_PIXEL_WIDTH (f);
3250 }
3251
3252 int
3253 x_pixel_height (f)
3254 register struct frame *f;
3255 {
3256 return FRAME_PIXEL_HEIGHT (f);
3257 }
3258
3259 int
3260 x_char_width (f)
3261 register struct frame *f;
3262 {
3263 return FRAME_COLUMN_WIDTH (f);
3264 }
3265
3266 int
3267 x_char_height (f)
3268 register struct frame *f;
3269 {
3270 return FRAME_LINE_HEIGHT (f);
3271 }
3272
3273 int
3274 x_screen_planes (f)
3275 register struct frame *f;
3276 {
3277 return FRAME_MAC_DISPLAY_INFO (f)->n_planes;
3278 }
3279 \f
3280 /* Return the display structure for the display named NAME.
3281 Open a new connection if necessary. */
3282
3283 struct mac_display_info *
3284 x_display_info_for_name (name)
3285 Lisp_Object name;
3286 {
3287 Lisp_Object names;
3288 struct mac_display_info *dpyinfo;
3289
3290 CHECK_STRING (name);
3291
3292 if (! EQ (Vwindow_system, intern ("mac")))
3293 error ("Not using Mac native windows");
3294
3295 for (dpyinfo = &one_mac_display_info, names = x_display_name_list;
3296 dpyinfo;
3297 dpyinfo = dpyinfo->next, names = XCDR (names))
3298 {
3299 Lisp_Object tem;
3300 tem = Fstring_equal (XCAR (XCAR (names)), name);
3301 if (!NILP (tem))
3302 return dpyinfo;
3303 }
3304
3305 /* Use this general default value to start with. */
3306 Vx_resource_name = Vinvocation_name;
3307
3308 validate_x_resource_name ();
3309
3310 dpyinfo = mac_term_init (name, (unsigned char *) 0,
3311 (char *) SDATA (Vx_resource_name));
3312
3313 if (dpyinfo == 0)
3314 error ("Cannot connect to server %s", SDATA (name));
3315
3316 mac_in_use = 1;
3317 XSETFASTINT (Vwindow_system_version, 3);
3318
3319 return dpyinfo;
3320 }
3321
3322 DEFUN ("x-open-connection", Fx_open_connection, Sx_open_connection,
3323 1, 3, 0,
3324 doc: /* Open a connection to a server.
3325 DISPLAY is the name of the display to connect to.
3326 Optional second arg XRM-STRING is a string of resources in xrdb format.
3327 If the optional third arg MUST-SUCCEED is non-nil,
3328 terminate Emacs if we can't open the connection. */)
3329 (display, xrm_string, must_succeed)
3330 Lisp_Object display, xrm_string, must_succeed;
3331 {
3332 unsigned char *xrm_option;
3333 struct mac_display_info *dpyinfo;
3334
3335 CHECK_STRING (display);
3336 if (! NILP (xrm_string))
3337 CHECK_STRING (xrm_string);
3338
3339 if (! EQ (Vwindow_system, intern ("mac")))
3340 error ("Not using Mac native windows");
3341
3342 if (! NILP (xrm_string))
3343 xrm_option = (unsigned char *) SDATA (xrm_string);
3344 else
3345 xrm_option = (unsigned char *) 0;
3346
3347 validate_x_resource_name ();
3348
3349 /* This is what opens the connection and sets x_current_display.
3350 This also initializes many symbols, such as those used for input. */
3351 dpyinfo = mac_term_init (display, xrm_option,
3352 (char *) SDATA (Vx_resource_name));
3353
3354 if (dpyinfo == 0)
3355 {
3356 if (!NILP (must_succeed))
3357 fatal ("Cannot connect to server %s.\n",
3358 SDATA (display));
3359 else
3360 error ("Cannot connect to server %s", SDATA (display));
3361 }
3362
3363 mac_in_use = 1;
3364
3365 XSETFASTINT (Vwindow_system_version, 3);
3366 return Qnil;
3367 }
3368
3369 DEFUN ("x-close-connection", Fx_close_connection,
3370 Sx_close_connection, 1, 1, 0,
3371 doc: /* Close the connection to DISPLAY's server.
3372 For DISPLAY, specify either a frame or a display name (a string).
3373 If DISPLAY is nil, that stands for the selected frame's display. */)
3374 (display)
3375 Lisp_Object display;
3376 {
3377 struct mac_display_info *dpyinfo = check_x_display_info (display);
3378 int i;
3379
3380 if (dpyinfo->reference_count > 0)
3381 error ("Display still has frames on it");
3382
3383 BLOCK_INPUT;
3384 /* Free the fonts in the font table. */
3385 for (i = 0; i < dpyinfo->n_fonts; i++)
3386 if (dpyinfo->font_table[i].name)
3387 {
3388 mac_unload_font (dpyinfo, dpyinfo->font_table[i].font);
3389 }
3390
3391 x_destroy_all_bitmaps (dpyinfo);
3392
3393 x_delete_display (dpyinfo);
3394 UNBLOCK_INPUT;
3395
3396 return Qnil;
3397 }
3398
3399 DEFUN ("x-display-list", Fx_display_list, Sx_display_list, 0, 0, 0,
3400 doc: /* Return the list of display names that Emacs has connections to. */)
3401 ()
3402 {
3403 Lisp_Object tail, result;
3404
3405 result = Qnil;
3406 for (tail = x_display_name_list; ! NILP (tail); tail = XCDR (tail))
3407 result = Fcons (XCAR (XCAR (tail)), result);
3408
3409 return result;
3410 }
3411
3412 DEFUN ("x-synchronize", Fx_synchronize, Sx_synchronize, 1, 2, 0,
3413 doc: /* This is a noop on Mac OS systems. */)
3414 (on, display)
3415 Lisp_Object display, on;
3416 {
3417 return Qnil;
3418 }
3419
3420 /* x_sync is a no-op on Mac. */
3421
3422 void
3423 x_sync (f)
3424 FRAME_PTR f;
3425 {
3426 }
3427
3428 \f
3429 /***********************************************************************
3430 Window properties
3431 ***********************************************************************/
3432
3433 DEFUN ("x-change-window-property", Fx_change_window_property,
3434 Sx_change_window_property, 2, 6, 0,
3435 doc: /* Change window property PROP to VALUE on the X window of FRAME.
3436 VALUE may be a string or a list of conses, numbers and/or strings.
3437 If an element in the list is a string, it is converted to
3438 an Atom and the value of the Atom is used. If an element is a cons,
3439 it is converted to a 32 bit number where the car is the 16 top bits and the
3440 cdr is the lower 16 bits.
3441 FRAME nil or omitted means use the selected frame.
3442 If TYPE is given and non-nil, it is the name of the type of VALUE.
3443 If TYPE is not given or nil, the type is STRING.
3444 FORMAT gives the size in bits of each element if VALUE is a list.
3445 It must be one of 8, 16 or 32.
3446 If VALUE is a string or FORMAT is nil or not given, FORMAT defaults to 8.
3447 If OUTER_P is non-nil, the property is changed for the outer X window of
3448 FRAME. Default is to change on the edit X window.
3449
3450 Value is VALUE. */)
3451 (prop, value, frame, type, format, outer_p)
3452 Lisp_Object prop, value, frame, type, format, outer_p;
3453 {
3454 #if 0 /* MAC_TODO : port window properties to Mac */
3455 struct frame *f = check_x_frame (frame);
3456 Atom prop_atom;
3457
3458 CHECK_STRING (prop);
3459 CHECK_STRING (value);
3460
3461 BLOCK_INPUT;
3462 prop_atom = XInternAtom (FRAME_W32_DISPLAY (f), SDATA (prop), False);
3463 XChangeProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
3464 prop_atom, XA_STRING, 8, PropModeReplace,
3465 SDATA (value), SCHARS (value));
3466
3467 /* Make sure the property is set when we return. */
3468 XFlush (FRAME_W32_DISPLAY (f));
3469 UNBLOCK_INPUT;
3470
3471 #endif /* MAC_TODO */
3472
3473 return value;
3474 }
3475
3476
3477 DEFUN ("x-delete-window-property", Fx_delete_window_property,
3478 Sx_delete_window_property, 1, 2, 0,
3479 doc: /* Remove window property PROP from X window of FRAME.
3480 FRAME nil or omitted means use the selected frame. Value is PROP. */)
3481 (prop, frame)
3482 Lisp_Object prop, frame;
3483 {
3484 #if 0 /* MAC_TODO : port window properties to Mac */
3485
3486 struct frame *f = check_x_frame (frame);
3487 Atom prop_atom;
3488
3489 CHECK_STRING (prop);
3490 BLOCK_INPUT;
3491 prop_atom = XInternAtom (FRAME_W32_DISPLAY (f), SDATA (prop), False);
3492 XDeleteProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f), prop_atom);
3493
3494 /* Make sure the property is removed when we return. */
3495 XFlush (FRAME_W32_DISPLAY (f));
3496 UNBLOCK_INPUT;
3497 #endif /* MAC_TODO */
3498
3499 return prop;
3500 }
3501
3502
3503 DEFUN ("x-window-property", Fx_window_property, Sx_window_property,
3504 1, 2, 0,
3505 doc: /* Value is the value of window property PROP on FRAME.
3506 If FRAME is nil or omitted, use the selected frame. Value is nil
3507 if FRAME hasn't a property with name PROP or if PROP has no string
3508 value. */)
3509 (prop, frame)
3510 Lisp_Object prop, frame;
3511 {
3512 #if 0 /* MAC_TODO : port window properties to Mac */
3513
3514 struct frame *f = check_x_frame (frame);
3515 Atom prop_atom;
3516 int rc;
3517 Lisp_Object prop_value = Qnil;
3518 char *tmp_data = NULL;
3519 Atom actual_type;
3520 int actual_format;
3521 unsigned long actual_size, bytes_remaining;
3522
3523 CHECK_STRING (prop);
3524 BLOCK_INPUT;
3525 prop_atom = XInternAtom (FRAME_W32_DISPLAY (f), SDATA (prop), False);
3526 rc = XGetWindowProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
3527 prop_atom, 0, 0, False, XA_STRING,
3528 &actual_type, &actual_format, &actual_size,
3529 &bytes_remaining, (unsigned char **) &tmp_data);
3530 if (rc == Success)
3531 {
3532 int size = bytes_remaining;
3533
3534 XFree (tmp_data);
3535 tmp_data = NULL;
3536
3537 rc = XGetWindowProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
3538 prop_atom, 0, bytes_remaining,
3539 False, XA_STRING,
3540 &actual_type, &actual_format,
3541 &actual_size, &bytes_remaining,
3542 (unsigned char **) &tmp_data);
3543 if (rc == Success)
3544 prop_value = make_string (tmp_data, size);
3545
3546 XFree (tmp_data);
3547 }
3548
3549 UNBLOCK_INPUT;
3550
3551 return prop_value;
3552
3553 #endif /* MAC_TODO */
3554 return Qnil;
3555 }
3556
3557
3558 \f
3559 /***********************************************************************
3560 Busy cursor
3561 ***********************************************************************/
3562
3563 /* If non-null, an asynchronous timer that, when it expires, displays
3564 an hourglass cursor on all frames. */
3565
3566 static struct atimer *hourglass_atimer;
3567
3568 /* Non-zero means an hourglass cursor is currently shown. */
3569
3570 static int hourglass_shown_p;
3571
3572 /* Number of seconds to wait before displaying an hourglass cursor. */
3573
3574 static Lisp_Object Vhourglass_delay;
3575
3576 /* Default number of seconds to wait before displaying an hourglass
3577 cursor. */
3578
3579 #define DEFAULT_HOURGLASS_DELAY 1
3580
3581 /* Function prototypes. */
3582
3583 static void show_hourglass P_ ((struct atimer *));
3584 static void hide_hourglass P_ ((void));
3585
3586 /* Return non-zero if houglass timer has been started or hourglass is shown. */
3587
3588 int
3589 hourglass_started ()
3590 {
3591 return hourglass_shown_p || hourglass_atimer != NULL;
3592 }
3593
3594
3595 /* Cancel a currently active hourglass timer, and start a new one. */
3596
3597 void
3598 start_hourglass ()
3599 {
3600 #ifdef MAC_OSX
3601 EMACS_TIME delay;
3602 int secs, usecs = 0;
3603
3604 /* Don't bother for ttys. */
3605 if (NILP (Vwindow_system))
3606 return;
3607
3608 cancel_hourglass ();
3609
3610 if (INTEGERP (Vhourglass_delay)
3611 && XINT (Vhourglass_delay) > 0)
3612 secs = XFASTINT (Vhourglass_delay);
3613 else if (FLOATP (Vhourglass_delay)
3614 && XFLOAT_DATA (Vhourglass_delay) > 0)
3615 {
3616 Lisp_Object tem;
3617 tem = Ftruncate (Vhourglass_delay, Qnil);
3618 secs = XFASTINT (tem);
3619 usecs = (XFLOAT_DATA (Vhourglass_delay) - secs) * 1000000;
3620 }
3621 else
3622 secs = DEFAULT_HOURGLASS_DELAY;
3623
3624 EMACS_SET_SECS_USECS (delay, secs, usecs);
3625 hourglass_atimer = start_atimer (ATIMER_RELATIVE, delay,
3626 show_hourglass, NULL);
3627 #endif /* MAC_OSX */
3628 }
3629
3630
3631 /* Cancel the hourglass cursor timer if active, hide a busy cursor if
3632 shown. */
3633
3634 void
3635 cancel_hourglass ()
3636 {
3637 #ifdef MAC_OSX
3638 if (hourglass_atimer)
3639 {
3640 cancel_atimer (hourglass_atimer);
3641 hourglass_atimer = NULL;
3642 }
3643
3644 if (hourglass_shown_p)
3645 hide_hourglass ();
3646 #endif /* MAC_OSX */
3647 }
3648
3649
3650 /* Timer function of hourglass_atimer. TIMER is equal to
3651 hourglass_atimer.
3652
3653 On Mac, busy status is shown by the progress indicator (chasing
3654 arrows) at the upper-right corner of each frame instead of the
3655 hourglass pointer. */
3656
3657 static void
3658 show_hourglass (timer)
3659 struct atimer *timer;
3660 {
3661 #if TARGET_API_MAC_CARBON
3662 /* The timer implementation will cancel this timer automatically
3663 after this function has run. Set hourglass_atimer to null
3664 so that we know the timer doesn't have to be canceled. */
3665 hourglass_atimer = NULL;
3666
3667 if (!hourglass_shown_p)
3668 {
3669 Lisp_Object rest, frame;
3670
3671 BLOCK_INPUT;
3672
3673 FOR_EACH_FRAME (rest, frame)
3674 {
3675 struct frame *f = XFRAME (frame);
3676
3677 if (FRAME_LIVE_P (f) && FRAME_MAC_P (f)
3678 && FRAME_MAC_WINDOW (f) != tip_window)
3679 {
3680 #if USE_CG_DRAWING
3681 mac_prepare_for_quickdraw (f);
3682 #endif
3683 if (!f->output_data.mac->hourglass_control)
3684 {
3685 Window w = FRAME_MAC_WINDOW (f);
3686 Rect r;
3687 ControlRef c;
3688
3689 GetWindowPortBounds (w, &r);
3690 r.left = r.right - HOURGLASS_WIDTH;
3691 r.bottom = r.top + HOURGLASS_HEIGHT;
3692 if (CreateChasingArrowsControl (w, &r, &c) == noErr)
3693 f->output_data.mac->hourglass_control = c;
3694 }
3695
3696 if (f->output_data.mac->hourglass_control)
3697 ShowControl (f->output_data.mac->hourglass_control);
3698 }
3699 }
3700
3701 hourglass_shown_p = 1;
3702 UNBLOCK_INPUT;
3703 }
3704 #endif /* TARGET_API_MAC_CARBON */
3705 }
3706
3707
3708 /* Hide the progress indicators on all frames, if it is currently
3709 shown. */
3710
3711 static void
3712 hide_hourglass ()
3713 {
3714 #if TARGET_API_MAC_CARBON
3715 if (hourglass_shown_p)
3716 {
3717 Lisp_Object rest, frame;
3718
3719 BLOCK_INPUT;
3720 FOR_EACH_FRAME (rest, frame)
3721 {
3722 struct frame *f = XFRAME (frame);
3723
3724 if (FRAME_MAC_P (f)
3725 /* Watch out for newly created frames. */
3726 && f->output_data.mac->hourglass_control)
3727 {
3728 #if USE_CG_DRAWING
3729 mac_prepare_for_quickdraw (f);
3730 #endif
3731 HideControl (f->output_data.mac->hourglass_control);
3732 }
3733 }
3734
3735 hourglass_shown_p = 0;
3736 UNBLOCK_INPUT;
3737 }
3738 #endif /* TARGET_API_MAC_CARBON */
3739 }
3740
3741
3742 \f
3743 /***********************************************************************
3744 Tool tips
3745 ***********************************************************************/
3746
3747 static Lisp_Object x_create_tip_frame P_ ((struct mac_display_info *,
3748 Lisp_Object, Lisp_Object));
3749 static void compute_tip_xy P_ ((struct frame *, Lisp_Object, Lisp_Object,
3750 Lisp_Object, int, int, int *, int *));
3751
3752 /* The frame of a currently visible tooltip. */
3753
3754 Lisp_Object tip_frame;
3755
3756 /* If non-nil, a timer started that hides the last tooltip when it
3757 fires. */
3758
3759 Lisp_Object tip_timer;
3760 Window tip_window;
3761
3762 /* If non-nil, a vector of 3 elements containing the last args
3763 with which x-show-tip was called. See there. */
3764
3765 Lisp_Object last_show_tip_args;
3766
3767 /* Maximum size for tooltips; a cons (COLUMNS . ROWS). */
3768
3769 Lisp_Object Vx_max_tooltip_size;
3770
3771
3772 static Lisp_Object
3773 unwind_create_tip_frame (frame)
3774 Lisp_Object frame;
3775 {
3776 Lisp_Object deleted;
3777
3778 deleted = unwind_create_frame (frame);
3779 if (EQ (deleted, Qt))
3780 {
3781 tip_window = NULL;
3782 tip_frame = Qnil;
3783 }
3784
3785 return deleted;
3786 }
3787
3788
3789 /* Create a frame for a tooltip on the display described by DPYINFO.
3790 PARMS is a list of frame parameters. TEXT is the string to
3791 display in the tip frame. Value is the frame.
3792
3793 Note that functions called here, esp. x_default_parameter can
3794 signal errors, for instance when a specified color name is
3795 undefined. We have to make sure that we're in a consistent state
3796 when this happens. */
3797
3798 static Lisp_Object
3799 x_create_tip_frame (dpyinfo, parms, text)
3800 struct mac_display_info *dpyinfo;
3801 Lisp_Object parms, text;
3802 {
3803 struct frame *f;
3804 Lisp_Object frame, tem;
3805 Lisp_Object name;
3806 long window_prompting = 0;
3807 int width, height;
3808 int count = SPECPDL_INDEX ();
3809 struct gcpro gcpro1, gcpro2, gcpro3;
3810 struct kboard *kb;
3811 int face_change_count_before = face_change_count;
3812 Lisp_Object buffer;
3813 struct buffer *old_buffer;
3814
3815 check_mac ();
3816
3817 parms = Fcopy_alist (parms);
3818
3819 #ifdef MULTI_KBOARD
3820 kb = dpyinfo->kboard;
3821 #else
3822 kb = &the_only_kboard;
3823 #endif
3824
3825 /* Get the name of the frame to use for resource lookup. */
3826 name = mac_get_arg (parms, Qname, "name", "Name", RES_TYPE_STRING);
3827 if (!STRINGP (name)
3828 && !EQ (name, Qunbound)
3829 && !NILP (name))
3830 error ("Invalid frame name--not a string or nil");
3831
3832 frame = Qnil;
3833 GCPRO3 (parms, name, frame);
3834 f = make_frame (1);
3835 XSETFRAME (frame, f);
3836
3837 buffer = Fget_buffer_create (build_string (" *tip*"));
3838 Fset_window_buffer (FRAME_ROOT_WINDOW (f), buffer, Qnil);
3839 old_buffer = current_buffer;
3840 set_buffer_internal_1 (XBUFFER (buffer));
3841 current_buffer->truncate_lines = Qnil;
3842 specbind (Qinhibit_read_only, Qt);
3843 specbind (Qinhibit_modification_hooks, Qt);
3844 Ferase_buffer ();
3845 Finsert (1, &text);
3846 set_buffer_internal_1 (old_buffer);
3847
3848 FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
3849 record_unwind_protect (unwind_create_tip_frame, frame);
3850
3851 /* By setting the output method, we're essentially saying that
3852 the frame is live, as per FRAME_LIVE_P. If we get a signal
3853 from this point on, x_destroy_window might screw up reference
3854 counts etc. */
3855 f->output_method = output_mac;
3856 f->output_data.mac =
3857 (struct mac_output *) xmalloc (sizeof (struct mac_output));
3858 bzero (f->output_data.mac, sizeof (struct mac_output));
3859
3860 FRAME_FONTSET (f) = -1;
3861 f->icon_name = Qnil;
3862 /* FRAME_X_DISPLAY_INFO (f) = dpyinfo; */
3863 #if GLYPH_DEBUG
3864 image_cache_refcount = FRAME_X_IMAGE_CACHE (f)->refcount;
3865 dpyinfo_refcount = dpyinfo->reference_count;
3866 #endif /* GLYPH_DEBUG */
3867 #ifdef MULTI_KBOARD
3868 FRAME_KBOARD (f) = kb;
3869 #endif
3870 f->output_data.mac->parent_desc = FRAME_MAC_DISPLAY_INFO (f)->root_window;
3871 f->output_data.mac->explicit_parent = 0;
3872
3873 /* Set the name; the functions to which we pass f expect the name to
3874 be set. */
3875 if (EQ (name, Qunbound) || NILP (name))
3876 {
3877 f->name = build_string (dpyinfo->mac_id_name);
3878 f->explicit_name = 0;
3879 }
3880 else
3881 {
3882 f->name = name;
3883 f->explicit_name = 1;
3884 /* use the frame's title when getting resources for this frame. */
3885 specbind (Qx_resource_name, name);
3886 }
3887
3888 /* Extract the window parameters from the supplied values that are
3889 needed to determine window geometry. */
3890 {
3891 Lisp_Object font;
3892
3893 font = mac_get_arg (parms, Qfont, "font", "Font", RES_TYPE_STRING);
3894
3895 BLOCK_INPUT;
3896 /* First, try whatever font the caller has specified. */
3897 if (STRINGP (font))
3898 {
3899 tem = Fquery_fontset (font, Qnil);
3900 if (STRINGP (tem))
3901 font = x_new_fontset (f, SDATA (tem));
3902 else
3903 font = x_new_font (f, SDATA (font));
3904 }
3905
3906 /* Try out a font which we hope has bold and italic variations. */
3907 #if USE_ATSUI
3908 if (! STRINGP (font))
3909 font = x_new_font (f, "-*-monaco-medium-r-normal--12-*-*-*-*-*-iso10646-1");
3910 #endif
3911 if (! STRINGP (font))
3912 font = x_new_font (f, "-ETL-fixed-medium-r-*--*-160-*-*-*-*-iso8859-1");
3913 /* If those didn't work, look for something which will at least work. */
3914 if (! STRINGP (font))
3915 font = x_new_fontset (f, "fontset-standard");
3916 if (! STRINGP (font))
3917 font = x_new_font (f, "-*-monaco-*-12-*-mac-roman");
3918 if (! STRINGP (font))
3919 font = x_new_font (f, "-*-courier-*-10-*-mac-roman");
3920 UNBLOCK_INPUT;
3921 if (! STRINGP (font))
3922 error ("Cannot find any usable font");
3923
3924 x_default_parameter (f, parms, Qfont, font,
3925 "font", "Font", RES_TYPE_STRING);
3926 }
3927
3928 x_default_parameter (f, parms, Qborder_width, make_number (2),
3929 "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
3930
3931 /* This defaults to 2 in order to match xterm. We recognize either
3932 internalBorderWidth or internalBorder (which is what xterm calls
3933 it). */
3934 if (NILP (Fassq (Qinternal_border_width, parms)))
3935 {
3936 Lisp_Object value;
3937
3938 value = mac_get_arg (parms, Qinternal_border_width,
3939 "internalBorder", "internalBorder", RES_TYPE_NUMBER);
3940 if (! EQ (value, Qunbound))
3941 parms = Fcons (Fcons (Qinternal_border_width, value),
3942 parms);
3943 }
3944
3945 x_default_parameter (f, parms, Qinternal_border_width, make_number (1),
3946 "internalBorderWidth", "internalBorderWidth",
3947 RES_TYPE_NUMBER);
3948
3949 /* Also do the stuff which must be set before the window exists. */
3950 x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
3951 "foreground", "Foreground", RES_TYPE_STRING);
3952 x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
3953 "background", "Background", RES_TYPE_STRING);
3954 x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
3955 "pointerColor", "Foreground", RES_TYPE_STRING);
3956 x_default_parameter (f, parms, Qcursor_color, build_string ("black"),
3957 "cursorColor", "Foreground", RES_TYPE_STRING);
3958 x_default_parameter (f, parms, Qborder_color, build_string ("black"),
3959 "borderColor", "BorderColor", RES_TYPE_STRING);
3960
3961 /* Init faces before x_default_parameter is called for scroll-bar
3962 parameters because that function calls x_set_scroll_bar_width,
3963 which calls change_frame_size, which calls Fset_window_buffer,
3964 which runs hooks, which call Fvertical_motion. At the end, we
3965 end up in init_iterator with a null face cache, which should not
3966 happen. */
3967 init_frame_faces (f);
3968
3969 f->output_data.mac->parent_desc = FRAME_MAC_DISPLAY_INFO (f)->root_window;
3970
3971 window_prompting = x_figure_window_size (f, parms, 0);
3972
3973 {
3974 Rect r;
3975
3976 BLOCK_INPUT;
3977 SetRect (&r, 0, 0, 1, 1);
3978 #if TARGET_API_MAC_CARBON
3979 if (CreateNewWindow (kHelpWindowClass,
3980 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
3981 kWindowIgnoreClicksAttribute |
3982 #endif
3983 kWindowNoUpdatesAttribute |
3984 kWindowNoActivatesAttribute,
3985 &r, &tip_window) == noErr)
3986 #else
3987 if (tip_window = NewCWindow (NULL, &r, "\p", false, plainDBox,
3988 NULL, false, 0L))
3989 #endif
3990 {
3991 FRAME_MAC_WINDOW (f) = tip_window;
3992 XSetWindowBackground (FRAME_MAC_DISPLAY(f), tip_window,
3993 FRAME_BACKGROUND_PIXEL (f));
3994 SetWRefCon (tip_window, (long) f->output_data.mac);
3995 /* so that update events can find this mac_output struct */
3996 f->output_data.mac->mFP = f;
3997 }
3998 UNBLOCK_INPUT;
3999 }
4000
4001 x_make_gc (f);
4002
4003 x_default_parameter (f, parms, Qauto_raise, Qnil,
4004 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
4005 x_default_parameter (f, parms, Qauto_lower, Qnil,
4006 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
4007 x_default_parameter (f, parms, Qcursor_type, Qbox,
4008 "cursorType", "CursorType", RES_TYPE_SYMBOL);
4009
4010 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
4011 Change will not be effected unless different from the current
4012 FRAME_LINES (f). */
4013 width = FRAME_COLS (f);
4014 height = FRAME_LINES (f);
4015 SET_FRAME_COLS (f, 0);
4016 FRAME_LINES (f) = 0;
4017 change_frame_size (f, height, width, 1, 0, 0);
4018
4019 /* Add `tooltip' frame parameter's default value. */
4020 if (NILP (Fframe_parameter (frame, intern ("tooltip"))))
4021 Fmodify_frame_parameters (frame, Fcons (Fcons (intern ("tooltip"), Qt),
4022 Qnil));
4023
4024 /* Set up faces after all frame parameters are known. This call
4025 also merges in face attributes specified for new frames.
4026
4027 Frame parameters may be changed if .Xdefaults contains
4028 specifications for the default font. For example, if there is an
4029 `Emacs.default.attributeBackground: pink', the `background-color'
4030 attribute of the frame get's set, which let's the internal border
4031 of the tooltip frame appear in pink. Prevent this. */
4032 {
4033 Lisp_Object bg = Fframe_parameter (frame, Qbackground_color);
4034
4035 /* Set tip_frame here, so that */
4036 tip_frame = frame;
4037 call1 (Qface_set_after_frame_default, frame);
4038
4039 if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
4040 Fmodify_frame_parameters (frame, Fcons (Fcons (Qbackground_color, bg),
4041 Qnil));
4042 }
4043
4044 f->no_split = 1;
4045
4046 UNGCPRO;
4047
4048 /* It is now ok to make the frame official even if we get an error
4049 below. And the frame needs to be on Vframe_list or making it
4050 visible won't work. */
4051 Vframe_list = Fcons (frame, Vframe_list);
4052
4053 /* Now that the frame is official, it counts as a reference to
4054 its display. */
4055 FRAME_MAC_DISPLAY_INFO (f)->reference_count++;
4056
4057 /* Setting attributes of faces of the tooltip frame from resources
4058 and similar will increment face_change_count, which leads to the
4059 clearing of all current matrices. Since this isn't necessary
4060 here, avoid it by resetting face_change_count to the value it
4061 had before we created the tip frame. */
4062 face_change_count = face_change_count_before;
4063
4064 /* Discard the unwind_protect. */
4065 return unbind_to (count, frame);
4066 }
4067
4068
4069 /* Compute where to display tip frame F. PARMS is the list of frame
4070 parameters for F. DX and DY are specified offsets from the current
4071 location of the mouse. WIDTH and HEIGHT are the width and height
4072 of the tooltip. Return coordinates relative to the root window of
4073 the display in *ROOT_X, and *ROOT_Y. */
4074
4075 static void
4076 compute_tip_xy (f, parms, dx, dy, width, height, root_x, root_y)
4077 struct frame *f;
4078 Lisp_Object parms, dx, dy;
4079 int width, height;
4080 int *root_x, *root_y;
4081 {
4082 Lisp_Object left, top;
4083
4084 /* User-specified position? */
4085 left = Fcdr (Fassq (Qleft, parms));
4086 top = Fcdr (Fassq (Qtop, parms));
4087
4088 /* Move the tooltip window where the mouse pointer is. Resize and
4089 show it. */
4090 if (!INTEGERP (left) || !INTEGERP (top))
4091 {
4092 Point mouse_pos;
4093
4094 BLOCK_INPUT;
4095 GetMouse (&mouse_pos);
4096 LocalToGlobal (&mouse_pos);
4097 *root_x = mouse_pos.h;
4098 *root_y = mouse_pos.v;
4099 UNBLOCK_INPUT;
4100 }
4101
4102 if (INTEGERP (top))
4103 *root_y = XINT (top);
4104 else if (*root_y + XINT (dy) <= 0)
4105 *root_y = 0; /* Can happen for negative dy */
4106 else if (*root_y + XINT (dy) + height <= FRAME_MAC_DISPLAY_INFO (f)->height)
4107 /* It fits below the pointer */
4108 *root_y += XINT (dy);
4109 else if (height + XINT (dy) <= *root_y)
4110 /* It fits above the pointer. */
4111 *root_y -= height + XINT (dy);
4112 else
4113 /* Put it on the top. */
4114 *root_y = 0;
4115
4116 if (INTEGERP (left))
4117 *root_x = XINT (left);
4118 else if (*root_x + XINT (dx) <= 0)
4119 *root_x = 0; /* Can happen for negative dx */
4120 else if (*root_x + XINT (dx) + width <= FRAME_MAC_DISPLAY_INFO (f)->width)
4121 /* It fits to the right of the pointer. */
4122 *root_x += XINT (dx);
4123 else if (width + XINT (dx) <= *root_x)
4124 /* It fits to the left of the pointer. */
4125 *root_x -= width + XINT (dx);
4126 else
4127 /* Put it left-justified on the screen -- it ought to fit that way. */
4128 *root_x = 0;
4129 }
4130
4131
4132 DEFUN ("x-show-tip", Fx_show_tip, Sx_show_tip, 1, 6, 0,
4133 doc: /* Show STRING in a "tooltip" window on frame FRAME.
4134 A tooltip window is a small window displaying a string.
4135
4136 FRAME nil or omitted means use the selected frame.
4137
4138 PARMS is an optional list of frame parameters which can be used to
4139 change the tooltip's appearance.
4140
4141 Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
4142 means use the default timeout of 5 seconds.
4143
4144 If the list of frame parameters PARMS contains a `left' parameter,
4145 the tooltip is displayed at that x-position. Otherwise it is
4146 displayed at the mouse position, with offset DX added (default is 5 if
4147 DX isn't specified). Likewise for the y-position; if a `top' frame
4148 parameter is specified, it determines the y-position of the tooltip
4149 window, otherwise it is displayed at the mouse position, with offset
4150 DY added (default is -10).
4151
4152 A tooltip's maximum size is specified by `x-max-tooltip-size'.
4153 Text larger than the specified size is clipped. */)
4154 (string, frame, parms, timeout, dx, dy)
4155 Lisp_Object string, frame, parms, timeout, dx, dy;
4156 {
4157 struct frame *f;
4158 struct window *w;
4159 int root_x, root_y;
4160 struct buffer *old_buffer;
4161 struct text_pos pos;
4162 int i, width, height;
4163 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
4164 int old_windows_or_buffers_changed = windows_or_buffers_changed;
4165 int count = SPECPDL_INDEX ();
4166
4167 specbind (Qinhibit_redisplay, Qt);
4168
4169 GCPRO4 (string, parms, frame, timeout);
4170
4171 CHECK_STRING (string);
4172 f = check_x_frame (frame);
4173 if (NILP (timeout))
4174 timeout = make_number (5);
4175 else
4176 CHECK_NATNUM (timeout);
4177
4178 if (NILP (dx))
4179 dx = make_number (5);
4180 else
4181 CHECK_NUMBER (dx);
4182
4183 if (NILP (dy))
4184 dy = make_number (-10);
4185 else
4186 CHECK_NUMBER (dy);
4187
4188 if (NILP (last_show_tip_args))
4189 last_show_tip_args = Fmake_vector (make_number (3), Qnil);
4190
4191 if (!NILP (tip_frame))
4192 {
4193 Lisp_Object last_string = AREF (last_show_tip_args, 0);
4194 Lisp_Object last_frame = AREF (last_show_tip_args, 1);
4195 Lisp_Object last_parms = AREF (last_show_tip_args, 2);
4196
4197 if (EQ (frame, last_frame)
4198 && !NILP (Fequal (last_string, string))
4199 && !NILP (Fequal (last_parms, parms)))
4200 {
4201 struct frame *f = XFRAME (tip_frame);
4202
4203 /* Only DX and DY have changed. */
4204 if (!NILP (tip_timer))
4205 {
4206 Lisp_Object timer = tip_timer;
4207 tip_timer = Qnil;
4208 call1 (Qcancel_timer, timer);
4209 }
4210
4211 BLOCK_INPUT;
4212 compute_tip_xy (f, parms, dx, dy, FRAME_PIXEL_WIDTH (f),
4213 FRAME_PIXEL_HEIGHT (f), &root_x, &root_y);
4214 MoveWindow (FRAME_MAC_WINDOW (f), root_x, root_y, false);
4215 UNBLOCK_INPUT;
4216 goto start_timer;
4217 }
4218 }
4219
4220 /* Hide a previous tip, if any. */
4221 Fx_hide_tip ();
4222
4223 ASET (last_show_tip_args, 0, string);
4224 ASET (last_show_tip_args, 1, frame);
4225 ASET (last_show_tip_args, 2, parms);
4226
4227 /* Add default values to frame parameters. */
4228 if (NILP (Fassq (Qname, parms)))
4229 parms = Fcons (Fcons (Qname, build_string ("tooltip")), parms);
4230 if (NILP (Fassq (Qinternal_border_width, parms)))
4231 parms = Fcons (Fcons (Qinternal_border_width, make_number (3)), parms);
4232 if (NILP (Fassq (Qborder_width, parms)))
4233 parms = Fcons (Fcons (Qborder_width, make_number (1)), parms);
4234 if (NILP (Fassq (Qborder_color, parms)))
4235 parms = Fcons (Fcons (Qborder_color, build_string ("lightyellow")), parms);
4236 if (NILP (Fassq (Qbackground_color, parms)))
4237 parms = Fcons (Fcons (Qbackground_color, build_string ("lightyellow")),
4238 parms);
4239
4240 /* Create a frame for the tooltip, and record it in the global
4241 variable tip_frame. */
4242 frame = x_create_tip_frame (FRAME_MAC_DISPLAY_INFO (f), parms, string);
4243 f = XFRAME (frame);
4244
4245 /* Set up the frame's root window. */
4246 w = XWINDOW (FRAME_ROOT_WINDOW (f));
4247 w->left_col = w->top_line = make_number (0);
4248
4249 if (CONSP (Vx_max_tooltip_size)
4250 && INTEGERP (XCAR (Vx_max_tooltip_size))
4251 && XINT (XCAR (Vx_max_tooltip_size)) > 0
4252 && INTEGERP (XCDR (Vx_max_tooltip_size))
4253 && XINT (XCDR (Vx_max_tooltip_size)) > 0)
4254 {
4255 w->total_cols = XCAR (Vx_max_tooltip_size);
4256 w->total_lines = XCDR (Vx_max_tooltip_size);
4257 }
4258 else
4259 {
4260 w->total_cols = make_number (80);
4261 w->total_lines = make_number (40);
4262 }
4263
4264 FRAME_TOTAL_COLS (f) = XINT (w->total_cols);
4265 adjust_glyphs (f);
4266 w->pseudo_window_p = 1;
4267
4268 /* Display the tooltip text in a temporary buffer. */
4269 old_buffer = current_buffer;
4270 set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f))->buffer));
4271 current_buffer->truncate_lines = Qnil;
4272 clear_glyph_matrix (w->desired_matrix);
4273 clear_glyph_matrix (w->current_matrix);
4274 SET_TEXT_POS (pos, BEGV, BEGV_BYTE);
4275 try_window (FRAME_ROOT_WINDOW (f), pos, 0);
4276
4277 /* Compute width and height of the tooltip. */
4278 width = height = 0;
4279 for (i = 0; i < w->desired_matrix->nrows; ++i)
4280 {
4281 struct glyph_row *row = &w->desired_matrix->rows[i];
4282 struct glyph *last;
4283 int row_width;
4284
4285 /* Stop at the first empty row at the end. */
4286 if (!row->enabled_p || !row->displays_text_p)
4287 break;
4288
4289 /* Let the row go over the full width of the frame. */
4290 row->full_width_p = 1;
4291
4292 /* There's a glyph at the end of rows that is used to place
4293 the cursor there. Don't include the width of this glyph. */
4294 if (row->used[TEXT_AREA])
4295 {
4296 last = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
4297 row_width = row->pixel_width - last->pixel_width;
4298 }
4299 else
4300 row_width = row->pixel_width;
4301
4302 height += row->height;
4303 width = max (width, row_width);
4304 }
4305
4306 /* Add the frame's internal border to the width and height the X
4307 window should have. */
4308 height += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
4309 width += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
4310
4311 /* Move the tooltip window where the mouse pointer is. Resize and
4312 show it. */
4313 compute_tip_xy (f, parms, dx, dy, width, height, &root_x, &root_y);
4314
4315 BLOCK_INPUT;
4316 MoveWindow (FRAME_MAC_WINDOW (f), root_x, root_y, false);
4317 SizeWindow (FRAME_MAC_WINDOW (f), width, height, true);
4318 ShowWindow (FRAME_MAC_WINDOW (f));
4319 BringToFront (FRAME_MAC_WINDOW (f));
4320 UNBLOCK_INPUT;
4321
4322 FRAME_PIXEL_WIDTH (f) = width;
4323 FRAME_PIXEL_HEIGHT (f) = height;
4324
4325 /* Draw into the window. */
4326 w->must_be_updated_p = 1;
4327 update_single_window (w, 1);
4328
4329 /* Restore original current buffer. */
4330 set_buffer_internal_1 (old_buffer);
4331 windows_or_buffers_changed = old_windows_or_buffers_changed;
4332
4333 start_timer:
4334 /* Let the tip disappear after timeout seconds. */
4335 tip_timer = call3 (intern ("run-at-time"), timeout, Qnil,
4336 intern ("x-hide-tip"));
4337
4338 UNGCPRO;
4339 return unbind_to (count, Qnil);
4340 }
4341
4342
4343 DEFUN ("x-hide-tip", Fx_hide_tip, Sx_hide_tip, 0, 0, 0,
4344 doc: /* Hide the current tooltip window, if there is any.
4345 Value is t if tooltip was open, nil otherwise. */)
4346 ()
4347 {
4348 int count;
4349 Lisp_Object deleted, frame, timer;
4350 struct gcpro gcpro1, gcpro2;
4351
4352 /* Return quickly if nothing to do. */
4353 if (NILP (tip_timer) && NILP (tip_frame))
4354 return Qnil;
4355
4356 frame = tip_frame;
4357 timer = tip_timer;
4358 GCPRO2 (frame, timer);
4359 tip_frame = tip_timer = deleted = Qnil;
4360
4361 count = SPECPDL_INDEX ();
4362 specbind (Qinhibit_redisplay, Qt);
4363 specbind (Qinhibit_quit, Qt);
4364
4365 if (!NILP (timer))
4366 call1 (Qcancel_timer, timer);
4367
4368 if (FRAMEP (frame))
4369 {
4370 Fdelete_frame (frame, Qnil);
4371 deleted = Qt;
4372 }
4373
4374 UNGCPRO;
4375 return unbind_to (count, deleted);
4376 }
4377
4378
4379 \f
4380 #if TARGET_API_MAC_CARBON
4381 /***********************************************************************
4382 File selection dialog
4383 ***********************************************************************/
4384
4385 static pascal void mac_nav_event_callback P_ ((NavEventCallbackMessage,
4386 NavCBRecPtr, void *));
4387
4388 /**
4389 There is a relatively standard way to do this using applescript to run
4390 a (choose file) method. However, this doesn't do "the right thing"
4391 by working only if the find-file occurred during a menu or toolbar
4392 click. So we must do the file dialog by hand, using the navigation
4393 manager. This also has more flexibility in determining the default
4394 directory and whether or not we are going to choose a file.
4395 **/
4396
4397 extern Lisp_Object Qfile_name_history;
4398
4399 DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
4400 doc: /* Read file name, prompting with PROMPT in directory DIR.
4401 Use a file selection dialog.
4402 Select DEFAULT-FILENAME in the dialog's file selection box, if
4403 specified. Ensure that file exists if MUSTMATCH is non-nil.
4404 If ONLY-DIR-P is non-nil, the user can only select directories. */)
4405 (prompt, dir, default_filename, mustmatch, only_dir_p)
4406 Lisp_Object prompt, dir, default_filename, mustmatch, only_dir_p;
4407 {
4408 Lisp_Object file = Qnil;
4409 int count = SPECPDL_INDEX ();
4410 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
4411 char filename[MAXPATHLEN];
4412 static NavEventUPP mac_nav_event_callbackUPP = NULL;
4413
4414 check_mac ();
4415
4416 GCPRO6 (prompt, dir, default_filename, mustmatch, file, only_dir_p);
4417 CHECK_STRING (prompt);
4418 CHECK_STRING (dir);
4419
4420 /* Create the dialog with PROMPT as title, using DIR as initial
4421 directory and using "*" as pattern. */
4422 dir = Fexpand_file_name (dir, Qnil);
4423
4424 {
4425 OSStatus status;
4426 NavDialogCreationOptions options;
4427 NavDialogRef dialogRef;
4428 NavTypeListHandle fileTypes = NULL;
4429 NavUserAction userAction;
4430 CFStringRef message=NULL, saveName = NULL;
4431
4432 BLOCK_INPUT;
4433 /* No need for a callback function because we are modal */
4434 NavGetDefaultDialogCreationOptions(&options);
4435 options.modality = kWindowModalityAppModal;
4436 options.location.h = options.location.v = -1;
4437 options.optionFlags = kNavDefaultNavDlogOptions;
4438 options.optionFlags |= kNavAllFilesInPopup; /* All files allowed */
4439 options.optionFlags |= kNavSelectAllReadableItem;
4440 options.optionFlags &= ~kNavAllowMultipleFiles;
4441 if (!NILP(prompt))
4442 {
4443 message = cfstring_create_with_string (prompt);
4444 options.message = message;
4445 }
4446 /* Don't set the application, let it use default.
4447 options.clientName = CFSTR ("Emacs");
4448 */
4449
4450 if (mac_nav_event_callbackUPP == NULL)
4451 mac_nav_event_callbackUPP = NewNavEventUPP (mac_nav_event_callback);
4452
4453 if (!NILP (only_dir_p))
4454 status = NavCreateChooseFolderDialog(&options, mac_nav_event_callbackUPP,
4455 NULL, NULL, &dialogRef);
4456 else if (NILP (mustmatch))
4457 {
4458 /* This is a save dialog */
4459 options.optionFlags |= kNavDontConfirmReplacement;
4460 options.actionButtonLabel = CFSTR ("Ok");
4461 options.windowTitle = CFSTR ("Enter name");
4462
4463 if (STRINGP (default_filename))
4464 {
4465 Lisp_Object utf8 = ENCODE_UTF_8 (default_filename);
4466 char *begPtr = SDATA(utf8);
4467 char *filePtr = begPtr + SBYTES(utf8);
4468 while (filePtr != begPtr && !IS_DIRECTORY_SEP(filePtr[-1]))
4469 filePtr--;
4470 saveName = cfstring_create_with_utf8_cstring (filePtr);
4471 options.saveFileName = saveName;
4472 options.optionFlags |= kNavSelectDefaultLocation;
4473 }
4474 status = NavCreatePutFileDialog(&options,
4475 'TEXT', kNavGenericSignature,
4476 mac_nav_event_callbackUPP, NULL,
4477 &dialogRef);
4478 }
4479 else
4480 {
4481 /* This is an open dialog*/
4482 status = NavCreateChooseFileDialog(&options, fileTypes,
4483 mac_nav_event_callbackUPP, NULL,
4484 NULL, NULL, &dialogRef);
4485 }
4486
4487 /* Set the default location and continue*/
4488 if (status == noErr)
4489 {
4490 Lisp_Object encoded_dir = ENCODE_FILE (dir);
4491 AEDesc defLocAed;
4492
4493 status = AECreateDesc (TYPE_FILE_NAME, SDATA (encoded_dir),
4494 SBYTES (encoded_dir), &defLocAed);
4495 if (status == noErr)
4496 {
4497 NavCustomControl(dialogRef, kNavCtlSetLocation, (void*) &defLocAed);
4498 AEDisposeDesc(&defLocAed);
4499 }
4500 status = NavDialogRun(dialogRef);
4501 }
4502
4503 if (saveName) CFRelease(saveName);
4504 if (message) CFRelease(message);
4505
4506 if (status == noErr) {
4507 userAction = NavDialogGetUserAction(dialogRef);
4508 switch (userAction)
4509 {
4510 case kNavUserActionNone:
4511 case kNavUserActionCancel:
4512 break; /* Treat cancel like C-g */
4513 case kNavUserActionOpen:
4514 case kNavUserActionChoose:
4515 case kNavUserActionSaveAs:
4516 {
4517 NavReplyRecord reply;
4518 Size len;
4519
4520 status = NavDialogGetReply(dialogRef, &reply);
4521 if (status != noErr)
4522 break;
4523 status = AEGetNthPtr (&reply.selection, 1, TYPE_FILE_NAME,
4524 NULL, NULL, filename,
4525 sizeof (filename) - 1, &len);
4526 if (status == noErr)
4527 {
4528 len = min (len, sizeof (filename) - 1);
4529 filename[len] = '\0';
4530 if (reply.saveFileName)
4531 {
4532 /* If it was a saved file, we need to add the file name */
4533 if (len && len < sizeof (filename) - 1
4534 && filename[len-1] != '/')
4535 filename[len++] = '/';
4536 CFStringGetCString(reply.saveFileName, filename+len,
4537 sizeof (filename) - len,
4538 #ifdef MAC_OSX
4539 kCFStringEncodingUTF8
4540 #else
4541 CFStringGetSystemEncoding ()
4542 #endif
4543 );
4544 }
4545 file = DECODE_FILE (make_unibyte_string (filename,
4546 strlen (filename)));
4547 }
4548 NavDisposeReply(&reply);
4549 }
4550 break;
4551 }
4552 NavDialogDispose(dialogRef);
4553 UNBLOCK_INPUT;
4554 }
4555 else {
4556 UNBLOCK_INPUT;
4557 /* Fall back on minibuffer if there was a problem */
4558 file = Fcompleting_read (prompt, intern ("read-file-name-internal"),
4559 dir, mustmatch, dir, Qfile_name_history,
4560 default_filename, Qnil);
4561 }
4562 }
4563
4564 UNGCPRO;
4565
4566 /* Make "Cancel" equivalent to C-g. */
4567 if (NILP (file))
4568 Fsignal (Qquit, Qnil);
4569
4570 return unbind_to (count, file);
4571 }
4572
4573
4574 /* Need to register some event callback function for enabling drag and
4575 drop in Navigation Service dialogs. */
4576 static pascal void
4577 mac_nav_event_callback (selector, parms, data)
4578 NavEventCallbackMessage selector;
4579 NavCBRecPtr parms;
4580 void *data ;
4581 {
4582 }
4583 #endif
4584 \f
4585 /***********************************************************************
4586 Fonts
4587 ***********************************************************************/
4588
4589 DEFUN ("mac-clear-font-name-table", Fmac_clear_font_name_table,
4590 Smac_clear_font_name_table, 0, 0, 0,
4591 doc: /* Clear the font name table. */)
4592 ()
4593 {
4594 check_mac ();
4595 mac_clear_font_name_table ();
4596 return Qnil;
4597 }
4598
4599 #if USE_MAC_FONT_PANEL
4600 DEFUN ("mac-set-font-panel-visible-p", Fmac_set_font_panel_visible_p,
4601 Smac_set_font_panel_visible_p, 1, 1, 0,
4602 doc: /* Make the font panel visible if and only if FLAG is non-nil.
4603 This is for internal use only. Use `mac-font-panel-mode' instead. */)
4604 (flag)
4605 Lisp_Object flag;
4606 {
4607 OSStatus err = noErr;
4608
4609 check_mac ();
4610
4611 BLOCK_INPUT;
4612 if (NILP (flag) != !mac_font_panel_visible_p ())
4613 {
4614 err = mac_show_hide_font_panel ();
4615 if (err == noErr && !NILP (flag))
4616 {
4617 Lisp_Object focus_frame = x_get_focus_frame (SELECTED_FRAME ());
4618 struct frame *f = (NILP (focus_frame) ? SELECTED_FRAME ()
4619 : XFRAME (focus_frame));
4620
4621 mac_set_font_info_for_selection (f, DEFAULT_FACE_ID, 0);
4622 }
4623 }
4624 UNBLOCK_INPUT;
4625
4626 if (err != noErr)
4627 error ("Cannot change visibility of the font panel");
4628 return Qnil;
4629 }
4630 #endif
4631
4632 #if USE_ATSUI
4633 extern Lisp_Object mac_atsu_font_face_attributes P_ ((ATSUFontID));
4634
4635 DEFUN ("mac-atsu-font-face-attributes", Fmac_atsu_font_face_attributes,
4636 Smac_atsu_font_face_attributes, 1, 1, 0,
4637 doc: /* Return plist of face attributes and values for ATSU font ID.
4638 ID is specified by either an integer or a float. */)
4639 (id)
4640 Lisp_Object id;
4641 {
4642 ATSUFontID font_id;
4643 Lisp_Object result;
4644
4645 check_mac ();
4646 CHECK_NUMBER_OR_FLOAT(id);
4647 font_id = NUMBERP (id) ? XINT (id) : (ATSUFontID) XFLOAT (id);
4648 BLOCK_INPUT;
4649 result = mac_atsu_font_face_attributes (font_id);
4650 UNBLOCK_INPUT;
4651 return result;
4652 }
4653 #endif
4654
4655 \f
4656 /***********************************************************************
4657 Initialization
4658 ***********************************************************************/
4659
4660 /* Keep this list in the same order as frame_parms in frame.c.
4661 Use 0 for unsupported frame parameters. */
4662
4663 frame_parm_handler mac_frame_parm_handlers[] =
4664 {
4665 x_set_autoraise,
4666 x_set_autolower,
4667 x_set_background_color,
4668 x_set_border_color,
4669 x_set_border_width,
4670 x_set_cursor_color,
4671 x_set_cursor_type,
4672 mac_set_font,
4673 x_set_foreground_color,
4674 x_set_icon_name,
4675 0, /* MAC_TODO: x_set_icon_type, */
4676 x_set_internal_border_width,
4677 x_set_menu_bar_lines,
4678 x_set_mouse_color,
4679 x_explicitly_set_name,
4680 mac_set_scroll_bar_width,
4681 x_set_title,
4682 x_set_unsplittable,
4683 x_set_vertical_scroll_bars,
4684 x_set_visibility,
4685 x_set_tool_bar_lines,
4686 0, /* MAC_TODO: x_set_scroll_bar_foreground, */
4687 0, /* MAC_TODO: x_set_scroll_bar_background, */
4688 x_set_screen_gamma,
4689 x_set_line_spacing,
4690 x_set_fringe_width,
4691 x_set_fringe_width,
4692 0, /* x_set_wait_for_wm, */
4693 x_set_fullscreen,
4694 };
4695
4696 void
4697 syms_of_macfns ()
4698 {
4699 #ifdef MAC_OSX
4700 /* This is zero if not using Mac native windows. */
4701 mac_in_use = 0;
4702 #else
4703 /* Certainly running on Mac native windows. */
4704 mac_in_use = 1;
4705 #endif
4706
4707 /* The section below is built by the lisp expression at the top of the file,
4708 just above where these variables are declared. */
4709 /*&&& init symbols here &&&*/
4710 Qnone = intern ("none");
4711 staticpro (&Qnone);
4712 Qsuppress_icon = intern ("suppress-icon");
4713 staticpro (&Qsuppress_icon);
4714 Qundefined_color = intern ("undefined-color");
4715 staticpro (&Qundefined_color);
4716 Qcancel_timer = intern ("cancel-timer");
4717 staticpro (&Qcancel_timer);
4718 /* This is the end of symbol initialization. */
4719
4720 /* Text property `display' should be nonsticky by default. */
4721 Vtext_property_default_nonsticky
4722 = Fcons (Fcons (Qdisplay, Qt), Vtext_property_default_nonsticky);
4723
4724
4725 Fput (Qundefined_color, Qerror_conditions,
4726 Fcons (Qundefined_color, Fcons (Qerror, Qnil)));
4727 Fput (Qundefined_color, Qerror_message,
4728 build_string ("Undefined color"));
4729
4730 DEFVAR_LISP ("x-pointer-shape", &Vx_pointer_shape,
4731 doc: /* The shape of the pointer when over text.
4732 Changing the value does not affect existing frames
4733 unless you set the mouse color. */);
4734 Vx_pointer_shape = Qnil;
4735
4736 #if 0 /* This doesn't really do anything. */
4737 DEFVAR_LISP ("x-nontext-pointer-shape", &Vx_nontext_pointer_shape,
4738 doc: /* The shape of the pointer when not over text.
4739 This variable takes effect when you create a new frame
4740 or when you set the mouse color. */);
4741 #endif
4742 Vx_nontext_pointer_shape = Qnil;
4743
4744 DEFVAR_LISP ("x-hourglass-pointer-shape", &Vx_hourglass_pointer_shape,
4745 doc: /* The shape of the pointer when Emacs is busy.
4746 This variable takes effect when you create a new frame
4747 or when you set the mouse color. */);
4748 Vx_hourglass_pointer_shape = Qnil;
4749
4750 DEFVAR_BOOL ("display-hourglass", &display_hourglass_p,
4751 doc: /* Non-zero means Emacs displays an hourglass pointer on window systems. */);
4752 display_hourglass_p = 1;
4753
4754 DEFVAR_LISP ("hourglass-delay", &Vhourglass_delay,
4755 doc: /* *Seconds to wait before displaying an hourglass pointer.
4756 Value must be an integer or float. */);
4757 Vhourglass_delay = make_number (DEFAULT_HOURGLASS_DELAY);
4758
4759 #if 0 /* This doesn't really do anything. */
4760 DEFVAR_LISP ("x-mode-pointer-shape", &Vx_mode_pointer_shape,
4761 doc: /* The shape of the pointer when over the mode line.
4762 This variable takes effect when you create a new frame
4763 or when you set the mouse color. */);
4764 #endif
4765 Vx_mode_pointer_shape = Qnil;
4766
4767 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
4768 &Vx_sensitive_text_pointer_shape,
4769 doc: /* The shape of the pointer when over mouse-sensitive text.
4770 This variable takes effect when you create a new frame
4771 or when you set the mouse color. */);
4772 Vx_sensitive_text_pointer_shape = Qnil;
4773
4774 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
4775 &Vx_window_horizontal_drag_shape,
4776 doc: /* Pointer shape to use for indicating a window can be dragged horizontally.
4777 This variable takes effect when you create a new frame
4778 or when you set the mouse color. */);
4779 Vx_window_horizontal_drag_shape = Qnil;
4780
4781 DEFVAR_LISP ("x-cursor-fore-pixel", &Vx_cursor_fore_pixel,
4782 doc: /* A string indicating the foreground color of the cursor box. */);
4783 Vx_cursor_fore_pixel = Qnil;
4784
4785 DEFVAR_LISP ("x-max-tooltip-size", &Vx_max_tooltip_size,
4786 doc: /* Maximum size for tooltips. Value is a pair (COLUMNS . ROWS).
4787 Text larger than this is clipped. */);
4788 Vx_max_tooltip_size = Fcons (make_number (80), make_number (40));
4789
4790 DEFVAR_LISP ("x-no-window-manager", &Vx_no_window_manager,
4791 doc: /* Non-nil if no window manager is in use.
4792 Emacs doesn't try to figure this out; this is always nil
4793 unless you set it to something else. */);
4794 /* We don't have any way to find this out, so set it to nil
4795 and maybe the user would like to set it to t. */
4796 Vx_no_window_manager = Qnil;
4797
4798 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
4799 &Vx_pixel_size_width_font_regexp,
4800 doc: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
4801
4802 Since Emacs gets width of a font matching with this regexp from
4803 PIXEL_SIZE field of the name, font finding mechanism gets faster for
4804 such a font. This is especially effective for such large fonts as
4805 Chinese, Japanese, and Korean. */);
4806 Vx_pixel_size_width_font_regexp = Qnil;
4807
4808 #if TARGET_API_MAC_CARBON
4809 DEFVAR_LISP ("mac-carbon-version-string", &Vmac_carbon_version_string,
4810 doc: /* Version info for Carbon API. */);
4811 {
4812 OSErr err;
4813 UInt32 response;
4814 char carbon_version[16] = "Unknown";
4815
4816 err = Gestalt (gestaltCarbonVersion, &response);
4817 if (err == noErr)
4818 sprintf (carbon_version, "%u.%u.%u",
4819 (response >> 8) & 0xf, (response >> 4) & 0xf, response & 0xf);
4820 Vmac_carbon_version_string = build_string (carbon_version);
4821 }
4822 #endif /* TARGET_API_MAC_CARBON */
4823
4824 /* X window properties. */
4825 defsubr (&Sx_change_window_property);
4826 defsubr (&Sx_delete_window_property);
4827 defsubr (&Sx_window_property);
4828
4829 defsubr (&Sxw_display_color_p);
4830 defsubr (&Sx_display_grayscale_p);
4831 defsubr (&Sxw_color_defined_p);
4832 defsubr (&Sxw_color_values);
4833 defsubr (&Sx_server_max_request_size);
4834 defsubr (&Sx_server_vendor);
4835 defsubr (&Sx_server_version);
4836 defsubr (&Sx_display_pixel_width);
4837 defsubr (&Sx_display_pixel_height);
4838 defsubr (&Sx_display_mm_width);
4839 defsubr (&Sx_display_mm_height);
4840 defsubr (&Sx_display_screens);
4841 defsubr (&Sx_display_planes);
4842 defsubr (&Sx_display_color_cells);
4843 defsubr (&Sx_display_visual_class);
4844 defsubr (&Sx_display_backing_store);
4845 defsubr (&Sx_display_save_under);
4846 defsubr (&Sx_create_frame);
4847 defsubr (&Sx_open_connection);
4848 defsubr (&Sx_close_connection);
4849 defsubr (&Sx_display_list);
4850 defsubr (&Sx_synchronize);
4851 defsubr (&Sx_focus_frame);
4852
4853 /* Setting callback functions for fontset handler. */
4854 get_font_info_func = x_get_font_info;
4855
4856 #if 0 /* This function pointer doesn't seem to be used anywhere.
4857 And the pointer assigned has the wrong type, anyway. */
4858 list_fonts_func = x_list_fonts;
4859 #endif
4860
4861 load_font_func = x_load_font;
4862 find_ccl_program_func = x_find_ccl_program;
4863 query_font_func = x_query_font;
4864 set_frame_fontset_func = mac_set_font;
4865 check_window_system_func = check_mac;
4866
4867 hourglass_atimer = NULL;
4868 hourglass_shown_p = 0;
4869
4870 defsubr (&Sx_show_tip);
4871 defsubr (&Sx_hide_tip);
4872 tip_timer = Qnil;
4873 staticpro (&tip_timer);
4874 tip_frame = Qnil;
4875 staticpro (&tip_frame);
4876
4877 last_show_tip_args = Qnil;
4878 staticpro (&last_show_tip_args);
4879
4880 #if TARGET_API_MAC_CARBON
4881 defsubr (&Sx_file_dialog);
4882 #endif
4883 defsubr (&Smac_clear_font_name_table);
4884 #if USE_MAC_FONT_PANEL
4885 defsubr (&Smac_set_font_panel_visible_p);
4886 #endif
4887 #if USE_ATSUI
4888 defsubr (&Smac_atsu_font_face_attributes);
4889 #endif
4890 }
4891
4892 /* arch-tag: d7591289-f374-4377-b245-12f5dbbb8edc
4893 (do not change this comment) */