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