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