Merge from emacs-24; up to 2012-04-25T15:23:19Z!sdl.web@gmail.com
[emacs.git] / src / xfns.c
blob43ccdfaef1a481cf6aafbbc8ba8bb575f65705bb
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 /* Nonzero if using X. */
131 int x_in_use;
133 static Lisp_Object Qnone;
134 static Lisp_Object Qsuppress_icon;
135 static Lisp_Object Qundefined_color;
136 static Lisp_Object Qcompound_text, Qcancel_timer;
137 Lisp_Object Qfont_param;
139 #if GLYPH_DEBUG
140 static ptrdiff_t image_cache_refcount;
141 static int dpyinfo_refcount;
142 #endif
144 #if defined (USE_GTK) && defined (HAVE_FREETYPE)
145 static char *x_last_font_name;
146 #endif
148 static struct x_display_info *x_display_info_for_name (Lisp_Object);
151 /* Error if we are not connected to X. */
153 void
154 check_x (void)
156 if (! x_in_use)
157 error ("X windows are not in use or not initialized");
160 /* Nonzero if we can use mouse menus.
161 You should not call this unless HAVE_MENUS is defined. */
164 have_menus_p (void)
166 return x_in_use;
169 /* Extract a frame as a FRAME_PTR, defaulting to the selected frame
170 and checking validity for X. */
172 FRAME_PTR
173 check_x_frame (Lisp_Object frame)
175 FRAME_PTR f;
177 if (NILP (frame))
178 frame = selected_frame;
179 CHECK_LIVE_FRAME (frame);
180 f = XFRAME (frame);
181 if (! FRAME_X_P (f))
182 error ("Non-X frame used");
183 return f;
186 /* Let the user specify an X display with a Lisp object.
187 OBJECT may be nil, a frame or a terminal object.
188 nil stands for the selected frame--or, if that is not an X frame,
189 the first X display on the list. */
191 struct x_display_info *
192 check_x_display_info (Lisp_Object object)
194 struct x_display_info *dpyinfo = NULL;
196 if (NILP (object))
198 struct frame *sf = XFRAME (selected_frame);
200 if (FRAME_X_P (sf) && FRAME_LIVE_P (sf))
201 dpyinfo = FRAME_X_DISPLAY_INFO (sf);
202 else if (x_display_list != 0)
203 dpyinfo = x_display_list;
204 else
205 error ("X windows are not in use or not initialized");
207 else if (TERMINALP (object))
209 struct terminal *t = get_terminal (object, 1);
211 if (t->type != output_x_window)
212 error ("Terminal %"pI"d is not an X display", XINT (object));
214 dpyinfo = t->display_info.x;
216 else if (STRINGP (object))
217 dpyinfo = x_display_info_for_name (object);
218 else
220 FRAME_PTR f = check_x_frame (object);
221 dpyinfo = FRAME_X_DISPLAY_INFO (f);
224 return dpyinfo;
228 /* Return the Emacs frame-object corresponding to an X window.
229 It could be the frame's main window or an icon window. */
231 /* This function can be called during GC, so use GC_xxx type test macros. */
233 struct frame *
234 x_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
236 Lisp_Object tail, frame;
237 struct frame *f;
239 if (wdesc == None) return 0;
241 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
243 frame = XCAR (tail);
244 if (!FRAMEP (frame))
245 continue;
246 f = XFRAME (frame);
247 if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
248 continue;
249 if (f->output_data.x->hourglass_window == wdesc)
250 return f;
251 #ifdef USE_X_TOOLKIT
252 if ((f->output_data.x->edit_widget
253 && XtWindow (f->output_data.x->edit_widget) == wdesc)
254 /* A tooltip frame? */
255 || (!f->output_data.x->edit_widget
256 && FRAME_X_WINDOW (f) == wdesc)
257 || f->output_data.x->icon_desc == wdesc)
258 return f;
259 #else /* not USE_X_TOOLKIT */
260 #ifdef USE_GTK
261 if (f->output_data.x->edit_widget)
263 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
264 struct x_output *x = f->output_data.x;
265 if (gwdesc != 0 && gwdesc == x->edit_widget)
266 return f;
268 #endif /* USE_GTK */
269 if (FRAME_X_WINDOW (f) == wdesc
270 || f->output_data.x->icon_desc == wdesc)
271 return f;
272 #endif /* not USE_X_TOOLKIT */
274 return 0;
277 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
278 /* Like x_window_to_frame but also compares the window with the widget's
279 windows. */
281 struct frame *
282 x_any_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
284 Lisp_Object tail, frame;
285 struct frame *f, *found;
286 struct x_output *x;
288 if (wdesc == None) return NULL;
290 found = NULL;
291 for (tail = Vframe_list; CONSP (tail) && !found; tail = XCDR (tail))
293 frame = XCAR (tail);
294 if (!FRAMEP (frame))
295 continue;
297 f = XFRAME (frame);
298 if (FRAME_X_P (f) && FRAME_X_DISPLAY_INFO (f) == dpyinfo)
300 /* This frame matches if the window is any of its widgets. */
301 x = f->output_data.x;
302 if (x->hourglass_window == wdesc)
303 found = f;
304 else if (x->widget)
306 #ifdef USE_GTK
307 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
308 if (gwdesc != 0
309 && gtk_widget_get_toplevel (gwdesc) == x->widget)
310 found = f;
311 #else
312 if (wdesc == XtWindow (x->widget)
313 || wdesc == XtWindow (x->column_widget)
314 || wdesc == XtWindow (x->edit_widget))
315 found = f;
316 /* Match if the window is this frame's menubar. */
317 else if (lw_window_is_in_menubar (wdesc, x->menubar_widget))
318 found = f;
319 #endif
321 else if (FRAME_X_WINDOW (f) == wdesc)
322 /* A tooltip frame. */
323 found = f;
327 return found;
330 /* Likewise, but consider only the menu bar widget. */
332 struct frame *
333 x_menubar_window_to_frame (struct x_display_info *dpyinfo, XEvent *event)
335 Window wdesc = event->xany.window;
336 Lisp_Object tail, frame;
337 struct frame *f;
338 struct x_output *x;
340 if (wdesc == None) return 0;
342 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
344 frame = XCAR (tail);
345 if (!FRAMEP (frame))
346 continue;
347 f = XFRAME (frame);
348 if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
349 continue;
350 x = f->output_data.x;
351 #ifdef USE_GTK
352 if (x->menubar_widget && xg_event_is_for_menubar (f, event))
353 return f;
354 #else
355 /* Match if the window is this frame's menubar. */
356 if (x->menubar_widget
357 && lw_window_is_in_menubar (wdesc, x->menubar_widget))
358 return f;
359 #endif
361 return 0;
364 /* Return the frame whose principal (outermost) window is WDESC.
365 If WDESC is some other (smaller) window, we return 0. */
367 struct frame *
368 x_top_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
370 Lisp_Object tail, frame;
371 struct frame *f;
372 struct x_output *x;
374 if (wdesc == None) return 0;
376 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
378 frame = XCAR (tail);
379 if (!FRAMEP (frame))
380 continue;
381 f = XFRAME (frame);
382 if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
383 continue;
384 x = f->output_data.x;
386 if (x->widget)
388 /* This frame matches if the window is its topmost widget. */
389 #ifdef USE_GTK
390 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
391 if (gwdesc == x->widget)
392 return f;
393 #else
394 if (wdesc == XtWindow (x->widget))
395 return f;
396 #if 0 /* I don't know why it did this,
397 but it seems logically wrong,
398 and it causes trouble for MapNotify events. */
399 /* Match if the window is this frame's menubar. */
400 if (x->menubar_widget
401 && wdesc == XtWindow (x->menubar_widget))
402 return f;
403 #endif
404 #endif
406 else if (FRAME_X_WINDOW (f) == wdesc)
407 /* Tooltip frame. */
408 return f;
410 return 0;
412 #endif /* USE_X_TOOLKIT || USE_GTK */
416 /* Store the screen positions of frame F into XPTR and YPTR.
417 These are the positions of the containing window manager window,
418 not Emacs's own window. */
420 void
421 x_real_positions (FRAME_PTR f, int *xptr, int *yptr)
423 int win_x, win_y, outer_x IF_LINT (= 0), outer_y IF_LINT (= 0);
424 int real_x = 0, real_y = 0;
425 int had_errors = 0;
426 Window win = f->output_data.x->parent_desc;
427 Atom actual_type;
428 unsigned long actual_size, bytes_remaining;
429 int rc, actual_format;
430 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
431 long max_len = 400;
432 Display *dpy = FRAME_X_DISPLAY (f);
433 unsigned char *tmp_data = NULL;
434 Atom target_type = XA_CARDINAL;
436 BLOCK_INPUT;
438 x_catch_errors (dpy);
440 if (win == dpyinfo->root_window)
441 win = FRAME_OUTER_WINDOW (f);
443 /* This loop traverses up the containment tree until we hit the root
444 window. Window managers may intersect many windows between our window
445 and the root window. The window we find just before the root window
446 should be the outer WM window. */
447 for (;;)
449 Window wm_window, rootw;
450 Window *tmp_children;
451 unsigned int tmp_nchildren;
452 int success;
454 success = XQueryTree (FRAME_X_DISPLAY (f), win, &rootw,
455 &wm_window, &tmp_children, &tmp_nchildren);
457 had_errors = x_had_errors_p (FRAME_X_DISPLAY (f));
459 /* Don't free tmp_children if XQueryTree failed. */
460 if (! success)
461 break;
463 XFree ((char *) tmp_children);
465 if (wm_window == rootw || had_errors)
466 break;
468 win = wm_window;
471 if (! had_errors)
473 unsigned int ign;
474 Window child, rootw;
476 /* Get the real coordinates for the WM window upper left corner */
477 XGetGeometry (FRAME_X_DISPLAY (f), win,
478 &rootw, &real_x, &real_y, &ign, &ign, &ign, &ign);
480 /* Translate real coordinates to coordinates relative to our
481 window. For our window, the upper left corner is 0, 0.
482 Since the upper left corner of the WM window is outside
483 our window, win_x and win_y will be negative:
485 ------------------ ---> x
486 | title |
487 | ----------------- v y
488 | | our window
490 XTranslateCoordinates (FRAME_X_DISPLAY (f),
492 /* From-window, to-window. */
493 FRAME_X_DISPLAY_INFO (f)->root_window,
494 FRAME_X_WINDOW (f),
496 /* From-position, to-position. */
497 real_x, real_y, &win_x, &win_y,
499 /* Child of win. */
500 &child);
502 if (FRAME_X_WINDOW (f) == FRAME_OUTER_WINDOW (f))
504 outer_x = win_x;
505 outer_y = win_y;
507 else
509 XTranslateCoordinates (FRAME_X_DISPLAY (f),
511 /* From-window, to-window. */
512 FRAME_X_DISPLAY_INFO (f)->root_window,
513 FRAME_OUTER_WINDOW (f),
515 /* From-position, to-position. */
516 real_x, real_y, &outer_x, &outer_y,
518 /* Child of win. */
519 &child);
522 had_errors = x_had_errors_p (FRAME_X_DISPLAY (f));
526 if (dpyinfo->root_window == f->output_data.x->parent_desc)
528 /* Try _NET_FRAME_EXTENTS if our parent is the root window. */
529 rc = XGetWindowProperty (dpy, win, dpyinfo->Xatom_net_frame_extents,
530 0, max_len, False, target_type,
531 &actual_type, &actual_format, &actual_size,
532 &bytes_remaining, &tmp_data);
534 if (rc == Success && actual_type == target_type && !x_had_errors_p (dpy)
535 && actual_size == 4 && actual_format == 32)
537 unsigned int ign;
538 Window rootw;
539 long *fe = (long *)tmp_data;
541 XGetGeometry (FRAME_X_DISPLAY (f), win,
542 &rootw, &real_x, &real_y, &ign, &ign, &ign, &ign);
543 outer_x = -fe[0];
544 outer_y = -fe[2];
545 real_x -= fe[0];
546 real_y -= fe[2];
550 if (tmp_data) XFree (tmp_data);
552 x_uncatch_errors ();
554 UNBLOCK_INPUT;
556 if (had_errors) return;
558 f->x_pixels_diff = -win_x;
559 f->y_pixels_diff = -win_y;
561 FRAME_X_OUTPUT (f)->x_pixels_outer_diff = -outer_x;
562 FRAME_X_OUTPUT (f)->y_pixels_outer_diff = -outer_y;
564 *xptr = real_x;
565 *yptr = real_y;
571 /* Gamma-correct COLOR on frame F. */
573 void
574 gamma_correct (struct frame *f, XColor *color)
576 if (f->gamma)
578 color->red = pow (color->red / 65535.0, f->gamma) * 65535.0 + 0.5;
579 color->green = pow (color->green / 65535.0, f->gamma) * 65535.0 + 0.5;
580 color->blue = pow (color->blue / 65535.0, f->gamma) * 65535.0 + 0.5;
585 /* Decide if color named COLOR_NAME is valid for use on frame F. If
586 so, return the RGB values in COLOR. If ALLOC_P is non-zero,
587 allocate the color. Value is zero if COLOR_NAME is invalid, or
588 no color could be allocated. */
591 x_defined_color (struct frame *f, const char *color_name,
592 XColor *color, int alloc_p)
594 int success_p = 0;
595 Display *dpy = FRAME_X_DISPLAY (f);
596 Colormap cmap = FRAME_X_COLORMAP (f);
598 BLOCK_INPUT;
599 #ifdef USE_GTK
600 success_p = xg_check_special_colors (f, color_name, color);
601 #endif
602 if (!success_p)
603 success_p = XParseColor (dpy, cmap, color_name, color);
604 if (success_p && alloc_p)
605 success_p = x_alloc_nearest_color (f, cmap, color);
606 UNBLOCK_INPUT;
608 return success_p;
612 /* Return the pixel color value for color COLOR_NAME on frame F. If F
613 is a monochrome frame, return MONO_COLOR regardless of what ARG says.
614 Signal an error if color can't be allocated. */
616 static int
617 x_decode_color (FRAME_PTR f, Lisp_Object color_name, int mono_color)
619 XColor cdef;
621 CHECK_STRING (color_name);
623 #if 0 /* Don't do this. It's wrong when we're not using the default
624 colormap, it makes freeing difficult, and it's probably not
625 an important optimization. */
626 if (strcmp (SDATA (color_name), "black") == 0)
627 return BLACK_PIX_DEFAULT (f);
628 else if (strcmp (SDATA (color_name), "white") == 0)
629 return WHITE_PIX_DEFAULT (f);
630 #endif
632 /* Return MONO_COLOR for monochrome frames. */
633 if (FRAME_X_DISPLAY_INFO (f)->n_planes == 1)
634 return mono_color;
636 /* x_defined_color is responsible for coping with failures
637 by looking for a near-miss. */
638 if (x_defined_color (f, SSDATA (color_name), &cdef, 1))
639 return cdef.pixel;
641 signal_error ("Undefined color", color_name);
646 /* Change the `wait-for-wm' frame parameter of frame F. OLD_VALUE is
647 the previous value of that parameter, NEW_VALUE is the new value.
648 See also the comment of wait_for_wm in struct x_output. */
650 static void
651 x_set_wait_for_wm (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
653 f->output_data.x->wait_for_wm = !NILP (new_value);
656 static void
657 x_set_tool_bar_position (struct frame *f,
658 Lisp_Object new_value,
659 Lisp_Object old_value)
661 if (! EQ (new_value, Qleft) && ! EQ (new_value, Qright)
662 && ! EQ (new_value, Qbottom) && ! EQ (new_value, Qtop))
663 return;
664 if (EQ (new_value, old_value)) return;
666 #ifdef USE_GTK
667 if (xg_change_toolbar_position (f, new_value))
668 f->tool_bar_position = new_value;
669 #endif
672 #ifdef USE_GTK
674 /* Set icon from FILE for frame F. By using GTK functions the icon
675 may be any format that GdkPixbuf knows about, i.e. not just bitmaps. */
678 xg_set_icon (FRAME_PTR f, Lisp_Object file)
680 int result = 0;
681 Lisp_Object found;
683 found = x_find_image_file (file);
685 if (! NILP (found))
687 GdkPixbuf *pixbuf;
688 GError *err = NULL;
689 char *filename = SSDATA (found);
690 BLOCK_INPUT;
692 pixbuf = gdk_pixbuf_new_from_file (filename, &err);
694 if (pixbuf)
696 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
697 pixbuf);
698 g_object_unref (pixbuf);
700 result = 1;
702 else
703 g_error_free (err);
705 UNBLOCK_INPUT;
708 return result;
712 xg_set_icon_from_xpm_data (FRAME_PTR f, const char **data)
714 GdkPixbuf *pixbuf = gdk_pixbuf_new_from_xpm_data (data);
716 if (!pixbuf)
717 return 0;
719 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)), pixbuf);
720 g_object_unref (pixbuf);
721 return 1;
723 #endif /* USE_GTK */
726 /* Functions called only from `x_set_frame_param'
727 to set individual parameters.
729 If FRAME_X_WINDOW (f) is 0,
730 the frame is being created and its X-window does not exist yet.
731 In that case, just record the parameter's new value
732 in the standard place; do not attempt to change the window. */
734 static void
735 x_set_foreground_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
737 struct x_output *x = f->output_data.x;
738 unsigned long fg, old_fg;
740 fg = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
741 old_fg = FRAME_FOREGROUND_PIXEL (f);
742 FRAME_FOREGROUND_PIXEL (f) = fg;
744 if (FRAME_X_WINDOW (f) != 0)
746 Display *dpy = FRAME_X_DISPLAY (f);
748 BLOCK_INPUT;
749 XSetForeground (dpy, x->normal_gc, fg);
750 XSetBackground (dpy, x->reverse_gc, fg);
752 if (x->cursor_pixel == old_fg)
754 unload_color (f, x->cursor_pixel);
755 x->cursor_pixel = x_copy_color (f, fg);
756 XSetBackground (dpy, x->cursor_gc, x->cursor_pixel);
759 UNBLOCK_INPUT;
761 update_face_from_frame_parameter (f, Qforeground_color, arg);
763 if (FRAME_VISIBLE_P (f))
764 redraw_frame (f);
767 unload_color (f, old_fg);
770 static void
771 x_set_background_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
773 struct x_output *x = f->output_data.x;
774 unsigned long bg;
776 bg = x_decode_color (f, arg, WHITE_PIX_DEFAULT (f));
777 unload_color (f, FRAME_BACKGROUND_PIXEL (f));
778 FRAME_BACKGROUND_PIXEL (f) = bg;
780 if (FRAME_X_WINDOW (f) != 0)
782 Display *dpy = FRAME_X_DISPLAY (f);
784 BLOCK_INPUT;
785 XSetBackground (dpy, x->normal_gc, bg);
786 XSetForeground (dpy, x->reverse_gc, bg);
787 XSetWindowBackground (dpy, FRAME_X_WINDOW (f), bg);
788 XSetForeground (dpy, x->cursor_gc, bg);
790 #ifdef USE_GTK
791 xg_set_background_color (f, bg);
792 #endif
794 #ifndef USE_TOOLKIT_SCROLL_BARS /* Turns out to be annoying with
795 toolkit scroll bars. */
797 Lisp_Object bar;
798 for (bar = FRAME_SCROLL_BARS (f);
799 !NILP (bar);
800 bar = XSCROLL_BAR (bar)->next)
802 Window window = XSCROLL_BAR (bar)->x_window;
803 XSetWindowBackground (dpy, window, bg);
806 #endif /* USE_TOOLKIT_SCROLL_BARS */
808 UNBLOCK_INPUT;
809 update_face_from_frame_parameter (f, Qbackground_color, arg);
811 if (FRAME_VISIBLE_P (f))
812 redraw_frame (f);
816 static Cursor
817 make_invisible_cursor (struct frame *f)
819 Display *dpy = FRAME_X_DISPLAY (f);
820 static char const no_data[] = { 0 };
821 Pixmap pix;
822 XColor col;
823 Cursor c = 0;
825 x_catch_errors (dpy);
826 pix = XCreateBitmapFromData (dpy, FRAME_X_DISPLAY_INFO (f)->root_window,
827 no_data, 1, 1);
828 if (! x_had_errors_p (dpy) && pix != None)
830 Cursor pixc;
831 col.pixel = 0;
832 col.red = col.green = col.blue = 0;
833 col.flags = DoRed | DoGreen | DoBlue;
834 pixc = XCreatePixmapCursor (dpy, pix, pix, &col, &col, 0, 0);
835 if (! x_had_errors_p (dpy) && pixc != None)
836 c = pixc;
837 XFreePixmap (dpy, pix);
840 x_uncatch_errors ();
842 return c;
845 static void
846 x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
848 struct x_output *x = f->output_data.x;
849 Display *dpy = FRAME_X_DISPLAY (f);
850 Cursor cursor, nontext_cursor, mode_cursor, hand_cursor;
851 Cursor hourglass_cursor, horizontal_drag_cursor;
852 unsigned long pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
853 unsigned long mask_color = FRAME_BACKGROUND_PIXEL (f);
855 /* Don't let pointers be invisible. */
856 if (mask_color == pixel)
858 x_free_colors (f, &pixel, 1);
859 pixel = x_copy_color (f, FRAME_FOREGROUND_PIXEL (f));
862 unload_color (f, x->mouse_pixel);
863 x->mouse_pixel = pixel;
865 BLOCK_INPUT;
867 /* It's not okay to crash if the user selects a screwy cursor. */
868 x_catch_errors (dpy);
870 if (!NILP (Vx_pointer_shape))
872 CHECK_NUMBER (Vx_pointer_shape);
873 cursor = XCreateFontCursor (dpy, XINT (Vx_pointer_shape));
875 else
876 cursor = XCreateFontCursor (dpy, XC_xterm);
877 x_check_errors (dpy, "bad text pointer cursor: %s");
879 if (!NILP (Vx_nontext_pointer_shape))
881 CHECK_NUMBER (Vx_nontext_pointer_shape);
882 nontext_cursor
883 = XCreateFontCursor (dpy, XINT (Vx_nontext_pointer_shape));
885 else
886 nontext_cursor = XCreateFontCursor (dpy, XC_left_ptr);
887 x_check_errors (dpy, "bad nontext pointer cursor: %s");
889 if (!NILP (Vx_hourglass_pointer_shape))
891 CHECK_NUMBER (Vx_hourglass_pointer_shape);
892 hourglass_cursor
893 = XCreateFontCursor (dpy, XINT (Vx_hourglass_pointer_shape));
895 else
896 hourglass_cursor = XCreateFontCursor (dpy, XC_watch);
897 x_check_errors (dpy, "bad hourglass pointer cursor: %s");
899 if (!NILP (Vx_mode_pointer_shape))
901 CHECK_NUMBER (Vx_mode_pointer_shape);
902 mode_cursor = XCreateFontCursor (dpy, XINT (Vx_mode_pointer_shape));
904 else
905 mode_cursor = XCreateFontCursor (dpy, XC_xterm);
906 x_check_errors (dpy, "bad modeline pointer cursor: %s");
908 if (!NILP (Vx_sensitive_text_pointer_shape))
910 CHECK_NUMBER (Vx_sensitive_text_pointer_shape);
911 hand_cursor
912 = XCreateFontCursor (dpy, XINT (Vx_sensitive_text_pointer_shape));
914 else
915 hand_cursor = XCreateFontCursor (dpy, XC_hand2);
917 if (!NILP (Vx_window_horizontal_drag_shape))
919 CHECK_NUMBER (Vx_window_horizontal_drag_shape);
920 horizontal_drag_cursor
921 = XCreateFontCursor (dpy, XINT (Vx_window_horizontal_drag_shape));
923 else
924 horizontal_drag_cursor
925 = XCreateFontCursor (dpy, XC_sb_h_double_arrow);
927 /* Check and report errors with the above calls. */
928 x_check_errors (dpy, "can't set cursor shape: %s");
929 x_uncatch_errors ();
932 XColor fore_color, back_color;
934 fore_color.pixel = x->mouse_pixel;
935 x_query_color (f, &fore_color);
936 back_color.pixel = mask_color;
937 x_query_color (f, &back_color);
939 XRecolorCursor (dpy, cursor, &fore_color, &back_color);
940 XRecolorCursor (dpy, nontext_cursor, &fore_color, &back_color);
941 XRecolorCursor (dpy, mode_cursor, &fore_color, &back_color);
942 XRecolorCursor (dpy, hand_cursor, &fore_color, &back_color);
943 XRecolorCursor (dpy, hourglass_cursor, &fore_color, &back_color);
944 XRecolorCursor (dpy, horizontal_drag_cursor, &fore_color, &back_color);
947 if (FRAME_X_WINDOW (f) != 0)
948 XDefineCursor (dpy, FRAME_X_WINDOW (f),
949 f->output_data.x->current_cursor = cursor);
951 if (FRAME_X_DISPLAY_INFO (f)->invisible_cursor == 0)
952 FRAME_X_DISPLAY_INFO (f)->invisible_cursor = make_invisible_cursor (f);
954 if (cursor != x->text_cursor
955 && x->text_cursor != 0)
956 XFreeCursor (dpy, x->text_cursor);
957 x->text_cursor = cursor;
959 if (nontext_cursor != x->nontext_cursor
960 && x->nontext_cursor != 0)
961 XFreeCursor (dpy, x->nontext_cursor);
962 x->nontext_cursor = nontext_cursor;
964 if (hourglass_cursor != x->hourglass_cursor
965 && x->hourglass_cursor != 0)
966 XFreeCursor (dpy, x->hourglass_cursor);
967 x->hourglass_cursor = hourglass_cursor;
969 if (mode_cursor != x->modeline_cursor
970 && x->modeline_cursor != 0)
971 XFreeCursor (dpy, f->output_data.x->modeline_cursor);
972 x->modeline_cursor = mode_cursor;
974 if (hand_cursor != x->hand_cursor
975 && x->hand_cursor != 0)
976 XFreeCursor (dpy, x->hand_cursor);
977 x->hand_cursor = hand_cursor;
979 if (horizontal_drag_cursor != x->horizontal_drag_cursor
980 && x->horizontal_drag_cursor != 0)
981 XFreeCursor (dpy, x->horizontal_drag_cursor);
982 x->horizontal_drag_cursor = horizontal_drag_cursor;
984 XFlush (dpy);
985 UNBLOCK_INPUT;
987 update_face_from_frame_parameter (f, Qmouse_color, arg);
990 static void
991 x_set_cursor_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
993 unsigned long fore_pixel, pixel;
994 int fore_pixel_allocated_p = 0, pixel_allocated_p = 0;
995 struct x_output *x = f->output_data.x;
997 if (!NILP (Vx_cursor_fore_pixel))
999 fore_pixel = x_decode_color (f, Vx_cursor_fore_pixel,
1000 WHITE_PIX_DEFAULT (f));
1001 fore_pixel_allocated_p = 1;
1003 else
1004 fore_pixel = FRAME_BACKGROUND_PIXEL (f);
1006 pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
1007 pixel_allocated_p = 1;
1009 /* Make sure that the cursor color differs from the background color. */
1010 if (pixel == FRAME_BACKGROUND_PIXEL (f))
1012 if (pixel_allocated_p)
1014 x_free_colors (f, &pixel, 1);
1015 pixel_allocated_p = 0;
1018 pixel = x->mouse_pixel;
1019 if (pixel == fore_pixel)
1021 if (fore_pixel_allocated_p)
1023 x_free_colors (f, &fore_pixel, 1);
1024 fore_pixel_allocated_p = 0;
1026 fore_pixel = FRAME_BACKGROUND_PIXEL (f);
1030 unload_color (f, x->cursor_foreground_pixel);
1031 if (!fore_pixel_allocated_p)
1032 fore_pixel = x_copy_color (f, fore_pixel);
1033 x->cursor_foreground_pixel = fore_pixel;
1035 unload_color (f, x->cursor_pixel);
1036 if (!pixel_allocated_p)
1037 pixel = x_copy_color (f, pixel);
1038 x->cursor_pixel = pixel;
1040 if (FRAME_X_WINDOW (f) != 0)
1042 BLOCK_INPUT;
1043 XSetBackground (FRAME_X_DISPLAY (f), x->cursor_gc, x->cursor_pixel);
1044 XSetForeground (FRAME_X_DISPLAY (f), x->cursor_gc, fore_pixel);
1045 UNBLOCK_INPUT;
1047 if (FRAME_VISIBLE_P (f))
1049 x_update_cursor (f, 0);
1050 x_update_cursor (f, 1);
1054 update_face_from_frame_parameter (f, Qcursor_color, arg);
1057 /* Set the border-color of frame F to pixel value PIX.
1058 Note that this does not fully take effect if done before
1059 F has an x-window. */
1061 static void
1062 x_set_border_pixel (struct frame *f, int pix)
1064 unload_color (f, f->output_data.x->border_pixel);
1065 f->output_data.x->border_pixel = pix;
1067 if (FRAME_X_WINDOW (f) != 0 && f->border_width > 0)
1069 BLOCK_INPUT;
1070 XSetWindowBorder (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), pix);
1071 UNBLOCK_INPUT;
1073 if (FRAME_VISIBLE_P (f))
1074 redraw_frame (f);
1078 /* Set the border-color of frame F to value described by ARG.
1079 ARG can be a string naming a color.
1080 The border-color is used for the border that is drawn by the X server.
1081 Note that this does not fully take effect if done before
1082 F has an x-window; it must be redone when the window is created.
1084 Note: this is done in two routines because of the way X10 works.
1086 Note: under X11, this is normally the province of the window manager,
1087 and so emacs' border colors may be overridden. */
1089 static void
1090 x_set_border_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1092 int pix;
1094 CHECK_STRING (arg);
1095 pix = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
1096 x_set_border_pixel (f, pix);
1097 update_face_from_frame_parameter (f, Qborder_color, arg);
1101 static void
1102 x_set_cursor_type (FRAME_PTR f, Lisp_Object arg, Lisp_Object oldval)
1104 set_frame_cursor_types (f, arg);
1106 /* Make sure the cursor gets redrawn. */
1107 cursor_type_changed = 1;
1110 static void
1111 x_set_icon_type (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1113 int result;
1115 if (STRINGP (arg))
1117 if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
1118 return;
1120 else if (!STRINGP (oldval) && EQ (oldval, Qnil) == EQ (arg, Qnil))
1121 return;
1123 BLOCK_INPUT;
1124 if (NILP (arg))
1125 result = x_text_icon (f,
1126 SSDATA ((!NILP (f->icon_name)
1127 ? f->icon_name
1128 : f->name)));
1129 else
1130 result = x_bitmap_icon (f, arg);
1132 if (result)
1134 UNBLOCK_INPUT;
1135 error ("No icon window available");
1138 XFlush (FRAME_X_DISPLAY (f));
1139 UNBLOCK_INPUT;
1142 static void
1143 x_set_icon_name (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1145 int result;
1147 if (STRINGP (arg))
1149 if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
1150 return;
1152 else if (!NILP (arg) || NILP (oldval))
1153 return;
1155 f->icon_name = arg;
1157 if (f->output_data.x->icon_bitmap != 0)
1158 return;
1160 BLOCK_INPUT;
1162 result = x_text_icon (f,
1163 SSDATA ((!NILP (f->icon_name)
1164 ? f->icon_name
1165 : !NILP (f->title)
1166 ? f->title
1167 : f->name)));
1169 if (result)
1171 UNBLOCK_INPUT;
1172 error ("No icon window available");
1175 XFlush (FRAME_X_DISPLAY (f));
1176 UNBLOCK_INPUT;
1180 void
1181 x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
1183 int nlines;
1184 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1185 int olines = FRAME_MENU_BAR_LINES (f);
1186 #endif
1188 /* Right now, menu bars don't work properly in minibuf-only frames;
1189 most of the commands try to apply themselves to the minibuffer
1190 frame itself, and get an error because you can't switch buffers
1191 in or split the minibuffer window. */
1192 if (FRAME_MINIBUF_ONLY_P (f))
1193 return;
1195 if (TYPE_RANGED_INTEGERP (int, value))
1196 nlines = XINT (value);
1197 else
1198 nlines = 0;
1200 /* Make sure we redisplay all windows in this frame. */
1201 windows_or_buffers_changed++;
1203 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1204 FRAME_MENU_BAR_LINES (f) = 0;
1205 if (nlines)
1207 FRAME_EXTERNAL_MENU_BAR (f) = 1;
1208 if (FRAME_X_P (f) && f->output_data.x->menubar_widget == 0)
1209 /* Make sure next redisplay shows the menu bar. */
1210 XWINDOW (FRAME_SELECTED_WINDOW (f))->update_mode_line = 1;
1212 else
1214 if (FRAME_EXTERNAL_MENU_BAR (f) == 1)
1215 free_frame_menubar (f);
1216 FRAME_EXTERNAL_MENU_BAR (f) = 0;
1217 if (FRAME_X_P (f))
1218 f->output_data.x->menubar_widget = 0;
1220 #else /* not USE_X_TOOLKIT && not USE_GTK */
1221 FRAME_MENU_BAR_LINES (f) = nlines;
1222 resize_frame_windows (f, FRAME_LINES (f), 0);
1224 /* If the menu bar height gets changed, the internal border below
1225 the top margin has to be cleared. Also, if the menu bar gets
1226 larger, the area for the added lines has to be cleared except for
1227 the first menu bar line that is to be drawn later. */
1228 if (nlines != olines)
1230 int height = FRAME_INTERNAL_BORDER_WIDTH (f);
1231 int width = FRAME_PIXEL_WIDTH (f);
1232 int y;
1234 /* height can be zero here. */
1235 if (height > 0 && width > 0)
1237 y = FRAME_TOP_MARGIN_HEIGHT (f);
1239 BLOCK_INPUT;
1240 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1241 0, y, width, height, False);
1242 UNBLOCK_INPUT;
1245 if (nlines > 1 && nlines > olines)
1247 y = (olines == 0 ? 1 : olines) * FRAME_LINE_HEIGHT (f);
1248 height = nlines * FRAME_LINE_HEIGHT (f) - y;
1250 BLOCK_INPUT;
1251 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1252 0, y, width, height, False);
1253 UNBLOCK_INPUT;
1256 if (nlines == 0 && WINDOWP (f->menu_bar_window))
1257 clear_glyph_matrix (XWINDOW (f->menu_bar_window)->current_matrix);
1259 #endif /* not USE_X_TOOLKIT && not USE_GTK */
1260 adjust_glyphs (f);
1261 run_window_configuration_change_hook (f);
1265 /* Set the number of lines used for the tool bar of frame F to VALUE.
1266 VALUE not an integer, or < 0 means set the lines to zero. OLDVAL
1267 is the old number of tool bar lines. This function changes the
1268 height of all windows on frame F to match the new tool bar height.
1269 The frame's height doesn't change. */
1271 void
1272 x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
1274 int delta, nlines, root_height;
1275 Lisp_Object root_window;
1277 /* Treat tool bars like menu bars. */
1278 if (FRAME_MINIBUF_ONLY_P (f))
1279 return;
1281 /* Use VALUE only if an int >= 0. */
1282 if (RANGED_INTEGERP (0, value, INT_MAX))
1283 nlines = XFASTINT (value);
1284 else
1285 nlines = 0;
1287 #ifdef USE_GTK
1288 FRAME_TOOL_BAR_LINES (f) = 0;
1289 if (nlines)
1291 FRAME_EXTERNAL_TOOL_BAR (f) = 1;
1292 if (FRAME_X_P (f) && f->output_data.x->toolbar_widget == 0)
1293 /* Make sure next redisplay shows the tool bar. */
1294 XWINDOW (FRAME_SELECTED_WINDOW (f))->update_mode_line = 1;
1295 update_frame_tool_bar (f);
1297 else
1299 if (FRAME_EXTERNAL_TOOL_BAR (f))
1300 free_frame_tool_bar (f);
1301 FRAME_EXTERNAL_TOOL_BAR (f) = 0;
1304 return;
1305 #endif
1307 /* Make sure we redisplay all windows in this frame. */
1308 ++windows_or_buffers_changed;
1310 delta = nlines - FRAME_TOOL_BAR_LINES (f);
1312 /* Don't resize the tool-bar to more than we have room for. */
1313 root_window = FRAME_ROOT_WINDOW (f);
1314 root_height = WINDOW_TOTAL_LINES (XWINDOW (root_window));
1315 if (root_height - delta < 1)
1317 delta = root_height - 1;
1318 nlines = FRAME_TOOL_BAR_LINES (f) + delta;
1321 FRAME_TOOL_BAR_LINES (f) = nlines;
1322 resize_frame_windows (f, FRAME_LINES (f), 0);
1323 adjust_glyphs (f);
1325 /* We also have to make sure that the internal border at the top of
1326 the frame, below the menu bar or tool bar, is redrawn when the
1327 tool bar disappears. This is so because the internal border is
1328 below the tool bar if one is displayed, but is below the menu bar
1329 if there isn't a tool bar. The tool bar draws into the area
1330 below the menu bar. */
1331 if (FRAME_X_WINDOW (f) && FRAME_TOOL_BAR_LINES (f) == 0)
1333 clear_frame (f);
1334 clear_current_matrices (f);
1337 /* If the tool bar gets smaller, the internal border below it
1338 has to be cleared. It was formerly part of the display
1339 of the larger tool bar, and updating windows won't clear it. */
1340 if (delta < 0)
1342 int height = FRAME_INTERNAL_BORDER_WIDTH (f);
1343 int width = FRAME_PIXEL_WIDTH (f);
1344 int y = (FRAME_MENU_BAR_LINES (f) + nlines) * FRAME_LINE_HEIGHT (f);
1346 /* height can be zero here. */
1347 if (height > 0 && width > 0)
1349 BLOCK_INPUT;
1350 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1351 0, y, width, height, False);
1352 UNBLOCK_INPUT;
1355 if (WINDOWP (f->tool_bar_window))
1356 clear_glyph_matrix (XWINDOW (f->tool_bar_window)->current_matrix);
1359 run_window_configuration_change_hook (f);
1364 /* Set the foreground color for scroll bars on frame F to VALUE.
1365 VALUE should be a string, a color name. If it isn't a string or
1366 isn't a valid color name, do nothing. OLDVAL is the old value of
1367 the frame parameter. */
1369 static void
1370 x_set_scroll_bar_foreground (struct frame *f, Lisp_Object value, Lisp_Object oldval)
1372 unsigned long pixel;
1374 if (STRINGP (value))
1375 pixel = x_decode_color (f, value, BLACK_PIX_DEFAULT (f));
1376 else
1377 pixel = -1;
1379 if (f->output_data.x->scroll_bar_foreground_pixel != -1)
1380 unload_color (f, f->output_data.x->scroll_bar_foreground_pixel);
1382 f->output_data.x->scroll_bar_foreground_pixel = pixel;
1383 if (FRAME_X_WINDOW (f) && FRAME_VISIBLE_P (f))
1385 /* Remove all scroll bars because they have wrong colors. */
1386 if (FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
1387 (*FRAME_TERMINAL (f)->condemn_scroll_bars_hook) (f);
1388 if (FRAME_TERMINAL (f)->judge_scroll_bars_hook)
1389 (*FRAME_TERMINAL (f)->judge_scroll_bars_hook) (f);
1391 update_face_from_frame_parameter (f, Qscroll_bar_foreground, value);
1392 redraw_frame (f);
1397 /* Set the background color for scroll bars on frame F to VALUE VALUE
1398 should be a string, a color name. If it isn't a string or isn't a
1399 valid color name, do nothing. OLDVAL is the old value of the frame
1400 parameter. */
1402 static void
1403 x_set_scroll_bar_background (struct frame *f, Lisp_Object value, Lisp_Object oldval)
1405 unsigned long pixel;
1407 if (STRINGP (value))
1408 pixel = x_decode_color (f, value, WHITE_PIX_DEFAULT (f));
1409 else
1410 pixel = -1;
1412 if (f->output_data.x->scroll_bar_background_pixel != -1)
1413 unload_color (f, f->output_data.x->scroll_bar_background_pixel);
1415 #ifdef USE_TOOLKIT_SCROLL_BARS
1416 /* Scrollbar shadow colors. */
1417 if (f->output_data.x->scroll_bar_top_shadow_pixel != -1)
1419 unload_color (f, f->output_data.x->scroll_bar_top_shadow_pixel);
1420 f->output_data.x->scroll_bar_top_shadow_pixel = -1;
1422 if (f->output_data.x->scroll_bar_bottom_shadow_pixel != -1)
1424 unload_color (f, f->output_data.x->scroll_bar_bottom_shadow_pixel);
1425 f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
1427 #endif /* USE_TOOLKIT_SCROLL_BARS */
1429 f->output_data.x->scroll_bar_background_pixel = pixel;
1430 if (FRAME_X_WINDOW (f) && FRAME_VISIBLE_P (f))
1432 /* Remove all scroll bars because they have wrong colors. */
1433 if (FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
1434 (*FRAME_TERMINAL (f)->condemn_scroll_bars_hook) (f);
1435 if (FRAME_TERMINAL (f)->judge_scroll_bars_hook)
1436 (*FRAME_TERMINAL (f)->judge_scroll_bars_hook) (f);
1438 update_face_from_frame_parameter (f, Qscroll_bar_background, value);
1439 redraw_frame (f);
1444 /* Encode Lisp string STRING as a text in a format appropriate for
1445 XICCC (X Inter Client Communication Conventions).
1447 This can call Lisp code, so callers must GCPRO.
1449 If STRING contains only ASCII characters, do no conversion and
1450 return the string data of STRING. Otherwise, encode the text by
1451 CODING_SYSTEM, and return a newly allocated memory area which
1452 should be freed by `xfree' by a caller.
1454 SELECTIONP non-zero means the string is being encoded for an X
1455 selection, so it is safe to run pre-write conversions (which
1456 may run Lisp code).
1458 Store the byte length of resulting text in *TEXT_BYTES.
1460 If the text contains only ASCII and Latin-1, store 1 in *STRING_P,
1461 which means that the `encoding' of the result can be `STRING'.
1462 Otherwise store 0 in *STRINGP, which means that the `encoding' of
1463 the result should be `COMPOUND_TEXT'. */
1465 static unsigned char *
1466 x_encode_text (Lisp_Object string, Lisp_Object coding_system, int selectionp,
1467 ptrdiff_t *text_bytes, int *stringp, int *freep)
1469 int result = string_xstring_p (string);
1470 struct coding_system coding;
1472 if (result == 0)
1474 /* No multibyte character in OBJ. We need not encode it. */
1475 *text_bytes = SBYTES (string);
1476 *stringp = 1;
1477 *freep = 0;
1478 return SDATA (string);
1481 setup_coding_system (coding_system, &coding);
1482 coding.mode |= (CODING_MODE_SAFE_ENCODING | CODING_MODE_LAST_BLOCK);
1483 /* We suppress producing escape sequences for composition. */
1484 coding.common_flags &= ~CODING_ANNOTATION_MASK;
1485 coding.destination = xnmalloc (SCHARS (string), 2);
1486 coding.dst_bytes = SCHARS (string) * 2;
1487 encode_coding_object (&coding, string, 0, 0,
1488 SCHARS (string), SBYTES (string), Qnil);
1489 *text_bytes = coding.produced;
1490 *stringp = (result == 1 || !EQ (coding_system, Qcompound_text));
1491 *freep = 1;
1492 return coding.destination;
1496 /* Set the WM name to NAME for frame F. Also set the icon name.
1497 If the frame already has an icon name, use that, otherwise set the
1498 icon name to NAME. */
1500 static void
1501 x_set_name_internal (FRAME_PTR f, Lisp_Object name)
1503 if (FRAME_X_WINDOW (f))
1505 BLOCK_INPUT;
1507 XTextProperty text, icon;
1508 ptrdiff_t bytes;
1509 int stringp;
1510 int do_free_icon_value = 0, do_free_text_value = 0;
1511 Lisp_Object coding_system;
1512 Lisp_Object encoded_name;
1513 Lisp_Object encoded_icon_name;
1514 struct gcpro gcpro1;
1516 /* As ENCODE_UTF_8 may cause GC and relocation of string data,
1517 we use it before x_encode_text that may return string data. */
1518 GCPRO1 (name);
1519 encoded_name = ENCODE_UTF_8 (name);
1520 UNGCPRO;
1522 coding_system = Qcompound_text;
1523 /* Note: Encoding strategy
1525 We encode NAME by compound-text and use "COMPOUND-TEXT" in
1526 text.encoding. But, there are non-internationalized window
1527 managers which don't support that encoding. So, if NAME
1528 contains only ASCII and 8859-1 characters, encode it by
1529 iso-latin-1, and use "STRING" in text.encoding hoping that
1530 such window managers at least analyze this format correctly,
1531 i.e. treat 8-bit bytes as 8859-1 characters.
1533 We may also be able to use "UTF8_STRING" in text.encoding
1534 in the future which can encode all Unicode characters.
1535 But, for the moment, there's no way to know that the
1536 current window manager supports it or not.
1538 Either way, we also set the _NET_WM_NAME and _NET_WM_ICON_NAME
1539 properties. Per the EWMH specification, those two properties
1540 are always UTF8_STRING. This matches what gtk_window_set_title()
1541 does in the USE_GTK case. */
1542 text.value = x_encode_text (name, coding_system, 0, &bytes, &stringp,
1543 &do_free_text_value);
1544 text.encoding = (stringp ? XA_STRING
1545 : FRAME_X_DISPLAY_INFO (f)->Xatom_COMPOUND_TEXT);
1546 text.format = 8;
1547 text.nitems = bytes;
1548 if (text.nitems != bytes)
1549 error ("Window name too large");
1551 if (!STRINGP (f->icon_name))
1553 icon = text;
1554 encoded_icon_name = encoded_name;
1556 else
1558 /* See the above comment "Note: Encoding strategy". */
1559 icon.value = x_encode_text (f->icon_name, coding_system, 0,
1560 &bytes, &stringp, &do_free_icon_value);
1561 icon.encoding = (stringp ? XA_STRING
1562 : FRAME_X_DISPLAY_INFO (f)->Xatom_COMPOUND_TEXT);
1563 icon.format = 8;
1564 icon.nitems = bytes;
1565 if (icon.nitems != bytes)
1566 error ("Icon name too large");
1568 encoded_icon_name = ENCODE_UTF_8 (f->icon_name);
1571 #ifdef USE_GTK
1572 gtk_window_set_title (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
1573 SSDATA (encoded_name));
1574 #else /* not USE_GTK */
1575 XSetWMName (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &text);
1576 XChangeProperty (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
1577 FRAME_X_DISPLAY_INFO (f)->Xatom_net_wm_name,
1578 FRAME_X_DISPLAY_INFO (f)->Xatom_UTF8_STRING,
1579 8, PropModeReplace,
1580 SDATA (encoded_name),
1581 SBYTES (encoded_name));
1582 #endif /* not USE_GTK */
1584 XSetWMIconName (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &icon);
1585 XChangeProperty (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
1586 FRAME_X_DISPLAY_INFO (f)->Xatom_net_wm_icon_name,
1587 FRAME_X_DISPLAY_INFO (f)->Xatom_UTF8_STRING,
1588 8, PropModeReplace,
1589 SDATA (encoded_icon_name),
1590 SBYTES (encoded_icon_name));
1592 if (do_free_icon_value)
1593 xfree (icon.value);
1594 if (do_free_text_value)
1595 xfree (text.value);
1597 UNBLOCK_INPUT;
1601 /* Change the name of frame F to NAME. If NAME is nil, set F's name to
1602 x_id_name.
1604 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1605 name; if NAME is a string, set F's name to NAME and set
1606 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1608 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1609 suggesting a new name, which lisp code should override; if
1610 F->explicit_name is set, ignore the new name; otherwise, set it. */
1612 static void
1613 x_set_name (struct frame *f, Lisp_Object name, int explicit)
1615 /* Make sure that requests from lisp code override requests from
1616 Emacs redisplay code. */
1617 if (explicit)
1619 /* If we're switching from explicit to implicit, we had better
1620 update the mode lines and thereby update the title. */
1621 if (f->explicit_name && NILP (name))
1622 update_mode_lines = 1;
1624 f->explicit_name = ! NILP (name);
1626 else if (f->explicit_name)
1627 return;
1629 /* If NAME is nil, set the name to the x_id_name. */
1630 if (NILP (name))
1632 /* Check for no change needed in this very common case
1633 before we do any consing. */
1634 if (!strcmp (FRAME_X_DISPLAY_INFO (f)->x_id_name,
1635 SSDATA (f->name)))
1636 return;
1637 name = build_string (FRAME_X_DISPLAY_INFO (f)->x_id_name);
1639 else
1640 CHECK_STRING (name);
1642 /* Don't change the name if it's already NAME. */
1643 if (! NILP (Fstring_equal (name, f->name)))
1644 return;
1646 f->name = name;
1648 /* For setting the frame title, the title parameter should override
1649 the name parameter. */
1650 if (! NILP (f->title))
1651 name = f->title;
1653 x_set_name_internal (f, name);
1656 /* This function should be called when the user's lisp code has
1657 specified a name for the frame; the name will override any set by the
1658 redisplay code. */
1659 static void
1660 x_explicitly_set_name (FRAME_PTR f, Lisp_Object arg, Lisp_Object oldval)
1662 x_set_name (f, arg, 1);
1665 /* This function should be called by Emacs redisplay code to set the
1666 name; names set this way will never override names set by the user's
1667 lisp code. */
1668 void
1669 x_implicitly_set_name (FRAME_PTR f, Lisp_Object arg, Lisp_Object oldval)
1671 x_set_name (f, arg, 0);
1674 /* Change the title of frame F to NAME.
1675 If NAME is nil, use the frame name as the title. */
1677 static void
1678 x_set_title (struct frame *f, Lisp_Object name, Lisp_Object old_name)
1680 /* Don't change the title if it's already NAME. */
1681 if (EQ (name, f->title))
1682 return;
1684 update_mode_lines = 1;
1686 f->title = name;
1688 if (NILP (name))
1689 name = f->name;
1690 else
1691 CHECK_STRING (name);
1693 x_set_name_internal (f, name);
1696 void
1697 x_set_scroll_bar_default_width (struct frame *f)
1699 int wid = FRAME_COLUMN_WIDTH (f);
1700 #ifdef USE_TOOLKIT_SCROLL_BARS
1701 #ifdef USE_GTK
1702 int minw = xg_get_default_scrollbar_width ();
1703 #else
1704 int minw = 16;
1705 #endif
1706 /* A minimum width of 14 doesn't look good for toolkit scroll bars. */
1707 int width = minw + 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM;
1708 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (width + wid - 1) / wid;
1709 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = width;
1710 #else
1711 /* Make the actual width at least 14 pixels and a multiple of a
1712 character width. */
1713 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
1715 /* Use all of that space (aside from required margins) for the
1716 scroll bar. */
1717 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = 0;
1718 #endif
1722 /* Record in frame F the specified or default value according to ALIST
1723 of the parameter named PROP (a Lisp symbol). If no value is
1724 specified for PROP, look for an X default for XPROP on the frame
1725 named NAME. If that is not found either, use the value DEFLT. */
1727 static Lisp_Object
1728 x_default_scroll_bar_color_parameter (struct frame *f,
1729 Lisp_Object alist, Lisp_Object prop,
1730 const char *xprop, const char *xclass,
1731 int foreground_p)
1733 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
1734 Lisp_Object tem;
1736 tem = x_get_arg (dpyinfo, alist, prop, xprop, xclass, RES_TYPE_STRING);
1737 if (EQ (tem, Qunbound))
1739 #ifdef USE_TOOLKIT_SCROLL_BARS
1741 /* See if an X resource for the scroll bar color has been
1742 specified. */
1743 tem = display_x_get_resource (dpyinfo,
1744 build_string (foreground_p
1745 ? "foreground"
1746 : "background"),
1747 empty_unibyte_string,
1748 build_string ("verticalScrollBar"),
1749 empty_unibyte_string);
1750 if (!STRINGP (tem))
1752 /* If nothing has been specified, scroll bars will use a
1753 toolkit-dependent default. Because these defaults are
1754 difficult to get at without actually creating a scroll
1755 bar, use nil to indicate that no color has been
1756 specified. */
1757 tem = Qnil;
1760 #else /* not USE_TOOLKIT_SCROLL_BARS */
1762 tem = Qnil;
1764 #endif /* not USE_TOOLKIT_SCROLL_BARS */
1767 x_set_frame_parameters (f, Fcons (Fcons (prop, tem), Qnil));
1768 return tem;
1774 #ifdef USE_X_TOOLKIT
1776 /* If the WM_PROTOCOLS property does not already contain WM_TAKE_FOCUS,
1777 WM_DELETE_WINDOW, and WM_SAVE_YOURSELF, then add them. (They may
1778 already be present because of the toolkit (Motif adds some of them,
1779 for example, but Xt doesn't). */
1781 static void
1782 hack_wm_protocols (FRAME_PTR f, Widget widget)
1784 Display *dpy = XtDisplay (widget);
1785 Window w = XtWindow (widget);
1786 int need_delete = 1;
1787 int need_focus = 1;
1788 int need_save = 1;
1790 BLOCK_INPUT;
1792 Atom type;
1793 unsigned char *catoms;
1794 int format = 0;
1795 unsigned long nitems = 0;
1796 unsigned long bytes_after;
1798 if ((XGetWindowProperty (dpy, w,
1799 FRAME_X_DISPLAY_INFO (f)->Xatom_wm_protocols,
1800 (long)0, (long)100, False, XA_ATOM,
1801 &type, &format, &nitems, &bytes_after,
1802 &catoms)
1803 == Success)
1804 && format == 32 && type == XA_ATOM)
1806 Atom *atoms = (Atom *) catoms;
1807 while (nitems > 0)
1809 nitems--;
1810 if (atoms[nitems]
1811 == FRAME_X_DISPLAY_INFO (f)->Xatom_wm_delete_window)
1812 need_delete = 0;
1813 else if (atoms[nitems]
1814 == FRAME_X_DISPLAY_INFO (f)->Xatom_wm_take_focus)
1815 need_focus = 0;
1816 else if (atoms[nitems]
1817 == FRAME_X_DISPLAY_INFO (f)->Xatom_wm_save_yourself)
1818 need_save = 0;
1821 if (catoms)
1822 XFree (catoms);
1825 Atom props [10];
1826 int count = 0;
1827 if (need_delete)
1828 props[count++] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_delete_window;
1829 if (need_focus)
1830 props[count++] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_take_focus;
1831 if (need_save)
1832 props[count++] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_save_yourself;
1833 if (count)
1834 XChangeProperty (dpy, w, FRAME_X_DISPLAY_INFO (f)->Xatom_wm_protocols,
1835 XA_ATOM, 32, PropModeAppend,
1836 (unsigned char *) props, count);
1838 UNBLOCK_INPUT;
1840 #endif
1844 /* Support routines for XIC (X Input Context). */
1846 #ifdef HAVE_X_I18N
1848 static XFontSet xic_create_xfontset (struct frame *);
1849 static XIMStyle best_xim_style (XIMStyles *, XIMStyles *);
1852 /* Supported XIM styles, ordered by preference. */
1854 static XIMStyle supported_xim_styles[] =
1856 XIMPreeditPosition | XIMStatusArea,
1857 XIMPreeditPosition | XIMStatusNothing,
1858 XIMPreeditPosition | XIMStatusNone,
1859 XIMPreeditNothing | XIMStatusArea,
1860 XIMPreeditNothing | XIMStatusNothing,
1861 XIMPreeditNothing | XIMStatusNone,
1862 XIMPreeditNone | XIMStatusArea,
1863 XIMPreeditNone | XIMStatusNothing,
1864 XIMPreeditNone | XIMStatusNone,
1869 #if defined HAVE_X_WINDOWS && defined USE_X_TOOLKIT
1870 /* Create an X fontset on frame F with base font name BASE_FONTNAME. */
1872 static const char xic_default_fontset[] = "-*-*-*-r-normal--14-*-*-*-*-*-*-*";
1874 /* Create an Xt fontset spec from the name of a base font.
1875 If `motif' is True use the Motif syntax. */
1876 char *
1877 xic_create_fontsetname (const char *base_fontname, int motif)
1879 const char *sep = motif ? ";" : ",";
1880 char *fontsetname;
1882 /* Make a fontset name from the base font name. */
1883 if (xic_default_fontset == base_fontname)
1884 { /* There is no base font name, use the default. */
1885 ptrdiff_t len = strlen (base_fontname) + 2;
1886 fontsetname = xmalloc (len);
1887 memset (fontsetname, 0, len);
1888 strcpy (fontsetname, base_fontname);
1890 else
1892 /* Make a fontset name from the base font name.
1893 The font set will be made of the following elements:
1894 - the base font.
1895 - the base font where the charset spec is replaced by -*-*.
1896 - the same but with the family also replaced with -*-*-. */
1897 const char *p = base_fontname;
1898 ptrdiff_t i;
1900 for (i = 0; *p; p++)
1901 if (*p == '-') i++;
1902 if (i != 14)
1903 { /* As the font name doesn't conform to XLFD, we can't
1904 modify it to generalize it to allcs and allfamilies.
1905 Use the specified font plus the default. */
1906 ptrdiff_t len =
1907 strlen (base_fontname) + strlen (xic_default_fontset) + 3;
1908 fontsetname = xmalloc (len);
1909 memset (fontsetname, 0, len);
1910 strcpy (fontsetname, base_fontname);
1911 strcat (fontsetname, sep);
1912 strcat (fontsetname, xic_default_fontset);
1914 else
1916 ptrdiff_t len;
1917 const char *p1 = NULL, *p2 = NULL, *p3 = NULL;
1918 char *font_allcs = NULL;
1919 char *font_allfamilies = NULL;
1920 char *font_all = NULL;
1921 const char *allcs = "*-*-*-*-*-*-*";
1922 const char *allfamilies = "-*-*-";
1923 const char *all = "*-*-*-*-";
1924 char *base;
1926 for (i = 0, p = base_fontname; i < 8; p++)
1928 if (*p == '-')
1930 i++;
1931 if (i == 3)
1932 p1 = p + 1;
1933 else if (i == 7)
1934 p2 = p + 1;
1935 else if (i == 6)
1936 p3 = p + 1;
1939 /* If base_fontname specifies ADSTYLE, make it a
1940 wildcard. */
1941 if (*p3 != '*')
1943 ptrdiff_t diff = (p2 - p3) - 2;
1945 base = alloca (strlen (base_fontname) + 1);
1946 memcpy (base, base_fontname, p3 - base_fontname);
1947 base[p3 - base_fontname] = '*';
1948 base[(p3 - base_fontname) + 1] = '-';
1949 strcpy (base + (p3 - base_fontname) + 2, p2);
1950 p = base + (p - base_fontname) - diff;
1951 p1 = base + (p1 - base_fontname);
1952 p2 = base + (p2 - base_fontname) - diff;
1953 base_fontname = base;
1956 /* Build the font spec that matches all charsets. */
1957 len = p - base_fontname + strlen (allcs) + 1;
1958 font_allcs = (char *) alloca (len);
1959 memset (font_allcs, 0, len);
1960 memcpy (font_allcs, base_fontname, p - base_fontname);
1961 strcat (font_allcs, allcs);
1963 /* Build the font spec that matches all families and
1964 add-styles. */
1965 len = p - p1 + strlen (allcs) + strlen (allfamilies) + 1;
1966 font_allfamilies = (char *) alloca (len);
1967 memset (font_allfamilies, 0, len);
1968 strcpy (font_allfamilies, allfamilies);
1969 memcpy (font_allfamilies + strlen (allfamilies), p1, p - p1);
1970 strcat (font_allfamilies, allcs);
1972 /* Build the font spec that matches all. */
1973 len = p - p2 + strlen (allcs) + strlen (all) + strlen (allfamilies) + 1;
1974 font_all = (char *) alloca (len);
1975 memset (font_all, 0, len);
1976 strcpy (font_all, allfamilies);
1977 strcat (font_all, all);
1978 memcpy (font_all + strlen (all) + strlen (allfamilies), p2, p - p2);
1979 strcat (font_all, allcs);
1981 /* Build the actual font set name. */
1982 len = strlen (base_fontname) + strlen (font_allcs)
1983 + strlen (font_allfamilies) + strlen (font_all) + 5;
1984 fontsetname = xmalloc (len);
1985 memset (fontsetname, 0, len);
1986 strcpy (fontsetname, base_fontname);
1987 strcat (fontsetname, sep);
1988 strcat (fontsetname, font_allcs);
1989 strcat (fontsetname, sep);
1990 strcat (fontsetname, font_allfamilies);
1991 strcat (fontsetname, sep);
1992 strcat (fontsetname, font_all);
1995 if (motif)
1996 strcat (fontsetname, ":");
1997 return fontsetname;
1999 #endif /* HAVE_X_WINDOWS && USE_X_TOOLKIT */
2001 #ifdef DEBUG_XIC_FONTSET
2002 static void
2003 print_fontset_result (XFontSet xfs, char *name, char **missing_list,
2004 int missing_count)
2006 if (xfs)
2007 fprintf (stderr, "XIC Fontset created: %s\n", name);
2008 else
2010 fprintf (stderr, "XIC Fontset failed: %s\n", name);
2011 while (missing_count-- > 0)
2013 fprintf (stderr, " missing: %s\n", *missing_list);
2014 missing_list++;
2019 #endif
2021 static XFontSet
2022 xic_create_xfontset (struct frame *f)
2024 XFontSet xfs = NULL;
2025 struct font *font = FRAME_FONT (f);
2026 int pixel_size = font->pixel_size;
2027 Lisp_Object rest, frame;
2029 /* See if there is another frame already using same fontset. */
2030 FOR_EACH_FRAME (rest, frame)
2032 struct frame *cf = XFRAME (frame);
2034 if (cf != f && FRAME_LIVE_P (f) && FRAME_X_P (cf)
2035 && FRAME_X_DISPLAY_INFO (cf) == FRAME_X_DISPLAY_INFO (f)
2036 && FRAME_FONT (f)
2037 && FRAME_FONT (f)->pixel_size == pixel_size)
2039 xfs = FRAME_XIC_FONTSET (cf);
2040 break;
2044 if (! xfs)
2046 char buf[256];
2047 char **missing_list;
2048 int missing_count;
2049 char *def_string;
2050 const char *xlfd_format = "-*-*-medium-r-normal--%d-*-*-*-*-*";
2052 sprintf (buf, xlfd_format, pixel_size);
2053 missing_list = NULL;
2054 xfs = XCreateFontSet (FRAME_X_DISPLAY (f), buf,
2055 &missing_list, &missing_count, &def_string);
2056 #ifdef DEBUG_XIC_FONTSET
2057 print_fontset_result (xfs, buf, missing_list, missing_count);
2058 #endif
2059 if (missing_list)
2060 XFreeStringList (missing_list);
2061 if (! xfs)
2063 /* List of pixel sizes most likely available. Find one that
2064 is closest to pixel_size. */
2065 int sizes[] = {0, 8, 10, 11, 12, 14, 17, 18, 20, 24, 26, 34, 0};
2066 int *smaller, *larger;
2068 for (smaller = sizes; smaller[1]; smaller++)
2069 if (smaller[1] >= pixel_size)
2070 break;
2071 larger = smaller + 1;
2072 if (*larger == pixel_size)
2073 larger++;
2074 while (*smaller || *larger)
2076 int this_size;
2078 if (! *larger)
2079 this_size = *smaller--;
2080 else if (! *smaller)
2081 this_size = *larger++;
2082 else if (pixel_size - *smaller < *larger - pixel_size)
2083 this_size = *smaller--;
2084 else
2085 this_size = *larger++;
2086 sprintf (buf, xlfd_format, this_size);
2087 missing_list = NULL;
2088 xfs = XCreateFontSet (FRAME_X_DISPLAY (f), buf,
2089 &missing_list, &missing_count, &def_string);
2090 #ifdef DEBUG_XIC_FONTSET
2091 print_fontset_result (xfs, buf, missing_list, missing_count);
2092 #endif
2093 if (missing_list)
2094 XFreeStringList (missing_list);
2095 if (xfs)
2096 break;
2099 if (! xfs)
2101 const char *last_resort = "-*-*-*-r-normal--*-*-*-*-*-*";
2103 missing_list = NULL;
2104 xfs = XCreateFontSet (FRAME_X_DISPLAY (f), last_resort,
2105 &missing_list, &missing_count, &def_string);
2106 #ifdef DEBUG_XIC_FONTSET
2107 print_fontset_result (xfs, last_resort, missing_list, missing_count);
2108 #endif
2109 if (missing_list)
2110 XFreeStringList (missing_list);
2115 return xfs;
2118 /* Free the X fontset of frame F if it is the last frame using it. */
2120 void
2121 xic_free_xfontset (struct frame *f)
2123 Lisp_Object rest, frame;
2124 int shared_p = 0;
2126 if (!FRAME_XIC_FONTSET (f))
2127 return;
2129 /* See if there is another frame sharing the same fontset. */
2130 FOR_EACH_FRAME (rest, frame)
2132 struct frame *cf = XFRAME (frame);
2133 if (cf != f && FRAME_LIVE_P (f) && FRAME_X_P (cf)
2134 && FRAME_X_DISPLAY_INFO (cf) == FRAME_X_DISPLAY_INFO (f)
2135 && FRAME_XIC_FONTSET (cf) == FRAME_XIC_FONTSET (f))
2137 shared_p = 1;
2138 break;
2142 if (!shared_p)
2143 /* The fontset is not used anymore. It is safe to free it. */
2144 XFreeFontSet (FRAME_X_DISPLAY (f), FRAME_XIC_FONTSET (f));
2146 if (FRAME_XIC_BASE_FONTNAME (f))
2147 xfree (FRAME_XIC_BASE_FONTNAME (f));
2148 FRAME_XIC_BASE_FONTNAME (f) = NULL;
2149 FRAME_XIC_FONTSET (f) = NULL;
2153 /* Value is the best input style, given user preferences USER (already
2154 checked to be supported by Emacs), and styles supported by the
2155 input method XIM. */
2157 static XIMStyle
2158 best_xim_style (XIMStyles *user, XIMStyles *xim)
2160 int i, j;
2162 for (i = 0; i < user->count_styles; ++i)
2163 for (j = 0; j < xim->count_styles; ++j)
2164 if (user->supported_styles[i] == xim->supported_styles[j])
2165 return user->supported_styles[i];
2167 /* Return the default style. */
2168 return XIMPreeditNothing | XIMStatusNothing;
2171 /* Create XIC for frame F. */
2173 static XIMStyle xic_style;
2175 void
2176 create_frame_xic (struct frame *f)
2178 XIM xim;
2179 XIC xic = NULL;
2180 XFontSet xfs = NULL;
2182 if (FRAME_XIC (f))
2183 return;
2185 /* Create X fontset. */
2186 xfs = xic_create_xfontset (f);
2187 xim = FRAME_X_XIM (f);
2188 if (xim)
2190 XRectangle s_area;
2191 XPoint spot;
2192 XVaNestedList preedit_attr;
2193 XVaNestedList status_attr;
2195 s_area.x = 0; s_area.y = 0; s_area.width = 1; s_area.height = 1;
2196 spot.x = 0; spot.y = 1;
2198 /* Determine XIC style. */
2199 if (xic_style == 0)
2201 XIMStyles supported_list;
2202 supported_list.count_styles = (sizeof supported_xim_styles
2203 / sizeof supported_xim_styles[0]);
2204 supported_list.supported_styles = supported_xim_styles;
2205 xic_style = best_xim_style (&supported_list,
2206 FRAME_X_XIM_STYLES (f));
2209 preedit_attr = XVaCreateNestedList (0,
2210 XNFontSet, xfs,
2211 XNForeground,
2212 FRAME_FOREGROUND_PIXEL (f),
2213 XNBackground,
2214 FRAME_BACKGROUND_PIXEL (f),
2215 (xic_style & XIMPreeditPosition
2216 ? XNSpotLocation
2217 : NULL),
2218 &spot,
2219 NULL);
2220 status_attr = XVaCreateNestedList (0,
2221 XNArea,
2222 &s_area,
2223 XNFontSet,
2224 xfs,
2225 XNForeground,
2226 FRAME_FOREGROUND_PIXEL (f),
2227 XNBackground,
2228 FRAME_BACKGROUND_PIXEL (f),
2229 NULL);
2231 xic = XCreateIC (xim,
2232 XNInputStyle, xic_style,
2233 XNClientWindow, FRAME_X_WINDOW (f),
2234 XNFocusWindow, FRAME_X_WINDOW (f),
2235 XNStatusAttributes, status_attr,
2236 XNPreeditAttributes, preedit_attr,
2237 NULL);
2238 XFree (preedit_attr);
2239 XFree (status_attr);
2242 FRAME_XIC (f) = xic;
2243 FRAME_XIC_STYLE (f) = xic_style;
2244 FRAME_XIC_FONTSET (f) = xfs;
2248 /* Destroy XIC and free XIC fontset of frame F, if any. */
2250 void
2251 free_frame_xic (struct frame *f)
2253 if (FRAME_XIC (f) == NULL)
2254 return;
2256 XDestroyIC (FRAME_XIC (f));
2257 xic_free_xfontset (f);
2259 FRAME_XIC (f) = NULL;
2263 /* Place preedit area for XIC of window W's frame to specified
2264 pixel position X/Y. X and Y are relative to window W. */
2266 void
2267 xic_set_preeditarea (struct window *w, int x, int y)
2269 struct frame *f = XFRAME (w->frame);
2270 XVaNestedList attr;
2271 XPoint spot;
2273 spot.x = WINDOW_TO_FRAME_PIXEL_X (w, x) + WINDOW_LEFT_FRINGE_WIDTH (w);
2274 spot.y = WINDOW_TO_FRAME_PIXEL_Y (w, y) + FONT_BASE (FRAME_FONT (f));
2275 attr = XVaCreateNestedList (0, XNSpotLocation, &spot, NULL);
2276 XSetICValues (FRAME_XIC (f), XNPreeditAttributes, attr, NULL);
2277 XFree (attr);
2281 /* Place status area for XIC in bottom right corner of frame F.. */
2283 void
2284 xic_set_statusarea (struct frame *f)
2286 XIC xic = FRAME_XIC (f);
2287 XVaNestedList attr;
2288 XRectangle area;
2289 XRectangle *needed;
2291 /* Negotiate geometry of status area. If input method has existing
2292 status area, use its current size. */
2293 area.x = area.y = area.width = area.height = 0;
2294 attr = XVaCreateNestedList (0, XNAreaNeeded, &area, NULL);
2295 XSetICValues (xic, XNStatusAttributes, attr, NULL);
2296 XFree (attr);
2298 attr = XVaCreateNestedList (0, XNAreaNeeded, &needed, NULL);
2299 XGetICValues (xic, XNStatusAttributes, attr, NULL);
2300 XFree (attr);
2302 if (needed->width == 0) /* Use XNArea instead of XNAreaNeeded */
2304 attr = XVaCreateNestedList (0, XNArea, &needed, NULL);
2305 XGetICValues (xic, XNStatusAttributes, attr, NULL);
2306 XFree (attr);
2309 area.width = needed->width;
2310 area.height = needed->height;
2311 area.x = FRAME_PIXEL_WIDTH (f) - area.width - FRAME_INTERNAL_BORDER_WIDTH (f);
2312 area.y = (FRAME_PIXEL_HEIGHT (f) - area.height
2313 - FRAME_MENUBAR_HEIGHT (f)
2314 - FRAME_TOOLBAR_TOP_HEIGHT (f)
2315 - FRAME_INTERNAL_BORDER_WIDTH (f));
2316 XFree (needed);
2318 attr = XVaCreateNestedList (0, XNArea, &area, NULL);
2319 XSetICValues (xic, XNStatusAttributes, attr, NULL);
2320 XFree (attr);
2324 /* Set X fontset for XIC of frame F, using base font name
2325 BASE_FONTNAME. Called when a new Emacs fontset is chosen. */
2327 void
2328 xic_set_xfontset (struct frame *f, const char *base_fontname)
2330 XVaNestedList attr;
2331 XFontSet xfs;
2333 xic_free_xfontset (f);
2335 xfs = xic_create_xfontset (f);
2337 attr = XVaCreateNestedList (0, XNFontSet, xfs, NULL);
2338 if (FRAME_XIC_STYLE (f) & XIMPreeditPosition)
2339 XSetICValues (FRAME_XIC (f), XNPreeditAttributes, attr, NULL);
2340 if (FRAME_XIC_STYLE (f) & XIMStatusArea)
2341 XSetICValues (FRAME_XIC (f), XNStatusAttributes, attr, NULL);
2342 XFree (attr);
2344 FRAME_XIC_FONTSET (f) = xfs;
2347 #endif /* HAVE_X_I18N */
2351 #ifdef USE_X_TOOLKIT
2353 /* Create and set up the X widget for frame F. */
2355 static void
2356 x_window (struct frame *f, long window_prompting, int minibuffer_only)
2358 XClassHint class_hints;
2359 XSetWindowAttributes attributes;
2360 unsigned long attribute_mask;
2361 Widget shell_widget;
2362 Widget pane_widget;
2363 Widget frame_widget;
2364 Arg al [25];
2365 int ac;
2367 BLOCK_INPUT;
2369 /* Use the resource name as the top-level widget name
2370 for looking up resources. Make a non-Lisp copy
2371 for the window manager, so GC relocation won't bother it.
2373 Elsewhere we specify the window name for the window manager. */
2376 char *str = SSDATA (Vx_resource_name);
2377 f->namebuf = (char *) xmalloc (strlen (str) + 1);
2378 strcpy (f->namebuf, str);
2381 ac = 0;
2382 XtSetArg (al[ac], XtNallowShellResize, 1); ac++;
2383 XtSetArg (al[ac], XtNinput, 1); ac++;
2384 XtSetArg (al[ac], XtNmappedWhenManaged, 0); ac++;
2385 XtSetArg (al[ac], XtNborderWidth, f->border_width); ac++;
2386 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2387 XtSetArg (al[ac], XtNdepth, FRAME_X_DISPLAY_INFO (f)->n_planes); ac++;
2388 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2389 shell_widget = XtAppCreateShell (f->namebuf, EMACS_CLASS,
2390 applicationShellWidgetClass,
2391 FRAME_X_DISPLAY (f), al, ac);
2393 f->output_data.x->widget = shell_widget;
2394 /* maybe_set_screen_title_format (shell_widget); */
2396 pane_widget = lw_create_widget ("main", "pane", widget_id_tick++,
2397 (widget_value *) NULL,
2398 shell_widget, False,
2399 (lw_callback) NULL,
2400 (lw_callback) NULL,
2401 (lw_callback) NULL,
2402 (lw_callback) NULL);
2404 ac = 0;
2405 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2406 XtSetArg (al[ac], XtNdepth, FRAME_X_DISPLAY_INFO (f)->n_planes); ac++;
2407 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2408 XtSetArg (al[ac], XtNborderWidth, 0); ac++;
2409 XtSetValues (pane_widget, al, ac);
2410 f->output_data.x->column_widget = pane_widget;
2412 /* mappedWhenManaged to false tells to the paned window to not map/unmap
2413 the emacs screen when changing menubar. This reduces flickering. */
2415 ac = 0;
2416 XtSetArg (al[ac], XtNmappedWhenManaged, 0); ac++;
2417 XtSetArg (al[ac], XtNshowGrip, 0); ac++;
2418 XtSetArg (al[ac], XtNallowResize, 1); ac++;
2419 XtSetArg (al[ac], XtNresizeToPreferred, 1); ac++;
2420 XtSetArg (al[ac], XtNemacsFrame, f); ac++;
2421 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2422 XtSetArg (al[ac], XtNdepth, FRAME_X_DISPLAY_INFO (f)->n_planes); ac++;
2423 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2424 XtSetArg (al[ac], XtNborderWidth, 0); ac++;
2425 frame_widget = XtCreateWidget (f->namebuf, emacsFrameClass, pane_widget,
2426 al, ac);
2428 f->output_data.x->edit_widget = frame_widget;
2430 XtManageChild (frame_widget);
2432 /* Do some needed geometry management. */
2434 char *tem, shell_position[sizeof "=x++" + 4 * INT_STRLEN_BOUND (int)];
2435 Arg gal[10];
2436 int gac = 0;
2437 int extra_borders = 0;
2438 int menubar_size
2439 = (f->output_data.x->menubar_widget
2440 ? (f->output_data.x->menubar_widget->core.height
2441 + f->output_data.x->menubar_widget->core.border_width)
2442 : 0);
2444 #if 0 /* Experimentally, we now get the right results
2445 for -geometry -0-0 without this. 24 Aug 96, rms. */
2446 if (FRAME_EXTERNAL_MENU_BAR (f))
2448 Dimension ibw = 0;
2449 XtVaGetValues (pane_widget, XtNinternalBorderWidth, &ibw, NULL);
2450 menubar_size += ibw;
2452 #endif
2454 f->output_data.x->menubar_height = menubar_size;
2456 #ifndef USE_LUCID
2457 /* Motif seems to need this amount added to the sizes
2458 specified for the shell widget. The Athena/Lucid widgets don't.
2459 Both conclusions reached experimentally. -- rms. */
2460 XtVaGetValues (f->output_data.x->edit_widget, XtNinternalBorderWidth,
2461 &extra_borders, NULL);
2462 extra_borders *= 2;
2463 #endif
2465 /* Convert our geometry parameters into a geometry string
2466 and specify it.
2467 Note that we do not specify here whether the position
2468 is a user-specified or program-specified one.
2469 We pass that information later, in x_wm_set_size_hints. */
2471 int left = f->left_pos;
2472 int xneg = window_prompting & XNegative;
2473 int top = f->top_pos;
2474 int yneg = window_prompting & YNegative;
2475 if (xneg)
2476 left = -left;
2477 if (yneg)
2478 top = -top;
2480 if (window_prompting & USPosition)
2481 sprintf (shell_position, "=%dx%d%c%d%c%d",
2482 FRAME_PIXEL_WIDTH (f) + extra_borders,
2483 FRAME_PIXEL_HEIGHT (f) + menubar_size + extra_borders,
2484 (xneg ? '-' : '+'), left,
2485 (yneg ? '-' : '+'), top);
2486 else
2488 sprintf (shell_position, "=%dx%d",
2489 FRAME_PIXEL_WIDTH (f) + extra_borders,
2490 FRAME_PIXEL_HEIGHT (f) + menubar_size + extra_borders);
2492 /* Setting x and y when the position is not specified in
2493 the geometry string will set program position in the WM hints.
2494 If Emacs had just one program position, we could set it in
2495 fallback resources, but since each make-frame call can specify
2496 different program positions, this is easier. */
2497 XtSetArg (gal[gac], XtNx, left); gac++;
2498 XtSetArg (gal[gac], XtNy, top); gac++;
2502 /* We don't free this because we don't know whether
2503 it is safe to free it while the frame exists.
2504 It isn't worth the trouble of arranging to free it
2505 when the frame is deleted. */
2506 tem = (char *) xstrdup (shell_position);
2507 XtSetArg (gal[gac], XtNgeometry, tem); gac++;
2508 XtSetValues (shell_widget, gal, gac);
2511 XtManageChild (pane_widget);
2512 XtRealizeWidget (shell_widget);
2514 if (FRAME_X_EMBEDDED_P (f))
2515 XReparentWindow (FRAME_X_DISPLAY (f), XtWindow (shell_widget),
2516 f->output_data.x->parent_desc, 0, 0);
2518 FRAME_X_WINDOW (f) = XtWindow (frame_widget);
2520 validate_x_resource_name ();
2522 class_hints.res_name = SSDATA (Vx_resource_name);
2523 class_hints.res_class = SSDATA (Vx_resource_class);
2524 XSetClassHint (FRAME_X_DISPLAY (f), XtWindow (shell_widget), &class_hints);
2526 #ifdef HAVE_X_I18N
2527 FRAME_XIC (f) = NULL;
2528 if (use_xim)
2529 create_frame_xic (f);
2530 #endif
2532 f->output_data.x->wm_hints.input = True;
2533 f->output_data.x->wm_hints.flags |= InputHint;
2534 XSetWMHints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2535 &f->output_data.x->wm_hints);
2537 hack_wm_protocols (f, shell_widget);
2539 #ifdef HACK_EDITRES
2540 XtAddEventHandler (shell_widget, 0, True, _XEditResCheckMessages, 0);
2541 #endif
2543 /* Do a stupid property change to force the server to generate a
2544 PropertyNotify event so that the event_stream server timestamp will
2545 be initialized to something relevant to the time we created the window.
2547 XChangeProperty (XtDisplay (frame_widget), XtWindow (frame_widget),
2548 FRAME_X_DISPLAY_INFO (f)->Xatom_wm_protocols,
2549 XA_ATOM, 32, PropModeAppend,
2550 (unsigned char*) NULL, 0);
2552 /* Make all the standard events reach the Emacs frame. */
2553 attributes.event_mask = STANDARD_EVENT_SET;
2555 #ifdef HAVE_X_I18N
2556 if (FRAME_XIC (f))
2558 /* XIM server might require some X events. */
2559 unsigned long fevent = NoEventMask;
2560 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2561 attributes.event_mask |= fevent;
2563 #endif /* HAVE_X_I18N */
2565 attribute_mask = CWEventMask;
2566 XChangeWindowAttributes (XtDisplay (shell_widget), XtWindow (shell_widget),
2567 attribute_mask, &attributes);
2569 XtMapWidget (frame_widget);
2571 /* x_set_name normally ignores requests to set the name if the
2572 requested name is the same as the current name. This is the one
2573 place where that assumption isn't correct; f->name is set, but
2574 the X server hasn't been told. */
2576 Lisp_Object name;
2577 int explicit = f->explicit_name;
2579 f->explicit_name = 0;
2580 name = f->name;
2581 f->name = Qnil;
2582 x_set_name (f, name, explicit);
2585 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2586 f->output_data.x->current_cursor
2587 = f->output_data.x->text_cursor);
2589 UNBLOCK_INPUT;
2591 /* This is a no-op, except under Motif. Make sure main areas are
2592 set to something reasonable, in case we get an error later. */
2593 lw_set_main_areas (pane_widget, 0, frame_widget);
2596 #else /* not USE_X_TOOLKIT */
2597 #ifdef USE_GTK
2598 static void
2599 x_window (FRAME_PTR f)
2601 if (! xg_create_frame_widgets (f))
2602 error ("Unable to create window");
2604 #ifdef HAVE_X_I18N
2605 FRAME_XIC (f) = NULL;
2606 if (use_xim)
2608 BLOCK_INPUT;
2609 create_frame_xic (f);
2610 if (FRAME_XIC (f))
2612 /* XIM server might require some X events. */
2613 unsigned long fevent = NoEventMask;
2614 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2616 if (fevent != NoEventMask)
2618 XSetWindowAttributes attributes;
2619 XWindowAttributes wattr;
2620 unsigned long attribute_mask;
2622 XGetWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2623 &wattr);
2624 attributes.event_mask = wattr.your_event_mask | fevent;
2625 attribute_mask = CWEventMask;
2626 XChangeWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2627 attribute_mask, &attributes);
2630 UNBLOCK_INPUT;
2632 #endif
2635 #else /*! USE_GTK */
2636 /* Create and set up the X window for frame F. */
2638 static void
2639 x_window (struct frame *f)
2641 XClassHint class_hints;
2642 XSetWindowAttributes attributes;
2643 unsigned long attribute_mask;
2645 attributes.background_pixel = FRAME_BACKGROUND_PIXEL (f);
2646 attributes.border_pixel = f->output_data.x->border_pixel;
2647 attributes.bit_gravity = StaticGravity;
2648 attributes.backing_store = NotUseful;
2649 attributes.save_under = True;
2650 attributes.event_mask = STANDARD_EVENT_SET;
2651 attributes.colormap = FRAME_X_COLORMAP (f);
2652 attribute_mask = (CWBackPixel | CWBorderPixel | CWBitGravity | CWEventMask
2653 | CWColormap);
2655 BLOCK_INPUT;
2656 FRAME_X_WINDOW (f)
2657 = XCreateWindow (FRAME_X_DISPLAY (f),
2658 f->output_data.x->parent_desc,
2659 f->left_pos,
2660 f->top_pos,
2661 FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f),
2662 f->border_width,
2663 CopyFromParent, /* depth */
2664 InputOutput, /* class */
2665 FRAME_X_VISUAL (f),
2666 attribute_mask, &attributes);
2668 #ifdef HAVE_X_I18N
2669 if (use_xim)
2671 create_frame_xic (f);
2672 if (FRAME_XIC (f))
2674 /* XIM server might require some X events. */
2675 unsigned long fevent = NoEventMask;
2676 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2677 attributes.event_mask |= fevent;
2678 attribute_mask = CWEventMask;
2679 XChangeWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2680 attribute_mask, &attributes);
2683 #endif /* HAVE_X_I18N */
2685 validate_x_resource_name ();
2687 class_hints.res_name = SSDATA (Vx_resource_name);
2688 class_hints.res_class = SSDATA (Vx_resource_class);
2689 XSetClassHint (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), &class_hints);
2691 /* The menubar is part of the ordinary display;
2692 it does not count in addition to the height of the window. */
2693 f->output_data.x->menubar_height = 0;
2695 /* This indicates that we use the "Passive Input" input model.
2696 Unless we do this, we don't get the Focus{In,Out} events that we
2697 need to draw the cursor correctly. Accursed bureaucrats.
2698 XWhipsAndChains (FRAME_X_DISPLAY (f), IronMaiden, &TheRack); */
2700 f->output_data.x->wm_hints.input = True;
2701 f->output_data.x->wm_hints.flags |= InputHint;
2702 XSetWMHints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2703 &f->output_data.x->wm_hints);
2704 f->output_data.x->wm_hints.icon_pixmap = None;
2706 /* Request "save yourself" and "delete window" commands from wm. */
2708 Atom protocols[2];
2709 protocols[0] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_delete_window;
2710 protocols[1] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_save_yourself;
2711 XSetWMProtocols (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), protocols, 2);
2714 /* x_set_name normally ignores requests to set the name if the
2715 requested name is the same as the current name. This is the one
2716 place where that assumption isn't correct; f->name is set, but
2717 the X server hasn't been told. */
2719 Lisp_Object name;
2720 int explicit = f->explicit_name;
2722 f->explicit_name = 0;
2723 name = f->name;
2724 f->name = Qnil;
2725 x_set_name (f, name, explicit);
2728 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2729 f->output_data.x->current_cursor
2730 = f->output_data.x->text_cursor);
2732 UNBLOCK_INPUT;
2734 if (FRAME_X_WINDOW (f) == 0)
2735 error ("Unable to create window");
2738 #endif /* not USE_GTK */
2739 #endif /* not USE_X_TOOLKIT */
2741 /* Verify that the icon position args for this window are valid. */
2743 static void
2744 x_icon_verify (struct frame *f, Lisp_Object parms)
2746 Lisp_Object icon_x, icon_y;
2748 /* Set the position of the icon. Note that twm groups all
2749 icons in an icon window. */
2750 icon_x = x_frame_get_and_record_arg (f, parms, Qicon_left, 0, 0, RES_TYPE_NUMBER);
2751 icon_y = x_frame_get_and_record_arg (f, parms, Qicon_top, 0, 0, RES_TYPE_NUMBER);
2752 if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
2754 CHECK_NUMBER (icon_x);
2755 CHECK_NUMBER (icon_y);
2757 else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
2758 error ("Both left and top icon corners of icon must be specified");
2761 /* Handle the icon stuff for this window. Perhaps later we might
2762 want an x_set_icon_position which can be called interactively as
2763 well. */
2765 static void
2766 x_icon (struct frame *f, Lisp_Object parms)
2768 Lisp_Object icon_x, icon_y;
2769 #if 0
2770 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
2771 #endif
2773 /* Set the position of the icon. Note that twm groups all
2774 icons in an icon window. */
2775 icon_x = x_frame_get_and_record_arg (f, parms, Qicon_left, 0, 0, RES_TYPE_NUMBER);
2776 icon_y = x_frame_get_and_record_arg (f, parms, Qicon_top, 0, 0, RES_TYPE_NUMBER);
2777 if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
2779 CHECK_TYPE_RANGED_INTEGER (int, icon_x);
2780 CHECK_TYPE_RANGED_INTEGER (int, icon_y);
2782 else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
2783 error ("Both left and top icon corners of icon must be specified");
2785 BLOCK_INPUT;
2787 if (! EQ (icon_x, Qunbound))
2788 x_wm_set_icon_position (f, XINT (icon_x), XINT (icon_y));
2790 #if 0 /* x_get_arg removes the visibility parameter as a side effect,
2791 but x_create_frame still needs it. */
2792 /* Start up iconic or window? */
2793 x_wm_set_window_state
2794 (f, (EQ (x_get_arg (dpyinfo, parms, Qvisibility, 0, 0, RES_TYPE_SYMBOL),
2795 Qicon)
2796 ? IconicState
2797 : NormalState));
2798 #endif
2800 x_text_icon (f, SSDATA ((!NILP (f->icon_name)
2801 ? f->icon_name
2802 : f->name)));
2804 UNBLOCK_INPUT;
2807 /* Make the GCs needed for this window, setting the
2808 background, border and mouse colors; also create the
2809 mouse cursor and the gray border tile. */
2811 static void
2812 x_make_gc (struct frame *f)
2814 XGCValues gc_values;
2816 BLOCK_INPUT;
2818 /* Create the GCs of this frame.
2819 Note that many default values are used. */
2821 gc_values.foreground = FRAME_FOREGROUND_PIXEL (f);
2822 gc_values.background = FRAME_BACKGROUND_PIXEL (f);
2823 gc_values.line_width = 0; /* Means 1 using fast algorithm. */
2824 f->output_data.x->normal_gc
2825 = XCreateGC (FRAME_X_DISPLAY (f),
2826 FRAME_X_WINDOW (f),
2827 GCLineWidth | GCForeground | GCBackground,
2828 &gc_values);
2830 /* Reverse video style. */
2831 gc_values.foreground = FRAME_BACKGROUND_PIXEL (f);
2832 gc_values.background = FRAME_FOREGROUND_PIXEL (f);
2833 f->output_data.x->reverse_gc
2834 = XCreateGC (FRAME_X_DISPLAY (f),
2835 FRAME_X_WINDOW (f),
2836 GCForeground | GCBackground | GCLineWidth,
2837 &gc_values);
2839 /* Cursor has cursor-color background, background-color foreground. */
2840 gc_values.foreground = FRAME_BACKGROUND_PIXEL (f);
2841 gc_values.background = f->output_data.x->cursor_pixel;
2842 gc_values.fill_style = FillOpaqueStippled;
2843 f->output_data.x->cursor_gc
2844 = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2845 (GCForeground | GCBackground
2846 | GCFillStyle | GCLineWidth),
2847 &gc_values);
2849 /* Reliefs. */
2850 f->output_data.x->white_relief.gc = 0;
2851 f->output_data.x->black_relief.gc = 0;
2853 /* Create the gray border tile used when the pointer is not in
2854 the frame. Since this depends on the frame's pixel values,
2855 this must be done on a per-frame basis. */
2856 f->output_data.x->border_tile
2857 = (XCreatePixmapFromBitmapData
2858 (FRAME_X_DISPLAY (f), FRAME_X_DISPLAY_INFO (f)->root_window,
2859 gray_bits, gray_width, gray_height,
2860 FRAME_FOREGROUND_PIXEL (f),
2861 FRAME_BACKGROUND_PIXEL (f),
2862 DefaultDepth (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f))));
2864 UNBLOCK_INPUT;
2868 /* Free what was allocated in x_make_gc. */
2870 void
2871 x_free_gcs (struct frame *f)
2873 Display *dpy = FRAME_X_DISPLAY (f);
2875 BLOCK_INPUT;
2877 if (f->output_data.x->normal_gc)
2879 XFreeGC (dpy, f->output_data.x->normal_gc);
2880 f->output_data.x->normal_gc = 0;
2883 if (f->output_data.x->reverse_gc)
2885 XFreeGC (dpy, f->output_data.x->reverse_gc);
2886 f->output_data.x->reverse_gc = 0;
2889 if (f->output_data.x->cursor_gc)
2891 XFreeGC (dpy, f->output_data.x->cursor_gc);
2892 f->output_data.x->cursor_gc = 0;
2895 if (f->output_data.x->border_tile)
2897 XFreePixmap (dpy, f->output_data.x->border_tile);
2898 f->output_data.x->border_tile = 0;
2901 UNBLOCK_INPUT;
2905 /* Handler for signals raised during x_create_frame and
2906 x_create_tip_frame. FRAME is the frame which is partially
2907 constructed. */
2909 static Lisp_Object
2910 unwind_create_frame (Lisp_Object frame)
2912 struct frame *f = XFRAME (frame);
2914 /* If frame is already dead, nothing to do. This can happen if the
2915 display is disconnected after the frame has become official, but
2916 before x_create_frame removes the unwind protect. */
2917 if (!FRAME_LIVE_P (f))
2918 return Qnil;
2920 /* If frame is ``official'', nothing to do. */
2921 if (NILP (Fmemq (frame, Vframe_list)))
2923 #if GLYPH_DEBUG && XASSERTS
2924 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
2925 #endif
2927 x_free_frame_resources (f);
2928 free_glyphs (f);
2930 #if GLYPH_DEBUG
2931 /* Check that reference counts are indeed correct. */
2932 xassert (dpyinfo->reference_count == dpyinfo_refcount);
2933 xassert (dpyinfo->terminal->image_cache->refcount == image_cache_refcount);
2934 #endif
2935 return Qt;
2938 return Qnil;
2941 static Lisp_Object
2942 unwind_create_frame_1 (Lisp_Object val)
2944 inhibit_lisp_code = val;
2945 return Qnil;
2948 static void
2949 x_default_font_parameter (struct frame *f, Lisp_Object parms)
2951 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
2952 Lisp_Object font_param = x_get_arg (dpyinfo, parms, Qfont, NULL, NULL,
2953 RES_TYPE_STRING);
2954 Lisp_Object font = Qnil;
2955 if (EQ (font_param, Qunbound))
2956 font_param = Qnil;
2958 if (NILP (font_param))
2960 /* System font should take precedence over X resources. We suggest this
2961 regardless of font-use-system-font because .emacs may not have been
2962 read yet. */
2963 const char *system_font = xsettings_get_system_font ();
2964 if (system_font)
2966 char *name = xstrdup (system_font);
2967 font = font_open_by_name (f, name);
2968 xfree (name);
2972 if (NILP (font))
2973 font = !NILP (font_param) ? font_param
2974 : x_get_arg (dpyinfo, parms, Qfont, "font", "Font", RES_TYPE_STRING);
2976 if (! FONTP (font) && ! STRINGP (font))
2978 const char *names[]
2980 #ifdef HAVE_XFT
2981 /* This will find the normal Xft font. */
2982 "monospace-10",
2983 #endif
2984 "-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1",
2985 "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1",
2986 "-*-*-medium-r-normal-*-*-140-*-*-c-*-iso8859-1",
2987 /* This was formerly the first thing tried, but it finds
2988 too many fonts and takes too long. */
2989 "-*-*-medium-r-*-*-*-*-*-*-c-*-iso8859-1",
2990 /* If those didn't work, look for something which will
2991 at least work. */
2992 "-*-fixed-*-*-*-*-*-140-*-*-c-*-iso8859-1",
2993 "fixed",
2994 NULL };
2995 int i;
2997 for (i = 0; names[i]; i++)
2999 font = font_open_by_name (f, names[i]);
3000 if (! NILP (font))
3001 break;
3003 if (NILP (font))
3004 error ("No suitable font was found");
3006 else if (!NILP (font_param))
3008 /* Remember the explicit font parameter, so we can re-apply it after
3009 we've applied the `default' face settings. */
3010 x_set_frame_parameters (f, Fcons (Fcons (Qfont_param, font_param), Qnil));
3013 /* This call will make X resources override any system font setting. */
3014 x_default_parameter (f, parms, Qfont, font, "font", "Font", RES_TYPE_STRING);
3018 DEFUN ("x-wm-set-size-hint", Fx_wm_set_size_hint, Sx_wm_set_size_hint,
3019 0, 1, 0,
3020 doc: /* Send the size hints for frame FRAME to the window manager.
3021 If FRAME is nil, use the selected frame. */)
3022 (Lisp_Object frame)
3024 struct frame *f;
3025 if (NILP (frame))
3026 frame = selected_frame;
3027 f = XFRAME (frame);
3028 BLOCK_INPUT;
3029 if (FRAME_X_P (f))
3030 x_wm_set_size_hint (f, 0, 0);
3031 UNBLOCK_INPUT;
3032 return Qnil;
3035 static void
3036 set_machine_and_pid_properties (struct frame *f)
3038 long pid = (long) getpid ();
3040 /* This will set WM_CLIENT_MACHINE and WM_LOCALE_NAME. */
3041 XSetWMProperties (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), NULL, NULL,
3042 NULL, 0, NULL, NULL, NULL);
3043 XChangeProperty (FRAME_X_DISPLAY (f),
3044 FRAME_OUTER_WINDOW (f),
3045 XInternAtom (FRAME_X_DISPLAY (f),
3046 "_NET_WM_PID",
3047 False),
3048 XA_CARDINAL, 32, PropModeReplace,
3049 (unsigned char *) &pid, 1);
3052 DEFUN ("x-create-frame", Fx_create_frame, Sx_create_frame,
3053 1, 1, 0,
3054 doc: /* Make a new X window, which is called a "frame" in Emacs terms.
3055 Return an Emacs frame object.
3056 PARMS is an alist of frame parameters.
3057 If the parameters specify that the frame should not have a minibuffer,
3058 and do not specify a specific minibuffer window to use,
3059 then `default-minibuffer-frame' must be a frame whose minibuffer can
3060 be shared by the new frame.
3062 This function is an internal primitive--use `make-frame' instead. */)
3063 (Lisp_Object parms)
3065 struct frame *f;
3066 Lisp_Object frame, tem;
3067 Lisp_Object name;
3068 int minibuffer_only = 0;
3069 long window_prompting = 0;
3070 int width, height;
3071 ptrdiff_t count = SPECPDL_INDEX ();
3072 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
3073 Lisp_Object display;
3074 struct x_display_info *dpyinfo = NULL;
3075 Lisp_Object parent;
3076 struct kboard *kb;
3078 parms = Fcopy_alist (parms);
3080 /* Use this general default value to start with
3081 until we know if this frame has a specified name. */
3082 Vx_resource_name = Vinvocation_name;
3084 display = x_get_arg (dpyinfo, parms, Qterminal, 0, 0, RES_TYPE_NUMBER);
3085 if (EQ (display, Qunbound))
3086 display = x_get_arg (dpyinfo, parms, Qdisplay, 0, 0, RES_TYPE_STRING);
3087 if (EQ (display, Qunbound))
3088 display = Qnil;
3089 dpyinfo = check_x_display_info (display);
3090 kb = dpyinfo->terminal->kboard;
3092 if (!dpyinfo->terminal->name)
3093 error ("Terminal is not live, can't create new frames on it");
3095 name = x_get_arg (dpyinfo, parms, Qname, "name", "Name", RES_TYPE_STRING);
3096 if (!STRINGP (name)
3097 && ! EQ (name, Qunbound)
3098 && ! NILP (name))
3099 error ("Invalid frame name--not a string or nil");
3101 if (STRINGP (name))
3102 Vx_resource_name = name;
3104 /* See if parent window is specified. */
3105 parent = x_get_arg (dpyinfo, parms, Qparent_id, NULL, NULL, RES_TYPE_NUMBER);
3106 if (EQ (parent, Qunbound))
3107 parent = Qnil;
3108 if (! NILP (parent))
3109 CHECK_NUMBER (parent);
3111 /* make_frame_without_minibuffer can run Lisp code and garbage collect. */
3112 /* No need to protect DISPLAY because that's not used after passing
3113 it to make_frame_without_minibuffer. */
3114 frame = Qnil;
3115 GCPRO4 (parms, parent, name, frame);
3116 tem = x_get_arg (dpyinfo, parms, Qminibuffer, "minibuffer", "Minibuffer",
3117 RES_TYPE_SYMBOL);
3118 if (EQ (tem, Qnone) || NILP (tem))
3119 f = make_frame_without_minibuffer (Qnil, kb, display);
3120 else if (EQ (tem, Qonly))
3122 f = make_minibuffer_frame ();
3123 minibuffer_only = 1;
3125 else if (WINDOWP (tem))
3126 f = make_frame_without_minibuffer (tem, kb, display);
3127 else
3128 f = make_frame (1);
3130 XSETFRAME (frame, f);
3132 /* Note that X Windows does support scroll bars. */
3133 FRAME_CAN_HAVE_SCROLL_BARS (f) = 1;
3135 f->terminal = dpyinfo->terminal;
3137 f->output_method = output_x_window;
3138 f->output_data.x = (struct x_output *) xmalloc (sizeof (struct x_output));
3139 memset (f->output_data.x, 0, sizeof (struct x_output));
3140 f->output_data.x->icon_bitmap = -1;
3141 FRAME_FONTSET (f) = -1;
3142 f->output_data.x->scroll_bar_foreground_pixel = -1;
3143 f->output_data.x->scroll_bar_background_pixel = -1;
3144 #ifdef USE_TOOLKIT_SCROLL_BARS
3145 f->output_data.x->scroll_bar_top_shadow_pixel = -1;
3146 f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
3147 #endif /* USE_TOOLKIT_SCROLL_BARS */
3149 f->icon_name
3150 = x_get_arg (dpyinfo, parms, Qicon_name, "iconName", "Title",
3151 RES_TYPE_STRING);
3152 if (! STRINGP (f->icon_name))
3153 f->icon_name = Qnil;
3155 FRAME_X_DISPLAY_INFO (f) = dpyinfo;
3157 /* With FRAME_X_DISPLAY_INFO set up, this unwind-protect is safe. */
3158 record_unwind_protect (unwind_create_frame, frame);
3160 /* These colors will be set anyway later, but it's important
3161 to get the color reference counts right, so initialize them! */
3163 Lisp_Object black;
3164 struct gcpro gcpro1;
3166 /* Function x_decode_color can signal an error. Make
3167 sure to initialize color slots so that we won't try
3168 to free colors we haven't allocated. */
3169 FRAME_FOREGROUND_PIXEL (f) = -1;
3170 FRAME_BACKGROUND_PIXEL (f) = -1;
3171 f->output_data.x->cursor_pixel = -1;
3172 f->output_data.x->cursor_foreground_pixel = -1;
3173 f->output_data.x->border_pixel = -1;
3174 f->output_data.x->mouse_pixel = -1;
3176 black = build_string ("black");
3177 GCPRO1 (black);
3178 FRAME_FOREGROUND_PIXEL (f)
3179 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3180 FRAME_BACKGROUND_PIXEL (f)
3181 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3182 f->output_data.x->cursor_pixel
3183 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3184 f->output_data.x->cursor_foreground_pixel
3185 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3186 f->output_data.x->border_pixel
3187 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3188 f->output_data.x->mouse_pixel
3189 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3190 UNGCPRO;
3193 /* Specify the parent under which to make this X window. */
3195 if (!NILP (parent))
3197 f->output_data.x->parent_desc = (Window) XFASTINT (parent);
3198 f->output_data.x->explicit_parent = 1;
3200 else
3202 f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
3203 f->output_data.x->explicit_parent = 0;
3206 /* Set the name; the functions to which we pass f expect the name to
3207 be set. */
3208 if (EQ (name, Qunbound) || NILP (name))
3210 f->name = build_string (dpyinfo->x_id_name);
3211 f->explicit_name = 0;
3213 else
3215 f->name = name;
3216 f->explicit_name = 1;
3217 /* use the frame's title when getting resources for this frame. */
3218 specbind (Qx_resource_name, name);
3221 f->resx = dpyinfo->resx;
3222 f->resy = dpyinfo->resy;
3224 #ifdef HAVE_FREETYPE
3225 #ifdef HAVE_XFT
3226 register_font_driver (&xftfont_driver, f);
3227 #else /* not HAVE_XFT */
3228 register_font_driver (&ftxfont_driver, f);
3229 #endif /* not HAVE_XFT */
3230 #endif /* HAVE_FREETYPE */
3231 register_font_driver (&xfont_driver, f);
3233 x_default_parameter (f, parms, Qfont_backend, Qnil,
3234 "fontBackend", "FontBackend", RES_TYPE_STRING);
3236 /* Extract the window parameters from the supplied values
3237 that are needed to determine window geometry. */
3238 x_default_font_parameter (f, parms);
3239 if (!FRAME_FONT (f))
3241 delete_frame (frame, Qnoelisp);
3242 error ("Invalid frame font");
3245 /* Frame contents get displaced if an embedded X window has a border. */
3246 if (! FRAME_X_EMBEDDED_P (f))
3247 x_default_parameter (f, parms, Qborder_width, make_number (0),
3248 "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
3250 /* This defaults to 1 in order to match xterm. We recognize either
3251 internalBorderWidth or internalBorder (which is what xterm calls
3252 it). */
3253 if (NILP (Fassq (Qinternal_border_width, parms)))
3255 Lisp_Object value;
3257 value = x_get_arg (dpyinfo, parms, Qinternal_border_width,
3258 "internalBorder", "internalBorder", RES_TYPE_NUMBER);
3259 if (! EQ (value, Qunbound))
3260 parms = Fcons (Fcons (Qinternal_border_width, value),
3261 parms);
3263 x_default_parameter (f, parms, Qinternal_border_width,
3264 #ifdef USE_GTK /* We used to impose 0 in xg_create_frame_widgets. */
3265 make_number (0),
3266 #else
3267 make_number (1),
3268 #endif
3269 "internalBorderWidth", "internalBorderWidth",
3270 RES_TYPE_NUMBER);
3271 x_default_parameter (f, parms, Qvertical_scroll_bars,
3272 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
3273 Qright,
3274 #else
3275 Qleft,
3276 #endif
3277 "verticalScrollBars", "ScrollBars",
3278 RES_TYPE_SYMBOL);
3280 /* Also do the stuff which must be set before the window exists. */
3281 x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
3282 "foreground", "Foreground", RES_TYPE_STRING);
3283 x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
3284 "background", "Background", RES_TYPE_STRING);
3285 x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
3286 "pointerColor", "Foreground", RES_TYPE_STRING);
3287 x_default_parameter (f, parms, Qborder_color, build_string ("black"),
3288 "borderColor", "BorderColor", RES_TYPE_STRING);
3289 x_default_parameter (f, parms, Qscreen_gamma, Qnil,
3290 "screenGamma", "ScreenGamma", RES_TYPE_FLOAT);
3291 x_default_parameter (f, parms, Qline_spacing, Qnil,
3292 "lineSpacing", "LineSpacing", RES_TYPE_NUMBER);
3293 x_default_parameter (f, parms, Qleft_fringe, Qnil,
3294 "leftFringe", "LeftFringe", RES_TYPE_NUMBER);
3295 x_default_parameter (f, parms, Qright_fringe, Qnil,
3296 "rightFringe", "RightFringe", RES_TYPE_NUMBER);
3298 x_default_scroll_bar_color_parameter (f, parms, Qscroll_bar_foreground,
3299 "scrollBarForeground",
3300 "ScrollBarForeground", 1);
3301 x_default_scroll_bar_color_parameter (f, parms, Qscroll_bar_background,
3302 "scrollBarBackground",
3303 "ScrollBarBackground", 0);
3305 #if GLYPH_DEBUG
3306 image_cache_refcount =
3307 FRAME_IMAGE_CACHE (f) ? FRAME_IMAGE_CACHE (f)->refcount : 0;
3308 dpyinfo_refcount = dpyinfo->reference_count;
3309 #endif /* GLYPH_DEBUG */
3311 /* Init faces before x_default_parameter is called for scroll-bar
3312 parameters because that function calls x_set_scroll_bar_width,
3313 which calls change_frame_size, which calls Fset_window_buffer,
3314 which runs hooks, which call Fvertical_motion. At the end, we
3315 end up in init_iterator with a null face cache, which should not
3316 happen. */
3317 init_frame_faces (f);
3319 /* Set the menu-bar-lines and tool-bar-lines parameters. We don't
3320 look up the X resources controlling the menu-bar and tool-bar
3321 here; they are processed specially at startup, and reflected in
3322 the values of the mode variables.
3324 Avoid calling window-configuration-change-hook; otherwise we
3325 could get an infloop in next_frame since the frame is not yet in
3326 Vframe_list. */
3328 ptrdiff_t count2 = SPECPDL_INDEX ();
3329 record_unwind_protect (unwind_create_frame_1, inhibit_lisp_code);
3330 inhibit_lisp_code = Qt;
3332 x_default_parameter (f, parms, Qmenu_bar_lines,
3333 NILP (Vmenu_bar_mode)
3334 ? make_number (0) : make_number (1),
3335 NULL, NULL, RES_TYPE_NUMBER);
3336 x_default_parameter (f, parms, Qtool_bar_lines,
3337 NILP (Vtool_bar_mode)
3338 ? make_number (0) : make_number (1),
3339 NULL, NULL, RES_TYPE_NUMBER);
3341 unbind_to (count2, Qnil);
3344 x_default_parameter (f, parms, Qbuffer_predicate, Qnil,
3345 "bufferPredicate", "BufferPredicate",
3346 RES_TYPE_SYMBOL);
3347 x_default_parameter (f, parms, Qtitle, Qnil,
3348 "title", "Title", RES_TYPE_STRING);
3349 x_default_parameter (f, parms, Qwait_for_wm, Qt,
3350 "waitForWM", "WaitForWM", RES_TYPE_BOOLEAN);
3351 x_default_parameter (f, parms, Qfullscreen, Qnil,
3352 "fullscreen", "Fullscreen", RES_TYPE_SYMBOL);
3353 x_default_parameter (f, parms, Qtool_bar_position,
3354 f->tool_bar_position, 0, 0, RES_TYPE_SYMBOL);
3356 /* Compute the size of the X window. */
3357 window_prompting = x_figure_window_size (f, parms, 1);
3359 tem = x_get_arg (dpyinfo, parms, Qunsplittable, 0, 0, RES_TYPE_BOOLEAN);
3360 f->no_split = minibuffer_only || EQ (tem, Qt);
3362 x_icon_verify (f, parms);
3364 /* Create the X widget or window. */
3365 #ifdef USE_X_TOOLKIT
3366 x_window (f, window_prompting, minibuffer_only);
3367 #else
3368 x_window (f);
3369 #endif
3371 x_icon (f, parms);
3372 x_make_gc (f);
3374 /* Now consider the frame official. */
3375 f->terminal->reference_count++;
3376 FRAME_X_DISPLAY_INFO (f)->reference_count++;
3377 Vframe_list = Fcons (frame, Vframe_list);
3379 /* We need to do this after creating the X window, so that the
3380 icon-creation functions can say whose icon they're describing. */
3381 x_default_parameter (f, parms, Qicon_type, Qt,
3382 "bitmapIcon", "BitmapIcon", RES_TYPE_BOOLEAN);
3384 x_default_parameter (f, parms, Qauto_raise, Qnil,
3385 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
3386 x_default_parameter (f, parms, Qauto_lower, Qnil,
3387 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
3388 x_default_parameter (f, parms, Qcursor_type, Qbox,
3389 "cursorType", "CursorType", RES_TYPE_SYMBOL);
3390 x_default_parameter (f, parms, Qscroll_bar_width, Qnil,
3391 "scrollBarWidth", "ScrollBarWidth",
3392 RES_TYPE_NUMBER);
3393 x_default_parameter (f, parms, Qalpha, Qnil,
3394 "alpha", "Alpha", RES_TYPE_NUMBER);
3396 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
3397 Change will not be effected unless different from the current
3398 FRAME_LINES (f). */
3399 width = FRAME_COLS (f);
3400 height = FRAME_LINES (f);
3402 SET_FRAME_COLS (f, 0);
3403 FRAME_LINES (f) = 0;
3404 change_frame_size (f, height, width, 1, 0, 0);
3406 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
3407 /* Create the menu bar. */
3408 if (!minibuffer_only && FRAME_EXTERNAL_MENU_BAR (f))
3410 /* If this signals an error, we haven't set size hints for the
3411 frame and we didn't make it visible. */
3412 initialize_frame_menubar (f);
3414 #ifndef USE_GTK
3415 /* This is a no-op, except under Motif where it arranges the
3416 main window for the widgets on it. */
3417 lw_set_main_areas (f->output_data.x->column_widget,
3418 f->output_data.x->menubar_widget,
3419 f->output_data.x->edit_widget);
3420 #endif /* not USE_GTK */
3422 #endif /* USE_X_TOOLKIT || USE_GTK */
3424 /* Tell the server what size and position, etc, we want, and how
3425 badly we want them. This should be done after we have the menu
3426 bar so that its size can be taken into account. */
3427 BLOCK_INPUT;
3428 x_wm_set_size_hint (f, window_prompting, 0);
3429 UNBLOCK_INPUT;
3431 /* Make the window appear on the frame and enable display, unless
3432 the caller says not to. However, with explicit parent, Emacs
3433 cannot control visibility, so don't try. */
3434 if (! f->output_data.x->explicit_parent)
3436 Lisp_Object visibility;
3438 visibility = x_get_arg (dpyinfo, parms, Qvisibility, 0, 0,
3439 RES_TYPE_SYMBOL);
3440 if (EQ (visibility, Qunbound))
3441 visibility = Qt;
3443 if (EQ (visibility, Qicon))
3444 x_iconify_frame (f);
3445 else if (! NILP (visibility))
3446 x_make_frame_visible (f);
3447 else
3449 /* Must have been Qnil. */
3453 BLOCK_INPUT;
3455 /* Set machine name and pid for the purpose of window managers. */
3456 set_machine_and_pid_properties (f);
3458 /* Set the WM leader property. GTK does this itself, so this is not
3459 needed when using GTK. */
3460 if (dpyinfo->client_leader_window != 0)
3462 XChangeProperty (FRAME_X_DISPLAY (f),
3463 FRAME_OUTER_WINDOW (f),
3464 dpyinfo->Xatom_wm_client_leader,
3465 XA_WINDOW, 32, PropModeReplace,
3466 (unsigned char *) &dpyinfo->client_leader_window, 1);
3469 UNBLOCK_INPUT;
3471 /* Initialize `default-minibuffer-frame' in case this is the first
3472 frame on this terminal. */
3473 if (FRAME_HAS_MINIBUF_P (f)
3474 && (!FRAMEP (KVAR (kb, Vdefault_minibuffer_frame))
3475 || !FRAME_LIVE_P (XFRAME (KVAR (kb, Vdefault_minibuffer_frame)))))
3476 KVAR (kb, Vdefault_minibuffer_frame) = frame;
3478 /* All remaining specified parameters, which have not been "used"
3479 by x_get_arg and friends, now go in the misc. alist of the frame. */
3480 for (tem = parms; CONSP (tem); tem = XCDR (tem))
3481 if (CONSP (XCAR (tem)) && !NILP (XCAR (XCAR (tem))))
3482 f->param_alist = Fcons (XCAR (tem), f->param_alist);
3484 UNGCPRO;
3486 /* Make sure windows on this frame appear in calls to next-window
3487 and similar functions. */
3488 Vwindow_list = Qnil;
3490 return unbind_to (count, frame);
3494 /* FRAME is used only to get a handle on the X display. We don't pass the
3495 display info directly because we're called from frame.c, which doesn't
3496 know about that structure. */
3498 Lisp_Object
3499 x_get_focus_frame (struct frame *frame)
3501 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (frame);
3502 Lisp_Object xfocus;
3503 if (! dpyinfo->x_focus_frame)
3504 return Qnil;
3506 XSETFRAME (xfocus, dpyinfo->x_focus_frame);
3507 return xfocus;
3511 /* In certain situations, when the window manager follows a
3512 click-to-focus policy, there seems to be no way around calling
3513 XSetInputFocus to give another frame the input focus .
3515 In an ideal world, XSetInputFocus should generally be avoided so
3516 that applications don't interfere with the window manager's focus
3517 policy. But I think it's okay to use when it's clearly done
3518 following a user-command. */
3520 DEFUN ("x-focus-frame", Fx_focus_frame, Sx_focus_frame, 1, 1, 0,
3521 doc: /* Set the input focus to FRAME.
3522 FRAME nil means use the selected frame. */)
3523 (Lisp_Object frame)
3525 struct frame *f = check_x_frame (frame);
3526 Display *dpy = FRAME_X_DISPLAY (f);
3528 BLOCK_INPUT;
3529 x_catch_errors (dpy);
3531 if (FRAME_X_EMBEDDED_P (f))
3533 /* For Xembedded frames, normally the embedder forwards key
3534 events. See XEmbed Protocol Specification at
3535 http://freedesktop.org/wiki/Specifications/xembed-spec */
3536 xembed_request_focus (f);
3538 else
3540 XSetInputFocus (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3541 RevertToParent, CurrentTime);
3542 x_ewmh_activate_frame (f);
3545 x_uncatch_errors ();
3546 UNBLOCK_INPUT;
3548 return Qnil;
3552 DEFUN ("xw-color-defined-p", Fxw_color_defined_p, Sxw_color_defined_p, 1, 2, 0,
3553 doc: /* Internal function called by `color-defined-p', which see
3554 .\(Note that the Nextstep version of this function ignores FRAME.) */)
3555 (Lisp_Object color, Lisp_Object frame)
3557 XColor foo;
3558 FRAME_PTR f = check_x_frame (frame);
3560 CHECK_STRING (color);
3562 if (x_defined_color (f, SSDATA (color), &foo, 0))
3563 return Qt;
3564 else
3565 return Qnil;
3568 DEFUN ("xw-color-values", Fxw_color_values, Sxw_color_values, 1, 2, 0,
3569 doc: /* Internal function called by `color-values', which see. */)
3570 (Lisp_Object color, Lisp_Object frame)
3572 XColor foo;
3573 FRAME_PTR f = check_x_frame (frame);
3575 CHECK_STRING (color);
3577 if (x_defined_color (f, SSDATA (color), &foo, 0))
3578 return list3 (make_number (foo.red),
3579 make_number (foo.green),
3580 make_number (foo.blue));
3581 else
3582 return Qnil;
3585 DEFUN ("xw-display-color-p", Fxw_display_color_p, Sxw_display_color_p, 0, 1, 0,
3586 doc: /* Internal function called by `display-color-p', which see. */)
3587 (Lisp_Object terminal)
3589 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3591 if (dpyinfo->n_planes <= 2)
3592 return Qnil;
3594 switch (dpyinfo->visual->class)
3596 case StaticColor:
3597 case PseudoColor:
3598 case TrueColor:
3599 case DirectColor:
3600 return Qt;
3602 default:
3603 return Qnil;
3607 DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p, Sx_display_grayscale_p,
3608 0, 1, 0,
3609 doc: /* Return t if the X display supports shades of gray.
3610 Note that color displays do support shades of gray.
3611 The optional argument TERMINAL specifies which display to ask about.
3612 TERMINAL should be a terminal object, a frame or a display name (a string).
3613 If omitted or nil, that stands for the selected frame's display. */)
3614 (Lisp_Object terminal)
3616 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3618 if (dpyinfo->n_planes <= 1)
3619 return Qnil;
3621 switch (dpyinfo->visual->class)
3623 case StaticColor:
3624 case PseudoColor:
3625 case TrueColor:
3626 case DirectColor:
3627 case StaticGray:
3628 case GrayScale:
3629 return Qt;
3631 default:
3632 return Qnil;
3636 DEFUN ("x-display-pixel-width", Fx_display_pixel_width, Sx_display_pixel_width,
3637 0, 1, 0,
3638 doc: /* Return the width in pixels of the X display TERMINAL.
3639 The optional argument TERMINAL specifies which display to ask about.
3640 TERMINAL should be a terminal object, a frame or a display name (a string).
3641 If omitted or nil, that stands for the selected frame's display. */)
3642 (Lisp_Object terminal)
3644 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3646 return make_number (x_display_pixel_width (dpyinfo));
3649 DEFUN ("x-display-pixel-height", Fx_display_pixel_height,
3650 Sx_display_pixel_height, 0, 1, 0,
3651 doc: /* Return the height in pixels of the X display TERMINAL.
3652 The optional argument TERMINAL specifies which display to ask about.
3653 TERMINAL should be a terminal object, a frame or a display name (a string).
3654 If omitted or nil, that stands for the selected frame's display. */)
3655 (Lisp_Object terminal)
3657 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3659 return make_number (x_display_pixel_height (dpyinfo));
3662 DEFUN ("x-display-planes", Fx_display_planes, Sx_display_planes,
3663 0, 1, 0,
3664 doc: /* Return the number of bitplanes of the X display TERMINAL.
3665 The optional argument TERMINAL specifies which display to ask about.
3666 TERMINAL should be a terminal object, a frame or a display name (a string).
3667 If omitted or nil, that stands for the selected frame's display. */)
3668 (Lisp_Object terminal)
3670 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3672 return make_number (dpyinfo->n_planes);
3675 DEFUN ("x-display-color-cells", Fx_display_color_cells, Sx_display_color_cells,
3676 0, 1, 0,
3677 doc: /* Return the number of color cells of the X display TERMINAL.
3678 The optional argument TERMINAL specifies which display to ask about.
3679 TERMINAL should be a terminal object, a frame or a display name (a string).
3680 If omitted or nil, that stands for the selected frame's display. */)
3681 (Lisp_Object terminal)
3683 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3685 int nr_planes = DisplayPlanes (dpyinfo->display,
3686 XScreenNumberOfScreen (dpyinfo->screen));
3688 /* Truncate nr_planes to 24 to avoid integer overflow.
3689 Some displays says 32, but only 24 bits are actually significant.
3690 There are only very few and rare video cards that have more than
3691 24 significant bits. Also 24 bits is more than 16 million colors,
3692 it "should be enough for everyone". */
3693 if (nr_planes > 24) nr_planes = 24;
3695 return make_number (1 << nr_planes);
3698 DEFUN ("x-server-max-request-size", Fx_server_max_request_size,
3699 Sx_server_max_request_size,
3700 0, 1, 0,
3701 doc: /* Return the maximum request size of the X server of display TERMINAL.
3702 The optional argument TERMINAL specifies which display to ask about.
3703 TERMINAL should be a terminal object, a frame or a display name (a string).
3704 If omitted or nil, that stands for the selected frame's display. */)
3705 (Lisp_Object terminal)
3707 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3709 return make_number (MAXREQUEST (dpyinfo->display));
3712 DEFUN ("x-server-vendor", Fx_server_vendor, Sx_server_vendor, 0, 1, 0,
3713 doc: /* Return the "vendor ID" string of the X server of display TERMINAL.
3714 \(Labeling every distributor as a "vendor" embodies the false assumption
3715 that operating systems cannot be developed and distributed noncommercially.)
3716 The optional argument TERMINAL specifies which display to ask about.
3717 TERMINAL should be a terminal object, a frame or a display name (a string).
3718 If omitted or nil, that stands for the selected frame's display. */)
3719 (Lisp_Object terminal)
3721 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3722 const char *vendor = ServerVendor (dpyinfo->display);
3724 if (! vendor) vendor = "";
3725 return build_string (vendor);
3728 DEFUN ("x-server-version", Fx_server_version, Sx_server_version, 0, 1, 0,
3729 doc: /* Return the version numbers of the X server of display TERMINAL.
3730 The value is a list of three integers: the major and minor
3731 version numbers of the X Protocol in use, and the distributor-specific release
3732 number. See also the function `x-server-vendor'.
3734 The optional argument TERMINAL specifies which display to ask about.
3735 TERMINAL should be a terminal object, a frame or a display name (a string).
3736 If omitted or nil, that stands for the selected frame's display. */)
3737 (Lisp_Object terminal)
3739 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3740 Display *dpy = dpyinfo->display;
3742 return Fcons (make_number (ProtocolVersion (dpy)),
3743 Fcons (make_number (ProtocolRevision (dpy)),
3744 Fcons (make_number (VendorRelease (dpy)), Qnil)));
3747 DEFUN ("x-display-screens", Fx_display_screens, Sx_display_screens, 0, 1, 0,
3748 doc: /* Return the number of screens on the X server of display TERMINAL.
3749 The optional argument TERMINAL specifies which display to ask about.
3750 TERMINAL should be a terminal object, a frame or a display name (a string).
3751 If omitted or nil, that stands for the selected frame's display. */)
3752 (Lisp_Object terminal)
3754 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3756 return make_number (ScreenCount (dpyinfo->display));
3759 DEFUN ("x-display-mm-height", Fx_display_mm_height, Sx_display_mm_height, 0, 1, 0,
3760 doc: /* Return the height in millimeters of the X display TERMINAL.
3761 The optional argument TERMINAL specifies which display to ask about.
3762 TERMINAL should be a terminal object, a frame or a display name (a string).
3763 If omitted or nil, that stands for the selected frame's display. */)
3764 (Lisp_Object terminal)
3766 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3768 return make_number (HeightMMOfScreen (dpyinfo->screen));
3771 DEFUN ("x-display-mm-width", Fx_display_mm_width, Sx_display_mm_width, 0, 1, 0,
3772 doc: /* Return the width in millimeters of the X display TERMINAL.
3773 The optional argument TERMINAL specifies which display to ask about.
3774 TERMINAL should be a terminal object, a frame or a display name (a string).
3775 If omitted or nil, that stands for the selected frame's display. */)
3776 (Lisp_Object terminal)
3778 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3780 return make_number (WidthMMOfScreen (dpyinfo->screen));
3783 DEFUN ("x-display-backing-store", Fx_display_backing_store,
3784 Sx_display_backing_store, 0, 1, 0,
3785 doc: /* Return an indication of whether X display TERMINAL does backing store.
3786 The value may be `always', `when-mapped', or `not-useful'.
3787 The optional argument TERMINAL specifies which display to ask about.
3788 TERMINAL should be a terminal object, a frame or a display name (a string).
3789 If omitted or nil, that stands for the selected frame's display. */)
3790 (Lisp_Object terminal)
3792 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3793 Lisp_Object result;
3795 switch (DoesBackingStore (dpyinfo->screen))
3797 case Always:
3798 result = intern ("always");
3799 break;
3801 case WhenMapped:
3802 result = intern ("when-mapped");
3803 break;
3805 case NotUseful:
3806 result = intern ("not-useful");
3807 break;
3809 default:
3810 error ("Strange value for BackingStore parameter of screen");
3811 result = Qnil;
3814 return result;
3817 DEFUN ("x-display-visual-class", Fx_display_visual_class,
3818 Sx_display_visual_class, 0, 1, 0,
3819 doc: /* Return the visual class of the X display TERMINAL.
3820 The value is one of the symbols `static-gray', `gray-scale',
3821 `static-color', `pseudo-color', `true-color', or `direct-color'.
3823 The optional argument TERMINAL specifies which display to ask about.
3824 TERMINAL should a terminal object, a frame or a display name (a string).
3825 If omitted or nil, that stands for the selected frame's display. */)
3826 (Lisp_Object terminal)
3828 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3829 Lisp_Object result;
3831 switch (dpyinfo->visual->class)
3833 case StaticGray:
3834 result = intern ("static-gray");
3835 break;
3836 case GrayScale:
3837 result = intern ("gray-scale");
3838 break;
3839 case StaticColor:
3840 result = intern ("static-color");
3841 break;
3842 case PseudoColor:
3843 result = intern ("pseudo-color");
3844 break;
3845 case TrueColor:
3846 result = intern ("true-color");
3847 break;
3848 case DirectColor:
3849 result = intern ("direct-color");
3850 break;
3851 default:
3852 error ("Display has an unknown visual class");
3853 result = Qnil;
3856 return result;
3859 DEFUN ("x-display-save-under", Fx_display_save_under,
3860 Sx_display_save_under, 0, 1, 0,
3861 doc: /* Return t if the X display TERMINAL supports the save-under feature.
3862 The optional argument TERMINAL specifies which display to ask about.
3863 TERMINAL should be a terminal object, a frame or a display name (a string).
3864 If omitted or nil, that stands for the selected frame's display. */)
3865 (Lisp_Object terminal)
3867 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3869 if (DoesSaveUnders (dpyinfo->screen) == True)
3870 return Qt;
3871 else
3872 return Qnil;
3876 x_pixel_width (register struct frame *f)
3878 return FRAME_PIXEL_WIDTH (f);
3882 x_pixel_height (register struct frame *f)
3884 return FRAME_PIXEL_HEIGHT (f);
3888 x_char_width (register struct frame *f)
3890 return FRAME_COLUMN_WIDTH (f);
3894 x_char_height (register struct frame *f)
3896 return FRAME_LINE_HEIGHT (f);
3901 /************************************************************************
3902 X Displays
3903 ************************************************************************/
3906 /* Mapping visual names to visuals. */
3908 static struct visual_class
3910 const char *name;
3911 int class;
3913 visual_classes[] =
3915 {"StaticGray", StaticGray},
3916 {"GrayScale", GrayScale},
3917 {"StaticColor", StaticColor},
3918 {"PseudoColor", PseudoColor},
3919 {"TrueColor", TrueColor},
3920 {"DirectColor", DirectColor},
3921 {NULL, 0}
3925 #ifndef HAVE_XSCREENNUMBEROFSCREEN
3927 /* Value is the screen number of screen SCR. This is a substitute for
3928 the X function with the same name when that doesn't exist. */
3931 XScreenNumberOfScreen (scr)
3932 register Screen *scr;
3934 Display *dpy = scr->display;
3935 int i;
3937 for (i = 0; i < dpy->nscreens; ++i)
3938 if (scr == dpy->screens + i)
3939 break;
3941 return i;
3944 #endif /* not HAVE_XSCREENNUMBEROFSCREEN */
3947 /* Select the visual that should be used on display DPYINFO. Set
3948 members of DPYINFO appropriately. Called from x_term_init. */
3950 void
3951 select_visual (struct x_display_info *dpyinfo)
3953 Display *dpy = dpyinfo->display;
3954 Screen *screen = dpyinfo->screen;
3955 Lisp_Object value;
3957 /* See if a visual is specified. */
3958 value = display_x_get_resource (dpyinfo,
3959 build_string ("visualClass"),
3960 build_string ("VisualClass"),
3961 Qnil, Qnil);
3962 if (STRINGP (value))
3964 /* VALUE should be of the form CLASS-DEPTH, where CLASS is one
3965 of `PseudoColor', `TrueColor' etc. and DEPTH is the color
3966 depth, a decimal number. NAME is compared with case ignored. */
3967 char *s = (char *) alloca (SBYTES (value) + 1);
3968 char *dash;
3969 int i, class = -1;
3970 XVisualInfo vinfo;
3972 strcpy (s, SSDATA (value));
3973 dash = strchr (s, '-');
3974 if (dash)
3976 dpyinfo->n_planes = atoi (dash + 1);
3977 *dash = '\0';
3979 else
3980 /* We won't find a matching visual with depth 0, so that
3981 an error will be printed below. */
3982 dpyinfo->n_planes = 0;
3984 /* Determine the visual class. */
3985 for (i = 0; visual_classes[i].name; ++i)
3986 if (xstrcasecmp (s, visual_classes[i].name) == 0)
3988 class = visual_classes[i].class;
3989 break;
3992 /* Look up a matching visual for the specified class. */
3993 if (class == -1
3994 || !XMatchVisualInfo (dpy, XScreenNumberOfScreen (screen),
3995 dpyinfo->n_planes, class, &vinfo))
3996 fatal ("Invalid visual specification `%s'", SDATA (value));
3998 dpyinfo->visual = vinfo.visual;
4000 else
4002 int n_visuals;
4003 XVisualInfo *vinfo, vinfo_template;
4005 dpyinfo->visual = DefaultVisualOfScreen (screen);
4007 vinfo_template.visualid = XVisualIDFromVisual (dpyinfo->visual);
4008 vinfo_template.screen = XScreenNumberOfScreen (screen);
4009 vinfo = XGetVisualInfo (dpy, VisualIDMask | VisualScreenMask,
4010 &vinfo_template, &n_visuals);
4011 if (n_visuals <= 0)
4012 fatal ("Can't get proper X visual info");
4014 dpyinfo->n_planes = vinfo->depth;
4015 XFree ((char *) vinfo);
4020 /* Return the X display structure for the display named NAME.
4021 Open a new connection if necessary. */
4023 static struct x_display_info *
4024 x_display_info_for_name (Lisp_Object name)
4026 Lisp_Object names;
4027 struct x_display_info *dpyinfo;
4029 CHECK_STRING (name);
4031 #if 0
4032 if (! EQ (Vinitial_window_system, intern ("x")))
4033 error ("Not using X Windows"); /* That doesn't stop us anymore. */
4034 #endif
4036 for (dpyinfo = x_display_list, names = x_display_name_list;
4037 dpyinfo;
4038 dpyinfo = dpyinfo->next, names = XCDR (names))
4040 Lisp_Object tem;
4041 tem = Fstring_equal (XCAR (XCAR (names)), name);
4042 if (!NILP (tem))
4043 return dpyinfo;
4046 /* Use this general default value to start with. */
4047 Vx_resource_name = Vinvocation_name;
4049 validate_x_resource_name ();
4051 dpyinfo = x_term_init (name, (char *)0,
4052 SSDATA (Vx_resource_name));
4054 if (dpyinfo == 0)
4055 error ("Cannot connect to X server %s", SDATA (name));
4057 x_in_use = 1;
4058 XSETFASTINT (Vwindow_system_version, 11);
4060 return dpyinfo;
4064 DEFUN ("x-open-connection", Fx_open_connection, Sx_open_connection,
4065 1, 3, 0,
4066 doc: /* Open a connection to a display server.
4067 DISPLAY is the name of the display to connect to.
4068 Optional second arg XRM-STRING is a string of resources in xrdb format.
4069 If the optional third arg MUST-SUCCEED is non-nil,
4070 terminate Emacs if we can't open the connection.
4071 \(In the Nextstep version, the last two arguments are currently ignored.) */)
4072 (Lisp_Object display, Lisp_Object xrm_string, Lisp_Object must_succeed)
4074 char *xrm_option;
4075 struct x_display_info *dpyinfo;
4077 CHECK_STRING (display);
4078 if (! NILP (xrm_string))
4079 CHECK_STRING (xrm_string);
4081 #if 0
4082 if (! EQ (Vinitial_window_system, intern ("x")))
4083 error ("Not using X Windows"); /* That doesn't stop us anymore. */
4084 #endif
4086 if (! NILP (xrm_string))
4087 xrm_option = SSDATA (xrm_string);
4088 else
4089 xrm_option = (char *) 0;
4091 validate_x_resource_name ();
4093 /* This is what opens the connection and sets x_current_display.
4094 This also initializes many symbols, such as those used for input. */
4095 dpyinfo = x_term_init (display, xrm_option,
4096 SSDATA (Vx_resource_name));
4098 if (dpyinfo == 0)
4100 if (!NILP (must_succeed))
4101 fatal ("Cannot connect to X server %s.\n\
4102 Check the DISPLAY environment variable or use `-d'.\n\
4103 Also use the `xauth' program to verify that you have the proper\n\
4104 authorization information needed to connect the X server.\n\
4105 An insecure way to solve the problem may be to use `xhost'.\n",
4106 SDATA (display));
4107 else
4108 error ("Cannot connect to X server %s", SDATA (display));
4111 x_in_use = 1;
4113 XSETFASTINT (Vwindow_system_version, 11);
4114 return Qnil;
4117 DEFUN ("x-close-connection", Fx_close_connection,
4118 Sx_close_connection, 1, 1, 0,
4119 doc: /* Close the connection to TERMINAL's X server.
4120 For TERMINAL, specify a terminal object, a frame or a display name (a
4121 string). If TERMINAL is nil, that stands for the selected frame's
4122 terminal. */)
4123 (Lisp_Object terminal)
4125 struct x_display_info *dpyinfo = check_x_display_info (terminal);
4127 if (dpyinfo->reference_count > 0)
4128 error ("Display still has frames on it");
4130 x_delete_terminal (dpyinfo->terminal);
4132 return Qnil;
4135 DEFUN ("x-display-list", Fx_display_list, Sx_display_list, 0, 0, 0,
4136 doc: /* Return the list of display names that Emacs has connections to. */)
4137 (void)
4139 Lisp_Object tail, result;
4141 result = Qnil;
4142 for (tail = x_display_name_list; CONSP (tail); tail = XCDR (tail))
4143 result = Fcons (XCAR (XCAR (tail)), result);
4145 return result;
4148 DEFUN ("x-synchronize", Fx_synchronize, Sx_synchronize, 1, 2, 0,
4149 doc: /* If ON is non-nil, report X errors as soon as the erring request is made.
4150 This function only has an effect on X Windows. With MS Windows, it is
4151 defined but does nothing.
4153 If ON is nil, allow buffering of requests.
4154 Turning on synchronization prohibits the Xlib routines from buffering
4155 requests and seriously degrades performance, but makes debugging much
4156 easier.
4157 The optional second argument TERMINAL specifies which display to act on.
4158 TERMINAL should be a terminal object, a frame or a display name (a string).
4159 If TERMINAL is omitted or nil, that stands for the selected frame's display. */)
4160 (Lisp_Object on, Lisp_Object terminal)
4162 struct x_display_info *dpyinfo = check_x_display_info (terminal);
4164 XSynchronize (dpyinfo->display, !EQ (on, Qnil));
4166 return Qnil;
4169 /* Wait for responses to all X commands issued so far for frame F. */
4171 void
4172 x_sync (FRAME_PTR f)
4174 BLOCK_INPUT;
4175 XSync (FRAME_X_DISPLAY (f), False);
4176 UNBLOCK_INPUT;
4180 /***********************************************************************
4181 Window properties
4182 ***********************************************************************/
4184 DEFUN ("x-change-window-property", Fx_change_window_property,
4185 Sx_change_window_property, 2, 6, 0,
4186 doc: /* Change window property PROP to VALUE on the X window of FRAME.
4187 PROP must be a string. VALUE may be a string or a list of conses,
4188 numbers and/or strings. If an element in the list is a string, it is
4189 converted to an atom and the value of the atom is used. If an element
4190 is a cons, it is converted to a 32 bit number where the car is the 16
4191 top bits and the cdr is the lower 16 bits.
4193 FRAME nil or omitted means use the selected frame.
4194 If TYPE is given and non-nil, it is the name of the type of VALUE.
4195 If TYPE is not given or nil, the type is STRING.
4196 FORMAT gives the size in bits of each element if VALUE is a list.
4197 It must be one of 8, 16 or 32.
4198 If VALUE is a string or FORMAT is nil or not given, FORMAT defaults to 8.
4199 If OUTER_P is non-nil, the property is changed for the outer X window of
4200 FRAME. Default is to change on the edit X window. */)
4201 (Lisp_Object prop, Lisp_Object value, Lisp_Object frame, Lisp_Object type, Lisp_Object format, Lisp_Object outer_p)
4203 struct frame *f = check_x_frame (frame);
4204 Atom prop_atom;
4205 Atom target_type = XA_STRING;
4206 int element_format = 8;
4207 unsigned char *data;
4208 int nelements;
4209 Window w;
4211 CHECK_STRING (prop);
4213 if (! NILP (format))
4215 CHECK_NUMBER (format);
4217 if (XINT (format) != 8 && XINT (format) != 16
4218 && XINT (format) != 32)
4219 error ("FORMAT must be one of 8, 16 or 32");
4220 element_format = XINT (format);
4223 if (CONSP (value))
4225 ptrdiff_t elsize;
4227 nelements = x_check_property_data (value);
4228 if (nelements == -1)
4229 error ("Bad data in VALUE, must be number, string or cons");
4231 /* The man page for XChangeProperty:
4232 "If the specified format is 32, the property data must be a
4233 long array."
4234 This applies even if long is more than 32 bits. The X library
4235 converts to 32 bits before sending to the X server. */
4236 elsize = element_format == 32 ? sizeof (long) : element_format >> 3;
4237 data = xnmalloc (nelements, elsize);
4239 x_fill_property_data (FRAME_X_DISPLAY (f), value, data, element_format);
4241 else
4243 CHECK_STRING (value);
4244 data = SDATA (value);
4245 if (INT_MAX < SBYTES (value))
4246 error ("VALUE too long");
4247 nelements = SBYTES (value);
4250 BLOCK_INPUT;
4251 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (prop), False);
4252 if (! NILP (type))
4254 CHECK_STRING (type);
4255 target_type = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (type), False);
4258 if (! NILP (outer_p)) w = FRAME_OUTER_WINDOW (f);
4259 else w = FRAME_X_WINDOW (f);
4261 XChangeProperty (FRAME_X_DISPLAY (f), w,
4262 prop_atom, target_type, element_format, PropModeReplace,
4263 data, nelements);
4265 if (CONSP (value)) xfree (data);
4267 /* Make sure the property is set when we return. */
4268 XFlush (FRAME_X_DISPLAY (f));
4269 UNBLOCK_INPUT;
4271 return value;
4275 DEFUN ("x-delete-window-property", Fx_delete_window_property,
4276 Sx_delete_window_property, 1, 2, 0,
4277 doc: /* Remove window property PROP from X window of FRAME.
4278 FRAME nil or omitted means use the selected frame. Value is PROP. */)
4279 (Lisp_Object prop, Lisp_Object frame)
4281 struct frame *f = check_x_frame (frame);
4282 Atom prop_atom;
4284 CHECK_STRING (prop);
4285 BLOCK_INPUT;
4286 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (prop), False);
4287 XDeleteProperty (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), prop_atom);
4289 /* Make sure the property is removed when we return. */
4290 XFlush (FRAME_X_DISPLAY (f));
4291 UNBLOCK_INPUT;
4293 return prop;
4297 DEFUN ("x-window-property", Fx_window_property, Sx_window_property,
4298 1, 6, 0,
4299 doc: /* Value is the value of window property PROP on FRAME.
4300 If FRAME is nil or omitted, use the selected frame.
4302 On MS Windows, this function only accepts the PROP and FRAME arguments.
4304 On X Windows, the following optional arguments are also accepted:
4305 If TYPE is nil or omitted, get the property as a string.
4306 Otherwise TYPE is the name of the atom that denotes the type expected.
4307 If SOURCE is non-nil, get the property on that window instead of from
4308 FRAME. The number 0 denotes the root window.
4309 If DELETE_P is non-nil, delete the property after retrieving it.
4310 If VECTOR_RET_P is non-nil, don't return a string but a vector of values.
4312 Value is nil if FRAME hasn't a property with name PROP or if PROP has
4313 no value of TYPE (always string in the MS Windows case). */)
4314 (Lisp_Object prop, Lisp_Object frame, Lisp_Object type, Lisp_Object source, Lisp_Object delete_p, Lisp_Object vector_ret_p)
4316 struct frame *f = check_x_frame (frame);
4317 Atom prop_atom;
4318 int rc;
4319 Lisp_Object prop_value = Qnil;
4320 unsigned char *tmp_data = NULL;
4321 Atom actual_type;
4322 Atom target_type = XA_STRING;
4323 int actual_format;
4324 unsigned long actual_size, bytes_remaining;
4325 Window target_window = FRAME_X_WINDOW (f);
4326 struct gcpro gcpro1;
4328 GCPRO1 (prop_value);
4329 CHECK_STRING (prop);
4331 if (! NILP (source))
4333 CONS_TO_INTEGER (source, Window, target_window);
4334 if (! target_window)
4335 target_window = FRAME_X_DISPLAY_INFO (f)->root_window;
4338 BLOCK_INPUT;
4339 if (STRINGP (type))
4341 if (strcmp ("AnyPropertyType", SSDATA (type)) == 0)
4342 target_type = AnyPropertyType;
4343 else
4344 target_type = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (type), False);
4347 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (prop), False);
4348 rc = XGetWindowProperty (FRAME_X_DISPLAY (f), target_window,
4349 prop_atom, 0, 0, False, target_type,
4350 &actual_type, &actual_format, &actual_size,
4351 &bytes_remaining, &tmp_data);
4352 if (rc == Success)
4354 int size = bytes_remaining;
4356 XFree (tmp_data);
4357 tmp_data = NULL;
4359 rc = XGetWindowProperty (FRAME_X_DISPLAY (f), target_window,
4360 prop_atom, 0, bytes_remaining,
4361 ! NILP (delete_p), target_type,
4362 &actual_type, &actual_format,
4363 &actual_size, &bytes_remaining,
4364 &tmp_data);
4365 if (rc == Success && tmp_data)
4367 /* The man page for XGetWindowProperty says:
4368 "If the returned format is 32, the returned data is represented
4369 as a long array and should be cast to that type to obtain the
4370 elements."
4371 This applies even if long is more than 32 bits, the X library
4372 converts from 32 bit elements received from the X server to long
4373 and passes the long array to us. Thus, for that case memcpy can not
4374 be used. We convert to a 32 bit type here, because so much code
4375 assume on that.
4377 The bytes and offsets passed to XGetWindowProperty refers to the
4378 property and those are indeed in 32 bit quantities if format is
4379 32. */
4381 if (32 < BITS_PER_LONG && actual_format == 32)
4383 unsigned long i;
4384 int *idata = (int *) tmp_data;
4385 long *ldata = (long *) tmp_data;
4387 for (i = 0; i < actual_size; ++i)
4388 idata[i] = (int) ldata[i];
4391 if (NILP (vector_ret_p))
4392 prop_value = make_string ((char *) tmp_data, size);
4393 else
4394 prop_value = x_property_data_to_lisp (f,
4395 tmp_data,
4396 actual_type,
4397 actual_format,
4398 actual_size);
4401 if (tmp_data) XFree (tmp_data);
4404 UNBLOCK_INPUT;
4405 UNGCPRO;
4406 return prop_value;
4411 /***********************************************************************
4412 Busy cursor
4413 ***********************************************************************/
4415 /* Timer function of hourglass_atimer. TIMER is equal to
4416 hourglass_atimer.
4418 Display an hourglass pointer on all frames by mapping the frames'
4419 hourglass_window. Set the hourglass_p flag in the frames'
4420 output_data.x structure to indicate that an hourglass cursor is
4421 shown on the frames. */
4423 void
4424 show_hourglass (struct atimer *timer)
4426 /* The timer implementation will cancel this timer automatically
4427 after this function has run. Set hourglass_atimer to null
4428 so that we know the timer doesn't have to be canceled. */
4429 hourglass_atimer = NULL;
4431 if (!hourglass_shown_p)
4433 Lisp_Object rest, frame;
4435 BLOCK_INPUT;
4437 FOR_EACH_FRAME (rest, frame)
4439 struct frame *f = XFRAME (frame);
4441 if (FRAME_LIVE_P (f) && FRAME_X_P (f) && FRAME_X_DISPLAY (f))
4443 Display *dpy = FRAME_X_DISPLAY (f);
4445 #ifdef USE_X_TOOLKIT
4446 if (f->output_data.x->widget)
4447 #else
4448 if (FRAME_OUTER_WINDOW (f))
4449 #endif
4451 f->output_data.x->hourglass_p = 1;
4453 if (!f->output_data.x->hourglass_window)
4455 unsigned long mask = CWCursor;
4456 XSetWindowAttributes attrs;
4457 #ifdef USE_GTK
4458 Window parent = FRAME_X_WINDOW (f);
4459 #else
4460 Window parent = FRAME_OUTER_WINDOW (f);
4461 #endif
4462 attrs.cursor = f->output_data.x->hourglass_cursor;
4464 f->output_data.x->hourglass_window
4465 = XCreateWindow (dpy, parent,
4466 0, 0, 32000, 32000, 0, 0,
4467 InputOnly,
4468 CopyFromParent,
4469 mask, &attrs);
4472 XMapRaised (dpy, f->output_data.x->hourglass_window);
4473 XFlush (dpy);
4478 hourglass_shown_p = 1;
4479 UNBLOCK_INPUT;
4484 /* Hide the hourglass pointer on all frames, if it is currently
4485 shown. */
4487 void
4488 hide_hourglass (void)
4490 if (hourglass_shown_p)
4492 Lisp_Object rest, frame;
4494 BLOCK_INPUT;
4495 FOR_EACH_FRAME (rest, frame)
4497 struct frame *f = XFRAME (frame);
4499 if (FRAME_X_P (f)
4500 /* Watch out for newly created frames. */
4501 && f->output_data.x->hourglass_window)
4503 XUnmapWindow (FRAME_X_DISPLAY (f),
4504 f->output_data.x->hourglass_window);
4505 /* Sync here because XTread_socket looks at the
4506 hourglass_p flag that is reset to zero below. */
4507 XSync (FRAME_X_DISPLAY (f), False);
4508 f->output_data.x->hourglass_p = 0;
4512 hourglass_shown_p = 0;
4513 UNBLOCK_INPUT;
4519 /***********************************************************************
4520 Tool tips
4521 ***********************************************************************/
4523 static Lisp_Object x_create_tip_frame (struct x_display_info *,
4524 Lisp_Object, Lisp_Object);
4525 static void compute_tip_xy (struct frame *, Lisp_Object, Lisp_Object,
4526 Lisp_Object, int, int, int *, int *);
4528 /* The frame of a currently visible tooltip. */
4530 Lisp_Object tip_frame;
4532 /* If non-nil, a timer started that hides the last tooltip when it
4533 fires. */
4535 static Lisp_Object tip_timer;
4536 Window tip_window;
4538 /* If non-nil, a vector of 3 elements containing the last args
4539 with which x-show-tip was called. See there. */
4541 static Lisp_Object last_show_tip_args;
4544 static Lisp_Object
4545 unwind_create_tip_frame (Lisp_Object frame)
4547 Lisp_Object deleted;
4549 deleted = unwind_create_frame (frame);
4550 if (EQ (deleted, Qt))
4552 tip_window = None;
4553 tip_frame = Qnil;
4556 return deleted;
4560 /* Create a frame for a tooltip on the display described by DPYINFO.
4561 PARMS is a list of frame parameters. TEXT is the string to
4562 display in the tip frame. Value is the frame.
4564 Note that functions called here, esp. x_default_parameter can
4565 signal errors, for instance when a specified color name is
4566 undefined. We have to make sure that we're in a consistent state
4567 when this happens. */
4569 static Lisp_Object
4570 x_create_tip_frame (struct x_display_info *dpyinfo,
4571 Lisp_Object parms,
4572 Lisp_Object text)
4574 struct frame *f;
4575 Lisp_Object frame;
4576 Lisp_Object name;
4577 int width, height;
4578 ptrdiff_t count = SPECPDL_INDEX ();
4579 struct gcpro gcpro1, gcpro2, gcpro3;
4580 int face_change_count_before = face_change_count;
4581 Lisp_Object buffer;
4582 struct buffer *old_buffer;
4584 check_x ();
4586 if (!dpyinfo->terminal->name)
4587 error ("Terminal is not live, can't create new frames on it");
4589 parms = Fcopy_alist (parms);
4591 /* Get the name of the frame to use for resource lookup. */
4592 name = x_get_arg (dpyinfo, parms, Qname, "name", "Name", RES_TYPE_STRING);
4593 if (!STRINGP (name)
4594 && !EQ (name, Qunbound)
4595 && !NILP (name))
4596 error ("Invalid frame name--not a string or nil");
4598 frame = Qnil;
4599 GCPRO3 (parms, name, frame);
4600 f = make_frame (1);
4601 XSETFRAME (frame, f);
4603 buffer = Fget_buffer_create (build_string (" *tip*"));
4604 Fset_window_buffer (FRAME_ROOT_WINDOW (f), buffer, Qnil);
4605 old_buffer = current_buffer;
4606 set_buffer_internal_1 (XBUFFER (buffer));
4607 BVAR (current_buffer, truncate_lines) = Qnil;
4608 specbind (Qinhibit_read_only, Qt);
4609 specbind (Qinhibit_modification_hooks, Qt);
4610 Ferase_buffer ();
4611 Finsert (1, &text);
4612 set_buffer_internal_1 (old_buffer);
4614 FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
4615 record_unwind_protect (unwind_create_tip_frame, frame);
4617 f->terminal = dpyinfo->terminal;
4619 /* By setting the output method, we're essentially saying that
4620 the frame is live, as per FRAME_LIVE_P. If we get a signal
4621 from this point on, x_destroy_window might screw up reference
4622 counts etc. */
4623 f->output_method = output_x_window;
4624 f->output_data.x = (struct x_output *) xmalloc (sizeof (struct x_output));
4625 memset (f->output_data.x, 0, sizeof (struct x_output));
4626 f->output_data.x->icon_bitmap = -1;
4627 FRAME_FONTSET (f) = -1;
4628 f->output_data.x->scroll_bar_foreground_pixel = -1;
4629 f->output_data.x->scroll_bar_background_pixel = -1;
4630 #ifdef USE_TOOLKIT_SCROLL_BARS
4631 f->output_data.x->scroll_bar_top_shadow_pixel = -1;
4632 f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
4633 #endif /* USE_TOOLKIT_SCROLL_BARS */
4634 f->icon_name = Qnil;
4635 FRAME_X_DISPLAY_INFO (f) = dpyinfo;
4636 f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
4637 f->output_data.x->explicit_parent = 0;
4639 /* These colors will be set anyway later, but it's important
4640 to get the color reference counts right, so initialize them! */
4642 Lisp_Object black;
4643 struct gcpro gcpro1;
4645 /* Function x_decode_color can signal an error. Make
4646 sure to initialize color slots so that we won't try
4647 to free colors we haven't allocated. */
4648 FRAME_FOREGROUND_PIXEL (f) = -1;
4649 FRAME_BACKGROUND_PIXEL (f) = -1;
4650 f->output_data.x->cursor_pixel = -1;
4651 f->output_data.x->cursor_foreground_pixel = -1;
4652 f->output_data.x->border_pixel = -1;
4653 f->output_data.x->mouse_pixel = -1;
4655 black = build_string ("black");
4656 GCPRO1 (black);
4657 FRAME_FOREGROUND_PIXEL (f)
4658 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4659 FRAME_BACKGROUND_PIXEL (f)
4660 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4661 f->output_data.x->cursor_pixel
4662 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4663 f->output_data.x->cursor_foreground_pixel
4664 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4665 f->output_data.x->border_pixel
4666 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4667 f->output_data.x->mouse_pixel
4668 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4669 UNGCPRO;
4672 /* Set the name; the functions to which we pass f expect the name to
4673 be set. */
4674 if (EQ (name, Qunbound) || NILP (name))
4676 f->name = build_string (dpyinfo->x_id_name);
4677 f->explicit_name = 0;
4679 else
4681 f->name = name;
4682 f->explicit_name = 1;
4683 /* use the frame's title when getting resources for this frame. */
4684 specbind (Qx_resource_name, name);
4687 f->resx = dpyinfo->resx;
4688 f->resy = dpyinfo->resy;
4690 register_font_driver (&xfont_driver, f);
4691 #ifdef HAVE_FREETYPE
4692 #ifdef HAVE_XFT
4693 register_font_driver (&xftfont_driver, f);
4694 #else /* not HAVE_XFT */
4695 register_font_driver (&ftxfont_driver, f);
4696 #endif /* not HAVE_XFT */
4697 #endif /* HAVE_FREETYPE */
4699 x_default_parameter (f, parms, Qfont_backend, Qnil,
4700 "fontBackend", "FontBackend", RES_TYPE_STRING);
4702 /* Extract the window parameters from the supplied values that are
4703 needed to determine window geometry. */
4704 x_default_font_parameter (f, parms);
4706 x_default_parameter (f, parms, Qborder_width, make_number (0),
4707 "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
4709 /* This defaults to 2 in order to match xterm. We recognize either
4710 internalBorderWidth or internalBorder (which is what xterm calls
4711 it). */
4712 if (NILP (Fassq (Qinternal_border_width, parms)))
4714 Lisp_Object value;
4716 value = x_get_arg (dpyinfo, parms, Qinternal_border_width,
4717 "internalBorder", "internalBorder", RES_TYPE_NUMBER);
4718 if (! EQ (value, Qunbound))
4719 parms = Fcons (Fcons (Qinternal_border_width, value),
4720 parms);
4723 x_default_parameter (f, parms, Qinternal_border_width, make_number (1),
4724 "internalBorderWidth", "internalBorderWidth",
4725 RES_TYPE_NUMBER);
4727 /* Also do the stuff which must be set before the window exists. */
4728 x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
4729 "foreground", "Foreground", RES_TYPE_STRING);
4730 x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
4731 "background", "Background", RES_TYPE_STRING);
4732 x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
4733 "pointerColor", "Foreground", RES_TYPE_STRING);
4734 x_default_parameter (f, parms, Qcursor_color, build_string ("black"),
4735 "cursorColor", "Foreground", RES_TYPE_STRING);
4736 x_default_parameter (f, parms, Qborder_color, build_string ("black"),
4737 "borderColor", "BorderColor", RES_TYPE_STRING);
4739 #if GLYPH_DEBUG
4740 image_cache_refcount =
4741 FRAME_IMAGE_CACHE (f) ? FRAME_IMAGE_CACHE (f)->refcount : 0;
4742 dpyinfo_refcount = dpyinfo->reference_count;
4743 #endif /* GLYPH_DEBUG */
4745 /* Init faces before x_default_parameter is called for scroll-bar
4746 parameters because that function calls x_set_scroll_bar_width,
4747 which calls change_frame_size, which calls Fset_window_buffer,
4748 which runs hooks, which call Fvertical_motion. At the end, we
4749 end up in init_iterator with a null face cache, which should not
4750 happen. */
4751 init_frame_faces (f);
4753 f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
4755 x_figure_window_size (f, parms, 0);
4758 XSetWindowAttributes attrs;
4759 unsigned long mask;
4760 Atom type = FRAME_X_DISPLAY_INFO (f)->Xatom_net_window_type_tooltip;
4762 BLOCK_INPUT;
4763 mask = CWBackPixel | CWOverrideRedirect | CWEventMask;
4764 if (DoesSaveUnders (dpyinfo->screen))
4765 mask |= CWSaveUnder;
4767 /* Window managers look at the override-redirect flag to determine
4768 whether or net to give windows a decoration (Xlib spec, chapter
4769 3.2.8). */
4770 attrs.override_redirect = True;
4771 attrs.save_under = True;
4772 attrs.background_pixel = FRAME_BACKGROUND_PIXEL (f);
4773 /* Arrange for getting MapNotify and UnmapNotify events. */
4774 attrs.event_mask = StructureNotifyMask;
4775 tip_window
4776 = FRAME_X_WINDOW (f)
4777 = XCreateWindow (FRAME_X_DISPLAY (f),
4778 FRAME_X_DISPLAY_INFO (f)->root_window,
4779 /* x, y, width, height */
4780 0, 0, 1, 1,
4781 /* Border. */
4782 f->border_width,
4783 CopyFromParent, InputOutput, CopyFromParent,
4784 mask, &attrs);
4785 XChangeProperty (FRAME_X_DISPLAY (f), tip_window,
4786 FRAME_X_DISPLAY_INFO (f)->Xatom_net_window_type,
4787 XA_ATOM, 32, PropModeReplace,
4788 (unsigned char *)&type, 1);
4789 UNBLOCK_INPUT;
4792 x_make_gc (f);
4794 x_default_parameter (f, parms, Qauto_raise, Qnil,
4795 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
4796 x_default_parameter (f, parms, Qauto_lower, Qnil,
4797 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
4798 x_default_parameter (f, parms, Qcursor_type, Qbox,
4799 "cursorType", "CursorType", RES_TYPE_SYMBOL);
4801 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
4802 Change will not be effected unless different from the current
4803 FRAME_LINES (f). */
4804 width = FRAME_COLS (f);
4805 height = FRAME_LINES (f);
4806 SET_FRAME_COLS (f, 0);
4807 FRAME_LINES (f) = 0;
4808 change_frame_size (f, height, width, 1, 0, 0);
4810 /* Add `tooltip' frame parameter's default value. */
4811 if (NILP (Fframe_parameter (frame, Qtooltip)))
4812 Fmodify_frame_parameters (frame, Fcons (Fcons (Qtooltip, Qt), Qnil));
4814 /* FIXME - can this be done in a similar way to normal frames?
4815 http://lists.gnu.org/archive/html/emacs-devel/2007-10/msg00641.html */
4817 /* Set the `display-type' frame parameter before setting up faces. */
4819 Lisp_Object disptype;
4821 if (FRAME_X_DISPLAY_INFO (f)->n_planes == 1)
4822 disptype = intern ("mono");
4823 else if (FRAME_X_DISPLAY_INFO (f)->visual->class == GrayScale
4824 || FRAME_X_DISPLAY_INFO (f)->visual->class == StaticGray)
4825 disptype = intern ("grayscale");
4826 else
4827 disptype = intern ("color");
4829 if (NILP (Fframe_parameter (frame, Qdisplay_type)))
4830 Fmodify_frame_parameters (frame, Fcons (Fcons (Qdisplay_type, disptype),
4831 Qnil));
4834 /* Set up faces after all frame parameters are known. This call
4835 also merges in face attributes specified for new frames.
4837 Frame parameters may be changed if .Xdefaults contains
4838 specifications for the default font. For example, if there is an
4839 `Emacs.default.attributeBackground: pink', the `background-color'
4840 attribute of the frame get's set, which let's the internal border
4841 of the tooltip frame appear in pink. Prevent this. */
4843 Lisp_Object bg = Fframe_parameter (frame, Qbackground_color);
4845 /* Set tip_frame here, so that */
4846 tip_frame = frame;
4847 call2 (Qface_set_after_frame_default, frame, Qnil);
4849 if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
4850 Fmodify_frame_parameters (frame, Fcons (Fcons (Qbackground_color, bg),
4851 Qnil));
4854 f->no_split = 1;
4856 UNGCPRO;
4858 /* Now that the frame will be official, it counts as a reference to
4859 its display and terminal. */
4860 FRAME_X_DISPLAY_INFO (f)->reference_count++;
4861 f->terminal->reference_count++;
4863 /* It is now ok to make the frame official even if we get an error
4864 below. And the frame needs to be on Vframe_list or making it
4865 visible won't work. */
4866 Vframe_list = Fcons (frame, Vframe_list);
4869 /* Setting attributes of faces of the tooltip frame from resources
4870 and similar will increment face_change_count, which leads to the
4871 clearing of all current matrices. Since this isn't necessary
4872 here, avoid it by resetting face_change_count to the value it
4873 had before we created the tip frame. */
4874 face_change_count = face_change_count_before;
4876 /* Discard the unwind_protect. */
4877 return unbind_to (count, frame);
4881 /* Compute where to display tip frame F. PARMS is the list of frame
4882 parameters for F. DX and DY are specified offsets from the current
4883 location of the mouse. WIDTH and HEIGHT are the width and height
4884 of the tooltip. Return coordinates relative to the root window of
4885 the display in *ROOT_X, and *ROOT_Y. */
4887 static void
4888 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)
4890 Lisp_Object left, top;
4891 int win_x, win_y;
4892 Window root, child;
4893 unsigned pmask;
4895 /* User-specified position? */
4896 left = Fcdr (Fassq (Qleft, parms));
4897 top = Fcdr (Fassq (Qtop, parms));
4899 /* Move the tooltip window where the mouse pointer is. Resize and
4900 show it. */
4901 if (!INTEGERP (left) || !INTEGERP (top))
4903 BLOCK_INPUT;
4904 XQueryPointer (FRAME_X_DISPLAY (f), FRAME_X_DISPLAY_INFO (f)->root_window,
4905 &root, &child, root_x, root_y, &win_x, &win_y, &pmask);
4906 UNBLOCK_INPUT;
4909 if (INTEGERP (top))
4910 *root_y = XINT (top);
4911 else if (*root_y + XINT (dy) <= 0)
4912 *root_y = 0; /* Can happen for negative dy */
4913 else if (*root_y + XINT (dy) + height
4914 <= x_display_pixel_height (FRAME_X_DISPLAY_INFO (f)))
4915 /* It fits below the pointer */
4916 *root_y += XINT (dy);
4917 else if (height + XINT (dy) <= *root_y)
4918 /* It fits above the pointer. */
4919 *root_y -= height + XINT (dy);
4920 else
4921 /* Put it on the top. */
4922 *root_y = 0;
4924 if (INTEGERP (left))
4925 *root_x = XINT (left);
4926 else if (*root_x + XINT (dx) <= 0)
4927 *root_x = 0; /* Can happen for negative dx */
4928 else if (*root_x + XINT (dx) + width
4929 <= x_display_pixel_width (FRAME_X_DISPLAY_INFO (f)))
4930 /* It fits to the right of the pointer. */
4931 *root_x += XINT (dx);
4932 else if (width + XINT (dx) <= *root_x)
4933 /* It fits to the left of the pointer. */
4934 *root_x -= width + XINT (dx);
4935 else
4936 /* Put it left-justified on the screen--it ought to fit that way. */
4937 *root_x = 0;
4941 DEFUN ("x-show-tip", Fx_show_tip, Sx_show_tip, 1, 6, 0,
4942 doc: /* Show STRING in a "tooltip" window on frame FRAME.
4943 A tooltip window is a small X window displaying a string.
4945 This is an internal function; Lisp code should call `tooltip-show'.
4947 FRAME nil or omitted means use the selected frame.
4949 PARMS is an optional list of frame parameters which can be used to
4950 change the tooltip's appearance.
4952 Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
4953 means use the default timeout of 5 seconds.
4955 If the list of frame parameters PARMS contains a `left' parameters,
4956 the tooltip is displayed at that x-position. Otherwise it is
4957 displayed at the mouse position, with offset DX added (default is 5 if
4958 DX isn't specified). Likewise for the y-position; if a `top' frame
4959 parameter is specified, it determines the y-position of the tooltip
4960 window, otherwise it is displayed at the mouse position, with offset
4961 DY added (default is -10).
4963 A tooltip's maximum size is specified by `x-max-tooltip-size'.
4964 Text larger than the specified size is clipped. */)
4965 (Lisp_Object string, Lisp_Object frame, Lisp_Object parms, Lisp_Object timeout, Lisp_Object dx, Lisp_Object dy)
4967 struct frame *f;
4968 struct window *w;
4969 int root_x, root_y;
4970 struct buffer *old_buffer;
4971 struct text_pos pos;
4972 int i, width, height, seen_reversed_p;
4973 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
4974 int old_windows_or_buffers_changed = windows_or_buffers_changed;
4975 ptrdiff_t count = SPECPDL_INDEX ();
4977 specbind (Qinhibit_redisplay, Qt);
4979 GCPRO4 (string, parms, frame, timeout);
4981 CHECK_STRING (string);
4982 if (SCHARS (string) == 0)
4983 string = make_unibyte_string (" ", 1);
4985 f = check_x_frame (frame);
4986 if (NILP (timeout))
4987 timeout = make_number (5);
4988 else
4989 CHECK_NATNUM (timeout);
4991 if (NILP (dx))
4992 dx = make_number (5);
4993 else
4994 CHECK_NUMBER (dx);
4996 if (NILP (dy))
4997 dy = make_number (-10);
4998 else
4999 CHECK_NUMBER (dy);
5001 #ifdef USE_GTK
5002 if (x_gtk_use_system_tooltips)
5004 int ok;
5006 /* Hide a previous tip, if any. */
5007 Fx_hide_tip ();
5009 BLOCK_INPUT;
5010 if ((ok = xg_prepare_tooltip (f, string, &width, &height)) != 0)
5012 compute_tip_xy (f, parms, dx, dy, width, height, &root_x, &root_y);
5013 xg_show_tooltip (f, root_x, root_y);
5014 /* This is used in Fx_hide_tip. */
5015 XSETFRAME (tip_frame, f);
5017 UNBLOCK_INPUT;
5018 if (ok) goto start_timer;
5020 #endif /* USE_GTK */
5022 if (NILP (last_show_tip_args))
5023 last_show_tip_args = Fmake_vector (make_number (3), Qnil);
5025 if (!NILP (tip_frame))
5027 Lisp_Object last_string = AREF (last_show_tip_args, 0);
5028 Lisp_Object last_frame = AREF (last_show_tip_args, 1);
5029 Lisp_Object last_parms = AREF (last_show_tip_args, 2);
5031 if (EQ (frame, last_frame)
5032 && !NILP (Fequal (last_string, string))
5033 && !NILP (Fequal (last_parms, parms)))
5035 struct frame *tip_f = XFRAME (tip_frame);
5037 /* Only DX and DY have changed. */
5038 if (!NILP (tip_timer))
5040 Lisp_Object timer = tip_timer;
5041 tip_timer = Qnil;
5042 call1 (Qcancel_timer, timer);
5045 BLOCK_INPUT;
5046 compute_tip_xy (tip_f, parms, dx, dy, FRAME_PIXEL_WIDTH (tip_f),
5047 FRAME_PIXEL_HEIGHT (tip_f), &root_x, &root_y);
5048 XMoveWindow (FRAME_X_DISPLAY (tip_f), FRAME_X_WINDOW (tip_f),
5049 root_x, root_y);
5050 UNBLOCK_INPUT;
5051 goto start_timer;
5055 /* Hide a previous tip, if any. */
5056 Fx_hide_tip ();
5058 ASET (last_show_tip_args, 0, string);
5059 ASET (last_show_tip_args, 1, frame);
5060 ASET (last_show_tip_args, 2, parms);
5062 /* Add default values to frame parameters. */
5063 if (NILP (Fassq (Qname, parms)))
5064 parms = Fcons (Fcons (Qname, build_string ("tooltip")), parms);
5065 if (NILP (Fassq (Qinternal_border_width, parms)))
5066 parms = Fcons (Fcons (Qinternal_border_width, make_number (3)), parms);
5067 if (NILP (Fassq (Qborder_width, parms)))
5068 parms = Fcons (Fcons (Qborder_width, make_number (1)), parms);
5069 if (NILP (Fassq (Qborder_color, parms)))
5070 parms = Fcons (Fcons (Qborder_color, build_string ("lightyellow")), parms);
5071 if (NILP (Fassq (Qbackground_color, parms)))
5072 parms = Fcons (Fcons (Qbackground_color, build_string ("lightyellow")),
5073 parms);
5075 /* Create a frame for the tooltip, and record it in the global
5076 variable tip_frame. */
5077 frame = x_create_tip_frame (FRAME_X_DISPLAY_INFO (f), parms, string);
5078 f = XFRAME (frame);
5080 /* Set up the frame's root window. */
5081 w = XWINDOW (FRAME_ROOT_WINDOW (f));
5082 w->left_col = w->top_line = make_number (0);
5084 if (CONSP (Vx_max_tooltip_size)
5085 && RANGED_INTEGERP (1, XCAR (Vx_max_tooltip_size), INT_MAX)
5086 && RANGED_INTEGERP (1, XCDR (Vx_max_tooltip_size), INT_MAX))
5088 w->total_cols = XCAR (Vx_max_tooltip_size);
5089 w->total_lines = XCDR (Vx_max_tooltip_size);
5091 else
5093 w->total_cols = make_number (80);
5094 w->total_lines = make_number (40);
5097 FRAME_TOTAL_COLS (f) = XINT (w->total_cols);
5098 adjust_glyphs (f);
5099 w->pseudo_window_p = 1;
5101 /* Display the tooltip text in a temporary buffer. */
5102 old_buffer = current_buffer;
5103 set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f))->buffer));
5104 BVAR (current_buffer, truncate_lines) = Qnil;
5105 clear_glyph_matrix (w->desired_matrix);
5106 clear_glyph_matrix (w->current_matrix);
5107 SET_TEXT_POS (pos, BEGV, BEGV_BYTE);
5108 try_window (FRAME_ROOT_WINDOW (f), pos, TRY_WINDOW_IGNORE_FONTS_CHANGE);
5110 /* Compute width and height of the tooltip. */
5111 width = height = seen_reversed_p = 0;
5112 for (i = 0; i < w->desired_matrix->nrows; ++i)
5114 struct glyph_row *row = &w->desired_matrix->rows[i];
5115 struct glyph *last;
5116 int row_width;
5118 /* Stop at the first empty row at the end. */
5119 if (!row->enabled_p || !row->displays_text_p)
5120 break;
5122 /* Let the row go over the full width of the frame. */
5123 row->full_width_p = 1;
5125 row_width = row->pixel_width;
5126 if (row->used[TEXT_AREA])
5128 /* There's a glyph at the end of rows that is used to place
5129 the cursor there. Don't include the width of this glyph. */
5130 if (!row->reversed_p)
5132 last = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
5133 if (INTEGERP (last->object))
5134 row_width -= last->pixel_width;
5136 else
5138 /* There could be a stretch glyph at the beginning of R2L
5139 rows that is produced by extend_face_to_end_of_line.
5140 Don't count that glyph. */
5141 struct glyph *g = row->glyphs[TEXT_AREA];
5143 if (g->type == STRETCH_GLYPH && INTEGERP (g->object))
5145 row_width -= g->pixel_width;
5146 seen_reversed_p = 1;
5151 height += row->height;
5152 width = max (width, row_width);
5155 /* If we've seen partial-length R2L rows, we need to re-adjust the
5156 tool-tip frame width and redisplay it again, to avoid over-wide
5157 tips due to the stretch glyph that extends R2L lines to full
5158 width of the frame. */
5159 if (seen_reversed_p)
5161 /* w->total_cols and FRAME_TOTAL_COLS want the width in columns,
5162 not in pixels. */
5163 width /= WINDOW_FRAME_COLUMN_WIDTH (w);
5164 w->total_cols = make_number (width);
5165 FRAME_TOTAL_COLS (f) = width;
5166 adjust_glyphs (f);
5167 clear_glyph_matrix (w->desired_matrix);
5168 clear_glyph_matrix (w->current_matrix);
5169 try_window (FRAME_ROOT_WINDOW (f), pos, 0);
5170 width = height = 0;
5171 /* Recompute width and height of the tooltip. */
5172 for (i = 0; i < w->desired_matrix->nrows; ++i)
5174 struct glyph_row *row = &w->desired_matrix->rows[i];
5175 struct glyph *last;
5176 int row_width;
5178 if (!row->enabled_p || !row->displays_text_p)
5179 break;
5180 row->full_width_p = 1;
5181 row_width = row->pixel_width;
5182 if (row->used[TEXT_AREA] && !row->reversed_p)
5184 last = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
5185 if (INTEGERP (last->object))
5186 row_width -= last->pixel_width;
5189 height += row->height;
5190 width = max (width, row_width);
5194 /* Add the frame's internal border to the width and height the X
5195 window should have. */
5196 height += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
5197 width += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
5199 /* Move the tooltip window where the mouse pointer is. Resize and
5200 show it. */
5201 compute_tip_xy (f, parms, dx, dy, width, height, &root_x, &root_y);
5203 BLOCK_INPUT;
5204 XMoveResizeWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
5205 root_x, root_y, width, height);
5206 XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
5207 UNBLOCK_INPUT;
5209 /* Draw into the window. */
5210 w->must_be_updated_p = 1;
5211 update_single_window (w, 1);
5213 /* Restore original current buffer. */
5214 set_buffer_internal_1 (old_buffer);
5215 windows_or_buffers_changed = old_windows_or_buffers_changed;
5217 start_timer:
5218 /* Let the tip disappear after timeout seconds. */
5219 tip_timer = call3 (intern ("run-at-time"), timeout, Qnil,
5220 intern ("x-hide-tip"));
5222 UNGCPRO;
5223 return unbind_to (count, Qnil);
5227 DEFUN ("x-hide-tip", Fx_hide_tip, Sx_hide_tip, 0, 0, 0,
5228 doc: /* Hide the current tooltip window, if there is any.
5229 Value is t if tooltip was open, nil otherwise. */)
5230 (void)
5232 ptrdiff_t count;
5233 Lisp_Object deleted, frame, timer;
5234 struct gcpro gcpro1, gcpro2;
5236 /* Return quickly if nothing to do. */
5237 if (NILP (tip_timer) && NILP (tip_frame))
5238 return Qnil;
5240 frame = tip_frame;
5241 timer = tip_timer;
5242 GCPRO2 (frame, timer);
5243 tip_frame = tip_timer = deleted = Qnil;
5245 count = SPECPDL_INDEX ();
5246 specbind (Qinhibit_redisplay, Qt);
5247 specbind (Qinhibit_quit, Qt);
5249 if (!NILP (timer))
5250 call1 (Qcancel_timer, timer);
5252 #ifdef USE_GTK
5254 /* When using system tooltip, tip_frame is the Emacs frame on which
5255 the tip is shown. */
5256 struct frame *f = XFRAME (frame);
5257 if (FRAME_LIVE_P (f) && xg_hide_tooltip (f))
5258 frame = Qnil;
5260 #endif
5262 if (FRAMEP (frame))
5264 delete_frame (frame, Qnil);
5265 deleted = Qt;
5267 #ifdef USE_LUCID
5268 /* Bloodcurdling hack alert: The Lucid menu bar widget's
5269 redisplay procedure is not called when a tip frame over menu
5270 items is unmapped. Redisplay the menu manually... */
5272 Widget w;
5273 struct frame *f = SELECTED_FRAME ();
5274 w = f->output_data.x->menubar_widget;
5276 if (!DoesSaveUnders (FRAME_X_DISPLAY_INFO (f)->screen)
5277 && w != NULL)
5279 BLOCK_INPUT;
5280 xlwmenu_redisplay (w);
5281 UNBLOCK_INPUT;
5284 #endif /* USE_LUCID */
5287 UNGCPRO;
5288 return unbind_to (count, deleted);
5293 /***********************************************************************
5294 File selection dialog
5295 ***********************************************************************/
5297 DEFUN ("x-uses-old-gtk-dialog", Fx_uses_old_gtk_dialog,
5298 Sx_uses_old_gtk_dialog,
5299 0, 0, 0,
5300 doc: /* Return t if the old Gtk+ file selection dialog is used. */)
5301 (void)
5303 #ifdef USE_GTK
5304 if (use_dialog_box
5305 && use_file_dialog
5306 && have_menus_p ()
5307 && xg_uses_old_file_dialog ())
5308 return Qt;
5309 #endif
5310 return Qnil;
5314 #ifdef USE_MOTIF
5315 /* Callback for "OK" and "Cancel" on file selection dialog. */
5317 static void
5318 file_dialog_cb (Widget widget, XtPointer client_data, XtPointer call_data)
5320 int *result = (int *) client_data;
5321 XmAnyCallbackStruct *cb = (XmAnyCallbackStruct *) call_data;
5322 *result = cb->reason;
5326 /* Callback for unmapping a file selection dialog. This is used to
5327 capture the case where a dialog is closed via a window manager's
5328 closer button, for example. Using a XmNdestroyCallback didn't work
5329 in this case. */
5331 static void
5332 file_dialog_unmap_cb (Widget widget, XtPointer client_data, XtPointer call_data)
5334 int *result = (int *) client_data;
5335 *result = XmCR_CANCEL;
5338 static Lisp_Object
5339 clean_up_file_dialog (Lisp_Object arg)
5341 struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
5342 Widget dialog = (Widget) p->pointer;
5344 /* Clean up. */
5345 BLOCK_INPUT;
5346 XtUnmanageChild (dialog);
5347 XtDestroyWidget (dialog);
5348 x_menu_set_in_use (0);
5349 UNBLOCK_INPUT;
5351 return Qnil;
5355 DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
5356 doc: /* Read file name, prompting with PROMPT in directory DIR.
5357 Use a file selection dialog. Select DEFAULT-FILENAME in the dialog's file
5358 selection box, if specified. If MUSTMATCH is non-nil, the returned file
5359 or directory must exist.
5361 This function is only defined on MS Windows, and X Windows with the
5362 Motif or Gtk toolkits. With the Motif toolkit, ONLY-DIR-P is ignored.
5363 Otherwise, if ONLY-DIR-P is non-nil, the user can only select directories. */)
5364 (Lisp_Object prompt, Lisp_Object dir, Lisp_Object default_filename, Lisp_Object mustmatch, Lisp_Object only_dir_p)
5366 int result;
5367 struct frame *f = SELECTED_FRAME ();
5368 Lisp_Object file = Qnil;
5369 Lisp_Object decoded_file;
5370 Widget dialog, text, help;
5371 Arg al[10];
5372 int ac = 0;
5373 XmString dir_xmstring, pattern_xmstring;
5374 ptrdiff_t count = SPECPDL_INDEX ();
5375 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
5377 check_x ();
5379 GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
5381 if (popup_activated ())
5382 error ("Trying to use a menu from within a menu-entry");
5384 CHECK_STRING (prompt);
5385 CHECK_STRING (dir);
5387 /* Prevent redisplay. */
5388 specbind (Qinhibit_redisplay, Qt);
5390 BLOCK_INPUT;
5392 /* Create the dialog with PROMPT as title, using DIR as initial
5393 directory and using "*" as pattern. */
5394 dir = Fexpand_file_name (dir, Qnil);
5395 dir_xmstring = XmStringCreateLocalized (SDATA (dir));
5396 pattern_xmstring = XmStringCreateLocalized ("*");
5398 XtSetArg (al[ac], XmNtitle, SDATA (prompt)); ++ac;
5399 XtSetArg (al[ac], XmNdirectory, dir_xmstring); ++ac;
5400 XtSetArg (al[ac], XmNpattern, pattern_xmstring); ++ac;
5401 XtSetArg (al[ac], XmNresizePolicy, XmRESIZE_GROW); ++ac;
5402 XtSetArg (al[ac], XmNdialogStyle, XmDIALOG_APPLICATION_MODAL); ++ac;
5403 dialog = XmCreateFileSelectionDialog (f->output_data.x->widget,
5404 "fsb", al, ac);
5405 XmStringFree (dir_xmstring);
5406 XmStringFree (pattern_xmstring);
5408 /* Add callbacks for OK and Cancel. */
5409 XtAddCallback (dialog, XmNokCallback, file_dialog_cb,
5410 (XtPointer) &result);
5411 XtAddCallback (dialog, XmNcancelCallback, file_dialog_cb,
5412 (XtPointer) &result);
5413 XtAddCallback (dialog, XmNunmapCallback, file_dialog_unmap_cb,
5414 (XtPointer) &result);
5416 /* Remove the help button since we can't display help. */
5417 help = XmFileSelectionBoxGetChild (dialog, XmDIALOG_HELP_BUTTON);
5418 XtUnmanageChild (help);
5420 /* Mark OK button as default. */
5421 XtVaSetValues (XmFileSelectionBoxGetChild (dialog, XmDIALOG_OK_BUTTON),
5422 XmNshowAsDefault, True, NULL);
5424 /* If MUSTMATCH is non-nil, disable the file entry field of the
5425 dialog, so that the user must select a file from the files list
5426 box. We can't remove it because we wouldn't have a way to get at
5427 the result file name, then. */
5428 text = XmFileSelectionBoxGetChild (dialog, XmDIALOG_TEXT);
5429 if (!NILP (mustmatch))
5431 Widget label;
5432 label = XmFileSelectionBoxGetChild (dialog, XmDIALOG_SELECTION_LABEL);
5433 XtSetSensitive (text, False);
5434 XtSetSensitive (label, False);
5437 /* Manage the dialog, so that list boxes get filled. */
5438 XtManageChild (dialog);
5440 if (STRINGP (default_filename))
5442 XmString default_xmstring;
5443 Widget wtext = XmFileSelectionBoxGetChild (dialog, XmDIALOG_TEXT);
5444 Widget list = XmFileSelectionBoxGetChild (dialog, XmDIALOG_LIST);
5446 XmTextPosition last_pos = XmTextFieldGetLastPosition (wtext);
5447 XmTextFieldReplace (wtext, 0, last_pos,
5448 (SDATA (Ffile_name_nondirectory (default_filename))));
5450 /* Select DEFAULT_FILENAME in the files list box. DEFAULT_FILENAME
5451 must include the path for this to work. */
5453 default_xmstring = XmStringCreateLocalized (SDATA (default_filename));
5455 if (XmListItemExists (list, default_xmstring))
5457 int item_pos = XmListItemPos (list, default_xmstring);
5458 /* Select the item and scroll it into view. */
5459 XmListSelectPos (list, item_pos, True);
5460 XmListSetPos (list, item_pos);
5463 XmStringFree (default_xmstring);
5466 record_unwind_protect (clean_up_file_dialog, make_save_value (dialog, 0));
5468 /* Process events until the user presses Cancel or OK. */
5469 x_menu_set_in_use (1);
5470 result = 0;
5471 while (result == 0)
5473 XEvent event;
5474 x_menu_wait_for_event (0);
5475 XtAppNextEvent (Xt_app_con, &event);
5476 if (event.type == KeyPress
5477 && FRAME_X_DISPLAY (f) == event.xkey.display)
5479 KeySym keysym = XLookupKeysym (&event.xkey, 0);
5481 /* Pop down on C-g. */
5482 if (keysym == XK_g && (event.xkey.state & ControlMask) != 0)
5483 XtUnmanageChild (dialog);
5486 (void) x_dispatch_event (&event, FRAME_X_DISPLAY (f));
5489 /* Get the result. */
5490 if (result == XmCR_OK)
5492 XmString text_string;
5493 String data;
5495 XtVaGetValues (dialog, XmNtextString, &text_string, NULL);
5496 XmStringGetLtoR (text_string, XmFONTLIST_DEFAULT_TAG, &data);
5497 XmStringFree (text_string);
5498 file = build_string (data);
5499 XtFree (data);
5501 else
5502 file = Qnil;
5504 UNBLOCK_INPUT;
5505 UNGCPRO;
5507 /* Make "Cancel" equivalent to C-g. */
5508 if (NILP (file))
5509 Fsignal (Qquit, Qnil);
5511 decoded_file = DECODE_FILE (file);
5513 return unbind_to (count, decoded_file);
5516 #endif /* USE_MOTIF */
5518 #ifdef USE_GTK
5520 static Lisp_Object
5521 clean_up_dialog (Lisp_Object arg)
5523 x_menu_set_in_use (0);
5525 return Qnil;
5528 DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
5529 doc: /* Read file name, prompting with PROMPT in directory DIR.
5530 Use a file selection dialog. Select DEFAULT-FILENAME in the dialog's file
5531 selection box, if specified. If MUSTMATCH is non-nil, the returned file
5532 or directory must exist.
5534 This function is only defined on MS Windows, and X Windows with the
5535 Motif or Gtk toolkits. With the Motif toolkit, ONLY-DIR-P is ignored.
5536 Otherwise, if ONLY-DIR-P is non-nil, the user can only select directories. */)
5537 (Lisp_Object prompt, Lisp_Object dir, Lisp_Object default_filename, Lisp_Object mustmatch, Lisp_Object only_dir_p)
5539 FRAME_PTR f = SELECTED_FRAME ();
5540 char *fn;
5541 Lisp_Object file = Qnil;
5542 Lisp_Object decoded_file;
5543 ptrdiff_t count = SPECPDL_INDEX ();
5544 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
5545 char *cdef_file;
5547 check_x ();
5549 GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
5551 if (popup_activated ())
5552 error ("Trying to use a menu from within a menu-entry");
5554 CHECK_STRING (prompt);
5555 CHECK_STRING (dir);
5557 /* Prevent redisplay. */
5558 specbind (Qinhibit_redisplay, Qt);
5559 record_unwind_protect (clean_up_dialog, Qnil);
5561 BLOCK_INPUT;
5563 if (STRINGP (default_filename))
5564 cdef_file = SSDATA (default_filename);
5565 else
5566 cdef_file = SSDATA (dir);
5568 fn = xg_get_file_name (f, SSDATA (prompt), cdef_file,
5569 ! NILP (mustmatch),
5570 ! NILP (only_dir_p));
5572 if (fn)
5574 file = build_string (fn);
5575 xfree (fn);
5578 UNBLOCK_INPUT;
5579 UNGCPRO;
5581 /* Make "Cancel" equivalent to C-g. */
5582 if (NILP (file))
5583 Fsignal (Qquit, Qnil);
5585 decoded_file = DECODE_FILE (file);
5587 return unbind_to (count, decoded_file);
5591 #ifdef HAVE_FREETYPE
5593 DEFUN ("x-select-font", Fx_select_font, Sx_select_font, 0, 2, 0,
5594 doc: /* Read a font name using a GTK font selection dialog.
5595 Return a GTK-style font string corresponding to the selection.
5597 If FRAME is omitted or nil, it defaults to the selected frame. */)
5598 (Lisp_Object frame, Lisp_Object ignored)
5600 FRAME_PTR f = check_x_frame (frame);
5601 char *name;
5602 Lisp_Object font;
5603 Lisp_Object font_param;
5604 char *default_name = NULL;
5605 struct gcpro gcpro1, gcpro2;
5606 ptrdiff_t count = SPECPDL_INDEX ();
5608 check_x ();
5610 if (popup_activated ())
5611 error ("Trying to use a menu from within a menu-entry");
5613 /* Prevent redisplay. */
5614 specbind (Qinhibit_redisplay, Qt);
5615 record_unwind_protect (clean_up_dialog, Qnil);
5617 BLOCK_INPUT;
5619 GCPRO2 (font_param, font);
5621 XSETFONT (font, FRAME_FONT (f));
5622 font_param = Ffont_get (font, intern (":name"));
5623 if (STRINGP (font_param))
5624 default_name = xstrdup (SSDATA (font_param));
5625 else
5627 font_param = Fframe_parameter (frame, Qfont_param);
5628 if (STRINGP (font_param))
5629 default_name = xstrdup (SSDATA (font_param));
5632 if (default_name == NULL && x_last_font_name != NULL)
5633 default_name = xstrdup (x_last_font_name);
5635 /* Convert fontconfig names to Gtk names, i.e. remove - before number */
5636 if (default_name)
5638 char *p = strrchr (default_name, '-');
5639 if (p)
5641 char *ep = p+1;
5642 while (isdigit (*ep))
5643 ++ep;
5644 if (*ep == '\0') *p = ' ';
5648 name = xg_get_font_name (f, default_name);
5649 xfree (default_name);
5651 if (name)
5653 font = build_string (name);
5654 g_free (x_last_font_name);
5655 x_last_font_name = name;
5658 UNBLOCK_INPUT;
5660 if (NILP (font))
5661 Fsignal (Qquit, Qnil);
5663 return unbind_to (count, font);
5665 #endif /* HAVE_FREETYPE */
5667 #endif /* USE_GTK */
5670 /***********************************************************************
5671 Keyboard
5672 ***********************************************************************/
5674 #ifdef HAVE_XKBGETKEYBOARD
5675 #include <X11/XKBlib.h>
5676 #include <X11/keysym.h>
5677 #endif
5679 DEFUN ("x-backspace-delete-keys-p", Fx_backspace_delete_keys_p,
5680 Sx_backspace_delete_keys_p, 0, 1, 0,
5681 doc: /* Check if both Backspace and Delete keys are on the keyboard of FRAME.
5682 FRAME nil means use the selected frame.
5683 Value is t if we know that both keys are present, and are mapped to the
5684 usual X keysyms. Value is `lambda' if we cannot determine if both keys are
5685 present and mapped to the usual X keysyms. */)
5686 (Lisp_Object frame)
5688 #ifdef HAVE_XKBGETKEYBOARD
5689 XkbDescPtr kb;
5690 struct frame *f = check_x_frame (frame);
5691 Display *dpy = FRAME_X_DISPLAY (f);
5692 Lisp_Object have_keys;
5693 int major, minor, op, event, error_code;
5695 BLOCK_INPUT;
5697 /* Check library version in case we're dynamically linked. */
5698 major = XkbMajorVersion;
5699 minor = XkbMinorVersion;
5700 if (!XkbLibraryVersion (&major, &minor))
5702 UNBLOCK_INPUT;
5703 return Qlambda;
5706 /* Check that the server supports XKB. */
5707 major = XkbMajorVersion;
5708 minor = XkbMinorVersion;
5709 if (!XkbQueryExtension (dpy, &op, &event, &error_code, &major, &minor))
5711 UNBLOCK_INPUT;
5712 return Qlambda;
5715 /* In this code we check that the keyboard has physical keys with names
5716 that start with BKSP (Backspace) and DELE (Delete), and that they
5717 generate keysym XK_BackSpace and XK_Delete respectively.
5718 This function is used to test if normal-erase-is-backspace should be
5719 turned on.
5720 An alternative approach would be to just check if XK_BackSpace and
5721 XK_Delete are mapped to any key. But if any of those are mapped to
5722 some non-intuitive key combination (Meta-Shift-Ctrl-whatever) and the
5723 user doesn't know about it, it is better to return false here.
5724 It is more obvious to the user what to do if she/he has two keys
5725 clearly marked with names/symbols and one key does something not
5726 expected (i.e. she/he then tries the other).
5727 The cases where Backspace/Delete is mapped to some other key combination
5728 are rare, and in those cases, normal-erase-is-backspace can be turned on
5729 manually. */
5731 have_keys = Qnil;
5732 kb = XkbGetMap (dpy, XkbAllMapComponentsMask, XkbUseCoreKbd);
5733 if (kb)
5735 int delete_keycode = 0, backspace_keycode = 0, i;
5737 if (XkbGetNames (dpy, XkbAllNamesMask, kb) == Success)
5739 for (i = kb->min_key_code;
5740 (i < kb->max_key_code
5741 && (delete_keycode == 0 || backspace_keycode == 0));
5742 ++i)
5744 /* The XKB symbolic key names can be seen most easily in
5745 the PS file generated by `xkbprint -label name
5746 $DISPLAY'. */
5747 if (memcmp ("DELE", kb->names->keys[i].name, 4) == 0)
5748 delete_keycode = i;
5749 else if (memcmp ("BKSP", kb->names->keys[i].name, 4) == 0)
5750 backspace_keycode = i;
5753 XkbFreeNames (kb, 0, True);
5756 XkbFreeClientMap (kb, 0, True);
5758 if (delete_keycode
5759 && backspace_keycode
5760 && XKeysymToKeycode (dpy, XK_Delete) == delete_keycode
5761 && XKeysymToKeycode (dpy, XK_BackSpace) == backspace_keycode)
5762 have_keys = Qt;
5764 UNBLOCK_INPUT;
5765 return have_keys;
5766 #else /* not HAVE_XKBGETKEYBOARD */
5767 return Qlambda;
5768 #endif /* not HAVE_XKBGETKEYBOARD */
5773 /***********************************************************************
5774 Initialization
5775 ***********************************************************************/
5777 /* Keep this list in the same order as frame_parms in frame.c.
5778 Use 0 for unsupported frame parameters. */
5780 frame_parm_handler x_frame_parm_handlers[] =
5782 x_set_autoraise,
5783 x_set_autolower,
5784 x_set_background_color,
5785 x_set_border_color,
5786 x_set_border_width,
5787 x_set_cursor_color,
5788 x_set_cursor_type,
5789 x_set_font,
5790 x_set_foreground_color,
5791 x_set_icon_name,
5792 x_set_icon_type,
5793 x_set_internal_border_width,
5794 x_set_menu_bar_lines,
5795 x_set_mouse_color,
5796 x_explicitly_set_name,
5797 x_set_scroll_bar_width,
5798 x_set_title,
5799 x_set_unsplittable,
5800 x_set_vertical_scroll_bars,
5801 x_set_visibility,
5802 x_set_tool_bar_lines,
5803 x_set_scroll_bar_foreground,
5804 x_set_scroll_bar_background,
5805 x_set_screen_gamma,
5806 x_set_line_spacing,
5807 x_set_fringe_width,
5808 x_set_fringe_width,
5809 x_set_wait_for_wm,
5810 x_set_fullscreen,
5811 x_set_font_backend,
5812 x_set_alpha,
5813 x_set_sticky,
5814 x_set_tool_bar_position,
5817 void
5818 syms_of_xfns (void)
5820 /* This is zero if not using X windows. */
5821 x_in_use = 0;
5823 /* The section below is built by the lisp expression at the top of the file,
5824 just above where these variables are declared. */
5825 /*&&& init symbols here &&&*/
5826 DEFSYM (Qnone, "none");
5827 DEFSYM (Qsuppress_icon, "suppress-icon");
5828 DEFSYM (Qundefined_color, "undefined-color");
5829 DEFSYM (Qcompound_text, "compound-text");
5830 DEFSYM (Qcancel_timer, "cancel-timer");
5831 DEFSYM (Qfont_param, "font-parameter");
5832 /* This is the end of symbol initialization. */
5834 Fput (Qundefined_color, Qerror_conditions,
5835 pure_cons (Qundefined_color, pure_cons (Qerror, Qnil)));
5836 Fput (Qundefined_color, Qerror_message,
5837 make_pure_c_string ("Undefined color"));
5839 DEFVAR_LISP ("x-pointer-shape", Vx_pointer_shape,
5840 doc: /* The shape of the pointer when over text.
5841 Changing the value does not affect existing frames
5842 unless you set the mouse color. */);
5843 Vx_pointer_shape = Qnil;
5845 #if 0 /* This doesn't really do anything. */
5846 DEFVAR_LISP ("x-nontext-pointer-shape", Vx_nontext_pointer_shape,
5847 doc: /* The shape of the pointer when not over text.
5848 This variable takes effect when you create a new frame
5849 or when you set the mouse color. */);
5850 #endif
5851 Vx_nontext_pointer_shape = Qnil;
5853 DEFVAR_LISP ("x-hourglass-pointer-shape", Vx_hourglass_pointer_shape,
5854 doc: /* The shape of the pointer when Emacs is busy.
5855 This variable takes effect when you create a new frame
5856 or when you set the mouse color. */);
5857 Vx_hourglass_pointer_shape = Qnil;
5859 #if 0 /* This doesn't really do anything. */
5860 DEFVAR_LISP ("x-mode-pointer-shape", Vx_mode_pointer_shape,
5861 doc: /* The shape of the pointer when over the mode line.
5862 This variable takes effect when you create a new frame
5863 or when you set the mouse color. */);
5864 #endif
5865 Vx_mode_pointer_shape = Qnil;
5867 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
5868 Vx_sensitive_text_pointer_shape,
5869 doc: /* The shape of the pointer when over mouse-sensitive text.
5870 This variable takes effect when you create a new frame
5871 or when you set the mouse color. */);
5872 Vx_sensitive_text_pointer_shape = Qnil;
5874 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
5875 Vx_window_horizontal_drag_shape,
5876 doc: /* Pointer shape to use for indicating a window can be dragged horizontally.
5877 This variable takes effect when you create a new frame
5878 or when you set the mouse color. */);
5879 Vx_window_horizontal_drag_shape = Qnil;
5881 DEFVAR_LISP ("x-cursor-fore-pixel", Vx_cursor_fore_pixel,
5882 doc: /* A string indicating the foreground color of the cursor box. */);
5883 Vx_cursor_fore_pixel = Qnil;
5885 DEFVAR_LISP ("x-max-tooltip-size", Vx_max_tooltip_size,
5886 doc: /* Maximum size for tooltips.
5887 Value is a pair (COLUMNS . ROWS). Text larger than this is clipped. */);
5888 Vx_max_tooltip_size = Fcons (make_number (80), make_number (40));
5890 DEFVAR_LISP ("x-no-window-manager", Vx_no_window_manager,
5891 doc: /* Non-nil if no X window manager is in use.
5892 Emacs doesn't try to figure this out; this is always nil
5893 unless you set it to something else. */);
5894 /* We don't have any way to find this out, so set it to nil
5895 and maybe the user would like to set it to t. */
5896 Vx_no_window_manager = Qnil;
5898 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
5899 Vx_pixel_size_width_font_regexp,
5900 doc: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
5902 Since Emacs gets width of a font matching with this regexp from
5903 PIXEL_SIZE field of the name, font finding mechanism gets faster for
5904 such a font. This is especially effective for such large fonts as
5905 Chinese, Japanese, and Korean. */);
5906 Vx_pixel_size_width_font_regexp = Qnil;
5908 /* This is not ifdef:ed, so other builds than GTK can customize it. */
5909 DEFVAR_BOOL ("x-gtk-use-old-file-dialog", x_gtk_use_old_file_dialog,
5910 doc: /* Non-nil means prompt with the old GTK file selection dialog.
5911 If nil or if the file selection dialog is not available, the new GTK file
5912 chooser is used instead. To turn off all file dialogs set the
5913 variable `use-file-dialog'. */);
5914 x_gtk_use_old_file_dialog = 0;
5916 DEFVAR_BOOL ("x-gtk-show-hidden-files", x_gtk_show_hidden_files,
5917 doc: /* If non-nil, the GTK file chooser will by default show hidden files.
5918 Note that this is just the default, there is a toggle button on the file
5919 chooser to show or not show hidden files on a case by case basis. */);
5920 x_gtk_show_hidden_files = 0;
5922 DEFVAR_BOOL ("x-gtk-file-dialog-help-text", x_gtk_file_dialog_help_text,
5923 doc: /* If non-nil, the GTK file chooser will show additional help text.
5924 If more space for files in the file chooser dialog is wanted, set this to nil
5925 to turn the additional text off. */);
5926 x_gtk_file_dialog_help_text = 1;
5928 DEFVAR_BOOL ("x-gtk-whole-detached-tool-bar", x_gtk_whole_detached_tool_bar,
5929 doc: /* If non-nil, a detached tool bar is shown in full.
5930 The default is to just show an arrow and pressing on that arrow shows
5931 the tool bar buttons. */);
5932 x_gtk_whole_detached_tool_bar = 0;
5934 DEFVAR_BOOL ("x-gtk-use-system-tooltips", x_gtk_use_system_tooltips,
5935 doc: /* If non-nil with a Gtk+ built Emacs, the Gtk+ tooltip is used.
5936 Otherwise use Emacs own tooltip implementation.
5937 When using Gtk+ tooltips, the tooltip face is not used. */);
5938 x_gtk_use_system_tooltips = 1;
5940 Fprovide (intern_c_string ("x"), Qnil);
5942 #ifdef USE_X_TOOLKIT
5943 Fprovide (intern_c_string ("x-toolkit"), Qnil);
5944 #ifdef USE_MOTIF
5945 Fprovide (intern_c_string ("motif"), Qnil);
5947 DEFVAR_LISP ("motif-version-string", Vmotif_version_string,
5948 doc: /* Version info for LessTif/Motif. */);
5949 Vmotif_version_string = build_string (XmVERSION_STRING);
5950 #endif /* USE_MOTIF */
5951 #endif /* USE_X_TOOLKIT */
5953 #ifdef USE_GTK
5954 /* Provide x-toolkit also for GTK. Internally GTK does not use Xt so it
5955 is not an X toolkit in that sense (USE_X_TOOLKIT is not defined).
5956 But for a user it is a toolkit for X, and indeed, configure
5957 accepts --with-x-toolkit=gtk. */
5958 Fprovide (intern_c_string ("x-toolkit"), Qnil);
5959 Fprovide (intern_c_string ("gtk"), Qnil);
5960 Fprovide (intern_c_string ("move-toolbar"), Qnil);
5962 DEFVAR_LISP ("gtk-version-string", Vgtk_version_string,
5963 doc: /* Version info for GTK+. */);
5965 char gtk_version[40];
5966 g_snprintf (gtk_version, sizeof (gtk_version), "%u.%u.%u",
5967 GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION);
5968 Vgtk_version_string = make_pure_string (gtk_version, strlen (gtk_version), strlen (gtk_version), 0);
5970 #endif /* USE_GTK */
5972 /* X window properties. */
5973 defsubr (&Sx_change_window_property);
5974 defsubr (&Sx_delete_window_property);
5975 defsubr (&Sx_window_property);
5977 defsubr (&Sxw_display_color_p);
5978 defsubr (&Sx_display_grayscale_p);
5979 defsubr (&Sxw_color_defined_p);
5980 defsubr (&Sxw_color_values);
5981 defsubr (&Sx_server_max_request_size);
5982 defsubr (&Sx_server_vendor);
5983 defsubr (&Sx_server_version);
5984 defsubr (&Sx_display_pixel_width);
5985 defsubr (&Sx_display_pixel_height);
5986 defsubr (&Sx_display_mm_width);
5987 defsubr (&Sx_display_mm_height);
5988 defsubr (&Sx_display_screens);
5989 defsubr (&Sx_display_planes);
5990 defsubr (&Sx_display_color_cells);
5991 defsubr (&Sx_display_visual_class);
5992 defsubr (&Sx_display_backing_store);
5993 defsubr (&Sx_display_save_under);
5994 defsubr (&Sx_wm_set_size_hint);
5995 defsubr (&Sx_create_frame);
5996 defsubr (&Sx_open_connection);
5997 defsubr (&Sx_close_connection);
5998 defsubr (&Sx_display_list);
5999 defsubr (&Sx_synchronize);
6000 defsubr (&Sx_focus_frame);
6001 defsubr (&Sx_backspace_delete_keys_p);
6003 /* Setting callback functions for fontset handler. */
6004 check_window_system_func = check_x;
6006 defsubr (&Sx_show_tip);
6007 defsubr (&Sx_hide_tip);
6008 tip_timer = Qnil;
6009 staticpro (&tip_timer);
6010 tip_frame = Qnil;
6011 staticpro (&tip_frame);
6013 last_show_tip_args = Qnil;
6014 staticpro (&last_show_tip_args);
6016 defsubr (&Sx_uses_old_gtk_dialog);
6017 #if defined (USE_MOTIF) || defined (USE_GTK)
6018 defsubr (&Sx_file_dialog);
6019 #endif
6021 #if defined (USE_GTK) && defined (HAVE_FREETYPE)
6022 defsubr (&Sx_select_font);
6023 x_last_font_name = NULL;
6024 #endif
6027 #endif /* HAVE_X_WINDOWS */