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