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