Add an index entry for "minibuffer-only frame".
[emacs.git] / src / xfns.c
blob6f08ada1bb92a163b5bab992f1e149c5322cbaec
1 /* Functions for the X window system.
3 Copyright (C) 1989, 1992-2012 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
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 3 of the License, or
10 (at your option) any later version.
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.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 #include <config.h>
21 #include <stdio.h>
22 #include <math.h>
23 #include <setjmp.h>
24 #include <ctype.h>
25 #include <unistd.h>
27 /* This makes the fields of a Display accessible, in Xlib header files. */
29 #define XLIB_ILLEGAL_ACCESS
31 #include "lisp.h"
32 #include "xterm.h"
33 #include "frame.h"
34 #include "window.h"
35 #include "buffer.h"
36 #include "intervals.h"
37 #include "dispextern.h"
38 #include "keyboard.h"
39 #include "blockinput.h"
40 #include <epaths.h>
41 #include "character.h"
42 #include "charset.h"
43 #include "coding.h"
44 #include "fontset.h"
45 #include "systime.h"
46 #include "termhooks.h"
47 #include "atimer.h"
48 #include "termchar.h"
49 #include "font.h"
51 #ifdef HAVE_X_WINDOWS
53 #include <ctype.h>
54 #include <sys/types.h>
55 #include <sys/stat.h>
57 #if 1 /* Used to be #ifdef EMACS_BITMAP_FILES, but this should always work. */
58 #include "bitmaps/gray.xbm"
59 #else
60 #include <X11/bitmaps/gray>
61 #endif
63 #include "xsettings.h"
65 #ifdef USE_GTK
66 #include "gtkutil.h"
67 #endif
69 #ifdef USE_X_TOOLKIT
70 #include <X11/Shell.h>
72 #ifndef USE_MOTIF
73 #ifdef HAVE_XAW3D
74 #include <X11/Xaw3d/Paned.h>
75 #include <X11/Xaw3d/Label.h>
76 #else /* !HAVE_XAW3D */
77 #include <X11/Xaw/Paned.h>
78 #include <X11/Xaw/Label.h>
79 #endif /* HAVE_XAW3D */
80 #endif /* USE_MOTIF */
82 #ifdef USG
83 #undef USG /* ####KLUDGE for Solaris 2.2 and up */
84 #include <X11/Xos.h>
85 #define USG
86 #ifdef USG /* Pacify gcc -Wunused-macros. */
87 #endif
88 #else
89 #include <X11/Xos.h>
90 #endif
92 #include "widget.h"
94 #include "../lwlib/lwlib.h"
96 #ifdef USE_MOTIF
97 #include <Xm/Xm.h>
98 #include <Xm/DialogS.h>
99 #include <Xm/FileSB.h>
100 #include <Xm/List.h>
101 #include <Xm/TextF.h>
102 #endif
104 #ifdef USE_LUCID
105 #include "../lwlib/xlwmenu.h"
106 #endif
108 #if !defined (NO_EDITRES)
109 #define HACK_EDITRES
110 extern void _XEditResCheckMessages (Widget, XtPointer, XEvent *, Boolean *);
111 #endif /* not defined NO_EDITRES */
113 /* Unique id counter for widgets created by the Lucid Widget Library. */
115 extern LWLIB_ID widget_id_tick;
117 #ifdef USE_MOTIF
119 #endif /* USE_MOTIF */
121 #endif /* USE_X_TOOLKIT */
123 #ifdef USE_GTK
125 #endif /* USE_GTK */
127 #define MAXREQUEST(dpy) (XMaxRequestSize (dpy))
129 /* The gray bitmap `bitmaps/gray'. This is done because xterm.c uses
130 it, and including `bitmaps/gray' more than once is a problem when
131 config.h defines `static' as an empty replacement string. */
133 int gray_bitmap_width = gray_width;
134 int gray_bitmap_height = gray_height;
135 char *gray_bitmap_bits = gray_bits;
137 /* Nonzero if using X. */
139 static int x_in_use;
141 static Lisp_Object Qnone;
142 static Lisp_Object Qsuppress_icon;
143 static Lisp_Object Qundefined_color;
144 static Lisp_Object Qcompound_text, Qcancel_timer;
145 Lisp_Object Qfont_param;
147 #if GLYPH_DEBUG
148 static ptrdiff_t image_cache_refcount;
149 static int dpyinfo_refcount;
150 #endif
152 #if defined (USE_GTK) && defined (HAVE_FREETYPE)
153 static char *x_last_font_name;
154 #endif
156 static struct x_display_info *x_display_info_for_name (Lisp_Object);
159 /* Error if we are not connected to X. */
161 void
162 check_x (void)
164 if (! x_in_use)
165 error ("X windows are not in use or not initialized");
168 /* Nonzero if we can use mouse menus.
169 You should not call this unless HAVE_MENUS is defined. */
172 have_menus_p (void)
174 return x_in_use;
177 /* Extract a frame as a FRAME_PTR, defaulting to the selected frame
178 and checking validity for X. */
180 FRAME_PTR
181 check_x_frame (Lisp_Object frame)
183 FRAME_PTR f;
185 if (NILP (frame))
186 frame = selected_frame;
187 CHECK_LIVE_FRAME (frame);
188 f = XFRAME (frame);
189 if (! FRAME_X_P (f))
190 error ("Non-X frame used");
191 return f;
194 /* Let the user specify an X display with a Lisp object.
195 OBJECT may be nil, a frame or a terminal object.
196 nil stands for the selected frame--or, if that is not an X frame,
197 the first X display on the list. */
199 struct x_display_info *
200 check_x_display_info (Lisp_Object object)
202 struct x_display_info *dpyinfo = NULL;
204 if (NILP (object))
206 struct frame *sf = XFRAME (selected_frame);
208 if (FRAME_X_P (sf) && FRAME_LIVE_P (sf))
209 dpyinfo = FRAME_X_DISPLAY_INFO (sf);
210 else if (x_display_list != 0)
211 dpyinfo = x_display_list;
212 else
213 error ("X windows are not in use or not initialized");
215 else if (TERMINALP (object))
217 struct terminal *t = get_terminal (object, 1);
219 if (t->type != output_x_window)
220 error ("Terminal %"pI"d is not an X display", XINT (object));
222 dpyinfo = t->display_info.x;
224 else if (STRINGP (object))
225 dpyinfo = x_display_info_for_name (object);
226 else
228 FRAME_PTR f = check_x_frame (object);
229 dpyinfo = FRAME_X_DISPLAY_INFO (f);
232 return dpyinfo;
236 /* Return the Emacs frame-object corresponding to an X window.
237 It could be the frame's main window or an icon window. */
239 /* This function can be called during GC, so use GC_xxx type test macros. */
241 struct frame *
242 x_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
244 Lisp_Object tail, frame;
245 struct frame *f;
247 if (wdesc == None) return 0;
249 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
251 frame = XCAR (tail);
252 if (!FRAMEP (frame))
253 continue;
254 f = XFRAME (frame);
255 if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
256 continue;
257 if (f->output_data.x->hourglass_window == wdesc)
258 return f;
259 #ifdef USE_X_TOOLKIT
260 if ((f->output_data.x->edit_widget
261 && XtWindow (f->output_data.x->edit_widget) == wdesc)
262 /* A tooltip frame? */
263 || (!f->output_data.x->edit_widget
264 && FRAME_X_WINDOW (f) == wdesc)
265 || f->output_data.x->icon_desc == wdesc)
266 return f;
267 #else /* not USE_X_TOOLKIT */
268 #ifdef USE_GTK
269 if (f->output_data.x->edit_widget)
271 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
272 struct x_output *x = f->output_data.x;
273 if (gwdesc != 0 && gwdesc == x->edit_widget)
274 return f;
276 #endif /* USE_GTK */
277 if (FRAME_X_WINDOW (f) == wdesc
278 || f->output_data.x->icon_desc == wdesc)
279 return f;
280 #endif /* not USE_X_TOOLKIT */
282 return 0;
285 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
286 /* Like x_window_to_frame but also compares the window with the widget's
287 windows. */
289 struct frame *
290 x_any_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
292 Lisp_Object tail, frame;
293 struct frame *f, *found;
294 struct x_output *x;
296 if (wdesc == None) return NULL;
298 found = NULL;
299 for (tail = Vframe_list; CONSP (tail) && !found; tail = XCDR (tail))
301 frame = XCAR (tail);
302 if (!FRAMEP (frame))
303 continue;
305 f = XFRAME (frame);
306 if (FRAME_X_P (f) && FRAME_X_DISPLAY_INFO (f) == dpyinfo)
308 /* This frame matches if the window is any of its widgets. */
309 x = f->output_data.x;
310 if (x->hourglass_window == wdesc)
311 found = f;
312 else if (x->widget)
314 #ifdef USE_GTK
315 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
316 if (gwdesc != 0
317 && gtk_widget_get_toplevel (gwdesc) == x->widget)
318 found = f;
319 #else
320 if (wdesc == XtWindow (x->widget)
321 || wdesc == XtWindow (x->column_widget)
322 || wdesc == XtWindow (x->edit_widget))
323 found = f;
324 /* Match if the window is this frame's menubar. */
325 else if (lw_window_is_in_menubar (wdesc, x->menubar_widget))
326 found = f;
327 #endif
329 else if (FRAME_X_WINDOW (f) == wdesc)
330 /* A tooltip frame. */
331 found = f;
335 return found;
338 /* Likewise, but consider only the menu bar widget. */
340 struct frame *
341 x_menubar_window_to_frame (struct x_display_info *dpyinfo, XEvent *event)
343 Window wdesc = event->xany.window;
344 Lisp_Object tail, frame;
345 struct frame *f;
346 struct x_output *x;
348 if (wdesc == None) return 0;
350 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
352 frame = XCAR (tail);
353 if (!FRAMEP (frame))
354 continue;
355 f = XFRAME (frame);
356 if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
357 continue;
358 x = f->output_data.x;
359 #ifdef USE_GTK
360 if (x->menubar_widget && xg_event_is_for_menubar (f, event))
361 return f;
362 #else
363 /* Match if the window is this frame's menubar. */
364 if (x->menubar_widget
365 && lw_window_is_in_menubar (wdesc, x->menubar_widget))
366 return f;
367 #endif
369 return 0;
372 /* Return the frame whose principal (outermost) window is WDESC.
373 If WDESC is some other (smaller) window, we return 0. */
375 struct frame *
376 x_top_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
378 Lisp_Object tail, frame;
379 struct frame *f;
380 struct x_output *x;
382 if (wdesc == None) return 0;
384 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
386 frame = XCAR (tail);
387 if (!FRAMEP (frame))
388 continue;
389 f = XFRAME (frame);
390 if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
391 continue;
392 x = f->output_data.x;
394 if (x->widget)
396 /* This frame matches if the window is its topmost widget. */
397 #ifdef USE_GTK
398 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
399 if (gwdesc == x->widget)
400 return f;
401 #else
402 if (wdesc == XtWindow (x->widget))
403 return f;
404 #if 0 /* I don't know why it did this,
405 but it seems logically wrong,
406 and it causes trouble for MapNotify events. */
407 /* Match if the window is this frame's menubar. */
408 if (x->menubar_widget
409 && wdesc == XtWindow (x->menubar_widget))
410 return f;
411 #endif
412 #endif
414 else if (FRAME_X_WINDOW (f) == wdesc)
415 /* Tooltip frame. */
416 return f;
418 return 0;
420 #endif /* USE_X_TOOLKIT || USE_GTK */
424 /* Store the screen positions of frame F into XPTR and YPTR.
425 These are the positions of the containing window manager window,
426 not Emacs's own window. */
428 void
429 x_real_positions (FRAME_PTR f, int *xptr, int *yptr)
431 int win_x, win_y, outer_x IF_LINT (= 0), outer_y IF_LINT (= 0);
432 int real_x = 0, real_y = 0;
433 int had_errors = 0;
434 Window win = f->output_data.x->parent_desc;
435 Atom actual_type;
436 unsigned long actual_size, bytes_remaining;
437 int rc, actual_format;
438 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
439 long max_len = 400;
440 Display *dpy = FRAME_X_DISPLAY (f);
441 unsigned char *tmp_data = NULL;
442 Atom target_type = XA_CARDINAL;
444 BLOCK_INPUT;
446 x_catch_errors (dpy);
448 if (win == dpyinfo->root_window)
449 win = FRAME_OUTER_WINDOW (f);
451 /* This loop traverses up the containment tree until we hit the root
452 window. Window managers may intersect many windows between our window
453 and the root window. The window we find just before the root window
454 should be the outer WM window. */
455 for (;;)
457 Window wm_window, rootw;
458 Window *tmp_children;
459 unsigned int tmp_nchildren;
460 int success;
462 success = XQueryTree (FRAME_X_DISPLAY (f), win, &rootw,
463 &wm_window, &tmp_children, &tmp_nchildren);
465 had_errors = x_had_errors_p (FRAME_X_DISPLAY (f));
467 /* Don't free tmp_children if XQueryTree failed. */
468 if (! success)
469 break;
471 XFree ((char *) tmp_children);
473 if (wm_window == rootw || had_errors)
474 break;
476 win = wm_window;
479 if (! had_errors)
481 unsigned int ign;
482 Window child, rootw;
484 /* Get the real coordinates for the WM window upper left corner */
485 XGetGeometry (FRAME_X_DISPLAY (f), win,
486 &rootw, &real_x, &real_y, &ign, &ign, &ign, &ign);
488 /* Translate real coordinates to coordinates relative to our
489 window. For our window, the upper left corner is 0, 0.
490 Since the upper left corner of the WM window is outside
491 our window, win_x and win_y will be negative:
493 ------------------ ---> x
494 | title |
495 | ----------------- v y
496 | | our window
498 XTranslateCoordinates (FRAME_X_DISPLAY (f),
500 /* From-window, to-window. */
501 FRAME_X_DISPLAY_INFO (f)->root_window,
502 FRAME_X_WINDOW (f),
504 /* From-position, to-position. */
505 real_x, real_y, &win_x, &win_y,
507 /* Child of win. */
508 &child);
510 if (FRAME_X_WINDOW (f) == FRAME_OUTER_WINDOW (f))
512 outer_x = win_x;
513 outer_y = win_y;
515 else
517 XTranslateCoordinates (FRAME_X_DISPLAY (f),
519 /* From-window, to-window. */
520 FRAME_X_DISPLAY_INFO (f)->root_window,
521 FRAME_OUTER_WINDOW (f),
523 /* From-position, to-position. */
524 real_x, real_y, &outer_x, &outer_y,
526 /* Child of win. */
527 &child);
530 had_errors = x_had_errors_p (FRAME_X_DISPLAY (f));
534 if (dpyinfo->root_window == f->output_data.x->parent_desc)
536 /* Try _NET_FRAME_EXTENTS if our parent is the root window. */
537 rc = XGetWindowProperty (dpy, win, dpyinfo->Xatom_net_frame_extents,
538 0, max_len, False, target_type,
539 &actual_type, &actual_format, &actual_size,
540 &bytes_remaining, &tmp_data);
542 if (rc == Success && actual_type == target_type && !x_had_errors_p (dpy)
543 && actual_size == 4 && actual_format == 32)
545 unsigned int ign;
546 Window rootw;
547 long *fe = (long *)tmp_data;
549 XGetGeometry (FRAME_X_DISPLAY (f), win,
550 &rootw, &real_x, &real_y, &ign, &ign, &ign, &ign);
551 outer_x = -fe[0];
552 outer_y = -fe[2];
553 real_x -= fe[0];
554 real_y -= fe[2];
558 if (tmp_data) XFree (tmp_data);
560 x_uncatch_errors ();
562 UNBLOCK_INPUT;
564 if (had_errors) return;
566 f->x_pixels_diff = -win_x;
567 f->y_pixels_diff = -win_y;
569 FRAME_X_OUTPUT (f)->x_pixels_outer_diff = -outer_x;
570 FRAME_X_OUTPUT (f)->y_pixels_outer_diff = -outer_y;
572 *xptr = real_x;
573 *yptr = real_y;
579 /* Gamma-correct COLOR on frame F. */
581 void
582 gamma_correct (struct frame *f, XColor *color)
584 if (f->gamma)
586 color->red = pow (color->red / 65535.0, f->gamma) * 65535.0 + 0.5;
587 color->green = pow (color->green / 65535.0, f->gamma) * 65535.0 + 0.5;
588 color->blue = pow (color->blue / 65535.0, f->gamma) * 65535.0 + 0.5;
593 /* Decide if color named COLOR_NAME is valid for use on frame F. If
594 so, return the RGB values in COLOR. If ALLOC_P is non-zero,
595 allocate the color. Value is zero if COLOR_NAME is invalid, or
596 no color could be allocated. */
599 x_defined_color (struct frame *f, const char *color_name,
600 XColor *color, int alloc_p)
602 int success_p = 0;
603 Display *dpy = FRAME_X_DISPLAY (f);
604 Colormap cmap = FRAME_X_COLORMAP (f);
606 BLOCK_INPUT;
607 #ifdef USE_GTK
608 success_p = xg_check_special_colors (f, color_name, color);
609 #endif
610 if (!success_p)
611 success_p = XParseColor (dpy, cmap, color_name, color);
612 if (success_p && alloc_p)
613 success_p = x_alloc_nearest_color (f, cmap, color);
614 UNBLOCK_INPUT;
616 return success_p;
620 /* Return the pixel color value for color COLOR_NAME on frame F. If F
621 is a monochrome frame, return MONO_COLOR regardless of what ARG says.
622 Signal an error if color can't be allocated. */
624 static int
625 x_decode_color (FRAME_PTR f, Lisp_Object color_name, int mono_color)
627 XColor cdef;
629 CHECK_STRING (color_name);
631 #if 0 /* Don't do this. It's wrong when we're not using the default
632 colormap, it makes freeing difficult, and it's probably not
633 an important optimization. */
634 if (strcmp (SDATA (color_name), "black") == 0)
635 return BLACK_PIX_DEFAULT (f);
636 else if (strcmp (SDATA (color_name), "white") == 0)
637 return WHITE_PIX_DEFAULT (f);
638 #endif
640 /* Return MONO_COLOR for monochrome frames. */
641 if (FRAME_X_DISPLAY_INFO (f)->n_planes == 1)
642 return mono_color;
644 /* x_defined_color is responsible for coping with failures
645 by looking for a near-miss. */
646 if (x_defined_color (f, SSDATA (color_name), &cdef, 1))
647 return cdef.pixel;
649 signal_error ("Undefined color", color_name);
654 /* Change the `wait-for-wm' frame parameter of frame F. OLD_VALUE is
655 the previous value of that parameter, NEW_VALUE is the new value.
656 See also the comment of wait_for_wm in struct x_output. */
658 static void
659 x_set_wait_for_wm (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
661 f->output_data.x->wait_for_wm = !NILP (new_value);
664 static void
665 x_set_tool_bar_position (struct frame *f,
666 Lisp_Object new_value,
667 Lisp_Object old_value)
669 if (! EQ (new_value, Qleft) && ! EQ (new_value, Qright)
670 && ! EQ (new_value, Qbottom) && ! EQ (new_value, Qtop))
671 return;
672 if (EQ (new_value, old_value)) return;
674 #ifdef USE_GTK
675 if (xg_change_toolbar_position (f, new_value))
676 f->tool_bar_position = new_value;
677 #endif
680 #ifdef USE_GTK
682 /* Set icon from FILE for frame F. By using GTK functions the icon
683 may be any format that GdkPixbuf knows about, i.e. not just bitmaps. */
686 xg_set_icon (FRAME_PTR f, Lisp_Object file)
688 int result = 0;
689 Lisp_Object found;
691 found = x_find_image_file (file);
693 if (! NILP (found))
695 GdkPixbuf *pixbuf;
696 GError *err = NULL;
697 char *filename = SSDATA (found);
698 BLOCK_INPUT;
700 pixbuf = gdk_pixbuf_new_from_file (filename, &err);
702 if (pixbuf)
704 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
705 pixbuf);
706 g_object_unref (pixbuf);
708 result = 1;
710 else
711 g_error_free (err);
713 UNBLOCK_INPUT;
716 return result;
720 xg_set_icon_from_xpm_data (FRAME_PTR f, const char **data)
722 GdkPixbuf *pixbuf = gdk_pixbuf_new_from_xpm_data (data);
724 if (!pixbuf)
725 return 0;
727 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)), pixbuf);
728 g_object_unref (pixbuf);
729 return 1;
731 #endif /* USE_GTK */
734 /* Functions called only from `x_set_frame_param'
735 to set individual parameters.
737 If FRAME_X_WINDOW (f) is 0,
738 the frame is being created and its X-window does not exist yet.
739 In that case, just record the parameter's new value
740 in the standard place; do not attempt to change the window. */
742 static void
743 x_set_foreground_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
745 struct x_output *x = f->output_data.x;
746 unsigned long fg, old_fg;
748 fg = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
749 old_fg = FRAME_FOREGROUND_PIXEL (f);
750 FRAME_FOREGROUND_PIXEL (f) = fg;
752 if (FRAME_X_WINDOW (f) != 0)
754 Display *dpy = FRAME_X_DISPLAY (f);
756 BLOCK_INPUT;
757 XSetForeground (dpy, x->normal_gc, fg);
758 XSetBackground (dpy, x->reverse_gc, fg);
760 if (x->cursor_pixel == old_fg)
762 unload_color (f, x->cursor_pixel);
763 x->cursor_pixel = x_copy_color (f, fg);
764 XSetBackground (dpy, x->cursor_gc, x->cursor_pixel);
767 UNBLOCK_INPUT;
769 update_face_from_frame_parameter (f, Qforeground_color, arg);
771 if (FRAME_VISIBLE_P (f))
772 redraw_frame (f);
775 unload_color (f, old_fg);
778 static void
779 x_set_background_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
781 struct x_output *x = f->output_data.x;
782 unsigned long bg;
784 bg = x_decode_color (f, arg, WHITE_PIX_DEFAULT (f));
785 unload_color (f, FRAME_BACKGROUND_PIXEL (f));
786 FRAME_BACKGROUND_PIXEL (f) = bg;
788 if (FRAME_X_WINDOW (f) != 0)
790 Display *dpy = FRAME_X_DISPLAY (f);
792 BLOCK_INPUT;
793 XSetBackground (dpy, x->normal_gc, bg);
794 XSetForeground (dpy, x->reverse_gc, bg);
795 XSetWindowBackground (dpy, FRAME_X_WINDOW (f), bg);
796 XSetForeground (dpy, x->cursor_gc, bg);
798 #ifdef USE_GTK
799 xg_set_background_color (f, bg);
800 #endif
802 #ifndef USE_TOOLKIT_SCROLL_BARS /* Turns out to be annoying with
803 toolkit scroll bars. */
805 Lisp_Object bar;
806 for (bar = FRAME_SCROLL_BARS (f);
807 !NILP (bar);
808 bar = XSCROLL_BAR (bar)->next)
810 Window window = XSCROLL_BAR (bar)->x_window;
811 XSetWindowBackground (dpy, window, bg);
814 #endif /* USE_TOOLKIT_SCROLL_BARS */
816 UNBLOCK_INPUT;
817 update_face_from_frame_parameter (f, Qbackground_color, arg);
819 if (FRAME_VISIBLE_P (f))
820 redraw_frame (f);
824 static Cursor
825 make_invisible_cursor (struct frame *f)
827 Display *dpy = FRAME_X_DISPLAY (f);
828 static char const no_data[] = { 0 };
829 Pixmap pix;
830 XColor col;
831 Cursor c = 0;
833 x_catch_errors (dpy);
834 pix = XCreateBitmapFromData (dpy, FRAME_X_DISPLAY_INFO (f)->root_window,
835 no_data, 1, 1);
836 if (! x_had_errors_p (dpy) && pix != None)
838 Cursor pixc;
839 col.pixel = 0;
840 col.red = col.green = col.blue = 0;
841 col.flags = DoRed | DoGreen | DoBlue;
842 pixc = XCreatePixmapCursor (dpy, pix, pix, &col, &col, 0, 0);
843 if (! x_had_errors_p (dpy) && pixc != None)
844 c = pixc;
845 XFreePixmap (dpy, pix);
848 x_uncatch_errors ();
850 return c;
853 static void
854 x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
856 struct x_output *x = f->output_data.x;
857 Display *dpy = FRAME_X_DISPLAY (f);
858 Cursor cursor, nontext_cursor, mode_cursor, hand_cursor;
859 Cursor hourglass_cursor, horizontal_drag_cursor;
860 unsigned long pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
861 unsigned long mask_color = FRAME_BACKGROUND_PIXEL (f);
863 /* Don't let pointers be invisible. */
864 if (mask_color == pixel)
866 x_free_colors (f, &pixel, 1);
867 pixel = x_copy_color (f, FRAME_FOREGROUND_PIXEL (f));
870 unload_color (f, x->mouse_pixel);
871 x->mouse_pixel = pixel;
873 BLOCK_INPUT;
875 /* It's not okay to crash if the user selects a screwy cursor. */
876 x_catch_errors (dpy);
878 if (!NILP (Vx_pointer_shape))
880 CHECK_NUMBER (Vx_pointer_shape);
881 cursor = XCreateFontCursor (dpy, XINT (Vx_pointer_shape));
883 else
884 cursor = XCreateFontCursor (dpy, XC_xterm);
885 x_check_errors (dpy, "bad text pointer cursor: %s");
887 if (!NILP (Vx_nontext_pointer_shape))
889 CHECK_NUMBER (Vx_nontext_pointer_shape);
890 nontext_cursor
891 = XCreateFontCursor (dpy, XINT (Vx_nontext_pointer_shape));
893 else
894 nontext_cursor = XCreateFontCursor (dpy, XC_left_ptr);
895 x_check_errors (dpy, "bad nontext pointer cursor: %s");
897 if (!NILP (Vx_hourglass_pointer_shape))
899 CHECK_NUMBER (Vx_hourglass_pointer_shape);
900 hourglass_cursor
901 = XCreateFontCursor (dpy, XINT (Vx_hourglass_pointer_shape));
903 else
904 hourglass_cursor = XCreateFontCursor (dpy, XC_watch);
905 x_check_errors (dpy, "bad hourglass pointer cursor: %s");
907 if (!NILP (Vx_mode_pointer_shape))
909 CHECK_NUMBER (Vx_mode_pointer_shape);
910 mode_cursor = XCreateFontCursor (dpy, XINT (Vx_mode_pointer_shape));
912 else
913 mode_cursor = XCreateFontCursor (dpy, XC_xterm);
914 x_check_errors (dpy, "bad modeline pointer cursor: %s");
916 if (!NILP (Vx_sensitive_text_pointer_shape))
918 CHECK_NUMBER (Vx_sensitive_text_pointer_shape);
919 hand_cursor
920 = XCreateFontCursor (dpy, XINT (Vx_sensitive_text_pointer_shape));
922 else
923 hand_cursor = XCreateFontCursor (dpy, XC_hand2);
925 if (!NILP (Vx_window_horizontal_drag_shape))
927 CHECK_NUMBER (Vx_window_horizontal_drag_shape);
928 horizontal_drag_cursor
929 = XCreateFontCursor (dpy, XINT (Vx_window_horizontal_drag_shape));
931 else
932 horizontal_drag_cursor
933 = XCreateFontCursor (dpy, XC_sb_h_double_arrow);
935 /* Check and report errors with the above calls. */
936 x_check_errors (dpy, "can't set cursor shape: %s");
937 x_uncatch_errors ();
940 XColor fore_color, back_color;
942 fore_color.pixel = x->mouse_pixel;
943 x_query_color (f, &fore_color);
944 back_color.pixel = mask_color;
945 x_query_color (f, &back_color);
947 XRecolorCursor (dpy, cursor, &fore_color, &back_color);
948 XRecolorCursor (dpy, nontext_cursor, &fore_color, &back_color);
949 XRecolorCursor (dpy, mode_cursor, &fore_color, &back_color);
950 XRecolorCursor (dpy, hand_cursor, &fore_color, &back_color);
951 XRecolorCursor (dpy, hourglass_cursor, &fore_color, &back_color);
952 XRecolorCursor (dpy, horizontal_drag_cursor, &fore_color, &back_color);
955 if (FRAME_X_WINDOW (f) != 0)
956 XDefineCursor (dpy, FRAME_X_WINDOW (f),
957 f->output_data.x->current_cursor = cursor);
959 if (FRAME_X_DISPLAY_INFO (f)->invisible_cursor == 0)
960 FRAME_X_DISPLAY_INFO (f)->invisible_cursor = make_invisible_cursor (f);
962 if (cursor != x->text_cursor
963 && x->text_cursor != 0)
964 XFreeCursor (dpy, x->text_cursor);
965 x->text_cursor = cursor;
967 if (nontext_cursor != x->nontext_cursor
968 && x->nontext_cursor != 0)
969 XFreeCursor (dpy, x->nontext_cursor);
970 x->nontext_cursor = nontext_cursor;
972 if (hourglass_cursor != x->hourglass_cursor
973 && x->hourglass_cursor != 0)
974 XFreeCursor (dpy, x->hourglass_cursor);
975 x->hourglass_cursor = hourglass_cursor;
977 if (mode_cursor != x->modeline_cursor
978 && x->modeline_cursor != 0)
979 XFreeCursor (dpy, f->output_data.x->modeline_cursor);
980 x->modeline_cursor = mode_cursor;
982 if (hand_cursor != x->hand_cursor
983 && x->hand_cursor != 0)
984 XFreeCursor (dpy, x->hand_cursor);
985 x->hand_cursor = hand_cursor;
987 if (horizontal_drag_cursor != x->horizontal_drag_cursor
988 && x->horizontal_drag_cursor != 0)
989 XFreeCursor (dpy, x->horizontal_drag_cursor);
990 x->horizontal_drag_cursor = horizontal_drag_cursor;
992 XFlush (dpy);
993 UNBLOCK_INPUT;
995 update_face_from_frame_parameter (f, Qmouse_color, arg);
998 static void
999 x_set_cursor_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1001 unsigned long fore_pixel, pixel;
1002 int fore_pixel_allocated_p = 0, pixel_allocated_p = 0;
1003 struct x_output *x = f->output_data.x;
1005 if (!NILP (Vx_cursor_fore_pixel))
1007 fore_pixel = x_decode_color (f, Vx_cursor_fore_pixel,
1008 WHITE_PIX_DEFAULT (f));
1009 fore_pixel_allocated_p = 1;
1011 else
1012 fore_pixel = FRAME_BACKGROUND_PIXEL (f);
1014 pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
1015 pixel_allocated_p = 1;
1017 /* Make sure that the cursor color differs from the background color. */
1018 if (pixel == FRAME_BACKGROUND_PIXEL (f))
1020 if (pixel_allocated_p)
1022 x_free_colors (f, &pixel, 1);
1023 pixel_allocated_p = 0;
1026 pixel = x->mouse_pixel;
1027 if (pixel == fore_pixel)
1029 if (fore_pixel_allocated_p)
1031 x_free_colors (f, &fore_pixel, 1);
1032 fore_pixel_allocated_p = 0;
1034 fore_pixel = FRAME_BACKGROUND_PIXEL (f);
1038 unload_color (f, x->cursor_foreground_pixel);
1039 if (!fore_pixel_allocated_p)
1040 fore_pixel = x_copy_color (f, fore_pixel);
1041 x->cursor_foreground_pixel = fore_pixel;
1043 unload_color (f, x->cursor_pixel);
1044 if (!pixel_allocated_p)
1045 pixel = x_copy_color (f, pixel);
1046 x->cursor_pixel = pixel;
1048 if (FRAME_X_WINDOW (f) != 0)
1050 BLOCK_INPUT;
1051 XSetBackground (FRAME_X_DISPLAY (f), x->cursor_gc, x->cursor_pixel);
1052 XSetForeground (FRAME_X_DISPLAY (f), x->cursor_gc, fore_pixel);
1053 UNBLOCK_INPUT;
1055 if (FRAME_VISIBLE_P (f))
1057 x_update_cursor (f, 0);
1058 x_update_cursor (f, 1);
1062 update_face_from_frame_parameter (f, Qcursor_color, arg);
1065 /* Set the border-color of frame F to pixel value PIX.
1066 Note that this does not fully take effect if done before
1067 F has an x-window. */
1069 static void
1070 x_set_border_pixel (struct frame *f, int pix)
1072 unload_color (f, f->output_data.x->border_pixel);
1073 f->output_data.x->border_pixel = pix;
1075 if (FRAME_X_WINDOW (f) != 0 && f->border_width > 0)
1077 BLOCK_INPUT;
1078 XSetWindowBorder (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), pix);
1079 UNBLOCK_INPUT;
1081 if (FRAME_VISIBLE_P (f))
1082 redraw_frame (f);
1086 /* Set the border-color of frame F to value described by ARG.
1087 ARG can be a string naming a color.
1088 The border-color is used for the border that is drawn by the X server.
1089 Note that this does not fully take effect if done before
1090 F has an x-window; it must be redone when the window is created.
1092 Note: this is done in two routines because of the way X10 works.
1094 Note: under X11, this is normally the province of the window manager,
1095 and so emacs' border colors may be overridden. */
1097 static void
1098 x_set_border_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1100 int pix;
1102 CHECK_STRING (arg);
1103 pix = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
1104 x_set_border_pixel (f, pix);
1105 update_face_from_frame_parameter (f, Qborder_color, arg);
1109 static void
1110 x_set_cursor_type (FRAME_PTR f, Lisp_Object arg, Lisp_Object oldval)
1112 set_frame_cursor_types (f, arg);
1114 /* Make sure the cursor gets redrawn. */
1115 cursor_type_changed = 1;
1118 static void
1119 x_set_icon_type (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1121 int result;
1123 if (STRINGP (arg))
1125 if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
1126 return;
1128 else if (!STRINGP (oldval) && EQ (oldval, Qnil) == EQ (arg, Qnil))
1129 return;
1131 BLOCK_INPUT;
1132 if (NILP (arg))
1133 result = x_text_icon (f,
1134 SSDATA ((!NILP (f->icon_name)
1135 ? f->icon_name
1136 : f->name)));
1137 else
1138 result = x_bitmap_icon (f, arg);
1140 if (result)
1142 UNBLOCK_INPUT;
1143 error ("No icon window available");
1146 XFlush (FRAME_X_DISPLAY (f));
1147 UNBLOCK_INPUT;
1150 static void
1151 x_set_icon_name (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1153 int result;
1155 if (STRINGP (arg))
1157 if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
1158 return;
1160 else if (!NILP (arg) || NILP (oldval))
1161 return;
1163 f->icon_name = arg;
1165 if (f->output_data.x->icon_bitmap != 0)
1166 return;
1168 BLOCK_INPUT;
1170 result = x_text_icon (f,
1171 SSDATA ((!NILP (f->icon_name)
1172 ? f->icon_name
1173 : !NILP (f->title)
1174 ? f->title
1175 : f->name)));
1177 if (result)
1179 UNBLOCK_INPUT;
1180 error ("No icon window available");
1183 XFlush (FRAME_X_DISPLAY (f));
1184 UNBLOCK_INPUT;
1188 void
1189 x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
1191 int nlines;
1192 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1193 int olines = FRAME_MENU_BAR_LINES (f);
1194 #endif
1196 /* Right now, menu bars don't work properly in minibuf-only frames;
1197 most of the commands try to apply themselves to the minibuffer
1198 frame itself, and get an error because you can't switch buffers
1199 in or split the minibuffer window. */
1200 if (FRAME_MINIBUF_ONLY_P (f))
1201 return;
1203 if (INTEGERP (value))
1204 nlines = XINT (value);
1205 else
1206 nlines = 0;
1208 /* Make sure we redisplay all windows in this frame. */
1209 windows_or_buffers_changed++;
1211 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1212 FRAME_MENU_BAR_LINES (f) = 0;
1213 if (nlines)
1215 FRAME_EXTERNAL_MENU_BAR (f) = 1;
1216 if (FRAME_X_P (f) && f->output_data.x->menubar_widget == 0)
1217 /* Make sure next redisplay shows the menu bar. */
1218 XWINDOW (FRAME_SELECTED_WINDOW (f))->update_mode_line = Qt;
1220 else
1222 if (FRAME_EXTERNAL_MENU_BAR (f) == 1)
1223 free_frame_menubar (f);
1224 FRAME_EXTERNAL_MENU_BAR (f) = 0;
1225 if (FRAME_X_P (f))
1226 f->output_data.x->menubar_widget = 0;
1228 #else /* not USE_X_TOOLKIT && not USE_GTK */
1229 FRAME_MENU_BAR_LINES (f) = nlines;
1230 resize_frame_windows (f, FRAME_LINES (f), 0);
1232 /* If the menu bar height gets changed, the internal border below
1233 the top margin has to be cleared. Also, if the menu bar gets
1234 larger, the area for the added lines has to be cleared except for
1235 the first menu bar line that is to be drawn later. */
1236 if (nlines != olines)
1238 int height = FRAME_INTERNAL_BORDER_WIDTH (f);
1239 int width = FRAME_PIXEL_WIDTH (f);
1240 int y;
1242 /* height can be zero here. */
1243 if (height > 0 && width > 0)
1245 y = FRAME_TOP_MARGIN_HEIGHT (f);
1247 BLOCK_INPUT;
1248 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1249 0, y, width, height, False);
1250 UNBLOCK_INPUT;
1253 if (nlines > 1 && nlines > olines)
1255 y = (olines == 0 ? 1 : olines) * FRAME_LINE_HEIGHT (f);
1256 height = nlines * FRAME_LINE_HEIGHT (f) - y;
1258 BLOCK_INPUT;
1259 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1260 0, y, width, height, False);
1261 UNBLOCK_INPUT;
1264 if (nlines == 0 && WINDOWP (f->menu_bar_window))
1265 clear_glyph_matrix (XWINDOW (f->menu_bar_window)->current_matrix);
1267 #endif /* not USE_X_TOOLKIT && not USE_GTK */
1268 adjust_glyphs (f);
1269 run_window_configuration_change_hook (f);
1273 /* Set the number of lines used for the tool bar of frame F to VALUE.
1274 VALUE not an integer, or < 0 means set the lines to zero. OLDVAL
1275 is the old number of tool bar lines. This function changes the
1276 height of all windows on frame F to match the new tool bar height.
1277 The frame's height doesn't change. */
1279 void
1280 x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
1282 int delta, nlines, root_height;
1283 Lisp_Object root_window;
1285 /* Treat tool bars like menu bars. */
1286 if (FRAME_MINIBUF_ONLY_P (f))
1287 return;
1289 /* Use VALUE only if an integer >= 0. */
1290 if (INTEGERP (value) && XINT (value) >= 0)
1291 nlines = XFASTINT (value);
1292 else
1293 nlines = 0;
1295 #ifdef USE_GTK
1296 FRAME_TOOL_BAR_LINES (f) = 0;
1297 if (nlines)
1299 FRAME_EXTERNAL_TOOL_BAR (f) = 1;
1300 if (FRAME_X_P (f) && f->output_data.x->toolbar_widget == 0)
1301 /* Make sure next redisplay shows the tool bar. */
1302 XWINDOW (FRAME_SELECTED_WINDOW (f))->update_mode_line = Qt;
1303 update_frame_tool_bar (f);
1305 else
1307 if (FRAME_EXTERNAL_TOOL_BAR (f))
1308 free_frame_tool_bar (f);
1309 FRAME_EXTERNAL_TOOL_BAR (f) = 0;
1312 return;
1313 #endif
1315 /* Make sure we redisplay all windows in this frame. */
1316 ++windows_or_buffers_changed;
1318 delta = nlines - FRAME_TOOL_BAR_LINES (f);
1320 /* Don't resize the tool-bar to more than we have room for. */
1321 root_window = FRAME_ROOT_WINDOW (f);
1322 root_height = WINDOW_TOTAL_LINES (XWINDOW (root_window));
1323 if (root_height - delta < 1)
1325 delta = root_height - 1;
1326 nlines = FRAME_TOOL_BAR_LINES (f) + delta;
1329 FRAME_TOOL_BAR_LINES (f) = nlines;
1330 resize_frame_windows (f, FRAME_LINES (f), 0);
1331 adjust_glyphs (f);
1333 /* We also have to make sure that the internal border at the top of
1334 the frame, below the menu bar or tool bar, is redrawn when the
1335 tool bar disappears. This is so because the internal border is
1336 below the tool bar if one is displayed, but is below the menu bar
1337 if there isn't a tool bar. The tool bar draws into the area
1338 below the menu bar. */
1339 if (FRAME_X_WINDOW (f) && FRAME_TOOL_BAR_LINES (f) == 0)
1341 clear_frame (f);
1342 clear_current_matrices (f);
1345 /* If the tool bar gets smaller, the internal border below it
1346 has to be cleared. It was formerly part of the display
1347 of the larger tool bar, and updating windows won't clear it. */
1348 if (delta < 0)
1350 int height = FRAME_INTERNAL_BORDER_WIDTH (f);
1351 int width = FRAME_PIXEL_WIDTH (f);
1352 int y = (FRAME_MENU_BAR_LINES (f) + nlines) * FRAME_LINE_HEIGHT (f);
1354 /* height can be zero here. */
1355 if (height > 0 && width > 0)
1357 BLOCK_INPUT;
1358 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1359 0, y, width, height, False);
1360 UNBLOCK_INPUT;
1363 if (WINDOWP (f->tool_bar_window))
1364 clear_glyph_matrix (XWINDOW (f->tool_bar_window)->current_matrix);
1367 run_window_configuration_change_hook (f);
1372 /* Set the foreground color for scroll bars on frame F to VALUE.
1373 VALUE should be a string, a color name. If it isn't a string or
1374 isn't a valid color name, do nothing. OLDVAL is the old value of
1375 the frame parameter. */
1377 static void
1378 x_set_scroll_bar_foreground (struct frame *f, Lisp_Object value, Lisp_Object oldval)
1380 unsigned long pixel;
1382 if (STRINGP (value))
1383 pixel = x_decode_color (f, value, BLACK_PIX_DEFAULT (f));
1384 else
1385 pixel = -1;
1387 if (f->output_data.x->scroll_bar_foreground_pixel != -1)
1388 unload_color (f, f->output_data.x->scroll_bar_foreground_pixel);
1390 f->output_data.x->scroll_bar_foreground_pixel = pixel;
1391 if (FRAME_X_WINDOW (f) && FRAME_VISIBLE_P (f))
1393 /* Remove all scroll bars because they have wrong colors. */
1394 if (FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
1395 (*FRAME_TERMINAL (f)->condemn_scroll_bars_hook) (f);
1396 if (FRAME_TERMINAL (f)->judge_scroll_bars_hook)
1397 (*FRAME_TERMINAL (f)->judge_scroll_bars_hook) (f);
1399 update_face_from_frame_parameter (f, Qscroll_bar_foreground, value);
1400 redraw_frame (f);
1405 /* Set the background color for scroll bars on frame F to VALUE VALUE
1406 should be a string, a color name. If it isn't a string or isn't a
1407 valid color name, do nothing. OLDVAL is the old value of the frame
1408 parameter. */
1410 static void
1411 x_set_scroll_bar_background (struct frame *f, Lisp_Object value, Lisp_Object oldval)
1413 unsigned long pixel;
1415 if (STRINGP (value))
1416 pixel = x_decode_color (f, value, WHITE_PIX_DEFAULT (f));
1417 else
1418 pixel = -1;
1420 if (f->output_data.x->scroll_bar_background_pixel != -1)
1421 unload_color (f, f->output_data.x->scroll_bar_background_pixel);
1423 #ifdef USE_TOOLKIT_SCROLL_BARS
1424 /* Scrollbar shadow colors. */
1425 if (f->output_data.x->scroll_bar_top_shadow_pixel != -1)
1427 unload_color (f, f->output_data.x->scroll_bar_top_shadow_pixel);
1428 f->output_data.x->scroll_bar_top_shadow_pixel = -1;
1430 if (f->output_data.x->scroll_bar_bottom_shadow_pixel != -1)
1432 unload_color (f, f->output_data.x->scroll_bar_bottom_shadow_pixel);
1433 f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
1435 #endif /* USE_TOOLKIT_SCROLL_BARS */
1437 f->output_data.x->scroll_bar_background_pixel = pixel;
1438 if (FRAME_X_WINDOW (f) && FRAME_VISIBLE_P (f))
1440 /* Remove all scroll bars because they have wrong colors. */
1441 if (FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
1442 (*FRAME_TERMINAL (f)->condemn_scroll_bars_hook) (f);
1443 if (FRAME_TERMINAL (f)->judge_scroll_bars_hook)
1444 (*FRAME_TERMINAL (f)->judge_scroll_bars_hook) (f);
1446 update_face_from_frame_parameter (f, Qscroll_bar_background, value);
1447 redraw_frame (f);
1452 /* Encode Lisp string STRING as a text in a format appropriate for
1453 XICCC (X Inter Client Communication Conventions).
1455 This can call Lisp code, so callers must GCPRO.
1457 If STRING contains only ASCII characters, do no conversion and
1458 return the string data of STRING. Otherwise, encode the text by
1459 CODING_SYSTEM, and return a newly allocated memory area which
1460 should be freed by `xfree' by a caller.
1462 SELECTIONP non-zero means the string is being encoded for an X
1463 selection, so it is safe to run pre-write conversions (which
1464 may run Lisp code).
1466 Store the byte length of resulting text in *TEXT_BYTES.
1468 If the text contains only ASCII and Latin-1, store 1 in *STRING_P,
1469 which means that the `encoding' of the result can be `STRING'.
1470 Otherwise store 0 in *STRINGP, which means that the `encoding' of
1471 the result should be `COMPOUND_TEXT'. */
1473 static unsigned char *
1474 x_encode_text (Lisp_Object string, Lisp_Object coding_system, int selectionp,
1475 ptrdiff_t *text_bytes, int *stringp, int *freep)
1477 int result = string_xstring_p (string);
1478 struct coding_system coding;
1480 if (result == 0)
1482 /* No multibyte character in OBJ. We need not encode it. */
1483 *text_bytes = SBYTES (string);
1484 *stringp = 1;
1485 *freep = 0;
1486 return SDATA (string);
1489 setup_coding_system (coding_system, &coding);
1490 coding.mode |= (CODING_MODE_SAFE_ENCODING | CODING_MODE_LAST_BLOCK);
1491 /* We suppress producing escape sequences for composition. */
1492 coding.common_flags &= ~CODING_ANNOTATION_MASK;
1493 coding.destination = xnmalloc (SCHARS (string), 2);
1494 coding.dst_bytes = SCHARS (string) * 2;
1495 encode_coding_object (&coding, string, 0, 0,
1496 SCHARS (string), SBYTES (string), Qnil);
1497 *text_bytes = coding.produced;
1498 *stringp = (result == 1 || !EQ (coding_system, Qcompound_text));
1499 *freep = 1;
1500 return coding.destination;
1504 /* Set the WM name to NAME for frame F. Also set the icon name.
1505 If the frame already has an icon name, use that, otherwise set the
1506 icon name to NAME. */
1508 static void
1509 x_set_name_internal (FRAME_PTR f, Lisp_Object name)
1511 if (FRAME_X_WINDOW (f))
1513 BLOCK_INPUT;
1515 XTextProperty text, icon;
1516 ptrdiff_t bytes;
1517 int stringp;
1518 int do_free_icon_value = 0, do_free_text_value = 0;
1519 Lisp_Object coding_system;
1520 Lisp_Object encoded_name;
1521 Lisp_Object encoded_icon_name;
1522 struct gcpro gcpro1;
1524 /* As ENCODE_UTF_8 may cause GC and relocation of string data,
1525 we use it before x_encode_text that may return string data. */
1526 GCPRO1 (name);
1527 encoded_name = ENCODE_UTF_8 (name);
1528 UNGCPRO;
1530 coding_system = Qcompound_text;
1531 /* Note: Encoding strategy
1533 We encode NAME by compound-text and use "COMPOUND-TEXT" in
1534 text.encoding. But, there are non-internationalized window
1535 managers which don't support that encoding. So, if NAME
1536 contains only ASCII and 8859-1 characters, encode it by
1537 iso-latin-1, and use "STRING" in text.encoding hoping that
1538 such window managers at least analyze this format correctly,
1539 i.e. treat 8-bit bytes as 8859-1 characters.
1541 We may also be able to use "UTF8_STRING" in text.encoding
1542 in the future which can encode all Unicode characters.
1543 But, for the moment, there's no way to know that the
1544 current window manager supports it or not.
1546 Either way, we also set the _NET_WM_NAME and _NET_WM_ICON_NAME
1547 properties. Per the EWMH specification, those two properties
1548 are always UTF8_STRING. This matches what gtk_window_set_title()
1549 does in the USE_GTK case. */
1550 text.value = x_encode_text (name, coding_system, 0, &bytes, &stringp,
1551 &do_free_text_value);
1552 text.encoding = (stringp ? XA_STRING
1553 : FRAME_X_DISPLAY_INFO (f)->Xatom_COMPOUND_TEXT);
1554 text.format = 8;
1555 text.nitems = bytes;
1556 if (text.nitems != bytes)
1557 error ("Window name too large");
1559 if (!STRINGP (f->icon_name))
1561 icon = text;
1562 encoded_icon_name = encoded_name;
1564 else
1566 /* See the above comment "Note: Encoding strategy". */
1567 icon.value = x_encode_text (f->icon_name, coding_system, 0,
1568 &bytes, &stringp, &do_free_icon_value);
1569 icon.encoding = (stringp ? XA_STRING
1570 : FRAME_X_DISPLAY_INFO (f)->Xatom_COMPOUND_TEXT);
1571 icon.format = 8;
1572 icon.nitems = bytes;
1573 if (icon.nitems != bytes)
1574 error ("Icon name too large");
1576 encoded_icon_name = ENCODE_UTF_8 (f->icon_name);
1579 #ifdef USE_GTK
1580 gtk_window_set_title (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
1581 SSDATA (encoded_name));
1582 #else /* not USE_GTK */
1583 XSetWMName (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &text);
1584 XChangeProperty (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
1585 FRAME_X_DISPLAY_INFO (f)->Xatom_net_wm_name,
1586 FRAME_X_DISPLAY_INFO (f)->Xatom_UTF8_STRING,
1587 8, PropModeReplace,
1588 SDATA (encoded_name),
1589 SBYTES (encoded_name));
1590 #endif /* not USE_GTK */
1592 XSetWMIconName (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &icon);
1593 XChangeProperty (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
1594 FRAME_X_DISPLAY_INFO (f)->Xatom_net_wm_icon_name,
1595 FRAME_X_DISPLAY_INFO (f)->Xatom_UTF8_STRING,
1596 8, PropModeReplace,
1597 SDATA (encoded_icon_name),
1598 SBYTES (encoded_icon_name));
1600 if (do_free_icon_value)
1601 xfree (icon.value);
1602 if (do_free_text_value)
1603 xfree (text.value);
1605 UNBLOCK_INPUT;
1609 /* Change the name of frame F to NAME. If NAME is nil, set F's name to
1610 x_id_name.
1612 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1613 name; if NAME is a string, set F's name to NAME and set
1614 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1616 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1617 suggesting a new name, which lisp code should override; if
1618 F->explicit_name is set, ignore the new name; otherwise, set it. */
1620 static void
1621 x_set_name (struct frame *f, Lisp_Object name, int explicit)
1623 /* Make sure that requests from lisp code override requests from
1624 Emacs redisplay code. */
1625 if (explicit)
1627 /* If we're switching from explicit to implicit, we had better
1628 update the mode lines and thereby update the title. */
1629 if (f->explicit_name && NILP (name))
1630 update_mode_lines = 1;
1632 f->explicit_name = ! NILP (name);
1634 else if (f->explicit_name)
1635 return;
1637 /* If NAME is nil, set the name to the x_id_name. */
1638 if (NILP (name))
1640 /* Check for no change needed in this very common case
1641 before we do any consing. */
1642 if (!strcmp (FRAME_X_DISPLAY_INFO (f)->x_id_name,
1643 SSDATA (f->name)))
1644 return;
1645 name = build_string (FRAME_X_DISPLAY_INFO (f)->x_id_name);
1647 else
1648 CHECK_STRING (name);
1650 /* Don't change the name if it's already NAME. */
1651 if (! NILP (Fstring_equal (name, f->name)))
1652 return;
1654 f->name = name;
1656 /* For setting the frame title, the title parameter should override
1657 the name parameter. */
1658 if (! NILP (f->title))
1659 name = f->title;
1661 x_set_name_internal (f, name);
1664 /* This function should be called when the user's lisp code has
1665 specified a name for the frame; the name will override any set by the
1666 redisplay code. */
1667 static void
1668 x_explicitly_set_name (FRAME_PTR f, Lisp_Object arg, Lisp_Object oldval)
1670 x_set_name (f, arg, 1);
1673 /* This function should be called by Emacs redisplay code to set the
1674 name; names set this way will never override names set by the user's
1675 lisp code. */
1676 void
1677 x_implicitly_set_name (FRAME_PTR f, Lisp_Object arg, Lisp_Object oldval)
1679 x_set_name (f, arg, 0);
1682 /* Change the title of frame F to NAME.
1683 If NAME is nil, use the frame name as the title. */
1685 static void
1686 x_set_title (struct frame *f, Lisp_Object name, Lisp_Object old_name)
1688 /* Don't change the title if it's already NAME. */
1689 if (EQ (name, f->title))
1690 return;
1692 update_mode_lines = 1;
1694 f->title = name;
1696 if (NILP (name))
1697 name = f->name;
1698 else
1699 CHECK_STRING (name);
1701 x_set_name_internal (f, name);
1704 void
1705 x_set_scroll_bar_default_width (struct frame *f)
1707 int wid = FRAME_COLUMN_WIDTH (f);
1708 #ifdef USE_TOOLKIT_SCROLL_BARS
1709 #ifdef USE_GTK
1710 int minw = xg_get_default_scrollbar_width ();
1711 #else
1712 int minw = 16;
1713 #endif
1714 /* A minimum width of 14 doesn't look good for toolkit scroll bars. */
1715 int width = minw + 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM;
1716 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (width + wid - 1) / wid;
1717 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = width;
1718 #else
1719 /* Make the actual width at least 14 pixels and a multiple of a
1720 character width. */
1721 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
1723 /* Use all of that space (aside from required margins) for the
1724 scroll bar. */
1725 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = 0;
1726 #endif
1730 /* Record in frame F the specified or default value according to ALIST
1731 of the parameter named PROP (a Lisp symbol). If no value is
1732 specified for PROP, look for an X default for XPROP on the frame
1733 named NAME. If that is not found either, use the value DEFLT. */
1735 static Lisp_Object
1736 x_default_scroll_bar_color_parameter (struct frame *f,
1737 Lisp_Object alist, Lisp_Object prop,
1738 const char *xprop, const char *xclass,
1739 int foreground_p)
1741 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
1742 Lisp_Object tem;
1744 tem = x_get_arg (dpyinfo, alist, prop, xprop, xclass, RES_TYPE_STRING);
1745 if (EQ (tem, Qunbound))
1747 #ifdef USE_TOOLKIT_SCROLL_BARS
1749 /* See if an X resource for the scroll bar color has been
1750 specified. */
1751 tem = display_x_get_resource (dpyinfo,
1752 build_string (foreground_p
1753 ? "foreground"
1754 : "background"),
1755 empty_unibyte_string,
1756 build_string ("verticalScrollBar"),
1757 empty_unibyte_string);
1758 if (!STRINGP (tem))
1760 /* If nothing has been specified, scroll bars will use a
1761 toolkit-dependent default. Because these defaults are
1762 difficult to get at without actually creating a scroll
1763 bar, use nil to indicate that no color has been
1764 specified. */
1765 tem = Qnil;
1768 #else /* not USE_TOOLKIT_SCROLL_BARS */
1770 tem = Qnil;
1772 #endif /* not USE_TOOLKIT_SCROLL_BARS */
1775 x_set_frame_parameters (f, Fcons (Fcons (prop, tem), Qnil));
1776 return tem;
1782 #ifdef USE_X_TOOLKIT
1784 /* If the WM_PROTOCOLS property does not already contain WM_TAKE_FOCUS,
1785 WM_DELETE_WINDOW, and WM_SAVE_YOURSELF, then add them. (They may
1786 already be present because of the toolkit (Motif adds some of them,
1787 for example, but Xt doesn't). */
1789 static void
1790 hack_wm_protocols (FRAME_PTR f, Widget widget)
1792 Display *dpy = XtDisplay (widget);
1793 Window w = XtWindow (widget);
1794 int need_delete = 1;
1795 int need_focus = 1;
1796 int need_save = 1;
1798 BLOCK_INPUT;
1800 Atom type;
1801 unsigned char *catoms;
1802 int format = 0;
1803 unsigned long nitems = 0;
1804 unsigned long bytes_after;
1806 if ((XGetWindowProperty (dpy, w,
1807 FRAME_X_DISPLAY_INFO (f)->Xatom_wm_protocols,
1808 (long)0, (long)100, False, XA_ATOM,
1809 &type, &format, &nitems, &bytes_after,
1810 &catoms)
1811 == Success)
1812 && format == 32 && type == XA_ATOM)
1814 Atom *atoms = (Atom *) catoms;
1815 while (nitems > 0)
1817 nitems--;
1818 if (atoms[nitems]
1819 == FRAME_X_DISPLAY_INFO (f)->Xatom_wm_delete_window)
1820 need_delete = 0;
1821 else if (atoms[nitems]
1822 == FRAME_X_DISPLAY_INFO (f)->Xatom_wm_take_focus)
1823 need_focus = 0;
1824 else if (atoms[nitems]
1825 == FRAME_X_DISPLAY_INFO (f)->Xatom_wm_save_yourself)
1826 need_save = 0;
1829 if (catoms)
1830 XFree (catoms);
1833 Atom props [10];
1834 int count = 0;
1835 if (need_delete)
1836 props[count++] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_delete_window;
1837 if (need_focus)
1838 props[count++] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_take_focus;
1839 if (need_save)
1840 props[count++] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_save_yourself;
1841 if (count)
1842 XChangeProperty (dpy, w, FRAME_X_DISPLAY_INFO (f)->Xatom_wm_protocols,
1843 XA_ATOM, 32, PropModeAppend,
1844 (unsigned char *) props, count);
1846 UNBLOCK_INPUT;
1848 #endif
1852 /* Support routines for XIC (X Input Context). */
1854 #ifdef HAVE_X_I18N
1856 static XFontSet xic_create_xfontset (struct frame *);
1857 static XIMStyle best_xim_style (XIMStyles *, XIMStyles *);
1860 /* Supported XIM styles, ordered by preference. */
1862 static XIMStyle supported_xim_styles[] =
1864 XIMPreeditPosition | XIMStatusArea,
1865 XIMPreeditPosition | XIMStatusNothing,
1866 XIMPreeditPosition | XIMStatusNone,
1867 XIMPreeditNothing | XIMStatusArea,
1868 XIMPreeditNothing | XIMStatusNothing,
1869 XIMPreeditNothing | XIMStatusNone,
1870 XIMPreeditNone | XIMStatusArea,
1871 XIMPreeditNone | XIMStatusNothing,
1872 XIMPreeditNone | XIMStatusNone,
1877 #if defined HAVE_X_WINDOWS && defined USE_X_TOOLKIT
1878 /* Create an X fontset on frame F with base font name BASE_FONTNAME. */
1880 static const char xic_default_fontset[] = "-*-*-*-r-normal--14-*-*-*-*-*-*-*";
1882 /* Create an Xt fontset spec from the name of a base font.
1883 If `motif' is True use the Motif syntax. */
1884 char *
1885 xic_create_fontsetname (const char *base_fontname, int motif)
1887 const char *sep = motif ? ";" : ",";
1888 char *fontsetname;
1890 /* Make a fontset name from the base font name. */
1891 if (xic_default_fontset == base_fontname)
1892 { /* There is no base font name, use the default. */
1893 ptrdiff_t len = strlen (base_fontname) + 2;
1894 fontsetname = xmalloc (len);
1895 memset (fontsetname, 0, len);
1896 strcpy (fontsetname, base_fontname);
1898 else
1900 /* Make a fontset name from the base font name.
1901 The font set will be made of the following elements:
1902 - the base font.
1903 - the base font where the charset spec is replaced by -*-*.
1904 - the same but with the family also replaced with -*-*-. */
1905 const char *p = base_fontname;
1906 ptrdiff_t i;
1908 for (i = 0; *p; p++)
1909 if (*p == '-') i++;
1910 if (i != 14)
1911 { /* As the font name doesn't conform to XLFD, we can't
1912 modify it to generalize it to allcs and allfamilies.
1913 Use the specified font plus the default. */
1914 ptrdiff_t len =
1915 strlen (base_fontname) + strlen (xic_default_fontset) + 3;
1916 fontsetname = xmalloc (len);
1917 memset (fontsetname, 0, len);
1918 strcpy (fontsetname, base_fontname);
1919 strcat (fontsetname, sep);
1920 strcat (fontsetname, xic_default_fontset);
1922 else
1924 ptrdiff_t len;
1925 const char *p1 = NULL, *p2 = NULL, *p3 = NULL;
1926 char *font_allcs = NULL;
1927 char *font_allfamilies = NULL;
1928 char *font_all = NULL;
1929 const char *allcs = "*-*-*-*-*-*-*";
1930 const char *allfamilies = "-*-*-";
1931 const char *all = "*-*-*-*-";
1932 char *base;
1934 for (i = 0, p = base_fontname; i < 8; p++)
1936 if (*p == '-')
1938 i++;
1939 if (i == 3)
1940 p1 = p + 1;
1941 else if (i == 7)
1942 p2 = p + 1;
1943 else if (i == 6)
1944 p3 = p + 1;
1947 /* If base_fontname specifies ADSTYLE, make it a
1948 wildcard. */
1949 if (*p3 != '*')
1951 ptrdiff_t diff = (p2 - p3) - 2;
1953 base = alloca (strlen (base_fontname) + 1);
1954 memcpy (base, base_fontname, p3 - base_fontname);
1955 base[p3 - base_fontname] = '*';
1956 base[(p3 - base_fontname) + 1] = '-';
1957 strcpy (base + (p3 - base_fontname) + 2, p2);
1958 p = base + (p - base_fontname) - diff;
1959 p1 = base + (p1 - base_fontname);
1960 p2 = base + (p2 - base_fontname) - diff;
1961 base_fontname = base;
1964 /* Build the font spec that matches all charsets. */
1965 len = p - base_fontname + strlen (allcs) + 1;
1966 font_allcs = (char *) alloca (len);
1967 memset (font_allcs, 0, len);
1968 memcpy (font_allcs, base_fontname, p - base_fontname);
1969 strcat (font_allcs, allcs);
1971 /* Build the font spec that matches all families and
1972 add-styles. */
1973 len = p - p1 + strlen (allcs) + strlen (allfamilies) + 1;
1974 font_allfamilies = (char *) alloca (len);
1975 memset (font_allfamilies, 0, len);
1976 strcpy (font_allfamilies, allfamilies);
1977 memcpy (font_allfamilies + strlen (allfamilies), p1, p - p1);
1978 strcat (font_allfamilies, allcs);
1980 /* Build the font spec that matches all. */
1981 len = p - p2 + strlen (allcs) + strlen (all) + strlen (allfamilies) + 1;
1982 font_all = (char *) alloca (len);
1983 memset (font_all, 0, len);
1984 strcpy (font_all, allfamilies);
1985 strcat (font_all, all);
1986 memcpy (font_all + strlen (all) + strlen (allfamilies), p2, p - p2);
1987 strcat (font_all, allcs);
1989 /* Build the actual font set name. */
1990 len = strlen (base_fontname) + strlen (font_allcs)
1991 + strlen (font_allfamilies) + strlen (font_all) + 5;
1992 fontsetname = xmalloc (len);
1993 memset (fontsetname, 0, len);
1994 strcpy (fontsetname, base_fontname);
1995 strcat (fontsetname, sep);
1996 strcat (fontsetname, font_allcs);
1997 strcat (fontsetname, sep);
1998 strcat (fontsetname, font_allfamilies);
1999 strcat (fontsetname, sep);
2000 strcat (fontsetname, font_all);
2003 if (motif)
2004 strcat (fontsetname, ":");
2005 return fontsetname;
2007 #endif /* HAVE_X_WINDOWS && USE_X_TOOLKIT */
2009 #ifdef DEBUG_XIC_FONTSET
2010 static void
2011 print_fontset_result (XFontSet xfs, char *name, char **missing_list,
2012 int missing_count)
2014 if (xfs)
2015 fprintf (stderr, "XIC Fontset created: %s\n", name);
2016 else
2018 fprintf (stderr, "XIC Fontset failed: %s\n", name);
2019 while (missing_count-- > 0)
2021 fprintf (stderr, " missing: %s\n", *missing_list);
2022 missing_list++;
2027 #endif
2029 static XFontSet
2030 xic_create_xfontset (struct frame *f)
2032 XFontSet xfs = NULL;
2033 struct font *font = FRAME_FONT (f);
2034 int pixel_size = font->pixel_size;
2035 Lisp_Object rest, frame;
2037 /* See if there is another frame already using same fontset. */
2038 FOR_EACH_FRAME (rest, frame)
2040 struct frame *cf = XFRAME (frame);
2042 if (cf != f && FRAME_LIVE_P (f) && FRAME_X_P (cf)
2043 && FRAME_X_DISPLAY_INFO (cf) == FRAME_X_DISPLAY_INFO (f)
2044 && FRAME_FONT (f)
2045 && FRAME_FONT (f)->pixel_size == pixel_size)
2047 xfs = FRAME_XIC_FONTSET (cf);
2048 break;
2052 if (! xfs)
2054 char buf[256];
2055 char **missing_list;
2056 int missing_count;
2057 char *def_string;
2058 const char *xlfd_format = "-*-*-medium-r-normal--%d-*-*-*-*-*";
2060 sprintf (buf, xlfd_format, pixel_size);
2061 missing_list = NULL;
2062 xfs = XCreateFontSet (FRAME_X_DISPLAY (f), buf,
2063 &missing_list, &missing_count, &def_string);
2064 #ifdef DEBUG_XIC_FONTSET
2065 print_fontset_result (xfs, buf, missing_list, missing_count);
2066 #endif
2067 if (missing_list)
2068 XFreeStringList (missing_list);
2069 if (! xfs)
2071 /* List of pixel sizes most likely available. Find one that
2072 is closest to pixel_size. */
2073 int sizes[] = {0, 8, 10, 11, 12, 14, 17, 18, 20, 24, 26, 34, 0};
2074 int *smaller, *larger;
2076 for (smaller = sizes; smaller[1]; smaller++)
2077 if (smaller[1] >= pixel_size)
2078 break;
2079 larger = smaller + 1;
2080 if (*larger == pixel_size)
2081 larger++;
2082 while (*smaller || *larger)
2084 int this_size;
2086 if (! *larger)
2087 this_size = *smaller--;
2088 else if (! *smaller)
2089 this_size = *larger++;
2090 else if (pixel_size - *smaller < *larger - pixel_size)
2091 this_size = *smaller--;
2092 else
2093 this_size = *larger++;
2094 sprintf (buf, xlfd_format, this_size);
2095 missing_list = NULL;
2096 xfs = XCreateFontSet (FRAME_X_DISPLAY (f), buf,
2097 &missing_list, &missing_count, &def_string);
2098 #ifdef DEBUG_XIC_FONTSET
2099 print_fontset_result (xfs, buf, missing_list, missing_count);
2100 #endif
2101 if (missing_list)
2102 XFreeStringList (missing_list);
2103 if (xfs)
2104 break;
2107 if (! xfs)
2109 const char *last_resort = "-*-*-*-r-normal--*-*-*-*-*-*";
2111 missing_list = NULL;
2112 xfs = XCreateFontSet (FRAME_X_DISPLAY (f), last_resort,
2113 &missing_list, &missing_count, &def_string);
2114 #ifdef DEBUG_XIC_FONTSET
2115 print_fontset_result (xfs, last_resort, missing_list, missing_count);
2116 #endif
2117 if (missing_list)
2118 XFreeStringList (missing_list);
2123 return xfs;
2126 /* Free the X fontset of frame F if it is the last frame using it. */
2128 void
2129 xic_free_xfontset (struct frame *f)
2131 Lisp_Object rest, frame;
2132 int shared_p = 0;
2134 if (!FRAME_XIC_FONTSET (f))
2135 return;
2137 /* See if there is another frame sharing the same fontset. */
2138 FOR_EACH_FRAME (rest, frame)
2140 struct frame *cf = XFRAME (frame);
2141 if (cf != f && FRAME_LIVE_P (f) && FRAME_X_P (cf)
2142 && FRAME_X_DISPLAY_INFO (cf) == FRAME_X_DISPLAY_INFO (f)
2143 && FRAME_XIC_FONTSET (cf) == FRAME_XIC_FONTSET (f))
2145 shared_p = 1;
2146 break;
2150 if (!shared_p)
2151 /* The fontset is not used anymore. It is safe to free it. */
2152 XFreeFontSet (FRAME_X_DISPLAY (f), FRAME_XIC_FONTSET (f));
2154 if (FRAME_XIC_BASE_FONTNAME (f))
2155 xfree (FRAME_XIC_BASE_FONTNAME (f));
2156 FRAME_XIC_BASE_FONTNAME (f) = NULL;
2157 FRAME_XIC_FONTSET (f) = NULL;
2161 /* Value is the best input style, given user preferences USER (already
2162 checked to be supported by Emacs), and styles supported by the
2163 input method XIM. */
2165 static XIMStyle
2166 best_xim_style (XIMStyles *user, XIMStyles *xim)
2168 int i, j;
2170 for (i = 0; i < user->count_styles; ++i)
2171 for (j = 0; j < xim->count_styles; ++j)
2172 if (user->supported_styles[i] == xim->supported_styles[j])
2173 return user->supported_styles[i];
2175 /* Return the default style. */
2176 return XIMPreeditNothing | XIMStatusNothing;
2179 /* Create XIC for frame F. */
2181 static XIMStyle xic_style;
2183 void
2184 create_frame_xic (struct frame *f)
2186 XIM xim;
2187 XIC xic = NULL;
2188 XFontSet xfs = NULL;
2190 if (FRAME_XIC (f))
2191 return;
2193 /* Create X fontset. */
2194 xfs = xic_create_xfontset (f);
2195 xim = FRAME_X_XIM (f);
2196 if (xim)
2198 XRectangle s_area;
2199 XPoint spot;
2200 XVaNestedList preedit_attr;
2201 XVaNestedList status_attr;
2203 s_area.x = 0; s_area.y = 0; s_area.width = 1; s_area.height = 1;
2204 spot.x = 0; spot.y = 1;
2206 /* Determine XIC style. */
2207 if (xic_style == 0)
2209 XIMStyles supported_list;
2210 supported_list.count_styles = (sizeof supported_xim_styles
2211 / sizeof supported_xim_styles[0]);
2212 supported_list.supported_styles = supported_xim_styles;
2213 xic_style = best_xim_style (&supported_list,
2214 FRAME_X_XIM_STYLES (f));
2217 preedit_attr = XVaCreateNestedList (0,
2218 XNFontSet, xfs,
2219 XNForeground,
2220 FRAME_FOREGROUND_PIXEL (f),
2221 XNBackground,
2222 FRAME_BACKGROUND_PIXEL (f),
2223 (xic_style & XIMPreeditPosition
2224 ? XNSpotLocation
2225 : NULL),
2226 &spot,
2227 NULL);
2228 status_attr = XVaCreateNestedList (0,
2229 XNArea,
2230 &s_area,
2231 XNFontSet,
2232 xfs,
2233 XNForeground,
2234 FRAME_FOREGROUND_PIXEL (f),
2235 XNBackground,
2236 FRAME_BACKGROUND_PIXEL (f),
2237 NULL);
2239 xic = XCreateIC (xim,
2240 XNInputStyle, xic_style,
2241 XNClientWindow, FRAME_X_WINDOW (f),
2242 XNFocusWindow, FRAME_X_WINDOW (f),
2243 XNStatusAttributes, status_attr,
2244 XNPreeditAttributes, preedit_attr,
2245 NULL);
2246 XFree (preedit_attr);
2247 XFree (status_attr);
2250 FRAME_XIC (f) = xic;
2251 FRAME_XIC_STYLE (f) = xic_style;
2252 FRAME_XIC_FONTSET (f) = xfs;
2256 /* Destroy XIC and free XIC fontset of frame F, if any. */
2258 void
2259 free_frame_xic (struct frame *f)
2261 if (FRAME_XIC (f) == NULL)
2262 return;
2264 XDestroyIC (FRAME_XIC (f));
2265 xic_free_xfontset (f);
2267 FRAME_XIC (f) = NULL;
2271 /* Place preedit area for XIC of window W's frame to specified
2272 pixel position X/Y. X and Y are relative to window W. */
2274 void
2275 xic_set_preeditarea (struct window *w, int x, int y)
2277 struct frame *f = XFRAME (w->frame);
2278 XVaNestedList attr;
2279 XPoint spot;
2281 spot.x = WINDOW_TO_FRAME_PIXEL_X (w, x) + WINDOW_LEFT_FRINGE_WIDTH (w);
2282 spot.y = WINDOW_TO_FRAME_PIXEL_Y (w, y) + FONT_BASE (FRAME_FONT (f));
2283 attr = XVaCreateNestedList (0, XNSpotLocation, &spot, NULL);
2284 XSetICValues (FRAME_XIC (f), XNPreeditAttributes, attr, NULL);
2285 XFree (attr);
2289 /* Place status area for XIC in bottom right corner of frame F.. */
2291 void
2292 xic_set_statusarea (struct frame *f)
2294 XIC xic = FRAME_XIC (f);
2295 XVaNestedList attr;
2296 XRectangle area;
2297 XRectangle *needed;
2299 /* Negotiate geometry of status area. If input method has existing
2300 status area, use its current size. */
2301 area.x = area.y = area.width = area.height = 0;
2302 attr = XVaCreateNestedList (0, XNAreaNeeded, &area, NULL);
2303 XSetICValues (xic, XNStatusAttributes, attr, NULL);
2304 XFree (attr);
2306 attr = XVaCreateNestedList (0, XNAreaNeeded, &needed, NULL);
2307 XGetICValues (xic, XNStatusAttributes, attr, NULL);
2308 XFree (attr);
2310 if (needed->width == 0) /* Use XNArea instead of XNAreaNeeded */
2312 attr = XVaCreateNestedList (0, XNArea, &needed, NULL);
2313 XGetICValues (xic, XNStatusAttributes, attr, NULL);
2314 XFree (attr);
2317 area.width = needed->width;
2318 area.height = needed->height;
2319 area.x = FRAME_PIXEL_WIDTH (f) - area.width - FRAME_INTERNAL_BORDER_WIDTH (f);
2320 area.y = (FRAME_PIXEL_HEIGHT (f) - area.height
2321 - FRAME_MENUBAR_HEIGHT (f)
2322 - FRAME_TOOLBAR_TOP_HEIGHT (f)
2323 - FRAME_INTERNAL_BORDER_WIDTH (f));
2324 XFree (needed);
2326 attr = XVaCreateNestedList (0, XNArea, &area, NULL);
2327 XSetICValues (xic, XNStatusAttributes, attr, NULL);
2328 XFree (attr);
2332 /* Set X fontset for XIC of frame F, using base font name
2333 BASE_FONTNAME. Called when a new Emacs fontset is chosen. */
2335 void
2336 xic_set_xfontset (struct frame *f, const char *base_fontname)
2338 XVaNestedList attr;
2339 XFontSet xfs;
2341 xic_free_xfontset (f);
2343 xfs = xic_create_xfontset (f);
2345 attr = XVaCreateNestedList (0, XNFontSet, xfs, NULL);
2346 if (FRAME_XIC_STYLE (f) & XIMPreeditPosition)
2347 XSetICValues (FRAME_XIC (f), XNPreeditAttributes, attr, NULL);
2348 if (FRAME_XIC_STYLE (f) & XIMStatusArea)
2349 XSetICValues (FRAME_XIC (f), XNStatusAttributes, attr, NULL);
2350 XFree (attr);
2352 FRAME_XIC_FONTSET (f) = xfs;
2355 #endif /* HAVE_X_I18N */
2359 #ifdef USE_X_TOOLKIT
2361 /* Create and set up the X widget for frame F. */
2363 static void
2364 x_window (struct frame *f, long window_prompting, int minibuffer_only)
2366 XClassHint class_hints;
2367 XSetWindowAttributes attributes;
2368 unsigned long attribute_mask;
2369 Widget shell_widget;
2370 Widget pane_widget;
2371 Widget frame_widget;
2372 Arg al [25];
2373 int ac;
2375 BLOCK_INPUT;
2377 /* Use the resource name as the top-level widget name
2378 for looking up resources. Make a non-Lisp copy
2379 for the window manager, so GC relocation won't bother it.
2381 Elsewhere we specify the window name for the window manager. */
2384 char *str = SSDATA (Vx_resource_name);
2385 f->namebuf = (char *) xmalloc (strlen (str) + 1);
2386 strcpy (f->namebuf, str);
2389 ac = 0;
2390 XtSetArg (al[ac], XtNallowShellResize, 1); ac++;
2391 XtSetArg (al[ac], XtNinput, 1); ac++;
2392 XtSetArg (al[ac], XtNmappedWhenManaged, 0); ac++;
2393 XtSetArg (al[ac], XtNborderWidth, f->border_width); ac++;
2394 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2395 XtSetArg (al[ac], XtNdepth, FRAME_X_DISPLAY_INFO (f)->n_planes); ac++;
2396 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2397 shell_widget = XtAppCreateShell (f->namebuf, EMACS_CLASS,
2398 applicationShellWidgetClass,
2399 FRAME_X_DISPLAY (f), al, ac);
2401 f->output_data.x->widget = shell_widget;
2402 /* maybe_set_screen_title_format (shell_widget); */
2404 pane_widget = lw_create_widget ("main", "pane", widget_id_tick++,
2405 (widget_value *) NULL,
2406 shell_widget, False,
2407 (lw_callback) NULL,
2408 (lw_callback) NULL,
2409 (lw_callback) NULL,
2410 (lw_callback) NULL);
2412 ac = 0;
2413 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2414 XtSetArg (al[ac], XtNdepth, FRAME_X_DISPLAY_INFO (f)->n_planes); ac++;
2415 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2416 XtSetArg (al[ac], XtNborderWidth, 0); ac++;
2417 XtSetValues (pane_widget, al, ac);
2418 f->output_data.x->column_widget = pane_widget;
2420 /* mappedWhenManaged to false tells to the paned window to not map/unmap
2421 the emacs screen when changing menubar. This reduces flickering. */
2423 ac = 0;
2424 XtSetArg (al[ac], XtNmappedWhenManaged, 0); ac++;
2425 XtSetArg (al[ac], XtNshowGrip, 0); ac++;
2426 XtSetArg (al[ac], XtNallowResize, 1); ac++;
2427 XtSetArg (al[ac], XtNresizeToPreferred, 1); ac++;
2428 XtSetArg (al[ac], XtNemacsFrame, f); ac++;
2429 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2430 XtSetArg (al[ac], XtNdepth, FRAME_X_DISPLAY_INFO (f)->n_planes); ac++;
2431 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2432 XtSetArg (al[ac], XtNborderWidth, 0); ac++;
2433 frame_widget = XtCreateWidget (f->namebuf, emacsFrameClass, pane_widget,
2434 al, ac);
2436 f->output_data.x->edit_widget = frame_widget;
2438 XtManageChild (frame_widget);
2440 /* Do some needed geometry management. */
2442 ptrdiff_t len;
2443 char *tem, shell_position[sizeof "=x++" + 4 * INT_STRLEN_BOUND (int)];
2444 Arg gal[10];
2445 int gac = 0;
2446 int extra_borders = 0;
2447 int menubar_size
2448 = (f->output_data.x->menubar_widget
2449 ? (f->output_data.x->menubar_widget->core.height
2450 + f->output_data.x->menubar_widget->core.border_width)
2451 : 0);
2453 #if 0 /* Experimentally, we now get the right results
2454 for -geometry -0-0 without this. 24 Aug 96, rms. */
2455 if (FRAME_EXTERNAL_MENU_BAR (f))
2457 Dimension ibw = 0;
2458 XtVaGetValues (pane_widget, XtNinternalBorderWidth, &ibw, NULL);
2459 menubar_size += ibw;
2461 #endif
2463 f->output_data.x->menubar_height = menubar_size;
2465 #ifndef USE_LUCID
2466 /* Motif seems to need this amount added to the sizes
2467 specified for the shell widget. The Athena/Lucid widgets don't.
2468 Both conclusions reached experimentally. -- rms. */
2469 XtVaGetValues (f->output_data.x->edit_widget, XtNinternalBorderWidth,
2470 &extra_borders, NULL);
2471 extra_borders *= 2;
2472 #endif
2474 /* Convert our geometry parameters into a geometry string
2475 and specify it.
2476 Note that we do not specify here whether the position
2477 is a user-specified or program-specified one.
2478 We pass that information later, in x_wm_set_size_hints. */
2480 int left = f->left_pos;
2481 int xneg = window_prompting & XNegative;
2482 int top = f->top_pos;
2483 int yneg = window_prompting & YNegative;
2484 if (xneg)
2485 left = -left;
2486 if (yneg)
2487 top = -top;
2489 if (window_prompting & USPosition)
2490 sprintf (shell_position, "=%dx%d%c%d%c%d",
2491 FRAME_PIXEL_WIDTH (f) + extra_borders,
2492 FRAME_PIXEL_HEIGHT (f) + menubar_size + extra_borders,
2493 (xneg ? '-' : '+'), left,
2494 (yneg ? '-' : '+'), top);
2495 else
2497 sprintf (shell_position, "=%dx%d",
2498 FRAME_PIXEL_WIDTH (f) + extra_borders,
2499 FRAME_PIXEL_HEIGHT (f) + menubar_size + extra_borders);
2501 /* Setting x and y when the position is not specified in
2502 the geometry string will set program position in the WM hints.
2503 If Emacs had just one program position, we could set it in
2504 fallback resources, but since each make-frame call can specify
2505 different program positions, this is easier. */
2506 XtSetArg (gal[gac], XtNx, left); gac++;
2507 XtSetArg (gal[gac], XtNy, top); gac++;
2511 len = strlen (shell_position) + 1;
2512 /* We don't free this because we don't know whether
2513 it is safe to free it while the frame exists.
2514 It isn't worth the trouble of arranging to free it
2515 when the frame is deleted. */
2516 tem = (char *) xmalloc (len);
2517 strncpy (tem, shell_position, len);
2518 XtSetArg (gal[gac], XtNgeometry, tem); gac++;
2519 XtSetValues (shell_widget, gal, gac);
2522 XtManageChild (pane_widget);
2523 XtRealizeWidget (shell_widget);
2525 if (FRAME_X_EMBEDDED_P (f))
2526 XReparentWindow (FRAME_X_DISPLAY (f), XtWindow (shell_widget),
2527 f->output_data.x->parent_desc, 0, 0);
2529 FRAME_X_WINDOW (f) = XtWindow (frame_widget);
2531 validate_x_resource_name ();
2533 class_hints.res_name = SSDATA (Vx_resource_name);
2534 class_hints.res_class = SSDATA (Vx_resource_class);
2535 XSetClassHint (FRAME_X_DISPLAY (f), XtWindow (shell_widget), &class_hints);
2537 #ifdef HAVE_X_I18N
2538 FRAME_XIC (f) = NULL;
2539 if (use_xim)
2540 create_frame_xic (f);
2541 #endif
2543 f->output_data.x->wm_hints.input = True;
2544 f->output_data.x->wm_hints.flags |= InputHint;
2545 XSetWMHints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2546 &f->output_data.x->wm_hints);
2548 hack_wm_protocols (f, shell_widget);
2550 #ifdef HACK_EDITRES
2551 XtAddEventHandler (shell_widget, 0, True, _XEditResCheckMessages, 0);
2552 #endif
2554 /* Do a stupid property change to force the server to generate a
2555 PropertyNotify event so that the event_stream server timestamp will
2556 be initialized to something relevant to the time we created the window.
2558 XChangeProperty (XtDisplay (frame_widget), XtWindow (frame_widget),
2559 FRAME_X_DISPLAY_INFO (f)->Xatom_wm_protocols,
2560 XA_ATOM, 32, PropModeAppend,
2561 (unsigned char*) NULL, 0);
2563 /* Make all the standard events reach the Emacs frame. */
2564 attributes.event_mask = STANDARD_EVENT_SET;
2566 #ifdef HAVE_X_I18N
2567 if (FRAME_XIC (f))
2569 /* XIM server might require some X events. */
2570 unsigned long fevent = NoEventMask;
2571 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2572 attributes.event_mask |= fevent;
2574 #endif /* HAVE_X_I18N */
2576 attribute_mask = CWEventMask;
2577 XChangeWindowAttributes (XtDisplay (shell_widget), XtWindow (shell_widget),
2578 attribute_mask, &attributes);
2580 XtMapWidget (frame_widget);
2582 /* x_set_name normally ignores requests to set the name if the
2583 requested name is the same as the current name. This is the one
2584 place where that assumption isn't correct; f->name is set, but
2585 the X server hasn't been told. */
2587 Lisp_Object name;
2588 int explicit = f->explicit_name;
2590 f->explicit_name = 0;
2591 name = f->name;
2592 f->name = Qnil;
2593 x_set_name (f, name, explicit);
2596 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2597 f->output_data.x->current_cursor
2598 = f->output_data.x->text_cursor);
2600 UNBLOCK_INPUT;
2602 /* This is a no-op, except under Motif. Make sure main areas are
2603 set to something reasonable, in case we get an error later. */
2604 lw_set_main_areas (pane_widget, 0, frame_widget);
2607 #else /* not USE_X_TOOLKIT */
2608 #ifdef USE_GTK
2609 static void
2610 x_window (FRAME_PTR f)
2612 if (! xg_create_frame_widgets (f))
2613 error ("Unable to create window");
2615 #ifdef HAVE_X_I18N
2616 FRAME_XIC (f) = NULL;
2617 if (use_xim)
2619 BLOCK_INPUT;
2620 create_frame_xic (f);
2621 if (FRAME_XIC (f))
2623 /* XIM server might require some X events. */
2624 unsigned long fevent = NoEventMask;
2625 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2627 if (fevent != NoEventMask)
2629 XSetWindowAttributes attributes;
2630 XWindowAttributes wattr;
2631 unsigned long attribute_mask;
2633 XGetWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2634 &wattr);
2635 attributes.event_mask = wattr.your_event_mask | fevent;
2636 attribute_mask = CWEventMask;
2637 XChangeWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2638 attribute_mask, &attributes);
2641 UNBLOCK_INPUT;
2643 #endif
2646 #else /*! USE_GTK */
2647 /* Create and set up the X window for frame F. */
2649 static void
2650 x_window (struct frame *f)
2652 XClassHint class_hints;
2653 XSetWindowAttributes attributes;
2654 unsigned long attribute_mask;
2656 attributes.background_pixel = FRAME_BACKGROUND_PIXEL (f);
2657 attributes.border_pixel = f->output_data.x->border_pixel;
2658 attributes.bit_gravity = StaticGravity;
2659 attributes.backing_store = NotUseful;
2660 attributes.save_under = True;
2661 attributes.event_mask = STANDARD_EVENT_SET;
2662 attributes.colormap = FRAME_X_COLORMAP (f);
2663 attribute_mask = (CWBackPixel | CWBorderPixel | CWBitGravity | CWEventMask
2664 | CWColormap);
2666 BLOCK_INPUT;
2667 FRAME_X_WINDOW (f)
2668 = XCreateWindow (FRAME_X_DISPLAY (f),
2669 f->output_data.x->parent_desc,
2670 f->left_pos,
2671 f->top_pos,
2672 FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f),
2673 f->border_width,
2674 CopyFromParent, /* depth */
2675 InputOutput, /* class */
2676 FRAME_X_VISUAL (f),
2677 attribute_mask, &attributes);
2679 #ifdef HAVE_X_I18N
2680 if (use_xim)
2682 create_frame_xic (f);
2683 if (FRAME_XIC (f))
2685 /* XIM server might require some X events. */
2686 unsigned long fevent = NoEventMask;
2687 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2688 attributes.event_mask |= fevent;
2689 attribute_mask = CWEventMask;
2690 XChangeWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2691 attribute_mask, &attributes);
2694 #endif /* HAVE_X_I18N */
2696 validate_x_resource_name ();
2698 class_hints.res_name = SSDATA (Vx_resource_name);
2699 class_hints.res_class = SSDATA (Vx_resource_class);
2700 XSetClassHint (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), &class_hints);
2702 /* The menubar is part of the ordinary display;
2703 it does not count in addition to the height of the window. */
2704 f->output_data.x->menubar_height = 0;
2706 /* This indicates that we use the "Passive Input" input model.
2707 Unless we do this, we don't get the Focus{In,Out} events that we
2708 need to draw the cursor correctly. Accursed bureaucrats.
2709 XWhipsAndChains (FRAME_X_DISPLAY (f), IronMaiden, &TheRack); */
2711 f->output_data.x->wm_hints.input = True;
2712 f->output_data.x->wm_hints.flags |= InputHint;
2713 XSetWMHints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2714 &f->output_data.x->wm_hints);
2715 f->output_data.x->wm_hints.icon_pixmap = None;
2717 /* Request "save yourself" and "delete window" commands from wm. */
2719 Atom protocols[2];
2720 protocols[0] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_delete_window;
2721 protocols[1] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_save_yourself;
2722 XSetWMProtocols (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), protocols, 2);
2725 /* x_set_name normally ignores requests to set the name if the
2726 requested name is the same as the current name. This is the one
2727 place where that assumption isn't correct; f->name is set, but
2728 the X server hasn't been told. */
2730 Lisp_Object name;
2731 int explicit = f->explicit_name;
2733 f->explicit_name = 0;
2734 name = f->name;
2735 f->name = Qnil;
2736 x_set_name (f, name, explicit);
2739 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2740 f->output_data.x->current_cursor
2741 = f->output_data.x->text_cursor);
2743 UNBLOCK_INPUT;
2745 if (FRAME_X_WINDOW (f) == 0)
2746 error ("Unable to create window");
2749 #endif /* not USE_GTK */
2750 #endif /* not USE_X_TOOLKIT */
2752 /* Verify that the icon position args for this window are valid. */
2754 static void
2755 x_icon_verify (struct frame *f, Lisp_Object parms)
2757 Lisp_Object icon_x, icon_y;
2759 /* Set the position of the icon. Note that twm groups all
2760 icons in an icon window. */
2761 icon_x = x_frame_get_and_record_arg (f, parms, Qicon_left, 0, 0, RES_TYPE_NUMBER);
2762 icon_y = x_frame_get_and_record_arg (f, parms, Qicon_top, 0, 0, RES_TYPE_NUMBER);
2763 if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
2765 CHECK_NUMBER (icon_x);
2766 CHECK_NUMBER (icon_y);
2768 else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
2769 error ("Both left and top icon corners of icon must be specified");
2772 /* Handle the icon stuff for this window. Perhaps later we might
2773 want an x_set_icon_position which can be called interactively as
2774 well. */
2776 static void
2777 x_icon (struct frame *f, Lisp_Object parms)
2779 Lisp_Object icon_x, icon_y;
2780 #if 0
2781 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
2782 #endif
2784 /* Set the position of the icon. Note that twm groups all
2785 icons in an icon window. */
2786 icon_x = x_frame_get_and_record_arg (f, parms, Qicon_left, 0, 0, RES_TYPE_NUMBER);
2787 icon_y = x_frame_get_and_record_arg (f, parms, Qicon_top, 0, 0, RES_TYPE_NUMBER);
2788 if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
2790 CHECK_NUMBER (icon_x);
2791 CHECK_NUMBER (icon_y);
2793 else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
2794 error ("Both left and top icon corners of icon must be specified");
2796 BLOCK_INPUT;
2798 if (! EQ (icon_x, Qunbound))
2799 x_wm_set_icon_position (f, XINT (icon_x), XINT (icon_y));
2801 #if 0 /* x_get_arg removes the visibility parameter as a side effect,
2802 but x_create_frame still needs it. */
2803 /* Start up iconic or window? */
2804 x_wm_set_window_state
2805 (f, (EQ (x_get_arg (dpyinfo, parms, Qvisibility, 0, 0, RES_TYPE_SYMBOL),
2806 Qicon)
2807 ? IconicState
2808 : NormalState));
2809 #endif
2811 x_text_icon (f, SSDATA ((!NILP (f->icon_name)
2812 ? f->icon_name
2813 : f->name)));
2815 UNBLOCK_INPUT;
2818 /* Make the GCs needed for this window, setting the
2819 background, border and mouse colors; also create the
2820 mouse cursor and the gray border tile. */
2822 static void
2823 x_make_gc (struct frame *f)
2825 XGCValues gc_values;
2827 BLOCK_INPUT;
2829 /* Create the GCs of this frame.
2830 Note that many default values are used. */
2832 gc_values.foreground = FRAME_FOREGROUND_PIXEL (f);
2833 gc_values.background = FRAME_BACKGROUND_PIXEL (f);
2834 gc_values.line_width = 0; /* Means 1 using fast algorithm. */
2835 f->output_data.x->normal_gc
2836 = XCreateGC (FRAME_X_DISPLAY (f),
2837 FRAME_X_WINDOW (f),
2838 GCLineWidth | GCForeground | GCBackground,
2839 &gc_values);
2841 /* Reverse video style. */
2842 gc_values.foreground = FRAME_BACKGROUND_PIXEL (f);
2843 gc_values.background = FRAME_FOREGROUND_PIXEL (f);
2844 f->output_data.x->reverse_gc
2845 = XCreateGC (FRAME_X_DISPLAY (f),
2846 FRAME_X_WINDOW (f),
2847 GCForeground | GCBackground | GCLineWidth,
2848 &gc_values);
2850 /* Cursor has cursor-color background, background-color foreground. */
2851 gc_values.foreground = FRAME_BACKGROUND_PIXEL (f);
2852 gc_values.background = f->output_data.x->cursor_pixel;
2853 gc_values.fill_style = FillOpaqueStippled;
2854 f->output_data.x->cursor_gc
2855 = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2856 (GCForeground | GCBackground
2857 | GCFillStyle | GCLineWidth),
2858 &gc_values);
2860 /* Reliefs. */
2861 f->output_data.x->white_relief.gc = 0;
2862 f->output_data.x->black_relief.gc = 0;
2864 /* Create the gray border tile used when the pointer is not in
2865 the frame. Since this depends on the frame's pixel values,
2866 this must be done on a per-frame basis. */
2867 f->output_data.x->border_tile
2868 = (XCreatePixmapFromBitmapData
2869 (FRAME_X_DISPLAY (f), FRAME_X_DISPLAY_INFO (f)->root_window,
2870 gray_bits, gray_width, gray_height,
2871 FRAME_FOREGROUND_PIXEL (f),
2872 FRAME_BACKGROUND_PIXEL (f),
2873 DefaultDepth (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f))));
2875 UNBLOCK_INPUT;
2879 /* Free what was allocated in x_make_gc. */
2881 void
2882 x_free_gcs (struct frame *f)
2884 Display *dpy = FRAME_X_DISPLAY (f);
2886 BLOCK_INPUT;
2888 if (f->output_data.x->normal_gc)
2890 XFreeGC (dpy, f->output_data.x->normal_gc);
2891 f->output_data.x->normal_gc = 0;
2894 if (f->output_data.x->reverse_gc)
2896 XFreeGC (dpy, f->output_data.x->reverse_gc);
2897 f->output_data.x->reverse_gc = 0;
2900 if (f->output_data.x->cursor_gc)
2902 XFreeGC (dpy, f->output_data.x->cursor_gc);
2903 f->output_data.x->cursor_gc = 0;
2906 if (f->output_data.x->border_tile)
2908 XFreePixmap (dpy, f->output_data.x->border_tile);
2909 f->output_data.x->border_tile = 0;
2912 UNBLOCK_INPUT;
2916 /* Handler for signals raised during x_create_frame and
2917 x_create_tip_frame. FRAME is the frame which is partially
2918 constructed. */
2920 static Lisp_Object
2921 unwind_create_frame (Lisp_Object frame)
2923 struct frame *f = XFRAME (frame);
2925 /* If frame is already dead, nothing to do. This can happen if the
2926 display is disconnected after the frame has become official, but
2927 before x_create_frame removes the unwind protect. */
2928 if (!FRAME_LIVE_P (f))
2929 return Qnil;
2931 /* If frame is ``official'', nothing to do. */
2932 if (NILP (Fmemq (frame, Vframe_list)))
2934 #if GLYPH_DEBUG && XASSERTS
2935 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
2936 #endif
2938 x_free_frame_resources (f);
2939 free_glyphs (f);
2941 #if GLYPH_DEBUG
2942 /* Check that reference counts are indeed correct. */
2943 xassert (dpyinfo->reference_count == dpyinfo_refcount);
2944 xassert (dpyinfo->terminal->image_cache->refcount == image_cache_refcount);
2945 #endif
2946 return Qt;
2949 return Qnil;
2952 static Lisp_Object
2953 unwind_create_frame_1 (Lisp_Object val)
2955 inhibit_lisp_code = val;
2956 return Qnil;
2959 static void
2960 x_default_font_parameter (struct frame *f, Lisp_Object parms)
2962 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
2963 Lisp_Object font_param = x_get_arg (dpyinfo, parms, Qfont, NULL, NULL,
2964 RES_TYPE_STRING);
2965 Lisp_Object font = Qnil;
2966 if (EQ (font_param, Qunbound))
2967 font_param = Qnil;
2969 if (NILP (font_param))
2971 /* System font should take precedence over X resources. We suggest this
2972 regardless of font-use-system-font because .emacs may not have been
2973 read yet. */
2974 const char *system_font = xsettings_get_system_font ();
2975 if (system_font)
2977 char *name = xstrdup (system_font);
2978 font = font_open_by_name (f, name);
2979 xfree (name);
2983 if (NILP (font))
2984 font = !NILP (font_param) ? font_param
2985 : x_get_arg (dpyinfo, parms, Qfont, "font", "Font", RES_TYPE_STRING);
2987 if (! FONTP (font) && ! STRINGP (font))
2989 const char *names[]
2991 #ifdef HAVE_XFT
2992 /* This will find the normal Xft font. */
2993 "monospace-10",
2994 #endif
2995 "-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1",
2996 "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1",
2997 "-*-*-medium-r-normal-*-*-140-*-*-c-*-iso8859-1",
2998 /* This was formerly the first thing tried, but it finds
2999 too many fonts and takes too long. */
3000 "-*-*-medium-r-*-*-*-*-*-*-c-*-iso8859-1",
3001 /* If those didn't work, look for something which will
3002 at least work. */
3003 "-*-fixed-*-*-*-*-*-140-*-*-c-*-iso8859-1",
3004 "fixed",
3005 NULL };
3006 int i;
3008 for (i = 0; names[i]; i++)
3010 font = font_open_by_name (f, names[i]);
3011 if (! NILP (font))
3012 break;
3014 if (NILP (font))
3015 error ("No suitable font was found");
3017 else if (!NILP (font_param))
3019 /* Remember the explicit font parameter, so we can re-apply it after
3020 we've applied the `default' face settings. */
3021 x_set_frame_parameters (f, Fcons (Fcons (Qfont_param, font_param), Qnil));
3024 /* This call will make X resources override any system font setting. */
3025 x_default_parameter (f, parms, Qfont, font, "font", "Font", RES_TYPE_STRING);
3029 DEFUN ("x-wm-set-size-hint", Fx_wm_set_size_hint, Sx_wm_set_size_hint,
3030 0, 1, 0,
3031 doc: /* Send the size hints for frame FRAME to the window manager.
3032 If FRAME is nil, use the selected frame. */)
3033 (Lisp_Object frame)
3035 struct frame *f;
3036 if (NILP (frame))
3037 frame = selected_frame;
3038 f = XFRAME (frame);
3039 BLOCK_INPUT;
3040 if (FRAME_X_P (f))
3041 x_wm_set_size_hint (f, 0, 0);
3042 UNBLOCK_INPUT;
3043 return Qnil;
3046 static void
3047 set_machine_and_pid_properties (struct frame *f)
3049 long pid = (long) getpid ();
3051 /* This will set WM_CLIENT_MACHINE and WM_LOCALE_NAME. */
3052 XSetWMProperties (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), NULL, NULL,
3053 NULL, 0, NULL, NULL, NULL);
3054 XChangeProperty (FRAME_X_DISPLAY (f),
3055 FRAME_OUTER_WINDOW (f),
3056 XInternAtom (FRAME_X_DISPLAY (f),
3057 "_NET_WM_PID",
3058 False),
3059 XA_CARDINAL, 32, PropModeReplace,
3060 (unsigned char *) &pid, 1);
3063 DEFUN ("x-create-frame", Fx_create_frame, Sx_create_frame,
3064 1, 1, 0,
3065 doc: /* Make a new X window, which is called a "frame" in Emacs terms.
3066 Return an Emacs frame object.
3067 PARMS is an alist of frame parameters.
3068 If the parameters specify that the frame should not have a minibuffer,
3069 and do not specify a specific minibuffer window to use,
3070 then `default-minibuffer-frame' must be a frame whose minibuffer can
3071 be shared by the new frame.
3073 This function is an internal primitive--use `make-frame' instead. */)
3074 (Lisp_Object parms)
3076 struct frame *f;
3077 Lisp_Object frame, tem;
3078 Lisp_Object name;
3079 int minibuffer_only = 0;
3080 long window_prompting = 0;
3081 int width, height;
3082 int count = SPECPDL_INDEX ();
3083 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
3084 Lisp_Object display;
3085 struct x_display_info *dpyinfo = NULL;
3086 Lisp_Object parent;
3087 struct kboard *kb;
3089 parms = Fcopy_alist (parms);
3091 /* Use this general default value to start with
3092 until we know if this frame has a specified name. */
3093 Vx_resource_name = Vinvocation_name;
3095 display = x_get_arg (dpyinfo, parms, Qterminal, 0, 0, RES_TYPE_NUMBER);
3096 if (EQ (display, Qunbound))
3097 display = x_get_arg (dpyinfo, parms, Qdisplay, 0, 0, RES_TYPE_STRING);
3098 if (EQ (display, Qunbound))
3099 display = Qnil;
3100 dpyinfo = check_x_display_info (display);
3101 kb = dpyinfo->terminal->kboard;
3103 if (!dpyinfo->terminal->name)
3104 error ("Terminal is not live, can't create new frames on it");
3106 name = x_get_arg (dpyinfo, parms, Qname, "name", "Name", RES_TYPE_STRING);
3107 if (!STRINGP (name)
3108 && ! EQ (name, Qunbound)
3109 && ! NILP (name))
3110 error ("Invalid frame name--not a string or nil");
3112 if (STRINGP (name))
3113 Vx_resource_name = name;
3115 /* See if parent window is specified. */
3116 parent = x_get_arg (dpyinfo, parms, Qparent_id, NULL, NULL, RES_TYPE_NUMBER);
3117 if (EQ (parent, Qunbound))
3118 parent = Qnil;
3119 if (! NILP (parent))
3120 CHECK_NUMBER (parent);
3122 /* make_frame_without_minibuffer can run Lisp code and garbage collect. */
3123 /* No need to protect DISPLAY because that's not used after passing
3124 it to make_frame_without_minibuffer. */
3125 frame = Qnil;
3126 GCPRO4 (parms, parent, name, frame);
3127 tem = x_get_arg (dpyinfo, parms, Qminibuffer, "minibuffer", "Minibuffer",
3128 RES_TYPE_SYMBOL);
3129 if (EQ (tem, Qnone) || NILP (tem))
3130 f = make_frame_without_minibuffer (Qnil, kb, display);
3131 else if (EQ (tem, Qonly))
3133 f = make_minibuffer_frame ();
3134 minibuffer_only = 1;
3136 else if (WINDOWP (tem))
3137 f = make_frame_without_minibuffer (tem, kb, display);
3138 else
3139 f = make_frame (1);
3141 XSETFRAME (frame, f);
3143 /* Note that X Windows does support scroll bars. */
3144 FRAME_CAN_HAVE_SCROLL_BARS (f) = 1;
3146 f->terminal = dpyinfo->terminal;
3148 f->output_method = output_x_window;
3149 f->output_data.x = (struct x_output *) xmalloc (sizeof (struct x_output));
3150 memset (f->output_data.x, 0, sizeof (struct x_output));
3151 f->output_data.x->icon_bitmap = -1;
3152 FRAME_FONTSET (f) = -1;
3153 f->output_data.x->scroll_bar_foreground_pixel = -1;
3154 f->output_data.x->scroll_bar_background_pixel = -1;
3155 #ifdef USE_TOOLKIT_SCROLL_BARS
3156 f->output_data.x->scroll_bar_top_shadow_pixel = -1;
3157 f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
3158 #endif /* USE_TOOLKIT_SCROLL_BARS */
3160 f->icon_name
3161 = x_get_arg (dpyinfo, parms, Qicon_name, "iconName", "Title",
3162 RES_TYPE_STRING);
3163 if (! STRINGP (f->icon_name))
3164 f->icon_name = Qnil;
3166 FRAME_X_DISPLAY_INFO (f) = dpyinfo;
3168 /* With FRAME_X_DISPLAY_INFO set up, this unwind-protect is safe. */
3169 record_unwind_protect (unwind_create_frame, frame);
3171 /* These colors will be set anyway later, but it's important
3172 to get the color reference counts right, so initialize them! */
3174 Lisp_Object black;
3175 struct gcpro gcpro1;
3177 /* Function x_decode_color can signal an error. Make
3178 sure to initialize color slots so that we won't try
3179 to free colors we haven't allocated. */
3180 FRAME_FOREGROUND_PIXEL (f) = -1;
3181 FRAME_BACKGROUND_PIXEL (f) = -1;
3182 f->output_data.x->cursor_pixel = -1;
3183 f->output_data.x->cursor_foreground_pixel = -1;
3184 f->output_data.x->border_pixel = -1;
3185 f->output_data.x->mouse_pixel = -1;
3187 black = build_string ("black");
3188 GCPRO1 (black);
3189 FRAME_FOREGROUND_PIXEL (f)
3190 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3191 FRAME_BACKGROUND_PIXEL (f)
3192 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3193 f->output_data.x->cursor_pixel
3194 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3195 f->output_data.x->cursor_foreground_pixel
3196 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3197 f->output_data.x->border_pixel
3198 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3199 f->output_data.x->mouse_pixel
3200 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3201 UNGCPRO;
3204 /* Specify the parent under which to make this X window. */
3206 if (!NILP (parent))
3208 f->output_data.x->parent_desc = (Window) XFASTINT (parent);
3209 f->output_data.x->explicit_parent = 1;
3211 else
3213 f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
3214 f->output_data.x->explicit_parent = 0;
3217 /* Set the name; the functions to which we pass f expect the name to
3218 be set. */
3219 if (EQ (name, Qunbound) || NILP (name))
3221 f->name = build_string (dpyinfo->x_id_name);
3222 f->explicit_name = 0;
3224 else
3226 f->name = name;
3227 f->explicit_name = 1;
3228 /* use the frame's title when getting resources for this frame. */
3229 specbind (Qx_resource_name, name);
3232 f->resx = dpyinfo->resx;
3233 f->resy = dpyinfo->resy;
3235 #ifdef HAVE_FREETYPE
3236 #ifdef HAVE_XFT
3237 register_font_driver (&xftfont_driver, f);
3238 #else /* not HAVE_XFT */
3239 register_font_driver (&ftxfont_driver, f);
3240 #endif /* not HAVE_XFT */
3241 #endif /* HAVE_FREETYPE */
3242 register_font_driver (&xfont_driver, f);
3244 x_default_parameter (f, parms, Qfont_backend, Qnil,
3245 "fontBackend", "FontBackend", RES_TYPE_STRING);
3247 /* Extract the window parameters from the supplied values
3248 that are needed to determine window geometry. */
3249 x_default_font_parameter (f, parms);
3250 if (!FRAME_FONT (f))
3252 delete_frame (frame, Qnoelisp);
3253 error ("Invalid frame font");
3256 /* Frame contents get displaced if an embedded X window has a border. */
3257 if (! FRAME_X_EMBEDDED_P (f))
3258 x_default_parameter (f, parms, Qborder_width, make_number (0),
3259 "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
3261 /* This defaults to 1 in order to match xterm. We recognize either
3262 internalBorderWidth or internalBorder (which is what xterm calls
3263 it). */
3264 if (NILP (Fassq (Qinternal_border_width, parms)))
3266 Lisp_Object value;
3268 value = x_get_arg (dpyinfo, parms, Qinternal_border_width,
3269 "internalBorder", "internalBorder", RES_TYPE_NUMBER);
3270 if (! EQ (value, Qunbound))
3271 parms = Fcons (Fcons (Qinternal_border_width, value),
3272 parms);
3274 x_default_parameter (f, parms, Qinternal_border_width,
3275 #ifdef USE_GTK /* We used to impose 0 in xg_create_frame_widgets. */
3276 make_number (0),
3277 #else
3278 make_number (1),
3279 #endif
3280 "internalBorderWidth", "internalBorderWidth",
3281 RES_TYPE_NUMBER);
3282 x_default_parameter (f, parms, Qvertical_scroll_bars,
3283 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
3284 Qright,
3285 #else
3286 Qleft,
3287 #endif
3288 "verticalScrollBars", "ScrollBars",
3289 RES_TYPE_SYMBOL);
3291 /* Also do the stuff which must be set before the window exists. */
3292 x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
3293 "foreground", "Foreground", RES_TYPE_STRING);
3294 x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
3295 "background", "Background", RES_TYPE_STRING);
3296 x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
3297 "pointerColor", "Foreground", RES_TYPE_STRING);
3298 x_default_parameter (f, parms, Qborder_color, build_string ("black"),
3299 "borderColor", "BorderColor", RES_TYPE_STRING);
3300 x_default_parameter (f, parms, Qscreen_gamma, Qnil,
3301 "screenGamma", "ScreenGamma", RES_TYPE_FLOAT);
3302 x_default_parameter (f, parms, Qline_spacing, Qnil,
3303 "lineSpacing", "LineSpacing", RES_TYPE_NUMBER);
3304 x_default_parameter (f, parms, Qleft_fringe, Qnil,
3305 "leftFringe", "LeftFringe", RES_TYPE_NUMBER);
3306 x_default_parameter (f, parms, Qright_fringe, Qnil,
3307 "rightFringe", "RightFringe", RES_TYPE_NUMBER);
3309 x_default_scroll_bar_color_parameter (f, parms, Qscroll_bar_foreground,
3310 "scrollBarForeground",
3311 "ScrollBarForeground", 1);
3312 x_default_scroll_bar_color_parameter (f, parms, Qscroll_bar_background,
3313 "scrollBarBackground",
3314 "ScrollBarBackground", 0);
3316 #if GLYPH_DEBUG
3317 image_cache_refcount =
3318 FRAME_IMAGE_CACHE (f) ? FRAME_IMAGE_CACHE (f)->refcount : 0;
3319 dpyinfo_refcount = dpyinfo->reference_count;
3320 #endif /* GLYPH_DEBUG */
3322 /* Init faces before x_default_parameter is called for scroll-bar
3323 parameters because that function calls x_set_scroll_bar_width,
3324 which calls change_frame_size, which calls Fset_window_buffer,
3325 which runs hooks, which call Fvertical_motion. At the end, we
3326 end up in init_iterator with a null face cache, which should not
3327 happen. */
3328 init_frame_faces (f);
3330 /* Set the menu-bar-lines and tool-bar-lines parameters. We don't
3331 look up the X resources controlling the menu-bar and tool-bar
3332 here; they are processed specially at startup, and reflected in
3333 the values of the mode variables.
3335 Avoid calling window-configuration-change-hook; otherwise we
3336 could get an infloop in next_frame since the frame is not yet in
3337 Vframe_list. */
3339 int count2 = SPECPDL_INDEX ();
3340 record_unwind_protect (unwind_create_frame_1, inhibit_lisp_code);
3341 inhibit_lisp_code = Qt;
3343 x_default_parameter (f, parms, Qmenu_bar_lines,
3344 NILP (Vmenu_bar_mode)
3345 ? make_number (0) : make_number (1),
3346 NULL, NULL, RES_TYPE_NUMBER);
3347 x_default_parameter (f, parms, Qtool_bar_lines,
3348 NILP (Vtool_bar_mode)
3349 ? make_number (0) : make_number (1),
3350 NULL, NULL, RES_TYPE_NUMBER);
3352 unbind_to (count2, Qnil);
3355 x_default_parameter (f, parms, Qbuffer_predicate, Qnil,
3356 "bufferPredicate", "BufferPredicate",
3357 RES_TYPE_SYMBOL);
3358 x_default_parameter (f, parms, Qtitle, Qnil,
3359 "title", "Title", RES_TYPE_STRING);
3360 x_default_parameter (f, parms, Qwait_for_wm, Qt,
3361 "waitForWM", "WaitForWM", RES_TYPE_BOOLEAN);
3362 x_default_parameter (f, parms, Qfullscreen, Qnil,
3363 "fullscreen", "Fullscreen", RES_TYPE_SYMBOL);
3364 x_default_parameter (f, parms, Qtool_bar_position,
3365 f->tool_bar_position, 0, 0, RES_TYPE_SYMBOL);
3367 /* Compute the size of the X window. */
3368 window_prompting = x_figure_window_size (f, parms, 1);
3370 tem = x_get_arg (dpyinfo, parms, Qunsplittable, 0, 0, RES_TYPE_BOOLEAN);
3371 f->no_split = minibuffer_only || EQ (tem, Qt);
3373 x_icon_verify (f, parms);
3375 /* Create the X widget or window. */
3376 #ifdef USE_X_TOOLKIT
3377 x_window (f, window_prompting, minibuffer_only);
3378 #else
3379 x_window (f);
3380 #endif
3382 x_icon (f, parms);
3383 x_make_gc (f);
3385 /* Now consider the frame official. */
3386 f->terminal->reference_count++;
3387 FRAME_X_DISPLAY_INFO (f)->reference_count++;
3388 Vframe_list = Fcons (frame, Vframe_list);
3390 /* We need to do this after creating the X window, so that the
3391 icon-creation functions can say whose icon they're describing. */
3392 x_default_parameter (f, parms, Qicon_type, Qt,
3393 "bitmapIcon", "BitmapIcon", RES_TYPE_BOOLEAN);
3395 x_default_parameter (f, parms, Qauto_raise, Qnil,
3396 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
3397 x_default_parameter (f, parms, Qauto_lower, Qnil,
3398 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
3399 x_default_parameter (f, parms, Qcursor_type, Qbox,
3400 "cursorType", "CursorType", RES_TYPE_SYMBOL);
3401 x_default_parameter (f, parms, Qscroll_bar_width, Qnil,
3402 "scrollBarWidth", "ScrollBarWidth",
3403 RES_TYPE_NUMBER);
3404 x_default_parameter (f, parms, Qalpha, Qnil,
3405 "alpha", "Alpha", RES_TYPE_NUMBER);
3407 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
3408 Change will not be effected unless different from the current
3409 FRAME_LINES (f). */
3410 width = FRAME_COLS (f);
3411 height = FRAME_LINES (f);
3413 SET_FRAME_COLS (f, 0);
3414 FRAME_LINES (f) = 0;
3415 change_frame_size (f, height, width, 1, 0, 0);
3417 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
3418 /* Create the menu bar. */
3419 if (!minibuffer_only && FRAME_EXTERNAL_MENU_BAR (f))
3421 /* If this signals an error, we haven't set size hints for the
3422 frame and we didn't make it visible. */
3423 initialize_frame_menubar (f);
3425 #ifndef USE_GTK
3426 /* This is a no-op, except under Motif where it arranges the
3427 main window for the widgets on it. */
3428 lw_set_main_areas (f->output_data.x->column_widget,
3429 f->output_data.x->menubar_widget,
3430 f->output_data.x->edit_widget);
3431 #endif /* not USE_GTK */
3433 #endif /* USE_X_TOOLKIT || USE_GTK */
3435 /* Tell the server what size and position, etc, we want, and how
3436 badly we want them. This should be done after we have the menu
3437 bar so that its size can be taken into account. */
3438 BLOCK_INPUT;
3439 x_wm_set_size_hint (f, window_prompting, 0);
3440 UNBLOCK_INPUT;
3442 /* Make the window appear on the frame and enable display, unless
3443 the caller says not to. However, with explicit parent, Emacs
3444 cannot control visibility, so don't try. */
3445 if (! f->output_data.x->explicit_parent)
3447 Lisp_Object visibility;
3449 visibility = x_get_arg (dpyinfo, parms, Qvisibility, 0, 0,
3450 RES_TYPE_SYMBOL);
3451 if (EQ (visibility, Qunbound))
3452 visibility = Qt;
3454 if (EQ (visibility, Qicon))
3455 x_iconify_frame (f);
3456 else if (! NILP (visibility))
3457 x_make_frame_visible (f);
3458 else
3460 /* Must have been Qnil. */
3464 BLOCK_INPUT;
3466 /* Set machine name and pid for the purpose of window managers. */
3467 set_machine_and_pid_properties (f);
3469 /* Set the WM leader property. GTK does this itself, so this is not
3470 needed when using GTK. */
3471 if (dpyinfo->client_leader_window != 0)
3473 XChangeProperty (FRAME_X_DISPLAY (f),
3474 FRAME_OUTER_WINDOW (f),
3475 dpyinfo->Xatom_wm_client_leader,
3476 XA_WINDOW, 32, PropModeReplace,
3477 (unsigned char *) &dpyinfo->client_leader_window, 1);
3480 UNBLOCK_INPUT;
3482 /* Initialize `default-minibuffer-frame' in case this is the first
3483 frame on this terminal. */
3484 if (FRAME_HAS_MINIBUF_P (f)
3485 && (!FRAMEP (KVAR (kb, Vdefault_minibuffer_frame))
3486 || !FRAME_LIVE_P (XFRAME (KVAR (kb, Vdefault_minibuffer_frame)))))
3487 KVAR (kb, Vdefault_minibuffer_frame) = frame;
3489 /* All remaining specified parameters, which have not been "used"
3490 by x_get_arg and friends, now go in the misc. alist of the frame. */
3491 for (tem = parms; CONSP (tem); tem = XCDR (tem))
3492 if (CONSP (XCAR (tem)) && !NILP (XCAR (XCAR (tem))))
3493 f->param_alist = Fcons (XCAR (tem), f->param_alist);
3495 UNGCPRO;
3497 /* Make sure windows on this frame appear in calls to next-window
3498 and similar functions. */
3499 Vwindow_list = Qnil;
3501 return unbind_to (count, frame);
3505 /* FRAME is used only to get a handle on the X display. We don't pass the
3506 display info directly because we're called from frame.c, which doesn't
3507 know about that structure. */
3509 Lisp_Object
3510 x_get_focus_frame (struct frame *frame)
3512 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (frame);
3513 Lisp_Object xfocus;
3514 if (! dpyinfo->x_focus_frame)
3515 return Qnil;
3517 XSETFRAME (xfocus, dpyinfo->x_focus_frame);
3518 return xfocus;
3522 /* In certain situations, when the window manager follows a
3523 click-to-focus policy, there seems to be no way around calling
3524 XSetInputFocus to give another frame the input focus .
3526 In an ideal world, XSetInputFocus should generally be avoided so
3527 that applications don't interfere with the window manager's focus
3528 policy. But I think it's okay to use when it's clearly done
3529 following a user-command. */
3531 DEFUN ("x-focus-frame", Fx_focus_frame, Sx_focus_frame, 1, 1, 0,
3532 doc: /* Set the input focus to FRAME.
3533 FRAME nil means use the selected frame. */)
3534 (Lisp_Object frame)
3536 struct frame *f = check_x_frame (frame);
3537 Display *dpy = FRAME_X_DISPLAY (f);
3539 BLOCK_INPUT;
3540 x_catch_errors (dpy);
3542 if (FRAME_X_EMBEDDED_P (f))
3544 /* For Xembedded frames, normally the embedder forwards key
3545 events. See XEmbed Protocol Specification at
3546 http://freedesktop.org/wiki/Specifications/xembed-spec */
3547 xembed_request_focus (f);
3549 else
3551 XSetInputFocus (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3552 RevertToParent, CurrentTime);
3553 x_ewmh_activate_frame (f);
3556 x_uncatch_errors ();
3557 UNBLOCK_INPUT;
3559 return Qnil;
3563 DEFUN ("xw-color-defined-p", Fxw_color_defined_p, Sxw_color_defined_p, 1, 2, 0,
3564 doc: /* Internal function called by `color-defined-p', which see
3565 .\(Note that the Nextstep version of this function ignores FRAME.) */)
3566 (Lisp_Object color, Lisp_Object frame)
3568 XColor foo;
3569 FRAME_PTR f = check_x_frame (frame);
3571 CHECK_STRING (color);
3573 if (x_defined_color (f, SSDATA (color), &foo, 0))
3574 return Qt;
3575 else
3576 return Qnil;
3579 DEFUN ("xw-color-values", Fxw_color_values, Sxw_color_values, 1, 2, 0,
3580 doc: /* Internal function called by `color-values', which see. */)
3581 (Lisp_Object color, Lisp_Object frame)
3583 XColor foo;
3584 FRAME_PTR f = check_x_frame (frame);
3586 CHECK_STRING (color);
3588 if (x_defined_color (f, SSDATA (color), &foo, 0))
3589 return list3 (make_number (foo.red),
3590 make_number (foo.green),
3591 make_number (foo.blue));
3592 else
3593 return Qnil;
3596 DEFUN ("xw-display-color-p", Fxw_display_color_p, Sxw_display_color_p, 0, 1, 0,
3597 doc: /* Internal function called by `display-color-p', which see. */)
3598 (Lisp_Object terminal)
3600 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3602 if (dpyinfo->n_planes <= 2)
3603 return Qnil;
3605 switch (dpyinfo->visual->class)
3607 case StaticColor:
3608 case PseudoColor:
3609 case TrueColor:
3610 case DirectColor:
3611 return Qt;
3613 default:
3614 return Qnil;
3618 DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p, Sx_display_grayscale_p,
3619 0, 1, 0,
3620 doc: /* Return t if the X display supports shades of gray.
3621 Note that color displays do support shades of gray.
3622 The optional argument TERMINAL specifies which display to ask about.
3623 TERMINAL should be a terminal object, a frame or a display name (a string).
3624 If omitted or nil, that stands for the selected frame's display. */)
3625 (Lisp_Object terminal)
3627 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3629 if (dpyinfo->n_planes <= 1)
3630 return Qnil;
3632 switch (dpyinfo->visual->class)
3634 case StaticColor:
3635 case PseudoColor:
3636 case TrueColor:
3637 case DirectColor:
3638 case StaticGray:
3639 case GrayScale:
3640 return Qt;
3642 default:
3643 return Qnil;
3647 DEFUN ("x-display-pixel-width", Fx_display_pixel_width, Sx_display_pixel_width,
3648 0, 1, 0,
3649 doc: /* Return the width in pixels of the X display TERMINAL.
3650 The optional argument TERMINAL specifies which display to ask about.
3651 TERMINAL should be a terminal object, a frame or a display name (a string).
3652 If omitted or nil, that stands for the selected frame's display. */)
3653 (Lisp_Object terminal)
3655 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3657 return make_number (x_display_pixel_width (dpyinfo));
3660 DEFUN ("x-display-pixel-height", Fx_display_pixel_height,
3661 Sx_display_pixel_height, 0, 1, 0,
3662 doc: /* Return the height in pixels of the X display TERMINAL.
3663 The optional argument TERMINAL specifies which display to ask about.
3664 TERMINAL should be a terminal object, a frame or a display name (a string).
3665 If omitted or nil, that stands for the selected frame's display. */)
3666 (Lisp_Object terminal)
3668 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3670 return make_number (x_display_pixel_height (dpyinfo));
3673 DEFUN ("x-display-planes", Fx_display_planes, Sx_display_planes,
3674 0, 1, 0,
3675 doc: /* Return the number of bitplanes of the X display TERMINAL.
3676 The optional argument TERMINAL specifies which display to ask about.
3677 TERMINAL should be a terminal object, a frame or a display name (a string).
3678 If omitted or nil, that stands for the selected frame's display. */)
3679 (Lisp_Object terminal)
3681 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3683 return make_number (dpyinfo->n_planes);
3686 DEFUN ("x-display-color-cells", Fx_display_color_cells, Sx_display_color_cells,
3687 0, 1, 0,
3688 doc: /* Return the number of color cells of the X display TERMINAL.
3689 The optional argument TERMINAL specifies which display to ask about.
3690 TERMINAL should be a terminal object, a frame or a display name (a string).
3691 If omitted or nil, that stands for the selected frame's display. */)
3692 (Lisp_Object terminal)
3694 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3696 int nr_planes = DisplayPlanes (dpyinfo->display,
3697 XScreenNumberOfScreen (dpyinfo->screen));
3699 /* Truncate nr_planes to 24 to avoid integer overflow.
3700 Some displays says 32, but only 24 bits are actually significant.
3701 There are only very few and rare video cards that have more than
3702 24 significant bits. Also 24 bits is more than 16 million colors,
3703 it "should be enough for everyone". */
3704 if (nr_planes > 24) nr_planes = 24;
3706 return make_number (1 << nr_planes);
3709 DEFUN ("x-server-max-request-size", Fx_server_max_request_size,
3710 Sx_server_max_request_size,
3711 0, 1, 0,
3712 doc: /* Return the maximum request size of the X server of display TERMINAL.
3713 The optional argument TERMINAL specifies which display to ask about.
3714 TERMINAL should be a terminal object, a frame or a display name (a string).
3715 If omitted or nil, that stands for the selected frame's display. */)
3716 (Lisp_Object terminal)
3718 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3720 return make_number (MAXREQUEST (dpyinfo->display));
3723 DEFUN ("x-server-vendor", Fx_server_vendor, Sx_server_vendor, 0, 1, 0,
3724 doc: /* Return the "vendor ID" string of the X server of display TERMINAL.
3725 \(Labeling every distributor as a "vendor" embodies the false assumption
3726 that operating systems cannot be developed and distributed noncommercially.)
3727 The optional argument TERMINAL specifies which display to ask about.
3728 TERMINAL should be a terminal object, a frame or a display name (a string).
3729 If omitted or nil, that stands for the selected frame's display. */)
3730 (Lisp_Object terminal)
3732 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3733 const char *vendor = ServerVendor (dpyinfo->display);
3735 if (! vendor) vendor = "";
3736 return build_string (vendor);
3739 DEFUN ("x-server-version", Fx_server_version, Sx_server_version, 0, 1, 0,
3740 doc: /* Return the version numbers of the X server of display TERMINAL.
3741 The value is a list of three integers: the major and minor
3742 version numbers of the X Protocol in use, and the distributor-specific release
3743 number. See also the function `x-server-vendor'.
3745 The optional argument TERMINAL specifies which display to ask about.
3746 TERMINAL should be a terminal object, a frame or a display name (a string).
3747 If omitted or nil, that stands for the selected frame's display. */)
3748 (Lisp_Object terminal)
3750 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3751 Display *dpy = dpyinfo->display;
3753 return Fcons (make_number (ProtocolVersion (dpy)),
3754 Fcons (make_number (ProtocolRevision (dpy)),
3755 Fcons (make_number (VendorRelease (dpy)), Qnil)));
3758 DEFUN ("x-display-screens", Fx_display_screens, Sx_display_screens, 0, 1, 0,
3759 doc: /* Return the number of screens on the X server of display TERMINAL.
3760 The optional argument TERMINAL specifies which display to ask about.
3761 TERMINAL should be a terminal object, a frame or a display name (a string).
3762 If omitted or nil, that stands for the selected frame's display. */)
3763 (Lisp_Object terminal)
3765 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3767 return make_number (ScreenCount (dpyinfo->display));
3770 DEFUN ("x-display-mm-height", Fx_display_mm_height, Sx_display_mm_height, 0, 1, 0,
3771 doc: /* Return the height in millimeters of the X display TERMINAL.
3772 The optional argument TERMINAL specifies which display to ask about.
3773 TERMINAL should be a terminal object, a frame or a display name (a string).
3774 If omitted or nil, that stands for the selected frame's display. */)
3775 (Lisp_Object terminal)
3777 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3779 return make_number (HeightMMOfScreen (dpyinfo->screen));
3782 DEFUN ("x-display-mm-width", Fx_display_mm_width, Sx_display_mm_width, 0, 1, 0,
3783 doc: /* Return the width in millimeters of the X display TERMINAL.
3784 The optional argument TERMINAL specifies which display to ask about.
3785 TERMINAL should be a terminal object, a frame or a display name (a string).
3786 If omitted or nil, that stands for the selected frame's display. */)
3787 (Lisp_Object terminal)
3789 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3791 return make_number (WidthMMOfScreen (dpyinfo->screen));
3794 DEFUN ("x-display-backing-store", Fx_display_backing_store,
3795 Sx_display_backing_store, 0, 1, 0,
3796 doc: /* Return an indication of whether X display TERMINAL does backing store.
3797 The value may be `always', `when-mapped', or `not-useful'.
3798 The optional argument TERMINAL specifies which display to ask about.
3799 TERMINAL should be a terminal object, a frame or a display name (a string).
3800 If omitted or nil, that stands for the selected frame's display. */)
3801 (Lisp_Object terminal)
3803 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3804 Lisp_Object result;
3806 switch (DoesBackingStore (dpyinfo->screen))
3808 case Always:
3809 result = intern ("always");
3810 break;
3812 case WhenMapped:
3813 result = intern ("when-mapped");
3814 break;
3816 case NotUseful:
3817 result = intern ("not-useful");
3818 break;
3820 default:
3821 error ("Strange value for BackingStore parameter of screen");
3822 result = Qnil;
3825 return result;
3828 DEFUN ("x-display-visual-class", Fx_display_visual_class,
3829 Sx_display_visual_class, 0, 1, 0,
3830 doc: /* Return the visual class of the X display TERMINAL.
3831 The value is one of the symbols `static-gray', `gray-scale',
3832 `static-color', `pseudo-color', `true-color', or `direct-color'.
3834 The optional argument TERMINAL specifies which display to ask about.
3835 TERMINAL should a terminal object, a frame or a display name (a string).
3836 If omitted or nil, that stands for the selected frame's display. */)
3837 (Lisp_Object terminal)
3839 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3840 Lisp_Object result;
3842 switch (dpyinfo->visual->class)
3844 case StaticGray:
3845 result = intern ("static-gray");
3846 break;
3847 case GrayScale:
3848 result = intern ("gray-scale");
3849 break;
3850 case StaticColor:
3851 result = intern ("static-color");
3852 break;
3853 case PseudoColor:
3854 result = intern ("pseudo-color");
3855 break;
3856 case TrueColor:
3857 result = intern ("true-color");
3858 break;
3859 case DirectColor:
3860 result = intern ("direct-color");
3861 break;
3862 default:
3863 error ("Display has an unknown visual class");
3864 result = Qnil;
3867 return result;
3870 DEFUN ("x-display-save-under", Fx_display_save_under,
3871 Sx_display_save_under, 0, 1, 0,
3872 doc: /* Return t if the X display TERMINAL supports the save-under feature.
3873 The optional argument TERMINAL specifies which display to ask about.
3874 TERMINAL should be a terminal object, a frame or a display name (a string).
3875 If omitted or nil, that stands for the selected frame's display. */)
3876 (Lisp_Object terminal)
3878 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3880 if (DoesSaveUnders (dpyinfo->screen) == True)
3881 return Qt;
3882 else
3883 return Qnil;
3887 x_pixel_width (register struct frame *f)
3889 return FRAME_PIXEL_WIDTH (f);
3893 x_pixel_height (register struct frame *f)
3895 return FRAME_PIXEL_HEIGHT (f);
3899 x_char_width (register struct frame *f)
3901 return FRAME_COLUMN_WIDTH (f);
3905 x_char_height (register struct frame *f)
3907 return FRAME_LINE_HEIGHT (f);
3912 /************************************************************************
3913 X Displays
3914 ************************************************************************/
3917 /* Mapping visual names to visuals. */
3919 static struct visual_class
3921 const char *name;
3922 int class;
3924 visual_classes[] =
3926 {"StaticGray", StaticGray},
3927 {"GrayScale", GrayScale},
3928 {"StaticColor", StaticColor},
3929 {"PseudoColor", PseudoColor},
3930 {"TrueColor", TrueColor},
3931 {"DirectColor", DirectColor},
3932 {NULL, 0}
3936 #ifndef HAVE_XSCREENNUMBEROFSCREEN
3938 /* Value is the screen number of screen SCR. This is a substitute for
3939 the X function with the same name when that doesn't exist. */
3942 XScreenNumberOfScreen (scr)
3943 register Screen *scr;
3945 Display *dpy = scr->display;
3946 int i;
3948 for (i = 0; i < dpy->nscreens; ++i)
3949 if (scr == dpy->screens + i)
3950 break;
3952 return i;
3955 #endif /* not HAVE_XSCREENNUMBEROFSCREEN */
3958 /* Select the visual that should be used on display DPYINFO. Set
3959 members of DPYINFO appropriately. Called from x_term_init. */
3961 void
3962 select_visual (struct x_display_info *dpyinfo)
3964 Display *dpy = dpyinfo->display;
3965 Screen *screen = dpyinfo->screen;
3966 Lisp_Object value;
3968 /* See if a visual is specified. */
3969 value = display_x_get_resource (dpyinfo,
3970 build_string ("visualClass"),
3971 build_string ("VisualClass"),
3972 Qnil, Qnil);
3973 if (STRINGP (value))
3975 /* VALUE should be of the form CLASS-DEPTH, where CLASS is one
3976 of `PseudoColor', `TrueColor' etc. and DEPTH is the color
3977 depth, a decimal number. NAME is compared with case ignored. */
3978 char *s = (char *) alloca (SBYTES (value) + 1);
3979 char *dash;
3980 int i, class = -1;
3981 XVisualInfo vinfo;
3983 strcpy (s, SSDATA (value));
3984 dash = strchr (s, '-');
3985 if (dash)
3987 dpyinfo->n_planes = atoi (dash + 1);
3988 *dash = '\0';
3990 else
3991 /* We won't find a matching visual with depth 0, so that
3992 an error will be printed below. */
3993 dpyinfo->n_planes = 0;
3995 /* Determine the visual class. */
3996 for (i = 0; visual_classes[i].name; ++i)
3997 if (xstrcasecmp (s, visual_classes[i].name) == 0)
3999 class = visual_classes[i].class;
4000 break;
4003 /* Look up a matching visual for the specified class. */
4004 if (class == -1
4005 || !XMatchVisualInfo (dpy, XScreenNumberOfScreen (screen),
4006 dpyinfo->n_planes, class, &vinfo))
4007 fatal ("Invalid visual specification `%s'", SDATA (value));
4009 dpyinfo->visual = vinfo.visual;
4011 else
4013 int n_visuals;
4014 XVisualInfo *vinfo, vinfo_template;
4016 dpyinfo->visual = DefaultVisualOfScreen (screen);
4018 vinfo_template.visualid = XVisualIDFromVisual (dpyinfo->visual);
4019 vinfo_template.screen = XScreenNumberOfScreen (screen);
4020 vinfo = XGetVisualInfo (dpy, VisualIDMask | VisualScreenMask,
4021 &vinfo_template, &n_visuals);
4022 if (n_visuals <= 0)
4023 fatal ("Can't get proper X visual info");
4025 dpyinfo->n_planes = vinfo->depth;
4026 XFree ((char *) vinfo);
4031 /* Return the X display structure for the display named NAME.
4032 Open a new connection if necessary. */
4034 static struct x_display_info *
4035 x_display_info_for_name (Lisp_Object name)
4037 Lisp_Object names;
4038 struct x_display_info *dpyinfo;
4040 CHECK_STRING (name);
4042 #if 0
4043 if (! EQ (Vinitial_window_system, intern ("x")))
4044 error ("Not using X Windows"); /* That doesn't stop us anymore. */
4045 #endif
4047 for (dpyinfo = x_display_list, names = x_display_name_list;
4048 dpyinfo;
4049 dpyinfo = dpyinfo->next, names = XCDR (names))
4051 Lisp_Object tem;
4052 tem = Fstring_equal (XCAR (XCAR (names)), name);
4053 if (!NILP (tem))
4054 return dpyinfo;
4057 /* Use this general default value to start with. */
4058 Vx_resource_name = Vinvocation_name;
4060 validate_x_resource_name ();
4062 dpyinfo = x_term_init (name, (char *)0,
4063 SSDATA (Vx_resource_name));
4065 if (dpyinfo == 0)
4066 error ("Cannot connect to X server %s", SDATA (name));
4068 x_in_use = 1;
4069 XSETFASTINT (Vwindow_system_version, 11);
4071 return dpyinfo;
4075 DEFUN ("x-open-connection", Fx_open_connection, Sx_open_connection,
4076 1, 3, 0,
4077 doc: /* Open a connection to a display server.
4078 DISPLAY is the name of the display to connect to.
4079 Optional second arg XRM-STRING is a string of resources in xrdb format.
4080 If the optional third arg MUST-SUCCEED is non-nil,
4081 terminate Emacs if we can't open the connection.
4082 \(In the Nextstep version, the last two arguments are currently ignored.) */)
4083 (Lisp_Object display, Lisp_Object xrm_string, Lisp_Object must_succeed)
4085 char *xrm_option;
4086 struct x_display_info *dpyinfo;
4088 CHECK_STRING (display);
4089 if (! NILP (xrm_string))
4090 CHECK_STRING (xrm_string);
4092 #if 0
4093 if (! EQ (Vinitial_window_system, intern ("x")))
4094 error ("Not using X Windows"); /* That doesn't stop us anymore. */
4095 #endif
4097 if (! NILP (xrm_string))
4098 xrm_option = SSDATA (xrm_string);
4099 else
4100 xrm_option = (char *) 0;
4102 validate_x_resource_name ();
4104 /* This is what opens the connection and sets x_current_display.
4105 This also initializes many symbols, such as those used for input. */
4106 dpyinfo = x_term_init (display, xrm_option,
4107 SSDATA (Vx_resource_name));
4109 if (dpyinfo == 0)
4111 if (!NILP (must_succeed))
4112 fatal ("Cannot connect to X server %s.\n\
4113 Check the DISPLAY environment variable or use `-d'.\n\
4114 Also use the `xauth' program to verify that you have the proper\n\
4115 authorization information needed to connect the X server.\n\
4116 An insecure way to solve the problem may be to use `xhost'.\n",
4117 SDATA (display));
4118 else
4119 error ("Cannot connect to X server %s", SDATA (display));
4122 x_in_use = 1;
4124 XSETFASTINT (Vwindow_system_version, 11);
4125 return Qnil;
4128 DEFUN ("x-close-connection", Fx_close_connection,
4129 Sx_close_connection, 1, 1, 0,
4130 doc: /* Close the connection to TERMINAL's X server.
4131 For TERMINAL, specify a terminal object, a frame or a display name (a
4132 string). If TERMINAL is nil, that stands for the selected frame's
4133 terminal. */)
4134 (Lisp_Object terminal)
4136 struct x_display_info *dpyinfo = check_x_display_info (terminal);
4138 if (dpyinfo->reference_count > 0)
4139 error ("Display still has frames on it");
4141 x_delete_terminal (dpyinfo->terminal);
4143 return Qnil;
4146 DEFUN ("x-display-list", Fx_display_list, Sx_display_list, 0, 0, 0,
4147 doc: /* Return the list of display names that Emacs has connections to. */)
4148 (void)
4150 Lisp_Object tail, result;
4152 result = Qnil;
4153 for (tail = x_display_name_list; CONSP (tail); tail = XCDR (tail))
4154 result = Fcons (XCAR (XCAR (tail)), result);
4156 return result;
4159 DEFUN ("x-synchronize", Fx_synchronize, Sx_synchronize, 1, 2, 0,
4160 doc: /* If ON is non-nil, report X errors as soon as the erring request is made.
4161 This function only has an effect on X Windows. With MS Windows, it is
4162 defined but does nothing.
4164 If ON is nil, allow buffering of requests.
4165 Turning on synchronization prohibits the Xlib routines from buffering
4166 requests and seriously degrades performance, but makes debugging much
4167 easier.
4168 The optional second argument TERMINAL specifies which display to act on.
4169 TERMINAL should be a terminal object, a frame or a display name (a string).
4170 If TERMINAL is omitted or nil, that stands for the selected frame's display. */)
4171 (Lisp_Object on, Lisp_Object terminal)
4173 struct x_display_info *dpyinfo = check_x_display_info (terminal);
4175 XSynchronize (dpyinfo->display, !EQ (on, Qnil));
4177 return Qnil;
4180 /* Wait for responses to all X commands issued so far for frame F. */
4182 void
4183 x_sync (FRAME_PTR f)
4185 BLOCK_INPUT;
4186 XSync (FRAME_X_DISPLAY (f), False);
4187 UNBLOCK_INPUT;
4191 /***********************************************************************
4192 Window properties
4193 ***********************************************************************/
4195 DEFUN ("x-change-window-property", Fx_change_window_property,
4196 Sx_change_window_property, 2, 6, 0,
4197 doc: /* Change window property PROP to VALUE on the X window of FRAME.
4198 PROP must be a string. VALUE may be a string or a list of conses,
4199 numbers and/or strings. If an element in the list is a string, it is
4200 converted to an atom and the value of the atom is used. If an element
4201 is a cons, it is converted to a 32 bit number where the car is the 16
4202 top bits and the cdr is the lower 16 bits.
4204 FRAME nil or omitted means use the selected frame.
4205 If TYPE is given and non-nil, it is the name of the type of VALUE.
4206 If TYPE is not given or nil, the type is STRING.
4207 FORMAT gives the size in bits of each element if VALUE is a list.
4208 It must be one of 8, 16 or 32.
4209 If VALUE is a string or FORMAT is nil or not given, FORMAT defaults to 8.
4210 If OUTER_P is non-nil, the property is changed for the outer X window of
4211 FRAME. Default is to change on the edit X window. */)
4212 (Lisp_Object prop, Lisp_Object value, Lisp_Object frame, Lisp_Object type, Lisp_Object format, Lisp_Object outer_p)
4214 struct frame *f = check_x_frame (frame);
4215 Atom prop_atom;
4216 Atom target_type = XA_STRING;
4217 int element_format = 8;
4218 unsigned char *data;
4219 int nelements;
4220 Window w;
4222 CHECK_STRING (prop);
4224 if (! NILP (format))
4226 CHECK_NUMBER (format);
4227 element_format = XFASTINT (format);
4229 if (element_format != 8 && element_format != 16
4230 && element_format != 32)
4231 error ("FORMAT must be one of 8, 16 or 32");
4234 if (CONSP (value))
4236 ptrdiff_t elsize;
4238 nelements = x_check_property_data (value);
4239 if (nelements == -1)
4240 error ("Bad data in VALUE, must be number, string or cons");
4242 /* The man page for XChangeProperty:
4243 "If the specified format is 32, the property data must be a
4244 long array."
4245 This applies even if long is more than 32 bits. The X library
4246 converts to 32 bits before sending to the X server. */
4247 elsize = element_format == 32 ? sizeof (long) : element_format >> 3;
4248 data = xnmalloc (nelements, elsize);
4250 x_fill_property_data (FRAME_X_DISPLAY (f), value, data, element_format);
4252 else
4254 CHECK_STRING (value);
4255 data = SDATA (value);
4256 if (INT_MAX < SBYTES (value))
4257 error ("VALUE too long");
4258 nelements = SBYTES (value);
4261 BLOCK_INPUT;
4262 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (prop), False);
4263 if (! NILP (type))
4265 CHECK_STRING (type);
4266 target_type = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (type), False);
4269 if (! NILP (outer_p)) w = FRAME_OUTER_WINDOW (f);
4270 else w = FRAME_X_WINDOW (f);
4272 XChangeProperty (FRAME_X_DISPLAY (f), w,
4273 prop_atom, target_type, element_format, PropModeReplace,
4274 data, nelements);
4276 if (CONSP (value)) xfree (data);
4278 /* Make sure the property is set when we return. */
4279 XFlush (FRAME_X_DISPLAY (f));
4280 UNBLOCK_INPUT;
4282 return value;
4286 DEFUN ("x-delete-window-property", Fx_delete_window_property,
4287 Sx_delete_window_property, 1, 2, 0,
4288 doc: /* Remove window property PROP from X window of FRAME.
4289 FRAME nil or omitted means use the selected frame. Value is PROP. */)
4290 (Lisp_Object prop, Lisp_Object frame)
4292 struct frame *f = check_x_frame (frame);
4293 Atom prop_atom;
4295 CHECK_STRING (prop);
4296 BLOCK_INPUT;
4297 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (prop), False);
4298 XDeleteProperty (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), prop_atom);
4300 /* Make sure the property is removed when we return. */
4301 XFlush (FRAME_X_DISPLAY (f));
4302 UNBLOCK_INPUT;
4304 return prop;
4308 DEFUN ("x-window-property", Fx_window_property, Sx_window_property,
4309 1, 6, 0,
4310 doc: /* Value is the value of window property PROP on FRAME.
4311 If FRAME is nil or omitted, use the selected frame.
4313 On MS Windows, this function only accepts the PROP and FRAME arguments.
4315 On X Windows, the following optional arguments are also accepted:
4316 If TYPE is nil or omitted, get the property as a string.
4317 Otherwise TYPE is the name of the atom that denotes the type expected.
4318 If SOURCE is non-nil, get the property on that window instead of from
4319 FRAME. The number 0 denotes the root window.
4320 If DELETE_P is non-nil, delete the property after retrieving it.
4321 If VECTOR_RET_P is non-nil, don't return a string but a vector of values.
4323 Value is nil if FRAME hasn't a property with name PROP or if PROP has
4324 no value of TYPE (always string in the MS Windows case). */)
4325 (Lisp_Object prop, Lisp_Object frame, Lisp_Object type, Lisp_Object source, Lisp_Object delete_p, Lisp_Object vector_ret_p)
4327 struct frame *f = check_x_frame (frame);
4328 Atom prop_atom;
4329 int rc;
4330 Lisp_Object prop_value = Qnil;
4331 unsigned char *tmp_data = NULL;
4332 Atom actual_type;
4333 Atom target_type = XA_STRING;
4334 int actual_format;
4335 unsigned long actual_size, bytes_remaining;
4336 Window target_window = FRAME_X_WINDOW (f);
4337 struct gcpro gcpro1;
4339 GCPRO1 (prop_value);
4340 CHECK_STRING (prop);
4342 if (! NILP (source))
4344 CONS_TO_INTEGER (source, Window, target_window);
4345 if (! target_window)
4346 target_window = FRAME_X_DISPLAY_INFO (f)->root_window;
4349 BLOCK_INPUT;
4350 if (STRINGP (type))
4352 if (strcmp ("AnyPropertyType", SSDATA (type)) == 0)
4353 target_type = AnyPropertyType;
4354 else
4355 target_type = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (type), False);
4358 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (prop), False);
4359 rc = XGetWindowProperty (FRAME_X_DISPLAY (f), target_window,
4360 prop_atom, 0, 0, False, target_type,
4361 &actual_type, &actual_format, &actual_size,
4362 &bytes_remaining, &tmp_data);
4363 if (rc == Success)
4365 int size = bytes_remaining;
4367 XFree (tmp_data);
4368 tmp_data = NULL;
4370 rc = XGetWindowProperty (FRAME_X_DISPLAY (f), target_window,
4371 prop_atom, 0, bytes_remaining,
4372 ! NILP (delete_p), target_type,
4373 &actual_type, &actual_format,
4374 &actual_size, &bytes_remaining,
4375 &tmp_data);
4376 if (rc == Success && tmp_data)
4378 /* The man page for XGetWindowProperty says:
4379 "If the returned format is 32, the returned data is represented
4380 as a long array and should be cast to that type to obtain the
4381 elements."
4382 This applies even if long is more than 32 bits, the X library
4383 converts from 32 bit elements received from the X server to long
4384 and passes the long array to us. Thus, for that case memcpy can not
4385 be used. We convert to a 32 bit type here, because so much code
4386 assume on that.
4388 The bytes and offsets passed to XGetWindowProperty refers to the
4389 property and those are indeed in 32 bit quantities if format is
4390 32. */
4392 if (32 < BITS_PER_LONG && actual_format == 32)
4394 unsigned long i;
4395 int *idata = (int *) tmp_data;
4396 long *ldata = (long *) tmp_data;
4398 for (i = 0; i < actual_size; ++i)
4399 idata[i] = (int) ldata[i];
4402 if (NILP (vector_ret_p))
4403 prop_value = make_string ((char *) tmp_data, size);
4404 else
4405 prop_value = x_property_data_to_lisp (f,
4406 tmp_data,
4407 actual_type,
4408 actual_format,
4409 actual_size);
4412 if (tmp_data) XFree (tmp_data);
4415 UNBLOCK_INPUT;
4416 UNGCPRO;
4417 return prop_value;
4422 /***********************************************************************
4423 Busy cursor
4424 ***********************************************************************/
4426 /* Timer function of hourglass_atimer. TIMER is equal to
4427 hourglass_atimer.
4429 Display an hourglass pointer on all frames by mapping the frames'
4430 hourglass_window. Set the hourglass_p flag in the frames'
4431 output_data.x structure to indicate that an hourglass cursor is
4432 shown on the frames. */
4434 void
4435 show_hourglass (struct atimer *timer)
4437 /* The timer implementation will cancel this timer automatically
4438 after this function has run. Set hourglass_atimer to null
4439 so that we know the timer doesn't have to be canceled. */
4440 hourglass_atimer = NULL;
4442 if (!hourglass_shown_p)
4444 Lisp_Object rest, frame;
4446 BLOCK_INPUT;
4448 FOR_EACH_FRAME (rest, frame)
4450 struct frame *f = XFRAME (frame);
4452 if (FRAME_LIVE_P (f) && FRAME_X_P (f) && FRAME_X_DISPLAY (f))
4454 Display *dpy = FRAME_X_DISPLAY (f);
4456 #ifdef USE_X_TOOLKIT
4457 if (f->output_data.x->widget)
4458 #else
4459 if (FRAME_OUTER_WINDOW (f))
4460 #endif
4462 f->output_data.x->hourglass_p = 1;
4464 if (!f->output_data.x->hourglass_window)
4466 unsigned long mask = CWCursor;
4467 XSetWindowAttributes attrs;
4468 #ifdef USE_GTK
4469 Window parent = FRAME_X_WINDOW (f);
4470 #else
4471 Window parent = FRAME_OUTER_WINDOW (f);
4472 #endif
4473 attrs.cursor = f->output_data.x->hourglass_cursor;
4475 f->output_data.x->hourglass_window
4476 = XCreateWindow (dpy, parent,
4477 0, 0, 32000, 32000, 0, 0,
4478 InputOnly,
4479 CopyFromParent,
4480 mask, &attrs);
4483 XMapRaised (dpy, f->output_data.x->hourglass_window);
4484 XFlush (dpy);
4489 hourglass_shown_p = 1;
4490 UNBLOCK_INPUT;
4495 /* Hide the hourglass pointer on all frames, if it is currently
4496 shown. */
4498 void
4499 hide_hourglass (void)
4501 if (hourglass_shown_p)
4503 Lisp_Object rest, frame;
4505 BLOCK_INPUT;
4506 FOR_EACH_FRAME (rest, frame)
4508 struct frame *f = XFRAME (frame);
4510 if (FRAME_X_P (f)
4511 /* Watch out for newly created frames. */
4512 && f->output_data.x->hourglass_window)
4514 XUnmapWindow (FRAME_X_DISPLAY (f),
4515 f->output_data.x->hourglass_window);
4516 /* Sync here because XTread_socket looks at the
4517 hourglass_p flag that is reset to zero below. */
4518 XSync (FRAME_X_DISPLAY (f), False);
4519 f->output_data.x->hourglass_p = 0;
4523 hourglass_shown_p = 0;
4524 UNBLOCK_INPUT;
4530 /***********************************************************************
4531 Tool tips
4532 ***********************************************************************/
4534 static Lisp_Object x_create_tip_frame (struct x_display_info *,
4535 Lisp_Object, Lisp_Object);
4536 static void compute_tip_xy (struct frame *, Lisp_Object, Lisp_Object,
4537 Lisp_Object, int, int, int *, int *);
4539 /* The frame of a currently visible tooltip. */
4541 Lisp_Object tip_frame;
4543 /* If non-nil, a timer started that hides the last tooltip when it
4544 fires. */
4546 static Lisp_Object tip_timer;
4547 Window tip_window;
4549 /* If non-nil, a vector of 3 elements containing the last args
4550 with which x-show-tip was called. See there. */
4552 static Lisp_Object last_show_tip_args;
4555 static Lisp_Object
4556 unwind_create_tip_frame (Lisp_Object frame)
4558 Lisp_Object deleted;
4560 deleted = unwind_create_frame (frame);
4561 if (EQ (deleted, Qt))
4563 tip_window = None;
4564 tip_frame = Qnil;
4567 return deleted;
4571 /* Create a frame for a tooltip on the display described by DPYINFO.
4572 PARMS is a list of frame parameters. TEXT is the string to
4573 display in the tip frame. Value is the frame.
4575 Note that functions called here, esp. x_default_parameter can
4576 signal errors, for instance when a specified color name is
4577 undefined. We have to make sure that we're in a consistent state
4578 when this happens. */
4580 static Lisp_Object
4581 x_create_tip_frame (struct x_display_info *dpyinfo,
4582 Lisp_Object parms,
4583 Lisp_Object text)
4585 struct frame *f;
4586 Lisp_Object frame;
4587 Lisp_Object name;
4588 int width, height;
4589 int count = SPECPDL_INDEX ();
4590 struct gcpro gcpro1, gcpro2, gcpro3;
4591 int face_change_count_before = face_change_count;
4592 Lisp_Object buffer;
4593 struct buffer *old_buffer;
4595 check_x ();
4597 if (!dpyinfo->terminal->name)
4598 error ("Terminal is not live, can't create new frames on it");
4600 parms = Fcopy_alist (parms);
4602 /* Get the name of the frame to use for resource lookup. */
4603 name = x_get_arg (dpyinfo, parms, Qname, "name", "Name", RES_TYPE_STRING);
4604 if (!STRINGP (name)
4605 && !EQ (name, Qunbound)
4606 && !NILP (name))
4607 error ("Invalid frame name--not a string or nil");
4609 frame = Qnil;
4610 GCPRO3 (parms, name, frame);
4611 f = make_frame (1);
4612 XSETFRAME (frame, f);
4614 buffer = Fget_buffer_create (build_string (" *tip*"));
4615 Fset_window_buffer (FRAME_ROOT_WINDOW (f), buffer, Qnil);
4616 old_buffer = current_buffer;
4617 set_buffer_internal_1 (XBUFFER (buffer));
4618 BVAR (current_buffer, truncate_lines) = Qnil;
4619 specbind (Qinhibit_read_only, Qt);
4620 specbind (Qinhibit_modification_hooks, Qt);
4621 Ferase_buffer ();
4622 Finsert (1, &text);
4623 set_buffer_internal_1 (old_buffer);
4625 FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
4626 record_unwind_protect (unwind_create_tip_frame, frame);
4628 f->terminal = dpyinfo->terminal;
4630 /* By setting the output method, we're essentially saying that
4631 the frame is live, as per FRAME_LIVE_P. If we get a signal
4632 from this point on, x_destroy_window might screw up reference
4633 counts etc. */
4634 f->output_method = output_x_window;
4635 f->output_data.x = (struct x_output *) xmalloc (sizeof (struct x_output));
4636 memset (f->output_data.x, 0, sizeof (struct x_output));
4637 f->output_data.x->icon_bitmap = -1;
4638 FRAME_FONTSET (f) = -1;
4639 f->output_data.x->scroll_bar_foreground_pixel = -1;
4640 f->output_data.x->scroll_bar_background_pixel = -1;
4641 #ifdef USE_TOOLKIT_SCROLL_BARS
4642 f->output_data.x->scroll_bar_top_shadow_pixel = -1;
4643 f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
4644 #endif /* USE_TOOLKIT_SCROLL_BARS */
4645 f->icon_name = Qnil;
4646 FRAME_X_DISPLAY_INFO (f) = dpyinfo;
4647 f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
4648 f->output_data.x->explicit_parent = 0;
4650 /* These colors will be set anyway later, but it's important
4651 to get the color reference counts right, so initialize them! */
4653 Lisp_Object black;
4654 struct gcpro gcpro1;
4656 /* Function x_decode_color can signal an error. Make
4657 sure to initialize color slots so that we won't try
4658 to free colors we haven't allocated. */
4659 FRAME_FOREGROUND_PIXEL (f) = -1;
4660 FRAME_BACKGROUND_PIXEL (f) = -1;
4661 f->output_data.x->cursor_pixel = -1;
4662 f->output_data.x->cursor_foreground_pixel = -1;
4663 f->output_data.x->border_pixel = -1;
4664 f->output_data.x->mouse_pixel = -1;
4666 black = build_string ("black");
4667 GCPRO1 (black);
4668 FRAME_FOREGROUND_PIXEL (f)
4669 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4670 FRAME_BACKGROUND_PIXEL (f)
4671 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4672 f->output_data.x->cursor_pixel
4673 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4674 f->output_data.x->cursor_foreground_pixel
4675 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4676 f->output_data.x->border_pixel
4677 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4678 f->output_data.x->mouse_pixel
4679 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4680 UNGCPRO;
4683 /* Set the name; the functions to which we pass f expect the name to
4684 be set. */
4685 if (EQ (name, Qunbound) || NILP (name))
4687 f->name = build_string (dpyinfo->x_id_name);
4688 f->explicit_name = 0;
4690 else
4692 f->name = name;
4693 f->explicit_name = 1;
4694 /* use the frame's title when getting resources for this frame. */
4695 specbind (Qx_resource_name, name);
4698 f->resx = dpyinfo->resx;
4699 f->resy = dpyinfo->resy;
4701 register_font_driver (&xfont_driver, f);
4702 #ifdef HAVE_FREETYPE
4703 #ifdef HAVE_XFT
4704 register_font_driver (&xftfont_driver, f);
4705 #else /* not HAVE_XFT */
4706 register_font_driver (&ftxfont_driver, f);
4707 #endif /* not HAVE_XFT */
4708 #endif /* HAVE_FREETYPE */
4710 x_default_parameter (f, parms, Qfont_backend, Qnil,
4711 "fontBackend", "FontBackend", RES_TYPE_STRING);
4713 /* Extract the window parameters from the supplied values that are
4714 needed to determine window geometry. */
4715 x_default_font_parameter (f, parms);
4717 x_default_parameter (f, parms, Qborder_width, make_number (0),
4718 "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
4720 /* This defaults to 2 in order to match xterm. We recognize either
4721 internalBorderWidth or internalBorder (which is what xterm calls
4722 it). */
4723 if (NILP (Fassq (Qinternal_border_width, parms)))
4725 Lisp_Object value;
4727 value = x_get_arg (dpyinfo, parms, Qinternal_border_width,
4728 "internalBorder", "internalBorder", RES_TYPE_NUMBER);
4729 if (! EQ (value, Qunbound))
4730 parms = Fcons (Fcons (Qinternal_border_width, value),
4731 parms);
4734 x_default_parameter (f, parms, Qinternal_border_width, make_number (1),
4735 "internalBorderWidth", "internalBorderWidth",
4736 RES_TYPE_NUMBER);
4738 /* Also do the stuff which must be set before the window exists. */
4739 x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
4740 "foreground", "Foreground", RES_TYPE_STRING);
4741 x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
4742 "background", "Background", RES_TYPE_STRING);
4743 x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
4744 "pointerColor", "Foreground", RES_TYPE_STRING);
4745 x_default_parameter (f, parms, Qcursor_color, build_string ("black"),
4746 "cursorColor", "Foreground", RES_TYPE_STRING);
4747 x_default_parameter (f, parms, Qborder_color, build_string ("black"),
4748 "borderColor", "BorderColor", RES_TYPE_STRING);
4750 #if GLYPH_DEBUG
4751 image_cache_refcount =
4752 FRAME_IMAGE_CACHE (f) ? FRAME_IMAGE_CACHE (f)->refcount : 0;
4753 dpyinfo_refcount = dpyinfo->reference_count;
4754 #endif /* GLYPH_DEBUG */
4756 /* Init faces before x_default_parameter is called for scroll-bar
4757 parameters because that function calls x_set_scroll_bar_width,
4758 which calls change_frame_size, which calls Fset_window_buffer,
4759 which runs hooks, which call Fvertical_motion. At the end, we
4760 end up in init_iterator with a null face cache, which should not
4761 happen. */
4762 init_frame_faces (f);
4764 f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
4766 x_figure_window_size (f, parms, 0);
4769 XSetWindowAttributes attrs;
4770 unsigned long mask;
4771 Atom type = FRAME_X_DISPLAY_INFO (f)->Xatom_net_window_type_tooltip;
4773 BLOCK_INPUT;
4774 mask = CWBackPixel | CWOverrideRedirect | CWEventMask;
4775 if (DoesSaveUnders (dpyinfo->screen))
4776 mask |= CWSaveUnder;
4778 /* Window managers look at the override-redirect flag to determine
4779 whether or net to give windows a decoration (Xlib spec, chapter
4780 3.2.8). */
4781 attrs.override_redirect = True;
4782 attrs.save_under = True;
4783 attrs.background_pixel = FRAME_BACKGROUND_PIXEL (f);
4784 /* Arrange for getting MapNotify and UnmapNotify events. */
4785 attrs.event_mask = StructureNotifyMask;
4786 tip_window
4787 = FRAME_X_WINDOW (f)
4788 = XCreateWindow (FRAME_X_DISPLAY (f),
4789 FRAME_X_DISPLAY_INFO (f)->root_window,
4790 /* x, y, width, height */
4791 0, 0, 1, 1,
4792 /* Border. */
4793 f->border_width,
4794 CopyFromParent, InputOutput, CopyFromParent,
4795 mask, &attrs);
4796 XChangeProperty (FRAME_X_DISPLAY (f), tip_window,
4797 FRAME_X_DISPLAY_INFO (f)->Xatom_net_window_type,
4798 XA_ATOM, 32, PropModeReplace,
4799 (unsigned char *)&type, 1);
4800 UNBLOCK_INPUT;
4803 x_make_gc (f);
4805 x_default_parameter (f, parms, Qauto_raise, Qnil,
4806 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
4807 x_default_parameter (f, parms, Qauto_lower, Qnil,
4808 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
4809 x_default_parameter (f, parms, Qcursor_type, Qbox,
4810 "cursorType", "CursorType", RES_TYPE_SYMBOL);
4812 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
4813 Change will not be effected unless different from the current
4814 FRAME_LINES (f). */
4815 width = FRAME_COLS (f);
4816 height = FRAME_LINES (f);
4817 SET_FRAME_COLS (f, 0);
4818 FRAME_LINES (f) = 0;
4819 change_frame_size (f, height, width, 1, 0, 0);
4821 /* Add `tooltip' frame parameter's default value. */
4822 if (NILP (Fframe_parameter (frame, Qtooltip)))
4823 Fmodify_frame_parameters (frame, Fcons (Fcons (Qtooltip, Qt), Qnil));
4825 /* FIXME - can this be done in a similar way to normal frames?
4826 http://lists.gnu.org/archive/html/emacs-devel/2007-10/msg00641.html */
4828 /* Set the `display-type' frame parameter before setting up faces. */
4830 Lisp_Object disptype;
4832 if (FRAME_X_DISPLAY_INFO (f)->n_planes == 1)
4833 disptype = intern ("mono");
4834 else if (FRAME_X_DISPLAY_INFO (f)->visual->class == GrayScale
4835 || FRAME_X_DISPLAY_INFO (f)->visual->class == StaticGray)
4836 disptype = intern ("grayscale");
4837 else
4838 disptype = intern ("color");
4840 if (NILP (Fframe_parameter (frame, Qdisplay_type)))
4841 Fmodify_frame_parameters (frame, Fcons (Fcons (Qdisplay_type, disptype),
4842 Qnil));
4845 /* Set up faces after all frame parameters are known. This call
4846 also merges in face attributes specified for new frames.
4848 Frame parameters may be changed if .Xdefaults contains
4849 specifications for the default font. For example, if there is an
4850 `Emacs.default.attributeBackground: pink', the `background-color'
4851 attribute of the frame get's set, which let's the internal border
4852 of the tooltip frame appear in pink. Prevent this. */
4854 Lisp_Object bg = Fframe_parameter (frame, Qbackground_color);
4856 /* Set tip_frame here, so that */
4857 tip_frame = frame;
4858 call2 (Qface_set_after_frame_default, frame, Qnil);
4860 if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
4861 Fmodify_frame_parameters (frame, Fcons (Fcons (Qbackground_color, bg),
4862 Qnil));
4865 f->no_split = 1;
4867 UNGCPRO;
4869 /* Now that the frame will be official, it counts as a reference to
4870 its display and terminal. */
4871 FRAME_X_DISPLAY_INFO (f)->reference_count++;
4872 f->terminal->reference_count++;
4874 /* It is now ok to make the frame official even if we get an error
4875 below. And the frame needs to be on Vframe_list or making it
4876 visible won't work. */
4877 Vframe_list = Fcons (frame, Vframe_list);
4880 /* Setting attributes of faces of the tooltip frame from resources
4881 and similar will increment face_change_count, which leads to the
4882 clearing of all current matrices. Since this isn't necessary
4883 here, avoid it by resetting face_change_count to the value it
4884 had before we created the tip frame. */
4885 face_change_count = face_change_count_before;
4887 /* Discard the unwind_protect. */
4888 return unbind_to (count, frame);
4892 /* Compute where to display tip frame F. PARMS is the list of frame
4893 parameters for F. DX and DY are specified offsets from the current
4894 location of the mouse. WIDTH and HEIGHT are the width and height
4895 of the tooltip. Return coordinates relative to the root window of
4896 the display in *ROOT_X, and *ROOT_Y. */
4898 static void
4899 compute_tip_xy (struct frame *f, Lisp_Object parms, Lisp_Object dx, Lisp_Object dy, int width, int height, int *root_x, int *root_y)
4901 Lisp_Object left, top;
4902 int win_x, win_y;
4903 Window root, child;
4904 unsigned pmask;
4906 /* User-specified position? */
4907 left = Fcdr (Fassq (Qleft, parms));
4908 top = Fcdr (Fassq (Qtop, parms));
4910 /* Move the tooltip window where the mouse pointer is. Resize and
4911 show it. */
4912 if (!INTEGERP (left) || !INTEGERP (top))
4914 BLOCK_INPUT;
4915 XQueryPointer (FRAME_X_DISPLAY (f), FRAME_X_DISPLAY_INFO (f)->root_window,
4916 &root, &child, root_x, root_y, &win_x, &win_y, &pmask);
4917 UNBLOCK_INPUT;
4920 if (INTEGERP (top))
4921 *root_y = XINT (top);
4922 else if (*root_y + XINT (dy) <= 0)
4923 *root_y = 0; /* Can happen for negative dy */
4924 else if (*root_y + XINT (dy) + height
4925 <= x_display_pixel_height (FRAME_X_DISPLAY_INFO (f)))
4926 /* It fits below the pointer */
4927 *root_y += XINT (dy);
4928 else if (height + XINT (dy) <= *root_y)
4929 /* It fits above the pointer. */
4930 *root_y -= height + XINT (dy);
4931 else
4932 /* Put it on the top. */
4933 *root_y = 0;
4935 if (INTEGERP (left))
4936 *root_x = XINT (left);
4937 else if (*root_x + XINT (dx) <= 0)
4938 *root_x = 0; /* Can happen for negative dx */
4939 else if (*root_x + XINT (dx) + width
4940 <= x_display_pixel_width (FRAME_X_DISPLAY_INFO (f)))
4941 /* It fits to the right of the pointer. */
4942 *root_x += XINT (dx);
4943 else if (width + XINT (dx) <= *root_x)
4944 /* It fits to the left of the pointer. */
4945 *root_x -= width + XINT (dx);
4946 else
4947 /* Put it left-justified on the screen--it ought to fit that way. */
4948 *root_x = 0;
4952 DEFUN ("x-show-tip", Fx_show_tip, Sx_show_tip, 1, 6, 0,
4953 doc: /* Show STRING in a "tooltip" window on frame FRAME.
4954 A tooltip window is a small X window displaying a string.
4956 This is an internal function; Lisp code should call `tooltip-show'.
4958 FRAME nil or omitted means use the selected frame.
4960 PARMS is an optional list of frame parameters which can be used to
4961 change the tooltip's appearance.
4963 Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
4964 means use the default timeout of 5 seconds.
4966 If the list of frame parameters PARMS contains a `left' parameters,
4967 the tooltip is displayed at that x-position. Otherwise it is
4968 displayed at the mouse position, with offset DX added (default is 5 if
4969 DX isn't specified). Likewise for the y-position; if a `top' frame
4970 parameter is specified, it determines the y-position of the tooltip
4971 window, otherwise it is displayed at the mouse position, with offset
4972 DY added (default is -10).
4974 A tooltip's maximum size is specified by `x-max-tooltip-size'.
4975 Text larger than the specified size is clipped. */)
4976 (Lisp_Object string, Lisp_Object frame, Lisp_Object parms, Lisp_Object timeout, Lisp_Object dx, Lisp_Object dy)
4978 struct frame *f;
4979 struct window *w;
4980 int root_x, root_y;
4981 struct buffer *old_buffer;
4982 struct text_pos pos;
4983 int i, width, height, seen_reversed_p;
4984 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
4985 int old_windows_or_buffers_changed = windows_or_buffers_changed;
4986 int count = SPECPDL_INDEX ();
4988 specbind (Qinhibit_redisplay, Qt);
4990 GCPRO4 (string, parms, frame, timeout);
4992 CHECK_STRING (string);
4993 if (SCHARS (string) == 0)
4994 string = make_unibyte_string (" ", 1);
4996 f = check_x_frame (frame);
4997 if (NILP (timeout))
4998 timeout = make_number (5);
4999 else
5000 CHECK_NATNUM (timeout);
5002 if (NILP (dx))
5003 dx = make_number (5);
5004 else
5005 CHECK_NUMBER (dx);
5007 if (NILP (dy))
5008 dy = make_number (-10);
5009 else
5010 CHECK_NUMBER (dy);
5012 #ifdef USE_GTK
5013 if (x_gtk_use_system_tooltips)
5015 int ok;
5017 /* Hide a previous tip, if any. */
5018 Fx_hide_tip ();
5020 BLOCK_INPUT;
5021 if ((ok = xg_prepare_tooltip (f, string, &width, &height)) != 0)
5023 compute_tip_xy (f, parms, dx, dy, width, height, &root_x, &root_y);
5024 xg_show_tooltip (f, root_x, root_y);
5025 /* This is used in Fx_hide_tip. */
5026 XSETFRAME (tip_frame, f);
5028 UNBLOCK_INPUT;
5029 if (ok) goto start_timer;
5031 #endif /* USE_GTK */
5033 if (NILP (last_show_tip_args))
5034 last_show_tip_args = Fmake_vector (make_number (3), Qnil);
5036 if (!NILP (tip_frame))
5038 Lisp_Object last_string = AREF (last_show_tip_args, 0);
5039 Lisp_Object last_frame = AREF (last_show_tip_args, 1);
5040 Lisp_Object last_parms = AREF (last_show_tip_args, 2);
5042 if (EQ (frame, last_frame)
5043 && !NILP (Fequal (last_string, string))
5044 && !NILP (Fequal (last_parms, parms)))
5046 struct frame *tip_f = XFRAME (tip_frame);
5048 /* Only DX and DY have changed. */
5049 if (!NILP (tip_timer))
5051 Lisp_Object timer = tip_timer;
5052 tip_timer = Qnil;
5053 call1 (Qcancel_timer, timer);
5056 BLOCK_INPUT;
5057 compute_tip_xy (tip_f, parms, dx, dy, FRAME_PIXEL_WIDTH (tip_f),
5058 FRAME_PIXEL_HEIGHT (tip_f), &root_x, &root_y);
5059 XMoveWindow (FRAME_X_DISPLAY (tip_f), FRAME_X_WINDOW (tip_f),
5060 root_x, root_y);
5061 UNBLOCK_INPUT;
5062 goto start_timer;
5066 /* Hide a previous tip, if any. */
5067 Fx_hide_tip ();
5069 ASET (last_show_tip_args, 0, string);
5070 ASET (last_show_tip_args, 1, frame);
5071 ASET (last_show_tip_args, 2, parms);
5073 /* Add default values to frame parameters. */
5074 if (NILP (Fassq (Qname, parms)))
5075 parms = Fcons (Fcons (Qname, build_string ("tooltip")), parms);
5076 if (NILP (Fassq (Qinternal_border_width, parms)))
5077 parms = Fcons (Fcons (Qinternal_border_width, make_number (3)), parms);
5078 if (NILP (Fassq (Qborder_width, parms)))
5079 parms = Fcons (Fcons (Qborder_width, make_number (1)), parms);
5080 if (NILP (Fassq (Qborder_color, parms)))
5081 parms = Fcons (Fcons (Qborder_color, build_string ("lightyellow")), parms);
5082 if (NILP (Fassq (Qbackground_color, parms)))
5083 parms = Fcons (Fcons (Qbackground_color, build_string ("lightyellow")),
5084 parms);
5086 /* Create a frame for the tooltip, and record it in the global
5087 variable tip_frame. */
5088 frame = x_create_tip_frame (FRAME_X_DISPLAY_INFO (f), parms, string);
5089 f = XFRAME (frame);
5091 /* Set up the frame's root window. */
5092 w = XWINDOW (FRAME_ROOT_WINDOW (f));
5093 w->left_col = w->top_line = make_number (0);
5095 if (CONSP (Vx_max_tooltip_size)
5096 && INTEGERP (XCAR (Vx_max_tooltip_size))
5097 && XINT (XCAR (Vx_max_tooltip_size)) > 0
5098 && INTEGERP (XCDR (Vx_max_tooltip_size))
5099 && XINT (XCDR (Vx_max_tooltip_size)) > 0)
5101 w->total_cols = XCAR (Vx_max_tooltip_size);
5102 w->total_lines = XCDR (Vx_max_tooltip_size);
5104 else
5106 w->total_cols = make_number (80);
5107 w->total_lines = make_number (40);
5110 FRAME_TOTAL_COLS (f) = XINT (w->total_cols);
5111 adjust_glyphs (f);
5112 w->pseudo_window_p = 1;
5114 /* Display the tooltip text in a temporary buffer. */
5115 old_buffer = current_buffer;
5116 set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f))->buffer));
5117 BVAR (current_buffer, truncate_lines) = Qnil;
5118 clear_glyph_matrix (w->desired_matrix);
5119 clear_glyph_matrix (w->current_matrix);
5120 SET_TEXT_POS (pos, BEGV, BEGV_BYTE);
5121 try_window (FRAME_ROOT_WINDOW (f), pos, TRY_WINDOW_IGNORE_FONTS_CHANGE);
5123 /* Compute width and height of the tooltip. */
5124 width = height = seen_reversed_p = 0;
5125 for (i = 0; i < w->desired_matrix->nrows; ++i)
5127 struct glyph_row *row = &w->desired_matrix->rows[i];
5128 struct glyph *last;
5129 int row_width;
5131 /* Stop at the first empty row at the end. */
5132 if (!row->enabled_p || !row->displays_text_p)
5133 break;
5135 /* Let the row go over the full width of the frame. */
5136 row->full_width_p = 1;
5138 row_width = row->pixel_width;
5139 if (row->used[TEXT_AREA])
5141 /* There's a glyph at the end of rows that is used to place
5142 the cursor there. Don't include the width of this glyph. */
5143 if (!row->reversed_p)
5145 last = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
5146 if (INTEGERP (last->object))
5147 row_width -= last->pixel_width;
5149 else
5151 /* There could be a stretch glyph at the beginning of R2L
5152 rows that is produced by extend_face_to_end_of_line.
5153 Don't count that glyph. */
5154 struct glyph *g = row->glyphs[TEXT_AREA];
5156 if (g->type == STRETCH_GLYPH && INTEGERP (g->object))
5158 row_width -= g->pixel_width;
5159 seen_reversed_p = 1;
5164 height += row->height;
5165 width = max (width, row_width);
5168 /* If we've seen partial-length R2L rows, we need to re-adjust the
5169 tool-tip frame width and redisplay it again, to avoid over-wide
5170 tips due to the stretch glyph that extends R2L lines to full
5171 width of the frame. */
5172 if (seen_reversed_p)
5174 /* w->total_cols and FRAME_TOTAL_COLS want the width in columns,
5175 not in pixels. */
5176 width /= WINDOW_FRAME_COLUMN_WIDTH (w);
5177 w->total_cols = make_number (width);
5178 FRAME_TOTAL_COLS (f) = width;
5179 adjust_glyphs (f);
5180 clear_glyph_matrix (w->desired_matrix);
5181 clear_glyph_matrix (w->current_matrix);
5182 try_window (FRAME_ROOT_WINDOW (f), pos, 0);
5183 width = height = 0;
5184 /* Recompute width and height of the tooltip. */
5185 for (i = 0; i < w->desired_matrix->nrows; ++i)
5187 struct glyph_row *row = &w->desired_matrix->rows[i];
5188 struct glyph *last;
5189 int row_width;
5191 if (!row->enabled_p || !row->displays_text_p)
5192 break;
5193 row->full_width_p = 1;
5194 row_width = row->pixel_width;
5195 if (row->used[TEXT_AREA] && !row->reversed_p)
5197 last = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
5198 if (INTEGERP (last->object))
5199 row_width -= last->pixel_width;
5202 height += row->height;
5203 width = max (width, row_width);
5207 /* Add the frame's internal border to the width and height the X
5208 window should have. */
5209 height += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
5210 width += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
5212 /* Move the tooltip window where the mouse pointer is. Resize and
5213 show it. */
5214 compute_tip_xy (f, parms, dx, dy, width, height, &root_x, &root_y);
5216 BLOCK_INPUT;
5217 XMoveResizeWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
5218 root_x, root_y, width, height);
5219 XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
5220 UNBLOCK_INPUT;
5222 /* Draw into the window. */
5223 w->must_be_updated_p = 1;
5224 update_single_window (w, 1);
5226 /* Restore original current buffer. */
5227 set_buffer_internal_1 (old_buffer);
5228 windows_or_buffers_changed = old_windows_or_buffers_changed;
5230 start_timer:
5231 /* Let the tip disappear after timeout seconds. */
5232 tip_timer = call3 (intern ("run-at-time"), timeout, Qnil,
5233 intern ("x-hide-tip"));
5235 UNGCPRO;
5236 return unbind_to (count, Qnil);
5240 DEFUN ("x-hide-tip", Fx_hide_tip, Sx_hide_tip, 0, 0, 0,
5241 doc: /* Hide the current tooltip window, if there is any.
5242 Value is t if tooltip was open, nil otherwise. */)
5243 (void)
5245 int count;
5246 Lisp_Object deleted, frame, timer;
5247 struct gcpro gcpro1, gcpro2;
5249 /* Return quickly if nothing to do. */
5250 if (NILP (tip_timer) && NILP (tip_frame))
5251 return Qnil;
5253 frame = tip_frame;
5254 timer = tip_timer;
5255 GCPRO2 (frame, timer);
5256 tip_frame = tip_timer = deleted = Qnil;
5258 count = SPECPDL_INDEX ();
5259 specbind (Qinhibit_redisplay, Qt);
5260 specbind (Qinhibit_quit, Qt);
5262 if (!NILP (timer))
5263 call1 (Qcancel_timer, timer);
5265 #ifdef USE_GTK
5267 /* When using system tooltip, tip_frame is the Emacs frame on which
5268 the tip is shown. */
5269 struct frame *f = XFRAME (frame);
5270 if (FRAME_LIVE_P (f) && xg_hide_tooltip (f))
5271 frame = Qnil;
5273 #endif
5275 if (FRAMEP (frame))
5277 delete_frame (frame, Qnil);
5278 deleted = Qt;
5280 #ifdef USE_LUCID
5281 /* Bloodcurdling hack alert: The Lucid menu bar widget's
5282 redisplay procedure is not called when a tip frame over menu
5283 items is unmapped. Redisplay the menu manually... */
5285 Widget w;
5286 struct frame *f = SELECTED_FRAME ();
5287 w = f->output_data.x->menubar_widget;
5289 if (!DoesSaveUnders (FRAME_X_DISPLAY_INFO (f)->screen)
5290 && w != NULL)
5292 BLOCK_INPUT;
5293 xlwmenu_redisplay (w);
5294 UNBLOCK_INPUT;
5297 #endif /* USE_LUCID */
5300 UNGCPRO;
5301 return unbind_to (count, deleted);
5306 /***********************************************************************
5307 File selection dialog
5308 ***********************************************************************/
5310 DEFUN ("x-uses-old-gtk-dialog", Fx_uses_old_gtk_dialog,
5311 Sx_uses_old_gtk_dialog,
5312 0, 0, 0,
5313 doc: /* Return t if the old Gtk+ file selection dialog is used. */)
5314 (void)
5316 #ifdef USE_GTK
5317 if (use_dialog_box
5318 && use_file_dialog
5319 && have_menus_p ()
5320 && xg_uses_old_file_dialog ())
5321 return Qt;
5322 #endif
5323 return Qnil;
5327 #ifdef USE_MOTIF
5328 /* Callback for "OK" and "Cancel" on file selection dialog. */
5330 static void
5331 file_dialog_cb (Widget widget, XtPointer client_data, XtPointer call_data)
5333 int *result = (int *) client_data;
5334 XmAnyCallbackStruct *cb = (XmAnyCallbackStruct *) call_data;
5335 *result = cb->reason;
5339 /* Callback for unmapping a file selection dialog. This is used to
5340 capture the case where a dialog is closed via a window manager's
5341 closer button, for example. Using a XmNdestroyCallback didn't work
5342 in this case. */
5344 static void
5345 file_dialog_unmap_cb (Widget widget, XtPointer client_data, XtPointer call_data)
5347 int *result = (int *) client_data;
5348 *result = XmCR_CANCEL;
5351 static Lisp_Object
5352 clean_up_file_dialog (Lisp_Object arg)
5354 struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
5355 Widget dialog = (Widget) p->pointer;
5357 /* Clean up. */
5358 BLOCK_INPUT;
5359 XtUnmanageChild (dialog);
5360 XtDestroyWidget (dialog);
5361 x_menu_set_in_use (0);
5362 UNBLOCK_INPUT;
5364 return Qnil;
5368 DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
5369 doc: /* Read file name, prompting with PROMPT in directory DIR.
5370 Use a file selection dialog. Select DEFAULT-FILENAME in the dialog's file
5371 selection box, if specified. If MUSTMATCH is non-nil, the returned file
5372 or directory must exist.
5374 This function is only defined on MS Windows, and X Windows with the
5375 Motif or Gtk toolkits. With the Motif toolkit, ONLY-DIR-P is ignored.
5376 Otherwise, if ONLY-DIR-P is non-nil, the user can only select directories. */)
5377 (Lisp_Object prompt, Lisp_Object dir, Lisp_Object default_filename, Lisp_Object mustmatch, Lisp_Object only_dir_p)
5379 int result;
5380 struct frame *f = SELECTED_FRAME ();
5381 Lisp_Object file = Qnil;
5382 Lisp_Object decoded_file;
5383 Widget dialog, text, help;
5384 Arg al[10];
5385 int ac = 0;
5386 XmString dir_xmstring, pattern_xmstring;
5387 int count = SPECPDL_INDEX ();
5388 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
5390 check_x ();
5392 GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
5394 if (popup_activated ())
5395 error ("Trying to use a menu from within a menu-entry");
5397 CHECK_STRING (prompt);
5398 CHECK_STRING (dir);
5400 /* Prevent redisplay. */
5401 specbind (Qinhibit_redisplay, Qt);
5403 BLOCK_INPUT;
5405 /* Create the dialog with PROMPT as title, using DIR as initial
5406 directory and using "*" as pattern. */
5407 dir = Fexpand_file_name (dir, Qnil);
5408 dir_xmstring = XmStringCreateLocalized (SDATA (dir));
5409 pattern_xmstring = XmStringCreateLocalized ("*");
5411 XtSetArg (al[ac], XmNtitle, SDATA (prompt)); ++ac;
5412 XtSetArg (al[ac], XmNdirectory, dir_xmstring); ++ac;
5413 XtSetArg (al[ac], XmNpattern, pattern_xmstring); ++ac;
5414 XtSetArg (al[ac], XmNresizePolicy, XmRESIZE_GROW); ++ac;
5415 XtSetArg (al[ac], XmNdialogStyle, XmDIALOG_APPLICATION_MODAL); ++ac;
5416 dialog = XmCreateFileSelectionDialog (f->output_data.x->widget,
5417 "fsb", al, ac);
5418 XmStringFree (dir_xmstring);
5419 XmStringFree (pattern_xmstring);
5421 /* Add callbacks for OK and Cancel. */
5422 XtAddCallback (dialog, XmNokCallback, file_dialog_cb,
5423 (XtPointer) &result);
5424 XtAddCallback (dialog, XmNcancelCallback, file_dialog_cb,
5425 (XtPointer) &result);
5426 XtAddCallback (dialog, XmNunmapCallback, file_dialog_unmap_cb,
5427 (XtPointer) &result);
5429 /* Remove the help button since we can't display help. */
5430 help = XmFileSelectionBoxGetChild (dialog, XmDIALOG_HELP_BUTTON);
5431 XtUnmanageChild (help);
5433 /* Mark OK button as default. */
5434 XtVaSetValues (XmFileSelectionBoxGetChild (dialog, XmDIALOG_OK_BUTTON),
5435 XmNshowAsDefault, True, NULL);
5437 /* If MUSTMATCH is non-nil, disable the file entry field of the
5438 dialog, so that the user must select a file from the files list
5439 box. We can't remove it because we wouldn't have a way to get at
5440 the result file name, then. */
5441 text = XmFileSelectionBoxGetChild (dialog, XmDIALOG_TEXT);
5442 if (!NILP (mustmatch))
5444 Widget label;
5445 label = XmFileSelectionBoxGetChild (dialog, XmDIALOG_SELECTION_LABEL);
5446 XtSetSensitive (text, False);
5447 XtSetSensitive (label, False);
5450 /* Manage the dialog, so that list boxes get filled. */
5451 XtManageChild (dialog);
5453 if (STRINGP (default_filename))
5455 XmString default_xmstring;
5456 Widget wtext = XmFileSelectionBoxGetChild (dialog, XmDIALOG_TEXT);
5457 Widget list = XmFileSelectionBoxGetChild (dialog, XmDIALOG_LIST);
5459 XmTextPosition last_pos = XmTextFieldGetLastPosition (wtext);
5460 XmTextFieldReplace (wtext, 0, last_pos,
5461 (SDATA (Ffile_name_nondirectory (default_filename))));
5463 /* Select DEFAULT_FILENAME in the files list box. DEFAULT_FILENAME
5464 must include the path for this to work. */
5466 default_xmstring = XmStringCreateLocalized (SDATA (default_filename));
5468 if (XmListItemExists (list, default_xmstring))
5470 int item_pos = XmListItemPos (list, default_xmstring);
5471 /* Select the item and scroll it into view. */
5472 XmListSelectPos (list, item_pos, True);
5473 XmListSetPos (list, item_pos);
5476 XmStringFree (default_xmstring);
5479 record_unwind_protect (clean_up_file_dialog, make_save_value (dialog, 0));
5481 /* Process events until the user presses Cancel or OK. */
5482 x_menu_set_in_use (1);
5483 result = 0;
5484 while (result == 0)
5486 XEvent event;
5487 x_menu_wait_for_event (0);
5488 XtAppNextEvent (Xt_app_con, &event);
5489 if (event.type == KeyPress
5490 && FRAME_X_DISPLAY (f) == event.xkey.display)
5492 KeySym keysym = XLookupKeysym (&event.xkey, 0);
5494 /* Pop down on C-g. */
5495 if (keysym == XK_g && (event.xkey.state & ControlMask) != 0)
5496 XtUnmanageChild (dialog);
5499 (void) x_dispatch_event (&event, FRAME_X_DISPLAY (f));
5502 /* Get the result. */
5503 if (result == XmCR_OK)
5505 XmString text_string;
5506 String data;
5508 XtVaGetValues (dialog, XmNtextString, &text_string, NULL);
5509 XmStringGetLtoR (text_string, XmFONTLIST_DEFAULT_TAG, &data);
5510 XmStringFree (text_string);
5511 file = build_string (data);
5512 XtFree (data);
5514 else
5515 file = Qnil;
5517 UNBLOCK_INPUT;
5518 UNGCPRO;
5520 /* Make "Cancel" equivalent to C-g. */
5521 if (NILP (file))
5522 Fsignal (Qquit, Qnil);
5524 decoded_file = DECODE_FILE (file);
5526 return unbind_to (count, decoded_file);
5529 #endif /* USE_MOTIF */
5531 #ifdef USE_GTK
5533 static Lisp_Object
5534 clean_up_dialog (Lisp_Object arg)
5536 x_menu_set_in_use (0);
5538 return Qnil;
5541 DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
5542 doc: /* Read file name, prompting with PROMPT in directory DIR.
5543 Use a file selection dialog. Select DEFAULT-FILENAME in the dialog's file
5544 selection box, if specified. If MUSTMATCH is non-nil, the returned file
5545 or directory must exist.
5547 This function is only defined on MS Windows, and X Windows with the
5548 Motif or Gtk toolkits. With the Motif toolkit, ONLY-DIR-P is ignored.
5549 Otherwise, if ONLY-DIR-P is non-nil, the user can only select directories. */)
5550 (Lisp_Object prompt, Lisp_Object dir, Lisp_Object default_filename, Lisp_Object mustmatch, Lisp_Object only_dir_p)
5552 FRAME_PTR f = SELECTED_FRAME ();
5553 char *fn;
5554 Lisp_Object file = Qnil;
5555 Lisp_Object decoded_file;
5556 int count = SPECPDL_INDEX ();
5557 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
5558 char *cdef_file;
5560 check_x ();
5562 GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
5564 if (popup_activated ())
5565 error ("Trying to use a menu from within a menu-entry");
5567 CHECK_STRING (prompt);
5568 CHECK_STRING (dir);
5570 /* Prevent redisplay. */
5571 specbind (Qinhibit_redisplay, Qt);
5572 record_unwind_protect (clean_up_dialog, Qnil);
5574 BLOCK_INPUT;
5576 if (STRINGP (default_filename))
5577 cdef_file = SSDATA (default_filename);
5578 else
5579 cdef_file = SSDATA (dir);
5581 fn = xg_get_file_name (f, SSDATA (prompt), cdef_file,
5582 ! NILP (mustmatch),
5583 ! NILP (only_dir_p));
5585 if (fn)
5587 file = build_string (fn);
5588 xfree (fn);
5591 UNBLOCK_INPUT;
5592 UNGCPRO;
5594 /* Make "Cancel" equivalent to C-g. */
5595 if (NILP (file))
5596 Fsignal (Qquit, Qnil);
5598 decoded_file = DECODE_FILE (file);
5600 return unbind_to (count, decoded_file);
5604 #ifdef HAVE_FREETYPE
5606 DEFUN ("x-select-font", Fx_select_font, Sx_select_font, 0, 2, 0,
5607 doc: /* Read a font name using a GTK font selection dialog.
5608 Return a GTK-style font string corresponding to the selection.
5610 If FRAME is omitted or nil, it defaults to the selected frame. */)
5611 (Lisp_Object frame, Lisp_Object ignored)
5613 FRAME_PTR f = check_x_frame (frame);
5614 char *name;
5615 Lisp_Object font;
5616 Lisp_Object font_param;
5617 char *default_name = NULL;
5618 struct gcpro gcpro1, gcpro2;
5619 int count = SPECPDL_INDEX ();
5621 check_x ();
5623 if (popup_activated ())
5624 error ("Trying to use a menu from within a menu-entry");
5626 /* Prevent redisplay. */
5627 specbind (Qinhibit_redisplay, Qt);
5628 record_unwind_protect (clean_up_dialog, Qnil);
5630 BLOCK_INPUT;
5632 GCPRO2 (font_param, font);
5634 XSETFONT (font, FRAME_FONT (f));
5635 font_param = Ffont_get (font, intern (":name"));
5636 if (STRINGP (font_param))
5637 default_name = xstrdup (SSDATA (font_param));
5638 else
5640 font_param = Fframe_parameter (frame, Qfont_param);
5641 if (STRINGP (font_param))
5642 default_name = xstrdup (SSDATA (font_param));
5645 if (default_name == NULL && x_last_font_name != NULL)
5646 default_name = xstrdup (x_last_font_name);
5648 /* Convert fontconfig names to Gtk names, i.e. remove - before number */
5649 if (default_name)
5651 char *p = strrchr (default_name, '-');
5652 if (p)
5654 char *ep = p+1;
5655 while (isdigit (*ep))
5656 ++ep;
5657 if (*ep == '\0') *p = ' ';
5661 name = xg_get_font_name (f, default_name);
5662 xfree (default_name);
5664 if (name)
5666 font = build_string (name);
5667 g_free (x_last_font_name);
5668 x_last_font_name = name;
5671 UNBLOCK_INPUT;
5673 if (NILP (font))
5674 Fsignal (Qquit, Qnil);
5676 return unbind_to (count, font);
5678 #endif /* HAVE_FREETYPE */
5680 #endif /* USE_GTK */
5683 /***********************************************************************
5684 Keyboard
5685 ***********************************************************************/
5687 #ifdef HAVE_XKBGETKEYBOARD
5688 #include <X11/XKBlib.h>
5689 #include <X11/keysym.h>
5690 #endif
5692 DEFUN ("x-backspace-delete-keys-p", Fx_backspace_delete_keys_p,
5693 Sx_backspace_delete_keys_p, 0, 1, 0,
5694 doc: /* Check if both Backspace and Delete keys are on the keyboard of FRAME.
5695 FRAME nil means use the selected frame.
5696 Value is t if we know that both keys are present, and are mapped to the
5697 usual X keysyms. Value is `lambda' if we cannot determine if both keys are
5698 present and mapped to the usual X keysyms. */)
5699 (Lisp_Object frame)
5701 #ifdef HAVE_XKBGETKEYBOARD
5702 XkbDescPtr kb;
5703 struct frame *f = check_x_frame (frame);
5704 Display *dpy = FRAME_X_DISPLAY (f);
5705 Lisp_Object have_keys;
5706 int major, minor, op, event, error_code;
5708 BLOCK_INPUT;
5710 /* Check library version in case we're dynamically linked. */
5711 major = XkbMajorVersion;
5712 minor = XkbMinorVersion;
5713 if (!XkbLibraryVersion (&major, &minor))
5715 UNBLOCK_INPUT;
5716 return Qlambda;
5719 /* Check that the server supports XKB. */
5720 major = XkbMajorVersion;
5721 minor = XkbMinorVersion;
5722 if (!XkbQueryExtension (dpy, &op, &event, &error_code, &major, &minor))
5724 UNBLOCK_INPUT;
5725 return Qlambda;
5728 /* In this code we check that the keyboard has physical keys with names
5729 that start with BKSP (Backspace) and DELE (Delete), and that they
5730 generate keysym XK_BackSpace and XK_Delete respectively.
5731 This function is used to test if normal-erase-is-backspace should be
5732 turned on.
5733 An alternative approach would be to just check if XK_BackSpace and
5734 XK_Delete are mapped to any key. But if any of those are mapped to
5735 some non-intuitive key combination (Meta-Shift-Ctrl-whatever) and the
5736 user doesn't know about it, it is better to return false here.
5737 It is more obvious to the user what to do if she/he has two keys
5738 clearly marked with names/symbols and one key does something not
5739 expected (i.e. she/he then tries the other).
5740 The cases where Backspace/Delete is mapped to some other key combination
5741 are rare, and in those cases, normal-erase-is-backspace can be turned on
5742 manually. */
5744 have_keys = Qnil;
5745 kb = XkbGetMap (dpy, XkbAllMapComponentsMask, XkbUseCoreKbd);
5746 if (kb)
5748 int delete_keycode = 0, backspace_keycode = 0, i;
5750 if (XkbGetNames (dpy, XkbAllNamesMask, kb) == Success)
5752 for (i = kb->min_key_code;
5753 (i < kb->max_key_code
5754 && (delete_keycode == 0 || backspace_keycode == 0));
5755 ++i)
5757 /* The XKB symbolic key names can be seen most easily in
5758 the PS file generated by `xkbprint -label name
5759 $DISPLAY'. */
5760 if (memcmp ("DELE", kb->names->keys[i].name, 4) == 0)
5761 delete_keycode = i;
5762 else if (memcmp ("BKSP", kb->names->keys[i].name, 4) == 0)
5763 backspace_keycode = i;
5766 XkbFreeNames (kb, 0, True);
5769 XkbFreeClientMap (kb, 0, True);
5771 if (delete_keycode
5772 && backspace_keycode
5773 && XKeysymToKeycode (dpy, XK_Delete) == delete_keycode
5774 && XKeysymToKeycode (dpy, XK_BackSpace) == backspace_keycode)
5775 have_keys = Qt;
5777 UNBLOCK_INPUT;
5778 return have_keys;
5779 #else /* not HAVE_XKBGETKEYBOARD */
5780 return Qlambda;
5781 #endif /* not HAVE_XKBGETKEYBOARD */
5786 /***********************************************************************
5787 Initialization
5788 ***********************************************************************/
5790 /* Keep this list in the same order as frame_parms in frame.c.
5791 Use 0 for unsupported frame parameters. */
5793 frame_parm_handler x_frame_parm_handlers[] =
5795 x_set_autoraise,
5796 x_set_autolower,
5797 x_set_background_color,
5798 x_set_border_color,
5799 x_set_border_width,
5800 x_set_cursor_color,
5801 x_set_cursor_type,
5802 x_set_font,
5803 x_set_foreground_color,
5804 x_set_icon_name,
5805 x_set_icon_type,
5806 x_set_internal_border_width,
5807 x_set_menu_bar_lines,
5808 x_set_mouse_color,
5809 x_explicitly_set_name,
5810 x_set_scroll_bar_width,
5811 x_set_title,
5812 x_set_unsplittable,
5813 x_set_vertical_scroll_bars,
5814 x_set_visibility,
5815 x_set_tool_bar_lines,
5816 x_set_scroll_bar_foreground,
5817 x_set_scroll_bar_background,
5818 x_set_screen_gamma,
5819 x_set_line_spacing,
5820 x_set_fringe_width,
5821 x_set_fringe_width,
5822 x_set_wait_for_wm,
5823 x_set_fullscreen,
5824 x_set_font_backend,
5825 x_set_alpha,
5826 x_set_sticky,
5827 x_set_tool_bar_position,
5830 void
5831 syms_of_xfns (void)
5833 /* This is zero if not using X windows. */
5834 x_in_use = 0;
5836 /* The section below is built by the lisp expression at the top of the file,
5837 just above where these variables are declared. */
5838 /*&&& init symbols here &&&*/
5839 DEFSYM (Qnone, "none");
5840 DEFSYM (Qsuppress_icon, "suppress-icon");
5841 DEFSYM (Qundefined_color, "undefined-color");
5842 DEFSYM (Qcompound_text, "compound-text");
5843 DEFSYM (Qcancel_timer, "cancel-timer");
5844 DEFSYM (Qfont_param, "font-parameter");
5845 /* This is the end of symbol initialization. */
5847 Fput (Qundefined_color, Qerror_conditions,
5848 pure_cons (Qundefined_color, pure_cons (Qerror, Qnil)));
5849 Fput (Qundefined_color, Qerror_message,
5850 make_pure_c_string ("Undefined color"));
5852 DEFVAR_LISP ("x-pointer-shape", Vx_pointer_shape,
5853 doc: /* The shape of the pointer when over text.
5854 Changing the value does not affect existing frames
5855 unless you set the mouse color. */);
5856 Vx_pointer_shape = Qnil;
5858 #if 0 /* This doesn't really do anything. */
5859 DEFVAR_LISP ("x-nontext-pointer-shape", Vx_nontext_pointer_shape,
5860 doc: /* The shape of the pointer when not over text.
5861 This variable takes effect when you create a new frame
5862 or when you set the mouse color. */);
5863 #endif
5864 Vx_nontext_pointer_shape = Qnil;
5866 DEFVAR_LISP ("x-hourglass-pointer-shape", Vx_hourglass_pointer_shape,
5867 doc: /* The shape of the pointer when Emacs is busy.
5868 This variable takes effect when you create a new frame
5869 or when you set the mouse color. */);
5870 Vx_hourglass_pointer_shape = Qnil;
5872 #if 0 /* This doesn't really do anything. */
5873 DEFVAR_LISP ("x-mode-pointer-shape", Vx_mode_pointer_shape,
5874 doc: /* The shape of the pointer when over the mode line.
5875 This variable takes effect when you create a new frame
5876 or when you set the mouse color. */);
5877 #endif
5878 Vx_mode_pointer_shape = Qnil;
5880 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
5881 Vx_sensitive_text_pointer_shape,
5882 doc: /* The shape of the pointer when over mouse-sensitive text.
5883 This variable takes effect when you create a new frame
5884 or when you set the mouse color. */);
5885 Vx_sensitive_text_pointer_shape = Qnil;
5887 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
5888 Vx_window_horizontal_drag_shape,
5889 doc: /* Pointer shape to use for indicating a window can be dragged horizontally.
5890 This variable takes effect when you create a new frame
5891 or when you set the mouse color. */);
5892 Vx_window_horizontal_drag_shape = Qnil;
5894 DEFVAR_LISP ("x-cursor-fore-pixel", Vx_cursor_fore_pixel,
5895 doc: /* A string indicating the foreground color of the cursor box. */);
5896 Vx_cursor_fore_pixel = Qnil;
5898 DEFVAR_LISP ("x-max-tooltip-size", Vx_max_tooltip_size,
5899 doc: /* Maximum size for tooltips.
5900 Value is a pair (COLUMNS . ROWS). Text larger than this is clipped. */);
5901 Vx_max_tooltip_size = Fcons (make_number (80), make_number (40));
5903 DEFVAR_LISP ("x-no-window-manager", Vx_no_window_manager,
5904 doc: /* Non-nil if no X window manager is in use.
5905 Emacs doesn't try to figure this out; this is always nil
5906 unless you set it to something else. */);
5907 /* We don't have any way to find this out, so set it to nil
5908 and maybe the user would like to set it to t. */
5909 Vx_no_window_manager = Qnil;
5911 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
5912 Vx_pixel_size_width_font_regexp,
5913 doc: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
5915 Since Emacs gets width of a font matching with this regexp from
5916 PIXEL_SIZE field of the name, font finding mechanism gets faster for
5917 such a font. This is especially effective for such large fonts as
5918 Chinese, Japanese, and Korean. */);
5919 Vx_pixel_size_width_font_regexp = Qnil;
5921 /* This is not ifdef:ed, so other builds than GTK can customize it. */
5922 DEFVAR_BOOL ("x-gtk-use-old-file-dialog", x_gtk_use_old_file_dialog,
5923 doc: /* *Non-nil means prompt with the old GTK file selection dialog.
5924 If nil or if the file selection dialog is not available, the new GTK file
5925 chooser is used instead. To turn off all file dialogs set the
5926 variable `use-file-dialog'. */);
5927 x_gtk_use_old_file_dialog = 0;
5929 DEFVAR_BOOL ("x-gtk-show-hidden-files", x_gtk_show_hidden_files,
5930 doc: /* *If non-nil, the GTK file chooser will by default show hidden files.
5931 Note that this is just the default, there is a toggle button on the file
5932 chooser to show or not show hidden files on a case by case basis. */);
5933 x_gtk_show_hidden_files = 0;
5935 DEFVAR_BOOL ("x-gtk-file-dialog-help-text", x_gtk_file_dialog_help_text,
5936 doc: /* *If non-nil, the GTK file chooser will show additional help text.
5937 If more space for files in the file chooser dialog is wanted, set this to nil
5938 to turn the additional text off. */);
5939 x_gtk_file_dialog_help_text = 1;
5941 DEFVAR_BOOL ("x-gtk-whole-detached-tool-bar", x_gtk_whole_detached_tool_bar,
5942 doc: /* *If non-nil, a detached tool bar is shown in full.
5943 The default is to just show an arrow and pressing on that arrow shows
5944 the tool bar buttons. */);
5945 x_gtk_whole_detached_tool_bar = 0;
5947 DEFVAR_BOOL ("x-gtk-use-system-tooltips", x_gtk_use_system_tooltips,
5948 doc: /* *If non-nil with a Gtk+ built Emacs, the Gtk+ tooltip is used.
5949 Otherwise use Emacs own tooltip implementation.
5950 When using Gtk+ tooltips, the tooltip face is not used. */);
5951 x_gtk_use_system_tooltips = 1;
5953 Fprovide (intern_c_string ("x"), Qnil);
5955 #ifdef USE_X_TOOLKIT
5956 Fprovide (intern_c_string ("x-toolkit"), Qnil);
5957 #ifdef USE_MOTIF
5958 Fprovide (intern_c_string ("motif"), Qnil);
5960 DEFVAR_LISP ("motif-version-string", Vmotif_version_string,
5961 doc: /* Version info for LessTif/Motif. */);
5962 Vmotif_version_string = build_string (XmVERSION_STRING);
5963 #endif /* USE_MOTIF */
5964 #endif /* USE_X_TOOLKIT */
5966 #ifdef USE_GTK
5967 /* Provide x-toolkit also for GTK. Internally GTK does not use Xt so it
5968 is not an X toolkit in that sense (USE_X_TOOLKIT is not defined).
5969 But for a user it is a toolkit for X, and indeed, configure
5970 accepts --with-x-toolkit=gtk. */
5971 Fprovide (intern_c_string ("x-toolkit"), Qnil);
5972 Fprovide (intern_c_string ("gtk"), Qnil);
5973 Fprovide (intern_c_string ("move-toolbar"), Qnil);
5975 DEFVAR_LISP ("gtk-version-string", Vgtk_version_string,
5976 doc: /* Version info for GTK+. */);
5978 char gtk_version[40];
5979 g_snprintf (gtk_version, sizeof (gtk_version), "%u.%u.%u",
5980 GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION);
5981 Vgtk_version_string = make_pure_string (gtk_version, strlen (gtk_version), strlen (gtk_version), 0);
5983 #endif /* USE_GTK */
5985 /* X window properties. */
5986 defsubr (&Sx_change_window_property);
5987 defsubr (&Sx_delete_window_property);
5988 defsubr (&Sx_window_property);
5990 defsubr (&Sxw_display_color_p);
5991 defsubr (&Sx_display_grayscale_p);
5992 defsubr (&Sxw_color_defined_p);
5993 defsubr (&Sxw_color_values);
5994 defsubr (&Sx_server_max_request_size);
5995 defsubr (&Sx_server_vendor);
5996 defsubr (&Sx_server_version);
5997 defsubr (&Sx_display_pixel_width);
5998 defsubr (&Sx_display_pixel_height);
5999 defsubr (&Sx_display_mm_width);
6000 defsubr (&Sx_display_mm_height);
6001 defsubr (&Sx_display_screens);
6002 defsubr (&Sx_display_planes);
6003 defsubr (&Sx_display_color_cells);
6004 defsubr (&Sx_display_visual_class);
6005 defsubr (&Sx_display_backing_store);
6006 defsubr (&Sx_display_save_under);
6007 defsubr (&Sx_wm_set_size_hint);
6008 defsubr (&Sx_create_frame);
6009 defsubr (&Sx_open_connection);
6010 defsubr (&Sx_close_connection);
6011 defsubr (&Sx_display_list);
6012 defsubr (&Sx_synchronize);
6013 defsubr (&Sx_focus_frame);
6014 defsubr (&Sx_backspace_delete_keys_p);
6016 /* Setting callback functions for fontset handler. */
6017 check_window_system_func = check_x;
6019 defsubr (&Sx_show_tip);
6020 defsubr (&Sx_hide_tip);
6021 tip_timer = Qnil;
6022 staticpro (&tip_timer);
6023 tip_frame = Qnil;
6024 staticpro (&tip_frame);
6026 last_show_tip_args = Qnil;
6027 staticpro (&last_show_tip_args);
6029 defsubr (&Sx_uses_old_gtk_dialog);
6030 #if defined (USE_MOTIF) || defined (USE_GTK)
6031 defsubr (&Sx_file_dialog);
6032 #endif
6034 #if defined (USE_GTK) && defined (HAVE_FREETYPE)
6035 defsubr (&Sx_select_font);
6036 x_last_font_name = NULL;
6037 #endif
6040 #endif /* HAVE_X_WINDOWS */