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