]> code.delx.au - gnu-emacs/blob - src/xfns.c
delx.au / code / gnu-emacs / blob
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Merged from miles@gnu.org--gnu-2005 (patch 27, 120-125)
[gnu-emacs] / src / xfns.c
1 /* Functions for the X window system.
2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005 Free Software Foundation.
4
5 This file is part of GNU Emacs.
6
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
21
22 #include <config.h>
23 #include <signal.h>
24 #include <stdio.h>
25 #include <math.h>
26
27 #ifdef HAVE_UNISTD_H
28 #include <unistd.h>
29 #endif
30
31 /* This makes the fields of a Display accessible, in Xlib header files. */
32
33 #define XLIB_ILLEGAL_ACCESS
34
35 #include "lisp.h"
36 #include "xterm.h"
37 #include "frame.h"
38 #include "window.h"
39 #include "buffer.h"
40 #include "intervals.h"
41 #include "dispextern.h"
42 #include "keyboard.h"
43 #include "blockinput.h"
44 #include <epaths.h>
45 #include "charset.h"
46 #include "coding.h"
47 #include "fontset.h"
48 #include "systime.h"
49 #include "termhooks.h"
50 #include "atimer.h"
51 #include "termchar.h"
52
53 #ifdef HAVE_X_WINDOWS
54
55 #include <ctype.h>
56 #include <sys/types.h>
57 #include <sys/stat.h>
58
59 #ifndef VMS
60 #if 1 /* Used to be #ifdef EMACS_BITMAP_FILES, but this should always work. */
61 #include "bitmaps/gray.xbm"
62 #else
63 #include <X11/bitmaps/gray>
64 #endif
65 #else
66 #include "[.bitmaps]gray.xbm"
67 #endif
68
69 #ifdef USE_GTK
70 #include "gtkutil.h"
71 #endif
72
73 #ifdef USE_X_TOOLKIT
74 #include <X11/Shell.h>
75
76 #ifndef USE_MOTIF
77 #include <X11/Xaw/Paned.h>
78 #include <X11/Xaw/Label.h>
79 #endif /* USE_MOTIF */
80
81 #ifdef USG
82 #undef USG /* ####KLUDGE for Solaris 2.2 and up */
83 #include <X11/Xos.h>
84 #define USG
85 #else
86 #include <X11/Xos.h>
87 #endif
88
89 #include "widget.h"
90
91 #include "../lwlib/lwlib.h"
92
93 #ifdef USE_MOTIF
94 #include <Xm/Xm.h>
95 #include <Xm/DialogS.h>
96 #include <Xm/FileSB.h>
97 #endif
98
99 /* Do the EDITRES protocol if running X11R5
100 Exception: HP-UX (at least version A.09.05) has X11R5 without EditRes */
101
102 #if (XtSpecificationRelease >= 5) && !defined(NO_EDITRES)
103 #define HACK_EDITRES
104 extern void _XEditResCheckMessages ();
105 #endif /* R5 + Athena */
106
107 /* Unique id counter for widgets created by the Lucid Widget Library. */
108
109 extern LWLIB_ID widget_id_tick;
110
111 #ifdef USE_LUCID
112 /* This is part of a kludge--see lwlib/xlwmenu.c. */
113 extern XFontStruct *xlwmenu_default_font;
114 #endif
115
116 extern void free_frame_menubar ();
117 extern double atof ();
118
119 #ifdef USE_MOTIF
120
121 /* LessTif/Motif version info. */
122
123 static Lisp_Object Vmotif_version_string;
124
125 #endif /* USE_MOTIF */
126
127 #endif /* USE_X_TOOLKIT */
128
129 #ifdef USE_GTK
130
131 /* GTK+ version info */
132
133 static Lisp_Object Vgtk_version_string;
134
135 #endif /* USE_GTK */
136
137 #ifdef HAVE_X11R4
138 #define MAXREQUEST(dpy) (XMaxRequestSize (dpy))
139 #else
140 #define MAXREQUEST(dpy) ((dpy)->max_request_size)
141 #endif
142
143 /* The gray bitmap `bitmaps/gray'. This is done because xterm.c uses
144 it, and including `bitmaps/gray' more than once is a problem when
145 config.h defines `static' as an empty replacement string. */
146
147 int gray_bitmap_width = gray_width;
148 int gray_bitmap_height = gray_height;
149 char *gray_bitmap_bits = gray_bits;
150
151 /* Non-zero means we're allowed to display an hourglass cursor. */
152
153 int display_hourglass_p;
154
155 /* Non-zero means prompt with the old GTK file selection dialog. */
156
157 int x_use_old_gtk_file_dialog;
158
159 /* The background and shape of the mouse pointer, and shape when not
160 over text or in the modeline. */
161
162 Lisp_Object Vx_pointer_shape, Vx_nontext_pointer_shape, Vx_mode_pointer_shape;
163 Lisp_Object Vx_hourglass_pointer_shape;
164
165 /* The shape when over mouse-sensitive text. */
166
167 Lisp_Object Vx_sensitive_text_pointer_shape;
168
169 /* If non-nil, the pointer shape to indicate that windows can be
170 dragged horizontally. */
171
172 Lisp_Object Vx_window_horizontal_drag_shape;
173
174 /* Color of chars displayed in cursor box. */
175
176 Lisp_Object Vx_cursor_fore_pixel;
177
178 /* Nonzero if using X. */
179
180 static int x_in_use;
181
182 /* Non nil if no window manager is in use. */
183
184 Lisp_Object Vx_no_window_manager;
185
186 /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'. */
187
188 Lisp_Object Vx_pixel_size_width_font_regexp;
189
190 Lisp_Object Qnone;
191 Lisp_Object Qsuppress_icon;
192 Lisp_Object Qundefined_color;
193 Lisp_Object Qcompound_text, Qcancel_timer;
194
195 /* In dispnew.c */
196
197 extern Lisp_Object Vwindow_system_version;
198
199 /* The below are defined in frame.c. */
200
201 #if GLYPH_DEBUG
202 int image_cache_refcount, dpyinfo_refcount;
203 #endif
204
205
206 \f
207 /* Error if we are not connected to X. */
208
209 void
210 check_x ()
211 {
212 if (! x_in_use)
213 error ("X windows are not in use or not initialized");
214 }
215
216 /* Nonzero if we can use mouse menus.
217 You should not call this unless HAVE_MENUS is defined. */
218
219 int
220 have_menus_p ()
221 {
222 return x_in_use;
223 }
224
225 /* Extract a frame as a FRAME_PTR, defaulting to the selected frame
226 and checking validity for X. */
227
228 FRAME_PTR
229 check_x_frame (frame)
230 Lisp_Object frame;
231 {
232 FRAME_PTR f;
233
234 if (NILP (frame))
235 frame = selected_frame;
236 CHECK_LIVE_FRAME (frame);
237 f = XFRAME (frame);
238 if (! FRAME_X_P (f))
239 error ("Non-X frame used");
240 return f;
241 }
242
243 /* Let the user specify an X display with a frame.
244 nil stands for the selected frame--or, if that is not an X frame,
245 the first X display on the list. */
246
247 struct x_display_info *
248 check_x_display_info (frame)
249 Lisp_Object frame;
250 {
251 struct x_display_info *dpyinfo = NULL;
252
253 if (NILP (frame))
254 {
255 struct frame *sf = XFRAME (selected_frame);
256
257 if (FRAME_X_P (sf) && FRAME_LIVE_P (sf))
258 dpyinfo = FRAME_X_DISPLAY_INFO (sf);
259 else if (x_display_list != 0)
260 dpyinfo = x_display_list;
261 else
262 error ("X windows are not in use or not initialized");
263 }
264 else if (INTEGERP (frame))
265 {
266 struct display *d = get_display (XINT (frame));
267
268 if (!d)
269 wrong_type_argument (Qdisplay_live_p, frame);
270 if (d->type != output_x_window)
271 error ("Display %d is not an X display", XINT (frame));
272
273 dpyinfo = d->display_info.x;
274 }
275 else if (STRINGP (frame))
276 dpyinfo = x_display_info_for_name (frame);
277 else
278 {
279 FRAME_PTR f = check_x_frame (frame);
280 dpyinfo = FRAME_X_DISPLAY_INFO (f);
281 }
282
283 return dpyinfo;
284 }
285
286 \f
287 /* Return the Emacs frame-object corresponding to an X window.
288 It could be the frame's main window or an icon window. */
289
290 /* This function can be called during GC, so use GC_xxx type test macros. */
291
292 struct frame *
293 x_window_to_frame (dpyinfo, wdesc)
294 struct x_display_info *dpyinfo;
295 int wdesc;
296 {
297 Lisp_Object tail, frame;
298 struct frame *f;
299
300 if (wdesc == None) return 0;
301
302 for (tail = Vframe_list; GC_CONSP (tail); tail = XCDR (tail))
303 {
304 frame = XCAR (tail);
305 if (!GC_FRAMEP (frame))
306 continue;
307 f = XFRAME (frame);
308 if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
309 continue;
310 if (f->output_data.x->hourglass_window == wdesc)
311 return f;
312 #ifdef USE_X_TOOLKIT
313 if ((f->output_data.x->edit_widget
314 && XtWindow (f->output_data.x->edit_widget) == wdesc)
315 /* A tooltip frame? */
316 || (!f->output_data.x->edit_widget
317 && FRAME_X_WINDOW (f) == wdesc)
318 || f->output_data.x->icon_desc == wdesc)
319 return f;
320 #else /* not USE_X_TOOLKIT */
321 #ifdef USE_GTK
322 if (f->output_data.x->edit_widget)
323 {
324 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
325 struct x_output *x = f->output_data.x;
326 if (gwdesc != 0 && gwdesc == x->edit_widget)
327 return f;
328 }
329 #endif /* USE_GTK */
330 if (FRAME_X_WINDOW (f) == wdesc
331 || f->output_data.x->icon_desc == wdesc)
332 return f;
333 #endif /* not USE_X_TOOLKIT */
334 }
335 return 0;
336 }
337
338 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
339 /* Like x_window_to_frame but also compares the window with the widget's
340 windows. */
341
342 struct frame *
343 x_any_window_to_frame (dpyinfo, wdesc)
344 struct x_display_info *dpyinfo;
345 int wdesc;
346 {
347 Lisp_Object tail, frame;
348 struct frame *f, *found;
349 struct x_output *x;
350
351 if (wdesc == None) return NULL;
352
353 found = NULL;
354 for (tail = Vframe_list; GC_CONSP (tail) && !found; tail = XCDR (tail))
355 {
356 frame = XCAR (tail);
357 if (!GC_FRAMEP (frame))
358 continue;
359
360 f = XFRAME (frame);
361 if (FRAME_X_P (f) && FRAME_X_DISPLAY_INFO (f) == dpyinfo)
362 {
363 /* This frame matches if the window is any of its widgets. */
364 x = f->output_data.x;
365 if (x->hourglass_window == wdesc)
366 found = f;
367 else if (x->widget)
368 {
369 #ifdef USE_GTK
370 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
371 if (gwdesc != 0
372 && (gwdesc == x->widget
373 || gwdesc == x->edit_widget
374 || gwdesc == x->vbox_widget
375 || gwdesc == x->menubar_widget))
376 found = f;
377 #else
378 if (wdesc == XtWindow (x->widget)
379 || wdesc == XtWindow (x->column_widget)
380 || wdesc == XtWindow (x->edit_widget))
381 found = f;
382 /* Match if the window is this frame's menubar. */
383 else if (lw_window_is_in_menubar (wdesc, x->menubar_widget))
384 found = f;
385 #endif
386 }
387 else if (FRAME_X_WINDOW (f) == wdesc)
388 /* A tooltip frame. */
389 found = f;
390 }
391 }
392
393 return found;
394 }
395
396 /* Likewise, but exclude the menu bar widget. */
397
398 struct frame *
399 x_non_menubar_window_to_frame (dpyinfo, wdesc)
400 struct x_display_info *dpyinfo;
401 int wdesc;
402 {
403 Lisp_Object tail, frame;
404 struct frame *f;
405 struct x_output *x;
406
407 if (wdesc == None) return 0;
408
409 for (tail = Vframe_list; GC_CONSP (tail); tail = XCDR (tail))
410 {
411 frame = XCAR (tail);
412 if (!GC_FRAMEP (frame))
413 continue;
414 f = XFRAME (frame);
415 if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
416 continue;
417 x = f->output_data.x;
418 /* This frame matches if the window is any of its widgets. */
419 if (x->hourglass_window == wdesc)
420 return f;
421 else if (x->widget)
422 {
423 #ifdef USE_GTK
424 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
425 if (gwdesc != 0
426 && (gwdesc == x->widget
427 || gwdesc == x->edit_widget
428 || gwdesc == x->vbox_widget))
429 return f;
430 #else
431 if (wdesc == XtWindow (x->widget)
432 || wdesc == XtWindow (x->column_widget)
433 || wdesc == XtWindow (x->edit_widget))
434 return f;
435 #endif
436 }
437 else if (FRAME_X_WINDOW (f) == wdesc)
438 /* A tooltip frame. */
439 return f;
440 }
441 return 0;
442 }
443
444 /* Likewise, but consider only the menu bar widget. */
445
446 struct frame *
447 x_menubar_window_to_frame (dpyinfo, wdesc)
448 struct x_display_info *dpyinfo;
449 int wdesc;
450 {
451 Lisp_Object tail, frame;
452 struct frame *f;
453 struct x_output *x;
454
455 if (wdesc == None) return 0;
456
457 for (tail = Vframe_list; GC_CONSP (tail); tail = XCDR (tail))
458 {
459 frame = XCAR (tail);
460 if (!GC_FRAMEP (frame))
461 continue;
462 f = XFRAME (frame);
463 if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
464 continue;
465 x = f->output_data.x;
466 /* Match if the window is this frame's menubar. */
467 #ifdef USE_GTK
468 if (x->menubar_widget)
469 {
470 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
471 int found = 0;
472
473 BLOCK_INPUT;
474 if (gwdesc != 0
475 && (gwdesc == x->menubar_widget
476 || gtk_widget_get_parent (gwdesc) == x->menubar_widget))
477 found = 1;
478 UNBLOCK_INPUT;
479 if (found) return f;
480 }
481 #else
482 if (x->menubar_widget
483 && lw_window_is_in_menubar (wdesc, x->menubar_widget))
484 return f;
485 #endif
486 }
487 return 0;
488 }
489
490 /* Return the frame whose principal (outermost) window is WDESC.
491 If WDESC is some other (smaller) window, we return 0. */
492
493 struct frame *
494 x_top_window_to_frame (dpyinfo, wdesc)
495 struct x_display_info *dpyinfo;
496 int wdesc;
497 {
498 Lisp_Object tail, frame;
499 struct frame *f;
500 struct x_output *x;
501
502 if (wdesc == None) return 0;
503
504 for (tail = Vframe_list; GC_CONSP (tail); tail = XCDR (tail))
505 {
506 frame = XCAR (tail);
507 if (!GC_FRAMEP (frame))
508 continue;
509 f = XFRAME (frame);
510 if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
511 continue;
512 x = f->output_data.x;
513
514 if (x->widget)
515 {
516 /* This frame matches if the window is its topmost widget. */
517 #ifdef USE_GTK
518 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
519 if (gwdesc == x->widget)
520 return f;
521 #else
522 if (wdesc == XtWindow (x->widget))
523 return f;
524 #if 0 /* I don't know why it did this,
525 but it seems logically wrong,
526 and it causes trouble for MapNotify events. */
527 /* Match if the window is this frame's menubar. */
528 if (x->menubar_widget
529 && wdesc == XtWindow (x->menubar_widget))
530 return f;
531 #endif
532 #endif
533 }
534 else if (FRAME_X_WINDOW (f) == wdesc)
535 /* Tooltip frame. */
536 return f;
537 }
538 return 0;
539 }
540 #endif /* USE_X_TOOLKIT || USE_GTK */
541
542 \f
543
544 static Lisp_Object unwind_create_frame P_ ((Lisp_Object));
545 static Lisp_Object unwind_create_tip_frame P_ ((Lisp_Object));
546
547 void x_set_foreground_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
548 static void x_set_wait_for_wm P_ ((struct frame *, Lisp_Object, Lisp_Object));
549 void x_set_background_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
550 void x_set_mouse_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
551 void x_set_cursor_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
552 void x_set_border_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
553 void x_set_cursor_type P_ ((struct frame *, Lisp_Object, Lisp_Object));
554 void x_set_icon_type P_ ((struct frame *, Lisp_Object, Lisp_Object));
555 void x_set_icon_name P_ ((struct frame *, Lisp_Object, Lisp_Object));
556 void x_explicitly_set_name P_ ((struct frame *, Lisp_Object, Lisp_Object));
557 void x_set_menu_bar_lines P_ ((struct frame *, Lisp_Object, Lisp_Object));
558 void x_set_title P_ ((struct frame *, Lisp_Object, Lisp_Object));
559 void x_set_tool_bar_lines P_ ((struct frame *, Lisp_Object, Lisp_Object));
560 void x_set_scroll_bar_foreground P_ ((struct frame *, Lisp_Object,
561 Lisp_Object));
562 void x_set_scroll_bar_background P_ ((struct frame *, Lisp_Object,
563 Lisp_Object));
564 static Lisp_Object x_default_scroll_bar_color_parameter P_ ((struct frame *,
565 Lisp_Object,
566 Lisp_Object,
567 char *, char *,
568 int));
569 \f
570
571 /* Store the screen positions of frame F into XPTR and YPTR.
572 These are the positions of the containing window manager window,
573 not Emacs's own window. */
574
575 void
576 x_real_positions (f, xptr, yptr)
577 FRAME_PTR f;
578 int *xptr, *yptr;
579 {
580 int win_x, win_y, outer_x, outer_y;
581 int real_x = 0, real_y = 0;
582 int had_errors = 0;
583 Window win = f->output_data.x->parent_desc;
584
585 int count;
586
587 BLOCK_INPUT;
588
589 count = x_catch_errors (FRAME_X_DISPLAY (f));
590
591 if (win == FRAME_X_DISPLAY_INFO (f)->root_window)
592 win = FRAME_OUTER_WINDOW (f);
593
594 /* This loop traverses up the containment tree until we hit the root
595 window. Window managers may intersect many windows between our window
596 and the root window. The window we find just before the root window
597 should be the outer WM window. */
598 for (;;)
599 {
600 Window wm_window, rootw;
601 Window *tmp_children;
602 unsigned int tmp_nchildren;
603 int success;
604
605 success = XQueryTree (FRAME_X_DISPLAY (f), win, &rootw,
606 &wm_window, &tmp_children, &tmp_nchildren);
607
608 had_errors = x_had_errors_p (FRAME_X_DISPLAY (f));
609
610 /* Don't free tmp_children if XQueryTree failed. */
611 if (! success)
612 break;
613
614 XFree ((char *) tmp_children);
615
616 if (wm_window == rootw || had_errors)
617 break;
618
619 win = wm_window;
620 }
621
622 if (! had_errors)
623 {
624 int ign;
625 Window child, rootw;
626
627 /* Get the real coordinates for the WM window upper left corner */
628 XGetGeometry (FRAME_X_DISPLAY (f), win,
629 &rootw, &real_x, &real_y, &ign, &ign, &ign, &ign);
630
631 /* Translate real coordinates to coordinates relative to our
632 window. For our window, the upper left corner is 0, 0.
633 Since the upper left corner of the WM window is outside
634 our window, win_x and win_y will be negative:
635
636 ------------------ ---> x
637 | title |
638 | ----------------- v y
639 | | our window
640 */
641 XTranslateCoordinates (FRAME_X_DISPLAY (f),
642
643 /* From-window, to-window. */
644 FRAME_X_DISPLAY_INFO (f)->root_window,
645 FRAME_X_WINDOW (f),
646
647 /* From-position, to-position. */
648 real_x, real_y, &win_x, &win_y,
649
650 /* Child of win. */
651 &child);
652
653 if (FRAME_X_WINDOW (f) == FRAME_OUTER_WINDOW (f))
654 {
655 outer_x = win_x;
656 outer_y = win_y;
657 }
658 else
659 {
660 XTranslateCoordinates (FRAME_X_DISPLAY (f),
661
662 /* From-window, to-window. */
663 FRAME_X_DISPLAY_INFO (f)->root_window,
664 FRAME_OUTER_WINDOW (f),
665
666 /* From-position, to-position. */
667 real_x, real_y, &outer_x, &outer_y,
668
669 /* Child of win. */
670 &child);
671 }
672
673 had_errors = x_had_errors_p (FRAME_X_DISPLAY (f));
674 }
675
676 x_uncatch_errors (FRAME_X_DISPLAY (f), count);
677
678 UNBLOCK_INPUT;
679
680 if (had_errors) return;
681
682 f->x_pixels_diff = -win_x;
683 f->y_pixels_diff = -win_y;
684
685 FRAME_X_OUTPUT (f)->x_pixels_outer_diff = -outer_x;
686 FRAME_X_OUTPUT (f)->y_pixels_outer_diff = -outer_y;
687
688 *xptr = real_x;
689 *yptr = real_y;
690 }
691
692 \f
693
694
695 /* Gamma-correct COLOR on frame F. */
696
697 void
698 gamma_correct (f, color)
699 struct frame *f;
700 XColor *color;
701 {
702 if (f->gamma)
703 {
704 color->red = pow (color->red / 65535.0, f->gamma) * 65535.0 + 0.5;
705 color->green = pow (color->green / 65535.0, f->gamma) * 65535.0 + 0.5;
706 color->blue = pow (color->blue / 65535.0, f->gamma) * 65535.0 + 0.5;
707 }
708 }
709
710
711 /* Decide if color named COLOR_NAME is valid for use on frame F. If
712 so, return the RGB values in COLOR. If ALLOC_P is non-zero,
713 allocate the color. Value is zero if COLOR_NAME is invalid, or
714 no color could be allocated. */
715
716 int
717 x_defined_color (f, color_name, color, alloc_p)
718 struct frame *f;
719 char *color_name;
720 XColor *color;
721 int alloc_p;
722 {
723 int success_p;
724 Display *dpy = FRAME_X_DISPLAY (f);
725 Colormap cmap = FRAME_X_COLORMAP (f);
726
727 BLOCK_INPUT;
728 success_p = XParseColor (dpy, cmap, color_name, color);
729 if (success_p && alloc_p)
730 success_p = x_alloc_nearest_color (f, cmap, color);
731 UNBLOCK_INPUT;
732
733 return success_p;
734 }
735
736
737 /* Return the pixel color value for color COLOR_NAME on frame F. If F
738 is a monochrome frame, return MONO_COLOR regardless of what ARG says.
739 Signal an error if color can't be allocated. */
740
741 int
742 x_decode_color (f, color_name, mono_color)
743 FRAME_PTR f;
744 Lisp_Object color_name;
745 int mono_color;
746 {
747 XColor cdef;
748
749 CHECK_STRING (color_name);
750
751 #if 0 /* Don't do this. It's wrong when we're not using the default
752 colormap, it makes freeing difficult, and it's probably not
753 an important optimization. */
754 if (strcmp (SDATA (color_name), "black") == 0)
755 return BLACK_PIX_DEFAULT (f);
756 else if (strcmp (SDATA (color_name), "white") == 0)
757 return WHITE_PIX_DEFAULT (f);
758 #endif
759
760 /* Return MONO_COLOR for monochrome frames. */
761 if (FRAME_X_DISPLAY_INFO (f)->n_planes == 1)
762 return mono_color;
763
764 /* x_defined_color is responsible for coping with failures
765 by looking for a near-miss. */
766 if (x_defined_color (f, SDATA (color_name), &cdef, 1))
767 return cdef.pixel;
768
769 Fsignal (Qerror, Fcons (build_string ("Undefined color"),
770 Fcons (color_name, Qnil)));
771 return 0;
772 }
773
774
775 \f
776 /* Change the `wait-for-wm' frame parameter of frame F. OLD_VALUE is
777 the previous value of that parameter, NEW_VALUE is the new value.
778 See also the comment of wait_for_wm in struct x_output. */
779
780 static void
781 x_set_wait_for_wm (f, new_value, old_value)
782 struct frame *f;
783 Lisp_Object new_value, old_value;
784 {
785 f->output_data.x->wait_for_wm = !NILP (new_value);
786 }
787
788 #ifdef USE_GTK
789
790 /* Set icon from FILE for frame F. By using GTK functions the icon
791 may be any format that GdkPixbuf knows about, i.e. not just bitmaps. */
792
793 int
794 xg_set_icon (f, file)
795 FRAME_PTR f;
796 Lisp_Object file;
797 {
798 struct gcpro gcpro1;
799 int result = 0;
800 Lisp_Object found;
801
802 GCPRO1 (found);
803
804 found = x_find_image_file (file);
805
806 if (! NILP (found))
807 {
808 GdkPixbuf *pixbuf;
809 GError *err = NULL;
810 char *filename;
811
812 filename = SDATA (found);
813 BLOCK_INPUT;
814
815 pixbuf = gdk_pixbuf_new_from_file (filename, &err);
816
817 if (pixbuf)
818 {
819 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
820 pixbuf);
821 g_object_unref (pixbuf);
822
823 result = 1;
824 }
825 else
826 g_error_free (err);
827
828 UNBLOCK_INPUT;
829 }
830
831 UNGCPRO;
832 return result;
833 }
834 #endif /* USE_GTK */
835
836
837 /* Functions called only from `x_set_frame_param'
838 to set individual parameters.
839
840 If FRAME_X_WINDOW (f) is 0,
841 the frame is being created and its X-window does not exist yet.
842 In that case, just record the parameter's new value
843 in the standard place; do not attempt to change the window. */
844
845 void
846 x_set_foreground_color (f, arg, oldval)
847 struct frame *f;
848 Lisp_Object arg, oldval;
849 {
850 struct x_output *x = f->output_data.x;
851 unsigned long fg, old_fg;
852
853 fg = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
854 old_fg = x->foreground_pixel;
855 x->foreground_pixel = fg;
856
857 if (FRAME_X_WINDOW (f) != 0)
858 {
859 Display *dpy = FRAME_X_DISPLAY (f);
860
861 BLOCK_INPUT;
862 XSetForeground (dpy, x->normal_gc, fg);
863 XSetBackground (dpy, x->reverse_gc, fg);
864
865 if (x->cursor_pixel == old_fg)
866 {
867 unload_color (f, x->cursor_pixel);
868 x->cursor_pixel = x_copy_color (f, fg);
869 XSetBackground (dpy, x->cursor_gc, x->cursor_pixel);
870 }
871
872 UNBLOCK_INPUT;
873
874 update_face_from_frame_parameter (f, Qforeground_color, arg);
875
876 if (FRAME_VISIBLE_P (f))
877 redraw_frame (f);
878 }
879
880 unload_color (f, old_fg);
881 }
882
883 void
884 x_set_background_color (f, arg, oldval)
885 struct frame *f;
886 Lisp_Object arg, oldval;
887 {
888 struct x_output *x = f->output_data.x;
889 unsigned long bg;
890
891 bg = x_decode_color (f, arg, WHITE_PIX_DEFAULT (f));
892 unload_color (f, x->background_pixel);
893 x->background_pixel = bg;
894
895 if (FRAME_X_WINDOW (f) != 0)
896 {
897 Display *dpy = FRAME_X_DISPLAY (f);
898
899 BLOCK_INPUT;
900 XSetBackground (dpy, x->normal_gc, bg);
901 XSetForeground (dpy, x->reverse_gc, bg);
902 XSetWindowBackground (dpy, FRAME_X_WINDOW (f), bg);
903 XSetForeground (dpy, x->cursor_gc, bg);
904
905 #ifdef USE_GTK
906 xg_set_background_color (f, bg);
907 #endif
908
909 #ifndef USE_TOOLKIT_SCROLL_BARS /* Turns out to be annoying with
910 toolkit scroll bars. */
911 {
912 Lisp_Object bar;
913 for (bar = FRAME_SCROLL_BARS (f);
914 !NILP (bar);
915 bar = XSCROLL_BAR (bar)->next)
916 {
917 Window window = SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar));
918 XSetWindowBackground (dpy, window, bg);
919 }
920 }
921 #endif /* USE_TOOLKIT_SCROLL_BARS */
922
923 UNBLOCK_INPUT;
924 update_face_from_frame_parameter (f, Qbackground_color, arg);
925
926 if (FRAME_VISIBLE_P (f))
927 redraw_frame (f);
928 }
929 }
930
931 void
932 x_set_mouse_color (f, arg, oldval)
933 struct frame *f;
934 Lisp_Object arg, oldval;
935 {
936 struct x_output *x = f->output_data.x;
937 Display *dpy = FRAME_X_DISPLAY (f);
938 Cursor cursor, nontext_cursor, mode_cursor, hand_cursor;
939 Cursor hourglass_cursor, horizontal_drag_cursor;
940 int count;
941 unsigned long pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
942 unsigned long mask_color = x->background_pixel;
943
944 /* Don't let pointers be invisible. */
945 if (mask_color == pixel)
946 {
947 x_free_colors (f, &pixel, 1);
948 pixel = x_copy_color (f, x->foreground_pixel);
949 }
950
951 unload_color (f, x->mouse_pixel);
952 x->mouse_pixel = pixel;
953
954 BLOCK_INPUT;
955
956 /* It's not okay to crash if the user selects a screwy cursor. */
957 count = x_catch_errors (dpy);
958
959 if (!NILP (Vx_pointer_shape))
960 {
961 CHECK_NUMBER (Vx_pointer_shape);
962 cursor = XCreateFontCursor (dpy, XINT (Vx_pointer_shape));
963 }
964 else
965 cursor = XCreateFontCursor (dpy, XC_xterm);
966 x_check_errors (dpy, "bad text pointer cursor: %s");
967
968 if (!NILP (Vx_nontext_pointer_shape))
969 {
970 CHECK_NUMBER (Vx_nontext_pointer_shape);
971 nontext_cursor
972 = XCreateFontCursor (dpy, XINT (Vx_nontext_pointer_shape));
973 }
974 else
975 nontext_cursor = XCreateFontCursor (dpy, XC_left_ptr);
976 x_check_errors (dpy, "bad nontext pointer cursor: %s");
977
978 if (!NILP (Vx_hourglass_pointer_shape))
979 {
980 CHECK_NUMBER (Vx_hourglass_pointer_shape);
981 hourglass_cursor
982 = XCreateFontCursor (dpy, XINT (Vx_hourglass_pointer_shape));
983 }
984 else
985 hourglass_cursor = XCreateFontCursor (dpy, XC_watch);
986 x_check_errors (dpy, "bad hourglass pointer cursor: %s");
987
988 if (!NILP (Vx_mode_pointer_shape))
989 {
990 CHECK_NUMBER (Vx_mode_pointer_shape);
991 mode_cursor = XCreateFontCursor (dpy, XINT (Vx_mode_pointer_shape));
992 }
993 else
994 mode_cursor = XCreateFontCursor (dpy, XC_xterm);
995 x_check_errors (dpy, "bad modeline pointer cursor: %s");
996
997 if (!NILP (Vx_sensitive_text_pointer_shape))
998 {
999 CHECK_NUMBER (Vx_sensitive_text_pointer_shape);
1000 hand_cursor
1001 = XCreateFontCursor (dpy, XINT (Vx_sensitive_text_pointer_shape));
1002 }
1003 else
1004 hand_cursor = XCreateFontCursor (dpy, XC_hand2);
1005
1006 if (!NILP (Vx_window_horizontal_drag_shape))
1007 {
1008 CHECK_NUMBER (Vx_window_horizontal_drag_shape);
1009 horizontal_drag_cursor
1010 = XCreateFontCursor (dpy, XINT (Vx_window_horizontal_drag_shape));
1011 }
1012 else
1013 horizontal_drag_cursor
1014 = XCreateFontCursor (dpy, XC_sb_h_double_arrow);
1015
1016 /* Check and report errors with the above calls. */
1017 x_check_errors (dpy, "can't set cursor shape: %s");
1018 x_uncatch_errors (dpy, count);
1019
1020 {
1021 XColor fore_color, back_color;
1022
1023 fore_color.pixel = x->mouse_pixel;
1024 x_query_color (f, &fore_color);
1025 back_color.pixel = mask_color;
1026 x_query_color (f, &back_color);
1027
1028 XRecolorCursor (dpy, cursor, &fore_color, &back_color);
1029 XRecolorCursor (dpy, nontext_cursor, &fore_color, &back_color);
1030 XRecolorCursor (dpy, mode_cursor, &fore_color, &back_color);
1031 XRecolorCursor (dpy, hand_cursor, &fore_color, &back_color);
1032 XRecolorCursor (dpy, hourglass_cursor, &fore_color, &back_color);
1033 XRecolorCursor (dpy, horizontal_drag_cursor, &fore_color, &back_color);
1034 }
1035
1036 if (FRAME_X_WINDOW (f) != 0)
1037 XDefineCursor (dpy, FRAME_X_WINDOW (f), cursor);
1038
1039 if (cursor != x->text_cursor
1040 && x->text_cursor != 0)
1041 XFreeCursor (dpy, x->text_cursor);
1042 x->text_cursor = cursor;
1043
1044 if (nontext_cursor != x->nontext_cursor
1045 && x->nontext_cursor != 0)
1046 XFreeCursor (dpy, x->nontext_cursor);
1047 x->nontext_cursor = nontext_cursor;
1048
1049 if (hourglass_cursor != x->hourglass_cursor
1050 && x->hourglass_cursor != 0)
1051 XFreeCursor (dpy, x->hourglass_cursor);
1052 x->hourglass_cursor = hourglass_cursor;
1053
1054 if (mode_cursor != x->modeline_cursor
1055 && x->modeline_cursor != 0)
1056 XFreeCursor (dpy, f->output_data.x->modeline_cursor);
1057 x->modeline_cursor = mode_cursor;
1058
1059 if (hand_cursor != x->hand_cursor
1060 && x->hand_cursor != 0)
1061 XFreeCursor (dpy, x->hand_cursor);
1062 x->hand_cursor = hand_cursor;
1063
1064 if (horizontal_drag_cursor != x->horizontal_drag_cursor
1065 && x->horizontal_drag_cursor != 0)
1066 XFreeCursor (dpy, x->horizontal_drag_cursor);
1067 x->horizontal_drag_cursor = horizontal_drag_cursor;
1068
1069 XFlush (dpy);
1070 UNBLOCK_INPUT;
1071
1072 update_face_from_frame_parameter (f, Qmouse_color, arg);
1073 }
1074
1075 void
1076 x_set_cursor_color (f, arg, oldval)
1077 struct frame *f;
1078 Lisp_Object arg, oldval;
1079 {
1080 unsigned long fore_pixel, pixel;
1081 int fore_pixel_allocated_p = 0, pixel_allocated_p = 0;
1082 struct x_output *x = f->output_data.x;
1083
1084 if (!NILP (Vx_cursor_fore_pixel))
1085 {
1086 fore_pixel = x_decode_color (f, Vx_cursor_fore_pixel,
1087 WHITE_PIX_DEFAULT (f));
1088 fore_pixel_allocated_p = 1;
1089 }
1090 else
1091 fore_pixel = x->background_pixel;
1092
1093 pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
1094 pixel_allocated_p = 1;
1095
1096 /* Make sure that the cursor color differs from the background color. */
1097 if (pixel == x->background_pixel)
1098 {
1099 if (pixel_allocated_p)
1100 {
1101 x_free_colors (f, &pixel, 1);
1102 pixel_allocated_p = 0;
1103 }
1104
1105 pixel = x->mouse_pixel;
1106 if (pixel == fore_pixel)
1107 {
1108 if (fore_pixel_allocated_p)
1109 {
1110 x_free_colors (f, &fore_pixel, 1);
1111 fore_pixel_allocated_p = 0;
1112 }
1113 fore_pixel = x->background_pixel;
1114 }
1115 }
1116
1117 unload_color (f, x->cursor_foreground_pixel);
1118 if (!fore_pixel_allocated_p)
1119 fore_pixel = x_copy_color (f, fore_pixel);
1120 x->cursor_foreground_pixel = fore_pixel;
1121
1122 unload_color (f, x->cursor_pixel);
1123 if (!pixel_allocated_p)
1124 pixel = x_copy_color (f, pixel);
1125 x->cursor_pixel = pixel;
1126
1127 if (FRAME_X_WINDOW (f) != 0)
1128 {
1129 BLOCK_INPUT;
1130 XSetBackground (FRAME_X_DISPLAY (f), x->cursor_gc, x->cursor_pixel);
1131 XSetForeground (FRAME_X_DISPLAY (f), x->cursor_gc, fore_pixel);
1132 UNBLOCK_INPUT;
1133
1134 if (FRAME_VISIBLE_P (f))
1135 {
1136 x_update_cursor (f, 0);
1137 x_update_cursor (f, 1);
1138 }
1139 }
1140
1141 update_face_from_frame_parameter (f, Qcursor_color, arg);
1142 }
1143 \f
1144 /* Set the border-color of frame F to pixel value PIX.
1145 Note that this does not fully take effect if done before
1146 F has an x-window. */
1147
1148 void
1149 x_set_border_pixel (f, pix)
1150 struct frame *f;
1151 int pix;
1152 {
1153 unload_color (f, f->output_data.x->border_pixel);
1154 f->output_data.x->border_pixel = pix;
1155
1156 if (FRAME_X_WINDOW (f) != 0 && f->border_width > 0)
1157 {
1158 BLOCK_INPUT;
1159 XSetWindowBorder (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1160 (unsigned long)pix);
1161 UNBLOCK_INPUT;
1162
1163 if (FRAME_VISIBLE_P (f))
1164 redraw_frame (f);
1165 }
1166 }
1167
1168 /* Set the border-color of frame F to value described by ARG.
1169 ARG can be a string naming a color.
1170 The border-color is used for the border that is drawn by the X server.
1171 Note that this does not fully take effect if done before
1172 F has an x-window; it must be redone when the window is created.
1173
1174 Note: this is done in two routines because of the way X10 works.
1175
1176 Note: under X11, this is normally the province of the window manager,
1177 and so emacs' border colors may be overridden. */
1178
1179 void
1180 x_set_border_color (f, arg, oldval)
1181 struct frame *f;
1182 Lisp_Object arg, oldval;
1183 {
1184 int pix;
1185
1186 CHECK_STRING (arg);
1187 pix = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
1188 x_set_border_pixel (f, pix);
1189 update_face_from_frame_parameter (f, Qborder_color, arg);
1190 }
1191
1192
1193 void
1194 x_set_cursor_type (f, arg, oldval)
1195 FRAME_PTR f;
1196 Lisp_Object arg, oldval;
1197 {
1198 set_frame_cursor_types (f, arg);
1199
1200 /* Make sure the cursor gets redrawn. */
1201 cursor_type_changed = 1;
1202 }
1203 \f
1204 void
1205 x_set_icon_type (f, arg, oldval)
1206 struct frame *f;
1207 Lisp_Object arg, oldval;
1208 {
1209 int result;
1210
1211 if (STRINGP (arg))
1212 {
1213 if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
1214 return;
1215 }
1216 else if (!STRINGP (oldval) && EQ (oldval, Qnil) == EQ (arg, Qnil))
1217 return;
1218
1219 BLOCK_INPUT;
1220 if (NILP (arg))
1221 result = x_text_icon (f,
1222 (char *) SDATA ((!NILP (f->icon_name)
1223 ? f->icon_name
1224 : f->name)));
1225 else
1226 result = x_bitmap_icon (f, arg);
1227
1228 if (result)
1229 {
1230 UNBLOCK_INPUT;
1231 error ("No icon window available");
1232 }
1233
1234 XFlush (FRAME_X_DISPLAY (f));
1235 UNBLOCK_INPUT;
1236 }
1237
1238 void
1239 x_set_icon_name (f, arg, oldval)
1240 struct frame *f;
1241 Lisp_Object arg, oldval;
1242 {
1243 int result;
1244
1245 if (STRINGP (arg))
1246 {
1247 if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
1248 return;
1249 }
1250 else if (!STRINGP (oldval) && EQ (oldval, Qnil) == EQ (arg, Qnil))
1251 return;
1252
1253 f->icon_name = arg;
1254
1255 if (f->output_data.x->icon_bitmap != 0)
1256 return;
1257
1258 BLOCK_INPUT;
1259
1260 result = x_text_icon (f,
1261 (char *) SDATA ((!NILP (f->icon_name)
1262 ? f->icon_name
1263 : !NILP (f->title)
1264 ? f->title
1265 : f->name)));
1266
1267 if (result)
1268 {
1269 UNBLOCK_INPUT;
1270 error ("No icon window available");
1271 }
1272
1273 XFlush (FRAME_X_DISPLAY (f));
1274 UNBLOCK_INPUT;
1275 }
1276
1277 \f
1278 void
1279 x_set_menu_bar_lines (f, value, oldval)
1280 struct frame *f;
1281 Lisp_Object value, oldval;
1282 {
1283 int nlines;
1284 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1285 int olines = FRAME_MENU_BAR_LINES (f);
1286 #endif
1287
1288 /* Right now, menu bars don't work properly in minibuf-only frames;
1289 most of the commands try to apply themselves to the minibuffer
1290 frame itself, and get an error because you can't switch buffers
1291 in or split the minibuffer window. */
1292 if (FRAME_MINIBUF_ONLY_P (f))
1293 return;
1294
1295 if (INTEGERP (value))
1296 nlines = XINT (value);
1297 else
1298 nlines = 0;
1299
1300 /* Make sure we redisplay all windows in this frame. */
1301 windows_or_buffers_changed++;
1302
1303 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1304 FRAME_MENU_BAR_LINES (f) = 0;
1305 if (nlines)
1306 {
1307 FRAME_EXTERNAL_MENU_BAR (f) = 1;
1308 if (FRAME_X_P (f) && f->output_data.x->menubar_widget == 0)
1309 /* Make sure next redisplay shows the menu bar. */
1310 XWINDOW (FRAME_SELECTED_WINDOW (f))->update_mode_line = Qt;
1311 }
1312 else
1313 {
1314 if (FRAME_EXTERNAL_MENU_BAR (f) == 1)
1315 free_frame_menubar (f);
1316 FRAME_EXTERNAL_MENU_BAR (f) = 0;
1317 if (FRAME_X_P (f))
1318 f->output_data.x->menubar_widget = 0;
1319 }
1320 #else /* not USE_X_TOOLKIT && not USE_GTK */
1321 FRAME_MENU_BAR_LINES (f) = nlines;
1322 change_window_heights (f->root_window, nlines - olines);
1323 #endif /* not USE_X_TOOLKIT */
1324 adjust_glyphs (f);
1325 }
1326
1327
1328 /* Set the number of lines used for the tool bar of frame F to VALUE.
1329 VALUE not an integer, or < 0 means set the lines to zero. OLDVAL
1330 is the old number of tool bar lines. This function changes the
1331 height of all windows on frame F to match the new tool bar height.
1332 The frame's height doesn't change. */
1333
1334 void
1335 x_set_tool_bar_lines (f, value, oldval)
1336 struct frame *f;
1337 Lisp_Object value, oldval;
1338 {
1339 int delta, nlines, root_height;
1340 Lisp_Object root_window;
1341
1342 /* Treat tool bars like menu bars. */
1343 if (FRAME_MINIBUF_ONLY_P (f))
1344 return;
1345
1346 /* Use VALUE only if an integer >= 0. */
1347 if (INTEGERP (value) && XINT (value) >= 0)
1348 nlines = XFASTINT (value);
1349 else
1350 nlines = 0;
1351
1352 #ifdef USE_GTK
1353 FRAME_TOOL_BAR_LINES (f) = 0;
1354 if (nlines)
1355 {
1356 FRAME_EXTERNAL_TOOL_BAR (f) = 1;
1357 if (FRAME_X_P (f) && f->output_data.x->toolbar_widget == 0)
1358 /* Make sure next redisplay shows the tool bar. */
1359 XWINDOW (FRAME_SELECTED_WINDOW (f))->update_mode_line = Qt;
1360 update_frame_tool_bar (f);
1361 }
1362 else
1363 {
1364 if (FRAME_EXTERNAL_TOOL_BAR (f))
1365 free_frame_tool_bar (f);
1366 FRAME_EXTERNAL_TOOL_BAR (f) = 0;
1367 }
1368
1369 return;
1370 #endif
1371
1372 /* Make sure we redisplay all windows in this frame. */
1373 ++windows_or_buffers_changed;
1374
1375 delta = nlines - FRAME_TOOL_BAR_LINES (f);
1376
1377 /* Don't resize the tool-bar to more than we have room for. */
1378 root_window = FRAME_ROOT_WINDOW (f);
1379 root_height = WINDOW_TOTAL_LINES (XWINDOW (root_window));
1380 if (root_height - delta < 1)
1381 {
1382 delta = root_height - 1;
1383 nlines = FRAME_TOOL_BAR_LINES (f) + delta;
1384 }
1385
1386 FRAME_TOOL_BAR_LINES (f) = nlines;
1387 change_window_heights (root_window, delta);
1388 adjust_glyphs (f);
1389
1390 /* We also have to make sure that the internal border at the top of
1391 the frame, below the menu bar or tool bar, is redrawn when the
1392 tool bar disappears. This is so because the internal border is
1393 below the tool bar if one is displayed, but is below the menu bar
1394 if there isn't a tool bar. The tool bar draws into the area
1395 below the menu bar. */
1396 if (FRAME_X_WINDOW (f) && FRAME_TOOL_BAR_LINES (f) == 0)
1397 {
1398 clear_frame (f);
1399 clear_current_matrices (f);
1400 }
1401
1402 /* If the tool bar gets smaller, the internal border below it
1403 has to be cleared. It was formerly part of the display
1404 of the larger tool bar, and updating windows won't clear it. */
1405 if (delta < 0)
1406 {
1407 int height = FRAME_INTERNAL_BORDER_WIDTH (f);
1408 int width = FRAME_PIXEL_WIDTH (f);
1409 int y = nlines * FRAME_LINE_HEIGHT (f);
1410
1411 /* height can be zero here. */
1412 if (height > 0 && width > 0)
1413 {
1414 BLOCK_INPUT;
1415 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1416 0, y, width, height, False);
1417 UNBLOCK_INPUT;
1418 }
1419
1420 if (WINDOWP (f->tool_bar_window))
1421 clear_glyph_matrix (XWINDOW (f->tool_bar_window)->current_matrix);
1422 }
1423 }
1424
1425
1426 /* Set the foreground color for scroll bars on frame F to VALUE.
1427 VALUE should be a string, a color name. If it isn't a string or
1428 isn't a valid color name, do nothing. OLDVAL is the old value of
1429 the frame parameter. */
1430
1431 void
1432 x_set_scroll_bar_foreground (f, value, oldval)
1433 struct frame *f;
1434 Lisp_Object value, oldval;
1435 {
1436 unsigned long pixel;
1437
1438 if (STRINGP (value))
1439 pixel = x_decode_color (f, value, BLACK_PIX_DEFAULT (f));
1440 else
1441 pixel = -1;
1442
1443 if (f->output_data.x->scroll_bar_foreground_pixel != -1)
1444 unload_color (f, f->output_data.x->scroll_bar_foreground_pixel);
1445
1446 f->output_data.x->scroll_bar_foreground_pixel = pixel;
1447 if (FRAME_X_WINDOW (f) && FRAME_VISIBLE_P (f))
1448 {
1449 /* Remove all scroll bars because they have wrong colors. */
1450 if (FRAME_DISPLAY (f)->condemn_scroll_bars_hook)
1451 (*FRAME_DISPLAY (f)->condemn_scroll_bars_hook) (f);
1452 if (FRAME_DISPLAY (f)->judge_scroll_bars_hook)
1453 (*FRAME_DISPLAY (f)->judge_scroll_bars_hook) (f);
1454
1455 update_face_from_frame_parameter (f, Qscroll_bar_foreground, value);
1456 redraw_frame (f);
1457 }
1458 }
1459
1460
1461 /* Set the background color for scroll bars on frame F to VALUE VALUE
1462 should be a string, a color name. If it isn't a string or isn't a
1463 valid color name, do nothing. OLDVAL is the old value of the frame
1464 parameter. */
1465
1466 void
1467 x_set_scroll_bar_background (f, value, oldval)
1468 struct frame *f;
1469 Lisp_Object value, oldval;
1470 {
1471 unsigned long pixel;
1472
1473 if (STRINGP (value))
1474 pixel = x_decode_color (f, value, WHITE_PIX_DEFAULT (f));
1475 else
1476 pixel = -1;
1477
1478 if (f->output_data.x->scroll_bar_background_pixel != -1)
1479 unload_color (f, f->output_data.x->scroll_bar_background_pixel);
1480
1481 #ifdef USE_TOOLKIT_SCROLL_BARS
1482 /* Scrollbar shadow colors. */
1483 if (f->output_data.x->scroll_bar_top_shadow_pixel != -1)
1484 {
1485 unload_color (f, f->output_data.x->scroll_bar_top_shadow_pixel);
1486 f->output_data.x->scroll_bar_top_shadow_pixel = -1;
1487 }
1488 if (f->output_data.x->scroll_bar_bottom_shadow_pixel != -1)
1489 {
1490 unload_color (f, f->output_data.x->scroll_bar_bottom_shadow_pixel);
1491 f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
1492 }
1493 #endif /* USE_TOOLKIT_SCROLL_BARS */
1494
1495 f->output_data.x->scroll_bar_background_pixel = pixel;
1496 if (FRAME_X_WINDOW (f) && FRAME_VISIBLE_P (f))
1497 {
1498 /* Remove all scroll bars because they have wrong colors. */
1499 if (FRAME_DISPLAY (f)->condemn_scroll_bars_hook)
1500 (*FRAME_DISPLAY (f)->condemn_scroll_bars_hook) (f);
1501 if (FRAME_DISPLAY (f)->judge_scroll_bars_hook)
1502 (*FRAME_DISPLAY (f)->judge_scroll_bars_hook) (f);
1503
1504 update_face_from_frame_parameter (f, Qscroll_bar_background, value);
1505 redraw_frame (f);
1506 }
1507 }
1508
1509 \f
1510 /* Encode Lisp string STRING as a text in a format appropriate for
1511 XICCC (X Inter Client Communication Conventions).
1512
1513 If STRING contains only ASCII characters, do no conversion and
1514 return the string data of STRING. Otherwise, encode the text by
1515 CODING_SYSTEM, and return a newly allocated memory area which
1516 should be freed by `xfree' by a caller.
1517
1518 SELECTIONP non-zero means the string is being encoded for an X
1519 selection, so it is safe to run pre-write conversions (which
1520 may run Lisp code).
1521
1522 Store the byte length of resulting text in *TEXT_BYTES.
1523
1524 If the text contains only ASCII and Latin-1, store 1 in *STRING_P,
1525 which means that the `encoding' of the result can be `STRING'.
1526 Otherwise store 0 in *STRINGP, which means that the `encoding' of
1527 the result should be `COMPOUND_TEXT'. */
1528
1529 unsigned char *
1530 x_encode_text (string, coding_system, selectionp, text_bytes, stringp)
1531 Lisp_Object string, coding_system;
1532 int *text_bytes, *stringp;
1533 int selectionp;
1534 {
1535 unsigned char *str = SDATA (string);
1536 int chars = SCHARS (string);
1537 int bytes = SBYTES (string);
1538 int charset_info;
1539 int bufsize;
1540 unsigned char *buf;
1541 struct coding_system coding;
1542 extern Lisp_Object Qcompound_text_with_extensions;
1543
1544 charset_info = find_charset_in_text (str, chars, bytes, NULL, Qnil);
1545 if (charset_info == 0)
1546 {
1547 /* No multibyte character in OBJ. We need not encode it. */
1548 *text_bytes = bytes;
1549 *stringp = 1;
1550 return str;
1551 }
1552
1553 setup_coding_system (coding_system, &coding);
1554 if (selectionp
1555 && SYMBOLP (coding.pre_write_conversion)
1556 && !NILP (Ffboundp (coding.pre_write_conversion)))
1557 {
1558 string = run_pre_post_conversion_on_str (string, &coding, 1);
1559 str = SDATA (string);
1560 chars = SCHARS (string);
1561 bytes = SBYTES (string);
1562 }
1563 coding.src_multibyte = 1;
1564 coding.dst_multibyte = 0;
1565 coding.mode |= CODING_MODE_LAST_BLOCK;
1566 if (coding.type == coding_type_iso2022)
1567 coding.flags |= CODING_FLAG_ISO_SAFE;
1568 /* We suppress producing escape sequences for composition. */
1569 coding.composing = COMPOSITION_DISABLED;
1570 bufsize = encoding_buffer_size (&coding, bytes);
1571 buf = (unsigned char *) xmalloc (bufsize);
1572 encode_coding (&coding, str, buf, bytes, bufsize);
1573 *text_bytes = coding.produced;
1574 *stringp = (charset_info == 1
1575 || (!EQ (coding_system, Qcompound_text)
1576 && !EQ (coding_system, Qcompound_text_with_extensions)));
1577 return buf;
1578 }
1579
1580 \f
1581 /* Set the WM name to NAME for frame F. Also set the icon name.
1582 If the frame already has an icon name, use that, otherwise set the
1583 icon name to NAME. */
1584
1585 static void
1586 x_set_name_internal (f, name)
1587 FRAME_PTR f;
1588 Lisp_Object name;
1589 {
1590 if (FRAME_X_WINDOW (f))
1591 {
1592 BLOCK_INPUT;
1593 #ifdef HAVE_X11R4
1594 {
1595 XTextProperty text, icon;
1596 int bytes, stringp;
1597 int do_free_icon_value = 0, do_free_text_value = 0;
1598 Lisp_Object coding_system;
1599
1600 coding_system = Qcompound_text;
1601 /* Note: Encoding strategy
1602
1603 We encode NAME by compound-text and use "COMPOUND-TEXT" in
1604 text.encoding. But, there are non-internationalized window
1605 managers which don't support that encoding. So, if NAME
1606 contains only ASCII and 8859-1 characters, encode it by
1607 iso-latin-1, and use "STRING" in text.encoding hoping that
1608 such window managers at least analyze this format correctly,
1609 i.e. treat 8-bit bytes as 8859-1 characters.
1610
1611 We may also be able to use "UTF8_STRING" in text.encoding
1612 in the future which can encode all Unicode characters.
1613 But, for the moment, there's no way to know that the
1614 current window manager supports it or not. */
1615 text.value = x_encode_text (name, coding_system, 0, &bytes, &stringp);
1616 text.encoding = (stringp ? XA_STRING
1617 : FRAME_X_DISPLAY_INFO (f)->Xatom_COMPOUND_TEXT);
1618 text.format = 8;
1619 text.nitems = bytes;
1620
1621 /* Check early, because ENCODE_UTF_8 below may GC and name may be
1622 relocated. */
1623 do_free_text_value = text.value != SDATA (name);
1624
1625 if (NILP (f->icon_name))
1626 {
1627 icon = text;
1628 }
1629 else
1630 {
1631 /* See the above comment "Note: Encoding strategy". */
1632 icon.value = x_encode_text (f->icon_name, coding_system, 0,
1633 &bytes, &stringp);
1634 icon.encoding = (stringp ? XA_STRING
1635 : FRAME_X_DISPLAY_INFO (f)->Xatom_COMPOUND_TEXT);
1636 icon.format = 8;
1637 icon.nitems = bytes;
1638 do_free_icon_value = icon.value != SDATA (f->icon_name);
1639 }
1640
1641 #ifdef USE_GTK
1642 gtk_window_set_title (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
1643 SDATA (ENCODE_UTF_8 (name)));
1644 #else /* not USE_GTK */
1645 XSetWMName (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &text);
1646 #endif /* not USE_GTK */
1647
1648 XSetWMIconName (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &icon);
1649
1650 if (do_free_icon_value)
1651 xfree (icon.value);
1652 if (do_free_text_value)
1653 xfree (text.value);
1654 }
1655 #else /* not HAVE_X11R4 */
1656 XSetIconName (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1657 SDATA (name));
1658 XStoreName (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1659 SDATA (name));
1660 #endif /* not HAVE_X11R4 */
1661 UNBLOCK_INPUT;
1662 }
1663 }
1664
1665 /* Change the name of frame F to NAME. If NAME is nil, set F's name to
1666 x_id_name.
1667
1668 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1669 name; if NAME is a string, set F's name to NAME and set
1670 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1671
1672 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1673 suggesting a new name, which lisp code should override; if
1674 F->explicit_name is set, ignore the new name; otherwise, set it. */
1675
1676 void
1677 x_set_name (f, name, explicit)
1678 struct frame *f;
1679 Lisp_Object name;
1680 int explicit;
1681 {
1682 /* Make sure that requests from lisp code override requests from
1683 Emacs redisplay code. */
1684 if (explicit)
1685 {
1686 /* If we're switching from explicit to implicit, we had better
1687 update the mode lines and thereby update the title. */
1688 if (f->explicit_name && NILP (name))
1689 update_mode_lines = 1;
1690
1691 f->explicit_name = ! NILP (name);
1692 }
1693 else if (f->explicit_name)
1694 return;
1695
1696 /* If NAME is nil, set the name to the x_id_name. */
1697 if (NILP (name))
1698 {
1699 /* Check for no change needed in this very common case
1700 before we do any consing. */
1701 if (!strcmp (FRAME_X_DISPLAY_INFO (f)->x_id_name,
1702 SDATA (f->name)))
1703 return;
1704 name = build_string (FRAME_X_DISPLAY_INFO (f)->x_id_name);
1705 }
1706 else
1707 CHECK_STRING (name);
1708
1709 /* Don't change the name if it's already NAME. */
1710 if (! NILP (Fstring_equal (name, f->name)))
1711 return;
1712
1713 f->name = name;
1714
1715 /* For setting the frame title, the title parameter should override
1716 the name parameter. */
1717 if (! NILP (f->title))
1718 name = f->title;
1719
1720 x_set_name_internal (f, name);
1721 }
1722
1723 /* This function should be called when the user's lisp code has
1724 specified a name for the frame; the name will override any set by the
1725 redisplay code. */
1726 void
1727 x_explicitly_set_name (f, arg, oldval)
1728 FRAME_PTR f;
1729 Lisp_Object arg, oldval;
1730 {
1731 x_set_name (f, arg, 1);
1732 }
1733
1734 /* This function should be called by Emacs redisplay code to set the
1735 name; names set this way will never override names set by the user's
1736 lisp code. */
1737 void
1738 x_implicitly_set_name (f, arg, oldval)
1739 FRAME_PTR f;
1740 Lisp_Object arg, oldval;
1741 {
1742 x_set_name (f, arg, 0);
1743 }
1744 \f
1745 /* Change the title of frame F to NAME.
1746 If NAME is nil, use the frame name as the title.
1747
1748 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1749 name; if NAME is a string, set F's name to NAME and set
1750 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1751
1752 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1753 suggesting a new name, which lisp code should override; if
1754 F->explicit_name is set, ignore the new name; otherwise, set it. */
1755
1756 void
1757 x_set_title (f, name, old_name)
1758 struct frame *f;
1759 Lisp_Object name, old_name;
1760 {
1761 /* Don't change the title if it's already NAME. */
1762 if (EQ (name, f->title))
1763 return;
1764
1765 update_mode_lines = 1;
1766
1767 f->title = name;
1768
1769 if (NILP (name))
1770 name = f->name;
1771 else
1772 CHECK_STRING (name);
1773
1774 x_set_name_internal (f, name);
1775 }
1776
1777 void
1778 x_set_scroll_bar_default_width (f)
1779 struct frame *f;
1780 {
1781 int wid = FRAME_COLUMN_WIDTH (f);
1782
1783 #ifdef USE_TOOLKIT_SCROLL_BARS
1784 /* A minimum width of 14 doesn't look good for toolkit scroll bars. */
1785 int width = 16 + 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM;
1786 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (width + wid - 1) / wid;
1787 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = width;
1788 #else
1789 /* Make the actual width at least 14 pixels and a multiple of a
1790 character width. */
1791 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
1792
1793 /* Use all of that space (aside from required margins) for the
1794 scroll bar. */
1795 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = 0;
1796 #endif
1797 }
1798
1799 \f
1800 /* Record in frame F the specified or default value according to ALIST
1801 of the parameter named PROP (a Lisp symbol). If no value is
1802 specified for PROP, look for an X default for XPROP on the frame
1803 named NAME. If that is not found either, use the value DEFLT. */
1804
1805 static Lisp_Object
1806 x_default_scroll_bar_color_parameter (f, alist, prop, xprop, xclass,
1807 foreground_p)
1808 struct frame *f;
1809 Lisp_Object alist;
1810 Lisp_Object prop;
1811 char *xprop;
1812 char *xclass;
1813 int foreground_p;
1814 {
1815 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
1816 Lisp_Object tem;
1817
1818 tem = x_get_arg (dpyinfo, alist, prop, xprop, xclass, RES_TYPE_STRING);
1819 if (EQ (tem, Qunbound))
1820 {
1821 #ifdef USE_TOOLKIT_SCROLL_BARS
1822
1823 /* See if an X resource for the scroll bar color has been
1824 specified. */
1825 tem = display_x_get_resource (dpyinfo,
1826 build_string (foreground_p
1827 ? "foreground"
1828 : "background"),
1829 empty_string,
1830 build_string ("verticalScrollBar"),
1831 empty_string);
1832 if (!STRINGP (tem))
1833 {
1834 /* If nothing has been specified, scroll bars will use a
1835 toolkit-dependent default. Because these defaults are
1836 difficult to get at without actually creating a scroll
1837 bar, use nil to indicate that no color has been
1838 specified. */
1839 tem = Qnil;
1840 }
1841
1842 #else /* not USE_TOOLKIT_SCROLL_BARS */
1843
1844 tem = Qnil;
1845
1846 #endif /* not USE_TOOLKIT_SCROLL_BARS */
1847 }
1848
1849 x_set_frame_parameters (f, Fcons (Fcons (prop, tem), Qnil));
1850 return tem;
1851 }
1852
1853
1854
1855 #if !defined (HAVE_X11R4) && !defined (HAVE_XSETWMPROTOCOLS)
1856
1857 Status
1858 XSetWMProtocols (dpy, w, protocols, count)
1859 Display *dpy;
1860 Window w;
1861 Atom *protocols;
1862 int count;
1863 {
1864 Atom prop;
1865 prop = XInternAtom (dpy, "WM_PROTOCOLS", False);
1866 if (prop == None) return False;
1867 XChangeProperty (dpy, w, prop, XA_ATOM, 32, PropModeReplace,
1868 (unsigned char *) protocols, count);
1869 return True;
1870 }
1871 #endif /* not HAVE_X11R4 && not HAVE_XSETWMPROTOCOLS */
1872 \f
1873 #ifdef USE_X_TOOLKIT
1874
1875 /* If the WM_PROTOCOLS property does not already contain WM_TAKE_FOCUS,
1876 WM_DELETE_WINDOW, and WM_SAVE_YOURSELF, then add them. (They may
1877 already be present because of the toolkit (Motif adds some of them,
1878 for example, but Xt doesn't). */
1879
1880 static void
1881 hack_wm_protocols (f, widget)
1882 FRAME_PTR f;
1883 Widget widget;
1884 {
1885 Display *dpy = XtDisplay (widget);
1886 Window w = XtWindow (widget);
1887 int need_delete = 1;
1888 int need_focus = 1;
1889 int need_save = 1;
1890
1891 BLOCK_INPUT;
1892 {
1893 Atom type;
1894 unsigned char *catoms;
1895 int format = 0;
1896 unsigned long nitems = 0;
1897 unsigned long bytes_after;
1898
1899 if ((XGetWindowProperty (dpy, w,
1900 FRAME_X_DISPLAY_INFO (f)->Xatom_wm_protocols,
1901 (long)0, (long)100, False, XA_ATOM,
1902 &type, &format, &nitems, &bytes_after,
1903 &catoms)
1904 == Success)
1905 && format == 32 && type == XA_ATOM)
1906 {
1907 Atom *atoms = (Atom *) catoms;
1908 while (nitems > 0)
1909 {
1910 nitems--;
1911 if (atoms[nitems]
1912 == FRAME_X_DISPLAY_INFO (f)->Xatom_wm_delete_window)
1913 need_delete = 0;
1914 else if (atoms[nitems]
1915 == FRAME_X_DISPLAY_INFO (f)->Xatom_wm_take_focus)
1916 need_focus = 0;
1917 else if (atoms[nitems]
1918 == FRAME_X_DISPLAY_INFO (f)->Xatom_wm_save_yourself)
1919 need_save = 0;
1920 }
1921 }
1922 if (catoms)
1923 XFree (catoms);
1924 }
1925 {
1926 Atom props [10];
1927 int count = 0;
1928 if (need_delete)
1929 props[count++] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_delete_window;
1930 if (need_focus)
1931 props[count++] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_take_focus;
1932 if (need_save)
1933 props[count++] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_save_yourself;
1934 if (count)
1935 XChangeProperty (dpy, w, FRAME_X_DISPLAY_INFO (f)->Xatom_wm_protocols,
1936 XA_ATOM, 32, PropModeAppend,
1937 (unsigned char *) props, count);
1938 }
1939 UNBLOCK_INPUT;
1940 }
1941 #endif
1942
1943
1944 \f
1945 /* Support routines for XIC (X Input Context). */
1946
1947 #ifdef HAVE_X_I18N
1948
1949 static XFontSet xic_create_xfontset P_ ((struct frame *, char *));
1950 static XIMStyle best_xim_style P_ ((XIMStyles *, XIMStyles *));
1951
1952
1953 /* Supported XIM styles, ordered by preference. */
1954
1955 static XIMStyle supported_xim_styles[] =
1956 {
1957 XIMPreeditPosition | XIMStatusArea,
1958 XIMPreeditPosition | XIMStatusNothing,
1959 XIMPreeditPosition | XIMStatusNone,
1960 XIMPreeditNothing | XIMStatusArea,
1961 XIMPreeditNothing | XIMStatusNothing,
1962 XIMPreeditNothing | XIMStatusNone,
1963 XIMPreeditNone | XIMStatusArea,
1964 XIMPreeditNone | XIMStatusNothing,
1965 XIMPreeditNone | XIMStatusNone,
1966 0,
1967 };
1968
1969
1970 /* Create an X fontset on frame F with base font name BASE_FONTNAME. */
1971
1972 static XFontSet
1973 xic_create_xfontset (f, base_fontname)
1974 struct frame *f;
1975 char *base_fontname;
1976 {
1977 XFontSet xfs = NULL;
1978 char **missing_list = NULL;
1979 int missing_count;
1980 char *def_string;
1981 Lisp_Object rest, frame;
1982
1983 /* See if there is another frame already using same fontset. */
1984 FOR_EACH_FRAME (rest, frame)
1985 {
1986 struct frame *cf = XFRAME (frame);
1987 if (cf != f && FRAME_LIVE_P (f) && FRAME_X_P (cf)
1988 && FRAME_X_DISPLAY_INFO (cf) == FRAME_X_DISPLAY_INFO (f)
1989 && FRAME_XIC_BASE_FONTNAME (cf)
1990 && !strcmp (FRAME_XIC_BASE_FONTNAME (cf), base_fontname))
1991 {
1992 xfs = FRAME_XIC_FONTSET (cf);
1993 break;
1994 }
1995 }
1996
1997 if (!xfs)
1998 {
1999 /* New fontset. */
2000 xfs = XCreateFontSet (FRAME_X_DISPLAY (f),
2001 base_fontname, &missing_list,
2002 &missing_count, &def_string);
2003 if (missing_list)
2004 XFreeStringList (missing_list);
2005 }
2006
2007 if (FRAME_XIC_BASE_FONTNAME (f))
2008 xfree (FRAME_XIC_BASE_FONTNAME (f));
2009 FRAME_XIC_BASE_FONTNAME (f) = xstrdup (base_fontname);
2010
2011 /* No need to free def_string. */
2012 return xfs;
2013 }
2014
2015 /* Free the X fontset of frame F if it is the last frame using it. */
2016
2017 void
2018 xic_free_xfontset (f)
2019 struct frame *f;
2020 {
2021 Lisp_Object rest, frame;
2022 int shared_p = 0;
2023
2024 if (!FRAME_XIC_FONTSET (f))
2025 return;
2026
2027 /* See if there is another frame sharing the same fontset. */
2028 FOR_EACH_FRAME (rest, frame)
2029 {
2030 struct frame *cf = XFRAME (frame);
2031 if (cf != f && FRAME_LIVE_P (f) && FRAME_X_P (cf)
2032 && FRAME_X_DISPLAY_INFO (cf) == FRAME_X_DISPLAY_INFO (f)
2033 && FRAME_XIC_FONTSET (cf) == FRAME_XIC_FONTSET (f))
2034 {
2035 shared_p = 1;
2036 break;
2037 }
2038 }
2039
2040 if (!shared_p)
2041 /* The fontset is not used anymore. It is safe to free it. */
2042 XFreeFontSet (FRAME_X_DISPLAY (f), FRAME_XIC_FONTSET (f));
2043
2044 if (FRAME_XIC_BASE_FONTNAME (f))
2045 xfree (FRAME_XIC_BASE_FONTNAME (f));
2046 FRAME_XIC_BASE_FONTNAME (f) = NULL;
2047 FRAME_XIC_FONTSET (f) = NULL;
2048 }
2049
2050
2051 /* Value is the best input style, given user preferences USER (already
2052 checked to be supported by Emacs), and styles supported by the
2053 input method XIM. */
2054
2055 static XIMStyle
2056 best_xim_style (user, xim)
2057 XIMStyles *user;
2058 XIMStyles *xim;
2059 {
2060 int i, j;
2061
2062 for (i = 0; i < user->count_styles; ++i)
2063 for (j = 0; j < xim->count_styles; ++j)
2064 if (user->supported_styles[i] == xim->supported_styles[j])
2065 return user->supported_styles[i];
2066
2067 /* Return the default style. */
2068 return XIMPreeditNothing | XIMStatusNothing;
2069 }
2070
2071 /* Create XIC for frame F. */
2072
2073 static XIMStyle xic_style;
2074
2075 void
2076 create_frame_xic (f)
2077 struct frame *f;
2078 {
2079 XIM xim;
2080 XIC xic = NULL;
2081 XFontSet xfs = NULL;
2082
2083 if (FRAME_XIC (f))
2084 return;
2085
2086 xim = FRAME_X_XIM (f);
2087 if (xim)
2088 {
2089 XRectangle s_area;
2090 XPoint spot;
2091 XVaNestedList preedit_attr;
2092 XVaNestedList status_attr;
2093 char *base_fontname;
2094 int fontset;
2095
2096 s_area.x = 0; s_area.y = 0; s_area.width = 1; s_area.height = 1;
2097 spot.x = 0; spot.y = 1;
2098 /* Create X fontset. */
2099 fontset = FRAME_FONTSET (f);
2100 if (fontset < 0)
2101 base_fontname = "-*-*-*-r-normal--14-*-*-*-*-*-*-*";
2102 else
2103 {
2104 /* Determine the base fontname from the ASCII font name of
2105 FONTSET. */
2106 char *ascii_font = (char *) SDATA (fontset_ascii (fontset));
2107 char *p = ascii_font;
2108 int i;
2109
2110 for (i = 0; *p; p++)
2111 if (*p == '-') i++;
2112 if (i != 14)
2113 /* As the font name doesn't conform to XLFD, we can't
2114 modify it to get a suitable base fontname for the
2115 frame. */
2116 base_fontname = "-*-*-*-r-normal--14-*-*-*-*-*-*-*";
2117 else
2118 {
2119 int len = strlen (ascii_font) + 1;
2120 char *p1 = NULL;
2121
2122 for (i = 0, p = ascii_font; i < 8; p++)
2123 {
2124 if (*p == '-')
2125 {
2126 i++;
2127 if (i == 3)
2128 p1 = p + 1;
2129 }
2130 }
2131 base_fontname = (char *) alloca (len);
2132 bzero (base_fontname, len);
2133 strcpy (base_fontname, "-*-*-");
2134 bcopy (p1, base_fontname + 5, p - p1);
2135 strcat (base_fontname, "*-*-*-*-*-*-*");
2136 }
2137 }
2138 xfs = xic_create_xfontset (f, base_fontname);
2139
2140 /* Determine XIC style. */
2141 if (xic_style == 0)
2142 {
2143 XIMStyles supported_list;
2144 supported_list.count_styles = (sizeof supported_xim_styles
2145 / sizeof supported_xim_styles[0]);
2146 supported_list.supported_styles = supported_xim_styles;
2147 xic_style = best_xim_style (&supported_list,
2148 FRAME_X_XIM_STYLES (f));
2149 }
2150
2151 preedit_attr = XVaCreateNestedList (0,
2152 XNFontSet, xfs,
2153 XNForeground,
2154 FRAME_FOREGROUND_PIXEL (f),
2155 XNBackground,
2156 FRAME_BACKGROUND_PIXEL (f),
2157 (xic_style & XIMPreeditPosition
2158 ? XNSpotLocation
2159 : NULL),
2160 &spot,
2161 NULL);
2162 status_attr = XVaCreateNestedList (0,
2163 XNArea,
2164 &s_area,
2165 XNFontSet,
2166 xfs,
2167 XNForeground,
2168 FRAME_FOREGROUND_PIXEL (f),
2169 XNBackground,
2170 FRAME_BACKGROUND_PIXEL (f),
2171 NULL);
2172
2173 xic = XCreateIC (xim,
2174 XNInputStyle, xic_style,
2175 XNClientWindow, FRAME_X_WINDOW (f),
2176 XNFocusWindow, FRAME_X_WINDOW (f),
2177 XNStatusAttributes, status_attr,
2178 XNPreeditAttributes, preedit_attr,
2179 NULL);
2180 XFree (preedit_attr);
2181 XFree (status_attr);
2182 }
2183
2184 FRAME_XIC (f) = xic;
2185 FRAME_XIC_STYLE (f) = xic_style;
2186 FRAME_XIC_FONTSET (f) = xfs;
2187 }
2188
2189
2190 /* Destroy XIC and free XIC fontset of frame F, if any. */
2191
2192 void
2193 free_frame_xic (f)
2194 struct frame *f;
2195 {
2196 if (FRAME_XIC (f) == NULL)
2197 return;
2198
2199 XDestroyIC (FRAME_XIC (f));
2200 xic_free_xfontset (f);
2201
2202 FRAME_XIC (f) = NULL;
2203 }
2204
2205
2206 /* Place preedit area for XIC of window W's frame to specified
2207 pixel position X/Y. X and Y are relative to window W. */
2208
2209 void
2210 xic_set_preeditarea (w, x, y)
2211 struct window *w;
2212 int x, y;
2213 {
2214 struct frame *f = XFRAME (w->frame);
2215 XVaNestedList attr;
2216 XPoint spot;
2217
2218 spot.x = WINDOW_TO_FRAME_PIXEL_X (w, x) + WINDOW_LEFT_FRINGE_WIDTH (w);
2219 spot.y = WINDOW_TO_FRAME_PIXEL_Y (w, y) + FONT_BASE (FRAME_FONT (f));
2220 attr = XVaCreateNestedList (0, XNSpotLocation, &spot, NULL);
2221 XSetICValues (FRAME_XIC (f), XNPreeditAttributes, attr, NULL);
2222 XFree (attr);
2223 }
2224
2225
2226 /* Place status area for XIC in bottom right corner of frame F.. */
2227
2228 void
2229 xic_set_statusarea (f)
2230 struct frame *f;
2231 {
2232 XIC xic = FRAME_XIC (f);
2233 XVaNestedList attr;
2234 XRectangle area;
2235 XRectangle *needed;
2236
2237 /* Negotiate geometry of status area. If input method has existing
2238 status area, use its current size. */
2239 area.x = area.y = area.width = area.height = 0;
2240 attr = XVaCreateNestedList (0, XNAreaNeeded, &area, NULL);
2241 XSetICValues (xic, XNStatusAttributes, attr, NULL);
2242 XFree (attr);
2243
2244 attr = XVaCreateNestedList (0, XNAreaNeeded, &needed, NULL);
2245 XGetICValues (xic, XNStatusAttributes, attr, NULL);
2246 XFree (attr);
2247
2248 if (needed->width == 0) /* Use XNArea instead of XNAreaNeeded */
2249 {
2250 attr = XVaCreateNestedList (0, XNArea, &needed, NULL);
2251 XGetICValues (xic, XNStatusAttributes, attr, NULL);
2252 XFree (attr);
2253 }
2254
2255 area.width = needed->width;
2256 area.height = needed->height;
2257 area.x = FRAME_PIXEL_WIDTH (f) - area.width - FRAME_INTERNAL_BORDER_WIDTH (f);
2258 area.y = (FRAME_PIXEL_HEIGHT (f) - area.height
2259 - FRAME_MENUBAR_HEIGHT (f)
2260 - FRAME_TOOLBAR_HEIGHT (f)
2261 - FRAME_INTERNAL_BORDER_WIDTH (f));
2262 XFree (needed);
2263
2264 attr = XVaCreateNestedList (0, XNArea, &area, NULL);
2265 XSetICValues (xic, XNStatusAttributes, attr, NULL);
2266 XFree (attr);
2267 }
2268
2269
2270 /* Set X fontset for XIC of frame F, using base font name
2271 BASE_FONTNAME. Called when a new Emacs fontset is chosen. */
2272
2273 void
2274 xic_set_xfontset (f, base_fontname)
2275 struct frame *f;
2276 char *base_fontname;
2277 {
2278 XVaNestedList attr;
2279 XFontSet xfs;
2280
2281 xic_free_xfontset (f);
2282
2283 xfs = xic_create_xfontset (f, base_fontname);
2284
2285 attr = XVaCreateNestedList (0, XNFontSet, xfs, NULL);
2286 if (FRAME_XIC_STYLE (f) & XIMPreeditPosition)
2287 XSetICValues (FRAME_XIC (f), XNPreeditAttributes, attr, NULL);
2288 if (FRAME_XIC_STYLE (f) & XIMStatusArea)
2289 XSetICValues (FRAME_XIC (f), XNStatusAttributes, attr, NULL);
2290 XFree (attr);
2291
2292 FRAME_XIC_FONTSET (f) = xfs;
2293 }
2294
2295 #endif /* HAVE_X_I18N */
2296
2297
2298 \f
2299 #ifdef USE_X_TOOLKIT
2300
2301 /* Create and set up the X widget for frame F. */
2302
2303 static void
2304 x_window (f, window_prompting, minibuffer_only)
2305 struct frame *f;
2306 long window_prompting;
2307 int minibuffer_only;
2308 {
2309 XClassHint class_hints;
2310 XSetWindowAttributes attributes;
2311 unsigned long attribute_mask;
2312 Widget shell_widget;
2313 Widget pane_widget;
2314 Widget frame_widget;
2315 Arg al [25];
2316 int ac;
2317
2318 BLOCK_INPUT;
2319
2320 /* Use the resource name as the top-level widget name
2321 for looking up resources. Make a non-Lisp copy
2322 for the window manager, so GC relocation won't bother it.
2323
2324 Elsewhere we specify the window name for the window manager. */
2325
2326 {
2327 char *str = (char *) SDATA (Vx_resource_name);
2328 f->namebuf = (char *) xmalloc (strlen (str) + 1);
2329 strcpy (f->namebuf, str);
2330 }
2331
2332 ac = 0;
2333 XtSetArg (al[ac], XtNallowShellResize, 1); ac++;
2334 XtSetArg (al[ac], XtNinput, 1); ac++;
2335 XtSetArg (al[ac], XtNmappedWhenManaged, 0); ac++;
2336 XtSetArg (al[ac], XtNborderWidth, f->border_width); ac++;
2337 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2338 XtSetArg (al[ac], XtNdepth, FRAME_X_DISPLAY_INFO (f)->n_planes); ac++;
2339 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2340 shell_widget = XtAppCreateShell (f->namebuf, EMACS_CLASS,
2341 applicationShellWidgetClass,
2342 FRAME_X_DISPLAY (f), al, ac);
2343
2344 f->output_data.x->widget = shell_widget;
2345 /* maybe_set_screen_title_format (shell_widget); */
2346
2347 pane_widget = lw_create_widget ("main", "pane", widget_id_tick++,
2348 (widget_value *) NULL,
2349 shell_widget, False,
2350 (lw_callback) NULL,
2351 (lw_callback) NULL,
2352 (lw_callback) NULL,
2353 (lw_callback) NULL);
2354
2355 ac = 0;
2356 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2357 XtSetArg (al[ac], XtNdepth, FRAME_X_DISPLAY_INFO (f)->n_planes); ac++;
2358 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2359 XtSetValues (pane_widget, al, ac);
2360 f->output_data.x->column_widget = pane_widget;
2361
2362 /* mappedWhenManaged to false tells to the paned window to not map/unmap
2363 the emacs screen when changing menubar. This reduces flickering. */
2364
2365 ac = 0;
2366 XtSetArg (al[ac], XtNmappedWhenManaged, 0); ac++;
2367 XtSetArg (al[ac], XtNshowGrip, 0); ac++;
2368 XtSetArg (al[ac], XtNallowResize, 1); ac++;
2369 XtSetArg (al[ac], XtNresizeToPreferred, 1); ac++;
2370 XtSetArg (al[ac], XtNemacsFrame, f); ac++;
2371 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2372 XtSetArg (al[ac], XtNdepth, FRAME_X_DISPLAY_INFO (f)->n_planes); ac++;
2373 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2374 frame_widget = XtCreateWidget (f->namebuf, emacsFrameClass, pane_widget,
2375 al, ac);
2376
2377 f->output_data.x->edit_widget = frame_widget;
2378
2379 XtManageChild (frame_widget);
2380
2381 /* Do some needed geometry management. */
2382 {
2383 int len;
2384 char *tem, shell_position[32];
2385 Arg al[10];
2386 int ac = 0;
2387 int extra_borders = 0;
2388 int menubar_size
2389 = (f->output_data.x->menubar_widget
2390 ? (f->output_data.x->menubar_widget->core.height
2391 + f->output_data.x->menubar_widget->core.border_width)
2392 : 0);
2393
2394 #if 0 /* Experimentally, we now get the right results
2395 for -geometry -0-0 without this. 24 Aug 96, rms. */
2396 if (FRAME_EXTERNAL_MENU_BAR (f))
2397 {
2398 Dimension ibw = 0;
2399 XtVaGetValues (pane_widget, XtNinternalBorderWidth, &ibw, NULL);
2400 menubar_size += ibw;
2401 }
2402 #endif
2403
2404 f->output_data.x->menubar_height = menubar_size;
2405
2406 #ifndef USE_LUCID
2407 /* Motif seems to need this amount added to the sizes
2408 specified for the shell widget. The Athena/Lucid widgets don't.
2409 Both conclusions reached experimentally. -- rms. */
2410 XtVaGetValues (f->output_data.x->edit_widget, XtNinternalBorderWidth,
2411 &extra_borders, NULL);
2412 extra_borders *= 2;
2413 #endif
2414
2415 /* Convert our geometry parameters into a geometry string
2416 and specify it.
2417 Note that we do not specify here whether the position
2418 is a user-specified or program-specified one.
2419 We pass that information later, in x_wm_set_size_hints. */
2420 {
2421 int left = f->left_pos;
2422 int xneg = window_prompting & XNegative;
2423 int top = f->top_pos;
2424 int yneg = window_prompting & YNegative;
2425 if (xneg)
2426 left = -left;
2427 if (yneg)
2428 top = -top;
2429
2430 if (window_prompting & USPosition)
2431 sprintf (shell_position, "=%dx%d%c%d%c%d",
2432 FRAME_PIXEL_WIDTH (f) + extra_borders,
2433 FRAME_PIXEL_HEIGHT (f) + menubar_size + extra_borders,
2434 (xneg ? '-' : '+'), left,
2435 (yneg ? '-' : '+'), top);
2436 else
2437 {
2438 sprintf (shell_position, "=%dx%d",
2439 FRAME_PIXEL_WIDTH (f) + extra_borders,
2440 FRAME_PIXEL_HEIGHT (f) + menubar_size + extra_borders);
2441
2442 /* Setting x and y when the position is not specified in
2443 the geometry string will set program position in the WM hints.
2444 If Emacs had just one program position, we could set it in
2445 fallback resources, but since each make-frame call can specify
2446 different program positions, this is easier. */
2447 XtSetArg (al[ac], XtNx, left); ac++;
2448 XtSetArg (al[ac], XtNy, top); ac++;
2449 }
2450 }
2451
2452 len = strlen (shell_position) + 1;
2453 /* We don't free this because we don't know whether
2454 it is safe to free it while the frame exists.
2455 It isn't worth the trouble of arranging to free it
2456 when the frame is deleted. */
2457 tem = (char *) xmalloc (len);
2458 strncpy (tem, shell_position, len);
2459 XtSetArg (al[ac], XtNgeometry, tem); ac++;
2460 XtSetValues (shell_widget, al, ac);
2461 }
2462
2463 XtManageChild (pane_widget);
2464 XtRealizeWidget (shell_widget);
2465
2466 FRAME_X_WINDOW (f) = XtWindow (frame_widget);
2467
2468 validate_x_resource_name ();
2469
2470 class_hints.res_name = (char *) SDATA (Vx_resource_name);
2471 class_hints.res_class = (char *) SDATA (Vx_resource_class);
2472 XSetClassHint (FRAME_X_DISPLAY (f), XtWindow (shell_widget), &class_hints);
2473
2474 #ifdef HAVE_X_I18N
2475 FRAME_XIC (f) = NULL;
2476 if (use_xim)
2477 create_frame_xic (f);
2478 #endif
2479
2480 f->output_data.x->wm_hints.input = True;
2481 f->output_data.x->wm_hints.flags |= InputHint;
2482 XSetWMHints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2483 &f->output_data.x->wm_hints);
2484
2485 hack_wm_protocols (f, shell_widget);
2486
2487 #ifdef HACK_EDITRES
2488 XtAddEventHandler (shell_widget, 0, True, _XEditResCheckMessages, 0);
2489 #endif
2490
2491 /* Do a stupid property change to force the server to generate a
2492 PropertyNotify event so that the event_stream server timestamp will
2493 be initialized to something relevant to the time we created the window.
2494 */
2495 XChangeProperty (XtDisplay (frame_widget), XtWindow (frame_widget),
2496 FRAME_X_DISPLAY_INFO (f)->Xatom_wm_protocols,
2497 XA_ATOM, 32, PropModeAppend,
2498 (unsigned char*) NULL, 0);
2499
2500 /* Make all the standard events reach the Emacs frame. */
2501 attributes.event_mask = STANDARD_EVENT_SET;
2502
2503 #ifdef HAVE_X_I18N
2504 if (FRAME_XIC (f))
2505 {
2506 /* XIM server might require some X events. */
2507 unsigned long fevent = NoEventMask;
2508 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2509 attributes.event_mask |= fevent;
2510 }
2511 #endif /* HAVE_X_I18N */
2512
2513 attribute_mask = CWEventMask;
2514 XChangeWindowAttributes (XtDisplay (shell_widget), XtWindow (shell_widget),
2515 attribute_mask, &attributes);
2516
2517 XtMapWidget (frame_widget);
2518
2519 /* x_set_name normally ignores requests to set the name if the
2520 requested name is the same as the current name. This is the one
2521 place where that assumption isn't correct; f->name is set, but
2522 the X server hasn't been told. */
2523 {
2524 Lisp_Object name;
2525 int explicit = f->explicit_name;
2526
2527 f->explicit_name = 0;
2528 name = f->name;
2529 f->name = Qnil;
2530 x_set_name (f, name, explicit);
2531 }
2532
2533 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2534 f->output_data.x->text_cursor);
2535
2536 UNBLOCK_INPUT;
2537
2538 /* This is a no-op, except under Motif. Make sure main areas are
2539 set to something reasonable, in case we get an error later. */
2540 lw_set_main_areas (pane_widget, 0, frame_widget);
2541 }
2542
2543 #else /* not USE_X_TOOLKIT */
2544 #ifdef USE_GTK
2545 void
2546 x_window (f)
2547 FRAME_PTR f;
2548 {
2549 if (! xg_create_frame_widgets (f))
2550 error ("Unable to create window");
2551
2552 #ifdef HAVE_X_I18N
2553 FRAME_XIC (f) = NULL;
2554 if (use_xim)
2555 {
2556 BLOCK_INPUT;
2557 create_frame_xic (f);
2558 if (FRAME_XIC (f))
2559 {
2560 /* XIM server might require some X events. */
2561 unsigned long fevent = NoEventMask;
2562 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2563
2564 if (fevent != NoEventMask)
2565 {
2566 XSetWindowAttributes attributes;
2567 XWindowAttributes wattr;
2568 unsigned long attribute_mask;
2569
2570 XGetWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2571 &wattr);
2572 attributes.event_mask = wattr.your_event_mask | fevent;
2573 attribute_mask = CWEventMask;
2574 XChangeWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2575 attribute_mask, &attributes);
2576 }
2577 }
2578 UNBLOCK_INPUT;
2579 }
2580 #endif
2581 }
2582
2583 #else /*! USE_GTK */
2584 /* Create and set up the X window for frame F. */
2585
2586 void
2587 x_window (f)
2588 struct frame *f;
2589
2590 {
2591 XClassHint class_hints;
2592 XSetWindowAttributes attributes;
2593 unsigned long attribute_mask;
2594
2595 attributes.background_pixel = f->output_data.x->background_pixel;
2596 attributes.border_pixel = f->output_data.x->border_pixel;
2597 attributes.bit_gravity = StaticGravity;
2598 attributes.backing_store = NotUseful;
2599 attributes.save_under = True;
2600 attributes.event_mask = STANDARD_EVENT_SET;
2601 attributes.colormap = FRAME_X_COLORMAP (f);
2602 attribute_mask = (CWBackPixel | CWBorderPixel | CWBitGravity | CWEventMask
2603 | CWColormap);
2604
2605 BLOCK_INPUT;
2606 FRAME_X_WINDOW (f)
2607 = XCreateWindow (FRAME_X_DISPLAY (f),
2608 f->output_data.x->parent_desc,
2609 f->left_pos,
2610 f->top_pos,
2611 FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f),
2612 f->border_width,
2613 CopyFromParent, /* depth */
2614 InputOutput, /* class */
2615 FRAME_X_VISUAL (f),
2616 attribute_mask, &attributes);
2617
2618 #ifdef HAVE_X_I18N
2619 if (use_xim)
2620 {
2621 create_frame_xic (f);
2622 if (FRAME_XIC (f))
2623 {
2624 /* XIM server might require some X events. */
2625 unsigned long fevent = NoEventMask;
2626 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2627 attributes.event_mask |= fevent;
2628 attribute_mask = CWEventMask;
2629 XChangeWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2630 attribute_mask, &attributes);
2631 }
2632 }
2633 #endif /* HAVE_X_I18N */
2634
2635 validate_x_resource_name ();
2636
2637 class_hints.res_name = (char *) SDATA (Vx_resource_name);
2638 class_hints.res_class = (char *) SDATA (Vx_resource_class);
2639 XSetClassHint (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), &class_hints);
2640
2641 /* The menubar is part of the ordinary display;
2642 it does not count in addition to the height of the window. */
2643 f->output_data.x->menubar_height = 0;
2644
2645 /* This indicates that we use the "Passive Input" input model.
2646 Unless we do this, we don't get the Focus{In,Out} events that we
2647 need to draw the cursor correctly. Accursed bureaucrats.
2648 XWhipsAndChains (FRAME_X_DISPLAY (f), IronMaiden, &TheRack); */
2649
2650 f->output_data.x->wm_hints.input = True;
2651 f->output_data.x->wm_hints.flags |= InputHint;
2652 XSetWMHints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2653 &f->output_data.x->wm_hints);
2654 f->output_data.x->wm_hints.icon_pixmap = None;
2655
2656 /* Request "save yourself" and "delete window" commands from wm. */
2657 {
2658 Atom protocols[2];
2659 protocols[0] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_delete_window;
2660 protocols[1] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_save_yourself;
2661 XSetWMProtocols (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), protocols, 2);
2662 }
2663
2664 /* x_set_name normally ignores requests to set the name if the
2665 requested name is the same as the current name. This is the one
2666 place where that assumption isn't correct; f->name is set, but
2667 the X server hasn't been told. */
2668 {
2669 Lisp_Object name;
2670 int explicit = f->explicit_name;
2671
2672 f->explicit_name = 0;
2673 name = f->name;
2674 f->name = Qnil;
2675 x_set_name (f, name, explicit);
2676 }
2677
2678 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2679 f->output_data.x->text_cursor);
2680
2681 UNBLOCK_INPUT;
2682
2683 if (FRAME_X_WINDOW (f) == 0)
2684 error ("Unable to create window");
2685 }
2686
2687 #endif /* not USE_GTK */
2688 #endif /* not USE_X_TOOLKIT */
2689
2690 /* Verify that the icon position args for this window are valid. */
2691
2692 static void
2693 x_icon_verify (f, parms)
2694 struct frame *f;
2695 Lisp_Object parms;
2696 {
2697 Lisp_Object icon_x, icon_y;
2698
2699 /* Set the position of the icon. Note that twm groups all
2700 icons in an icon window. */
2701 icon_x = x_frame_get_and_record_arg (f, parms, Qicon_left, 0, 0, RES_TYPE_NUMBER);
2702 icon_y = x_frame_get_and_record_arg (f, parms, Qicon_top, 0, 0, RES_TYPE_NUMBER);
2703 if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
2704 {
2705 CHECK_NUMBER (icon_x);
2706 CHECK_NUMBER (icon_y);
2707 }
2708 else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
2709 error ("Both left and top icon corners of icon must be specified");
2710 }
2711
2712 /* Handle the icon stuff for this window. Perhaps later we might
2713 want an x_set_icon_position which can be called interactively as
2714 well. */
2715
2716 static void
2717 x_icon (f, parms)
2718 struct frame *f;
2719 Lisp_Object parms;
2720 {
2721 Lisp_Object icon_x, icon_y;
2722 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
2723
2724 /* Set the position of the icon. Note that twm groups all
2725 icons in an icon window. */
2726 icon_x = x_frame_get_and_record_arg (f, parms, Qicon_left, 0, 0, RES_TYPE_NUMBER);
2727 icon_y = x_frame_get_and_record_arg (f, parms, Qicon_top, 0, 0, RES_TYPE_NUMBER);
2728 if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
2729 {
2730 CHECK_NUMBER (icon_x);
2731 CHECK_NUMBER (icon_y);
2732 }
2733 else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
2734 error ("Both left and top icon corners of icon must be specified");
2735
2736 BLOCK_INPUT;
2737
2738 if (! EQ (icon_x, Qunbound))
2739 x_wm_set_icon_position (f, XINT (icon_x), XINT (icon_y));
2740
2741 /* Start up iconic or window? */
2742 x_wm_set_window_state
2743 (f, (EQ (x_get_arg (dpyinfo, parms, Qvisibility, 0, 0, RES_TYPE_SYMBOL),
2744 Qicon)
2745 ? IconicState
2746 : NormalState));
2747
2748 x_text_icon (f, (char *) SDATA ((!NILP (f->icon_name)
2749 ? f->icon_name
2750 : f->name)));
2751
2752 UNBLOCK_INPUT;
2753 }
2754
2755 /* Make the GCs needed for this window, setting the
2756 background, border and mouse colors; also create the
2757 mouse cursor and the gray border tile. */
2758
2759 static char cursor_bits[] =
2760 {
2761 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2762 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2763 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2764 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2765 };
2766
2767 static void
2768 x_make_gc (f)
2769 struct frame *f;
2770 {
2771 XGCValues gc_values;
2772
2773 BLOCK_INPUT;
2774
2775 /* Create the GCs of this frame.
2776 Note that many default values are used. */
2777
2778 /* Normal video */
2779 gc_values.font = FRAME_FONT (f)->fid;
2780 gc_values.foreground = f->output_data.x->foreground_pixel;
2781 gc_values.background = f->output_data.x->background_pixel;
2782 gc_values.line_width = 0; /* Means 1 using fast algorithm. */
2783 f->output_data.x->normal_gc
2784 = XCreateGC (FRAME_X_DISPLAY (f),
2785 FRAME_X_WINDOW (f),
2786 GCLineWidth | GCFont | GCForeground | GCBackground,
2787 &gc_values);
2788
2789 /* Reverse video style. */
2790 gc_values.foreground = f->output_data.x->background_pixel;
2791 gc_values.background = f->output_data.x->foreground_pixel;
2792 f->output_data.x->reverse_gc
2793 = XCreateGC (FRAME_X_DISPLAY (f),
2794 FRAME_X_WINDOW (f),
2795 GCFont | GCForeground | GCBackground | GCLineWidth,
2796 &gc_values);
2797
2798 /* Cursor has cursor-color background, background-color foreground. */
2799 gc_values.foreground = f->output_data.x->background_pixel;
2800 gc_values.background = f->output_data.x->cursor_pixel;
2801 gc_values.fill_style = FillOpaqueStippled;
2802 gc_values.stipple
2803 = XCreateBitmapFromData (FRAME_X_DISPLAY (f),
2804 FRAME_X_DISPLAY_INFO (f)->root_window,
2805 cursor_bits, 16, 16);
2806 f->output_data.x->cursor_gc
2807 = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2808 (GCFont | GCForeground | GCBackground
2809 | GCFillStyle /* | GCStipple */ | GCLineWidth),
2810 &gc_values);
2811
2812 /* Reliefs. */
2813 f->output_data.x->white_relief.gc = 0;
2814 f->output_data.x->black_relief.gc = 0;
2815
2816 /* Create the gray border tile used when the pointer is not in
2817 the frame. Since this depends on the frame's pixel values,
2818 this must be done on a per-frame basis. */
2819 f->output_data.x->border_tile
2820 = (XCreatePixmapFromBitmapData
2821 (FRAME_X_DISPLAY (f), FRAME_X_DISPLAY_INFO (f)->root_window,
2822 gray_bits, gray_width, gray_height,
2823 f->output_data.x->foreground_pixel,
2824 f->output_data.x->background_pixel,
2825 DefaultDepth (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f))));
2826
2827 UNBLOCK_INPUT;
2828 }
2829
2830
2831 /* Free what was was allocated in x_make_gc. */
2832
2833 void
2834 x_free_gcs (f)
2835 struct frame *f;
2836 {
2837 Display *dpy = FRAME_X_DISPLAY (f);
2838
2839 BLOCK_INPUT;
2840
2841 if (f->output_data.x->normal_gc)
2842 {
2843 XFreeGC (dpy, f->output_data.x->normal_gc);
2844 f->output_data.x->normal_gc = 0;
2845 }
2846
2847 if (f->output_data.x->reverse_gc)
2848 {
2849 XFreeGC (dpy, f->output_data.x->reverse_gc);
2850 f->output_data.x->reverse_gc = 0;
2851 }
2852
2853 if (f->output_data.x->cursor_gc)
2854 {
2855 XFreeGC (dpy, f->output_data.x->cursor_gc);
2856 f->output_data.x->cursor_gc = 0;
2857 }
2858
2859 if (f->output_data.x->border_tile)
2860 {
2861 XFreePixmap (dpy, f->output_data.x->border_tile);
2862 f->output_data.x->border_tile = 0;
2863 }
2864
2865 UNBLOCK_INPUT;
2866 }
2867
2868
2869 /* Handler for signals raised during x_create_frame and
2870 x_create_top_frame. FRAME is the frame which is partially
2871 constructed. */
2872
2873 static Lisp_Object
2874 unwind_create_frame (frame)
2875 Lisp_Object frame;
2876 {
2877 struct frame *f = XFRAME (frame);
2878
2879 /* If frame is ``official'', nothing to do. */
2880 if (!CONSP (Vframe_list) || !EQ (XCAR (Vframe_list), frame))
2881 {
2882 #if GLYPH_DEBUG
2883 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
2884 #endif
2885
2886 x_free_frame_resources (f);
2887
2888 #if GLYPH_DEBUG
2889 /* Check that reference counts are indeed correct. */
2890 xassert (dpyinfo->reference_count == dpyinfo_refcount);
2891 xassert (dpyinfo->image_cache->refcount == image_cache_refcount);
2892 #endif
2893 return Qt;
2894 }
2895
2896 return Qnil;
2897 }
2898
2899
2900 DEFUN ("x-create-frame", Fx_create_frame, Sx_create_frame,
2901 1, 1, 0,
2902 doc: /* Make a new X window, which is called a "frame" in Emacs terms.
2903 Returns an Emacs frame object.
2904 ALIST is an alist of frame parameters.
2905 If the parameters specify that the frame should not have a minibuffer,
2906 and do not specify a specific minibuffer window to use,
2907 then `default-minibuffer-frame' must be a frame whose minibuffer can
2908 be shared by the new frame.
2909
2910 This function is an internal primitive--use `make-frame' instead. */)
2911 (parms)
2912 Lisp_Object parms;
2913 {
2914 struct frame *f;
2915 Lisp_Object frame, tem;
2916 Lisp_Object name;
2917 int minibuffer_only = 0;
2918 long window_prompting = 0;
2919 int width, height;
2920 int count = SPECPDL_INDEX ();
2921 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
2922 Lisp_Object display;
2923 struct x_display_info *dpyinfo = NULL;
2924 Lisp_Object parent;
2925 struct kboard *kb;
2926
2927 /* Use this general default value to start with
2928 until we know if this frame has a specified name. */
2929 Vx_resource_name = Vinvocation_name;
2930
2931 display = x_get_arg (dpyinfo, parms, Qdisplay_id, 0, 0, RES_TYPE_NUMBER);
2932 if (EQ (display, Qunbound))
2933 display = x_get_arg (dpyinfo, parms, Qdisplay, 0, 0, RES_TYPE_STRING);
2934 if (EQ (display, Qunbound))
2935 display = Qnil;
2936 dpyinfo = check_x_display_info (display);
2937 #ifdef MULTI_KBOARD
2938 kb = dpyinfo->kboard;
2939 #else
2940 kb = &the_only_kboard;
2941 #endif
2942
2943 name = x_get_arg (dpyinfo, parms, Qname, "name", "Name", RES_TYPE_STRING);
2944 if (!STRINGP (name)
2945 && ! EQ (name, Qunbound)
2946 && ! NILP (name))
2947 error ("Invalid frame name--not a string or nil");
2948
2949 if (STRINGP (name))
2950 Vx_resource_name = name;
2951
2952 /* See if parent window is specified. */
2953 parent = x_get_arg (dpyinfo, parms, Qparent_id, NULL, NULL, RES_TYPE_NUMBER);
2954 if (EQ (parent, Qunbound))
2955 parent = Qnil;
2956 if (! NILP (parent))
2957 CHECK_NUMBER (parent);
2958
2959 /* make_frame_without_minibuffer can run Lisp code and garbage collect. */
2960 /* No need to protect DISPLAY because that's not used after passing
2961 it to make_frame_without_minibuffer. */
2962 frame = Qnil;
2963 GCPRO4 (parms, parent, name, frame);
2964 tem = x_get_arg (dpyinfo, parms, Qminibuffer, "minibuffer", "Minibuffer",
2965 RES_TYPE_SYMBOL);
2966 if (EQ (tem, Qnone) || NILP (tem))
2967 f = make_frame_without_minibuffer (Qnil, kb, display);
2968 else if (EQ (tem, Qonly))
2969 {
2970 f = make_minibuffer_frame ();
2971 minibuffer_only = 1;
2972 }
2973 else if (WINDOWP (tem))
2974 f = make_frame_without_minibuffer (tem, kb, display);
2975 else
2976 f = make_frame (1);
2977
2978 XSETFRAME (frame, f);
2979
2980 /* Note that X Windows does support scroll bars. */
2981 FRAME_CAN_HAVE_SCROLL_BARS (f) = 1;
2982
2983 f->display = dpyinfo->frame_display;
2984 f->display->reference_count++;
2985
2986 f->output_method = output_x_window;
2987 f->output_data.x = (struct x_output *) xmalloc (sizeof (struct x_output));
2988 bzero (f->output_data.x, sizeof (struct x_output));
2989 f->output_data.x->icon_bitmap = -1;
2990 FRAME_FONTSET (f) = -1;
2991 f->output_data.x->scroll_bar_foreground_pixel = -1;
2992 f->output_data.x->scroll_bar_background_pixel = -1;
2993 #ifdef USE_TOOLKIT_SCROLL_BARS
2994 f->output_data.x->scroll_bar_top_shadow_pixel = -1;
2995 f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
2996 #endif /* USE_TOOLKIT_SCROLL_BARS */
2997 record_unwind_protect (unwind_create_frame, frame);
2998
2999 f->icon_name
3000 = x_get_arg (dpyinfo, parms, Qicon_name, "iconName", "Title",
3001 RES_TYPE_STRING);
3002 if (! STRINGP (f->icon_name))
3003 f->icon_name = Qnil;
3004
3005 FRAME_X_DISPLAY_INFO (f) = dpyinfo;
3006 #if GLYPH_DEBUG
3007 image_cache_refcount = FRAME_X_IMAGE_CACHE (f)->refcount;
3008 dpyinfo_refcount = dpyinfo->reference_count;
3009 #endif /* GLYPH_DEBUG */
3010 #ifdef MULTI_KBOARD
3011 FRAME_KBOARD (f) = kb;
3012 #endif
3013
3014 /* These colors will be set anyway later, but it's important
3015 to get the color reference counts right, so initialize them! */
3016 {
3017 Lisp_Object black;
3018 struct gcpro gcpro1;
3019
3020 /* Function x_decode_color can signal an error. Make
3021 sure to initialize color slots so that we won't try
3022 to free colors we haven't allocated. */
3023 f->output_data.x->foreground_pixel = -1;
3024 f->output_data.x->background_pixel = -1;
3025 f->output_data.x->cursor_pixel = -1;
3026 f->output_data.x->cursor_foreground_pixel = -1;
3027 f->output_data.x->border_pixel = -1;
3028 f->output_data.x->mouse_pixel = -1;
3029
3030 black = build_string ("black");
3031 GCPRO1 (black);
3032 f->output_data.x->foreground_pixel
3033 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3034 f->output_data.x->background_pixel
3035 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3036 f->output_data.x->cursor_pixel
3037 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3038 f->output_data.x->cursor_foreground_pixel
3039 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3040 f->output_data.x->border_pixel
3041 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3042 f->output_data.x->mouse_pixel
3043 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3044 UNGCPRO;
3045 }
3046
3047 /* Specify the parent under which to make this X window. */
3048
3049 if (!NILP (parent))
3050 {
3051 f->output_data.x->parent_desc = (Window) XFASTINT (parent);
3052 f->output_data.x->explicit_parent = 1;
3053 }
3054 else
3055 {
3056 f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
3057 f->output_data.x->explicit_parent = 0;
3058 }
3059
3060 /* Set the name; the functions to which we pass f expect the name to
3061 be set. */
3062 if (EQ (name, Qunbound) || NILP (name))
3063 {
3064 f->name = build_string (dpyinfo->x_id_name);
3065 f->explicit_name = 0;
3066 }
3067 else
3068 {
3069 f->name = name;
3070 f->explicit_name = 1;
3071 /* use the frame's title when getting resources for this frame. */
3072 specbind (Qx_resource_name, name);
3073 }
3074
3075 Fmodify_frame_parameters (frame, Fcons (Fcons (Qwindow_system, Qx), Qnil));
3076
3077 /* Extract the window parameters from the supplied values
3078 that are needed to determine window geometry. */
3079 {
3080 Lisp_Object font;
3081
3082 font = x_get_arg (dpyinfo, parms, Qfont, "font", "Font", RES_TYPE_STRING);
3083
3084 BLOCK_INPUT;
3085 /* First, try whatever font the caller has specified. */
3086 if (STRINGP (font))
3087 {
3088 tem = Fquery_fontset (font, Qnil);
3089 if (STRINGP (tem))
3090 font = x_new_fontset (f, SDATA (tem));
3091 else
3092 font = x_new_font (f, SDATA (font));
3093 }
3094
3095 /* Try out a font which we hope has bold and italic variations. */
3096 if (!STRINGP (font))
3097 font = x_new_font (f, "-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1");
3098 if (!STRINGP (font))
3099 font = x_new_font (f, "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
3100 if (! STRINGP (font))
3101 font = x_new_font (f, "-*-*-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
3102 if (! STRINGP (font))
3103 /* This was formerly the first thing tried, but it finds too many fonts
3104 and takes too long. */
3105 font = x_new_font (f, "-*-*-medium-r-*-*-*-*-*-*-c-*-iso8859-1");
3106 /* If those didn't work, look for something which will at least work. */
3107 if (! STRINGP (font))
3108 font = x_new_font (f, "-*-fixed-*-*-*-*-*-140-*-*-c-*-iso8859-1");
3109 UNBLOCK_INPUT;
3110 if (! STRINGP (font))
3111 font = build_string ("fixed");
3112
3113 x_default_parameter (f, parms, Qfont, font,
3114 "font", "Font", RES_TYPE_STRING);
3115 }
3116
3117 #ifdef USE_LUCID
3118 /* Prevent lwlib/xlwmenu.c from crashing because of a bug
3119 whereby it fails to get any font. */
3120 xlwmenu_default_font = FRAME_FONT (f);
3121 #endif
3122
3123 x_default_parameter (f, parms, Qborder_width, make_number (2),
3124 "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
3125
3126 /* This defaults to 1 in order to match xterm. We recognize either
3127 internalBorderWidth or internalBorder (which is what xterm calls
3128 it). */
3129 if (NILP (Fassq (Qinternal_border_width, parms)))
3130 {
3131 Lisp_Object value;
3132
3133 value = x_get_arg (dpyinfo, parms, Qinternal_border_width,
3134 "internalBorder", "internalBorder", RES_TYPE_NUMBER);
3135 if (! EQ (value, Qunbound))
3136 parms = Fcons (Fcons (Qinternal_border_width, value),
3137 parms);
3138 }
3139 x_default_parameter (f, parms, Qinternal_border_width, make_number (1),
3140 "internalBorderWidth", "internalBorderWidth",
3141 RES_TYPE_NUMBER);
3142 x_default_parameter (f, parms, Qvertical_scroll_bars, Qleft,
3143 "verticalScrollBars", "ScrollBars",
3144 RES_TYPE_SYMBOL);
3145
3146 /* Also do the stuff which must be set before the window exists. */
3147 x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
3148 "foreground", "Foreground", RES_TYPE_STRING);
3149 x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
3150 "background", "Background", RES_TYPE_STRING);
3151 x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
3152 "pointerColor", "Foreground", RES_TYPE_STRING);
3153 x_default_parameter (f, parms, Qcursor_color, build_string ("black"),
3154 "cursorColor", "Foreground", RES_TYPE_STRING);
3155 x_default_parameter (f, parms, Qborder_color, build_string ("black"),
3156 "borderColor", "BorderColor", RES_TYPE_STRING);
3157 x_default_parameter (f, parms, Qscreen_gamma, Qnil,
3158 "screenGamma", "ScreenGamma", RES_TYPE_FLOAT);
3159 x_default_parameter (f, parms, Qline_spacing, Qnil,
3160 "lineSpacing", "LineSpacing", RES_TYPE_NUMBER);
3161 x_default_parameter (f, parms, Qleft_fringe, Qnil,
3162 "leftFringe", "LeftFringe", RES_TYPE_NUMBER);
3163 x_default_parameter (f, parms, Qright_fringe, Qnil,
3164 "rightFringe", "RightFringe", RES_TYPE_NUMBER);
3165
3166 x_default_scroll_bar_color_parameter (f, parms, Qscroll_bar_foreground,
3167 "scrollBarForeground",
3168 "ScrollBarForeground", 1);
3169 x_default_scroll_bar_color_parameter (f, parms, Qscroll_bar_background,
3170 "scrollBarBackground",
3171 "ScrollBarBackground", 0);
3172
3173 /* Init faces before x_default_parameter is called for scroll-bar
3174 parameters because that function calls x_set_scroll_bar_width,
3175 which calls change_frame_size, which calls Fset_window_buffer,
3176 which runs hooks, which call Fvertical_motion. At the end, we
3177 end up in init_iterator with a null face cache, which should not
3178 happen. */
3179 init_frame_faces (f);
3180
3181 x_default_parameter (f, parms, Qmenu_bar_lines, make_number (1),
3182 "menuBar", "MenuBar", RES_TYPE_NUMBER);
3183 x_default_parameter (f, parms, Qtool_bar_lines, make_number (1),
3184 "toolBar", "ToolBar", RES_TYPE_NUMBER);
3185 x_default_parameter (f, parms, Qbuffer_predicate, Qnil,
3186 "bufferPredicate", "BufferPredicate",
3187 RES_TYPE_SYMBOL);
3188 x_default_parameter (f, parms, Qtitle, Qnil,
3189 "title", "Title", RES_TYPE_STRING);
3190 x_default_parameter (f, parms, Qwait_for_wm, Qt,
3191 "waitForWM", "WaitForWM", RES_TYPE_BOOLEAN);
3192 x_default_parameter (f, parms, Qfullscreen, Qnil,
3193 "fullscreen", "Fullscreen", RES_TYPE_SYMBOL);
3194
3195 f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
3196
3197 /* Compute the size of the X window. */
3198 window_prompting = x_figure_window_size (f, parms, 1);
3199
3200 tem = x_get_arg (dpyinfo, parms, Qunsplittable, 0, 0, RES_TYPE_BOOLEAN);
3201 f->no_split = minibuffer_only || EQ (tem, Qt);
3202
3203 x_icon_verify (f, parms);
3204
3205 /* Create the X widget or window. */
3206 #ifdef USE_X_TOOLKIT
3207 x_window (f, window_prompting, minibuffer_only);
3208 #else
3209 x_window (f);
3210 #endif
3211
3212 x_icon (f, parms);
3213 x_make_gc (f);
3214
3215 /* Now consider the frame official. */
3216 FRAME_X_DISPLAY_INFO (f)->reference_count++;
3217 Vframe_list = Fcons (frame, Vframe_list);
3218
3219 /* We need to do this after creating the X window, so that the
3220 icon-creation functions can say whose icon they're describing. */
3221 x_default_parameter (f, parms, Qicon_type, Qnil,
3222 "bitmapIcon", "BitmapIcon", RES_TYPE_SYMBOL);
3223
3224 x_default_parameter (f, parms, Qauto_raise, Qnil,
3225 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
3226 x_default_parameter (f, parms, Qauto_lower, Qnil,
3227 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
3228 x_default_parameter (f, parms, Qcursor_type, Qbox,
3229 "cursorType", "CursorType", RES_TYPE_SYMBOL);
3230 x_default_parameter (f, parms, Qscroll_bar_width, Qnil,
3231 "scrollBarWidth", "ScrollBarWidth",
3232 RES_TYPE_NUMBER);
3233
3234 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
3235 Change will not be effected unless different from the current
3236 FRAME_LINES (f). */
3237 width = FRAME_COLS (f);
3238 height = FRAME_LINES (f);
3239
3240 SET_FRAME_COLS (f, 0);
3241 FRAME_LINES (f) = 0;
3242 change_frame_size (f, height, width, 1, 0, 0);
3243
3244 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
3245 /* Create the menu bar. */
3246 if (!minibuffer_only && FRAME_EXTERNAL_MENU_BAR (f))
3247 {
3248 /* If this signals an error, we haven't set size hints for the
3249 frame and we didn't make it visible. */
3250 initialize_frame_menubar (f);
3251
3252 #ifndef USE_GTK
3253 /* This is a no-op, except under Motif where it arranges the
3254 main window for the widgets on it. */
3255 lw_set_main_areas (f->output_data.x->column_widget,
3256 f->output_data.x->menubar_widget,
3257 f->output_data.x->edit_widget);
3258 #endif /* not USE_GTK */
3259 }
3260 #endif /* USE_X_TOOLKIT || USE_GTK */
3261
3262 /* Tell the server what size and position, etc, we want, and how
3263 badly we want them. This should be done after we have the menu
3264 bar so that its size can be taken into account. */
3265 BLOCK_INPUT;
3266 x_wm_set_size_hint (f, window_prompting, 0);
3267 UNBLOCK_INPUT;
3268
3269 /* Make the window appear on the frame and enable display, unless
3270 the caller says not to. However, with explicit parent, Emacs
3271 cannot control visibility, so don't try. */
3272 if (! f->output_data.x->explicit_parent)
3273 {
3274 Lisp_Object visibility;
3275
3276 visibility = x_get_arg (dpyinfo, parms, Qvisibility, 0, 0,
3277 RES_TYPE_SYMBOL);
3278 if (EQ (visibility, Qunbound))
3279 visibility = Qt;
3280
3281 if (EQ (visibility, Qicon))
3282 x_iconify_frame (f);
3283 else if (! NILP (visibility))
3284 x_make_frame_visible (f);
3285 else
3286 /* Must have been Qnil. */
3287 ;
3288 }
3289
3290 /* Set the WM leader property. GTK does this itself, so this is not
3291 needed when using GTK. */
3292 if (dpyinfo->client_leader_window != 0)
3293 {
3294 BLOCK_INPUT;
3295 XChangeProperty (FRAME_X_DISPLAY (f),
3296 FRAME_OUTER_WINDOW (f),
3297 dpyinfo->Xatom_wm_client_leader,
3298 XA_WINDOW, 32, PropModeReplace,
3299 (char *) &dpyinfo->client_leader_window, 1);
3300 UNBLOCK_INPUT;
3301 }
3302
3303 UNGCPRO;
3304
3305 /* Make sure windows on this frame appear in calls to next-window
3306 and similar functions. */
3307 Vwindow_list = Qnil;
3308
3309 return unbind_to (count, frame);
3310 }
3311
3312
3313 /* FRAME is used only to get a handle on the X display. We don't pass the
3314 display info directly because we're called from frame.c, which doesn't
3315 know about that structure. */
3316
3317 Lisp_Object
3318 x_get_focus_frame (frame)
3319 struct frame *frame;
3320 {
3321 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (frame);
3322 Lisp_Object xfocus;
3323 if (! dpyinfo->x_focus_frame)
3324 return Qnil;
3325
3326 XSETFRAME (xfocus, dpyinfo->x_focus_frame);
3327 return xfocus;
3328 }
3329
3330
3331 /* In certain situations, when the window manager follows a
3332 click-to-focus policy, there seems to be no way around calling
3333 XSetInputFocus to give another frame the input focus .
3334
3335 In an ideal world, XSetInputFocus should generally be avoided so
3336 that applications don't interfere with the window manager's focus
3337 policy. But I think it's okay to use when it's clearly done
3338 following a user-command. */
3339
3340 DEFUN ("x-focus-frame", Fx_focus_frame, Sx_focus_frame, 1, 1, 0,
3341 doc: /* Set the input focus to FRAME.
3342 FRAME nil means use the selected frame. */)
3343 (frame)
3344 Lisp_Object frame;
3345 {
3346 struct frame *f = check_x_frame (frame);
3347 Display *dpy = FRAME_X_DISPLAY (f);
3348 int count;
3349
3350 BLOCK_INPUT;
3351 count = x_catch_errors (dpy);
3352 XSetInputFocus (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3353 RevertToParent, CurrentTime);
3354 x_uncatch_errors (dpy, count);
3355 UNBLOCK_INPUT;
3356
3357 return Qnil;
3358 }
3359
3360 \f
3361 DEFUN ("xw-color-defined-p", Fxw_color_defined_p, Sxw_color_defined_p, 1, 2, 0,
3362 doc: /* Internal function called by `color-defined-p', which see. */)
3363 (color, frame)
3364 Lisp_Object color, frame;
3365 {
3366 XColor foo;
3367 FRAME_PTR f = check_x_frame (frame);
3368
3369 CHECK_STRING (color);
3370
3371 if (x_defined_color (f, SDATA (color), &foo, 0))
3372 return Qt;
3373 else
3374 return Qnil;
3375 }
3376
3377 DEFUN ("xw-color-values", Fxw_color_values, Sxw_color_values, 1, 2, 0,
3378 doc: /* Internal function called by `color-values', which see. */)
3379 (color, frame)
3380 Lisp_Object color, frame;
3381 {
3382 XColor foo;
3383 FRAME_PTR f = check_x_frame (frame);
3384
3385 CHECK_STRING (color);
3386
3387 if (x_defined_color (f, SDATA (color), &foo, 0))
3388 {
3389 Lisp_Object rgb[3];
3390
3391 rgb[0] = make_number (foo.red);
3392 rgb[1] = make_number (foo.green);
3393 rgb[2] = make_number (foo.blue);
3394 return Flist (3, rgb);
3395 }
3396 else
3397 return Qnil;
3398 }
3399
3400 DEFUN ("xw-display-color-p", Fxw_display_color_p, Sxw_display_color_p, 0, 1, 0,
3401 doc: /* Internal function called by `display-color-p', which see. */)
3402 (display)
3403 Lisp_Object display;
3404 {
3405 struct x_display_info *dpyinfo = check_x_display_info (display);
3406
3407 if (dpyinfo->n_planes <= 2)
3408 return Qnil;
3409
3410 switch (dpyinfo->visual->class)
3411 {
3412 case StaticColor:
3413 case PseudoColor:
3414 case TrueColor:
3415 case DirectColor:
3416 return Qt;
3417
3418 default:
3419 return Qnil;
3420 }
3421 }
3422
3423 DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p, Sx_display_grayscale_p,
3424 0, 1, 0,
3425 doc: /* Return t if the X display supports shades of gray.
3426 Note that color displays do support shades of gray.
3427 The optional argument DISPLAY specifies which display to ask about.
3428 DISPLAY should be either a frame or a display name (a string).
3429 If omitted or nil, that stands for the selected frame's display. */)
3430 (display)
3431 Lisp_Object display;
3432 {
3433 struct x_display_info *dpyinfo = check_x_display_info (display);
3434
3435 if (dpyinfo->n_planes <= 1)
3436 return Qnil;
3437
3438 switch (dpyinfo->visual->class)
3439 {
3440 case StaticColor:
3441 case PseudoColor:
3442 case TrueColor:
3443 case DirectColor:
3444 case StaticGray:
3445 case GrayScale:
3446 return Qt;
3447
3448 default:
3449 return Qnil;
3450 }
3451 }
3452
3453 DEFUN ("x-display-pixel-width", Fx_display_pixel_width, Sx_display_pixel_width,
3454 0, 1, 0,
3455 doc: /* Returns the width in pixels of the X display DISPLAY.
3456 The optional argument DISPLAY specifies which display to ask about.
3457 DISPLAY should be either a frame or a display name (a string).
3458 If omitted or nil, that stands for the selected frame's display. */)
3459 (display)
3460 Lisp_Object display;
3461 {
3462 struct x_display_info *dpyinfo = check_x_display_info (display);
3463
3464 return make_number (dpyinfo->width);
3465 }
3466
3467 DEFUN ("x-display-pixel-height", Fx_display_pixel_height,
3468 Sx_display_pixel_height, 0, 1, 0,
3469 doc: /* Returns the height in pixels of the X display DISPLAY.
3470 The optional argument DISPLAY specifies which display to ask about.
3471 DISPLAY should be either a frame or a display name (a string).
3472 If omitted or nil, that stands for the selected frame's display. */)
3473 (display)
3474 Lisp_Object display;
3475 {
3476 struct x_display_info *dpyinfo = check_x_display_info (display);
3477
3478 return make_number (dpyinfo->height);
3479 }
3480
3481 DEFUN ("x-display-planes", Fx_display_planes, Sx_display_planes,
3482 0, 1, 0,
3483 doc: /* Returns the number of bitplanes of the X display DISPLAY.
3484 The optional argument DISPLAY specifies which display to ask about.
3485 DISPLAY should be either a frame or a display name (a string).
3486 If omitted or nil, that stands for the selected frame's display. */)
3487 (display)
3488 Lisp_Object display;
3489 {
3490 struct x_display_info *dpyinfo = check_x_display_info (display);
3491
3492 return make_number (dpyinfo->n_planes);
3493 }
3494
3495 DEFUN ("x-display-color-cells", Fx_display_color_cells, Sx_display_color_cells,
3496 0, 1, 0,
3497 doc: /* Returns the number of color cells of the X display DISPLAY.
3498 The optional argument DISPLAY specifies which display to ask about.
3499 DISPLAY should be either a frame or a display name (a string).
3500 If omitted or nil, that stands for the selected frame's display. */)
3501 (display)
3502 Lisp_Object display;
3503 {
3504 struct x_display_info *dpyinfo = check_x_display_info (display);
3505
3506 int nr_planes = DisplayPlanes (dpyinfo->display,
3507 XScreenNumberOfScreen (dpyinfo->screen));
3508
3509 /* Truncate nr_planes to 24 to avoid integer overflow.
3510 Some displays says 32, but only 24 bits are actually significant.
3511 There are only very few and rare video cards that have more than
3512 24 significant bits. Also 24 bits is more than 16 million colors,
3513 it "should be enough for everyone". */
3514 if (nr_planes > 24) nr_planes = 24;
3515
3516 return make_number (1 << nr_planes);
3517 }
3518
3519 DEFUN ("x-server-max-request-size", Fx_server_max_request_size,
3520 Sx_server_max_request_size,
3521 0, 1, 0,
3522 doc: /* Returns the maximum request size of the X server of display DISPLAY.
3523 The optional argument DISPLAY specifies which display to ask about.
3524 DISPLAY should be either a frame or a display name (a string).
3525 If omitted or nil, that stands for the selected frame's display. */)
3526 (display)
3527 Lisp_Object display;
3528 {
3529 struct x_display_info *dpyinfo = check_x_display_info (display);
3530
3531 return make_number (MAXREQUEST (dpyinfo->display));
3532 }
3533
3534 DEFUN ("x-server-vendor", Fx_server_vendor, Sx_server_vendor, 0, 1, 0,
3535 doc: /* Returns the "vendor ID" string of the X server of display DISPLAY.
3536 \(Labelling every distributor as a "vendor" embodies the false assumption
3537 that operating systems cannot be developed and distributed noncommercially.)
3538 The optional argument DISPLAY specifies which display to ask about.
3539 DISPLAY should be either a frame or a display name (a string).
3540 If omitted or nil, that stands for the selected frame's display. */)
3541 (display)
3542 Lisp_Object display;
3543 {
3544 struct x_display_info *dpyinfo = check_x_display_info (display);
3545 char *vendor = ServerVendor (dpyinfo->display);
3546
3547 if (! vendor) vendor = "";
3548 return build_string (vendor);
3549 }
3550
3551 DEFUN ("x-server-version", Fx_server_version, Sx_server_version, 0, 1, 0,
3552 doc: /* Returns the version numbers of the X server of display DISPLAY.
3553 The value is a list of three integers: the major and minor
3554 version numbers of the X Protocol in use, and the distributor-specific release
3555 number. See also the function `x-server-vendor'.
3556
3557 The optional argument DISPLAY specifies which display to ask about.
3558 DISPLAY should be either a frame or a display name (a string).
3559 If omitted or nil, that stands for the selected frame's display. */)
3560 (display)
3561 Lisp_Object display;
3562 {
3563 struct x_display_info *dpyinfo = check_x_display_info (display);
3564 Display *dpy = dpyinfo->display;
3565
3566 return Fcons (make_number (ProtocolVersion (dpy)),
3567 Fcons (make_number (ProtocolRevision (dpy)),
3568 Fcons (make_number (VendorRelease (dpy)), Qnil)));
3569 }
3570
3571 DEFUN ("x-display-screens", Fx_display_screens, Sx_display_screens, 0, 1, 0,
3572 doc: /* Return the number of screens on the X server of display DISPLAY.
3573 The optional argument DISPLAY specifies which display to ask about.
3574 DISPLAY should be either a frame or a display name (a string).
3575 If omitted or nil, that stands for the selected frame's display. */)
3576 (display)
3577 Lisp_Object display;
3578 {
3579 struct x_display_info *dpyinfo = check_x_display_info (display);
3580
3581 return make_number (ScreenCount (dpyinfo->display));
3582 }
3583
3584 DEFUN ("x-display-mm-height", Fx_display_mm_height, Sx_display_mm_height, 0, 1, 0,
3585 doc: /* Return the height in millimeters of the X display DISPLAY.
3586 The optional argument DISPLAY specifies which display to ask about.
3587 DISPLAY should be either a frame or a display name (a string).
3588 If omitted or nil, that stands for the selected frame's display. */)
3589 (display)
3590 Lisp_Object display;
3591 {
3592 struct x_display_info *dpyinfo = check_x_display_info (display);
3593
3594 return make_number (HeightMMOfScreen (dpyinfo->screen));
3595 }
3596
3597 DEFUN ("x-display-mm-width", Fx_display_mm_width, Sx_display_mm_width, 0, 1, 0,
3598 doc: /* Return the width in millimeters of the X display DISPLAY.
3599 The optional argument DISPLAY specifies which display to ask about.
3600 DISPLAY should be either a frame or a display name (a string).
3601 If omitted or nil, that stands for the selected frame's display. */)
3602 (display)
3603 Lisp_Object display;
3604 {
3605 struct x_display_info *dpyinfo = check_x_display_info (display);
3606
3607 return make_number (WidthMMOfScreen (dpyinfo->screen));
3608 }
3609
3610 DEFUN ("x-display-backing-store", Fx_display_backing_store,
3611 Sx_display_backing_store, 0, 1, 0,
3612 doc: /* Returns an indication of whether X display DISPLAY does backing store.
3613 The value may be `always', `when-mapped', or `not-useful'.
3614 The optional argument DISPLAY specifies which display to ask about.
3615 DISPLAY should be either a frame or a display name (a string).
3616 If omitted or nil, that stands for the selected frame's display. */)
3617 (display)
3618 Lisp_Object display;
3619 {
3620 struct x_display_info *dpyinfo = check_x_display_info (display);
3621 Lisp_Object result;
3622
3623 switch (DoesBackingStore (dpyinfo->screen))
3624 {
3625 case Always:
3626 result = intern ("always");
3627 break;
3628
3629 case WhenMapped:
3630 result = intern ("when-mapped");
3631 break;
3632
3633 case NotUseful:
3634 result = intern ("not-useful");
3635 break;
3636
3637 default:
3638 error ("Strange value for BackingStore parameter of screen");
3639 result = Qnil;
3640 }
3641
3642 return result;
3643 }
3644
3645 DEFUN ("x-display-visual-class", Fx_display_visual_class,
3646 Sx_display_visual_class, 0, 1, 0,
3647 doc: /* Return the visual class of the X display DISPLAY.
3648 The value is one of the symbols `static-gray', `gray-scale',
3649 `static-color', `pseudo-color', `true-color', or `direct-color'.
3650
3651 The optional argument DISPLAY specifies which display to ask about.
3652 DISPLAY should be either a frame or a display name (a string).
3653 If omitted or nil, that stands for the selected frame's display. */)
3654 (display)
3655 Lisp_Object display;
3656 {
3657 struct x_display_info *dpyinfo = check_x_display_info (display);
3658 Lisp_Object result;
3659
3660 switch (dpyinfo->visual->class)
3661 {
3662 case StaticGray:
3663 result = intern ("static-gray");
3664 break;
3665 case GrayScale:
3666 result = intern ("gray-scale");
3667 break;
3668 case StaticColor:
3669 result = intern ("static-color");
3670 break;
3671 case PseudoColor:
3672 result = intern ("pseudo-color");
3673 break;
3674 case TrueColor:
3675 result = intern ("true-color");
3676 break;
3677 case DirectColor:
3678 result = intern ("direct-color");
3679 break;
3680 default:
3681 error ("Display has an unknown visual class");
3682 result = Qnil;
3683 }
3684
3685 return result;
3686 }
3687
3688 DEFUN ("x-display-save-under", Fx_display_save_under,
3689 Sx_display_save_under, 0, 1, 0,
3690 doc: /* Returns t if the X display DISPLAY supports the save-under feature.
3691 The optional argument DISPLAY specifies which display to ask about.
3692 DISPLAY should be either a frame or a display name (a string).
3693 If omitted or nil, that stands for the selected frame's display. */)
3694 (display)
3695 Lisp_Object display;
3696 {
3697 struct x_display_info *dpyinfo = check_x_display_info (display);
3698
3699 if (DoesSaveUnders (dpyinfo->screen) == True)
3700 return Qt;
3701 else
3702 return Qnil;
3703 }
3704 \f
3705 int
3706 x_pixel_width (f)
3707 register struct frame *f;
3708 {
3709 return FRAME_PIXEL_WIDTH (f);
3710 }
3711
3712 int
3713 x_pixel_height (f)
3714 register struct frame *f;
3715 {
3716 return FRAME_PIXEL_HEIGHT (f);
3717 }
3718
3719 int
3720 x_char_width (f)
3721 register struct frame *f;
3722 {
3723 return FRAME_COLUMN_WIDTH (f);
3724 }
3725
3726 int
3727 x_char_height (f)
3728 register struct frame *f;
3729 {
3730 return FRAME_LINE_HEIGHT (f);
3731 }
3732
3733 int
3734 x_screen_planes (f)
3735 register struct frame *f;
3736 {
3737 return FRAME_X_DISPLAY_INFO (f)->n_planes;
3738 }
3739
3740
3741 \f
3742 /************************************************************************
3743 X Displays
3744 ************************************************************************/
3745
3746 \f
3747 /* Mapping visual names to visuals. */
3748
3749 static struct visual_class
3750 {
3751 char *name;
3752 int class;
3753 }
3754 visual_classes[] =
3755 {
3756 {"StaticGray", StaticGray},
3757 {"GrayScale", GrayScale},
3758 {"StaticColor", StaticColor},
3759 {"PseudoColor", PseudoColor},
3760 {"TrueColor", TrueColor},
3761 {"DirectColor", DirectColor},
3762 {NULL, 0}
3763 };
3764
3765
3766 #ifndef HAVE_XSCREENNUMBEROFSCREEN
3767
3768 /* Value is the screen number of screen SCR. This is a substitute for
3769 the X function with the same name when that doesn't exist. */
3770
3771 int
3772 XScreenNumberOfScreen (scr)
3773 register Screen *scr;
3774 {
3775 Display *dpy = scr->display;
3776 int i;
3777
3778 for (i = 0; i < dpy->nscreens; ++i)
3779 if (scr == dpy->screens + i)
3780 break;
3781
3782 return i;
3783 }
3784
3785 #endif /* not HAVE_XSCREENNUMBEROFSCREEN */
3786
3787
3788 /* Select the visual that should be used on display DPYINFO. Set
3789 members of DPYINFO appropriately. Called from x_term_init. */
3790
3791 void
3792 select_visual (dpyinfo)
3793 struct x_display_info *dpyinfo;
3794 {
3795 Display *dpy = dpyinfo->display;
3796 Screen *screen = dpyinfo->screen;
3797 Lisp_Object value;
3798
3799 /* See if a visual is specified. */
3800 value = display_x_get_resource (dpyinfo,
3801 build_string ("visualClass"),
3802 build_string ("VisualClass"),
3803 Qnil, Qnil);
3804 if (STRINGP (value))
3805 {
3806 /* VALUE should be of the form CLASS-DEPTH, where CLASS is one
3807 of `PseudoColor', `TrueColor' etc. and DEPTH is the color
3808 depth, a decimal number. NAME is compared with case ignored. */
3809 char *s = (char *) alloca (SBYTES (value) + 1);
3810 char *dash;
3811 int i, class = -1;
3812 XVisualInfo vinfo;
3813
3814 strcpy (s, SDATA (value));
3815 dash = index (s, '-');
3816 if (dash)
3817 {
3818 dpyinfo->n_planes = atoi (dash + 1);
3819 *dash = '\0';
3820 }
3821 else
3822 /* We won't find a matching visual with depth 0, so that
3823 an error will be printed below. */
3824 dpyinfo->n_planes = 0;
3825
3826 /* Determine the visual class. */
3827 for (i = 0; visual_classes[i].name; ++i)
3828 if (xstricmp (s, visual_classes[i].name) == 0)
3829 {
3830 class = visual_classes[i].class;
3831 break;
3832 }
3833
3834 /* Look up a matching visual for the specified class. */
3835 if (class == -1
3836 || !XMatchVisualInfo (dpy, XScreenNumberOfScreen (screen),
3837 dpyinfo->n_planes, class, &vinfo))
3838 fatal ("Invalid visual specification `%s'", SDATA (value));
3839
3840 dpyinfo->visual = vinfo.visual;
3841 }
3842 else
3843 {
3844 int n_visuals;
3845 XVisualInfo *vinfo, vinfo_template;
3846
3847 dpyinfo->visual = DefaultVisualOfScreen (screen);
3848
3849 #ifdef HAVE_X11R4
3850 vinfo_template.visualid = XVisualIDFromVisual (dpyinfo->visual);
3851 #else
3852 vinfo_template.visualid = dpyinfo->visual->visualid;
3853 #endif
3854 vinfo_template.screen = XScreenNumberOfScreen (screen);
3855 vinfo = XGetVisualInfo (dpy, VisualIDMask | VisualScreenMask,
3856 &vinfo_template, &n_visuals);
3857 if (n_visuals != 1)
3858 fatal ("Can't get proper X visual info");
3859
3860 dpyinfo->n_planes = vinfo->depth;
3861 XFree ((char *) vinfo);
3862 }
3863 }
3864
3865
3866 /* Return the X display structure for the display named NAME.
3867 Open a new connection if necessary. */
3868
3869 struct x_display_info *
3870 x_display_info_for_name (name)
3871 Lisp_Object name;
3872 {
3873 Lisp_Object names;
3874 struct x_display_info *dpyinfo;
3875
3876 CHECK_STRING (name);
3877
3878 #if 0
3879 if (! EQ (Vinitial_window_system, intern ("x")))
3880 error ("Not using X Windows"); /* That doesn't stop us anymore. */
3881 #endif
3882
3883 for (dpyinfo = x_display_list, names = x_display_name_list;
3884 dpyinfo;
3885 dpyinfo = dpyinfo->next, names = XCDR (names))
3886 {
3887 Lisp_Object tem;
3888 tem = Fstring_equal (XCAR (XCAR (names)), name);
3889 if (!NILP (tem))
3890 return dpyinfo;
3891 }
3892
3893 /* Use this general default value to start with. */
3894 Vx_resource_name = Vinvocation_name;
3895
3896 validate_x_resource_name ();
3897
3898 dpyinfo = x_term_init (name, (char *)0,
3899 (char *) SDATA (Vx_resource_name));
3900
3901 if (dpyinfo == 0)
3902 error ("Cannot connect to X server %s", SDATA (name));
3903
3904 x_in_use = 1;
3905 XSETFASTINT (Vwindow_system_version, 11);
3906
3907 return dpyinfo;
3908 }
3909
3910
3911 DEFUN ("x-open-connection", Fx_open_connection, Sx_open_connection,
3912 1, 3, 0,
3913 doc: /* Open a connection to an X server.
3914 DISPLAY is the name of the display to connect to.
3915 Optional second arg XRM-STRING is a string of resources in xrdb format.
3916 If the optional third arg MUST-SUCCEED is non-nil,
3917 terminate Emacs if we can't open the connection. */)
3918 (display, xrm_string, must_succeed)
3919 Lisp_Object display, xrm_string, must_succeed;
3920 {
3921 unsigned char *xrm_option;
3922 struct x_display_info *dpyinfo;
3923
3924 CHECK_STRING (display);
3925 if (! NILP (xrm_string))
3926 CHECK_STRING (xrm_string);
3927
3928 #if 0
3929 if (! EQ (Vinitial_window_system, intern ("x")))
3930 error ("Not using X Windows"); /* That doesn't stop us anymore. */
3931 #endif
3932
3933 if (! NILP (xrm_string))
3934 xrm_option = (unsigned char *) SDATA (xrm_string);
3935 else
3936 xrm_option = (unsigned char *) 0;
3937
3938 validate_x_resource_name ();
3939
3940 /* This is what opens the connection and sets x_current_display.
3941 This also initializes many symbols, such as those used for input. */
3942 dpyinfo = x_term_init (display, xrm_option,
3943 (char *) SDATA (Vx_resource_name));
3944
3945 if (dpyinfo == 0)
3946 {
3947 if (!NILP (must_succeed))
3948 fatal ("Cannot connect to X server %s.\n\
3949 Check the DISPLAY environment variable or use `-d'.\n\
3950 Also use the `xauth' program to verify that you have the proper\n\
3951 authorization information needed to connect the X server.\n\
3952 An insecure way to solve the problem may be to use `xhost'.\n",
3953 SDATA (display));
3954 else
3955 error ("Cannot connect to X server %s", SDATA (display));
3956 }
3957
3958 x_in_use = 1;
3959
3960 XSETFASTINT (Vwindow_system_version, 11);
3961 return Qnil;
3962 }
3963
3964 DEFUN ("x-close-connection", Fx_close_connection,
3965 Sx_close_connection, 1, 1, 0,
3966 doc: /* Close the connection to DISPLAY's X server.
3967 For DISPLAY, specify either a frame or a display name (a string).
3968 If DISPLAY is nil, that stands for the selected frame's display. */)
3969 (display)
3970 Lisp_Object display;
3971 {
3972 struct x_display_info *dpyinfo = check_x_display_info (display);
3973 int i;
3974
3975 if (dpyinfo->reference_count > 0)
3976 error ("Display still has frames on it");
3977
3978 BLOCK_INPUT;
3979 /* Free the fonts in the font table. */
3980 for (i = 0; i < dpyinfo->n_fonts; i++)
3981 if (dpyinfo->font_table[i].name)
3982 {
3983 XFreeFont (dpyinfo->display, dpyinfo->font_table[i].font);
3984 }
3985
3986 x_destroy_all_bitmaps (dpyinfo);
3987 XSetCloseDownMode (dpyinfo->display, DestroyAll);
3988
3989 #ifdef USE_X_TOOLKIT
3990 XtCloseDisplay (dpyinfo->display);
3991 #else
3992 XCloseDisplay (dpyinfo->display);
3993 #endif
3994
3995 x_delete_display (dpyinfo);
3996 UNBLOCK_INPUT;
3997
3998 return Qnil;
3999 }
4000
4001 DEFUN ("x-display-list", Fx_display_list, Sx_display_list, 0, 0, 0,
4002 doc: /* Return the list of display names that Emacs has connections to. */)
4003 ()
4004 {
4005 Lisp_Object tail, result;
4006
4007 result = Qnil;
4008 for (tail = x_display_name_list; ! NILP (tail); tail = XCDR (tail))
4009 result = Fcons (XCAR (XCAR (tail)), result);
4010
4011 return result;
4012 }
4013
4014 DEFUN ("x-synchronize", Fx_synchronize, Sx_synchronize, 1, 2, 0,
4015 doc: /* If ON is non-nil, report X errors as soon as the erring request is made.
4016 If ON is nil, allow buffering of requests.
4017 Turning on synchronization prohibits the Xlib routines from buffering
4018 requests and seriously degrades performance, but makes debugging much
4019 easier.
4020 The optional second argument DISPLAY specifies which display to act on.
4021 DISPLAY should be either a frame or a display name (a string).
4022 If DISPLAY is omitted or nil, that stands for the selected frame's display. */)
4023 (on, display)
4024 Lisp_Object display, on;
4025 {
4026 struct x_display_info *dpyinfo = check_x_display_info (display);
4027
4028 XSynchronize (dpyinfo->display, !EQ (on, Qnil));
4029
4030 return Qnil;
4031 }
4032
4033 /* Wait for responses to all X commands issued so far for frame F. */
4034
4035 void
4036 x_sync (f)
4037 FRAME_PTR f;
4038 {
4039 BLOCK_INPUT;
4040 XSync (FRAME_X_DISPLAY (f), False);
4041 UNBLOCK_INPUT;
4042 }
4043
4044 \f
4045 /***********************************************************************
4046 Window properties
4047 ***********************************************************************/
4048
4049 DEFUN ("x-change-window-property", Fx_change_window_property,
4050 Sx_change_window_property, 2, 6, 0,
4051 doc: /* Change window property PROP to VALUE on the X window of FRAME.
4052 PROP must be a string.
4053 VALUE may be a string or a list of conses, numbers and/or strings.
4054 If an element in the list is a string, it is converted to
4055 an Atom and the value of the Atom is used. If an element is a cons,
4056 it is converted to a 32 bit number where the car is the 16 top bits and the
4057 cdr is the lower 16 bits.
4058 FRAME nil or omitted means use the selected frame.
4059 If TYPE is given and non-nil, it is the name of the type of VALUE.
4060 If TYPE is not given or nil, the type is STRING.
4061 FORMAT gives the size in bits of each element if VALUE is a list.
4062 It must be one of 8, 16 or 32.
4063 If VALUE is a string or FORMAT is nil or not given, FORMAT defaults to 8.
4064 If OUTER_P is non-nil, the property is changed for the outer X window of
4065 FRAME. Default is to change on the edit X window.
4066
4067 Value is VALUE. */)
4068 (prop, value, frame, type, format, outer_p)
4069 Lisp_Object prop, value, frame, type, format, outer_p;
4070 {
4071 struct frame *f = check_x_frame (frame);
4072 Atom prop_atom;
4073 Atom target_type = XA_STRING;
4074 int element_format = 8;
4075 unsigned char *data;
4076 int nelements;
4077 Window w;
4078
4079 CHECK_STRING (prop);
4080
4081 if (! NILP (format))
4082 {
4083 CHECK_NUMBER (format);
4084 element_format = XFASTINT (format);
4085
4086 if (element_format != 8 && element_format != 16
4087 && element_format != 32)
4088 error ("FORMAT must be one of 8, 16 or 32");
4089 }
4090
4091 if (CONSP (value))
4092 {
4093 nelements = x_check_property_data (value);
4094 if (nelements == -1)
4095 error ("Bad data in VALUE, must be number, string or cons");
4096
4097 if (element_format == 8)
4098 data = (unsigned char *) xmalloc (nelements);
4099 else if (element_format == 16)
4100 data = (unsigned char *) xmalloc (nelements*2);
4101 else /* format == 32 */
4102 /* The man page for XChangeProperty:
4103 "If the specified format is 32, the property data must be a
4104 long array."
4105 This applies even if long is more than 64 bits. The X library
4106 converts to 32 bits before sending to the X server. */
4107 data = (unsigned char *) xmalloc (nelements * sizeof(long));
4108
4109 x_fill_property_data (FRAME_X_DISPLAY (f), value, data, element_format);
4110 }
4111 else
4112 {
4113 CHECK_STRING (value);
4114 data = SDATA (value);
4115 nelements = SCHARS (value);
4116 }
4117
4118 BLOCK_INPUT;
4119 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SDATA (prop), False);
4120 if (! NILP (type))
4121 {
4122 CHECK_STRING (type);
4123 target_type = XInternAtom (FRAME_X_DISPLAY (f), SDATA (type), False);
4124 }
4125
4126 if (! NILP (outer_p)) w = FRAME_OUTER_WINDOW (f);
4127 else w = FRAME_X_WINDOW (f);
4128
4129 XChangeProperty (FRAME_X_DISPLAY (f), w,
4130 prop_atom, target_type, element_format, PropModeReplace,
4131 data, nelements);
4132
4133 if (CONSP (value)) xfree (data);
4134
4135 /* Make sure the property is set when we return. */
4136 XFlush (FRAME_X_DISPLAY (f));
4137 UNBLOCK_INPUT;
4138
4139 return value;
4140 }
4141
4142
4143 DEFUN ("x-delete-window-property", Fx_delete_window_property,
4144 Sx_delete_window_property, 1, 2, 0,
4145 doc: /* Remove window property PROP from X window of FRAME.
4146 FRAME nil or omitted means use the selected frame. Value is PROP. */)
4147 (prop, frame)
4148 Lisp_Object prop, frame;
4149 {
4150 struct frame *f = check_x_frame (frame);
4151 Atom prop_atom;
4152
4153 CHECK_STRING (prop);
4154 BLOCK_INPUT;
4155 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SDATA (prop), False);
4156 XDeleteProperty (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), prop_atom);
4157
4158 /* Make sure the property is removed when we return. */
4159 XFlush (FRAME_X_DISPLAY (f));
4160 UNBLOCK_INPUT;
4161
4162 return prop;
4163 }
4164
4165
4166 DEFUN ("x-window-property", Fx_window_property, Sx_window_property,
4167 1, 6, 0,
4168 doc: /* Value is the value of window property PROP on FRAME.
4169 If FRAME is nil or omitted, use the selected frame.
4170 If TYPE is nil or omitted, get the property as a string. Otherwise TYPE
4171 is the name of the Atom that denotes the type expected.
4172 If SOURCE is non-nil, get the property on that window instead of from
4173 FRAME. The number 0 denotes the root window.
4174 If DELETE_P is non-nil, delete the property after retreiving it.
4175 If VECTOR_RET_P is non-nil, don't return a string but a vector of values.
4176
4177 Value is nil if FRAME hasn't a property with name PROP or if PROP has
4178 no value of TYPE. */)
4179 (prop, frame, type, source, delete_p, vector_ret_p)
4180 Lisp_Object prop, frame, type, source, delete_p, vector_ret_p;
4181 {
4182 struct frame *f = check_x_frame (frame);
4183 Atom prop_atom;
4184 int rc;
4185 Lisp_Object prop_value = Qnil;
4186 unsigned char *tmp_data = NULL;
4187 Atom actual_type;
4188 Atom target_type = XA_STRING;
4189 int actual_format;
4190 unsigned long actual_size, bytes_remaining;
4191 Window target_window = FRAME_X_WINDOW (f);
4192 struct gcpro gcpro1;
4193
4194 GCPRO1 (prop_value);
4195 CHECK_STRING (prop);
4196
4197 if (! NILP (source))
4198 {
4199 if (NUMBERP (source))
4200 {
4201 if (FLOATP (source))
4202 target_window = (Window) XFLOAT (source);
4203 else
4204 target_window = XFASTINT (source);
4205
4206 if (target_window == 0)
4207 target_window = FRAME_X_DISPLAY_INFO (f)->root_window;
4208 }
4209 else if (CONSP (source))
4210 target_window = cons_to_long (source);
4211 }
4212
4213 BLOCK_INPUT;
4214 if (STRINGP (type))
4215 {
4216 if (strcmp ("AnyPropertyType", SDATA (type)) == 0)
4217 target_type = AnyPropertyType;
4218 else
4219 target_type = XInternAtom (FRAME_X_DISPLAY (f), SDATA (type), False);
4220 }
4221
4222 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SDATA (prop), False);
4223 rc = XGetWindowProperty (FRAME_X_DISPLAY (f), target_window,
4224 prop_atom, 0, 0, False, target_type,
4225 &actual_type, &actual_format, &actual_size,
4226 &bytes_remaining, &tmp_data);
4227 if (rc == Success)
4228 {
4229 int size = bytes_remaining;
4230
4231 XFree (tmp_data);
4232 tmp_data = NULL;
4233
4234 rc = XGetWindowProperty (FRAME_X_DISPLAY (f), target_window,
4235 prop_atom, 0, bytes_remaining,
4236 ! NILP (delete_p), target_type,
4237 &actual_type, &actual_format,
4238 &actual_size, &bytes_remaining,
4239 &tmp_data);
4240 if (rc == Success && tmp_data)
4241 {
4242 /* The man page for XGetWindowProperty says:
4243 "If the returned format is 32, the returned data is represented
4244 as a long array and should be cast to that type to obtain the
4245 elements."
4246 This applies even if long is more than 32 bits, the X library
4247 converts from 32 bit elements received from the X server to long
4248 and passes the long array to us. Thus, for that case bcopy can not
4249 be used. We convert to a 32 bit type here, because so much code
4250 assume on that.
4251
4252 The bytes and offsets passed to XGetWindowProperty refers to the
4253 property and those are indeed in 32 bit quantities if format is
4254 32. */
4255
4256 if (actual_format == 32 && actual_format < BITS_PER_LONG)
4257 {
4258 unsigned long i;
4259 int *idata = (int *) tmp_data;
4260 long *ldata = (long *) tmp_data;
4261
4262 for (i = 0; i < actual_size; ++i)
4263 idata[i] = (int) ldata[i];
4264 }
4265
4266 if (NILP (vector_ret_p))
4267 prop_value = make_string (tmp_data, size);
4268 else
4269 prop_value = x_property_data_to_lisp (f,
4270 tmp_data,
4271 actual_type,
4272 actual_format,
4273 actual_size);
4274 }
4275
4276 if (tmp_data) XFree (tmp_data);
4277 }
4278
4279 UNBLOCK_INPUT;
4280 UNGCPRO;
4281 return prop_value;
4282 }
4283
4284
4285 \f
4286 /***********************************************************************
4287 Busy cursor
4288 ***********************************************************************/
4289
4290 /* If non-null, an asynchronous timer that, when it expires, displays
4291 an hourglass cursor on all frames. */
4292
4293 static struct atimer *hourglass_atimer;
4294
4295 /* Non-zero means an hourglass cursor is currently shown. */
4296
4297 static int hourglass_shown_p;
4298
4299 /* Number of seconds to wait before displaying an hourglass cursor. */
4300
4301 static Lisp_Object Vhourglass_delay;
4302
4303 /* Default number of seconds to wait before displaying an hourglass
4304 cursor. */
4305
4306 #define DEFAULT_HOURGLASS_DELAY 1
4307
4308 /* Function prototypes. */
4309
4310 static void show_hourglass P_ ((struct atimer *));
4311 static void hide_hourglass P_ ((void));
4312
4313
4314 /* Cancel a currently active hourglass timer, and start a new one. */
4315
4316 void
4317 start_hourglass ()
4318 {
4319 EMACS_TIME delay;
4320 int secs, usecs = 0;
4321
4322 cancel_hourglass ();
4323
4324 if (INTEGERP (Vhourglass_delay)
4325 && XINT (Vhourglass_delay) > 0)
4326 secs = XFASTINT (Vhourglass_delay);
4327 else if (FLOATP (Vhourglass_delay)
4328 && XFLOAT_DATA (Vhourglass_delay) > 0)
4329 {
4330 Lisp_Object tem;
4331 tem = Ftruncate (Vhourglass_delay, Qnil);
4332 secs = XFASTINT (tem);
4333 usecs = (XFLOAT_DATA (Vhourglass_delay) - secs) * 1000000;
4334 }
4335 else
4336 secs = DEFAULT_HOURGLASS_DELAY;
4337
4338 EMACS_SET_SECS_USECS (delay, secs, usecs);
4339 hourglass_atimer = start_atimer (ATIMER_RELATIVE, delay,
4340 show_hourglass, NULL);
4341 }
4342
4343
4344 /* Cancel the hourglass cursor timer if active, hide a busy cursor if
4345 shown. */
4346
4347 void
4348 cancel_hourglass ()
4349 {
4350 if (hourglass_atimer)
4351 {
4352 cancel_atimer (hourglass_atimer);
4353 hourglass_atimer = NULL;
4354 }
4355
4356 if (hourglass_shown_p)
4357 hide_hourglass ();
4358 }
4359
4360
4361 /* Timer function of hourglass_atimer. TIMER is equal to
4362 hourglass_atimer.
4363
4364 Display an hourglass pointer on all frames by mapping the frames'
4365 hourglass_window. Set the hourglass_p flag in the frames'
4366 output_data.x structure to indicate that an hourglass cursor is
4367 shown on the frames. */
4368
4369 static void
4370 show_hourglass (timer)
4371 struct atimer *timer;
4372 {
4373 /* The timer implementation will cancel this timer automatically
4374 after this function has run. Set hourglass_atimer to null
4375 so that we know the timer doesn't have to be canceled. */
4376 hourglass_atimer = NULL;
4377
4378 if (!hourglass_shown_p)
4379 {
4380 Lisp_Object rest, frame;
4381
4382 BLOCK_INPUT;
4383
4384 FOR_EACH_FRAME (rest, frame)
4385 {
4386 struct frame *f = XFRAME (frame);
4387
4388 if (FRAME_LIVE_P (f) && FRAME_X_P (f) && FRAME_X_DISPLAY (f))
4389 {
4390 Display *dpy = FRAME_X_DISPLAY (f);
4391
4392 #ifdef USE_X_TOOLKIT
4393 if (f->output_data.x->widget)
4394 #else
4395 if (FRAME_OUTER_WINDOW (f))
4396 #endif
4397 {
4398 f->output_data.x->hourglass_p = 1;
4399
4400 if (!f->output_data.x->hourglass_window)
4401 {
4402 unsigned long mask = CWCursor;
4403 XSetWindowAttributes attrs;
4404 #ifdef USE_GTK
4405 Window parent = FRAME_X_WINDOW (f);
4406 #else
4407 Window parent = FRAME_OUTER_WINDOW (f);
4408 #endif
4409 attrs.cursor = f->output_data.x->hourglass_cursor;
4410
4411 f->output_data.x->hourglass_window
4412 = XCreateWindow (dpy, parent,
4413 0, 0, 32000, 32000, 0, 0,
4414 InputOnly,
4415 CopyFromParent,
4416 mask, &attrs);
4417 }
4418
4419 XMapRaised (dpy, f->output_data.x->hourglass_window);
4420 XFlush (dpy);
4421 }
4422 }
4423 }
4424
4425 hourglass_shown_p = 1;
4426 UNBLOCK_INPUT;
4427 }
4428 }
4429
4430
4431 /* Hide the hourglass pointer on all frames, if it is currently
4432 shown. */
4433
4434 static void
4435 hide_hourglass ()
4436 {
4437 if (hourglass_shown_p)
4438 {
4439 Lisp_Object rest, frame;
4440
4441 BLOCK_INPUT;
4442 FOR_EACH_FRAME (rest, frame)
4443 {
4444 struct frame *f = XFRAME (frame);
4445
4446 if (FRAME_X_P (f)
4447 /* Watch out for newly created frames. */
4448 && f->output_data.x->hourglass_window)
4449 {
4450 XUnmapWindow (FRAME_X_DISPLAY (f),
4451 f->output_data.x->hourglass_window);
4452 /* Sync here because XTread_socket looks at the
4453 hourglass_p flag that is reset to zero below. */
4454 XSync (FRAME_X_DISPLAY (f), False);
4455 f->output_data.x->hourglass_p = 0;
4456 }
4457 }
4458
4459 hourglass_shown_p = 0;
4460 UNBLOCK_INPUT;
4461 }
4462 }
4463
4464
4465 \f
4466 /***********************************************************************
4467 Tool tips
4468 ***********************************************************************/
4469
4470 static Lisp_Object x_create_tip_frame P_ ((struct x_display_info *,
4471 Lisp_Object, Lisp_Object));
4472 static void compute_tip_xy P_ ((struct frame *, Lisp_Object, Lisp_Object,
4473 Lisp_Object, int, int, int *, int *));
4474
4475 /* The frame of a currently visible tooltip. */
4476
4477 Lisp_Object tip_frame;
4478
4479 /* If non-nil, a timer started that hides the last tooltip when it
4480 fires. */
4481
4482 Lisp_Object tip_timer;
4483 Window tip_window;
4484
4485 /* If non-nil, a vector of 3 elements containing the last args
4486 with which x-show-tip was called. See there. */
4487
4488 Lisp_Object last_show_tip_args;
4489
4490 /* Maximum size for tooltips; a cons (COLUMNS . ROWS). */
4491
4492 Lisp_Object Vx_max_tooltip_size;
4493
4494
4495 static Lisp_Object
4496 unwind_create_tip_frame (frame)
4497 Lisp_Object frame;
4498 {
4499 Lisp_Object deleted;
4500
4501 deleted = unwind_create_frame (frame);
4502 if (EQ (deleted, Qt))
4503 {
4504 tip_window = None;
4505 tip_frame = Qnil;
4506 }
4507
4508 return deleted;
4509 }
4510
4511
4512 /* Create a frame for a tooltip on the display described by DPYINFO.
4513 PARMS is a list of frame parameters. TEXT is the string to
4514 display in the tip frame. Value is the frame.
4515
4516 Note that functions called here, esp. x_default_parameter can
4517 signal errors, for instance when a specified color name is
4518 undefined. We have to make sure that we're in a consistent state
4519 when this happens. */
4520
4521 static Lisp_Object
4522 x_create_tip_frame (dpyinfo, parms, text)
4523 struct x_display_info *dpyinfo;
4524 Lisp_Object parms, text;
4525 {
4526 struct frame *f;
4527 Lisp_Object frame, tem;
4528 Lisp_Object name;
4529 long window_prompting = 0;
4530 int width, height;
4531 int count = SPECPDL_INDEX ();
4532 struct gcpro gcpro1, gcpro2, gcpro3;
4533 struct kboard *kb;
4534 int face_change_count_before = face_change_count;
4535 Lisp_Object buffer;
4536 struct buffer *old_buffer;
4537
4538 check_x ();
4539
4540 /* Use this general default value to start with until we know if
4541 this frame has a specified name. */
4542 Vx_resource_name = Vinvocation_name;
4543
4544 #ifdef MULTI_KBOARD
4545 kb = dpyinfo->kboard;
4546 #else
4547 kb = &the_only_kboard;
4548 #endif
4549
4550 /* Get the name of the frame to use for resource lookup. */
4551 name = x_get_arg (dpyinfo, parms, Qname, "name", "Name", RES_TYPE_STRING);
4552 if (!STRINGP (name)
4553 && !EQ (name, Qunbound)
4554 && !NILP (name))
4555 error ("Invalid frame name--not a string or nil");
4556
4557 Vx_resource_name = name;
4558
4559 frame = Qnil;
4560 GCPRO3 (parms, name, frame);
4561 f = make_frame (1);
4562 XSETFRAME (frame, f);
4563
4564 buffer = Fget_buffer_create (build_string (" *tip*"));
4565 Fset_window_buffer (FRAME_ROOT_WINDOW (f), buffer, Qnil);
4566 old_buffer = current_buffer;
4567 set_buffer_internal_1 (XBUFFER (buffer));
4568 current_buffer->truncate_lines = Qnil;
4569 specbind (Qinhibit_read_only, Qt);
4570 specbind (Qinhibit_modification_hooks, Qt);
4571 Ferase_buffer ();
4572 Finsert (1, &text);
4573 set_buffer_internal_1 (old_buffer);
4574
4575 FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
4576 record_unwind_protect (unwind_create_tip_frame, frame);
4577
4578 f->display = dpyinfo->frame_display;
4579 f->display->reference_count++;
4580
4581 /* By setting the output method, we're essentially saying that
4582 the frame is live, as per FRAME_LIVE_P. If we get a signal
4583 from this point on, x_destroy_window might screw up reference
4584 counts etc. */
4585 f->output_method = output_x_window;
4586 f->output_data.x = (struct x_output *) xmalloc (sizeof (struct x_output));
4587 bzero (f->output_data.x, sizeof (struct x_output));
4588 f->output_data.x->icon_bitmap = -1;
4589 FRAME_FONTSET (f) = -1;
4590 f->output_data.x->scroll_bar_foreground_pixel = -1;
4591 f->output_data.x->scroll_bar_background_pixel = -1;
4592 #ifdef USE_TOOLKIT_SCROLL_BARS
4593 f->output_data.x->scroll_bar_top_shadow_pixel = -1;
4594 f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
4595 #endif /* USE_TOOLKIT_SCROLL_BARS */
4596 f->icon_name = Qnil;
4597 FRAME_X_DISPLAY_INFO (f) = dpyinfo;
4598 #if GLYPH_DEBUG
4599 image_cache_refcount = FRAME_X_IMAGE_CACHE (f)->refcount;
4600 dpyinfo_refcount = dpyinfo->reference_count;
4601 #endif /* GLYPH_DEBUG */
4602 #ifdef MULTI_KBOARD
4603 FRAME_KBOARD (f) = kb;
4604 #endif
4605 f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
4606 f->output_data.x->explicit_parent = 0;
4607
4608 /* These colors will be set anyway later, but it's important
4609 to get the color reference counts right, so initialize them! */
4610 {
4611 Lisp_Object black;
4612 struct gcpro gcpro1;
4613
4614 /* Function x_decode_color can signal an error. Make
4615 sure to initialize color slots so that we won't try
4616 to free colors we haven't allocated. */
4617 f->output_data.x->foreground_pixel = -1;
4618 f->output_data.x->background_pixel = -1;
4619 f->output_data.x->cursor_pixel = -1;
4620 f->output_data.x->cursor_foreground_pixel = -1;
4621 f->output_data.x->border_pixel = -1;
4622 f->output_data.x->mouse_pixel = -1;
4623
4624 black = build_string ("black");
4625 GCPRO1 (black);
4626 f->output_data.x->foreground_pixel
4627 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4628 f->output_data.x->background_pixel
4629 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4630 f->output_data.x->cursor_pixel
4631 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4632 f->output_data.x->cursor_foreground_pixel
4633 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4634 f->output_data.x->border_pixel
4635 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4636 f->output_data.x->mouse_pixel
4637 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4638 UNGCPRO;
4639 }
4640
4641 /* Set the name; the functions to which we pass f expect the name to
4642 be set. */
4643 if (EQ (name, Qunbound) || NILP (name))
4644 {
4645 f->name = build_string (dpyinfo->x_id_name);
4646 f->explicit_name = 0;
4647 }
4648 else
4649 {
4650 f->name = name;
4651 f->explicit_name = 1;
4652 /* use the frame's title when getting resources for this frame. */
4653 specbind (Qx_resource_name, name);
4654 }
4655
4656 /* Extract the window parameters from the supplied values that are
4657 needed to determine window geometry. */
4658 {
4659 Lisp_Object font;
4660
4661 font = x_get_arg (dpyinfo, parms, Qfont, "font", "Font", RES_TYPE_STRING);
4662
4663 BLOCK_INPUT;
4664 /* First, try whatever font the caller has specified. */
4665 if (STRINGP (font))
4666 {
4667 tem = Fquery_fontset (font, Qnil);
4668 if (STRINGP (tem))
4669 font = x_new_fontset (f, SDATA (tem));
4670 else
4671 font = x_new_font (f, SDATA (font));
4672 }
4673
4674 /* Try out a font which we hope has bold and italic variations. */
4675 if (!STRINGP (font))
4676 font = x_new_font (f, "-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1");
4677 if (!STRINGP (font))
4678 font = x_new_font (f, "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
4679 if (! STRINGP (font))
4680 font = x_new_font (f, "-*-*-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
4681 if (! STRINGP (font))
4682 /* This was formerly the first thing tried, but it finds too many fonts
4683 and takes too long. */
4684 font = x_new_font (f, "-*-*-medium-r-*-*-*-*-*-*-c-*-iso8859-1");
4685 /* If those didn't work, look for something which will at least work. */
4686 if (! STRINGP (font))
4687 font = x_new_font (f, "-*-fixed-*-*-*-*-*-140-*-*-c-*-iso8859-1");
4688 UNBLOCK_INPUT;
4689 if (! STRINGP (font))
4690 font = build_string ("fixed");
4691
4692 x_default_parameter (f, parms, Qfont, font,
4693 "font", "Font", RES_TYPE_STRING);
4694 }
4695
4696 x_default_parameter (f, parms, Qborder_width, make_number (2),
4697 "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
4698
4699 /* This defaults to 1 in order to match xterm. We recognize either
4700 internalBorderWidth or internalBorder (which is what xterm calls
4701 it). */
4702 if (NILP (Fassq (Qinternal_border_width, parms)))
4703 {
4704 Lisp_Object value;
4705
4706 value = x_get_arg (dpyinfo, parms, Qinternal_border_width,
4707 "internalBorder", "internalBorder", RES_TYPE_NUMBER);
4708 if (! EQ (value, Qunbound))
4709 parms = Fcons (Fcons (Qinternal_border_width, value),
4710 parms);
4711 }
4712
4713 x_default_parameter (f, parms, Qinternal_border_width, make_number (1),
4714 "internalBorderWidth", "internalBorderWidth",
4715 RES_TYPE_NUMBER);
4716
4717 /* Also do the stuff which must be set before the window exists. */
4718 x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
4719 "foreground", "Foreground", RES_TYPE_STRING);
4720 x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
4721 "background", "Background", RES_TYPE_STRING);
4722 x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
4723 "pointerColor", "Foreground", RES_TYPE_STRING);
4724 x_default_parameter (f, parms, Qcursor_color, build_string ("black"),
4725 "cursorColor", "Foreground", RES_TYPE_STRING);
4726 x_default_parameter (f, parms, Qborder_color, build_string ("black"),
4727 "borderColor", "BorderColor", RES_TYPE_STRING);
4728
4729 /* Init faces before x_default_parameter is called for scroll-bar
4730 parameters because that function calls x_set_scroll_bar_width,
4731 which calls change_frame_size, which calls Fset_window_buffer,
4732 which runs hooks, which call Fvertical_motion. At the end, we
4733 end up in init_iterator with a null face cache, which should not
4734 happen. */
4735 init_frame_faces (f);
4736
4737 f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
4738
4739 window_prompting = x_figure_window_size (f, parms, 0);
4740
4741 {
4742 XSetWindowAttributes attrs;
4743 unsigned long mask;
4744
4745 BLOCK_INPUT;
4746 mask = CWBackPixel | CWOverrideRedirect | CWEventMask;
4747 if (DoesSaveUnders (dpyinfo->screen))
4748 mask |= CWSaveUnder;
4749
4750 /* Window managers look at the override-redirect flag to determine
4751 whether or net to give windows a decoration (Xlib spec, chapter
4752 3.2.8). */
4753 attrs.override_redirect = True;
4754 attrs.save_under = True;
4755 attrs.background_pixel = FRAME_BACKGROUND_PIXEL (f);
4756 /* Arrange for getting MapNotify and UnmapNotify events. */
4757 attrs.event_mask = StructureNotifyMask;
4758 tip_window
4759 = FRAME_X_WINDOW (f)
4760 = XCreateWindow (FRAME_X_DISPLAY (f),
4761 FRAME_X_DISPLAY_INFO (f)->root_window,
4762 /* x, y, width, height */
4763 0, 0, 1, 1,
4764 /* Border. */
4765 1,
4766 CopyFromParent, InputOutput, CopyFromParent,
4767 mask, &attrs);
4768 UNBLOCK_INPUT;
4769 }
4770
4771 x_make_gc (f);
4772
4773 x_default_parameter (f, parms, Qauto_raise, Qnil,
4774 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
4775 x_default_parameter (f, parms, Qauto_lower, Qnil,
4776 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
4777 x_default_parameter (f, parms, Qcursor_type, Qbox,
4778 "cursorType", "CursorType", RES_TYPE_SYMBOL);
4779
4780 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
4781 Change will not be effected unless different from the current
4782 FRAME_LINES (f). */
4783 width = FRAME_COLS (f);
4784 height = FRAME_LINES (f);
4785 SET_FRAME_COLS (f, 0);
4786 FRAME_LINES (f) = 0;
4787 change_frame_size (f, height, width, 1, 0, 0);
4788
4789 /* Add `tooltip' frame parameter's default value. */
4790 if (NILP (Fframe_parameter (frame, intern ("tooltip"))))
4791 Fmodify_frame_parameters (frame, Fcons (Fcons (intern ("tooltip"), Qt),
4792 Qnil));
4793
4794 /* Set up faces after all frame parameters are known. This call
4795 also merges in face attributes specified for new frames.
4796
4797 Frame parameters may be changed if .Xdefaults contains
4798 specifications for the default font. For example, if there is an
4799 `Emacs.default.attributeBackground: pink', the `background-color'
4800 attribute of the frame get's set, which let's the internal border
4801 of the tooltip frame appear in pink. Prevent this. */
4802 {
4803 Lisp_Object bg = Fframe_parameter (frame, Qbackground_color);
4804
4805 /* Set tip_frame here, so that */
4806 tip_frame = frame;
4807 call1 (Qface_set_after_frame_default, frame);
4808
4809 if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
4810 Fmodify_frame_parameters (frame, Fcons (Fcons (Qbackground_color, bg),
4811 Qnil));
4812 }
4813
4814 Fmodify_frame_parameters (frame, Fcons (Fcons (Qwindow_system, Qx), Qnil));
4815
4816 f->no_split = 1;
4817
4818 UNGCPRO;
4819
4820 /* It is now ok to make the frame official even if we get an error
4821 below. And the frame needs to be on Vframe_list or making it
4822 visible won't work. */
4823 Vframe_list = Fcons (frame, Vframe_list);
4824
4825 /* Now that the frame is official, it counts as a reference to
4826 its display. */
4827 FRAME_X_DISPLAY_INFO (f)->reference_count++;
4828
4829 /* Setting attributes of faces of the tooltip frame from resources
4830 and similar will increment face_change_count, which leads to the
4831 clearing of all current matrices. Since this isn't necessary
4832 here, avoid it by resetting face_change_count to the value it
4833 had before we created the tip frame. */
4834 face_change_count = face_change_count_before;
4835
4836 /* Discard the unwind_protect. */
4837 return unbind_to (count, frame);
4838 }
4839
4840
4841 /* Compute where to display tip frame F. PARMS is the list of frame
4842 parameters for F. DX and DY are specified offsets from the current
4843 location of the mouse. WIDTH and HEIGHT are the width and height
4844 of the tooltip. Return coordinates relative to the root window of
4845 the display in *ROOT_X, and *ROOT_Y. */
4846
4847 static void
4848 compute_tip_xy (f, parms, dx, dy, width, height, root_x, root_y)
4849 struct frame *f;
4850 Lisp_Object parms, dx, dy;
4851 int width, height;
4852 int *root_x, *root_y;
4853 {
4854 Lisp_Object left, top;
4855 int win_x, win_y;
4856 Window root, child;
4857 unsigned pmask;
4858
4859 /* User-specified position? */
4860 left = Fcdr (Fassq (Qleft, parms));
4861 top = Fcdr (Fassq (Qtop, parms));
4862
4863 /* Move the tooltip window where the mouse pointer is. Resize and
4864 show it. */
4865 if (!INTEGERP (left) || !INTEGERP (top))
4866 {
4867 BLOCK_INPUT;
4868 XQueryPointer (FRAME_X_DISPLAY (f), FRAME_X_DISPLAY_INFO (f)->root_window,
4869 &root, &child, root_x, root_y, &win_x, &win_y, &pmask);
4870 UNBLOCK_INPUT;
4871 }
4872
4873 if (INTEGERP (top))
4874 *root_y = XINT (top);
4875 else if (*root_y + XINT (dy) - height < 0)
4876 *root_y -= XINT (dy);
4877 else
4878 {
4879 *root_y -= height;
4880 *root_y += XINT (dy);
4881 }
4882
4883 if (INTEGERP (left))
4884 *root_x = XINT (left);
4885 else if (*root_x + XINT (dx) + width <= FRAME_X_DISPLAY_INFO (f)->width)
4886 /* It fits to the right of the pointer. */
4887 *root_x += XINT (dx);
4888 else if (width + XINT (dx) <= *root_x)
4889 /* It fits to the left of the pointer. */
4890 *root_x -= width + XINT (dx);
4891 else
4892 /* Put it left-justified on the screen--it ought to fit that way. */
4893 *root_x = 0;
4894 }
4895
4896
4897 DEFUN ("x-show-tip", Fx_show_tip, Sx_show_tip, 1, 6, 0,
4898 doc: /* Show STRING in a "tooltip" window on frame FRAME.
4899 A tooltip window is a small X window displaying a string.
4900
4901 FRAME nil or omitted means use the selected frame.
4902
4903 PARMS is an optional list of frame parameters which can be used to
4904 change the tooltip's appearance.
4905
4906 Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
4907 means use the default timeout of 5 seconds.
4908
4909 If the list of frame parameters PARAMS contains a `left' parameters,
4910 the tooltip is displayed at that x-position. Otherwise it is
4911 displayed at the mouse position, with offset DX added (default is 5 if
4912 DX isn't specified). Likewise for the y-position; if a `top' frame
4913 parameter is specified, it determines the y-position of the tooltip
4914 window, otherwise it is displayed at the mouse position, with offset
4915 DY added (default is -10).
4916
4917 A tooltip's maximum size is specified by `x-max-tooltip-size'.
4918 Text larger than the specified size is clipped. */)
4919 (string, frame, parms, timeout, dx, dy)
4920 Lisp_Object string, frame, parms, timeout, dx, dy;
4921 {
4922 struct frame *f;
4923 struct window *w;
4924 int root_x, root_y;
4925 struct buffer *old_buffer;
4926 struct text_pos pos;
4927 int i, width, height;
4928 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
4929 int old_windows_or_buffers_changed = windows_or_buffers_changed;
4930 int count = SPECPDL_INDEX ();
4931
4932 specbind (Qinhibit_redisplay, Qt);
4933
4934 GCPRO4 (string, parms, frame, timeout);
4935
4936 CHECK_STRING (string);
4937 f = check_x_frame (frame);
4938 if (NILP (timeout))
4939 timeout = make_number (5);
4940 else
4941 CHECK_NATNUM (timeout);
4942
4943 if (NILP (dx))
4944 dx = make_number (5);
4945 else
4946 CHECK_NUMBER (dx);
4947
4948 if (NILP (dy))
4949 dy = make_number (-10);
4950 else
4951 CHECK_NUMBER (dy);
4952
4953 if (NILP (last_show_tip_args))
4954 last_show_tip_args = Fmake_vector (make_number (3), Qnil);
4955
4956 if (!NILP (tip_frame))
4957 {
4958 Lisp_Object last_string = AREF (last_show_tip_args, 0);
4959 Lisp_Object last_frame = AREF (last_show_tip_args, 1);
4960 Lisp_Object last_parms = AREF (last_show_tip_args, 2);
4961
4962 if (EQ (frame, last_frame)
4963 && !NILP (Fequal (last_string, string))
4964 && !NILP (Fequal (last_parms, parms)))
4965 {
4966 struct frame *f = XFRAME (tip_frame);
4967
4968 /* Only DX and DY have changed. */
4969 if (!NILP (tip_timer))
4970 {
4971 Lisp_Object timer = tip_timer;
4972 tip_timer = Qnil;
4973 call1 (Qcancel_timer, timer);
4974 }
4975
4976 BLOCK_INPUT;
4977 compute_tip_xy (f, parms, dx, dy, FRAME_PIXEL_WIDTH (f),
4978 FRAME_PIXEL_HEIGHT (f), &root_x, &root_y);
4979 XMoveWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
4980 root_x, root_y);
4981 UNBLOCK_INPUT;
4982 goto start_timer;
4983 }
4984 }
4985
4986 /* Hide a previous tip, if any. */
4987 Fx_hide_tip ();
4988
4989 ASET (last_show_tip_args, 0, string);
4990 ASET (last_show_tip_args, 1, frame);
4991 ASET (last_show_tip_args, 2, parms);
4992
4993 /* Add default values to frame parameters. */
4994 if (NILP (Fassq (Qname, parms)))
4995 parms = Fcons (Fcons (Qname, build_string ("tooltip")), parms);
4996 if (NILP (Fassq (Qinternal_border_width, parms)))
4997 parms = Fcons (Fcons (Qinternal_border_width, make_number (3)), parms);
4998 if (NILP (Fassq (Qborder_width, parms)))
4999 parms = Fcons (Fcons (Qborder_width, make_number (1)), parms);
5000 if (NILP (Fassq (Qborder_color, parms)))
5001 parms = Fcons (Fcons (Qborder_color, build_string ("lightyellow")), parms);
5002 if (NILP (Fassq (Qbackground_color, parms)))
5003 parms = Fcons (Fcons (Qbackground_color, build_string ("lightyellow")),
5004 parms);
5005
5006 /* Create a frame for the tooltip, and record it in the global
5007 variable tip_frame. */
5008 frame = x_create_tip_frame (FRAME_X_DISPLAY_INFO (f), parms, string);
5009 f = XFRAME (frame);
5010
5011 /* Set up the frame's root window. */
5012 w = XWINDOW (FRAME_ROOT_WINDOW (f));
5013 w->left_col = w->top_line = make_number (0);
5014
5015 if (CONSP (Vx_max_tooltip_size)
5016 && INTEGERP (XCAR (Vx_max_tooltip_size))
5017 && XINT (XCAR (Vx_max_tooltip_size)) > 0
5018 && INTEGERP (XCDR (Vx_max_tooltip_size))
5019 && XINT (XCDR (Vx_max_tooltip_size)) > 0)
5020 {
5021 w->total_cols = XCAR (Vx_max_tooltip_size);
5022 w->total_lines = XCDR (Vx_max_tooltip_size);
5023 }
5024 else
5025 {
5026 w->total_cols = make_number (80);
5027 w->total_lines = make_number (40);
5028 }
5029
5030 FRAME_TOTAL_COLS (f) = XINT (w->total_cols);
5031 adjust_glyphs (f);
5032 w->pseudo_window_p = 1;
5033
5034 /* Display the tooltip text in a temporary buffer. */
5035 old_buffer = current_buffer;
5036 set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f))->buffer));
5037 current_buffer->truncate_lines = Qnil;
5038 clear_glyph_matrix (w->desired_matrix);
5039 clear_glyph_matrix (w->current_matrix);
5040 SET_TEXT_POS (pos, BEGV, BEGV_BYTE);
5041 try_window (FRAME_ROOT_WINDOW (f), pos);
5042
5043 /* Compute width and height of the tooltip. */
5044 width = height = 0;
5045 for (i = 0; i < w->desired_matrix->nrows; ++i)
5046 {
5047 struct glyph_row *row = &w->desired_matrix->rows[i];
5048 struct glyph *last;
5049 int row_width;
5050
5051 /* Stop at the first empty row at the end. */
5052 if (!row->enabled_p || !row->displays_text_p)
5053 break;
5054
5055 /* Let the row go over the full width of the frame. */
5056 row->full_width_p = 1;
5057
5058 /* There's a glyph at the end of rows that is used to place
5059 the cursor there. Don't include the width of this glyph. */
5060 if (row->used[TEXT_AREA])
5061 {
5062 last = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
5063 row_width = row->pixel_width - last->pixel_width;
5064 }
5065 else
5066 row_width = row->pixel_width;
5067
5068 height += row->height;
5069 width = max (width, row_width);
5070 }
5071
5072 /* Add the frame's internal border to the width and height the X
5073 window should have. */
5074 height += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
5075 width += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
5076
5077 /* Move the tooltip window where the mouse pointer is. Resize and
5078 show it. */
5079 compute_tip_xy (f, parms, dx, dy, width, height, &root_x, &root_y);
5080
5081 BLOCK_INPUT;
5082 XMoveResizeWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
5083 root_x, root_y, width, height);
5084 XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
5085 UNBLOCK_INPUT;
5086
5087 /* Draw into the window. */
5088 w->must_be_updated_p = 1;
5089 update_single_window (w, 1);
5090
5091 /* Restore original current buffer. */
5092 set_buffer_internal_1 (old_buffer);
5093 windows_or_buffers_changed = old_windows_or_buffers_changed;
5094
5095 start_timer:
5096 /* Let the tip disappear after timeout seconds. */
5097 tip_timer = call3 (intern ("run-at-time"), timeout, Qnil,
5098 intern ("x-hide-tip"));
5099
5100 UNGCPRO;
5101 return unbind_to (count, Qnil);
5102 }
5103
5104
5105 DEFUN ("x-hide-tip", Fx_hide_tip, Sx_hide_tip, 0, 0, 0,
5106 doc: /* Hide the current tooltip window, if there is any.
5107 Value is t if tooltip was open, nil otherwise. */)
5108 ()
5109 {
5110 int count;
5111 Lisp_Object deleted, frame, timer;
5112 struct gcpro gcpro1, gcpro2;
5113
5114 /* Return quickly if nothing to do. */
5115 if (NILP (tip_timer) && NILP (tip_frame))
5116 return Qnil;
5117
5118 frame = tip_frame;
5119 timer = tip_timer;
5120 GCPRO2 (frame, timer);
5121 tip_frame = tip_timer = deleted = Qnil;
5122
5123 count = SPECPDL_INDEX ();
5124 specbind (Qinhibit_redisplay, Qt);
5125 specbind (Qinhibit_quit, Qt);
5126
5127 if (!NILP (timer))
5128 call1 (Qcancel_timer, timer);
5129
5130 if (FRAMEP (frame))
5131 {
5132 Fdelete_frame (frame, Qnil);
5133 deleted = Qt;
5134
5135 #ifdef USE_LUCID
5136 /* Bloodcurdling hack alert: The Lucid menu bar widget's
5137 redisplay procedure is not called when a tip frame over menu
5138 items is unmapped. Redisplay the menu manually... */
5139 {
5140 struct frame *f = SELECTED_FRAME ();
5141 Widget w = f->output_data.x->menubar_widget;
5142 extern void xlwmenu_redisplay P_ ((Widget));
5143
5144 if (!DoesSaveUnders (FRAME_X_DISPLAY_INFO (f)->screen)
5145 && w != NULL)
5146 {
5147 BLOCK_INPUT;
5148 xlwmenu_redisplay (w);
5149 UNBLOCK_INPUT;
5150 }
5151 }
5152 #endif /* USE_LUCID */
5153 }
5154
5155 UNGCPRO;
5156 return unbind_to (count, deleted);
5157 }
5158
5159
5160 \f
5161 /***********************************************************************
5162 File selection dialog
5163 ***********************************************************************/
5164
5165 #ifdef USE_MOTIF
5166
5167 /* Callback for "OK" and "Cancel" on file selection dialog. */
5168
5169 static void
5170 file_dialog_cb (widget, client_data, call_data)
5171 Widget widget;
5172 XtPointer call_data, client_data;
5173 {
5174 int *result = (int *) client_data;
5175 XmAnyCallbackStruct *cb = (XmAnyCallbackStruct *) call_data;
5176 *result = cb->reason;
5177 }
5178
5179
5180 /* Callback for unmapping a file selection dialog. This is used to
5181 capture the case where a dialog is closed via a window manager's
5182 closer button, for example. Using a XmNdestroyCallback didn't work
5183 in this case. */
5184
5185 static void
5186 file_dialog_unmap_cb (widget, client_data, call_data)
5187 Widget widget;
5188 XtPointer call_data, client_data;
5189 {
5190 int *result = (int *) client_data;
5191 *result = XmCR_CANCEL;
5192 }
5193
5194 static Lisp_Object
5195 clean_up_file_dialog (arg)
5196 Lisp_Object arg;
5197 {
5198 struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
5199 Widget dialog = (Widget) p->pointer;
5200
5201 /* Clean up. */
5202 BLOCK_INPUT;
5203 XtUnmanageChild (dialog);
5204 XtDestroyWidget (dialog);
5205 x_menu_set_in_use (0);
5206 UNBLOCK_INPUT;
5207
5208 return Qnil;
5209 }
5210
5211
5212 DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
5213 doc: /* Read file name, prompting with PROMPT in directory DIR.
5214 Use a file selection dialog. Select DEFAULT-FILENAME in the dialog's file
5215 selection box, if specified. If MUSTMATCH is non-nil, the returned file
5216 or directory must exist. ONLY-DIR-P is ignored." */)
5217 (prompt, dir, default_filename, mustmatch, only_dir_p)
5218 Lisp_Object prompt, dir, default_filename, mustmatch, only_dir_p;
5219 {
5220 int result;
5221 struct frame *f = SELECTED_FRAME ();
5222 Lisp_Object file = Qnil;
5223 Widget dialog, text, help;
5224 Arg al[10];
5225 int ac = 0;
5226 extern XtAppContext Xt_app_con;
5227 XmString dir_xmstring, pattern_xmstring;
5228 int count = SPECPDL_INDEX ();
5229 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
5230
5231 GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
5232
5233 if (popup_activated ())
5234 error ("Trying to use a menu from within a menu-entry");
5235
5236 CHECK_STRING (prompt);
5237 CHECK_STRING (dir);
5238
5239 /* Prevent redisplay. */
5240 specbind (Qinhibit_redisplay, Qt);
5241
5242 BLOCK_INPUT;
5243
5244 /* Create the dialog with PROMPT as title, using DIR as initial
5245 directory and using "*" as pattern. */
5246 dir = Fexpand_file_name (dir, Qnil);
5247 dir_xmstring = XmStringCreateLocalized (SDATA (dir));
5248 pattern_xmstring = XmStringCreateLocalized ("*");
5249
5250 XtSetArg (al[ac], XmNtitle, SDATA (prompt)); ++ac;
5251 XtSetArg (al[ac], XmNdirectory, dir_xmstring); ++ac;
5252 XtSetArg (al[ac], XmNpattern, pattern_xmstring); ++ac;
5253 XtSetArg (al[ac], XmNresizePolicy, XmRESIZE_GROW); ++ac;
5254 XtSetArg (al[ac], XmNdialogStyle, XmDIALOG_APPLICATION_MODAL); ++ac;
5255 dialog = XmCreateFileSelectionDialog (f->output_data.x->widget,
5256 "fsb", al, ac);
5257 XmStringFree (dir_xmstring);
5258 XmStringFree (pattern_xmstring);
5259
5260 /* Add callbacks for OK and Cancel. */
5261 XtAddCallback (dialog, XmNokCallback, file_dialog_cb,
5262 (XtPointer) &result);
5263 XtAddCallback (dialog, XmNcancelCallback, file_dialog_cb,
5264 (XtPointer) &result);
5265 XtAddCallback (dialog, XmNunmapCallback, file_dialog_unmap_cb,
5266 (XtPointer) &result);
5267
5268 /* Remove the help button since we can't display help. */
5269 help = XmFileSelectionBoxGetChild (dialog, XmDIALOG_HELP_BUTTON);
5270 XtUnmanageChild (help);
5271
5272 /* Mark OK button as default. */
5273 XtVaSetValues (XmFileSelectionBoxGetChild (dialog, XmDIALOG_OK_BUTTON),
5274 XmNshowAsDefault, True, NULL);
5275
5276 /* If MUSTMATCH is non-nil, disable the file entry field of the
5277 dialog, so that the user must select a file from the files list
5278 box. We can't remove it because we wouldn't have a way to get at
5279 the result file name, then. */
5280 text = XmFileSelectionBoxGetChild (dialog, XmDIALOG_TEXT);
5281 if (!NILP (mustmatch))
5282 {
5283 Widget label;
5284 label = XmFileSelectionBoxGetChild (dialog, XmDIALOG_SELECTION_LABEL);
5285 XtSetSensitive (text, False);
5286 XtSetSensitive (label, False);
5287 }
5288
5289 /* Manage the dialog, so that list boxes get filled. */
5290 XtManageChild (dialog);
5291
5292 if (STRINGP (default_filename))
5293 {
5294 XmString default_xmstring;
5295 Widget wtext = XmFileSelectionBoxGetChild (dialog, XmDIALOG_TEXT);
5296 Widget list = XmFileSelectionBoxGetChild (dialog, XmDIALOG_LIST);
5297
5298 XmTextPosition last_pos = XmTextFieldGetLastPosition (wtext);
5299 XmTextFieldReplace (wtext, 0, last_pos,
5300 (SDATA (Ffile_name_nondirectory (default_filename))));
5301
5302 /* Select DEFAULT_FILENAME in the files list box. DEFAULT_FILENAME
5303 must include the path for this to work. */
5304
5305 default_xmstring = XmStringCreateLocalized (SDATA (default_filename));
5306
5307 if (XmListItemExists (list, default_xmstring))
5308 {
5309 int item_pos = XmListItemPos (list, default_xmstring);
5310 /* Select the item and scroll it into view. */
5311 XmListSelectPos (list, item_pos, True);
5312 XmListSetPos (list, item_pos);
5313 }
5314
5315 XmStringFree (default_xmstring);
5316 }
5317
5318 record_unwind_protect (clean_up_file_dialog, make_save_value (dialog, 0));
5319
5320 /* Process events until the user presses Cancel or OK. */
5321 x_menu_set_in_use (1);
5322 result = 0;
5323 while (result == 0)
5324 {
5325 XEvent event;
5326 x_menu_wait_for_event (0);
5327 XtAppNextEvent (Xt_app_con, &event);
5328 if (event.type == KeyPress
5329 && FRAME_X_DISPLAY (f) == event.xkey.display)
5330 {
5331 KeySym keysym = XLookupKeysym (&event.xkey, 0);
5332
5333 /* Pop down on C-g. */
5334 if (keysym == XK_g && (event.xkey.state & ControlMask) != 0)
5335 XtUnmanageChild (dialog);
5336 }
5337
5338 (void) x_dispatch_event (&event, FRAME_X_DISPLAY (f));
5339 }
5340
5341 /* Get the result. */
5342 if (result == XmCR_OK)
5343 {
5344 XmString text;
5345 String data;
5346
5347 XtVaGetValues (dialog, XmNtextString, &text, NULL);
5348 XmStringGetLtoR (text, XmFONTLIST_DEFAULT_TAG, &data);
5349 XmStringFree (text);
5350 file = build_string (data);
5351 XtFree (data);
5352 }
5353 else
5354 file = Qnil;
5355
5356 UNBLOCK_INPUT;
5357 UNGCPRO;
5358
5359 /* Make "Cancel" equivalent to C-g. */
5360 if (NILP (file))
5361 Fsignal (Qquit, Qnil);
5362
5363 return unbind_to (count, file);
5364 }
5365
5366 #endif /* USE_MOTIF */
5367
5368 #ifdef USE_GTK
5369
5370 static Lisp_Object
5371 clean_up_dialog (arg)
5372 Lisp_Object arg;
5373 {
5374 x_menu_set_in_use (0);
5375
5376 return Qnil;
5377 }
5378
5379 DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
5380 doc: /* Read file name, prompting with PROMPT in directory DIR.
5381 Use a file selection dialog. Select DEFAULT-FILENAME in the dialog's file
5382 selection box, if specified. If MUSTMATCH is non-nil, the returned file
5383 or directory must exist. If ONLY-DIR-P is non-nil, the user can only select
5384 directories. */)
5385 (prompt, dir, default_filename, mustmatch, only_dir_p)
5386 Lisp_Object prompt, dir, default_filename, mustmatch, only_dir_p;
5387 {
5388 FRAME_PTR f = SELECTED_FRAME ();
5389 char *fn;
5390 Lisp_Object file = Qnil;
5391 int count = SPECPDL_INDEX ();
5392 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
5393 char *cdef_file;
5394
5395 GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
5396
5397 if (popup_activated ())
5398 error ("Trying to use a menu from within a menu-entry");
5399
5400 CHECK_STRING (prompt);
5401 CHECK_STRING (dir);
5402
5403 /* Prevent redisplay. */
5404 specbind (Qinhibit_redisplay, Qt);
5405 record_unwind_protect (clean_up_dialog, Qnil);
5406
5407 BLOCK_INPUT;
5408
5409 if (STRINGP (default_filename))
5410 cdef_file = SDATA (default_filename);
5411 else
5412 cdef_file = SDATA (dir);
5413
5414 fn = xg_get_file_name (f, SDATA (prompt), cdef_file,
5415 ! NILP (mustmatch),
5416 ! NILP (only_dir_p));
5417
5418 if (fn)
5419 {
5420 file = build_string (fn);
5421 xfree (fn);
5422 }
5423
5424 UNBLOCK_INPUT;
5425 UNGCPRO;
5426
5427 /* Make "Cancel" equivalent to C-g. */
5428 if (NILP (file))
5429 Fsignal (Qquit, Qnil);
5430
5431 return unbind_to (count, file);
5432 }
5433
5434 #endif /* USE_GTK */
5435
5436 \f
5437 /***********************************************************************
5438 Keyboard
5439 ***********************************************************************/
5440
5441 #ifdef HAVE_XKBGETKEYBOARD
5442 #include <X11/XKBlib.h>
5443 #include <X11/keysym.h>
5444 #endif
5445
5446 DEFUN ("x-backspace-delete-keys-p", Fx_backspace_delete_keys_p,
5447 Sx_backspace_delete_keys_p, 0, 1, 0,
5448 doc: /* Check if both Backspace and Delete keys are on the keyboard of FRAME.
5449 FRAME nil means use the selected frame.
5450 Value is t if we know that both keys are present, and are mapped to the
5451 usual X keysyms. */)
5452 (frame)
5453 Lisp_Object frame;
5454 {
5455 #ifdef HAVE_XKBGETKEYBOARD
5456 XkbDescPtr kb;
5457 struct frame *f = check_x_frame (frame);
5458 Display *dpy = FRAME_X_DISPLAY (f);
5459 Lisp_Object have_keys;
5460 int major, minor, op, event, error;
5461
5462 BLOCK_INPUT;
5463
5464 /* Check library version in case we're dynamically linked. */
5465 major = XkbMajorVersion;
5466 minor = XkbMinorVersion;
5467 if (!XkbLibraryVersion (&major, &minor))
5468 {
5469 UNBLOCK_INPUT;
5470 return Qnil;
5471 }
5472
5473 /* Check that the server supports XKB. */
5474 major = XkbMajorVersion;
5475 minor = XkbMinorVersion;
5476 if (!XkbQueryExtension (dpy, &op, &event, &error, &major, &minor))
5477 {
5478 UNBLOCK_INPUT;
5479 return Qnil;
5480 }
5481
5482 /* In this code we check that the keyboard has physical keys with names
5483 that start with BKSP (Backspace) and DELE (Delete), and that they
5484 generate keysym XK_BackSpace and XK_Delete respectively.
5485 This function is used to test if normal-erase-is-backspace should be
5486 turned on.
5487 An alternative approach would be to just check if XK_BackSpace and
5488 XK_Delete are mapped to any key. But if any of those are mapped to
5489 some non-intuitive key combination (Meta-Shift-Ctrl-whatever) and the
5490 user doesn't know about it, it is better to return false here.
5491 It is more obvious to the user what to do if she/he has two keys
5492 clearly marked with names/symbols and one key does something not
5493 expected (i.e. she/he then tries the other).
5494 The cases where Backspace/Delete is mapped to some other key combination
5495 are rare, and in those cases, normal-erase-is-backspace can be turned on
5496 manually. */
5497
5498 have_keys = Qnil;
5499 kb = XkbGetMap (dpy, XkbAllMapComponentsMask, XkbUseCoreKbd);
5500 if (kb)
5501 {
5502 int delete_keycode = 0, backspace_keycode = 0, i;
5503
5504 if (XkbGetNames (dpy, XkbAllNamesMask, kb) == Success)
5505 {
5506 for (i = kb->min_key_code;
5507 (i < kb->max_key_code
5508 && (delete_keycode == 0 || backspace_keycode == 0));
5509 ++i)
5510 {
5511 /* The XKB symbolic key names can be seen most easily in
5512 the PS file generated by `xkbprint -label name
5513 $DISPLAY'. */
5514 if (bcmp ("DELE", kb->names->keys[i].name, 4) == 0)
5515 delete_keycode = i;
5516 else if (bcmp ("BKSP", kb->names->keys[i].name, 4) == 0)
5517 backspace_keycode = i;
5518 }
5519
5520 XkbFreeNames (kb, 0, True);
5521 }
5522
5523 XkbFreeClientMap (kb, 0, True);
5524
5525 if (delete_keycode
5526 && backspace_keycode
5527 && XKeysymToKeycode (dpy, XK_Delete) == delete_keycode
5528 && XKeysymToKeycode (dpy, XK_BackSpace) == backspace_keycode)
5529 have_keys = Qt;
5530 }
5531 UNBLOCK_INPUT;
5532 return have_keys;
5533 #else /* not HAVE_XKBGETKEYBOARD */
5534 return Qnil;
5535 #endif /* not HAVE_XKBGETKEYBOARD */
5536 }
5537
5538
5539 \f
5540 /***********************************************************************
5541 Initialization
5542 ***********************************************************************/
5543
5544 /* Keep this list in the same order as frame_parms in frame.c.
5545 Use 0 for unsupported frame parameters. */
5546
5547 frame_parm_handler x_frame_parm_handlers[] =
5548 {
5549 x_set_autoraise,
5550 x_set_autolower,
5551 x_set_background_color,
5552 x_set_border_color,
5553 x_set_border_width,
5554 x_set_cursor_color,
5555 x_set_cursor_type,
5556 x_set_font,
5557 x_set_foreground_color,
5558 x_set_icon_name,
5559 x_set_icon_type,
5560 x_set_internal_border_width,
5561 x_set_menu_bar_lines,
5562 x_set_mouse_color,
5563 x_explicitly_set_name,
5564 x_set_scroll_bar_width,
5565 x_set_title,
5566 x_set_unsplittable,
5567 x_set_vertical_scroll_bars,
5568 x_set_visibility,
5569 x_set_tool_bar_lines,
5570 x_set_scroll_bar_foreground,
5571 x_set_scroll_bar_background,
5572 x_set_screen_gamma,
5573 x_set_line_spacing,
5574 x_set_fringe_width,
5575 x_set_fringe_width,
5576 x_set_wait_for_wm,
5577 x_set_fullscreen,
5578 };
5579
5580 void
5581 syms_of_xfns ()
5582 {
5583 /* This is zero if not using X windows. */
5584 x_in_use = 0;
5585
5586 /* The section below is built by the lisp expression at the top of the file,
5587 just above where these variables are declared. */
5588 /*&&& init symbols here &&&*/
5589 Qnone = intern ("none");
5590 staticpro (&Qnone);
5591 Qsuppress_icon = intern ("suppress-icon");
5592 staticpro (&Qsuppress_icon);
5593 Qundefined_color = intern ("undefined-color");
5594 staticpro (&Qundefined_color);
5595 Qcompound_text = intern ("compound-text");
5596 staticpro (&Qcompound_text);
5597 Qcancel_timer = intern ("cancel-timer");
5598 staticpro (&Qcancel_timer);
5599 /* This is the end of symbol initialization. */
5600
5601 /* Text property `display' should be nonsticky by default. */
5602 Vtext_property_default_nonsticky
5603 = Fcons (Fcons (Qdisplay, Qt), Vtext_property_default_nonsticky);
5604
5605
5606 Fput (Qundefined_color, Qerror_conditions,
5607 Fcons (Qundefined_color, Fcons (Qerror, Qnil)));
5608 Fput (Qundefined_color, Qerror_message,
5609 build_string ("Undefined color"));
5610
5611 DEFVAR_LISP ("x-pointer-shape", &Vx_pointer_shape,
5612 doc: /* The shape of the pointer when over text.
5613 Changing the value does not affect existing frames
5614 unless you set the mouse color. */);
5615 Vx_pointer_shape = Qnil;
5616
5617 #if 0 /* This doesn't really do anything. */
5618 DEFVAR_LISP ("x-nontext-pointer-shape", &Vx_nontext_pointer_shape,
5619 doc: /* The shape of the pointer when not over text.
5620 This variable takes effect when you create a new frame
5621 or when you set the mouse color. */);
5622 #endif
5623 Vx_nontext_pointer_shape = Qnil;
5624
5625 DEFVAR_LISP ("x-hourglass-pointer-shape", &Vx_hourglass_pointer_shape,
5626 doc: /* The shape of the pointer when Emacs is busy.
5627 This variable takes effect when you create a new frame
5628 or when you set the mouse color. */);
5629 Vx_hourglass_pointer_shape = Qnil;
5630
5631 DEFVAR_BOOL ("display-hourglass", &display_hourglass_p,
5632 doc: /* Non-zero means Emacs displays an hourglass pointer on window systems. */);
5633 display_hourglass_p = 1;
5634
5635 DEFVAR_LISP ("hourglass-delay", &Vhourglass_delay,
5636 doc: /* *Seconds to wait before displaying an hourglass pointer.
5637 Value must be an integer or float. */);
5638 Vhourglass_delay = make_number (DEFAULT_HOURGLASS_DELAY);
5639
5640 #if 0 /* This doesn't really do anything. */
5641 DEFVAR_LISP ("x-mode-pointer-shape", &Vx_mode_pointer_shape,
5642 doc: /* The shape of the pointer when over the mode line.
5643 This variable takes effect when you create a new frame
5644 or when you set the mouse color. */);
5645 #endif
5646 Vx_mode_pointer_shape = Qnil;
5647
5648 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
5649 &Vx_sensitive_text_pointer_shape,
5650 doc: /* The shape of the pointer when over mouse-sensitive text.
5651 This variable takes effect when you create a new frame
5652 or when you set the mouse color. */);
5653 Vx_sensitive_text_pointer_shape = Qnil;
5654
5655 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
5656 &Vx_window_horizontal_drag_shape,
5657 doc: /* Pointer shape to use for indicating a window can be dragged horizontally.
5658 This variable takes effect when you create a new frame
5659 or when you set the mouse color. */);
5660 Vx_window_horizontal_drag_shape = Qnil;
5661
5662 DEFVAR_LISP ("x-cursor-fore-pixel", &Vx_cursor_fore_pixel,
5663 doc: /* A string indicating the foreground color of the cursor box. */);
5664 Vx_cursor_fore_pixel = Qnil;
5665
5666 DEFVAR_LISP ("x-max-tooltip-size", &Vx_max_tooltip_size,
5667 doc: /* Maximum size for tooltips. Value is a pair (COLUMNS . ROWS).
5668 Text larger than this is clipped. */);
5669 Vx_max_tooltip_size = Fcons (make_number (80), make_number (40));
5670
5671 DEFVAR_LISP ("x-no-window-manager", &Vx_no_window_manager,
5672 doc: /* Non-nil if no X window manager is in use.
5673 Emacs doesn't try to figure this out; this is always nil
5674 unless you set it to something else. */);
5675 /* We don't have any way to find this out, so set it to nil
5676 and maybe the user would like to set it to t. */
5677 Vx_no_window_manager = Qnil;
5678
5679 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
5680 &Vx_pixel_size_width_font_regexp,
5681 doc: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
5682
5683 Since Emacs gets width of a font matching with this regexp from
5684 PIXEL_SIZE field of the name, font finding mechanism gets faster for
5685 such a font. This is especially effective for such large fonts as
5686 Chinese, Japanese, and Korean. */);
5687 Vx_pixel_size_width_font_regexp = Qnil;
5688
5689 /* This is not ifdef:ed, so other builds than GTK can customize it. */
5690 DEFVAR_BOOL ("x-use-old-gtk-file-dialog", &x_use_old_gtk_file_dialog,
5691 doc: /* *Non-nil means prompt with the old GTK file selection dialog.
5692 If nil or if the file selection dialog is not available, the new GTK file
5693 chooser is used instead. To turn off all file dialogs set the
5694 variable `use-file-dialog'. */);
5695 x_use_old_gtk_file_dialog = 0;
5696
5697 #ifdef USE_X_TOOLKIT
5698 Fprovide (intern ("x-toolkit"), Qnil);
5699 #ifdef USE_MOTIF
5700 Fprovide (intern ("motif"), Qnil);
5701
5702 DEFVAR_LISP ("motif-version-string", &Vmotif_version_string,
5703 doc: /* Version info for LessTif/Motif. */);
5704 Vmotif_version_string = build_string (XmVERSION_STRING);
5705 #endif /* USE_MOTIF */
5706 #endif /* USE_X_TOOLKIT */
5707
5708 #ifdef USE_GTK
5709 /* Provide x-toolkit also for GTK. Internally GTK does not use Xt so it
5710 is not an X toolkit in that sense (USE_X_TOOLKIT is not defined).
5711 But for a user it is a toolkit for X, and indeed, configure
5712 accepts --with-x-toolkit=gtk. */
5713 Fprovide (intern ("x-toolkit"), Qnil);
5714 Fprovide (intern ("gtk"), Qnil);
5715
5716 DEFVAR_LISP ("gtk-version-string", &Vgtk_version_string,
5717 doc: /* Version info for GTK+. */);
5718 {
5719 char gtk_version[40];
5720 g_snprintf (gtk_version, sizeof (gtk_version), "%u.%u.%u",
5721 GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION);
5722 Vgtk_version_string = build_string (gtk_version);
5723 }
5724 #endif /* USE_GTK */
5725
5726 /* X window properties. */
5727 defsubr (&Sx_change_window_property);
5728 defsubr (&Sx_delete_window_property);
5729 defsubr (&Sx_window_property);
5730
5731 defsubr (&Sxw_display_color_p);
5732 defsubr (&Sx_display_grayscale_p);
5733 defsubr (&Sxw_color_defined_p);
5734 defsubr (&Sxw_color_values);
5735 defsubr (&Sx_server_max_request_size);
5736 defsubr (&Sx_server_vendor);
5737 defsubr (&Sx_server_version);
5738 defsubr (&Sx_display_pixel_width);
5739 defsubr (&Sx_display_pixel_height);
5740 defsubr (&Sx_display_mm_width);
5741 defsubr (&Sx_display_mm_height);
5742 defsubr (&Sx_display_screens);
5743 defsubr (&Sx_display_planes);
5744 defsubr (&Sx_display_color_cells);
5745 defsubr (&Sx_display_visual_class);
5746 defsubr (&Sx_display_backing_store);
5747 defsubr (&Sx_display_save_under);
5748 defsubr (&Sx_create_frame);
5749 defsubr (&Sx_open_connection);
5750 defsubr (&Sx_close_connection);
5751 defsubr (&Sx_display_list);
5752 defsubr (&Sx_synchronize);
5753 defsubr (&Sx_focus_frame);
5754 defsubr (&Sx_backspace_delete_keys_p);
5755
5756 /* Setting callback functions for fontset handler. */
5757 get_font_info_func = x_get_font_info;
5758
5759 #if 0 /* This function pointer doesn't seem to be used anywhere.
5760 And the pointer assigned has the wrong type, anyway. */
5761 list_fonts_func = x_list_fonts;
5762 #endif
5763
5764 load_font_func = x_load_font;
5765 find_ccl_program_func = x_find_ccl_program;
5766 query_font_func = x_query_font;
5767 set_frame_fontset_func = x_set_font;
5768 check_window_system_func = check_x;
5769
5770 hourglass_atimer = NULL;
5771 hourglass_shown_p = 0;
5772
5773 defsubr (&Sx_show_tip);
5774 defsubr (&Sx_hide_tip);
5775 tip_timer = Qnil;
5776 staticpro (&tip_timer);
5777 tip_frame = Qnil;
5778 staticpro (&tip_frame);
5779
5780 last_show_tip_args = Qnil;
5781 staticpro (&last_show_tip_args);
5782
5783 #if defined (USE_MOTIF) || defined (USE_GTK)
5784 defsubr (&Sx_file_dialog);
5785 #endif
5786 }
5787
5788 #endif /* HAVE_X_WINDOWS */
5789
5790 /* arch-tag: 55040d02-5485-4d58-8b22-95a7a05f3288
5791 (do not change this comment) */