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