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