HCoop / bpt / emacs.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
(w32_wnd_proc): Force non-tooltip frames to respect the minimum tracking size.
[bpt/emacs.git] / src / macfns.c
1 /* Graphical user interface functions for Mac OS.
2 Copyright (C) 2000, 2001, 2002, 2003, 2004,
3 2005, 2006 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;
1973 #else
1974 FSSpec fss;
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 #ifdef MAC_OSX
2001 err = FSUpdateAlias (NULL, &fref, alias, &changed);
2002 #else
2003 err = UpdateAlias (NULL, &fss, alias, &changed);
2004 #endif
2005 }
2006 if (err != noErr || alias == NULL)
2007 {
2008 if (alias)
2009 DisposeHandle ((Handle) alias);
2010 #ifdef MAC_OSX
2011 err = FSNewAliasMinimal (&fref, &alias);
2012 #else
2013 err = NewAliasMinimal (&fss, &alias);
2014 #endif
2015 changed = true;
2016 }
2017 }
2018 if (err == noErr)
2019 if (changed)
2020 err = SetWindowProxyAlias (w, alias);
2021 }
2022
2023 if (alias)
2024 DisposeHandle ((Handle) alias);
2025
2026 if (err != noErr || !STRINGP (file_name))
2027 RemoveWindowProxy (w);
2028
2029 out:
2030 UNBLOCK_INPUT;
2031 }
2032 #endif
2033
2034 void
2035 mac_update_title_bar (f, save_match_data)
2036 struct frame *f;
2037 int save_match_data;
2038 {
2039 #if TARGET_API_MAC_CARBON
2040 struct window *w;
2041 int modified_p;
2042
2043 if (!FRAME_MAC_P (f))
2044 return;
2045
2046 w = XWINDOW (FRAME_SELECTED_WINDOW (f));
2047 modified_p = (BUF_SAVE_MODIFF (XBUFFER (w->buffer))
2048 < BUF_MODIFF (XBUFFER (w->buffer)));
2049 if (windows_or_buffers_changed
2050 /* Minibuffer modification status shown in the close button is
2051 confusing. */
2052 || (!MINI_WINDOW_P (w)
2053 && (modified_p != !NILP (w->last_had_star))))
2054 SetWindowModified (FRAME_MAC_WINDOW (f),
2055 !MINI_WINDOW_P (w) && modified_p);
2056
2057 if (windows_or_buffers_changed)
2058 mac_update_proxy_icon (f);
2059 #endif
2060 }
2061
2062 \f
2063 /* Subroutines of creating a frame. */
2064
2065 /* Retrieve the string resource specified by NAME with CLASS from
2066 database RDB.
2067
2068 The return value points to the contents of a Lisp string. So it
2069 will not be valid after the next GC where string compaction will
2070 occur. */
2071
2072 char *
2073 x_get_string_resource (rdb, name, class)
2074 XrmDatabase rdb;
2075 char *name, *class;
2076 {
2077 Lisp_Object value = xrm_get_resource (rdb, name, class);
2078
2079 if (STRINGP (value))
2080 return SDATA (value);
2081 else
2082 return NULL;
2083 }
2084
2085 /* Return the value of parameter PARAM.
2086
2087 First search ALIST, then Vdefault_frame_alist, then the X defaults
2088 database, using ATTRIBUTE as the attribute name and CLASS as its class.
2089
2090 Convert the resource to the type specified by desired_type.
2091
2092 If no default is specified, return Qunbound. If you call
2093 mac_get_arg, make sure you deal with Qunbound in a reasonable way,
2094 and don't let it get stored in any Lisp-visible variables! */
2095
2096 static Lisp_Object
2097 mac_get_arg (alist, param, attribute, class, type)
2098 Lisp_Object alist, param;
2099 char *attribute;
2100 char *class;
2101 enum resource_types type;
2102 {
2103 return x_get_arg (check_x_display_info (Qnil),
2104 alist, param, attribute, class, type);
2105 }
2106
2107 \f
2108 /* XParseGeometry copied from w32xfns.c */
2109
2110 /*
2111 * XParseGeometry parses strings of the form
2112 * "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
2113 * width, height, xoffset, and yoffset are unsigned integers.
2114 * Example: "=80x24+300-49"
2115 * The equal sign is optional.
2116 * It returns a bitmask that indicates which of the four values
2117 * were actually found in the string. For each value found,
2118 * the corresponding argument is updated; for each value
2119 * not found, the corresponding argument is left unchanged.
2120 */
2121
2122 static int
2123 read_integer (string, NextString)
2124 register char *string;
2125 char **NextString;
2126 {
2127 register int Result = 0;
2128 int Sign = 1;
2129
2130 if (*string == '+')
2131 string++;
2132 else if (*string == '-')
2133 {
2134 string++;
2135 Sign = -1;
2136 }
2137 for (; (*string >= '0') && (*string <= '9'); string++)
2138 {
2139 Result = (Result * 10) + (*string - '0');
2140 }
2141 *NextString = string;
2142 if (Sign >= 0)
2143 return (Result);
2144 else
2145 return (-Result);
2146 }
2147
2148 int
2149 XParseGeometry (string, x, y, width, height)
2150 char *string;
2151 int *x, *y;
2152 unsigned int *width, *height; /* RETURN */
2153 {
2154 int mask = NoValue;
2155 register char *strind;
2156 unsigned int tempWidth, tempHeight;
2157 int tempX, tempY;
2158 char *nextCharacter;
2159
2160 if ((string == NULL) || (*string == '\0')) return (mask);
2161 if (*string == '=')
2162 string++; /* ignore possible '=' at beg of geometry spec */
2163
2164 strind = (char *)string;
2165 if (*strind != '+' && *strind != '-' && *strind != 'x')
2166 {
2167 tempWidth = read_integer (strind, &nextCharacter);
2168 if (strind == nextCharacter)
2169 return (0);
2170 strind = nextCharacter;
2171 mask |= WidthValue;
2172 }
2173
2174 if (*strind == 'x' || *strind == 'X')
2175 {
2176 strind++;
2177 tempHeight = read_integer (strind, &nextCharacter);
2178 if (strind == nextCharacter)
2179 return (0);
2180 strind = nextCharacter;
2181 mask |= HeightValue;
2182 }
2183
2184 if ((*strind == '+') || (*strind == '-'))
2185 {
2186 if (*strind == '-')
2187 {
2188 strind++;
2189 tempX = -read_integer (strind, &nextCharacter);
2190 if (strind == nextCharacter)
2191 return (0);
2192 strind = nextCharacter;
2193 mask |= XNegative;
2194
2195 }
2196 else
2197 {
2198 strind++;
2199 tempX = read_integer (strind, &nextCharacter);
2200 if (strind == nextCharacter)
2201 return (0);
2202 strind = nextCharacter;
2203 }
2204 mask |= XValue;
2205 if ((*strind == '+') || (*strind == '-'))
2206 {
2207 if (*strind == '-')
2208 {
2209 strind++;
2210 tempY = -read_integer (strind, &nextCharacter);
2211 if (strind == nextCharacter)
2212 return (0);
2213 strind = nextCharacter;
2214 mask |= YNegative;
2215
2216 }
2217 else
2218 {
2219 strind++;
2220 tempY = read_integer (strind, &nextCharacter);
2221 if (strind == nextCharacter)
2222 return (0);
2223 strind = nextCharacter;
2224 }
2225 mask |= YValue;
2226 }
2227 }
2228
2229 /* If strind isn't at the end of the string the it's an invalid
2230 geometry specification. */
2231
2232 if (*strind != '\0') return (0);
2233
2234 if (mask & XValue)
2235 *x = tempX;
2236 if (mask & YValue)
2237 *y = tempY;
2238 if (mask & WidthValue)
2239 *width = tempWidth;
2240 if (mask & HeightValue)
2241 *height = tempHeight;
2242 return (mask);
2243 }
2244
2245 \f
2246 /* Create and set up the Mac window for frame F. */
2247
2248 static void
2249 mac_window (f)
2250 struct frame *f;
2251 {
2252 Rect r;
2253
2254 BLOCK_INPUT;
2255
2256 SetRect (&r, f->left_pos, f->top_pos,
2257 f->left_pos + FRAME_PIXEL_WIDTH (f),
2258 f->top_pos + FRAME_PIXEL_HEIGHT (f));
2259 #if TARGET_API_MAC_CARBON
2260 CreateNewWindow (kDocumentWindowClass,
2261 kWindowStandardDocumentAttributes
2262 #ifdef MAC_OSX
2263 | kWindowToolbarButtonAttribute
2264 #endif
2265 , &r, &FRAME_MAC_WINDOW (f));
2266 if (FRAME_MAC_WINDOW (f))
2267 {
2268 SetWRefCon (FRAME_MAC_WINDOW (f), (long) f->output_data.mac);
2269 if (install_window_handler (FRAME_MAC_WINDOW (f)) != noErr)
2270 {
2271 DisposeWindow (FRAME_MAC_WINDOW (f));
2272 FRAME_MAC_WINDOW (f) = NULL;
2273 }
2274 }
2275 #else
2276 FRAME_MAC_WINDOW (f)
2277 = NewCWindow (NULL, &r, "\p", false, zoomDocProc,
2278 (WindowPtr) -1, 1, (long) f->output_data.mac);
2279 #endif
2280 /* so that update events can find this mac_output struct */
2281 f->output_data.mac->mFP = f; /* point back to emacs frame */
2282
2283 #ifndef MAC_OSX
2284 if (FRAME_MAC_WINDOW (f))
2285 {
2286 ControlRef root_control;
2287
2288 if (CreateRootControl (FRAME_MAC_WINDOW (f), &root_control) != noErr)
2289 {
2290 DisposeWindow (FRAME_MAC_WINDOW (f));
2291 FRAME_MAC_WINDOW (f) = NULL;
2292 }
2293 }
2294 #endif
2295 if (FRAME_MAC_WINDOW (f))
2296 XSetWindowBackground (FRAME_MAC_DISPLAY(f), FRAME_MAC_WINDOW (f),
2297 FRAME_BACKGROUND_PIXEL (f));
2298
2299 validate_x_resource_name ();
2300
2301 /* x_set_name normally ignores requests to set the name if the
2302 requested name is the same as the current name. This is the one
2303 place where that assumption isn't correct; f->name is set, but
2304 the server hasn't been told. */
2305 {
2306 Lisp_Object name;
2307 int explicit = f->explicit_name;
2308
2309 f->explicit_name = 0;
2310 name = f->name;
2311 f->name = Qnil;
2312 x_set_name (f, name, explicit);
2313 }
2314
2315 UNBLOCK_INPUT;
2316
2317 if (FRAME_MAC_WINDOW (f) == 0)
2318 error ("Unable to create window");
2319 }
2320
2321 /* Handle the icon stuff for this window. Perhaps later we might
2322 want an x_set_icon_position which can be called interactively as
2323 well. */
2324
2325 static void
2326 x_icon (f, parms)
2327 struct frame *f;
2328 Lisp_Object parms;
2329 {
2330 Lisp_Object icon_x, icon_y;
2331
2332 /* Set the position of the icon. Note that Windows 95 groups all
2333 icons in the tray. */
2334 icon_x = mac_get_arg (parms, Qicon_left, 0, 0, RES_TYPE_NUMBER);
2335 icon_y = mac_get_arg (parms, Qicon_top, 0, 0, RES_TYPE_NUMBER);
2336 if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
2337 {
2338 CHECK_NUMBER (icon_x);
2339 CHECK_NUMBER (icon_y);
2340 }
2341 else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
2342 error ("Both left and top icon corners of icon must be specified");
2343
2344 BLOCK_INPUT;
2345
2346 if (! EQ (icon_x, Qunbound))
2347 x_wm_set_icon_position (f, XINT (icon_x), XINT (icon_y));
2348
2349 #if 0 /* TODO */
2350 /* Start up iconic or window? */
2351 x_wm_set_window_state
2352 (f, (EQ (w32_get_arg (parms, Qvisibility, 0, 0, RES_TYPE_SYMBOL), Qicon)
2353 ? IconicState
2354 : NormalState));
2355
2356 x_text_icon (f, (char *) SDATA ((!NILP (f->icon_name)
2357 ? f->icon_name
2358 : f->name)));
2359 #endif
2360
2361 UNBLOCK_INPUT;
2362 }
2363
2364
2365 void
2366 x_make_gc (f)
2367 struct frame *f;
2368 {
2369 XGCValues gc_values;
2370
2371 BLOCK_INPUT;
2372
2373 /* Create the GCs of this frame.
2374 Note that many default values are used. */
2375
2376 /* Normal video */
2377 gc_values.font = FRAME_FONT (f);
2378 gc_values.foreground = FRAME_FOREGROUND_PIXEL (f);
2379 gc_values.background = FRAME_BACKGROUND_PIXEL (f);
2380 f->output_data.mac->normal_gc = XCreateGC (FRAME_MAC_DISPLAY (f),
2381 FRAME_MAC_WINDOW (f),
2382 GCFont | GCForeground | GCBackground,
2383 &gc_values);
2384
2385 /* Reverse video style. */
2386 gc_values.foreground = FRAME_BACKGROUND_PIXEL (f);
2387 gc_values.background = FRAME_FOREGROUND_PIXEL (f);
2388 f->output_data.mac->reverse_gc = XCreateGC (FRAME_MAC_DISPLAY (f),
2389 FRAME_MAC_WINDOW (f),
2390 GCFont | GCForeground | GCBackground,
2391 &gc_values);
2392
2393 /* Cursor has cursor-color background, background-color foreground. */
2394 gc_values.foreground = FRAME_BACKGROUND_PIXEL (f);
2395 gc_values.background = f->output_data.mac->cursor_pixel;
2396 f->output_data.mac->cursor_gc = XCreateGC (FRAME_MAC_DISPLAY (f),
2397 FRAME_MAC_WINDOW (f),
2398 GCFont | GCForeground | GCBackground,
2399 &gc_values);
2400
2401 /* Reliefs. */
2402 f->output_data.mac->white_relief.gc = 0;
2403 f->output_data.mac->black_relief.gc = 0;
2404
2405 #if 0
2406 /* Create the gray border tile used when the pointer is not in
2407 the frame. Since this depends on the frame's pixel values,
2408 this must be done on a per-frame basis. */
2409 f->output_data.x->border_tile
2410 = (XCreatePixmapFromBitmapData
2411 (FRAME_X_DISPLAY (f), FRAME_X_DISPLAY_INFO (f)->root_window,
2412 gray_bits, gray_width, gray_height,
2413 f->output_data.x->foreground_pixel,
2414 f->output_data.x->background_pixel,
2415 DefaultDepth (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f))));
2416 #endif
2417
2418 UNBLOCK_INPUT;
2419 }
2420
2421
2422 /* Free what was was allocated in x_make_gc. */
2423
2424 void
2425 x_free_gcs (f)
2426 struct frame *f;
2427 {
2428 Display *dpy = FRAME_MAC_DISPLAY (f);
2429
2430 BLOCK_INPUT;
2431
2432 if (f->output_data.mac->normal_gc)
2433 {
2434 XFreeGC (dpy, f->output_data.mac->normal_gc);
2435 f->output_data.mac->normal_gc = 0;
2436 }
2437
2438 if (f->output_data.mac->reverse_gc)
2439 {
2440 XFreeGC (dpy, f->output_data.mac->reverse_gc);
2441 f->output_data.mac->reverse_gc = 0;
2442 }
2443
2444 if (f->output_data.mac->cursor_gc)
2445 {
2446 XFreeGC (dpy, f->output_data.mac->cursor_gc);
2447 f->output_data.mac->cursor_gc = 0;
2448 }
2449
2450 #if 0
2451 if (f->output_data.mac->border_tile)
2452 {
2453 XFreePixmap (dpy, f->output_data.mac->border_tile);
2454 f->output_data.mac->border_tile = 0;
2455 }
2456 #endif
2457
2458 if (f->output_data.mac->white_relief.gc)
2459 {
2460 XFreeGC (dpy, f->output_data.mac->white_relief.gc);
2461 f->output_data.mac->white_relief.gc = 0;
2462 }
2463
2464 if (f->output_data.mac->black_relief.gc)
2465 {
2466 XFreeGC (dpy, f->output_data.mac->black_relief.gc);
2467 f->output_data.mac->black_relief.gc = 0;
2468 }
2469
2470 UNBLOCK_INPUT;
2471 }
2472
2473
2474 /* Handler for signals raised during x_create_frame and
2475 x_create_top_frame. FRAME is the frame which is partially
2476 constructed. */
2477
2478 static Lisp_Object
2479 unwind_create_frame (frame)
2480 Lisp_Object frame;
2481 {
2482 struct frame *f = XFRAME (frame);
2483
2484 /* If frame is ``official'', nothing to do. */
2485 if (!CONSP (Vframe_list) || !EQ (XCAR (Vframe_list), frame))
2486 {
2487 #if GLYPH_DEBUG
2488 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
2489 #endif
2490
2491 x_free_frame_resources (f);
2492
2493 #if GLYPH_DEBUG
2494 /* Check that reference counts are indeed correct. */
2495 xassert (dpyinfo->reference_count == dpyinfo_refcount);
2496 xassert (dpyinfo->image_cache->refcount == image_cache_refcount);
2497 #endif
2498 return Qt;
2499 }
2500
2501 return Qnil;
2502 }
2503
2504
2505 DEFUN ("x-create-frame", Fx_create_frame, Sx_create_frame,
2506 1, 1, 0,
2507 doc: /* Make a new window, which is called a "frame" in Emacs terms.
2508 Returns an Emacs frame object.
2509 ALIST is an alist of frame parameters.
2510 If the parameters specify that the frame should not have a minibuffer,
2511 and do not specify a specific minibuffer window to use,
2512 then `default-minibuffer-frame' must be a frame whose minibuffer can
2513 be shared by the new frame.
2514
2515 This function is an internal primitive--use `make-frame' instead. */)
2516 (parms)
2517 Lisp_Object parms;
2518 {
2519 struct frame *f;
2520 Lisp_Object frame, tem;
2521 Lisp_Object name;
2522 int minibuffer_only = 0;
2523 long window_prompting = 0;
2524 int width, height;
2525 int count = SPECPDL_INDEX ();
2526 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
2527 Lisp_Object display;
2528 struct mac_display_info *dpyinfo = NULL;
2529 Lisp_Object parent;
2530 struct kboard *kb;
2531
2532 check_mac ();
2533
2534 parms = Fcopy_alist (parms);
2535
2536 /* Use this general default value to start with
2537 until we know if this frame has a specified name. */
2538 Vx_resource_name = Vinvocation_name;
2539
2540 display = mac_get_arg (parms, Qdisplay, 0, 0, RES_TYPE_STRING);
2541 if (EQ (display, Qunbound))
2542 display = Qnil;
2543 dpyinfo = check_x_display_info (display);
2544 #ifdef MULTI_KBOARD
2545 kb = dpyinfo->kboard;
2546 #else
2547 kb = &the_only_kboard;
2548 #endif
2549
2550 name = mac_get_arg (parms, Qname, "name", "Name", RES_TYPE_STRING);
2551 if (!STRINGP (name)
2552 && ! EQ (name, Qunbound)
2553 && ! NILP (name))
2554 error ("Invalid frame name--not a string or nil");
2555
2556 if (STRINGP (name))
2557 Vx_resource_name = name;
2558
2559 /* See if parent window is specified. */
2560 parent = mac_get_arg (parms, Qparent_id, NULL, NULL, RES_TYPE_NUMBER);
2561 if (EQ (parent, Qunbound))
2562 parent = Qnil;
2563 if (! NILP (parent))
2564 CHECK_NUMBER (parent);
2565
2566 /* make_frame_without_minibuffer can run Lisp code and garbage collect. */
2567 /* No need to protect DISPLAY because that's not used after passing
2568 it to make_frame_without_minibuffer. */
2569 frame = Qnil;
2570 GCPRO4 (parms, parent, name, frame);
2571 tem = mac_get_arg (parms, Qminibuffer, "minibuffer", "Minibuffer",
2572 RES_TYPE_SYMBOL);
2573 if (EQ (tem, Qnone) || NILP (tem))
2574 f = make_frame_without_minibuffer (Qnil, kb, display);
2575 else if (EQ (tem, Qonly))
2576 {
2577 f = make_minibuffer_frame ();
2578 minibuffer_only = 1;
2579 }
2580 else if (WINDOWP (tem))
2581 f = make_frame_without_minibuffer (tem, kb, display);
2582 else
2583 f = make_frame (1);
2584
2585 XSETFRAME (frame, f);
2586
2587 /* Note that X Windows does support scroll bars. */
2588 FRAME_CAN_HAVE_SCROLL_BARS (f) = 1;
2589
2590 f->output_method = output_mac;
2591 f->output_data.mac = (struct mac_output *) xmalloc (sizeof (struct mac_output));
2592 bzero (f->output_data.mac, sizeof (struct mac_output));
2593 FRAME_FONTSET (f) = -1;
2594
2595 f->icon_name
2596 = mac_get_arg (parms, Qicon_name, "iconName", "Title", RES_TYPE_STRING);
2597 if (! STRINGP (f->icon_name))
2598 f->icon_name = Qnil;
2599
2600 /* FRAME_MAC_DISPLAY_INFO (f) = dpyinfo; */
2601
2602 /* With FRAME_MAC_DISPLAY_INFO set up, this unwind-protect is safe. */
2603 record_unwind_protect (unwind_create_frame, frame);
2604 #if GLYPH_DEBUG
2605 image_cache_refcount = FRAME_X_IMAGE_CACHE (f)->refcount;
2606 dpyinfo_refcount = dpyinfo->reference_count;
2607 #endif /* GLYPH_DEBUG */
2608 #ifdef MULTI_KBOARD
2609 FRAME_KBOARD (f) = kb;
2610 #endif
2611
2612 /* Specify the parent under which to make this window. */
2613
2614 if (!NILP (parent))
2615 {
2616 f->output_data.mac->parent_desc = (Window) XFASTINT (parent);
2617 f->output_data.mac->explicit_parent = 1;
2618 }
2619 else
2620 {
2621 f->output_data.mac->parent_desc = FRAME_MAC_DISPLAY_INFO (f)->root_window;
2622 f->output_data.mac->explicit_parent = 0;
2623 }
2624
2625 /* Set the name; the functions to which we pass f expect the name to
2626 be set. */
2627 if (EQ (name, Qunbound) || NILP (name))
2628 {
2629 f->name = build_string (dpyinfo->mac_id_name);
2630 f->explicit_name = 0;
2631 }
2632 else
2633 {
2634 f->name = name;
2635 f->explicit_name = 1;
2636 /* use the frame's title when getting resources for this frame. */
2637 specbind (Qx_resource_name, name);
2638 }
2639
2640 /* Extract the window parameters from the supplied values
2641 that are needed to determine window geometry. */
2642 {
2643 Lisp_Object font;
2644
2645 font = mac_get_arg (parms, Qfont, "font", "Font", RES_TYPE_STRING);
2646
2647 BLOCK_INPUT;
2648 /* First, try whatever font the caller has specified. */
2649 if (STRINGP (font))
2650 {
2651 tem = Fquery_fontset (font, Qnil);
2652 if (STRINGP (tem))
2653 font = x_new_fontset (f, SDATA (tem));
2654 else
2655 font = x_new_font (f, SDATA (font));
2656 }
2657
2658 /* Try out a font which we hope has bold and italic variations. */
2659 #if USE_ATSUI
2660 if (! STRINGP (font))
2661 font = x_new_font (f, "-*-monaco-medium-r-normal--12-*-*-*-*-*-iso10646-1");
2662 #endif
2663 if (! STRINGP (font))
2664 font = x_new_font (f, "-ETL-fixed-medium-r-*--*-160-*-*-*-*-iso8859-1");
2665 /* If those didn't work, look for something which will at least work. */
2666 if (! STRINGP (font))
2667 font = x_new_fontset (f, "fontset-standard");
2668 if (! STRINGP (font))
2669 font = x_new_font (f, "-*-monaco-*-12-*-mac-roman");
2670 if (! STRINGP (font))
2671 font = x_new_font (f, "-*-courier-*-10-*-mac-roman");
2672 if (! STRINGP (font))
2673 error ("Cannot find any usable font");
2674 UNBLOCK_INPUT;
2675
2676 x_set_frame_parameters (f, Fcons (Fcons (Qfont, font), Qnil));
2677 }
2678
2679 x_default_parameter (f, parms, Qborder_width, make_number (0),
2680 "borderwidth", "BorderWidth", RES_TYPE_NUMBER);
2681 /* This defaults to 2 in order to match xterm. We recognize either
2682 internalBorderWidth or internalBorder (which is what xterm calls
2683 it). */
2684 if (NILP (Fassq (Qinternal_border_width, parms)))
2685 {
2686 Lisp_Object value;
2687
2688 value = mac_get_arg (parms, Qinternal_border_width,
2689 "internalBorder", "InternalBorder", RES_TYPE_NUMBER);
2690 if (! EQ (value, Qunbound))
2691 parms = Fcons (Fcons (Qinternal_border_width, value),
2692 parms);
2693 }
2694 /* Default internalBorderWidth to 0 on Windows to match other programs. */
2695 x_default_parameter (f, parms, Qinternal_border_width, make_number (0),
2696 "internalBorderWidth", "InternalBorder", RES_TYPE_NUMBER);
2697 x_default_parameter (f, parms, Qvertical_scroll_bars, Qright,
2698 "verticalScrollBars", "ScrollBars", RES_TYPE_SYMBOL);
2699
2700 /* Also do the stuff which must be set before the window exists. */
2701 x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
2702 "foreground", "Foreground", RES_TYPE_STRING);
2703 x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
2704 "background", "Background", RES_TYPE_STRING);
2705 x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
2706 "pointerColor", "Foreground", RES_TYPE_STRING);
2707 x_default_parameter (f, parms, Qcursor_color, build_string ("black"),
2708 "cursorColor", "Foreground", RES_TYPE_STRING);
2709 x_default_parameter (f, parms, Qborder_color, build_string ("black"),
2710 "borderColor", "BorderColor", RES_TYPE_STRING);
2711 x_default_parameter (f, parms, Qscreen_gamma, Qnil,
2712 "screenGamma", "ScreenGamma", RES_TYPE_FLOAT);
2713 x_default_parameter (f, parms, Qline_spacing, Qnil,
2714 "lineSpacing", "LineSpacing", RES_TYPE_NUMBER);
2715 x_default_parameter (f, parms, Qleft_fringe, Qnil,
2716 "leftFringe", "LeftFringe", RES_TYPE_NUMBER);
2717 x_default_parameter (f, parms, Qright_fringe, Qnil,
2718 "rightFringe", "RightFringe", RES_TYPE_NUMBER);
2719
2720
2721 /* Init faces before x_default_parameter is called for scroll-bar
2722 parameters because that function calls x_set_scroll_bar_width,
2723 which calls change_frame_size, which calls Fset_window_buffer,
2724 which runs hooks, which call Fvertical_motion. At the end, we
2725 end up in init_iterator with a null face cache, which should not
2726 happen. */
2727 init_frame_faces (f);
2728
2729 x_default_parameter (f, parms, Qmenu_bar_lines, make_number (1),
2730 "menuBar", "MenuBar", RES_TYPE_NUMBER);
2731 x_default_parameter (f, parms, Qtool_bar_lines, make_number (1),
2732 "toolBar", "ToolBar", RES_TYPE_NUMBER);
2733 x_default_parameter (f, parms, Qbuffer_predicate, Qnil,
2734 "bufferPredicate", "BufferPredicate",
2735 RES_TYPE_SYMBOL);
2736 x_default_parameter (f, parms, Qtitle, Qnil,
2737 "title", "Title", RES_TYPE_STRING);
2738 x_default_parameter (f, parms, Qfullscreen, Qnil,
2739 "fullscreen", "Fullscreen", RES_TYPE_SYMBOL);
2740
2741 f->output_data.mac->parent_desc = FRAME_MAC_DISPLAY_INFO (f)->root_window;
2742
2743 /* Compute the size of the window. */
2744 window_prompting = x_figure_window_size (f, parms, 1);
2745
2746 tem = mac_get_arg (parms, Qunsplittable, 0, 0, RES_TYPE_BOOLEAN);
2747 f->no_split = minibuffer_only || EQ (tem, Qt);
2748
2749 mac_window (f);
2750
2751 x_icon (f, parms);
2752 x_make_gc (f);
2753
2754 /* Now consider the frame official. */
2755 FRAME_MAC_DISPLAY_INFO (f)->reference_count++;
2756 Vframe_list = Fcons (frame, Vframe_list);
2757
2758 /* We need to do this after creating the window, so that the
2759 icon-creation functions can say whose icon they're describing. */
2760 x_default_parameter (f, parms, Qicon_type, Qnil,
2761 "bitmapIcon", "BitmapIcon", RES_TYPE_SYMBOL);
2762
2763 x_default_parameter (f, parms, Qauto_raise, Qnil,
2764 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
2765 x_default_parameter (f, parms, Qauto_lower, Qnil,
2766 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
2767 x_default_parameter (f, parms, Qcursor_type, Qbox,
2768 "cursorType", "CursorType", RES_TYPE_SYMBOL);
2769 x_default_parameter (f, parms, Qscroll_bar_width, Qnil,
2770 "scrollBarWidth", "ScrollBarWidth",
2771 RES_TYPE_NUMBER);
2772
2773 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
2774 Change will not be effected unless different from the current
2775 FRAME_LINES (f). */
2776 width = FRAME_COLS (f);
2777 height = FRAME_LINES (f);
2778
2779 SET_FRAME_COLS (f, 0);
2780 FRAME_LINES (f) = 0;
2781 change_frame_size (f, height, width, 1, 0, 0);
2782
2783 /* Tell the server what size and position, etc, we want, and how
2784 badly we want them. This should be done after we have the menu
2785 bar so that its size can be taken into account. */
2786 BLOCK_INPUT;
2787 x_wm_set_size_hint (f, window_prompting, 0);
2788 UNBLOCK_INPUT;
2789
2790 /* Make the window appear on the frame and enable display, unless
2791 the caller says not to. However, with explicit parent, Emacs
2792 cannot control visibility, so don't try. */
2793 if (! f->output_data.mac->explicit_parent)
2794 {
2795 Lisp_Object visibility;
2796
2797 visibility = mac_get_arg (parms, Qvisibility, 0, 0, RES_TYPE_SYMBOL);
2798 if (EQ (visibility, Qunbound))
2799 visibility = Qt;
2800
2801 if (EQ (visibility, Qicon))
2802 x_iconify_frame (f);
2803 else if (! NILP (visibility))
2804 x_make_frame_visible (f);
2805 else
2806 /* Must have been Qnil. */
2807 ;
2808 }
2809
2810 /* Initialize `default-minibuffer-frame' in case this is the first
2811 frame on this display device. */
2812 if (FRAME_HAS_MINIBUF_P (f)
2813 && (!FRAMEP (kb->Vdefault_minibuffer_frame)
2814 || !FRAME_LIVE_P (XFRAME (kb->Vdefault_minibuffer_frame))))
2815 kb->Vdefault_minibuffer_frame = frame;
2816
2817 /* All remaining specified parameters, which have not been "used"
2818 by x_get_arg and friends, now go in the misc. alist of the frame. */
2819 for (tem = parms; !NILP (tem); tem = XCDR (tem))
2820 if (CONSP (XCAR (tem)) && !NILP (XCAR (XCAR (tem))))
2821 f->param_alist = Fcons (XCAR (tem), f->param_alist);
2822
2823 UNGCPRO;
2824
2825 /* Make sure windows on this frame appear in calls to next-window
2826 and similar functions. */
2827 Vwindow_list = Qnil;
2828
2829 return unbind_to (count, frame);
2830 }
2831
2832
2833 /* FRAME is used only to get a handle on the X display. We don't pass the
2834 display info directly because we're called from frame.c, which doesn't
2835 know about that structure. */
2836
2837 Lisp_Object
2838 x_get_focus_frame (frame)
2839 struct frame *frame;
2840 {
2841 struct mac_display_info *dpyinfo = FRAME_MAC_DISPLAY_INFO (frame);
2842 Lisp_Object xfocus;
2843 if (! dpyinfo->x_focus_frame)
2844 return Qnil;
2845
2846 XSETFRAME (xfocus, dpyinfo->x_focus_frame);
2847 return xfocus;
2848 }
2849
2850
2851 DEFUN ("x-focus-frame", Fx_focus_frame, Sx_focus_frame, 1, 1, 0,
2852 doc: /* Set the input focus to FRAME.
2853 FRAME nil means use the selected frame. */)
2854 (frame)
2855 Lisp_Object frame;
2856 {
2857 struct frame *f = check_x_frame (frame);
2858
2859 BLOCK_INPUT;
2860 #ifdef MAC_OSX
2861 ActivateWindow (ActiveNonFloatingWindow (), false);
2862 ActivateWindow (FRAME_MAC_WINDOW (f), true);
2863 #else
2864 #if !TARGET_API_MAC_CARBON
2865 /* SelectWindow (Non-Carbon) does not issue deactivate events if the
2866 possibly inactive window that is to be selected is already the
2867 frontmost one. */
2868 SendBehind (FRAME_MAC_WINDOW (f), NULL);
2869 #endif
2870 /* This brings the window to the front. */
2871 SelectWindow (FRAME_MAC_WINDOW (f));
2872 #endif
2873 UNBLOCK_INPUT;
2874
2875 return Qnil;
2876 }
2877
2878 \f
2879 DEFUN ("xw-color-defined-p", Fxw_color_defined_p, Sxw_color_defined_p, 1, 2, 0,
2880 doc: /* Internal function called by `color-defined-p', which see. */)
2881 (color, frame)
2882 Lisp_Object color, frame;
2883 {
2884 XColor foo;
2885 FRAME_PTR f = check_x_frame (frame);
2886
2887 CHECK_STRING (color);
2888
2889 if (mac_defined_color (f, SDATA (color), &foo, 0))
2890 return Qt;
2891 else
2892 return Qnil;
2893 }
2894
2895 DEFUN ("xw-color-values", Fxw_color_values, Sxw_color_values, 1, 2, 0,
2896 doc: /* Internal function called by `color-values', which see. */)
2897 (color, frame)
2898 Lisp_Object color, frame;
2899 {
2900 XColor foo;
2901 FRAME_PTR f = check_x_frame (frame);
2902
2903 CHECK_STRING (color);
2904
2905 if (mac_defined_color (f, SDATA (color), &foo, 0))
2906 return list3 (make_number (foo.red),
2907 make_number (foo.green),
2908 make_number (foo.blue));
2909 else
2910 return Qnil;
2911 }
2912
2913 DEFUN ("xw-display-color-p", Fxw_display_color_p, Sxw_display_color_p, 0, 1, 0,
2914 doc: /* Internal function called by `display-color-p', which see. */)
2915 (display)
2916 Lisp_Object display;
2917 {
2918 struct mac_display_info *dpyinfo = check_x_display_info (display);
2919
2920 if (!dpyinfo->color_p)
2921 return Qnil;
2922
2923 return Qt;
2924 }
2925
2926 DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p, Sx_display_grayscale_p,
2927 0, 1, 0,
2928 doc: /* Return t if DISPLAY supports shades of gray.
2929 Note that color displays do support shades of gray.
2930 The optional argument DISPLAY specifies which display to ask about.
2931 DISPLAY should be either a frame or a display name (a string).
2932 If omitted or nil, that stands for the selected frame's display. */)
2933 (display)
2934 Lisp_Object display;
2935 {
2936 struct mac_display_info *dpyinfo = check_x_display_info (display);
2937
2938 if (dpyinfo->n_planes <= 1)
2939 return Qnil;
2940
2941 return Qt;
2942 }
2943
2944 DEFUN ("x-display-pixel-width", Fx_display_pixel_width, Sx_display_pixel_width,
2945 0, 1, 0,
2946 doc: /* Returns the width in pixels of DISPLAY.
2947 The optional argument DISPLAY specifies which display to ask about.
2948 DISPLAY should be either a frame or a display name (a string).
2949 If omitted or nil, that stands for the selected frame's display. */)
2950 (display)
2951 Lisp_Object display;
2952 {
2953 struct mac_display_info *dpyinfo = check_x_display_info (display);
2954
2955 return make_number (dpyinfo->width);
2956 }
2957
2958 DEFUN ("x-display-pixel-height", Fx_display_pixel_height,
2959 Sx_display_pixel_height, 0, 1, 0,
2960 doc: /* Returns the height in pixels of DISPLAY.
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 return make_number (dpyinfo->height);
2970 }
2971
2972 DEFUN ("x-display-planes", Fx_display_planes, Sx_display_planes,
2973 0, 1, 0,
2974 doc: /* Returns the number of bitplanes of DISPLAY.
2975 The optional argument DISPLAY specifies which display to ask about.
2976 DISPLAY should be either a frame or a display name (a string).
2977 If omitted or nil, that stands for the selected frame's display. */)
2978 (display)
2979 Lisp_Object display;
2980 {
2981 struct mac_display_info *dpyinfo = check_x_display_info (display);
2982
2983 return make_number (dpyinfo->n_planes);
2984 }
2985
2986 DEFUN ("x-display-color-cells", Fx_display_color_cells, Sx_display_color_cells,
2987 0, 1, 0,
2988 doc: /* Returns the number of color cells of DISPLAY.
2989 The optional argument DISPLAY specifies which display to ask about.
2990 DISPLAY should be either a frame or a display name (a string).
2991 If omitted or nil, that stands for the selected frame's display. */)
2992 (display)
2993 Lisp_Object display;
2994 {
2995 struct mac_display_info *dpyinfo = check_x_display_info (display);
2996
2997 /* We force 24+ bit depths to 24-bit to prevent an overflow. */
2998 return make_number (1 << min (dpyinfo->n_planes, 24));
2999 }
3000
3001 DEFUN ("x-server-max-request-size", Fx_server_max_request_size,
3002 Sx_server_max_request_size,
3003 0, 1, 0,
3004 doc: /* Returns the maximum request size of the server of DISPLAY.
3005 The optional argument DISPLAY specifies which display to ask about.
3006 DISPLAY should be either a frame or a display name (a string).
3007 If omitted or nil, that stands for the selected frame's display. */)
3008 (display)
3009 Lisp_Object display;
3010 {
3011 struct mac_display_info *dpyinfo = check_x_display_info (display);
3012
3013 return make_number (1);
3014 }
3015
3016 DEFUN ("x-server-vendor", Fx_server_vendor, Sx_server_vendor, 0, 1, 0,
3017 doc: /* Returns the "vendor ID" string of the Mac OS system (Apple).
3018 The optional argument DISPLAY specifies which display to ask about.
3019 DISPLAY should be either a frame or a display name (a string).
3020 If omitted or nil, that stands for the selected frame's display. */)
3021 (display)
3022 Lisp_Object display;
3023 {
3024 return build_string ("Apple Computers");
3025 }
3026
3027 DEFUN ("x-server-version", Fx_server_version, Sx_server_version, 0, 1, 0,
3028 doc: /* Returns the version numbers of the Mac OS system.
3029 The value is a list of three integers: the major and minor
3030 version numbers, and the vendor-specific release
3031 number. See also the function `x-server-vendor'.
3032
3033 The optional argument DISPLAY specifies which display to ask about.
3034 DISPLAY should be either a frame or a display name (a string).
3035 If omitted or nil, that stands for the selected frame's display. */)
3036 (display)
3037 Lisp_Object display;
3038 {
3039 UInt32 response, major, minor, bugfix;
3040 OSErr err;
3041
3042 BLOCK_INPUT;
3043 err = Gestalt (gestaltSystemVersion, &response);
3044 if (err == noErr)
3045 {
3046 if (response >= 0x00001040)
3047 {
3048 err = Gestalt (gestaltSystemVersionMajor, &major);
3049 if (err == noErr)
3050 err = Gestalt (gestaltSystemVersionMinor, &minor);
3051 if (err == noErr)
3052 err = Gestalt (gestaltSystemVersionBugFix, &bugfix);
3053 }
3054 else
3055 {
3056 bugfix = response & 0xf;
3057 response >>= 4;
3058 minor = response & 0xf;
3059 response >>= 4;
3060 /* convert BCD to int */
3061 major = response - (response >> 4) * 6;
3062 }
3063 }
3064 UNBLOCK_INPUT;
3065
3066 if (err != noErr)
3067 error ("Cannot get Mac OS version");
3068
3069 return Fcons (make_number (major),
3070 Fcons (make_number (minor),
3071 Fcons (make_number (bugfix),
3072 Qnil)));
3073 }
3074
3075 DEFUN ("x-display-screens", Fx_display_screens, Sx_display_screens, 0, 1, 0,
3076 doc: /* Return the number of screens on the server of DISPLAY.
3077 The optional argument DISPLAY specifies which display to ask about.
3078 DISPLAY should be either a frame or a display name (a string).
3079 If omitted or nil, that stands for the selected frame's display. */)
3080 (display)
3081 Lisp_Object display;
3082 {
3083 return make_number (1);
3084 }
3085
3086 DEFUN ("x-display-mm-height", Fx_display_mm_height, Sx_display_mm_height, 0, 1, 0,
3087 doc: /* Return the height in millimeters of DISPLAY.
3088 The optional argument DISPLAY specifies which display to ask about.
3089 DISPLAY should be either a frame or a display name (a string).
3090 If omitted or nil, that stands for the selected frame's display. */)
3091 (display)
3092 Lisp_Object display;
3093 {
3094 struct mac_display_info *dpyinfo = check_x_display_info (display);
3095
3096 /* Only of the main display. */
3097 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
3098 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
3099 if (CGDisplayScreenSize != NULL)
3100 #endif
3101 {
3102 CGSize size;
3103
3104 BLOCK_INPUT;
3105 size = CGDisplayScreenSize (kCGDirectMainDisplay);
3106 UNBLOCK_INPUT;
3107
3108 return make_number ((int) (size.height + .5f));
3109 }
3110 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
3111 else
3112 #endif
3113 #endif /* MAC_OS_X_VERSION_MAX_ALLOWED >= 1030 */
3114 #if MAC_OS_X_VERSION_MAX_ALLOWED < 1030 || MAC_OS_X_VERSION_MIN_REQUIRED == 1020
3115 {
3116 /* This is an approximation. */
3117 return make_number ((int) (dpyinfo->height * 25.4 / dpyinfo->resy));
3118 }
3119 #endif
3120 }
3121
3122 DEFUN ("x-display-mm-width", Fx_display_mm_width, Sx_display_mm_width, 0, 1, 0,
3123 doc: /* Return the width in millimeters of DISPLAY.
3124 The optional argument DISPLAY specifies which display to ask about.
3125 DISPLAY should be either a frame or a display name (a string).
3126 If omitted or nil, that stands for the selected frame's display. */)
3127 (display)
3128 Lisp_Object display;
3129 {
3130 struct mac_display_info *dpyinfo = check_x_display_info (display);
3131
3132 /* Only of the main display. */
3133 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1030
3134 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
3135 if (CGDisplayScreenSize != NULL)
3136 #endif
3137 {
3138 CGSize size;
3139
3140 BLOCK_INPUT;
3141 size = CGDisplayScreenSize (kCGDirectMainDisplay);
3142 UNBLOCK_INPUT;
3143
3144 return make_number ((int) (size.width + .5f));
3145 }
3146 #if MAC_OS_X_VERSION_MIN_REQUIRED == 1020
3147 else
3148 #endif
3149 #endif /* MAC_OS_X_VERSION_MAX_ALLOWED >= 1030 */
3150 #if MAC_OS_X_VERSION_MAX_ALLOWED < 1030 || MAC_OS_X_VERSION_MIN_REQUIRED == 1020
3151 {
3152 /* This is an approximation. */
3153 return make_number ((int) (dpyinfo->width * 25.4 / dpyinfo->resx));
3154 }
3155 #endif
3156 }
3157
3158 DEFUN ("x-display-backing-store", Fx_display_backing_store,
3159 Sx_display_backing_store, 0, 1, 0,
3160 doc: /* Returns an indication of whether DISPLAY does backing store.
3161 The value may be `always', `when-mapped', or `not-useful'.
3162 The optional argument DISPLAY specifies which display to ask about.
3163 DISPLAY should be either a frame or a display name (a string).
3164 If omitted or nil, that stands for the selected frame's display. */)
3165 (display)
3166 Lisp_Object display;
3167 {
3168 return intern ("not-useful");
3169 }
3170
3171 DEFUN ("x-display-visual-class", Fx_display_visual_class,
3172 Sx_display_visual_class, 0, 1, 0,
3173 doc: /* Returns the visual class of DISPLAY.
3174 The value is one of the symbols `static-gray', `gray-scale',
3175 `static-color', `pseudo-color', `true-color', or `direct-color'.
3176
3177 The optional argument DISPLAY specifies which display to ask about.
3178 DISPLAY should be either a frame or a display name (a string).
3179 If omitted or nil, that stands for the selected frame's display. */)
3180 (display)
3181 Lisp_Object display;
3182 {
3183 struct mac_display_info *dpyinfo = check_x_display_info (display);
3184
3185 #if 0
3186 switch (dpyinfo->visual->class)
3187 {
3188 case StaticGray: return (intern ("static-gray"));
3189 case GrayScale: return (intern ("gray-scale"));
3190 case StaticColor: return (intern ("static-color"));
3191 case PseudoColor: return (intern ("pseudo-color"));
3192 case TrueColor: return (intern ("true-color"));
3193 case DirectColor: return (intern ("direct-color"));
3194 default:
3195 error ("Display has an unknown visual class");
3196 }
3197 #endif /* 0 */
3198
3199 return (intern ("true-color"));
3200 }
3201
3202 DEFUN ("x-display-save-under", Fx_display_save_under,
3203 Sx_display_save_under, 0, 1, 0,
3204 doc: /* Returns t if DISPLAY supports the save-under feature.
3205 The optional argument DISPLAY specifies which display to ask about.
3206 DISPLAY should be either a frame or a display name (a string).
3207 If omitted or nil, that stands for the selected frame's display. */)
3208 (display)
3209 Lisp_Object display;
3210 {
3211 return Qnil;
3212 }
3213 \f
3214 int
3215 x_pixel_width (f)
3216 register struct frame *f;
3217 {
3218 return FRAME_PIXEL_WIDTH (f);
3219 }
3220
3221 int
3222 x_pixel_height (f)
3223 register struct frame *f;
3224 {
3225 return FRAME_PIXEL_HEIGHT (f);
3226 }
3227
3228 int
3229 x_char_width (f)
3230 register struct frame *f;
3231 {
3232 return FRAME_COLUMN_WIDTH (f);
3233 }
3234
3235 int
3236 x_char_height (f)
3237 register struct frame *f;
3238 {
3239 return FRAME_LINE_HEIGHT (f);
3240 }
3241
3242 int
3243 x_screen_planes (f)
3244 register struct frame *f;
3245 {
3246 return FRAME_MAC_DISPLAY_INFO (f)->n_planes;
3247 }
3248 \f
3249 /* Return the display structure for the display named NAME.
3250 Open a new connection if necessary. */
3251
3252 struct mac_display_info *
3253 x_display_info_for_name (name)
3254 Lisp_Object name;
3255 {
3256 Lisp_Object names;
3257 struct mac_display_info *dpyinfo;
3258
3259 CHECK_STRING (name);
3260
3261 if (! EQ (Vwindow_system, intern ("mac")))
3262 error ("Not using Mac native windows");
3263
3264 for (dpyinfo = &one_mac_display_info, names = x_display_name_list;
3265 dpyinfo;
3266 dpyinfo = dpyinfo->next, names = XCDR (names))
3267 {
3268 Lisp_Object tem;
3269 tem = Fstring_equal (XCAR (XCAR (names)), name);
3270 if (!NILP (tem))
3271 return dpyinfo;
3272 }
3273
3274 /* Use this general default value to start with. */
3275 Vx_resource_name = Vinvocation_name;
3276
3277 validate_x_resource_name ();
3278
3279 dpyinfo = mac_term_init (name, (unsigned char *) 0,
3280 (char *) SDATA (Vx_resource_name));
3281
3282 if (dpyinfo == 0)
3283 error ("Cannot connect to server %s", SDATA (name));
3284
3285 mac_in_use = 1;
3286 XSETFASTINT (Vwindow_system_version, 3);
3287
3288 return dpyinfo;
3289 }
3290
3291 DEFUN ("x-open-connection", Fx_open_connection, Sx_open_connection,
3292 1, 3, 0,
3293 doc: /* Open a connection to a server.
3294 DISPLAY is the name of the display to connect to.
3295 Optional second arg XRM-STRING is a string of resources in xrdb format.
3296 If the optional third arg MUST-SUCCEED is non-nil,
3297 terminate Emacs if we can't open the connection. */)
3298 (display, xrm_string, must_succeed)
3299 Lisp_Object display, xrm_string, must_succeed;
3300 {
3301 unsigned char *xrm_option;
3302 struct mac_display_info *dpyinfo;
3303
3304 CHECK_STRING (display);
3305 if (! NILP (xrm_string))
3306 CHECK_STRING (xrm_string);
3307
3308 if (! EQ (Vwindow_system, intern ("mac")))
3309 error ("Not using Mac native windows");
3310
3311 if (! NILP (xrm_string))
3312 xrm_option = (unsigned char *) SDATA (xrm_string);
3313 else
3314 xrm_option = (unsigned char *) 0;
3315
3316 validate_x_resource_name ();
3317
3318 /* This is what opens the connection and sets x_current_display.
3319 This also initializes many symbols, such as those used for input. */
3320 dpyinfo = mac_term_init (display, xrm_option,
3321 (char *) SDATA (Vx_resource_name));
3322
3323 if (dpyinfo == 0)
3324 {
3325 if (!NILP (must_succeed))
3326 fatal ("Cannot connect to server %s.\n",
3327 SDATA (display));
3328 else
3329 error ("Cannot connect to server %s", SDATA (display));
3330 }
3331
3332 mac_in_use = 1;
3333
3334 XSETFASTINT (Vwindow_system_version, 3);
3335 return Qnil;
3336 }
3337
3338 DEFUN ("x-close-connection", Fx_close_connection,
3339 Sx_close_connection, 1, 1, 0,
3340 doc: /* Close the connection to DISPLAY's server.
3341 For DISPLAY, specify either a frame or a display name (a string).
3342 If DISPLAY is nil, that stands for the selected frame's display. */)
3343 (display)
3344 Lisp_Object display;
3345 {
3346 struct mac_display_info *dpyinfo = check_x_display_info (display);
3347 int i;
3348
3349 if (dpyinfo->reference_count > 0)
3350 error ("Display still has frames on it");
3351
3352 BLOCK_INPUT;
3353 /* Free the fonts in the font table. */
3354 for (i = 0; i < dpyinfo->n_fonts; i++)
3355 if (dpyinfo->font_table[i].name)
3356 {
3357 mac_unload_font (dpyinfo, dpyinfo->font_table[i].font);
3358 }
3359
3360 x_destroy_all_bitmaps (dpyinfo);
3361
3362 x_delete_display (dpyinfo);
3363 UNBLOCK_INPUT;
3364
3365 return Qnil;
3366 }
3367
3368 DEFUN ("x-display-list", Fx_display_list, Sx_display_list, 0, 0, 0,
3369 doc: /* Return the list of display names that Emacs has connections to. */)
3370 ()
3371 {
3372 Lisp_Object tail, result;
3373
3374 result = Qnil;
3375 for (tail = x_display_name_list; ! NILP (tail); tail = XCDR (tail))
3376 result = Fcons (XCAR (XCAR (tail)), result);
3377
3378 return result;
3379 }
3380
3381 DEFUN ("x-synchronize", Fx_synchronize, Sx_synchronize, 1, 2, 0,
3382 doc: /* This is a noop on Mac OS systems. */)
3383 (on, display)
3384 Lisp_Object display, on;
3385 {
3386 return Qnil;
3387 }
3388
3389 /* x_sync is a no-op on Mac. */
3390
3391 void
3392 x_sync (f)
3393 FRAME_PTR f;
3394 {
3395 }
3396
3397 \f
3398 /***********************************************************************
3399 Window properties
3400 ***********************************************************************/
3401
3402 DEFUN ("x-change-window-property", Fx_change_window_property,
3403 Sx_change_window_property, 2, 6, 0,
3404 doc: /* Change window property PROP to VALUE on the X window of FRAME.
3405 VALUE may be a string or a list of conses, numbers and/or strings.
3406 If an element in the list is a string, it is converted to
3407 an Atom and the value of the Atom is used. If an element is a cons,
3408 it is converted to a 32 bit number where the car is the 16 top bits and the
3409 cdr is the lower 16 bits.
3410 FRAME nil or omitted means use the selected frame.
3411 If TYPE is given and non-nil, it is the name of the type of VALUE.
3412 If TYPE is not given or nil, the type is STRING.
3413 FORMAT gives the size in bits of each element if VALUE is a list.
3414 It must be one of 8, 16 or 32.
3415 If VALUE is a string or FORMAT is nil or not given, FORMAT defaults to 8.
3416 If OUTER_P is non-nil, the property is changed for the outer X window of
3417 FRAME. Default is to change on the edit X window.
3418
3419 Value is VALUE. */)
3420 (prop, value, frame, type, format, outer_p)
3421 Lisp_Object prop, value, frame, type, format, outer_p;
3422 {
3423 #if 0 /* MAC_TODO : port window properties to Mac */
3424 struct frame *f = check_x_frame (frame);
3425 Atom prop_atom;
3426
3427 CHECK_STRING (prop);
3428 CHECK_STRING (value);
3429
3430 BLOCK_INPUT;
3431 prop_atom = XInternAtom (FRAME_W32_DISPLAY (f), SDATA (prop), False);
3432 XChangeProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
3433 prop_atom, XA_STRING, 8, PropModeReplace,
3434 SDATA (value), SCHARS (value));
3435
3436 /* Make sure the property is set when we return. */
3437 XFlush (FRAME_W32_DISPLAY (f));
3438 UNBLOCK_INPUT;
3439
3440 #endif /* MAC_TODO */
3441
3442 return value;
3443 }
3444
3445
3446 DEFUN ("x-delete-window-property", Fx_delete_window_property,
3447 Sx_delete_window_property, 1, 2, 0,
3448 doc: /* Remove window property PROP from X window of FRAME.
3449 FRAME nil or omitted means use the selected frame. Value is PROP. */)
3450 (prop, frame)
3451 Lisp_Object prop, frame;
3452 {
3453 #if 0 /* MAC_TODO : port window properties to Mac */
3454
3455 struct frame *f = check_x_frame (frame);
3456 Atom prop_atom;
3457
3458 CHECK_STRING (prop);
3459 BLOCK_INPUT;
3460 prop_atom = XInternAtom (FRAME_W32_DISPLAY (f), SDATA (prop), False);
3461 XDeleteProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f), prop_atom);
3462
3463 /* Make sure the property is removed when we return. */
3464 XFlush (FRAME_W32_DISPLAY (f));
3465 UNBLOCK_INPUT;
3466 #endif /* MAC_TODO */
3467
3468 return prop;
3469 }
3470
3471
3472 DEFUN ("x-window-property", Fx_window_property, Sx_window_property,
3473 1, 2, 0,
3474 doc: /* Value is the value of window property PROP on FRAME.
3475 If FRAME is nil or omitted, use the selected frame. Value is nil
3476 if FRAME hasn't a property with name PROP or if PROP has no string
3477 value. */)
3478 (prop, frame)
3479 Lisp_Object prop, frame;
3480 {
3481 #if 0 /* MAC_TODO : port window properties to Mac */
3482
3483 struct frame *f = check_x_frame (frame);
3484 Atom prop_atom;
3485 int rc;
3486 Lisp_Object prop_value = Qnil;
3487 char *tmp_data = NULL;
3488 Atom actual_type;
3489 int actual_format;
3490 unsigned long actual_size, bytes_remaining;
3491
3492 CHECK_STRING (prop);
3493 BLOCK_INPUT;
3494 prop_atom = XInternAtom (FRAME_W32_DISPLAY (f), SDATA (prop), False);
3495 rc = XGetWindowProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
3496 prop_atom, 0, 0, False, XA_STRING,
3497 &actual_type, &actual_format, &actual_size,
3498 &bytes_remaining, (unsigned char **) &tmp_data);
3499 if (rc == Success)
3500 {
3501 int size = bytes_remaining;
3502
3503 XFree (tmp_data);
3504 tmp_data = NULL;
3505
3506 rc = XGetWindowProperty (FRAME_W32_DISPLAY (f), FRAME_W32_WINDOW (f),
3507 prop_atom, 0, bytes_remaining,
3508 False, XA_STRING,
3509 &actual_type, &actual_format,
3510 &actual_size, &bytes_remaining,
3511 (unsigned char **) &tmp_data);
3512 if (rc == Success)
3513 prop_value = make_string (tmp_data, size);
3514
3515 XFree (tmp_data);
3516 }
3517
3518 UNBLOCK_INPUT;
3519
3520 return prop_value;
3521
3522 #endif /* MAC_TODO */
3523 return Qnil;
3524 }
3525
3526
3527 \f
3528 /***********************************************************************
3529 Busy cursor
3530 ***********************************************************************/
3531
3532 /* If non-null, an asynchronous timer that, when it expires, displays
3533 an hourglass cursor on all frames. */
3534
3535 static struct atimer *hourglass_atimer;
3536
3537 /* Non-zero means an hourglass cursor is currently shown. */
3538
3539 static int hourglass_shown_p;
3540
3541 /* Number of seconds to wait before displaying an hourglass cursor. */
3542
3543 static Lisp_Object Vhourglass_delay;
3544
3545 /* Default number of seconds to wait before displaying an hourglass
3546 cursor. */
3547
3548 #define DEFAULT_HOURGLASS_DELAY 1
3549
3550 /* Function prototypes. */
3551
3552 static void show_hourglass P_ ((struct atimer *));
3553 static void hide_hourglass P_ ((void));
3554
3555 /* Return non-zero if houglass timer has been started or hourglass is shown. */
3556
3557 int
3558 hourglass_started ()
3559 {
3560 return hourglass_shown_p || hourglass_atimer != NULL;
3561 }
3562
3563
3564 /* Cancel a currently active hourglass timer, and start a new one. */
3565
3566 void
3567 start_hourglass ()
3568 {
3569 #ifdef MAC_OSX
3570 EMACS_TIME delay;
3571 int secs, usecs = 0;
3572
3573 /* Don't bother for ttys. */
3574 if (NILP (Vwindow_system))
3575 return;
3576
3577 cancel_hourglass ();
3578
3579 if (INTEGERP (Vhourglass_delay)
3580 && XINT (Vhourglass_delay) > 0)
3581 secs = XFASTINT (Vhourglass_delay);
3582 else if (FLOATP (Vhourglass_delay)
3583 && XFLOAT_DATA (Vhourglass_delay) > 0)
3584 {
3585 Lisp_Object tem;
3586 tem = Ftruncate (Vhourglass_delay, Qnil);
3587 secs = XFASTINT (tem);
3588 usecs = (XFLOAT_DATA (Vhourglass_delay) - secs) * 1000000;
3589 }
3590 else
3591 secs = DEFAULT_HOURGLASS_DELAY;
3592
3593 EMACS_SET_SECS_USECS (delay, secs, usecs);
3594 hourglass_atimer = start_atimer (ATIMER_RELATIVE, delay,
3595 show_hourglass, NULL);
3596 #endif /* MAC_OSX */
3597 }
3598
3599
3600 /* Cancel the hourglass cursor timer if active, hide a busy cursor if
3601 shown. */
3602
3603 void
3604 cancel_hourglass ()
3605 {
3606 #ifdef MAC_OSX
3607 if (hourglass_atimer)
3608 {
3609 cancel_atimer (hourglass_atimer);
3610 hourglass_atimer = NULL;
3611 }
3612
3613 if (hourglass_shown_p)
3614 hide_hourglass ();
3615 #endif /* MAC_OSX */
3616 }
3617
3618
3619 /* Timer function of hourglass_atimer. TIMER is equal to
3620 hourglass_atimer.
3621
3622 On Mac, busy status is shown by the progress indicator (chasing
3623 arrows) at the upper-right corner of each frame instead of the
3624 hourglass pointer. */
3625
3626 static void
3627 show_hourglass (timer)
3628 struct atimer *timer;
3629 {
3630 #if TARGET_API_MAC_CARBON
3631 /* The timer implementation will cancel this timer automatically
3632 after this function has run. Set hourglass_atimer to null
3633 so that we know the timer doesn't have to be canceled. */
3634 hourglass_atimer = NULL;
3635
3636 if (!hourglass_shown_p)
3637 {
3638 Lisp_Object rest, frame;
3639
3640 BLOCK_INPUT;
3641
3642 FOR_EACH_FRAME (rest, frame)
3643 {
3644 struct frame *f = XFRAME (frame);
3645
3646 if (FRAME_LIVE_P (f) && FRAME_MAC_P (f)
3647 && FRAME_MAC_WINDOW (f) != tip_window)
3648 {
3649 #if USE_CG_DRAWING
3650 mac_prepare_for_quickdraw (f);
3651 #endif
3652 if (!f->output_data.mac->hourglass_control)
3653 {
3654 Window w = FRAME_MAC_WINDOW (f);
3655 Rect r;
3656 ControlRef c;
3657
3658 GetWindowPortBounds (w, &r);
3659 r.left = r.right - HOURGLASS_WIDTH;
3660 r.bottom = r.top + HOURGLASS_HEIGHT;
3661 if (CreateChasingArrowsControl (w, &r, &c) == noErr)
3662 f->output_data.mac->hourglass_control = c;
3663 }
3664
3665 if (f->output_data.mac->hourglass_control)
3666 ShowControl (f->output_data.mac->hourglass_control);
3667 }
3668 }
3669
3670 hourglass_shown_p = 1;
3671 UNBLOCK_INPUT;
3672 }
3673 #endif /* TARGET_API_MAC_CARBON */
3674 }
3675
3676
3677 /* Hide the progress indicators on all frames, if it is currently
3678 shown. */
3679
3680 static void
3681 hide_hourglass ()
3682 {
3683 #if TARGET_API_MAC_CARBON
3684 if (hourglass_shown_p)
3685 {
3686 Lisp_Object rest, frame;
3687
3688 BLOCK_INPUT;
3689 FOR_EACH_FRAME (rest, frame)
3690 {
3691 struct frame *f = XFRAME (frame);
3692
3693 if (FRAME_MAC_P (f)
3694 /* Watch out for newly created frames. */
3695 && f->output_data.mac->hourglass_control)
3696 {
3697 #if USE_CG_DRAWING
3698 mac_prepare_for_quickdraw (f);
3699 #endif
3700 HideControl (f->output_data.mac->hourglass_control);
3701 }
3702 }
3703
3704 hourglass_shown_p = 0;
3705 UNBLOCK_INPUT;
3706 }
3707 #endif /* TARGET_API_MAC_CARBON */
3708 }
3709
3710
3711 \f
3712 /***********************************************************************
3713 Tool tips
3714 ***********************************************************************/
3715
3716 static Lisp_Object x_create_tip_frame P_ ((struct mac_display_info *,
3717 Lisp_Object, Lisp_Object));
3718 static void compute_tip_xy P_ ((struct frame *, Lisp_Object, Lisp_Object,
3719 Lisp_Object, int, int, int *, int *));
3720
3721 /* The frame of a currently visible tooltip. */
3722
3723 Lisp_Object tip_frame;
3724
3725 /* If non-nil, a timer started that hides the last tooltip when it
3726 fires. */
3727
3728 Lisp_Object tip_timer;
3729 Window tip_window;
3730
3731 /* If non-nil, a vector of 3 elements containing the last args
3732 with which x-show-tip was called. See there. */
3733
3734 Lisp_Object last_show_tip_args;
3735
3736 /* Maximum size for tooltips; a cons (COLUMNS . ROWS). */
3737
3738 Lisp_Object Vx_max_tooltip_size;
3739
3740
3741 static Lisp_Object
3742 unwind_create_tip_frame (frame)
3743 Lisp_Object frame;
3744 {
3745 Lisp_Object deleted;
3746
3747 deleted = unwind_create_frame (frame);
3748 if (EQ (deleted, Qt))
3749 {
3750 tip_window = NULL;
3751 tip_frame = Qnil;
3752 }
3753
3754 return deleted;
3755 }
3756
3757
3758 /* Create a frame for a tooltip on the display described by DPYINFO.
3759 PARMS is a list of frame parameters. TEXT is the string to
3760 display in the tip frame. Value is the frame.
3761
3762 Note that functions called here, esp. x_default_parameter can
3763 signal errors, for instance when a specified color name is
3764 undefined. We have to make sure that we're in a consistent state
3765 when this happens. */
3766
3767 static Lisp_Object
3768 x_create_tip_frame (dpyinfo, parms, text)
3769 struct mac_display_info *dpyinfo;
3770 Lisp_Object parms, text;
3771 {
3772 struct frame *f;
3773 Lisp_Object frame, tem;
3774 Lisp_Object name;
3775 long window_prompting = 0;
3776 int width, height;
3777 int count = SPECPDL_INDEX ();
3778 struct gcpro gcpro1, gcpro2, gcpro3;
3779 struct kboard *kb;
3780 int face_change_count_before = face_change_count;
3781 Lisp_Object buffer;
3782 struct buffer *old_buffer;
3783
3784 check_mac ();
3785
3786 parms = Fcopy_alist (parms);
3787
3788 #ifdef MULTI_KBOARD
3789 kb = dpyinfo->kboard;
3790 #else
3791 kb = &the_only_kboard;
3792 #endif
3793
3794 /* Get the name of the frame to use for resource lookup. */
3795 name = mac_get_arg (parms, Qname, "name", "Name", RES_TYPE_STRING);
3796 if (!STRINGP (name)
3797 && !EQ (name, Qunbound)
3798 && !NILP (name))
3799 error ("Invalid frame name--not a string or nil");
3800
3801 frame = Qnil;
3802 GCPRO3 (parms, name, frame);
3803 f = make_frame (1);
3804 XSETFRAME (frame, f);
3805
3806 buffer = Fget_buffer_create (build_string (" *tip*"));
3807 Fset_window_buffer (FRAME_ROOT_WINDOW (f), buffer, Qnil);
3808 old_buffer = current_buffer;
3809 set_buffer_internal_1 (XBUFFER (buffer));
3810 current_buffer->truncate_lines = Qnil;
3811 specbind (Qinhibit_read_only, Qt);
3812 specbind (Qinhibit_modification_hooks, Qt);
3813 Ferase_buffer ();
3814 Finsert (1, &text);
3815 set_buffer_internal_1 (old_buffer);
3816
3817 FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
3818 record_unwind_protect (unwind_create_tip_frame, frame);
3819
3820 /* By setting the output method, we're essentially saying that
3821 the frame is live, as per FRAME_LIVE_P. If we get a signal
3822 from this point on, x_destroy_window might screw up reference
3823 counts etc. */
3824 f->output_method = output_mac;
3825 f->output_data.mac =
3826 (struct mac_output *) xmalloc (sizeof (struct mac_output));
3827 bzero (f->output_data.mac, sizeof (struct mac_output));
3828
3829 FRAME_FONTSET (f) = -1;
3830 f->icon_name = Qnil;
3831 /* FRAME_X_DISPLAY_INFO (f) = dpyinfo; */
3832 #if GLYPH_DEBUG
3833 image_cache_refcount = FRAME_X_IMAGE_CACHE (f)->refcount;
3834 dpyinfo_refcount = dpyinfo->reference_count;
3835 #endif /* GLYPH_DEBUG */
3836 #ifdef MULTI_KBOARD
3837 FRAME_KBOARD (f) = kb;
3838 #endif
3839 f->output_data.mac->parent_desc = FRAME_MAC_DISPLAY_INFO (f)->root_window;
3840 f->output_data.mac->explicit_parent = 0;
3841
3842 /* Set the name; the functions to which we pass f expect the name to
3843 be set. */
3844 if (EQ (name, Qunbound) || NILP (name))
3845 {
3846 f->name = build_string (dpyinfo->mac_id_name);
3847 f->explicit_name = 0;
3848 }
3849 else
3850 {
3851 f->name = name;
3852 f->explicit_name = 1;
3853 /* use the frame's title when getting resources for this frame. */
3854 specbind (Qx_resource_name, name);
3855 }
3856
3857 /* Extract the window parameters from the supplied values that are
3858 needed to determine window geometry. */
3859 {
3860 Lisp_Object font;
3861
3862 font = mac_get_arg (parms, Qfont, "font", "Font", RES_TYPE_STRING);
3863
3864 BLOCK_INPUT;
3865 /* First, try whatever font the caller has specified. */
3866 if (STRINGP (font))
3867 {
3868 tem = Fquery_fontset (font, Qnil);
3869 if (STRINGP (tem))
3870 font = x_new_fontset (f, SDATA (tem));
3871 else
3872 font = x_new_font (f, SDATA (font));
3873 }
3874
3875 /* Try out a font which we hope has bold and italic variations. */
3876 #if USE_ATSUI
3877 if (! STRINGP (font))
3878 font = x_new_font (f, "-*-monaco-medium-r-normal--12-*-*-*-*-*-iso10646-1");
3879 #endif
3880 if (! STRINGP (font))
3881 font = x_new_font (f, "-ETL-fixed-medium-r-*--*-160-*-*-*-*-iso8859-1");
3882 /* If those didn't work, look for something which will at least work. */
3883 if (! STRINGP (font))
3884 font = x_new_fontset (f, "fontset-standard");
3885 if (! STRINGP (font))
3886 font = x_new_font (f, "-*-monaco-*-12-*-mac-roman");
3887 if (! STRINGP (font))
3888 font = x_new_font (f, "-*-courier-*-10-*-mac-roman");
3889 UNBLOCK_INPUT;
3890 if (! STRINGP (font))
3891 error ("Cannot find any usable font");
3892
3893 x_default_parameter (f, parms, Qfont, font,
3894 "font", "Font", RES_TYPE_STRING);
3895 }
3896
3897 x_default_parameter (f, parms, Qborder_width, make_number (2),
3898 "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
3899
3900 /* This defaults to 2 in order to match xterm. We recognize either
3901 internalBorderWidth or internalBorder (which is what xterm calls
3902 it). */
3903 if (NILP (Fassq (Qinternal_border_width, parms)))
3904 {
3905 Lisp_Object value;
3906
3907 value = mac_get_arg (parms, Qinternal_border_width,
3908 "internalBorder", "internalBorder", RES_TYPE_NUMBER);
3909 if (! EQ (value, Qunbound))
3910 parms = Fcons (Fcons (Qinternal_border_width, value),
3911 parms);
3912 }
3913
3914 x_default_parameter (f, parms, Qinternal_border_width, make_number (1),
3915 "internalBorderWidth", "internalBorderWidth",
3916 RES_TYPE_NUMBER);
3917
3918 /* Also do the stuff which must be set before the window exists. */
3919 x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
3920 "foreground", "Foreground", RES_TYPE_STRING);
3921 x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
3922 "background", "Background", RES_TYPE_STRING);
3923 x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
3924 "pointerColor", "Foreground", RES_TYPE_STRING);
3925 x_default_parameter (f, parms, Qcursor_color, build_string ("black"),
3926 "cursorColor", "Foreground", RES_TYPE_STRING);
3927 x_default_parameter (f, parms, Qborder_color, build_string ("black"),
3928 "borderColor", "BorderColor", RES_TYPE_STRING);
3929
3930 /* Init faces before x_default_parameter is called for scroll-bar
3931 parameters because that function calls x_set_scroll_bar_width,
3932 which calls change_frame_size, which calls Fset_window_buffer,
3933 which runs hooks, which call Fvertical_motion. At the end, we
3934 end up in init_iterator with a null face cache, which should not
3935 happen. */
3936 init_frame_faces (f);
3937
3938 f->output_data.mac->parent_desc = FRAME_MAC_DISPLAY_INFO (f)->root_window;
3939
3940 window_prompting = x_figure_window_size (f, parms, 0);
3941
3942 {
3943 Rect r;
3944
3945 BLOCK_INPUT;
3946 SetRect (&r, 0, 0, 1, 1);
3947 #if TARGET_API_MAC_CARBON
3948 if (CreateNewWindow (kHelpWindowClass,
3949 #if MAC_OS_X_VERSION_MAX_ALLOWED >= 1020
3950 kWindowIgnoreClicksAttribute |
3951 #endif
3952 kWindowNoUpdatesAttribute |
3953 kWindowNoActivatesAttribute,
3954 &r, &tip_window) == noErr)
3955 #else
3956 if (tip_window = NewCWindow (NULL, &r, "\p", false, plainDBox,
3957 NULL, false, 0L))
3958 #endif
3959 {
3960 FRAME_MAC_WINDOW (f) = tip_window;
3961 XSetWindowBackground (FRAME_MAC_DISPLAY(f), tip_window,
3962 FRAME_BACKGROUND_PIXEL (f));
3963 SetWRefCon (tip_window, (long) f->output_data.mac);
3964 /* so that update events can find this mac_output struct */
3965 f->output_data.mac->mFP = f;
3966 }
3967 UNBLOCK_INPUT;
3968 }
3969
3970 x_make_gc (f);
3971
3972 x_default_parameter (f, parms, Qauto_raise, Qnil,
3973 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
3974 x_default_parameter (f, parms, Qauto_lower, Qnil,
3975 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
3976 x_default_parameter (f, parms, Qcursor_type, Qbox,
3977 "cursorType", "CursorType", RES_TYPE_SYMBOL);
3978
3979 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
3980 Change will not be effected unless different from the current
3981 FRAME_LINES (f). */
3982 width = FRAME_COLS (f);
3983 height = FRAME_LINES (f);
3984 SET_FRAME_COLS (f, 0);
3985 FRAME_LINES (f) = 0;
3986 change_frame_size (f, height, width, 1, 0, 0);
3987
3988 /* Add `tooltip' frame parameter's default value. */
3989 if (NILP (Fframe_parameter (frame, intern ("tooltip"))))
3990 Fmodify_frame_parameters (frame, Fcons (Fcons (intern ("tooltip"), Qt),
3991 Qnil));
3992
3993 /* Set up faces after all frame parameters are known. This call
3994 also merges in face attributes specified for new frames.
3995
3996 Frame parameters may be changed if .Xdefaults contains
3997 specifications for the default font. For example, if there is an
3998 `Emacs.default.attributeBackground: pink', the `background-color'
3999 attribute of the frame get's set, which let's the internal border
4000 of the tooltip frame appear in pink. Prevent this. */
4001 {
4002 Lisp_Object bg = Fframe_parameter (frame, Qbackground_color);
4003
4004 /* Set tip_frame here, so that */
4005 tip_frame = frame;
4006 call1 (Qface_set_after_frame_default, frame);
4007
4008 if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
4009 Fmodify_frame_parameters (frame, Fcons (Fcons (Qbackground_color, bg),
4010 Qnil));
4011 }
4012
4013 f->no_split = 1;
4014
4015 UNGCPRO;
4016
4017 /* It is now ok to make the frame official even if we get an error
4018 below. And the frame needs to be on Vframe_list or making it
4019 visible won't work. */
4020 Vframe_list = Fcons (frame, Vframe_list);
4021
4022 /* Now that the frame is official, it counts as a reference to
4023 its display. */
4024 FRAME_MAC_DISPLAY_INFO (f)->reference_count++;
4025
4026 /* Setting attributes of faces of the tooltip frame from resources
4027 and similar will increment face_change_count, which leads to the
4028 clearing of all current matrices. Since this isn't necessary
4029 here, avoid it by resetting face_change_count to the value it
4030 had before we created the tip frame. */
4031 face_change_count = face_change_count_before;
4032
4033 /* Discard the unwind_protect. */
4034 return unbind_to (count, frame);
4035 }
4036
4037
4038 /* Compute where to display tip frame F. PARMS is the list of frame
4039 parameters for F. DX and DY are specified offsets from the current
4040 location of the mouse. WIDTH and HEIGHT are the width and height
4041 of the tooltip. Return coordinates relative to the root window of
4042 the display in *ROOT_X, and *ROOT_Y. */
4043
4044 static void
4045 compute_tip_xy (f, parms, dx, dy, width, height, root_x, root_y)
4046 struct frame *f;
4047 Lisp_Object parms, dx, dy;
4048 int width, height;
4049 int *root_x, *root_y;
4050 {
4051 Lisp_Object left, top;
4052
4053 /* User-specified position? */
4054 left = Fcdr (Fassq (Qleft, parms));
4055 top = Fcdr (Fassq (Qtop, parms));
4056
4057 /* Move the tooltip window where the mouse pointer is. Resize and
4058 show it. */
4059 if (!INTEGERP (left) || !INTEGERP (top))
4060 {
4061 Point mouse_pos;
4062
4063 BLOCK_INPUT;
4064 GetMouse (&mouse_pos);
4065 LocalToGlobal (&mouse_pos);
4066 *root_x = mouse_pos.h;
4067 *root_y = mouse_pos.v;
4068 UNBLOCK_INPUT;
4069 }
4070
4071 if (INTEGERP (top))
4072 *root_y = XINT (top);
4073 else if (*root_y + XINT (dy) <= 0)
4074 *root_y = 0; /* Can happen for negative dy */
4075 else if (*root_y + XINT (dy) + height <= FRAME_MAC_DISPLAY_INFO (f)->height)
4076 /* It fits below the pointer */
4077 *root_y += XINT (dy);
4078 else if (height + XINT (dy) <= *root_y)
4079 /* It fits above the pointer. */
4080 *root_y -= height + XINT (dy);
4081 else
4082 /* Put it on the top. */
4083 *root_y = 0;
4084
4085 if (INTEGERP (left))
4086 *root_x = XINT (left);
4087 else if (*root_x + XINT (dx) <= 0)
4088 *root_x = 0; /* Can happen for negative dx */
4089 else if (*root_x + XINT (dx) + width <= FRAME_MAC_DISPLAY_INFO (f)->width)
4090 /* It fits to the right of the pointer. */
4091 *root_x += XINT (dx);
4092 else if (width + XINT (dx) <= *root_x)
4093 /* It fits to the left of the pointer. */
4094 *root_x -= width + XINT (dx);
4095 else
4096 /* Put it left-justified on the screen -- it ought to fit that way. */
4097 *root_x = 0;
4098 }
4099
4100
4101 DEFUN ("x-show-tip", Fx_show_tip, Sx_show_tip, 1, 6, 0,
4102 doc: /* Show STRING in a "tooltip" window on frame FRAME.
4103 A tooltip window is a small window displaying a string.
4104
4105 FRAME nil or omitted means use the selected frame.
4106
4107 PARMS is an optional list of frame parameters which can be used to
4108 change the tooltip's appearance.
4109
4110 Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
4111 means use the default timeout of 5 seconds.
4112
4113 If the list of frame parameters PARMS contains a `left' parameter,
4114 the tooltip is displayed at that x-position. Otherwise it is
4115 displayed at the mouse position, with offset DX added (default is 5 if
4116 DX isn't specified). Likewise for the y-position; if a `top' frame
4117 parameter is specified, it determines the y-position of the tooltip
4118 window, otherwise it is displayed at the mouse position, with offset
4119 DY added (default is -10).
4120
4121 A tooltip's maximum size is specified by `x-max-tooltip-size'.
4122 Text larger than the specified size is clipped. */)
4123 (string, frame, parms, timeout, dx, dy)
4124 Lisp_Object string, frame, parms, timeout, dx, dy;
4125 {
4126 struct frame *f;
4127 struct window *w;
4128 int root_x, root_y;
4129 struct buffer *old_buffer;
4130 struct text_pos pos;
4131 int i, width, height;
4132 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
4133 int old_windows_or_buffers_changed = windows_or_buffers_changed;
4134 int count = SPECPDL_INDEX ();
4135
4136 specbind (Qinhibit_redisplay, Qt);
4137
4138 GCPRO4 (string, parms, frame, timeout);
4139
4140 CHECK_STRING (string);
4141 f = check_x_frame (frame);
4142 if (NILP (timeout))
4143 timeout = make_number (5);
4144 else
4145 CHECK_NATNUM (timeout);
4146
4147 if (NILP (dx))
4148 dx = make_number (5);
4149 else
4150 CHECK_NUMBER (dx);
4151
4152 if (NILP (dy))
4153 dy = make_number (-10);
4154 else
4155 CHECK_NUMBER (dy);
4156
4157 if (NILP (last_show_tip_args))
4158 last_show_tip_args = Fmake_vector (make_number (3), Qnil);
4159
4160 if (!NILP (tip_frame))
4161 {
4162 Lisp_Object last_string = AREF (last_show_tip_args, 0);
4163 Lisp_Object last_frame = AREF (last_show_tip_args, 1);
4164 Lisp_Object last_parms = AREF (last_show_tip_args, 2);
4165
4166 if (EQ (frame, last_frame)
4167 && !NILP (Fequal (last_string, string))
4168 && !NILP (Fequal (last_parms, parms)))
4169 {
4170 struct frame *f = XFRAME (tip_frame);
4171
4172 /* Only DX and DY have changed. */
4173 if (!NILP (tip_timer))
4174 {
4175 Lisp_Object timer = tip_timer;
4176 tip_timer = Qnil;
4177 call1 (Qcancel_timer, timer);
4178 }
4179
4180 BLOCK_INPUT;
4181 compute_tip_xy (f, parms, dx, dy, FRAME_PIXEL_WIDTH (f),
4182 FRAME_PIXEL_HEIGHT (f), &root_x, &root_y);
4183 MoveWindow (FRAME_MAC_WINDOW (f), root_x, root_y, false);
4184 UNBLOCK_INPUT;
4185 goto start_timer;
4186 }
4187 }
4188
4189 /* Hide a previous tip, if any. */
4190 Fx_hide_tip ();
4191
4192 ASET (last_show_tip_args, 0, string);
4193 ASET (last_show_tip_args, 1, frame);
4194 ASET (last_show_tip_args, 2, parms);
4195
4196 /* Add default values to frame parameters. */
4197 if (NILP (Fassq (Qname, parms)))
4198 parms = Fcons (Fcons (Qname, build_string ("tooltip")), parms);
4199 if (NILP (Fassq (Qinternal_border_width, parms)))
4200 parms = Fcons (Fcons (Qinternal_border_width, make_number (3)), parms);
4201 if (NILP (Fassq (Qborder_width, parms)))
4202 parms = Fcons (Fcons (Qborder_width, make_number (1)), parms);
4203 if (NILP (Fassq (Qborder_color, parms)))
4204 parms = Fcons (Fcons (Qborder_color, build_string ("lightyellow")), parms);
4205 if (NILP (Fassq (Qbackground_color, parms)))
4206 parms = Fcons (Fcons (Qbackground_color, build_string ("lightyellow")),
4207 parms);
4208
4209 /* Create a frame for the tooltip, and record it in the global
4210 variable tip_frame. */
4211 frame = x_create_tip_frame (FRAME_MAC_DISPLAY_INFO (f), parms, string);
4212 f = XFRAME (frame);
4213
4214 /* Set up the frame's root window. */
4215 w = XWINDOW (FRAME_ROOT_WINDOW (f));
4216 w->left_col = w->top_line = make_number (0);
4217
4218 if (CONSP (Vx_max_tooltip_size)
4219 && INTEGERP (XCAR (Vx_max_tooltip_size))
4220 && XINT (XCAR (Vx_max_tooltip_size)) > 0
4221 && INTEGERP (XCDR (Vx_max_tooltip_size))
4222 && XINT (XCDR (Vx_max_tooltip_size)) > 0)
4223 {
4224 w->total_cols = XCAR (Vx_max_tooltip_size);
4225 w->total_lines = XCDR (Vx_max_tooltip_size);
4226 }
4227 else
4228 {
4229 w->total_cols = make_number (80);
4230 w->total_lines = make_number (40);
4231 }
4232
4233 FRAME_TOTAL_COLS (f) = XINT (w->total_cols);
4234 adjust_glyphs (f);
4235 w->pseudo_window_p = 1;
4236
4237 /* Display the tooltip text in a temporary buffer. */
4238 old_buffer = current_buffer;
4239 set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f))->buffer));
4240 current_buffer->truncate_lines = Qnil;
4241 clear_glyph_matrix (w->desired_matrix);
4242 clear_glyph_matrix (w->current_matrix);
4243 SET_TEXT_POS (pos, BEGV, BEGV_BYTE);
4244 try_window (FRAME_ROOT_WINDOW (f), pos, 0);
4245
4246 /* Compute width and height of the tooltip. */
4247 width = height = 0;
4248 for (i = 0; i < w->desired_matrix->nrows; ++i)
4249 {
4250 struct glyph_row *row = &w->desired_matrix->rows[i];
4251 struct glyph *last;
4252 int row_width;
4253
4254 /* Stop at the first empty row at the end. */
4255 if (!row->enabled_p || !row->displays_text_p)
4256 break;
4257
4258 /* Let the row go over the full width of the frame. */
4259 row->full_width_p = 1;
4260
4261 /* There's a glyph at the end of rows that is used to place
4262 the cursor there. Don't include the width of this glyph. */
4263 if (row->used[TEXT_AREA])
4264 {
4265 last = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
4266 row_width = row->pixel_width - last->pixel_width;
4267 }
4268 else
4269 row_width = row->pixel_width;
4270
4271 height += row->height;
4272 width = max (width, row_width);
4273 }
4274
4275 /* Add the frame's internal border to the width and height the X
4276 window should have. */
4277 height += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
4278 width += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
4279
4280 /* Move the tooltip window where the mouse pointer is. Resize and
4281 show it. */
4282 compute_tip_xy (f, parms, dx, dy, width, height, &root_x, &root_y);
4283
4284 BLOCK_INPUT;
4285 MoveWindow (FRAME_MAC_WINDOW (f), root_x, root_y, false);
4286 SizeWindow (FRAME_MAC_WINDOW (f), width, height, true);
4287 ShowWindow (FRAME_MAC_WINDOW (f));
4288 BringToFront (FRAME_MAC_WINDOW (f));
4289 UNBLOCK_INPUT;
4290
4291 FRAME_PIXEL_WIDTH (f) = width;
4292 FRAME_PIXEL_HEIGHT (f) = height;
4293
4294 /* Draw into the window. */
4295 w->must_be_updated_p = 1;
4296 update_single_window (w, 1);
4297
4298 /* Restore original current buffer. */
4299 set_buffer_internal_1 (old_buffer);
4300 windows_or_buffers_changed = old_windows_or_buffers_changed;
4301
4302 start_timer:
4303 /* Let the tip disappear after timeout seconds. */
4304 tip_timer = call3 (intern ("run-at-time"), timeout, Qnil,
4305 intern ("x-hide-tip"));
4306
4307 UNGCPRO;
4308 return unbind_to (count, Qnil);
4309 }
4310
4311
4312 DEFUN ("x-hide-tip", Fx_hide_tip, Sx_hide_tip, 0, 0, 0,
4313 doc: /* Hide the current tooltip window, if there is any.
4314 Value is t if tooltip was open, nil otherwise. */)
4315 ()
4316 {
4317 int count;
4318 Lisp_Object deleted, frame, timer;
4319 struct gcpro gcpro1, gcpro2;
4320
4321 /* Return quickly if nothing to do. */
4322 if (NILP (tip_timer) && NILP (tip_frame))
4323 return Qnil;
4324
4325 frame = tip_frame;
4326 timer = tip_timer;
4327 GCPRO2 (frame, timer);
4328 tip_frame = tip_timer = deleted = Qnil;
4329
4330 count = SPECPDL_INDEX ();
4331 specbind (Qinhibit_redisplay, Qt);
4332 specbind (Qinhibit_quit, Qt);
4333
4334 if (!NILP (timer))
4335 call1 (Qcancel_timer, timer);
4336
4337 if (FRAMEP (frame))
4338 {
4339 Fdelete_frame (frame, Qnil);
4340 deleted = Qt;
4341 }
4342
4343 UNGCPRO;
4344 return unbind_to (count, deleted);
4345 }
4346
4347
4348 \f
4349 #if TARGET_API_MAC_CARBON
4350 /***********************************************************************
4351 File selection dialog
4352 ***********************************************************************/
4353
4354 static pascal void mac_nav_event_callback P_ ((NavEventCallbackMessage,
4355 NavCBRecPtr, void *));
4356
4357 /**
4358 There is a relatively standard way to do this using applescript to run
4359 a (choose file) method. However, this doesn't do "the right thing"
4360 by working only if the find-file occurred during a menu or toolbar
4361 click. So we must do the file dialog by hand, using the navigation
4362 manager. This also has more flexibility in determining the default
4363 directory and whether or not we are going to choose a file.
4364 **/
4365
4366 extern Lisp_Object Qfile_name_history;
4367
4368 DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
4369 doc: /* Read file name, prompting with PROMPT in directory DIR.
4370 Use a file selection dialog.
4371 Select DEFAULT-FILENAME in the dialog's file selection box, if
4372 specified. Ensure that file exists if MUSTMATCH is non-nil.
4373 If ONLY-DIR-P is non-nil, the user can only select directories. */)
4374 (prompt, dir, default_filename, mustmatch, only_dir_p)
4375 Lisp_Object prompt, dir, default_filename, mustmatch, only_dir_p;
4376 {
4377 Lisp_Object file = Qnil;
4378 int count = SPECPDL_INDEX ();
4379 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
4380 char filename[MAXPATHLEN];
4381 static NavEventUPP mac_nav_event_callbackUPP = NULL;
4382
4383 check_mac ();
4384
4385 GCPRO6 (prompt, dir, default_filename, mustmatch, file, only_dir_p);
4386 CHECK_STRING (prompt);
4387 CHECK_STRING (dir);
4388
4389 /* Create the dialog with PROMPT as title, using DIR as initial
4390 directory and using "*" as pattern. */
4391 dir = Fexpand_file_name (dir, Qnil);
4392
4393 {
4394 OSStatus status;
4395 NavDialogCreationOptions options;
4396 NavDialogRef dialogRef;
4397 NavTypeListHandle fileTypes = NULL;
4398 NavUserAction userAction;
4399 CFStringRef message=NULL, saveName = NULL;
4400
4401 BLOCK_INPUT;
4402 /* No need for a callback function because we are modal */
4403 NavGetDefaultDialogCreationOptions(&options);
4404 options.modality = kWindowModalityAppModal;
4405 options.location.h = options.location.v = -1;
4406 options.optionFlags = kNavDefaultNavDlogOptions;
4407 options.optionFlags |= kNavAllFilesInPopup; /* All files allowed */
4408 options.optionFlags |= kNavSelectAllReadableItem;
4409 options.optionFlags &= ~kNavAllowMultipleFiles;
4410 if (!NILP(prompt))
4411 {
4412 message = cfstring_create_with_string (prompt);
4413 options.message = message;
4414 }
4415 /* Don't set the application, let it use default.
4416 options.clientName = CFSTR ("Emacs");
4417 */
4418
4419 if (mac_nav_event_callbackUPP == NULL)
4420 mac_nav_event_callbackUPP = NewNavEventUPP (mac_nav_event_callback);
4421
4422 if (!NILP (only_dir_p))
4423 status = NavCreateChooseFolderDialog(&options, mac_nav_event_callbackUPP,
4424 NULL, NULL, &dialogRef);
4425 else if (NILP (mustmatch))
4426 {
4427 /* This is a save dialog */
4428 options.optionFlags |= kNavDontConfirmReplacement;
4429 options.actionButtonLabel = CFSTR ("Ok");
4430 options.windowTitle = CFSTR ("Enter name");
4431
4432 if (STRINGP (default_filename))
4433 {
4434 Lisp_Object utf8 = ENCODE_UTF_8 (default_filename);
4435 char *begPtr = SDATA(utf8);
4436 char *filePtr = begPtr + SBYTES(utf8);
4437 while (filePtr != begPtr && !IS_DIRECTORY_SEP(filePtr[-1]))
4438 filePtr--;
4439 saveName = cfstring_create_with_utf8_cstring (filePtr);
4440 options.saveFileName = saveName;
4441 options.optionFlags |= kNavSelectDefaultLocation;
4442 }
4443 status = NavCreatePutFileDialog(&options,
4444 'TEXT', kNavGenericSignature,
4445 mac_nav_event_callbackUPP, NULL,
4446 &dialogRef);
4447 }
4448 else
4449 {
4450 /* This is an open dialog*/
4451 status = NavCreateChooseFileDialog(&options, fileTypes,
4452 mac_nav_event_callbackUPP, NULL,
4453 NULL, NULL, &dialogRef);
4454 }
4455
4456 /* Set the default location and continue*/
4457 if (status == noErr)
4458 {
4459 Lisp_Object encoded_dir = ENCODE_FILE (dir);
4460 AEDesc defLocAed;
4461
4462 status = AECreateDesc (TYPE_FILE_NAME, SDATA (encoded_dir),
4463 SBYTES (encoded_dir), &defLocAed);
4464 if (status == noErr)
4465 {
4466 NavCustomControl(dialogRef, kNavCtlSetLocation, (void*) &defLocAed);
4467 AEDisposeDesc(&defLocAed);
4468 }
4469 status = NavDialogRun(dialogRef);
4470 }
4471
4472 if (saveName) CFRelease(saveName);
4473 if (message) CFRelease(message);
4474
4475 if (status == noErr) {
4476 userAction = NavDialogGetUserAction(dialogRef);
4477 switch (userAction)
4478 {
4479 case kNavUserActionNone:
4480 case kNavUserActionCancel:
4481 break; /* Treat cancel like C-g */
4482 case kNavUserActionOpen:
4483 case kNavUserActionChoose:
4484 case kNavUserActionSaveAs:
4485 {
4486 NavReplyRecord reply;
4487 Size len;
4488
4489 status = NavDialogGetReply(dialogRef, &reply);
4490 if (status != noErr)
4491 break;
4492 status = AEGetNthPtr (&reply.selection, 1, TYPE_FILE_NAME,
4493 NULL, NULL, filename,
4494 sizeof (filename) - 1, &len);
4495 if (status == noErr)
4496 {
4497 len = min (len, sizeof (filename) - 1);
4498 filename[len] = '\0';
4499 if (reply.saveFileName)
4500 {
4501 /* If it was a saved file, we need to add the file name */
4502 if (len && len < sizeof (filename) - 1
4503 && filename[len-1] != '/')
4504 filename[len++] = '/';
4505 CFStringGetCString(reply.saveFileName, filename+len,
4506 sizeof (filename) - len,
4507 #if MAC_OSX
4508 kCFStringEncodingUTF8
4509 #else
4510 CFStringGetSystemEncoding ()
4511 #endif
4512 );
4513 }
4514 file = DECODE_FILE (make_unibyte_string (filename,
4515 strlen (filename)));
4516 }
4517 NavDisposeReply(&reply);
4518 }
4519 break;
4520 }
4521 NavDialogDispose(dialogRef);
4522 UNBLOCK_INPUT;
4523 }
4524 else {
4525 UNBLOCK_INPUT;
4526 /* Fall back on minibuffer if there was a problem */
4527 file = Fcompleting_read (prompt, intern ("read-file-name-internal"),
4528 dir, mustmatch, dir, Qfile_name_history,
4529 default_filename, Qnil);
4530 }
4531 }
4532
4533 UNGCPRO;
4534
4535 /* Make "Cancel" equivalent to C-g. */
4536 if (NILP (file))
4537 Fsignal (Qquit, Qnil);
4538
4539 return unbind_to (count, file);
4540 }
4541
4542
4543 /* Need to register some event callback function for enabling drag and
4544 drop in Navigation Service dialogs. */
4545 static pascal void
4546 mac_nav_event_callback (selector, parms, data)
4547 NavEventCallbackMessage selector;
4548 NavCBRecPtr parms;
4549 void *data ;
4550 {
4551 }
4552 #endif
4553 \f
4554 /***********************************************************************
4555 Fonts
4556 ***********************************************************************/
4557
4558 DEFUN ("mac-clear-font-name-table", Fmac_clear_font_name_table,
4559 Smac_clear_font_name_table, 0, 0, 0,
4560 doc: /* Clear the font name table. */)
4561 ()
4562 {
4563 check_mac ();
4564 mac_clear_font_name_table ();
4565 return Qnil;
4566 }
4567
4568 #if USE_MAC_FONT_PANEL
4569 DEFUN ("mac-set-font-panel-visibility", Fmac_set_font_panel_visibility,
4570 Smac_set_font_panel_visibility, 1, 1, 0,
4571 doc: /* Make the font panel visible if and only if VISIBLE is non-nil.
4572 This is for internal use only. Use `mac-font-panel-mode' instead. */)
4573 (visible)
4574 Lisp_Object visible;
4575 {
4576 OSStatus err = noErr;
4577
4578 check_mac ();
4579
4580 BLOCK_INPUT;
4581 if (NILP (visible) != !mac_font_panel_visible_p ())
4582 {
4583 err = mac_show_hide_font_panel ();
4584 if (err == noErr && !NILP (visible))
4585 {
4586 Lisp_Object focus_frame = x_get_focus_frame (SELECTED_FRAME ());
4587 struct frame *f = (NILP (focus_frame) ? SELECTED_FRAME ()
4588 : XFRAME (focus_frame));
4589
4590 mac_set_font_info_for_selection (f, DEFAULT_FACE_ID, 0);
4591 }
4592 }
4593 UNBLOCK_INPUT;
4594
4595 if (err != noErr)
4596 error ("Cannot change visibility of the font panel");
4597 return Qnil;
4598 }
4599 #endif
4600 \f
4601 /***********************************************************************
4602 Initialization
4603 ***********************************************************************/
4604
4605 /* Keep this list in the same order as frame_parms in frame.c.
4606 Use 0 for unsupported frame parameters. */
4607
4608 frame_parm_handler mac_frame_parm_handlers[] =
4609 {
4610 x_set_autoraise,
4611 x_set_autolower,
4612 x_set_background_color,
4613 x_set_border_color,
4614 x_set_border_width,
4615 x_set_cursor_color,
4616 x_set_cursor_type,
4617 mac_set_font,
4618 x_set_foreground_color,
4619 x_set_icon_name,
4620 0, /* MAC_TODO: x_set_icon_type, */
4621 x_set_internal_border_width,
4622 x_set_menu_bar_lines,
4623 x_set_mouse_color,
4624 x_explicitly_set_name,
4625 mac_set_scroll_bar_width,
4626 x_set_title,
4627 x_set_unsplittable,
4628 x_set_vertical_scroll_bars,
4629 x_set_visibility,
4630 x_set_tool_bar_lines,
4631 0, /* MAC_TODO: x_set_scroll_bar_foreground, */
4632 0, /* MAC_TODO: x_set_scroll_bar_background, */
4633 x_set_screen_gamma,
4634 x_set_line_spacing,
4635 x_set_fringe_width,
4636 x_set_fringe_width,
4637 0, /* x_set_wait_for_wm, */
4638 x_set_fullscreen,
4639 };
4640
4641 void
4642 syms_of_macfns ()
4643 {
4644 #ifdef MAC_OSX
4645 /* This is zero if not using Mac native windows. */
4646 mac_in_use = 0;
4647 #else
4648 /* Certainly running on Mac native windows. */
4649 mac_in_use = 1;
4650 #endif
4651
4652 /* The section below is built by the lisp expression at the top of the file,
4653 just above where these variables are declared. */
4654 /*&&& init symbols here &&&*/
4655 Qnone = intern ("none");
4656 staticpro (&Qnone);
4657 Qsuppress_icon = intern ("suppress-icon");
4658 staticpro (&Qsuppress_icon);
4659 Qundefined_color = intern ("undefined-color");
4660 staticpro (&Qundefined_color);
4661 Qcancel_timer = intern ("cancel-timer");
4662 staticpro (&Qcancel_timer);
4663 /* This is the end of symbol initialization. */
4664
4665 /* Text property `display' should be nonsticky by default. */
4666 Vtext_property_default_nonsticky
4667 = Fcons (Fcons (Qdisplay, Qt), Vtext_property_default_nonsticky);
4668
4669
4670 Fput (Qundefined_color, Qerror_conditions,
4671 Fcons (Qundefined_color, Fcons (Qerror, Qnil)));
4672 Fput (Qundefined_color, Qerror_message,
4673 build_string ("Undefined color"));
4674
4675 DEFVAR_LISP ("x-pointer-shape", &Vx_pointer_shape,
4676 doc: /* The shape of the pointer when over text.
4677 Changing the value does not affect existing frames
4678 unless you set the mouse color. */);
4679 Vx_pointer_shape = Qnil;
4680
4681 #if 0 /* This doesn't really do anything. */
4682 DEFVAR_LISP ("x-nontext-pointer-shape", &Vx_nontext_pointer_shape,
4683 doc: /* The shape of the pointer when not over text.
4684 This variable takes effect when you create a new frame
4685 or when you set the mouse color. */);
4686 #endif
4687 Vx_nontext_pointer_shape = Qnil;
4688
4689 DEFVAR_LISP ("x-hourglass-pointer-shape", &Vx_hourglass_pointer_shape,
4690 doc: /* The shape of the pointer when Emacs is busy.
4691 This variable takes effect when you create a new frame
4692 or when you set the mouse color. */);
4693 Vx_hourglass_pointer_shape = Qnil;
4694
4695 DEFVAR_BOOL ("display-hourglass", &display_hourglass_p,
4696 doc: /* Non-zero means Emacs displays an hourglass pointer on window systems. */);
4697 display_hourglass_p = 1;
4698
4699 DEFVAR_LISP ("hourglass-delay", &Vhourglass_delay,
4700 doc: /* *Seconds to wait before displaying an hourglass pointer.
4701 Value must be an integer or float. */);
4702 Vhourglass_delay = make_number (DEFAULT_HOURGLASS_DELAY);
4703
4704 #if 0 /* This doesn't really do anything. */
4705 DEFVAR_LISP ("x-mode-pointer-shape", &Vx_mode_pointer_shape,
4706 doc: /* The shape of the pointer when over the mode line.
4707 This variable takes effect when you create a new frame
4708 or when you set the mouse color. */);
4709 #endif
4710 Vx_mode_pointer_shape = Qnil;
4711
4712 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
4713 &Vx_sensitive_text_pointer_shape,
4714 doc: /* The shape of the pointer when over mouse-sensitive text.
4715 This variable takes effect when you create a new frame
4716 or when you set the mouse color. */);
4717 Vx_sensitive_text_pointer_shape = Qnil;
4718
4719 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
4720 &Vx_window_horizontal_drag_shape,
4721 doc: /* Pointer shape to use for indicating a window can be dragged horizontally.
4722 This variable takes effect when you create a new frame
4723 or when you set the mouse color. */);
4724 Vx_window_horizontal_drag_shape = Qnil;
4725
4726 DEFVAR_LISP ("x-cursor-fore-pixel", &Vx_cursor_fore_pixel,
4727 doc: /* A string indicating the foreground color of the cursor box. */);
4728 Vx_cursor_fore_pixel = Qnil;
4729
4730 DEFVAR_LISP ("x-max-tooltip-size", &Vx_max_tooltip_size,
4731 doc: /* Maximum size for tooltips. Value is a pair (COLUMNS . ROWS).
4732 Text larger than this is clipped. */);
4733 Vx_max_tooltip_size = Fcons (make_number (80), make_number (40));
4734
4735 DEFVAR_LISP ("x-no-window-manager", &Vx_no_window_manager,
4736 doc: /* Non-nil if no window manager is in use.
4737 Emacs doesn't try to figure this out; this is always nil
4738 unless you set it to something else. */);
4739 /* We don't have any way to find this out, so set it to nil
4740 and maybe the user would like to set it to t. */
4741 Vx_no_window_manager = Qnil;
4742
4743 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
4744 &Vx_pixel_size_width_font_regexp,
4745 doc: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
4746
4747 Since Emacs gets width of a font matching with this regexp from
4748 PIXEL_SIZE field of the name, font finding mechanism gets faster for
4749 such a font. This is especially effective for such large fonts as
4750 Chinese, Japanese, and Korean. */);
4751 Vx_pixel_size_width_font_regexp = Qnil;
4752
4753 #if TARGET_API_MAC_CARBON
4754 DEFVAR_LISP ("mac-carbon-version-string", &Vmac_carbon_version_string,
4755 doc: /* Version info for Carbon API. */);
4756 {
4757 OSErr err;
4758 UInt32 response;
4759 char carbon_version[16] = "Unknown";
4760
4761 err = Gestalt (gestaltCarbonVersion, &response);
4762 if (err == noErr)
4763 sprintf (carbon_version, "%u.%u.%u",
4764 (response >> 8) & 0xf, (response >> 4) & 0xf, response & 0xf);
4765 Vmac_carbon_version_string = build_string (carbon_version);
4766 }
4767 #endif /* TARGET_API_MAC_CARBON */
4768
4769 /* X window properties. */
4770 defsubr (&Sx_change_window_property);
4771 defsubr (&Sx_delete_window_property);
4772 defsubr (&Sx_window_property);
4773
4774 defsubr (&Sxw_display_color_p);
4775 defsubr (&Sx_display_grayscale_p);
4776 defsubr (&Sxw_color_defined_p);
4777 defsubr (&Sxw_color_values);
4778 defsubr (&Sx_server_max_request_size);
4779 defsubr (&Sx_server_vendor);
4780 defsubr (&Sx_server_version);
4781 defsubr (&Sx_display_pixel_width);
4782 defsubr (&Sx_display_pixel_height);
4783 defsubr (&Sx_display_mm_width);
4784 defsubr (&Sx_display_mm_height);
4785 defsubr (&Sx_display_screens);
4786 defsubr (&Sx_display_planes);
4787 defsubr (&Sx_display_color_cells);
4788 defsubr (&Sx_display_visual_class);
4789 defsubr (&Sx_display_backing_store);
4790 defsubr (&Sx_display_save_under);
4791 defsubr (&Sx_create_frame);
4792 defsubr (&Sx_open_connection);
4793 defsubr (&Sx_close_connection);
4794 defsubr (&Sx_display_list);
4795 defsubr (&Sx_synchronize);
4796 defsubr (&Sx_focus_frame);
4797
4798 /* Setting callback functions for fontset handler. */
4799 get_font_info_func = x_get_font_info;
4800
4801 #if 0 /* This function pointer doesn't seem to be used anywhere.
4802 And the pointer assigned has the wrong type, anyway. */
4803 list_fonts_func = x_list_fonts;
4804 #endif
4805
4806 load_font_func = x_load_font;
4807 find_ccl_program_func = x_find_ccl_program;
4808 query_font_func = x_query_font;
4809 set_frame_fontset_func = mac_set_font;
4810 check_window_system_func = check_mac;
4811
4812 hourglass_atimer = NULL;
4813 hourglass_shown_p = 0;
4814
4815 defsubr (&Sx_show_tip);
4816 defsubr (&Sx_hide_tip);
4817 tip_timer = Qnil;
4818 staticpro (&tip_timer);
4819 tip_frame = Qnil;
4820 staticpro (&tip_frame);
4821
4822 last_show_tip_args = Qnil;
4823 staticpro (&last_show_tip_args);
4824
4825 #if TARGET_API_MAC_CARBON
4826 defsubr (&Sx_file_dialog);
4827 #endif
4828 defsubr (&Smac_clear_font_name_table);
4829 #if USE_MAC_FONT_PANEL
4830 defsubr (&Smac_set_font_panel_visibility);
4831 #endif
4832 }
4833
4834 /* arch-tag: d7591289-f374-4377-b245-12f5dbbb8edc
4835 (do not change this comment) */
Unnamed repository; edit this file 'description' to name the repository.