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