* ftfont.c (ftfont_shape_by_flt): Use signed integers for lengths.
[emacs.git] / src / xfns.c
blobabc273c2bdf99886929ef62bea69ccb510d9a29e
1 /* Functions for the X window system.
3 Copyright (C) 1989, 1992-2011 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 #include <config.h>
21 #include <stdio.h>
22 #include <math.h>
23 #include <setjmp.h>
24 #include <ctype.h>
25 #include <unistd.h>
27 /* This makes the fields of a Display accessible, in Xlib header files. */
29 #define XLIB_ILLEGAL_ACCESS
31 #include "lisp.h"
32 #include "xterm.h"
33 #include "frame.h"
34 #include "window.h"
35 #include "buffer.h"
36 #include "intervals.h"
37 #include "dispextern.h"
38 #include "keyboard.h"
39 #include "blockinput.h"
40 #include <epaths.h>
41 #include "character.h"
42 #include "charset.h"
43 #include "coding.h"
44 #include "fontset.h"
45 #include "systime.h"
46 #include "termhooks.h"
47 #include "atimer.h"
48 #include "termchar.h"
49 #include "font.h"
51 #ifdef HAVE_X_WINDOWS
53 #include <ctype.h>
54 #include <sys/types.h>
55 #include <sys/stat.h>
57 #if 1 /* Used to be #ifdef EMACS_BITMAP_FILES, but this should always work. */
58 #include "bitmaps/gray.xbm"
59 #else
60 #include <X11/bitmaps/gray>
61 #endif
63 #include "xsettings.h"
65 #ifdef USE_GTK
66 #include "gtkutil.h"
67 #endif
69 #ifdef USE_X_TOOLKIT
70 #include <X11/Shell.h>
72 #ifndef USE_MOTIF
73 #ifdef HAVE_XAW3D
74 #include <X11/Xaw3d/Paned.h>
75 #include <X11/Xaw3d/Label.h>
76 #else /* !HAVE_XAW3D */
77 #include <X11/Xaw/Paned.h>
78 #include <X11/Xaw/Label.h>
79 #endif /* HAVE_XAW3D */
80 #endif /* USE_MOTIF */
82 #ifdef USG
83 #undef USG /* ####KLUDGE for Solaris 2.2 and up */
84 #include <X11/Xos.h>
85 #define USG
86 #ifdef USG /* Pacify gcc -Wunused-macros. */
87 #endif
88 #else
89 #include <X11/Xos.h>
90 #endif
92 #include "widget.h"
94 #include "../lwlib/lwlib.h"
96 #ifdef USE_MOTIF
97 #include <Xm/Xm.h>
98 #include <Xm/DialogS.h>
99 #include <Xm/FileSB.h>
100 #include <Xm/List.h>
101 #include <Xm/TextF.h>
102 #endif
104 #ifdef USE_LUCID
105 #include "../lwlib/xlwmenu.h"
106 #endif
108 #if !defined(NO_EDITRES)
109 #define HACK_EDITRES
110 extern void _XEditResCheckMessages (Widget, XtPointer, XEvent *, Boolean *);
111 #endif /* not defined NO_EDITRES */
113 /* Unique id counter for widgets created by the Lucid Widget Library. */
115 extern LWLIB_ID widget_id_tick;
117 #ifdef USE_MOTIF
119 #endif /* USE_MOTIF */
121 #endif /* USE_X_TOOLKIT */
123 #ifdef USE_GTK
125 #endif /* USE_GTK */
127 #define MAXREQUEST(dpy) (XMaxRequestSize (dpy))
129 /* The gray bitmap `bitmaps/gray'. This is done because xterm.c uses
130 it, and including `bitmaps/gray' more than once is a problem when
131 config.h defines `static' as an empty replacement string. */
133 int gray_bitmap_width = gray_width;
134 int gray_bitmap_height = gray_height;
135 char *gray_bitmap_bits = gray_bits;
137 /* Nonzero if using X. */
139 static int x_in_use;
141 static Lisp_Object Qnone;
142 static Lisp_Object Qsuppress_icon;
143 static Lisp_Object Qundefined_color;
144 static Lisp_Object Qcompound_text, Qcancel_timer;
145 Lisp_Object Qfont_param;
147 #if GLYPH_DEBUG
148 int image_cache_refcount, dpyinfo_refcount;
149 #endif
151 #if defined (USE_GTK) && defined (HAVE_FREETYPE)
152 static char *x_last_font_name;
153 #endif
155 static struct x_display_info *x_display_info_for_name (Lisp_Object);
158 /* Error if we are not connected to X. */
160 void
161 check_x (void)
163 if (! x_in_use)
164 error ("X windows are not in use or not initialized");
167 /* Nonzero if we can use mouse menus.
168 You should not call this unless HAVE_MENUS is defined. */
171 have_menus_p (void)
173 return x_in_use;
176 /* Extract a frame as a FRAME_PTR, defaulting to the selected frame
177 and checking validity for X. */
179 FRAME_PTR
180 check_x_frame (Lisp_Object frame)
182 FRAME_PTR f;
184 if (NILP (frame))
185 frame = selected_frame;
186 CHECK_LIVE_FRAME (frame);
187 f = XFRAME (frame);
188 if (! FRAME_X_P (f))
189 error ("Non-X frame used");
190 return f;
193 /* Let the user specify an X display with a Lisp object.
194 OBJECT may be nil, a frame or a terminal object.
195 nil stands for the selected frame--or, if that is not an X frame,
196 the first X display on the list. */
198 struct x_display_info *
199 check_x_display_info (Lisp_Object object)
201 struct x_display_info *dpyinfo = NULL;
203 if (NILP (object))
205 struct frame *sf = XFRAME (selected_frame);
207 if (FRAME_X_P (sf) && FRAME_LIVE_P (sf))
208 dpyinfo = FRAME_X_DISPLAY_INFO (sf);
209 else if (x_display_list != 0)
210 dpyinfo = x_display_list;
211 else
212 error ("X windows are not in use or not initialized");
214 else if (TERMINALP (object))
216 struct terminal *t = get_terminal (object, 1);
218 if (t->type != output_x_window)
219 error ("Terminal %"pI"d is not an X display", XINT (object));
221 dpyinfo = t->display_info.x;
223 else if (STRINGP (object))
224 dpyinfo = x_display_info_for_name (object);
225 else
227 FRAME_PTR f = check_x_frame (object);
228 dpyinfo = FRAME_X_DISPLAY_INFO (f);
231 return dpyinfo;
235 /* Return the Emacs frame-object corresponding to an X window.
236 It could be the frame's main window or an icon window. */
238 /* This function can be called during GC, so use GC_xxx type test macros. */
240 struct frame *
241 x_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
243 Lisp_Object tail, frame;
244 struct frame *f;
246 if (wdesc == None) return 0;
248 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
250 frame = XCAR (tail);
251 if (!FRAMEP (frame))
252 continue;
253 f = XFRAME (frame);
254 if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
255 continue;
256 if (f->output_data.x->hourglass_window == wdesc)
257 return f;
258 #ifdef USE_X_TOOLKIT
259 if ((f->output_data.x->edit_widget
260 && XtWindow (f->output_data.x->edit_widget) == wdesc)
261 /* A tooltip frame? */
262 || (!f->output_data.x->edit_widget
263 && FRAME_X_WINDOW (f) == wdesc)
264 || f->output_data.x->icon_desc == wdesc)
265 return f;
266 #else /* not USE_X_TOOLKIT */
267 #ifdef USE_GTK
268 if (f->output_data.x->edit_widget)
270 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
271 struct x_output *x = f->output_data.x;
272 if (gwdesc != 0 && gwdesc == x->edit_widget)
273 return f;
275 #endif /* USE_GTK */
276 if (FRAME_X_WINDOW (f) == wdesc
277 || f->output_data.x->icon_desc == wdesc)
278 return f;
279 #endif /* not USE_X_TOOLKIT */
281 return 0;
284 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
285 /* Like x_window_to_frame but also compares the window with the widget's
286 windows. */
288 struct frame *
289 x_any_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
291 Lisp_Object tail, frame;
292 struct frame *f, *found;
293 struct x_output *x;
295 if (wdesc == None) return NULL;
297 found = NULL;
298 for (tail = Vframe_list; CONSP (tail) && !found; tail = XCDR (tail))
300 frame = XCAR (tail);
301 if (!FRAMEP (frame))
302 continue;
304 f = XFRAME (frame);
305 if (FRAME_X_P (f) && FRAME_X_DISPLAY_INFO (f) == dpyinfo)
307 /* This frame matches if the window is any of its widgets. */
308 x = f->output_data.x;
309 if (x->hourglass_window == wdesc)
310 found = f;
311 else if (x->widget)
313 #ifdef USE_GTK
314 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
315 if (gwdesc != 0
316 && gtk_widget_get_toplevel (gwdesc) == x->widget)
317 found = f;
318 #else
319 if (wdesc == XtWindow (x->widget)
320 || wdesc == XtWindow (x->column_widget)
321 || wdesc == XtWindow (x->edit_widget))
322 found = f;
323 /* Match if the window is this frame's menubar. */
324 else if (lw_window_is_in_menubar (wdesc, x->menubar_widget))
325 found = f;
326 #endif
328 else if (FRAME_X_WINDOW (f) == wdesc)
329 /* A tooltip frame. */
330 found = f;
334 return found;
337 /* Likewise, but consider only the menu bar widget. */
339 struct frame *
340 x_menubar_window_to_frame (struct x_display_info *dpyinfo, XEvent *event)
342 Window wdesc = event->xany.window;
343 Lisp_Object tail, frame;
344 struct frame *f;
345 struct x_output *x;
347 if (wdesc == None) return 0;
349 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
351 frame = XCAR (tail);
352 if (!FRAMEP (frame))
353 continue;
354 f = XFRAME (frame);
355 if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
356 continue;
357 x = f->output_data.x;
358 #ifdef USE_GTK
359 if (x->menubar_widget && xg_event_is_for_menubar (f, event))
360 return f;
361 #else
362 /* Match if the window is this frame's menubar. */
363 if (x->menubar_widget
364 && lw_window_is_in_menubar (wdesc, x->menubar_widget))
365 return f;
366 #endif
368 return 0;
371 /* Return the frame whose principal (outermost) window is WDESC.
372 If WDESC is some other (smaller) window, we return 0. */
374 struct frame *
375 x_top_window_to_frame (struct x_display_info *dpyinfo, int wdesc)
377 Lisp_Object tail, frame;
378 struct frame *f;
379 struct x_output *x;
381 if (wdesc == None) return 0;
383 for (tail = Vframe_list; CONSP (tail); tail = XCDR (tail))
385 frame = XCAR (tail);
386 if (!FRAMEP (frame))
387 continue;
388 f = XFRAME (frame);
389 if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
390 continue;
391 x = f->output_data.x;
393 if (x->widget)
395 /* This frame matches if the window is its topmost widget. */
396 #ifdef USE_GTK
397 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
398 if (gwdesc == x->widget)
399 return f;
400 #else
401 if (wdesc == XtWindow (x->widget))
402 return f;
403 #if 0 /* I don't know why it did this,
404 but it seems logically wrong,
405 and it causes trouble for MapNotify events. */
406 /* Match if the window is this frame's menubar. */
407 if (x->menubar_widget
408 && wdesc == XtWindow (x->menubar_widget))
409 return f;
410 #endif
411 #endif
413 else if (FRAME_X_WINDOW (f) == wdesc)
414 /* Tooltip frame. */
415 return f;
417 return 0;
419 #endif /* USE_X_TOOLKIT || USE_GTK */
423 /* Store the screen positions of frame F into XPTR and YPTR.
424 These are the positions of the containing window manager window,
425 not Emacs's own window. */
427 void
428 x_real_positions (FRAME_PTR f, int *xptr, int *yptr)
430 int win_x, win_y, outer_x IF_LINT (= 0), outer_y IF_LINT (= 0);
431 int real_x = 0, real_y = 0;
432 int had_errors = 0;
433 Window win = f->output_data.x->parent_desc;
434 Atom actual_type;
435 unsigned long actual_size, bytes_remaining;
436 int rc, actual_format;
437 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
438 long max_len = 400;
439 Display *dpy = FRAME_X_DISPLAY (f);
440 unsigned char *tmp_data = NULL;
441 Atom target_type = XA_CARDINAL;
443 BLOCK_INPUT;
445 x_catch_errors (dpy);
447 if (win == dpyinfo->root_window)
448 win = FRAME_OUTER_WINDOW (f);
450 /* This loop traverses up the containment tree until we hit the root
451 window. Window managers may intersect many windows between our window
452 and the root window. The window we find just before the root window
453 should be the outer WM window. */
454 for (;;)
456 Window wm_window, rootw;
457 Window *tmp_children;
458 unsigned int tmp_nchildren;
459 int success;
461 success = XQueryTree (FRAME_X_DISPLAY (f), win, &rootw,
462 &wm_window, &tmp_children, &tmp_nchildren);
464 had_errors = x_had_errors_p (FRAME_X_DISPLAY (f));
466 /* Don't free tmp_children if XQueryTree failed. */
467 if (! success)
468 break;
470 XFree ((char *) tmp_children);
472 if (wm_window == rootw || had_errors)
473 break;
475 win = wm_window;
478 if (! had_errors)
480 unsigned int ign;
481 Window child, rootw;
483 /* Get the real coordinates for the WM window upper left corner */
484 XGetGeometry (FRAME_X_DISPLAY (f), win,
485 &rootw, &real_x, &real_y, &ign, &ign, &ign, &ign);
487 /* Translate real coordinates to coordinates relative to our
488 window. For our window, the upper left corner is 0, 0.
489 Since the upper left corner of the WM window is outside
490 our window, win_x and win_y will be negative:
492 ------------------ ---> x
493 | title |
494 | ----------------- v y
495 | | our window
497 XTranslateCoordinates (FRAME_X_DISPLAY (f),
499 /* From-window, to-window. */
500 FRAME_X_DISPLAY_INFO (f)->root_window,
501 FRAME_X_WINDOW (f),
503 /* From-position, to-position. */
504 real_x, real_y, &win_x, &win_y,
506 /* Child of win. */
507 &child);
509 if (FRAME_X_WINDOW (f) == FRAME_OUTER_WINDOW (f))
511 outer_x = win_x;
512 outer_y = win_y;
514 else
516 XTranslateCoordinates (FRAME_X_DISPLAY (f),
518 /* From-window, to-window. */
519 FRAME_X_DISPLAY_INFO (f)->root_window,
520 FRAME_OUTER_WINDOW (f),
522 /* From-position, to-position. */
523 real_x, real_y, &outer_x, &outer_y,
525 /* Child of win. */
526 &child);
529 had_errors = x_had_errors_p (FRAME_X_DISPLAY (f));
533 if (dpyinfo->root_window == f->output_data.x->parent_desc)
535 /* Try _NET_FRAME_EXTENTS if our parent is the root window. */
536 rc = XGetWindowProperty (dpy, win, dpyinfo->Xatom_net_frame_extents,
537 0, max_len, False, target_type,
538 &actual_type, &actual_format, &actual_size,
539 &bytes_remaining, &tmp_data);
541 if (rc == Success && actual_type == target_type && !x_had_errors_p (dpy)
542 && actual_size == 4 && actual_format == 32)
544 unsigned int ign;
545 Window rootw;
546 long *fe = (long *)tmp_data;
548 XGetGeometry (FRAME_X_DISPLAY (f), win,
549 &rootw, &real_x, &real_y, &ign, &ign, &ign, &ign);
550 outer_x = -fe[0];
551 outer_y = -fe[2];
552 real_x -= fe[0];
553 real_y -= fe[2];
557 if (tmp_data) XFree (tmp_data);
559 x_uncatch_errors ();
561 UNBLOCK_INPUT;
563 if (had_errors) return;
565 f->x_pixels_diff = -win_x;
566 f->y_pixels_diff = -win_y;
568 FRAME_X_OUTPUT (f)->x_pixels_outer_diff = -outer_x;
569 FRAME_X_OUTPUT (f)->y_pixels_outer_diff = -outer_y;
571 *xptr = real_x;
572 *yptr = real_y;
578 /* Gamma-correct COLOR on frame F. */
580 void
581 gamma_correct (struct frame *f, XColor *color)
583 if (f->gamma)
585 color->red = pow (color->red / 65535.0, f->gamma) * 65535.0 + 0.5;
586 color->green = pow (color->green / 65535.0, f->gamma) * 65535.0 + 0.5;
587 color->blue = pow (color->blue / 65535.0, f->gamma) * 65535.0 + 0.5;
592 /* Decide if color named COLOR_NAME is valid for use on frame F. If
593 so, return the RGB values in COLOR. If ALLOC_P is non-zero,
594 allocate the color. Value is zero if COLOR_NAME is invalid, or
595 no color could be allocated. */
598 x_defined_color (struct frame *f, const char *color_name,
599 XColor *color, int alloc_p)
601 int success_p = 0;
602 Display *dpy = FRAME_X_DISPLAY (f);
603 Colormap cmap = FRAME_X_COLORMAP (f);
605 BLOCK_INPUT;
606 #ifdef USE_GTK
607 success_p = xg_check_special_colors (f, color_name, color);
608 #endif
609 if (!success_p)
610 success_p = XParseColor (dpy, cmap, color_name, color);
611 if (success_p && alloc_p)
612 success_p = x_alloc_nearest_color (f, cmap, color);
613 UNBLOCK_INPUT;
615 return success_p;
619 /* Return the pixel color value for color COLOR_NAME on frame F. If F
620 is a monochrome frame, return MONO_COLOR regardless of what ARG says.
621 Signal an error if color can't be allocated. */
623 static int
624 x_decode_color (FRAME_PTR f, Lisp_Object color_name, int mono_color)
626 XColor cdef;
628 CHECK_STRING (color_name);
630 #if 0 /* Don't do this. It's wrong when we're not using the default
631 colormap, it makes freeing difficult, and it's probably not
632 an important optimization. */
633 if (strcmp (SDATA (color_name), "black") == 0)
634 return BLACK_PIX_DEFAULT (f);
635 else if (strcmp (SDATA (color_name), "white") == 0)
636 return WHITE_PIX_DEFAULT (f);
637 #endif
639 /* Return MONO_COLOR for monochrome frames. */
640 if (FRAME_X_DISPLAY_INFO (f)->n_planes == 1)
641 return mono_color;
643 /* x_defined_color is responsible for coping with failures
644 by looking for a near-miss. */
645 if (x_defined_color (f, SSDATA (color_name), &cdef, 1))
646 return cdef.pixel;
648 signal_error ("Undefined color", color_name);
653 /* Change the `wait-for-wm' frame parameter of frame F. OLD_VALUE is
654 the previous value of that parameter, NEW_VALUE is the new value.
655 See also the comment of wait_for_wm in struct x_output. */
657 static void
658 x_set_wait_for_wm (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
660 f->output_data.x->wait_for_wm = !NILP (new_value);
663 static void
664 x_set_tool_bar_position (struct frame *f,
665 Lisp_Object new_value,
666 Lisp_Object old_value)
668 if (! EQ (new_value, Qleft) && ! EQ (new_value, Qright)
669 && ! EQ (new_value, Qbottom) && ! EQ (new_value, Qtop))
670 return;
671 if (EQ (new_value, old_value)) return;
673 #ifdef USE_GTK
674 if (xg_change_toolbar_position (f, new_value))
675 f->tool_bar_position = new_value;
676 #endif
679 #ifdef USE_GTK
681 /* Set icon from FILE for frame F. By using GTK functions the icon
682 may be any format that GdkPixbuf knows about, i.e. not just bitmaps. */
685 xg_set_icon (FRAME_PTR f, Lisp_Object file)
687 int result = 0;
688 Lisp_Object found;
690 found = x_find_image_file (file);
692 if (! NILP (found))
694 GdkPixbuf *pixbuf;
695 GError *err = NULL;
696 char *filename = SSDATA (found);
697 BLOCK_INPUT;
699 pixbuf = gdk_pixbuf_new_from_file (filename, &err);
701 if (pixbuf)
703 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
704 pixbuf);
705 g_object_unref (pixbuf);
707 result = 1;
709 else
710 g_error_free (err);
712 UNBLOCK_INPUT;
715 return result;
719 xg_set_icon_from_xpm_data (FRAME_PTR f, const char **data)
721 GdkPixbuf *pixbuf = gdk_pixbuf_new_from_xpm_data (data);
723 if (!pixbuf)
724 return 0;
726 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)), pixbuf);
727 g_object_unref (pixbuf);
728 return 1;
730 #endif /* USE_GTK */
733 /* Functions called only from `x_set_frame_param'
734 to set individual parameters.
736 If FRAME_X_WINDOW (f) is 0,
737 the frame is being created and its X-window does not exist yet.
738 In that case, just record the parameter's new value
739 in the standard place; do not attempt to change the window. */
741 static void
742 x_set_foreground_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
744 struct x_output *x = f->output_data.x;
745 unsigned long fg, old_fg;
747 fg = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
748 old_fg = FRAME_FOREGROUND_PIXEL (f);
749 FRAME_FOREGROUND_PIXEL (f) = fg;
751 if (FRAME_X_WINDOW (f) != 0)
753 Display *dpy = FRAME_X_DISPLAY (f);
755 BLOCK_INPUT;
756 XSetForeground (dpy, x->normal_gc, fg);
757 XSetBackground (dpy, x->reverse_gc, fg);
759 if (x->cursor_pixel == old_fg)
761 unload_color (f, x->cursor_pixel);
762 x->cursor_pixel = x_copy_color (f, fg);
763 XSetBackground (dpy, x->cursor_gc, x->cursor_pixel);
766 UNBLOCK_INPUT;
768 update_face_from_frame_parameter (f, Qforeground_color, arg);
770 if (FRAME_VISIBLE_P (f))
771 redraw_frame (f);
774 unload_color (f, old_fg);
777 static void
778 x_set_background_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
780 struct x_output *x = f->output_data.x;
781 unsigned long bg;
783 bg = x_decode_color (f, arg, WHITE_PIX_DEFAULT (f));
784 unload_color (f, FRAME_BACKGROUND_PIXEL (f));
785 FRAME_BACKGROUND_PIXEL (f) = bg;
787 if (FRAME_X_WINDOW (f) != 0)
789 Display *dpy = FRAME_X_DISPLAY (f);
791 BLOCK_INPUT;
792 XSetBackground (dpy, x->normal_gc, bg);
793 XSetForeground (dpy, x->reverse_gc, bg);
794 XSetWindowBackground (dpy, FRAME_X_WINDOW (f), bg);
795 XSetForeground (dpy, x->cursor_gc, bg);
797 #ifdef USE_GTK
798 xg_set_background_color (f, bg);
799 #endif
801 #ifndef USE_TOOLKIT_SCROLL_BARS /* Turns out to be annoying with
802 toolkit scroll bars. */
804 Lisp_Object bar;
805 for (bar = FRAME_SCROLL_BARS (f);
806 !NILP (bar);
807 bar = XSCROLL_BAR (bar)->next)
809 Window window = XSCROLL_BAR (bar)->x_window;
810 XSetWindowBackground (dpy, window, bg);
813 #endif /* USE_TOOLKIT_SCROLL_BARS */
815 UNBLOCK_INPUT;
816 update_face_from_frame_parameter (f, Qbackground_color, arg);
818 if (FRAME_VISIBLE_P (f))
819 redraw_frame (f);
823 static Cursor
824 make_invisible_cursor (struct frame *f)
826 Display *dpy = FRAME_X_DISPLAY (f);
827 static char const no_data[] = { 0 };
828 Pixmap pix;
829 XColor col;
830 Cursor c = 0;
832 x_catch_errors (dpy);
833 pix = XCreateBitmapFromData (dpy, FRAME_X_DISPLAY_INFO (f)->root_window,
834 no_data, 1, 1);
835 if (! x_had_errors_p (dpy) && pix != None)
837 Cursor pixc;
838 col.pixel = 0;
839 col.red = col.green = col.blue = 0;
840 col.flags = DoRed | DoGreen | DoBlue;
841 pixc = XCreatePixmapCursor (dpy, pix, pix, &col, &col, 0, 0);
842 if (! x_had_errors_p (dpy) && pixc != None)
843 c = pixc;
844 XFreePixmap (dpy, pix);
847 x_uncatch_errors ();
849 return c;
852 static void
853 x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
855 struct x_output *x = f->output_data.x;
856 Display *dpy = FRAME_X_DISPLAY (f);
857 Cursor cursor, nontext_cursor, mode_cursor, hand_cursor;
858 Cursor hourglass_cursor, horizontal_drag_cursor;
859 unsigned long pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
860 unsigned long mask_color = FRAME_BACKGROUND_PIXEL (f);
862 /* Don't let pointers be invisible. */
863 if (mask_color == pixel)
865 x_free_colors (f, &pixel, 1);
866 pixel = x_copy_color (f, FRAME_FOREGROUND_PIXEL (f));
869 unload_color (f, x->mouse_pixel);
870 x->mouse_pixel = pixel;
872 BLOCK_INPUT;
874 /* It's not okay to crash if the user selects a screwy cursor. */
875 x_catch_errors (dpy);
877 if (!NILP (Vx_pointer_shape))
879 CHECK_NUMBER (Vx_pointer_shape);
880 cursor = XCreateFontCursor (dpy, XINT (Vx_pointer_shape));
882 else
883 cursor = XCreateFontCursor (dpy, XC_xterm);
884 x_check_errors (dpy, "bad text pointer cursor: %s");
886 if (!NILP (Vx_nontext_pointer_shape))
888 CHECK_NUMBER (Vx_nontext_pointer_shape);
889 nontext_cursor
890 = XCreateFontCursor (dpy, XINT (Vx_nontext_pointer_shape));
892 else
893 nontext_cursor = XCreateFontCursor (dpy, XC_left_ptr);
894 x_check_errors (dpy, "bad nontext pointer cursor: %s");
896 if (!NILP (Vx_hourglass_pointer_shape))
898 CHECK_NUMBER (Vx_hourglass_pointer_shape);
899 hourglass_cursor
900 = XCreateFontCursor (dpy, XINT (Vx_hourglass_pointer_shape));
902 else
903 hourglass_cursor = XCreateFontCursor (dpy, XC_watch);
904 x_check_errors (dpy, "bad hourglass pointer cursor: %s");
906 if (!NILP (Vx_mode_pointer_shape))
908 CHECK_NUMBER (Vx_mode_pointer_shape);
909 mode_cursor = XCreateFontCursor (dpy, XINT (Vx_mode_pointer_shape));
911 else
912 mode_cursor = XCreateFontCursor (dpy, XC_xterm);
913 x_check_errors (dpy, "bad modeline pointer cursor: %s");
915 if (!NILP (Vx_sensitive_text_pointer_shape))
917 CHECK_NUMBER (Vx_sensitive_text_pointer_shape);
918 hand_cursor
919 = XCreateFontCursor (dpy, XINT (Vx_sensitive_text_pointer_shape));
921 else
922 hand_cursor = XCreateFontCursor (dpy, XC_hand2);
924 if (!NILP (Vx_window_horizontal_drag_shape))
926 CHECK_NUMBER (Vx_window_horizontal_drag_shape);
927 horizontal_drag_cursor
928 = XCreateFontCursor (dpy, XINT (Vx_window_horizontal_drag_shape));
930 else
931 horizontal_drag_cursor
932 = XCreateFontCursor (dpy, XC_sb_h_double_arrow);
934 /* Check and report errors with the above calls. */
935 x_check_errors (dpy, "can't set cursor shape: %s");
936 x_uncatch_errors ();
939 XColor fore_color, back_color;
941 fore_color.pixel = x->mouse_pixel;
942 x_query_color (f, &fore_color);
943 back_color.pixel = mask_color;
944 x_query_color (f, &back_color);
946 XRecolorCursor (dpy, cursor, &fore_color, &back_color);
947 XRecolorCursor (dpy, nontext_cursor, &fore_color, &back_color);
948 XRecolorCursor (dpy, mode_cursor, &fore_color, &back_color);
949 XRecolorCursor (dpy, hand_cursor, &fore_color, &back_color);
950 XRecolorCursor (dpy, hourglass_cursor, &fore_color, &back_color);
951 XRecolorCursor (dpy, horizontal_drag_cursor, &fore_color, &back_color);
954 if (FRAME_X_WINDOW (f) != 0)
955 XDefineCursor (dpy, FRAME_X_WINDOW (f),
956 f->output_data.x->current_cursor = cursor);
958 if (FRAME_X_DISPLAY_INFO (f)->invisible_cursor == 0)
959 FRAME_X_DISPLAY_INFO (f)->invisible_cursor = make_invisible_cursor (f);
961 if (cursor != x->text_cursor
962 && x->text_cursor != 0)
963 XFreeCursor (dpy, x->text_cursor);
964 x->text_cursor = cursor;
966 if (nontext_cursor != x->nontext_cursor
967 && x->nontext_cursor != 0)
968 XFreeCursor (dpy, x->nontext_cursor);
969 x->nontext_cursor = nontext_cursor;
971 if (hourglass_cursor != x->hourglass_cursor
972 && x->hourglass_cursor != 0)
973 XFreeCursor (dpy, x->hourglass_cursor);
974 x->hourglass_cursor = hourglass_cursor;
976 if (mode_cursor != x->modeline_cursor
977 && x->modeline_cursor != 0)
978 XFreeCursor (dpy, f->output_data.x->modeline_cursor);
979 x->modeline_cursor = mode_cursor;
981 if (hand_cursor != x->hand_cursor
982 && x->hand_cursor != 0)
983 XFreeCursor (dpy, x->hand_cursor);
984 x->hand_cursor = hand_cursor;
986 if (horizontal_drag_cursor != x->horizontal_drag_cursor
987 && x->horizontal_drag_cursor != 0)
988 XFreeCursor (dpy, x->horizontal_drag_cursor);
989 x->horizontal_drag_cursor = horizontal_drag_cursor;
991 XFlush (dpy);
992 UNBLOCK_INPUT;
994 update_face_from_frame_parameter (f, Qmouse_color, arg);
997 static void
998 x_set_cursor_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1000 unsigned long fore_pixel, pixel;
1001 int fore_pixel_allocated_p = 0, pixel_allocated_p = 0;
1002 struct x_output *x = f->output_data.x;
1004 if (!NILP (Vx_cursor_fore_pixel))
1006 fore_pixel = x_decode_color (f, Vx_cursor_fore_pixel,
1007 WHITE_PIX_DEFAULT (f));
1008 fore_pixel_allocated_p = 1;
1010 else
1011 fore_pixel = FRAME_BACKGROUND_PIXEL (f);
1013 pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
1014 pixel_allocated_p = 1;
1016 /* Make sure that the cursor color differs from the background color. */
1017 if (pixel == FRAME_BACKGROUND_PIXEL (f))
1019 if (pixel_allocated_p)
1021 x_free_colors (f, &pixel, 1);
1022 pixel_allocated_p = 0;
1025 pixel = x->mouse_pixel;
1026 if (pixel == fore_pixel)
1028 if (fore_pixel_allocated_p)
1030 x_free_colors (f, &fore_pixel, 1);
1031 fore_pixel_allocated_p = 0;
1033 fore_pixel = FRAME_BACKGROUND_PIXEL (f);
1037 unload_color (f, x->cursor_foreground_pixel);
1038 if (!fore_pixel_allocated_p)
1039 fore_pixel = x_copy_color (f, fore_pixel);
1040 x->cursor_foreground_pixel = fore_pixel;
1042 unload_color (f, x->cursor_pixel);
1043 if (!pixel_allocated_p)
1044 pixel = x_copy_color (f, pixel);
1045 x->cursor_pixel = pixel;
1047 if (FRAME_X_WINDOW (f) != 0)
1049 BLOCK_INPUT;
1050 XSetBackground (FRAME_X_DISPLAY (f), x->cursor_gc, x->cursor_pixel);
1051 XSetForeground (FRAME_X_DISPLAY (f), x->cursor_gc, fore_pixel);
1052 UNBLOCK_INPUT;
1054 if (FRAME_VISIBLE_P (f))
1056 x_update_cursor (f, 0);
1057 x_update_cursor (f, 1);
1061 update_face_from_frame_parameter (f, Qcursor_color, arg);
1064 /* Set the border-color of frame F to pixel value PIX.
1065 Note that this does not fully take effect if done before
1066 F has an x-window. */
1068 static void
1069 x_set_border_pixel (struct frame *f, int pix)
1071 unload_color (f, f->output_data.x->border_pixel);
1072 f->output_data.x->border_pixel = pix;
1074 if (FRAME_X_WINDOW (f) != 0 && f->border_width > 0)
1076 BLOCK_INPUT;
1077 XSetWindowBorder (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), pix);
1078 UNBLOCK_INPUT;
1080 if (FRAME_VISIBLE_P (f))
1081 redraw_frame (f);
1085 /* Set the border-color of frame F to value described by ARG.
1086 ARG can be a string naming a color.
1087 The border-color is used for the border that is drawn by the X server.
1088 Note that this does not fully take effect if done before
1089 F has an x-window; it must be redone when the window is created.
1091 Note: this is done in two routines because of the way X10 works.
1093 Note: under X11, this is normally the province of the window manager,
1094 and so emacs' border colors may be overridden. */
1096 static void
1097 x_set_border_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1099 int pix;
1101 CHECK_STRING (arg);
1102 pix = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
1103 x_set_border_pixel (f, pix);
1104 update_face_from_frame_parameter (f, Qborder_color, arg);
1108 static void
1109 x_set_cursor_type (FRAME_PTR f, Lisp_Object arg, Lisp_Object oldval)
1111 set_frame_cursor_types (f, arg);
1113 /* Make sure the cursor gets redrawn. */
1114 cursor_type_changed = 1;
1117 static void
1118 x_set_icon_type (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1120 int result;
1122 if (STRINGP (arg))
1124 if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
1125 return;
1127 else if (!STRINGP (oldval) && EQ (oldval, Qnil) == EQ (arg, Qnil))
1128 return;
1130 BLOCK_INPUT;
1131 if (NILP (arg))
1132 result = x_text_icon (f,
1133 SSDATA ((!NILP (f->icon_name)
1134 ? f->icon_name
1135 : f->name)));
1136 else
1137 result = x_bitmap_icon (f, arg);
1139 if (result)
1141 UNBLOCK_INPUT;
1142 error ("No icon window available");
1145 XFlush (FRAME_X_DISPLAY (f));
1146 UNBLOCK_INPUT;
1149 static void
1150 x_set_icon_name (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1152 int result;
1154 if (STRINGP (arg))
1156 if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
1157 return;
1159 else if (!NILP (arg) || NILP (oldval))
1160 return;
1162 f->icon_name = arg;
1164 if (f->output_data.x->icon_bitmap != 0)
1165 return;
1167 BLOCK_INPUT;
1169 result = x_text_icon (f,
1170 SSDATA ((!NILP (f->icon_name)
1171 ? f->icon_name
1172 : !NILP (f->title)
1173 ? f->title
1174 : f->name)));
1176 if (result)
1178 UNBLOCK_INPUT;
1179 error ("No icon window available");
1182 XFlush (FRAME_X_DISPLAY (f));
1183 UNBLOCK_INPUT;
1187 void
1188 x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
1190 int nlines;
1191 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1192 int olines = FRAME_MENU_BAR_LINES (f);
1193 #endif
1195 /* Right now, menu bars don't work properly in minibuf-only frames;
1196 most of the commands try to apply themselves to the minibuffer
1197 frame itself, and get an error because you can't switch buffers
1198 in or split the minibuffer window. */
1199 if (FRAME_MINIBUF_ONLY_P (f))
1200 return;
1202 if (INTEGERP (value))
1203 nlines = XINT (value);
1204 else
1205 nlines = 0;
1207 /* Make sure we redisplay all windows in this frame. */
1208 windows_or_buffers_changed++;
1210 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1211 FRAME_MENU_BAR_LINES (f) = 0;
1212 if (nlines)
1214 FRAME_EXTERNAL_MENU_BAR (f) = 1;
1215 if (FRAME_X_P (f) && f->output_data.x->menubar_widget == 0)
1216 /* Make sure next redisplay shows the menu bar. */
1217 XWINDOW (FRAME_SELECTED_WINDOW (f))->update_mode_line = Qt;
1219 else
1221 if (FRAME_EXTERNAL_MENU_BAR (f) == 1)
1222 free_frame_menubar (f);
1223 FRAME_EXTERNAL_MENU_BAR (f) = 0;
1224 if (FRAME_X_P (f))
1225 f->output_data.x->menubar_widget = 0;
1227 #else /* not USE_X_TOOLKIT && not USE_GTK */
1228 FRAME_MENU_BAR_LINES (f) = nlines;
1229 resize_frame_windows (f, FRAME_LINES (f), 0);
1231 /* If the menu bar height gets changed, the internal border below
1232 the top margin has to be cleared. Also, if the menu bar gets
1233 larger, the area for the added lines has to be cleared except for
1234 the first menu bar line that is to be drawn later. */
1235 if (nlines != olines)
1237 int height = FRAME_INTERNAL_BORDER_WIDTH (f);
1238 int width = FRAME_PIXEL_WIDTH (f);
1239 int y;
1241 /* height can be zero here. */
1242 if (height > 0 && width > 0)
1244 y = FRAME_TOP_MARGIN_HEIGHT (f);
1246 BLOCK_INPUT;
1247 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1248 0, y, width, height, False);
1249 UNBLOCK_INPUT;
1252 if (nlines > 1 && nlines > olines)
1254 y = (olines == 0 ? 1 : olines) * FRAME_LINE_HEIGHT (f);
1255 height = nlines * FRAME_LINE_HEIGHT (f) - y;
1257 BLOCK_INPUT;
1258 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1259 0, y, width, height, False);
1260 UNBLOCK_INPUT;
1263 if (nlines == 0 && WINDOWP (f->menu_bar_window))
1264 clear_glyph_matrix (XWINDOW (f->menu_bar_window)->current_matrix);
1266 #endif /* not USE_X_TOOLKIT && not USE_GTK */
1267 adjust_glyphs (f);
1268 run_window_configuration_change_hook (f);
1272 /* Set the number of lines used for the tool bar of frame F to VALUE.
1273 VALUE not an integer, or < 0 means set the lines to zero. OLDVAL
1274 is the old number of tool bar lines. This function changes the
1275 height of all windows on frame F to match the new tool bar height.
1276 The frame's height doesn't change. */
1278 void
1279 x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
1281 int delta, nlines, root_height;
1282 Lisp_Object root_window;
1284 /* Treat tool bars like menu bars. */
1285 if (FRAME_MINIBUF_ONLY_P (f))
1286 return;
1288 /* Use VALUE only if an integer >= 0. */
1289 if (INTEGERP (value) && XINT (value) >= 0)
1290 nlines = XFASTINT (value);
1291 else
1292 nlines = 0;
1294 #ifdef USE_GTK
1295 FRAME_TOOL_BAR_LINES (f) = 0;
1296 if (nlines)
1298 FRAME_EXTERNAL_TOOL_BAR (f) = 1;
1299 if (FRAME_X_P (f) && f->output_data.x->toolbar_widget == 0)
1300 /* Make sure next redisplay shows the tool bar. */
1301 XWINDOW (FRAME_SELECTED_WINDOW (f))->update_mode_line = Qt;
1302 update_frame_tool_bar (f);
1304 else
1306 if (FRAME_EXTERNAL_TOOL_BAR (f))
1307 free_frame_tool_bar (f);
1308 FRAME_EXTERNAL_TOOL_BAR (f) = 0;
1311 return;
1312 #endif
1314 /* Make sure we redisplay all windows in this frame. */
1315 ++windows_or_buffers_changed;
1317 delta = nlines - FRAME_TOOL_BAR_LINES (f);
1319 /* Don't resize the tool-bar to more than we have room for. */
1320 root_window = FRAME_ROOT_WINDOW (f);
1321 root_height = WINDOW_TOTAL_LINES (XWINDOW (root_window));
1322 if (root_height - delta < 1)
1324 delta = root_height - 1;
1325 nlines = FRAME_TOOL_BAR_LINES (f) + delta;
1328 FRAME_TOOL_BAR_LINES (f) = nlines;
1329 resize_frame_windows (f, FRAME_LINES (f), 0);
1330 adjust_glyphs (f);
1332 /* We also have to make sure that the internal border at the top of
1333 the frame, below the menu bar or tool bar, is redrawn when the
1334 tool bar disappears. This is so because the internal border is
1335 below the tool bar if one is displayed, but is below the menu bar
1336 if there isn't a tool bar. The tool bar draws into the area
1337 below the menu bar. */
1338 if (FRAME_X_WINDOW (f) && FRAME_TOOL_BAR_LINES (f) == 0)
1340 clear_frame (f);
1341 clear_current_matrices (f);
1344 /* If the tool bar gets smaller, the internal border below it
1345 has to be cleared. It was formerly part of the display
1346 of the larger tool bar, and updating windows won't clear it. */
1347 if (delta < 0)
1349 int height = FRAME_INTERNAL_BORDER_WIDTH (f);
1350 int width = FRAME_PIXEL_WIDTH (f);
1351 int y = (FRAME_MENU_BAR_LINES (f) + nlines) * FRAME_LINE_HEIGHT (f);
1353 /* height can be zero here. */
1354 if (height > 0 && width > 0)
1356 BLOCK_INPUT;
1357 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1358 0, y, width, height, False);
1359 UNBLOCK_INPUT;
1362 if (WINDOWP (f->tool_bar_window))
1363 clear_glyph_matrix (XWINDOW (f->tool_bar_window)->current_matrix);
1366 run_window_configuration_change_hook (f);
1371 /* Set the foreground color for scroll bars on frame F to VALUE.
1372 VALUE should be a string, a color name. If it isn't a string or
1373 isn't a valid color name, do nothing. OLDVAL is the old value of
1374 the frame parameter. */
1376 static void
1377 x_set_scroll_bar_foreground (struct frame *f, Lisp_Object value, Lisp_Object oldval)
1379 unsigned long pixel;
1381 if (STRINGP (value))
1382 pixel = x_decode_color (f, value, BLACK_PIX_DEFAULT (f));
1383 else
1384 pixel = -1;
1386 if (f->output_data.x->scroll_bar_foreground_pixel != -1)
1387 unload_color (f, f->output_data.x->scroll_bar_foreground_pixel);
1389 f->output_data.x->scroll_bar_foreground_pixel = pixel;
1390 if (FRAME_X_WINDOW (f) && FRAME_VISIBLE_P (f))
1392 /* Remove all scroll bars because they have wrong colors. */
1393 if (FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
1394 (*FRAME_TERMINAL (f)->condemn_scroll_bars_hook) (f);
1395 if (FRAME_TERMINAL (f)->judge_scroll_bars_hook)
1396 (*FRAME_TERMINAL (f)->judge_scroll_bars_hook) (f);
1398 update_face_from_frame_parameter (f, Qscroll_bar_foreground, value);
1399 redraw_frame (f);
1404 /* Set the background color for scroll bars on frame F to VALUE VALUE
1405 should be a string, a color name. If it isn't a string or isn't a
1406 valid color name, do nothing. OLDVAL is the old value of the frame
1407 parameter. */
1409 static void
1410 x_set_scroll_bar_background (struct frame *f, Lisp_Object value, Lisp_Object oldval)
1412 unsigned long pixel;
1414 if (STRINGP (value))
1415 pixel = x_decode_color (f, value, WHITE_PIX_DEFAULT (f));
1416 else
1417 pixel = -1;
1419 if (f->output_data.x->scroll_bar_background_pixel != -1)
1420 unload_color (f, f->output_data.x->scroll_bar_background_pixel);
1422 #ifdef USE_TOOLKIT_SCROLL_BARS
1423 /* Scrollbar shadow colors. */
1424 if (f->output_data.x->scroll_bar_top_shadow_pixel != -1)
1426 unload_color (f, f->output_data.x->scroll_bar_top_shadow_pixel);
1427 f->output_data.x->scroll_bar_top_shadow_pixel = -1;
1429 if (f->output_data.x->scroll_bar_bottom_shadow_pixel != -1)
1431 unload_color (f, f->output_data.x->scroll_bar_bottom_shadow_pixel);
1432 f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
1434 #endif /* USE_TOOLKIT_SCROLL_BARS */
1436 f->output_data.x->scroll_bar_background_pixel = pixel;
1437 if (FRAME_X_WINDOW (f) && FRAME_VISIBLE_P (f))
1439 /* Remove all scroll bars because they have wrong colors. */
1440 if (FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
1441 (*FRAME_TERMINAL (f)->condemn_scroll_bars_hook) (f);
1442 if (FRAME_TERMINAL (f)->judge_scroll_bars_hook)
1443 (*FRAME_TERMINAL (f)->judge_scroll_bars_hook) (f);
1445 update_face_from_frame_parameter (f, Qscroll_bar_background, value);
1446 redraw_frame (f);
1451 /* Encode Lisp string STRING as a text in a format appropriate for
1452 XICCC (X Inter Client Communication Conventions).
1454 This can call Lisp code, so callers must GCPRO.
1456 If STRING contains only ASCII characters, do no conversion and
1457 return the string data of STRING. Otherwise, encode the text by
1458 CODING_SYSTEM, and return a newly allocated memory area which
1459 should be freed by `xfree' by a caller.
1461 SELECTIONP non-zero means the string is being encoded for an X
1462 selection, so it is safe to run pre-write conversions (which
1463 may run Lisp code).
1465 Store the byte length of resulting text in *TEXT_BYTES.
1467 If the text contains only ASCII and Latin-1, store 1 in *STRING_P,
1468 which means that the `encoding' of the result can be `STRING'.
1469 Otherwise store 0 in *STRINGP, which means that the `encoding' of
1470 the result should be `COMPOUND_TEXT'. */
1472 static unsigned char *
1473 x_encode_text (Lisp_Object string, Lisp_Object coding_system, int selectionp, int *text_bytes, int *stringp, int *freep)
1475 int result = string_xstring_p (string);
1476 struct coding_system coding;
1478 if (result == 0)
1480 /* No multibyte character in OBJ. We need not encode it. */
1481 *text_bytes = SBYTES (string);
1482 *stringp = 1;
1483 *freep = 0;
1484 return SDATA (string);
1487 setup_coding_system (coding_system, &coding);
1488 coding.mode |= (CODING_MODE_SAFE_ENCODING | CODING_MODE_LAST_BLOCK);
1489 /* We suppress producing escape sequences for composition. */
1490 coding.common_flags &= ~CODING_ANNOTATION_MASK;
1491 coding.dst_bytes = SCHARS (string) * 2;
1492 coding.destination = (unsigned char *) xmalloc (coding.dst_bytes);
1493 encode_coding_object (&coding, string, 0, 0,
1494 SCHARS (string), SBYTES (string), Qnil);
1495 *text_bytes = coding.produced;
1496 *stringp = (result == 1 || !EQ (coding_system, Qcompound_text));
1497 *freep = 1;
1498 return coding.destination;
1502 /* Set the WM name to NAME for frame F. Also set the icon name.
1503 If the frame already has an icon name, use that, otherwise set the
1504 icon name to NAME. */
1506 static void
1507 x_set_name_internal (FRAME_PTR f, Lisp_Object name)
1509 if (FRAME_X_WINDOW (f))
1511 BLOCK_INPUT;
1513 XTextProperty text, icon;
1514 int bytes, stringp;
1515 int do_free_icon_value = 0, do_free_text_value = 0;
1516 Lisp_Object coding_system;
1517 Lisp_Object encoded_name;
1518 Lisp_Object encoded_icon_name;
1519 struct gcpro gcpro1;
1521 /* As ENCODE_UTF_8 may cause GC and relocation of string data,
1522 we use it before x_encode_text that may return string data. */
1523 GCPRO1 (name);
1524 encoded_name = ENCODE_UTF_8 (name);
1525 UNGCPRO;
1527 coding_system = Qcompound_text;
1528 /* Note: Encoding strategy
1530 We encode NAME by compound-text and use "COMPOUND-TEXT" in
1531 text.encoding. But, there are non-internationalized window
1532 managers which don't support that encoding. So, if NAME
1533 contains only ASCII and 8859-1 characters, encode it by
1534 iso-latin-1, and use "STRING" in text.encoding hoping that
1535 such window managers at least analyze this format correctly,
1536 i.e. treat 8-bit bytes as 8859-1 characters.
1538 We may also be able to use "UTF8_STRING" in text.encoding
1539 in the future which can encode all Unicode characters.
1540 But, for the moment, there's no way to know that the
1541 current window manager supports it or not.
1543 Either way, we also set the _NET_WM_NAME and _NET_WM_ICON_NAME
1544 properties. Per the EWMH specification, those two properties
1545 are always UTF8_STRING. This matches what gtk_window_set_title()
1546 does in the USE_GTK case. */
1547 text.value = x_encode_text (name, coding_system, 0, &bytes, &stringp,
1548 &do_free_text_value);
1549 text.encoding = (stringp ? XA_STRING
1550 : FRAME_X_DISPLAY_INFO (f)->Xatom_COMPOUND_TEXT);
1551 text.format = 8;
1552 text.nitems = bytes;
1554 if (!STRINGP (f->icon_name))
1556 icon = text;
1557 encoded_icon_name = encoded_name;
1559 else
1561 /* See the above comment "Note: Encoding strategy". */
1562 icon.value = x_encode_text (f->icon_name, coding_system, 0,
1563 &bytes, &stringp, &do_free_icon_value);
1564 icon.encoding = (stringp ? XA_STRING
1565 : FRAME_X_DISPLAY_INFO (f)->Xatom_COMPOUND_TEXT);
1566 icon.format = 8;
1567 icon.nitems = bytes;
1569 encoded_icon_name = ENCODE_UTF_8 (f->icon_name);
1572 #ifdef USE_GTK
1573 gtk_window_set_title (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
1574 SSDATA (encoded_name));
1575 #else /* not USE_GTK */
1576 XSetWMName (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &text);
1577 XChangeProperty (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
1578 FRAME_X_DISPLAY_INFO (f)->Xatom_net_wm_name,
1579 FRAME_X_DISPLAY_INFO (f)->Xatom_UTF8_STRING,
1580 8, PropModeReplace,
1581 SDATA (encoded_name),
1582 SBYTES (encoded_name));
1583 #endif /* not USE_GTK */
1585 XSetWMIconName (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &icon);
1586 XChangeProperty (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
1587 FRAME_X_DISPLAY_INFO (f)->Xatom_net_wm_icon_name,
1588 FRAME_X_DISPLAY_INFO (f)->Xatom_UTF8_STRING,
1589 8, PropModeReplace,
1590 SDATA (encoded_icon_name),
1591 SBYTES (encoded_icon_name));
1593 if (do_free_icon_value)
1594 xfree (icon.value);
1595 if (do_free_text_value)
1596 xfree (text.value);
1598 UNBLOCK_INPUT;
1602 /* Change the name of frame F to NAME. If NAME is nil, set F's name to
1603 x_id_name.
1605 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1606 name; if NAME is a string, set F's name to NAME and set
1607 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1609 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1610 suggesting a new name, which lisp code should override; if
1611 F->explicit_name is set, ignore the new name; otherwise, set it. */
1613 static void
1614 x_set_name (struct frame *f, Lisp_Object name, int explicit)
1616 /* Make sure that requests from lisp code override requests from
1617 Emacs redisplay code. */
1618 if (explicit)
1620 /* If we're switching from explicit to implicit, we had better
1621 update the mode lines and thereby update the title. */
1622 if (f->explicit_name && NILP (name))
1623 update_mode_lines = 1;
1625 f->explicit_name = ! NILP (name);
1627 else if (f->explicit_name)
1628 return;
1630 /* If NAME is nil, set the name to the x_id_name. */
1631 if (NILP (name))
1633 /* Check for no change needed in this very common case
1634 before we do any consing. */
1635 if (!strcmp (FRAME_X_DISPLAY_INFO (f)->x_id_name,
1636 SSDATA (f->name)))
1637 return;
1638 name = build_string (FRAME_X_DISPLAY_INFO (f)->x_id_name);
1640 else
1641 CHECK_STRING (name);
1643 /* Don't change the name if it's already NAME. */
1644 if (! NILP (Fstring_equal (name, f->name)))
1645 return;
1647 f->name = name;
1649 /* For setting the frame title, the title parameter should override
1650 the name parameter. */
1651 if (! NILP (f->title))
1652 name = f->title;
1654 x_set_name_internal (f, name);
1657 /* This function should be called when the user's lisp code has
1658 specified a name for the frame; the name will override any set by the
1659 redisplay code. */
1660 static void
1661 x_explicitly_set_name (FRAME_PTR f, Lisp_Object arg, Lisp_Object oldval)
1663 x_set_name (f, arg, 1);
1666 /* This function should be called by Emacs redisplay code to set the
1667 name; names set this way will never override names set by the user's
1668 lisp code. */
1669 void
1670 x_implicitly_set_name (FRAME_PTR f, Lisp_Object arg, Lisp_Object oldval)
1672 x_set_name (f, arg, 0);
1675 /* Change the title of frame F to NAME.
1676 If NAME is nil, use the frame name as the title. */
1678 static void
1679 x_set_title (struct frame *f, Lisp_Object name, Lisp_Object old_name)
1681 /* Don't change the title if it's already NAME. */
1682 if (EQ (name, f->title))
1683 return;
1685 update_mode_lines = 1;
1687 f->title = name;
1689 if (NILP (name))
1690 name = f->name;
1691 else
1692 CHECK_STRING (name);
1694 x_set_name_internal (f, name);
1697 void
1698 x_set_scroll_bar_default_width (struct frame *f)
1700 int wid = FRAME_COLUMN_WIDTH (f);
1701 #ifdef USE_TOOLKIT_SCROLL_BARS
1702 #ifdef USE_GTK
1703 int minw = xg_get_default_scrollbar_width ();
1704 #else
1705 int minw = 16;
1706 #endif
1707 /* A minimum width of 14 doesn't look good for toolkit scroll bars. */
1708 int width = minw + 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM;
1709 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (width + wid - 1) / wid;
1710 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = width;
1711 #else
1712 /* Make the actual width at least 14 pixels and a multiple of a
1713 character width. */
1714 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
1716 /* Use all of that space (aside from required margins) for the
1717 scroll bar. */
1718 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = 0;
1719 #endif
1723 /* Record in frame F the specified or default value according to ALIST
1724 of the parameter named PROP (a Lisp symbol). If no value is
1725 specified for PROP, look for an X default for XPROP on the frame
1726 named NAME. If that is not found either, use the value DEFLT. */
1728 static Lisp_Object
1729 x_default_scroll_bar_color_parameter (struct frame *f,
1730 Lisp_Object alist, Lisp_Object prop,
1731 const char *xprop, const char *xclass,
1732 int foreground_p)
1734 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
1735 Lisp_Object tem;
1737 tem = x_get_arg (dpyinfo, alist, prop, xprop, xclass, RES_TYPE_STRING);
1738 if (EQ (tem, Qunbound))
1740 #ifdef USE_TOOLKIT_SCROLL_BARS
1742 /* See if an X resource for the scroll bar color has been
1743 specified. */
1744 tem = display_x_get_resource (dpyinfo,
1745 build_string (foreground_p
1746 ? "foreground"
1747 : "background"),
1748 empty_unibyte_string,
1749 build_string ("verticalScrollBar"),
1750 empty_unibyte_string);
1751 if (!STRINGP (tem))
1753 /* If nothing has been specified, scroll bars will use a
1754 toolkit-dependent default. Because these defaults are
1755 difficult to get at without actually creating a scroll
1756 bar, use nil to indicate that no color has been
1757 specified. */
1758 tem = Qnil;
1761 #else /* not USE_TOOLKIT_SCROLL_BARS */
1763 tem = Qnil;
1765 #endif /* not USE_TOOLKIT_SCROLL_BARS */
1768 x_set_frame_parameters (f, Fcons (Fcons (prop, tem), Qnil));
1769 return tem;
1775 #ifdef USE_X_TOOLKIT
1777 /* If the WM_PROTOCOLS property does not already contain WM_TAKE_FOCUS,
1778 WM_DELETE_WINDOW, and WM_SAVE_YOURSELF, then add them. (They may
1779 already be present because of the toolkit (Motif adds some of them,
1780 for example, but Xt doesn't). */
1782 static void
1783 hack_wm_protocols (FRAME_PTR f, Widget widget)
1785 Display *dpy = XtDisplay (widget);
1786 Window w = XtWindow (widget);
1787 int need_delete = 1;
1788 int need_focus = 1;
1789 int need_save = 1;
1791 BLOCK_INPUT;
1793 Atom type;
1794 unsigned char *catoms;
1795 int format = 0;
1796 unsigned long nitems = 0;
1797 unsigned long bytes_after;
1799 if ((XGetWindowProperty (dpy, w,
1800 FRAME_X_DISPLAY_INFO (f)->Xatom_wm_protocols,
1801 (long)0, (long)100, False, XA_ATOM,
1802 &type, &format, &nitems, &bytes_after,
1803 &catoms)
1804 == Success)
1805 && format == 32 && type == XA_ATOM)
1807 Atom *atoms = (Atom *) catoms;
1808 while (nitems > 0)
1810 nitems--;
1811 if (atoms[nitems]
1812 == FRAME_X_DISPLAY_INFO (f)->Xatom_wm_delete_window)
1813 need_delete = 0;
1814 else if (atoms[nitems]
1815 == FRAME_X_DISPLAY_INFO (f)->Xatom_wm_take_focus)
1816 need_focus = 0;
1817 else if (atoms[nitems]
1818 == FRAME_X_DISPLAY_INFO (f)->Xatom_wm_save_yourself)
1819 need_save = 0;
1822 if (catoms)
1823 XFree (catoms);
1826 Atom props [10];
1827 int count = 0;
1828 if (need_delete)
1829 props[count++] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_delete_window;
1830 if (need_focus)
1831 props[count++] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_take_focus;
1832 if (need_save)
1833 props[count++] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_save_yourself;
1834 if (count)
1835 XChangeProperty (dpy, w, FRAME_X_DISPLAY_INFO (f)->Xatom_wm_protocols,
1836 XA_ATOM, 32, PropModeAppend,
1837 (unsigned char *) props, count);
1839 UNBLOCK_INPUT;
1841 #endif
1845 /* Support routines for XIC (X Input Context). */
1847 #ifdef HAVE_X_I18N
1849 static XFontSet xic_create_xfontset (struct frame *);
1850 static XIMStyle best_xim_style (XIMStyles *, XIMStyles *);
1853 /* Supported XIM styles, ordered by preference. */
1855 static XIMStyle supported_xim_styles[] =
1857 XIMPreeditPosition | XIMStatusArea,
1858 XIMPreeditPosition | XIMStatusNothing,
1859 XIMPreeditPosition | XIMStatusNone,
1860 XIMPreeditNothing | XIMStatusArea,
1861 XIMPreeditNothing | XIMStatusNothing,
1862 XIMPreeditNothing | XIMStatusNone,
1863 XIMPreeditNone | XIMStatusArea,
1864 XIMPreeditNone | XIMStatusNothing,
1865 XIMPreeditNone | XIMStatusNone,
1870 #if defined HAVE_X_WINDOWS && defined USE_X_TOOLKIT
1871 /* Create an X fontset on frame F with base font name BASE_FONTNAME. */
1873 static const char xic_defaut_fontset[] = "-*-*-*-r-normal--14-*-*-*-*-*-*-*";
1875 /* Create an Xt fontset spec from the name of a base font.
1876 If `motif' is True use the Motif syntax. */
1877 char *
1878 xic_create_fontsetname (const char *base_fontname, int motif)
1880 const char *sep = motif ? ";" : ",";
1881 char *fontsetname;
1883 /* Make a fontset name from the base font name. */
1884 if (xic_defaut_fontset == base_fontname)
1885 { /* There is no base font name, use the default. */
1886 int len = strlen (base_fontname) + 2;
1887 fontsetname = xmalloc (len);
1888 memset (fontsetname, 0, len);
1889 strcpy (fontsetname, base_fontname);
1891 else
1893 /* Make a fontset name from the base font name.
1894 The font set will be made of the following elements:
1895 - the base font.
1896 - the base font where the charset spec is replaced by -*-*.
1897 - the same but with the family also replaced with -*-*-. */
1898 const char *p = base_fontname;
1899 int i;
1901 for (i = 0; *p; p++)
1902 if (*p == '-') i++;
1903 if (i != 14)
1904 { /* As the font name doesn't conform to XLFD, we can't
1905 modify it to generalize it to allcs and allfamilies.
1906 Use the specified font plus the default. */
1907 int len = strlen (base_fontname) + strlen (xic_defaut_fontset) + 3;
1908 fontsetname = xmalloc (len);
1909 memset (fontsetname, 0, len);
1910 strcpy (fontsetname, base_fontname);
1911 strcat (fontsetname, sep);
1912 strcat (fontsetname, xic_defaut_fontset);
1914 else
1916 int 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 int 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 (xfs, name, missing_list, missing_count)
2004 XFontSet xfs;
2005 char *name;
2006 char **missing_list;
2007 int missing_count;
2009 if (xfs)
2010 fprintf (stderr, "XIC Fontset created: %s\n", name);
2011 else
2013 fprintf (stderr, "XIC Fontset failed: %s\n", name);
2014 while (missing_count-- > 0)
2016 fprintf (stderr, " missing: %s\n", *missing_list);
2017 missing_list++;
2022 #endif
2024 static XFontSet
2025 xic_create_xfontset (struct frame *f)
2027 XFontSet xfs = NULL;
2028 struct font *font = FRAME_FONT (f);
2029 int pixel_size = font->pixel_size;
2030 Lisp_Object rest, frame;
2032 /* See if there is another frame already using same fontset. */
2033 FOR_EACH_FRAME (rest, frame)
2035 struct frame *cf = XFRAME (frame);
2037 if (cf != f && FRAME_LIVE_P (f) && FRAME_X_P (cf)
2038 && FRAME_X_DISPLAY_INFO (cf) == FRAME_X_DISPLAY_INFO (f)
2039 && FRAME_FONT (f)
2040 && FRAME_FONT (f)->pixel_size == pixel_size)
2042 xfs = FRAME_XIC_FONTSET (cf);
2043 break;
2047 if (! xfs)
2049 char buf[256];
2050 char **missing_list;
2051 int missing_count;
2052 char *def_string;
2053 const char *xlfd_format = "-*-*-medium-r-normal--%d-*-*-*-*-*";
2055 sprintf (buf, xlfd_format, pixel_size);
2056 missing_list = NULL;
2057 xfs = XCreateFontSet (FRAME_X_DISPLAY (f), buf,
2058 &missing_list, &missing_count, &def_string);
2059 #ifdef DEBUG_XIC_FONTSET
2060 print_fontset_result (xfs, buf, missing_list, missing_count);
2061 #endif
2062 if (missing_list)
2063 XFreeStringList (missing_list);
2064 if (! xfs)
2066 /* List of pixel sizes most likely available. Find one that
2067 is closest to pixel_size. */
2068 int sizes[] = {0, 8, 10, 11, 12, 14, 17, 18, 20, 24, 26, 34, 0};
2069 int *smaller, *larger;
2071 for (smaller = sizes; smaller[1]; smaller++)
2072 if (smaller[1] >= pixel_size)
2073 break;
2074 larger = smaller + 1;
2075 if (*larger == pixel_size)
2076 larger++;
2077 while (*smaller || *larger)
2079 int this_size;
2081 if (! *larger)
2082 this_size = *smaller--;
2083 else if (! *smaller)
2084 this_size = *larger++;
2085 else if (pixel_size - *smaller < *larger - pixel_size)
2086 this_size = *smaller--;
2087 else
2088 this_size = *larger++;
2089 sprintf (buf, xlfd_format, this_size);
2090 missing_list = NULL;
2091 xfs = XCreateFontSet (FRAME_X_DISPLAY (f), buf,
2092 &missing_list, &missing_count, &def_string);
2093 #ifdef DEBUG_XIC_FONTSET
2094 print_fontset_result (xfs, buf, missing_list, missing_count);
2095 #endif
2096 if (missing_list)
2097 XFreeStringList (missing_list);
2098 if (xfs)
2099 break;
2102 if (! xfs)
2104 const char *last_resort = "-*-*-*-r-normal--*-*-*-*-*-*";
2106 missing_list = NULL;
2107 xfs = XCreateFontSet (FRAME_X_DISPLAY (f), last_resort,
2108 &missing_list, &missing_count, &def_string);
2109 #ifdef DEBUG_XIC_FONTSET
2110 print_fontset_result (xfs, last_resort, missing_list, missing_count);
2111 #endif
2112 if (missing_list)
2113 XFreeStringList (missing_list);
2118 return xfs;
2121 /* Free the X fontset of frame F if it is the last frame using it. */
2123 void
2124 xic_free_xfontset (struct frame *f)
2126 Lisp_Object rest, frame;
2127 int shared_p = 0;
2129 if (!FRAME_XIC_FONTSET (f))
2130 return;
2132 /* See if there is another frame sharing the same fontset. */
2133 FOR_EACH_FRAME (rest, frame)
2135 struct frame *cf = XFRAME (frame);
2136 if (cf != f && FRAME_LIVE_P (f) && FRAME_X_P (cf)
2137 && FRAME_X_DISPLAY_INFO (cf) == FRAME_X_DISPLAY_INFO (f)
2138 && FRAME_XIC_FONTSET (cf) == FRAME_XIC_FONTSET (f))
2140 shared_p = 1;
2141 break;
2145 if (!shared_p)
2146 /* The fontset is not used anymore. It is safe to free it. */
2147 XFreeFontSet (FRAME_X_DISPLAY (f), FRAME_XIC_FONTSET (f));
2149 if (FRAME_XIC_BASE_FONTNAME (f))
2150 xfree (FRAME_XIC_BASE_FONTNAME (f));
2151 FRAME_XIC_BASE_FONTNAME (f) = NULL;
2152 FRAME_XIC_FONTSET (f) = NULL;
2156 /* Value is the best input style, given user preferences USER (already
2157 checked to be supported by Emacs), and styles supported by the
2158 input method XIM. */
2160 static XIMStyle
2161 best_xim_style (XIMStyles *user, XIMStyles *xim)
2163 int i, j;
2165 for (i = 0; i < user->count_styles; ++i)
2166 for (j = 0; j < xim->count_styles; ++j)
2167 if (user->supported_styles[i] == xim->supported_styles[j])
2168 return user->supported_styles[i];
2170 /* Return the default style. */
2171 return XIMPreeditNothing | XIMStatusNothing;
2174 /* Create XIC for frame F. */
2176 static XIMStyle xic_style;
2178 void
2179 create_frame_xic (struct frame *f)
2181 XIM xim;
2182 XIC xic = NULL;
2183 XFontSet xfs = NULL;
2185 if (FRAME_XIC (f))
2186 return;
2188 /* Create X fontset. */
2189 xfs = xic_create_xfontset (f);
2190 xim = FRAME_X_XIM (f);
2191 if (xim)
2193 XRectangle s_area;
2194 XPoint spot;
2195 XVaNestedList preedit_attr;
2196 XVaNestedList status_attr;
2198 s_area.x = 0; s_area.y = 0; s_area.width = 1; s_area.height = 1;
2199 spot.x = 0; spot.y = 1;
2201 /* Determine XIC style. */
2202 if (xic_style == 0)
2204 XIMStyles supported_list;
2205 supported_list.count_styles = (sizeof supported_xim_styles
2206 / sizeof supported_xim_styles[0]);
2207 supported_list.supported_styles = supported_xim_styles;
2208 xic_style = best_xim_style (&supported_list,
2209 FRAME_X_XIM_STYLES (f));
2212 preedit_attr = XVaCreateNestedList (0,
2213 XNFontSet, xfs,
2214 XNForeground,
2215 FRAME_FOREGROUND_PIXEL (f),
2216 XNBackground,
2217 FRAME_BACKGROUND_PIXEL (f),
2218 (xic_style & XIMPreeditPosition
2219 ? XNSpotLocation
2220 : NULL),
2221 &spot,
2222 NULL);
2223 status_attr = XVaCreateNestedList (0,
2224 XNArea,
2225 &s_area,
2226 XNFontSet,
2227 xfs,
2228 XNForeground,
2229 FRAME_FOREGROUND_PIXEL (f),
2230 XNBackground,
2231 FRAME_BACKGROUND_PIXEL (f),
2232 NULL);
2234 xic = XCreateIC (xim,
2235 XNInputStyle, xic_style,
2236 XNClientWindow, FRAME_X_WINDOW (f),
2237 XNFocusWindow, FRAME_X_WINDOW (f),
2238 XNStatusAttributes, status_attr,
2239 XNPreeditAttributes, preedit_attr,
2240 NULL);
2241 XFree (preedit_attr);
2242 XFree (status_attr);
2245 FRAME_XIC (f) = xic;
2246 FRAME_XIC_STYLE (f) = xic_style;
2247 FRAME_XIC_FONTSET (f) = xfs;
2251 /* Destroy XIC and free XIC fontset of frame F, if any. */
2253 void
2254 free_frame_xic (struct frame *f)
2256 if (FRAME_XIC (f) == NULL)
2257 return;
2259 XDestroyIC (FRAME_XIC (f));
2260 xic_free_xfontset (f);
2262 FRAME_XIC (f) = NULL;
2266 /* Place preedit area for XIC of window W's frame to specified
2267 pixel position X/Y. X and Y are relative to window W. */
2269 void
2270 xic_set_preeditarea (struct window *w, int x, int y)
2272 struct frame *f = XFRAME (w->frame);
2273 XVaNestedList attr;
2274 XPoint spot;
2276 spot.x = WINDOW_TO_FRAME_PIXEL_X (w, x) + WINDOW_LEFT_FRINGE_WIDTH (w);
2277 spot.y = WINDOW_TO_FRAME_PIXEL_Y (w, y) + FONT_BASE (FRAME_FONT (f));
2278 attr = XVaCreateNestedList (0, XNSpotLocation, &spot, NULL);
2279 XSetICValues (FRAME_XIC (f), XNPreeditAttributes, attr, NULL);
2280 XFree (attr);
2284 /* Place status area for XIC in bottom right corner of frame F.. */
2286 void
2287 xic_set_statusarea (struct frame *f)
2289 XIC xic = FRAME_XIC (f);
2290 XVaNestedList attr;
2291 XRectangle area;
2292 XRectangle *needed;
2294 /* Negotiate geometry of status area. If input method has existing
2295 status area, use its current size. */
2296 area.x = area.y = area.width = area.height = 0;
2297 attr = XVaCreateNestedList (0, XNAreaNeeded, &area, NULL);
2298 XSetICValues (xic, XNStatusAttributes, attr, NULL);
2299 XFree (attr);
2301 attr = XVaCreateNestedList (0, XNAreaNeeded, &needed, NULL);
2302 XGetICValues (xic, XNStatusAttributes, attr, NULL);
2303 XFree (attr);
2305 if (needed->width == 0) /* Use XNArea instead of XNAreaNeeded */
2307 attr = XVaCreateNestedList (0, XNArea, &needed, NULL);
2308 XGetICValues (xic, XNStatusAttributes, attr, NULL);
2309 XFree (attr);
2312 area.width = needed->width;
2313 area.height = needed->height;
2314 area.x = FRAME_PIXEL_WIDTH (f) - area.width - FRAME_INTERNAL_BORDER_WIDTH (f);
2315 area.y = (FRAME_PIXEL_HEIGHT (f) - area.height
2316 - FRAME_MENUBAR_HEIGHT (f)
2317 - FRAME_TOOLBAR_TOP_HEIGHT (f)
2318 - FRAME_INTERNAL_BORDER_WIDTH (f));
2319 XFree (needed);
2321 attr = XVaCreateNestedList (0, XNArea, &area, NULL);
2322 XSetICValues (xic, XNStatusAttributes, attr, NULL);
2323 XFree (attr);
2327 /* Set X fontset for XIC of frame F, using base font name
2328 BASE_FONTNAME. Called when a new Emacs fontset is chosen. */
2330 void
2331 xic_set_xfontset (struct frame *f, const char *base_fontname)
2333 XVaNestedList attr;
2334 XFontSet xfs;
2336 xic_free_xfontset (f);
2338 xfs = xic_create_xfontset (f);
2340 attr = XVaCreateNestedList (0, XNFontSet, xfs, NULL);
2341 if (FRAME_XIC_STYLE (f) & XIMPreeditPosition)
2342 XSetICValues (FRAME_XIC (f), XNPreeditAttributes, attr, NULL);
2343 if (FRAME_XIC_STYLE (f) & XIMStatusArea)
2344 XSetICValues (FRAME_XIC (f), XNStatusAttributes, attr, NULL);
2345 XFree (attr);
2347 FRAME_XIC_FONTSET (f) = xfs;
2350 #endif /* HAVE_X_I18N */
2354 #ifdef USE_X_TOOLKIT
2356 /* Create and set up the X widget for frame F. */
2358 static void
2359 x_window (struct frame *f, long window_prompting, int minibuffer_only)
2361 XClassHint class_hints;
2362 XSetWindowAttributes attributes;
2363 unsigned long attribute_mask;
2364 Widget shell_widget;
2365 Widget pane_widget;
2366 Widget frame_widget;
2367 Arg al [25];
2368 int ac;
2370 BLOCK_INPUT;
2372 /* Use the resource name as the top-level widget name
2373 for looking up resources. Make a non-Lisp copy
2374 for the window manager, so GC relocation won't bother it.
2376 Elsewhere we specify the window name for the window manager. */
2379 char *str = SSDATA (Vx_resource_name);
2380 f->namebuf = (char *) xmalloc (strlen (str) + 1);
2381 strcpy (f->namebuf, str);
2384 ac = 0;
2385 XtSetArg (al[ac], XtNallowShellResize, 1); ac++;
2386 XtSetArg (al[ac], XtNinput, 1); ac++;
2387 XtSetArg (al[ac], XtNmappedWhenManaged, 0); ac++;
2388 XtSetArg (al[ac], XtNborderWidth, f->border_width); ac++;
2389 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2390 XtSetArg (al[ac], XtNdepth, FRAME_X_DISPLAY_INFO (f)->n_planes); ac++;
2391 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2392 shell_widget = XtAppCreateShell (f->namebuf, EMACS_CLASS,
2393 applicationShellWidgetClass,
2394 FRAME_X_DISPLAY (f), al, ac);
2396 f->output_data.x->widget = shell_widget;
2397 /* maybe_set_screen_title_format (shell_widget); */
2399 pane_widget = lw_create_widget ("main", "pane", widget_id_tick++,
2400 (widget_value *) NULL,
2401 shell_widget, False,
2402 (lw_callback) NULL,
2403 (lw_callback) NULL,
2404 (lw_callback) NULL,
2405 (lw_callback) NULL);
2407 ac = 0;
2408 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2409 XtSetArg (al[ac], XtNdepth, FRAME_X_DISPLAY_INFO (f)->n_planes); ac++;
2410 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2411 XtSetArg (al[ac], XtNborderWidth, 0); ac++;
2412 XtSetValues (pane_widget, al, ac);
2413 f->output_data.x->column_widget = pane_widget;
2415 /* mappedWhenManaged to false tells to the paned window to not map/unmap
2416 the emacs screen when changing menubar. This reduces flickering. */
2418 ac = 0;
2419 XtSetArg (al[ac], XtNmappedWhenManaged, 0); ac++;
2420 XtSetArg (al[ac], XtNshowGrip, 0); ac++;
2421 XtSetArg (al[ac], XtNallowResize, 1); ac++;
2422 XtSetArg (al[ac], XtNresizeToPreferred, 1); ac++;
2423 XtSetArg (al[ac], XtNemacsFrame, f); ac++;
2424 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2425 XtSetArg (al[ac], XtNdepth, FRAME_X_DISPLAY_INFO (f)->n_planes); ac++;
2426 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2427 XtSetArg (al[ac], XtNborderWidth, 0); ac++;
2428 frame_widget = XtCreateWidget (f->namebuf, emacsFrameClass, pane_widget,
2429 al, ac);
2431 f->output_data.x->edit_widget = frame_widget;
2433 XtManageChild (frame_widget);
2435 /* Do some needed geometry management. */
2437 int len;
2438 char *tem, shell_position[32];
2439 Arg gal[10];
2440 int gac = 0;
2441 int extra_borders = 0;
2442 int menubar_size
2443 = (f->output_data.x->menubar_widget
2444 ? (f->output_data.x->menubar_widget->core.height
2445 + f->output_data.x->menubar_widget->core.border_width)
2446 : 0);
2448 #if 0 /* Experimentally, we now get the right results
2449 for -geometry -0-0 without this. 24 Aug 96, rms. */
2450 if (FRAME_EXTERNAL_MENU_BAR (f))
2452 Dimension ibw = 0;
2453 XtVaGetValues (pane_widget, XtNinternalBorderWidth, &ibw, NULL);
2454 menubar_size += ibw;
2456 #endif
2458 f->output_data.x->menubar_height = menubar_size;
2460 #ifndef USE_LUCID
2461 /* Motif seems to need this amount added to the sizes
2462 specified for the shell widget. The Athena/Lucid widgets don't.
2463 Both conclusions reached experimentally. -- rms. */
2464 XtVaGetValues (f->output_data.x->edit_widget, XtNinternalBorderWidth,
2465 &extra_borders, NULL);
2466 extra_borders *= 2;
2467 #endif
2469 /* Convert our geometry parameters into a geometry string
2470 and specify it.
2471 Note that we do not specify here whether the position
2472 is a user-specified or program-specified one.
2473 We pass that information later, in x_wm_set_size_hints. */
2475 int left = f->left_pos;
2476 int xneg = window_prompting & XNegative;
2477 int top = f->top_pos;
2478 int yneg = window_prompting & YNegative;
2479 if (xneg)
2480 left = -left;
2481 if (yneg)
2482 top = -top;
2484 if (window_prompting & USPosition)
2485 sprintf (shell_position, "=%dx%d%c%d%c%d",
2486 FRAME_PIXEL_WIDTH (f) + extra_borders,
2487 FRAME_PIXEL_HEIGHT (f) + menubar_size + extra_borders,
2488 (xneg ? '-' : '+'), left,
2489 (yneg ? '-' : '+'), top);
2490 else
2492 sprintf (shell_position, "=%dx%d",
2493 FRAME_PIXEL_WIDTH (f) + extra_borders,
2494 FRAME_PIXEL_HEIGHT (f) + menubar_size + extra_borders);
2496 /* Setting x and y when the position is not specified in
2497 the geometry string will set program position in the WM hints.
2498 If Emacs had just one program position, we could set it in
2499 fallback resources, but since each make-frame call can specify
2500 different program positions, this is easier. */
2501 XtSetArg (gal[gac], XtNx, left); gac++;
2502 XtSetArg (gal[gac], XtNy, top); gac++;
2506 len = strlen (shell_position) + 1;
2507 /* We don't free this because we don't know whether
2508 it is safe to free it while the frame exists.
2509 It isn't worth the trouble of arranging to free it
2510 when the frame is deleted. */
2511 tem = (char *) xmalloc (len);
2512 strncpy (tem, shell_position, len);
2513 XtSetArg (gal[gac], XtNgeometry, tem); gac++;
2514 XtSetValues (shell_widget, gal, gac);
2517 XtManageChild (pane_widget);
2518 XtRealizeWidget (shell_widget);
2520 if (FRAME_X_EMBEDDED_P (f))
2521 XReparentWindow (FRAME_X_DISPLAY (f), XtWindow (shell_widget),
2522 f->output_data.x->parent_desc, 0, 0);
2524 FRAME_X_WINDOW (f) = XtWindow (frame_widget);
2526 validate_x_resource_name ();
2528 class_hints.res_name = SSDATA (Vx_resource_name);
2529 class_hints.res_class = SSDATA (Vx_resource_class);
2530 XSetClassHint (FRAME_X_DISPLAY (f), XtWindow (shell_widget), &class_hints);
2532 #ifdef HAVE_X_I18N
2533 FRAME_XIC (f) = NULL;
2534 if (use_xim)
2535 create_frame_xic (f);
2536 #endif
2538 f->output_data.x->wm_hints.input = True;
2539 f->output_data.x->wm_hints.flags |= InputHint;
2540 XSetWMHints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2541 &f->output_data.x->wm_hints);
2543 hack_wm_protocols (f, shell_widget);
2545 #ifdef HACK_EDITRES
2546 XtAddEventHandler (shell_widget, 0, True, _XEditResCheckMessages, 0);
2547 #endif
2549 /* Do a stupid property change to force the server to generate a
2550 PropertyNotify event so that the event_stream server timestamp will
2551 be initialized to something relevant to the time we created the window.
2553 XChangeProperty (XtDisplay (frame_widget), XtWindow (frame_widget),
2554 FRAME_X_DISPLAY_INFO (f)->Xatom_wm_protocols,
2555 XA_ATOM, 32, PropModeAppend,
2556 (unsigned char*) NULL, 0);
2558 /* Make all the standard events reach the Emacs frame. */
2559 attributes.event_mask = STANDARD_EVENT_SET;
2561 #ifdef HAVE_X_I18N
2562 if (FRAME_XIC (f))
2564 /* XIM server might require some X events. */
2565 unsigned long fevent = NoEventMask;
2566 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2567 attributes.event_mask |= fevent;
2569 #endif /* HAVE_X_I18N */
2571 attribute_mask = CWEventMask;
2572 XChangeWindowAttributes (XtDisplay (shell_widget), XtWindow (shell_widget),
2573 attribute_mask, &attributes);
2575 XtMapWidget (frame_widget);
2577 /* x_set_name normally ignores requests to set the name if the
2578 requested name is the same as the current name. This is the one
2579 place where that assumption isn't correct; f->name is set, but
2580 the X server hasn't been told. */
2582 Lisp_Object name;
2583 int explicit = f->explicit_name;
2585 f->explicit_name = 0;
2586 name = f->name;
2587 f->name = Qnil;
2588 x_set_name (f, name, explicit);
2591 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2592 f->output_data.x->current_cursor
2593 = f->output_data.x->text_cursor);
2595 UNBLOCK_INPUT;
2597 /* This is a no-op, except under Motif. Make sure main areas are
2598 set to something reasonable, in case we get an error later. */
2599 lw_set_main_areas (pane_widget, 0, frame_widget);
2602 #else /* not USE_X_TOOLKIT */
2603 #ifdef USE_GTK
2604 static void
2605 x_window (FRAME_PTR f)
2607 if (! xg_create_frame_widgets (f))
2608 error ("Unable to create window");
2610 #ifdef HAVE_X_I18N
2611 FRAME_XIC (f) = NULL;
2612 if (use_xim)
2614 BLOCK_INPUT;
2615 create_frame_xic (f);
2616 if (FRAME_XIC (f))
2618 /* XIM server might require some X events. */
2619 unsigned long fevent = NoEventMask;
2620 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2622 if (fevent != NoEventMask)
2624 XSetWindowAttributes attributes;
2625 XWindowAttributes wattr;
2626 unsigned long attribute_mask;
2628 XGetWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2629 &wattr);
2630 attributes.event_mask = wattr.your_event_mask | fevent;
2631 attribute_mask = CWEventMask;
2632 XChangeWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2633 attribute_mask, &attributes);
2636 UNBLOCK_INPUT;
2638 #endif
2641 #else /*! USE_GTK */
2642 /* Create and set up the X window for frame F. */
2644 static void
2645 x_window (struct frame *f)
2647 XClassHint class_hints;
2648 XSetWindowAttributes attributes;
2649 unsigned long attribute_mask;
2651 attributes.background_pixel = FRAME_BACKGROUND_PIXEL (f);
2652 attributes.border_pixel = f->output_data.x->border_pixel;
2653 attributes.bit_gravity = StaticGravity;
2654 attributes.backing_store = NotUseful;
2655 attributes.save_under = True;
2656 attributes.event_mask = STANDARD_EVENT_SET;
2657 attributes.colormap = FRAME_X_COLORMAP (f);
2658 attribute_mask = (CWBackPixel | CWBorderPixel | CWBitGravity | CWEventMask
2659 | CWColormap);
2661 BLOCK_INPUT;
2662 FRAME_X_WINDOW (f)
2663 = XCreateWindow (FRAME_X_DISPLAY (f),
2664 f->output_data.x->parent_desc,
2665 f->left_pos,
2666 f->top_pos,
2667 FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f),
2668 f->border_width,
2669 CopyFromParent, /* depth */
2670 InputOutput, /* class */
2671 FRAME_X_VISUAL (f),
2672 attribute_mask, &attributes);
2674 #ifdef HAVE_X_I18N
2675 if (use_xim)
2677 create_frame_xic (f);
2678 if (FRAME_XIC (f))
2680 /* XIM server might require some X events. */
2681 unsigned long fevent = NoEventMask;
2682 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2683 attributes.event_mask |= fevent;
2684 attribute_mask = CWEventMask;
2685 XChangeWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2686 attribute_mask, &attributes);
2689 #endif /* HAVE_X_I18N */
2691 validate_x_resource_name ();
2693 class_hints.res_name = SSDATA (Vx_resource_name);
2694 class_hints.res_class = SSDATA (Vx_resource_class);
2695 XSetClassHint (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), &class_hints);
2697 /* The menubar is part of the ordinary display;
2698 it does not count in addition to the height of the window. */
2699 f->output_data.x->menubar_height = 0;
2701 /* This indicates that we use the "Passive Input" input model.
2702 Unless we do this, we don't get the Focus{In,Out} events that we
2703 need to draw the cursor correctly. Accursed bureaucrats.
2704 XWhipsAndChains (FRAME_X_DISPLAY (f), IronMaiden, &TheRack); */
2706 f->output_data.x->wm_hints.input = True;
2707 f->output_data.x->wm_hints.flags |= InputHint;
2708 XSetWMHints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2709 &f->output_data.x->wm_hints);
2710 f->output_data.x->wm_hints.icon_pixmap = None;
2712 /* Request "save yourself" and "delete window" commands from wm. */
2714 Atom protocols[2];
2715 protocols[0] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_delete_window;
2716 protocols[1] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_save_yourself;
2717 XSetWMProtocols (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), protocols, 2);
2720 /* x_set_name normally ignores requests to set the name if the
2721 requested name is the same as the current name. This is the one
2722 place where that assumption isn't correct; f->name is set, but
2723 the X server hasn't been told. */
2725 Lisp_Object name;
2726 int explicit = f->explicit_name;
2728 f->explicit_name = 0;
2729 name = f->name;
2730 f->name = Qnil;
2731 x_set_name (f, name, explicit);
2734 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2735 f->output_data.x->current_cursor
2736 = f->output_data.x->text_cursor);
2738 UNBLOCK_INPUT;
2740 if (FRAME_X_WINDOW (f) == 0)
2741 error ("Unable to create window");
2744 #endif /* not USE_GTK */
2745 #endif /* not USE_X_TOOLKIT */
2747 /* Verify that the icon position args for this window are valid. */
2749 static void
2750 x_icon_verify (struct frame *f, Lisp_Object parms)
2752 Lisp_Object icon_x, icon_y;
2754 /* Set the position of the icon. Note that twm groups all
2755 icons in an icon window. */
2756 icon_x = x_frame_get_and_record_arg (f, parms, Qicon_left, 0, 0, RES_TYPE_NUMBER);
2757 icon_y = x_frame_get_and_record_arg (f, parms, Qicon_top, 0, 0, RES_TYPE_NUMBER);
2758 if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
2760 CHECK_NUMBER (icon_x);
2761 CHECK_NUMBER (icon_y);
2763 else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
2764 error ("Both left and top icon corners of icon must be specified");
2767 /* Handle the icon stuff for this window. Perhaps later we might
2768 want an x_set_icon_position which can be called interactively as
2769 well. */
2771 static void
2772 x_icon (struct frame *f, Lisp_Object parms)
2774 Lisp_Object icon_x, icon_y;
2775 #if 0
2776 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
2777 #endif
2779 /* Set the position of the icon. Note that twm groups all
2780 icons in an icon window. */
2781 icon_x = x_frame_get_and_record_arg (f, parms, Qicon_left, 0, 0, RES_TYPE_NUMBER);
2782 icon_y = x_frame_get_and_record_arg (f, parms, Qicon_top, 0, 0, RES_TYPE_NUMBER);
2783 if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
2785 CHECK_NUMBER (icon_x);
2786 CHECK_NUMBER (icon_y);
2788 else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
2789 error ("Both left and top icon corners of icon must be specified");
2791 BLOCK_INPUT;
2793 if (! EQ (icon_x, Qunbound))
2794 x_wm_set_icon_position (f, XINT (icon_x), XINT (icon_y));
2796 #if 0 /* x_get_arg removes the visibility parameter as a side effect,
2797 but x_create_frame still needs it. */
2798 /* Start up iconic or window? */
2799 x_wm_set_window_state
2800 (f, (EQ (x_get_arg (dpyinfo, parms, Qvisibility, 0, 0, RES_TYPE_SYMBOL),
2801 Qicon)
2802 ? IconicState
2803 : NormalState));
2804 #endif
2806 x_text_icon (f, SSDATA ((!NILP (f->icon_name)
2807 ? f->icon_name
2808 : f->name)));
2810 UNBLOCK_INPUT;
2813 /* Make the GCs needed for this window, setting the
2814 background, border and mouse colors; also create the
2815 mouse cursor and the gray border tile. */
2817 static void
2818 x_make_gc (struct frame *f)
2820 XGCValues gc_values;
2822 BLOCK_INPUT;
2824 /* Create the GCs of this frame.
2825 Note that many default values are used. */
2827 gc_values.foreground = FRAME_FOREGROUND_PIXEL (f);
2828 gc_values.background = FRAME_BACKGROUND_PIXEL (f);
2829 gc_values.line_width = 0; /* Means 1 using fast algorithm. */
2830 f->output_data.x->normal_gc
2831 = XCreateGC (FRAME_X_DISPLAY (f),
2832 FRAME_X_WINDOW (f),
2833 GCLineWidth | GCForeground | GCBackground,
2834 &gc_values);
2836 /* Reverse video style. */
2837 gc_values.foreground = FRAME_BACKGROUND_PIXEL (f);
2838 gc_values.background = FRAME_FOREGROUND_PIXEL (f);
2839 f->output_data.x->reverse_gc
2840 = XCreateGC (FRAME_X_DISPLAY (f),
2841 FRAME_X_WINDOW (f),
2842 GCForeground | GCBackground | GCLineWidth,
2843 &gc_values);
2845 /* Cursor has cursor-color background, background-color foreground. */
2846 gc_values.foreground = FRAME_BACKGROUND_PIXEL (f);
2847 gc_values.background = f->output_data.x->cursor_pixel;
2848 gc_values.fill_style = FillOpaqueStippled;
2849 f->output_data.x->cursor_gc
2850 = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2851 (GCForeground | GCBackground
2852 | GCFillStyle | GCLineWidth),
2853 &gc_values);
2855 /* Reliefs. */
2856 f->output_data.x->white_relief.gc = 0;
2857 f->output_data.x->black_relief.gc = 0;
2859 /* Create the gray border tile used when the pointer is not in
2860 the frame. Since this depends on the frame's pixel values,
2861 this must be done on a per-frame basis. */
2862 f->output_data.x->border_tile
2863 = (XCreatePixmapFromBitmapData
2864 (FRAME_X_DISPLAY (f), FRAME_X_DISPLAY_INFO (f)->root_window,
2865 gray_bits, gray_width, gray_height,
2866 FRAME_FOREGROUND_PIXEL (f),
2867 FRAME_BACKGROUND_PIXEL (f),
2868 DefaultDepth (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f))));
2870 UNBLOCK_INPUT;
2874 /* Free what was allocated in x_make_gc. */
2876 void
2877 x_free_gcs (struct frame *f)
2879 Display *dpy = FRAME_X_DISPLAY (f);
2881 BLOCK_INPUT;
2883 if (f->output_data.x->normal_gc)
2885 XFreeGC (dpy, f->output_data.x->normal_gc);
2886 f->output_data.x->normal_gc = 0;
2889 if (f->output_data.x->reverse_gc)
2891 XFreeGC (dpy, f->output_data.x->reverse_gc);
2892 f->output_data.x->reverse_gc = 0;
2895 if (f->output_data.x->cursor_gc)
2897 XFreeGC (dpy, f->output_data.x->cursor_gc);
2898 f->output_data.x->cursor_gc = 0;
2901 if (f->output_data.x->border_tile)
2903 XFreePixmap (dpy, f->output_data.x->border_tile);
2904 f->output_data.x->border_tile = 0;
2907 UNBLOCK_INPUT;
2911 /* Handler for signals raised during x_create_frame and
2912 x_create_top_frame. FRAME is the frame which is partially
2913 constructed. */
2915 static Lisp_Object
2916 unwind_create_frame (Lisp_Object frame)
2918 struct frame *f = XFRAME (frame);
2920 /* If frame is already dead, nothing to do. This can happen if the
2921 display is disconnected after the frame has become official, but
2922 before x_create_frame removes the unwind protect. */
2923 if (!FRAME_LIVE_P (f))
2924 return Qnil;
2926 /* If frame is ``official'', nothing to do. */
2927 if (!CONSP (Vframe_list) || !EQ (XCAR (Vframe_list), frame))
2929 #if GLYPH_DEBUG
2930 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
2931 #endif
2933 x_free_frame_resources (f);
2935 #if GLYPH_DEBUG
2936 /* Check that reference counts are indeed correct. */
2937 xassert (dpyinfo->reference_count == dpyinfo_refcount);
2938 xassert (dpyinfo->image_cache->refcount == image_cache_refcount);
2939 #endif
2940 return Qt;
2943 return Qnil;
2947 static void
2948 x_default_font_parameter (struct frame *f, Lisp_Object parms)
2950 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
2951 Lisp_Object font_param = x_get_arg (dpyinfo, parms, Qfont, NULL, NULL,
2952 RES_TYPE_STRING);
2953 Lisp_Object font = Qnil;
2954 if (EQ (font_param, Qunbound))
2955 font_param = Qnil;
2957 if (NILP (font_param))
2959 /* System font should take precedendce over X resources. We suggest this
2960 regardless of font-use-system-font because .emacs may not have been
2961 read yet. */
2962 const char *system_font = xsettings_get_system_font ();
2963 if (system_font)
2965 char *name = xstrdup (system_font);
2966 font = font_open_by_name (f, name);
2967 xfree (name);
2971 if (NILP (font))
2972 font = !NILP (font_param) ? font_param
2973 : x_get_arg (dpyinfo, parms, Qfont, "font", "Font", RES_TYPE_STRING);
2975 if (! FONTP (font) && ! STRINGP (font))
2977 const char *names[]
2979 #ifdef HAVE_XFT
2980 /* This will find the normal Xft font. */
2981 "monospace-10",
2982 #endif
2983 "-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1",
2984 "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1",
2985 "-*-*-medium-r-normal-*-*-140-*-*-c-*-iso8859-1",
2986 /* This was formerly the first thing tried, but it finds
2987 too many fonts and takes too long. */
2988 "-*-*-medium-r-*-*-*-*-*-*-c-*-iso8859-1",
2989 /* If those didn't work, look for something which will
2990 at least work. */
2991 "-*-fixed-*-*-*-*-*-140-*-*-c-*-iso8859-1",
2992 "fixed",
2993 NULL };
2994 int i;
2996 for (i = 0; names[i]; i++)
2998 font = font_open_by_name (f, names[i]);
2999 if (! NILP (font))
3000 break;
3002 if (NILP (font))
3003 error ("No suitable font was found");
3005 else if (!NILP (font_param))
3007 /* Remember the explicit font parameter, so we can re-apply it after
3008 we've applied the `default' face settings. */
3009 x_set_frame_parameters (f, Fcons (Fcons (Qfont_param, font_param), Qnil));
3012 /* This call will make X resources override any system font setting. */
3013 x_default_parameter (f, parms, Qfont, font, "font", "Font", RES_TYPE_STRING);
3017 DEFUN ("x-wm-set-size-hint", Fx_wm_set_size_hint, Sx_wm_set_size_hint,
3018 0, 1, 0,
3019 doc: /* Send the size hints for frame FRAME to the window manager.
3020 If FRAME is nil, use the selected frame. */)
3021 (Lisp_Object frame)
3023 struct frame *f;
3024 if (NILP (frame))
3025 frame = selected_frame;
3026 f = XFRAME (frame);
3027 BLOCK_INPUT;
3028 if (FRAME_X_P (f))
3029 x_wm_set_size_hint (f, 0, 0);
3030 UNBLOCK_INPUT;
3031 return Qnil;
3034 static void
3035 set_machine_and_pid_properties (struct frame *f)
3037 long pid = (long) getpid ();
3039 /* This will set WM_CLIENT_MACHINE and WM_LOCALE_NAME. */
3040 XSetWMProperties (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), NULL, NULL,
3041 NULL, 0, NULL, NULL, NULL);
3042 XChangeProperty (FRAME_X_DISPLAY (f),
3043 FRAME_OUTER_WINDOW (f),
3044 XInternAtom (FRAME_X_DISPLAY (f),
3045 "_NET_WM_PID",
3046 False),
3047 XA_CARDINAL, 32, PropModeReplace,
3048 (unsigned char *) &pid, 1);
3051 DEFUN ("x-create-frame", Fx_create_frame, Sx_create_frame,
3052 1, 1, 0,
3053 doc: /* Make a new X window, which is called a "frame" in Emacs terms.
3054 Return an Emacs frame object.
3055 PARMS is an alist of frame parameters.
3056 If the parameters specify that the frame should not have a minibuffer,
3057 and do not specify a specific minibuffer window to use,
3058 then `default-minibuffer-frame' must be a frame whose minibuffer can
3059 be shared by the new frame.
3061 This function is an internal primitive--use `make-frame' instead. */)
3062 (Lisp_Object parms)
3064 struct frame *f;
3065 Lisp_Object frame, tem;
3066 Lisp_Object name;
3067 int minibuffer_only = 0;
3068 long window_prompting = 0;
3069 int width, height;
3070 int count = SPECPDL_INDEX ();
3071 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
3072 Lisp_Object display;
3073 struct x_display_info *dpyinfo = NULL;
3074 Lisp_Object parent;
3075 struct kboard *kb;
3077 parms = Fcopy_alist (parms);
3079 /* Use this general default value to start with
3080 until we know if this frame has a specified name. */
3081 Vx_resource_name = Vinvocation_name;
3083 display = x_get_arg (dpyinfo, parms, Qterminal, 0, 0, RES_TYPE_NUMBER);
3084 if (EQ (display, Qunbound))
3085 display = x_get_arg (dpyinfo, parms, Qdisplay, 0, 0, RES_TYPE_STRING);
3086 if (EQ (display, Qunbound))
3087 display = Qnil;
3088 dpyinfo = check_x_display_info (display);
3089 kb = dpyinfo->terminal->kboard;
3091 if (!dpyinfo->terminal->name)
3092 error ("Terminal is not live, can't create new frames on it");
3094 name = x_get_arg (dpyinfo, parms, Qname, "name", "Name", RES_TYPE_STRING);
3095 if (!STRINGP (name)
3096 && ! EQ (name, Qunbound)
3097 && ! NILP (name))
3098 error ("Invalid frame name--not a string or nil");
3100 if (STRINGP (name))
3101 Vx_resource_name = name;
3103 /* See if parent window is specified. */
3104 parent = x_get_arg (dpyinfo, parms, Qparent_id, NULL, NULL, RES_TYPE_NUMBER);
3105 if (EQ (parent, Qunbound))
3106 parent = Qnil;
3107 if (! NILP (parent))
3108 CHECK_NUMBER (parent);
3110 /* make_frame_without_minibuffer can run Lisp code and garbage collect. */
3111 /* No need to protect DISPLAY because that's not used after passing
3112 it to make_frame_without_minibuffer. */
3113 frame = Qnil;
3114 GCPRO4 (parms, parent, name, frame);
3115 tem = x_get_arg (dpyinfo, parms, Qminibuffer, "minibuffer", "Minibuffer",
3116 RES_TYPE_SYMBOL);
3117 if (EQ (tem, Qnone) || NILP (tem))
3118 f = make_frame_without_minibuffer (Qnil, kb, display);
3119 else if (EQ (tem, Qonly))
3121 f = make_minibuffer_frame ();
3122 minibuffer_only = 1;
3124 else if (WINDOWP (tem))
3125 f = make_frame_without_minibuffer (tem, kb, display);
3126 else
3127 f = make_frame (1);
3129 XSETFRAME (frame, f);
3131 /* Note that X Windows does support scroll bars. */
3132 FRAME_CAN_HAVE_SCROLL_BARS (f) = 1;
3134 f->terminal = dpyinfo->terminal;
3135 f->terminal->reference_count++;
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);
3159 #if GLYPH_DEBUG
3160 image_cache_refcount = FRAME_IMAGE_CACHE (f)->refcount;
3161 dpyinfo_refcount = dpyinfo->reference_count;
3162 #endif /* GLYPH_DEBUG */
3164 /* These colors will be set anyway later, but it's important
3165 to get the color reference counts right, so initialize them! */
3167 Lisp_Object black;
3168 struct gcpro inner_gcpro1;
3170 /* Function x_decode_color can signal an error. Make
3171 sure to initialize color slots so that we won't try
3172 to free colors we haven't allocated. */
3173 FRAME_FOREGROUND_PIXEL (f) = -1;
3174 FRAME_BACKGROUND_PIXEL (f) = -1;
3175 f->output_data.x->cursor_pixel = -1;
3176 f->output_data.x->cursor_foreground_pixel = -1;
3177 f->output_data.x->border_pixel = -1;
3178 f->output_data.x->mouse_pixel = -1;
3180 black = build_string ("black");
3181 GCPRO1_VAR (black, inner_gcpro);
3182 FRAME_FOREGROUND_PIXEL (f)
3183 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3184 FRAME_BACKGROUND_PIXEL (f)
3185 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3186 f->output_data.x->cursor_pixel
3187 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3188 f->output_data.x->cursor_foreground_pixel
3189 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3190 f->output_data.x->border_pixel
3191 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3192 f->output_data.x->mouse_pixel
3193 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3194 UNGCPRO_VAR (inner_gcpro);
3197 /* Specify the parent under which to make this X window. */
3199 if (!NILP (parent))
3201 f->output_data.x->parent_desc = (Window) XFASTINT (parent);
3202 f->output_data.x->explicit_parent = 1;
3204 else
3206 f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
3207 f->output_data.x->explicit_parent = 0;
3210 /* Set the name; the functions to which we pass f expect the name to
3211 be set. */
3212 if (EQ (name, Qunbound) || NILP (name))
3214 f->name = build_string (dpyinfo->x_id_name);
3215 f->explicit_name = 0;
3217 else
3219 f->name = name;
3220 f->explicit_name = 1;
3221 /* use the frame's title when getting resources for this frame. */
3222 specbind (Qx_resource_name, name);
3225 f->resx = dpyinfo->resx;
3226 f->resy = dpyinfo->resy;
3228 #ifdef HAVE_FREETYPE
3229 #ifdef HAVE_XFT
3230 register_font_driver (&xftfont_driver, f);
3231 #else /* not HAVE_XFT */
3232 register_font_driver (&ftxfont_driver, f);
3233 #endif /* not HAVE_XFT */
3234 #endif /* HAVE_FREETYPE */
3235 register_font_driver (&xfont_driver, f);
3237 x_default_parameter (f, parms, Qfont_backend, Qnil,
3238 "fontBackend", "FontBackend", RES_TYPE_STRING);
3240 /* Extract the window parameters from the supplied values
3241 that are needed to determine window geometry. */
3242 x_default_font_parameter (f, parms);
3243 if (!FRAME_FONT (f))
3245 delete_frame (frame, Qnoelisp);
3246 error ("Invalid frame font");
3249 /* Frame contents get displaced if an embedded X window has a border. */
3250 if (! FRAME_X_EMBEDDED_P (f))
3251 x_default_parameter (f, parms, Qborder_width, make_number (0),
3252 "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
3254 /* This defaults to 1 in order to match xterm. We recognize either
3255 internalBorderWidth or internalBorder (which is what xterm calls
3256 it). */
3257 if (NILP (Fassq (Qinternal_border_width, parms)))
3259 Lisp_Object value;
3261 value = x_get_arg (dpyinfo, parms, Qinternal_border_width,
3262 "internalBorder", "internalBorder", RES_TYPE_NUMBER);
3263 if (! EQ (value, Qunbound))
3264 parms = Fcons (Fcons (Qinternal_border_width, value),
3265 parms);
3267 x_default_parameter (f, parms, Qinternal_border_width,
3268 #ifdef USE_GTK /* We used to impose 0 in xg_create_frame_widgets. */
3269 make_number (0),
3270 #else
3271 make_number (1),
3272 #endif
3273 "internalBorderWidth", "internalBorderWidth",
3274 RES_TYPE_NUMBER);
3275 x_default_parameter (f, parms, Qvertical_scroll_bars,
3276 #if defined(USE_GTK) && defined(USE_TOOLKIT_SCROLL_BARS)
3277 Qright,
3278 #else
3279 Qleft,
3280 #endif
3281 "verticalScrollBars", "ScrollBars",
3282 RES_TYPE_SYMBOL);
3284 /* Also do the stuff which must be set before the window exists. */
3285 x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
3286 "foreground", "Foreground", RES_TYPE_STRING);
3287 x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
3288 "background", "Background", RES_TYPE_STRING);
3289 x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
3290 "pointerColor", "Foreground", RES_TYPE_STRING);
3291 x_default_parameter (f, parms, Qborder_color, build_string ("black"),
3292 "borderColor", "BorderColor", RES_TYPE_STRING);
3293 x_default_parameter (f, parms, Qscreen_gamma, Qnil,
3294 "screenGamma", "ScreenGamma", RES_TYPE_FLOAT);
3295 x_default_parameter (f, parms, Qline_spacing, Qnil,
3296 "lineSpacing", "LineSpacing", RES_TYPE_NUMBER);
3297 x_default_parameter (f, parms, Qleft_fringe, Qnil,
3298 "leftFringe", "LeftFringe", RES_TYPE_NUMBER);
3299 x_default_parameter (f, parms, Qright_fringe, Qnil,
3300 "rightFringe", "RightFringe", RES_TYPE_NUMBER);
3302 x_default_scroll_bar_color_parameter (f, parms, Qscroll_bar_foreground,
3303 "scrollBarForeground",
3304 "ScrollBarForeground", 1);
3305 x_default_scroll_bar_color_parameter (f, parms, Qscroll_bar_background,
3306 "scrollBarBackground",
3307 "ScrollBarBackground", 0);
3309 /* Init faces before x_default_parameter is called for scroll-bar
3310 parameters because that function calls x_set_scroll_bar_width,
3311 which calls change_frame_size, which calls Fset_window_buffer,
3312 which runs hooks, which call Fvertical_motion. At the end, we
3313 end up in init_iterator with a null face cache, which should not
3314 happen. */
3315 init_frame_faces (f);
3317 /* The X resources controlling the menu-bar and tool-bar are
3318 processed specially at startup, and reflected in the mode
3319 variables; ignore them here. */
3320 x_default_parameter (f, parms, Qmenu_bar_lines,
3321 NILP (Vmenu_bar_mode)
3322 ? make_number (0) : make_number (1),
3323 NULL, NULL, RES_TYPE_NUMBER);
3324 x_default_parameter (f, parms, Qtool_bar_lines,
3325 NILP (Vtool_bar_mode)
3326 ? make_number (0) : make_number (1),
3327 NULL, NULL, RES_TYPE_NUMBER);
3329 x_default_parameter (f, parms, Qbuffer_predicate, Qnil,
3330 "bufferPredicate", "BufferPredicate",
3331 RES_TYPE_SYMBOL);
3332 x_default_parameter (f, parms, Qtitle, Qnil,
3333 "title", "Title", RES_TYPE_STRING);
3334 x_default_parameter (f, parms, Qwait_for_wm, Qt,
3335 "waitForWM", "WaitForWM", RES_TYPE_BOOLEAN);
3336 x_default_parameter (f, parms, Qfullscreen, Qnil,
3337 "fullscreen", "Fullscreen", RES_TYPE_SYMBOL);
3338 x_default_parameter (f, parms, Qtool_bar_position,
3339 f->tool_bar_position, 0, 0, RES_TYPE_SYMBOL);
3341 /* Compute the size of the X window. */
3342 window_prompting = x_figure_window_size (f, parms, 1);
3344 tem = x_get_arg (dpyinfo, parms, Qunsplittable, 0, 0, RES_TYPE_BOOLEAN);
3345 f->no_split = minibuffer_only || EQ (tem, Qt);
3347 x_icon_verify (f, parms);
3349 /* Create the X widget or window. */
3350 #ifdef USE_X_TOOLKIT
3351 x_window (f, window_prompting, minibuffer_only);
3352 #else
3353 x_window (f);
3354 #endif
3356 x_icon (f, parms);
3357 x_make_gc (f);
3359 /* Now consider the frame official. */
3360 FRAME_X_DISPLAY_INFO (f)->reference_count++;
3361 Vframe_list = Fcons (frame, Vframe_list);
3363 /* We need to do this after creating the X window, so that the
3364 icon-creation functions can say whose icon they're describing. */
3365 x_default_parameter (f, parms, Qicon_type, Qt,
3366 "bitmapIcon", "BitmapIcon", RES_TYPE_SYMBOL);
3368 x_default_parameter (f, parms, Qauto_raise, Qnil,
3369 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
3370 x_default_parameter (f, parms, Qauto_lower, Qnil,
3371 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
3372 x_default_parameter (f, parms, Qcursor_type, Qbox,
3373 "cursorType", "CursorType", RES_TYPE_SYMBOL);
3374 x_default_parameter (f, parms, Qscroll_bar_width, Qnil,
3375 "scrollBarWidth", "ScrollBarWidth",
3376 RES_TYPE_NUMBER);
3377 x_default_parameter (f, parms, Qalpha, Qnil,
3378 "alpha", "Alpha", RES_TYPE_NUMBER);
3380 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
3381 Change will not be effected unless different from the current
3382 FRAME_LINES (f). */
3383 width = FRAME_COLS (f);
3384 height = FRAME_LINES (f);
3386 SET_FRAME_COLS (f, 0);
3387 FRAME_LINES (f) = 0;
3388 change_frame_size (f, height, width, 1, 0, 0);
3390 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
3391 /* Create the menu bar. */
3392 if (!minibuffer_only && FRAME_EXTERNAL_MENU_BAR (f))
3394 /* If this signals an error, we haven't set size hints for the
3395 frame and we didn't make it visible. */
3396 initialize_frame_menubar (f);
3398 #ifndef USE_GTK
3399 /* This is a no-op, except under Motif where it arranges the
3400 main window for the widgets on it. */
3401 lw_set_main_areas (f->output_data.x->column_widget,
3402 f->output_data.x->menubar_widget,
3403 f->output_data.x->edit_widget);
3404 #endif /* not USE_GTK */
3406 #endif /* USE_X_TOOLKIT || USE_GTK */
3408 /* Tell the server what size and position, etc, we want, and how
3409 badly we want them. This should be done after we have the menu
3410 bar so that its size can be taken into account. */
3411 BLOCK_INPUT;
3412 x_wm_set_size_hint (f, window_prompting, 0);
3413 UNBLOCK_INPUT;
3415 /* Make the window appear on the frame and enable display, unless
3416 the caller says not to. However, with explicit parent, Emacs
3417 cannot control visibility, so don't try. */
3418 if (! f->output_data.x->explicit_parent)
3420 Lisp_Object visibility;
3422 visibility = x_get_arg (dpyinfo, parms, Qvisibility, 0, 0,
3423 RES_TYPE_SYMBOL);
3424 if (EQ (visibility, Qunbound))
3425 visibility = Qt;
3427 if (EQ (visibility, Qicon))
3428 x_iconify_frame (f);
3429 else if (! NILP (visibility))
3430 x_make_frame_visible (f);
3431 else
3433 /* Must have been Qnil. */
3437 BLOCK_INPUT;
3439 /* Set machine name and pid for the purpose of window managers. */
3440 set_machine_and_pid_properties(f);
3442 /* Set the WM leader property. GTK does this itself, so this is not
3443 needed when using GTK. */
3444 if (dpyinfo->client_leader_window != 0)
3446 XChangeProperty (FRAME_X_DISPLAY (f),
3447 FRAME_OUTER_WINDOW (f),
3448 dpyinfo->Xatom_wm_client_leader,
3449 XA_WINDOW, 32, PropModeReplace,
3450 (unsigned char *) &dpyinfo->client_leader_window, 1);
3453 UNBLOCK_INPUT;
3455 /* Initialize `default-minibuffer-frame' in case this is the first
3456 frame on this terminal. */
3457 if (FRAME_HAS_MINIBUF_P (f)
3458 && (!FRAMEP (KVAR (kb, Vdefault_minibuffer_frame))
3459 || !FRAME_LIVE_P (XFRAME (KVAR (kb, Vdefault_minibuffer_frame)))))
3460 KVAR (kb, Vdefault_minibuffer_frame) = frame;
3462 /* All remaining specified parameters, which have not been "used"
3463 by x_get_arg and friends, now go in the misc. alist of the frame. */
3464 for (tem = parms; CONSP (tem); tem = XCDR (tem))
3465 if (CONSP (XCAR (tem)) && !NILP (XCAR (XCAR (tem))))
3466 f->param_alist = Fcons (XCAR (tem), f->param_alist);
3468 UNGCPRO;
3470 /* Make sure windows on this frame appear in calls to next-window
3471 and similar functions. */
3472 Vwindow_list = Qnil;
3474 return unbind_to (count, frame);
3478 /* FRAME is used only to get a handle on the X display. We don't pass the
3479 display info directly because we're called from frame.c, which doesn't
3480 know about that structure. */
3482 Lisp_Object
3483 x_get_focus_frame (struct frame *frame)
3485 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (frame);
3486 Lisp_Object xfocus;
3487 if (! dpyinfo->x_focus_frame)
3488 return Qnil;
3490 XSETFRAME (xfocus, dpyinfo->x_focus_frame);
3491 return xfocus;
3495 /* In certain situations, when the window manager follows a
3496 click-to-focus policy, there seems to be no way around calling
3497 XSetInputFocus to give another frame the input focus .
3499 In an ideal world, XSetInputFocus should generally be avoided so
3500 that applications don't interfere with the window manager's focus
3501 policy. But I think it's okay to use when it's clearly done
3502 following a user-command. */
3504 DEFUN ("x-focus-frame", Fx_focus_frame, Sx_focus_frame, 1, 1, 0,
3505 doc: /* Set the input focus to FRAME.
3506 FRAME nil means use the selected frame. */)
3507 (Lisp_Object frame)
3509 struct frame *f = check_x_frame (frame);
3510 Display *dpy = FRAME_X_DISPLAY (f);
3512 BLOCK_INPUT;
3513 x_catch_errors (dpy);
3514 XSetInputFocus (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3515 RevertToParent, CurrentTime);
3516 x_ewmh_activate_frame (f);
3517 x_uncatch_errors ();
3518 UNBLOCK_INPUT;
3520 return Qnil;
3524 DEFUN ("xw-color-defined-p", Fxw_color_defined_p, Sxw_color_defined_p, 1, 2, 0,
3525 doc: /* Internal function called by `color-defined-p', which see
3526 .\(Note that the Nextstep version of this function ignores FRAME.) */)
3527 (Lisp_Object color, Lisp_Object frame)
3529 XColor foo;
3530 FRAME_PTR f = check_x_frame (frame);
3532 CHECK_STRING (color);
3534 if (x_defined_color (f, SSDATA (color), &foo, 0))
3535 return Qt;
3536 else
3537 return Qnil;
3540 DEFUN ("xw-color-values", Fxw_color_values, Sxw_color_values, 1, 2, 0,
3541 doc: /* Internal function called by `color-values', which see. */)
3542 (Lisp_Object color, Lisp_Object frame)
3544 XColor foo;
3545 FRAME_PTR f = check_x_frame (frame);
3547 CHECK_STRING (color);
3549 if (x_defined_color (f, SSDATA (color), &foo, 0))
3550 return list3 (make_number (foo.red),
3551 make_number (foo.green),
3552 make_number (foo.blue));
3553 else
3554 return Qnil;
3557 DEFUN ("xw-display-color-p", Fxw_display_color_p, Sxw_display_color_p, 0, 1, 0,
3558 doc: /* Internal function called by `display-color-p', which see. */)
3559 (Lisp_Object terminal)
3561 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3563 if (dpyinfo->n_planes <= 2)
3564 return Qnil;
3566 switch (dpyinfo->visual->class)
3568 case StaticColor:
3569 case PseudoColor:
3570 case TrueColor:
3571 case DirectColor:
3572 return Qt;
3574 default:
3575 return Qnil;
3579 DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p, Sx_display_grayscale_p,
3580 0, 1, 0,
3581 doc: /* Return t if the X display supports shades of gray.
3582 Note that color displays do support shades of gray.
3583 The optional argument TERMINAL specifies which display to ask about.
3584 TERMINAL should be a terminal object, a frame or a display name (a string).
3585 If omitted or nil, that stands for the selected frame's display. */)
3586 (Lisp_Object terminal)
3588 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3590 if (dpyinfo->n_planes <= 1)
3591 return Qnil;
3593 switch (dpyinfo->visual->class)
3595 case StaticColor:
3596 case PseudoColor:
3597 case TrueColor:
3598 case DirectColor:
3599 case StaticGray:
3600 case GrayScale:
3601 return Qt;
3603 default:
3604 return Qnil;
3608 DEFUN ("x-display-pixel-width", Fx_display_pixel_width, Sx_display_pixel_width,
3609 0, 1, 0,
3610 doc: /* Return the width in pixels of the X display TERMINAL.
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 return make_number (x_display_pixel_width (dpyinfo));
3621 DEFUN ("x-display-pixel-height", Fx_display_pixel_height,
3622 Sx_display_pixel_height, 0, 1, 0,
3623 doc: /* Return the height in pixels of the X display TERMINAL.
3624 The optional argument TERMINAL specifies which display to ask about.
3625 TERMINAL should be a terminal object, a frame or a display name (a string).
3626 If omitted or nil, that stands for the selected frame's display. */)
3627 (Lisp_Object terminal)
3629 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3631 return make_number (x_display_pixel_height (dpyinfo));
3634 DEFUN ("x-display-planes", Fx_display_planes, Sx_display_planes,
3635 0, 1, 0,
3636 doc: /* Return the number of bitplanes of the X display TERMINAL.
3637 The optional argument TERMINAL specifies which display to ask about.
3638 TERMINAL should be a terminal object, a frame or a display name (a string).
3639 If omitted or nil, that stands for the selected frame's display. */)
3640 (Lisp_Object terminal)
3642 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3644 return make_number (dpyinfo->n_planes);
3647 DEFUN ("x-display-color-cells", Fx_display_color_cells, Sx_display_color_cells,
3648 0, 1, 0,
3649 doc: /* Return the number of color cells of the X display TERMINAL.
3650 The optional argument TERMINAL specifies which display to ask about.
3651 TERMINAL should be a terminal object, a frame or a display name (a string).
3652 If omitted or nil, that stands for the selected frame's display. */)
3653 (Lisp_Object terminal)
3655 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3657 int nr_planes = DisplayPlanes (dpyinfo->display,
3658 XScreenNumberOfScreen (dpyinfo->screen));
3660 /* Truncate nr_planes to 24 to avoid integer overflow.
3661 Some displays says 32, but only 24 bits are actually significant.
3662 There are only very few and rare video cards that have more than
3663 24 significant bits. Also 24 bits is more than 16 million colors,
3664 it "should be enough for everyone". */
3665 if (nr_planes > 24) nr_planes = 24;
3667 return make_number (1 << nr_planes);
3670 DEFUN ("x-server-max-request-size", Fx_server_max_request_size,
3671 Sx_server_max_request_size,
3672 0, 1, 0,
3673 doc: /* Return the maximum request size of the X server of display TERMINAL.
3674 The optional argument TERMINAL specifies which display to ask about.
3675 TERMINAL should be a terminal object, a frame or a display name (a string).
3676 If omitted or nil, that stands for the selected frame's display. */)
3677 (Lisp_Object terminal)
3679 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3681 return make_number (MAXREQUEST (dpyinfo->display));
3684 DEFUN ("x-server-vendor", Fx_server_vendor, Sx_server_vendor, 0, 1, 0,
3685 doc: /* Return the "vendor ID" string of the X server of display TERMINAL.
3686 \(Labelling every distributor as a "vendor" embodies the false assumption
3687 that operating systems cannot be developed and distributed noncommercially.)
3688 The optional argument TERMINAL specifies which display to ask about.
3689 TERMINAL should be a terminal object, a frame or a display name (a string).
3690 If omitted or nil, that stands for the selected frame's display. */)
3691 (Lisp_Object terminal)
3693 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3694 const char *vendor = ServerVendor (dpyinfo->display);
3696 if (! vendor) vendor = "";
3697 return build_string (vendor);
3700 DEFUN ("x-server-version", Fx_server_version, Sx_server_version, 0, 1, 0,
3701 doc: /* Return the version numbers of the X server of display TERMINAL.
3702 The value is a list of three integers: the major and minor
3703 version numbers of the X Protocol in use, and the distributor-specific release
3704 number. See also the function `x-server-vendor'.
3706 The optional argument TERMINAL specifies which display to ask about.
3707 TERMINAL should be a terminal object, a frame or a display name (a string).
3708 If omitted or nil, that stands for the selected frame's display. */)
3709 (Lisp_Object terminal)
3711 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3712 Display *dpy = dpyinfo->display;
3714 return Fcons (make_number (ProtocolVersion (dpy)),
3715 Fcons (make_number (ProtocolRevision (dpy)),
3716 Fcons (make_number (VendorRelease (dpy)), Qnil)));
3719 DEFUN ("x-display-screens", Fx_display_screens, Sx_display_screens, 0, 1, 0,
3720 doc: /* Return the number of screens on the X server of display TERMINAL.
3721 The optional argument TERMINAL specifies which display to ask about.
3722 TERMINAL should be a terminal object, a frame or a display name (a string).
3723 If omitted or nil, that stands for the selected frame's display. */)
3724 (Lisp_Object terminal)
3726 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3728 return make_number (ScreenCount (dpyinfo->display));
3731 DEFUN ("x-display-mm-height", Fx_display_mm_height, Sx_display_mm_height, 0, 1, 0,
3732 doc: /* Return the height in millimeters of the X display TERMINAL.
3733 The optional argument TERMINAL specifies which display to ask about.
3734 TERMINAL should be a terminal object, a frame or a display name (a string).
3735 If omitted or nil, that stands for the selected frame's display. */)
3736 (Lisp_Object terminal)
3738 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3740 return make_number (HeightMMOfScreen (dpyinfo->screen));
3743 DEFUN ("x-display-mm-width", Fx_display_mm_width, Sx_display_mm_width, 0, 1, 0,
3744 doc: /* Return the width in millimeters of the X display TERMINAL.
3745 The optional argument TERMINAL specifies which display to ask about.
3746 TERMINAL should be a terminal object, a frame or a display name (a string).
3747 If omitted or nil, that stands for the selected frame's display. */)
3748 (Lisp_Object terminal)
3750 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3752 return make_number (WidthMMOfScreen (dpyinfo->screen));
3755 DEFUN ("x-display-backing-store", Fx_display_backing_store,
3756 Sx_display_backing_store, 0, 1, 0,
3757 doc: /* Return an indication of whether X display TERMINAL does backing store.
3758 The value may be `always', `when-mapped', or `not-useful'.
3759 The optional argument TERMINAL specifies which display to ask about.
3760 TERMINAL should be a terminal object, a frame or a display name (a string).
3761 If omitted or nil, that stands for the selected frame's display. */)
3762 (Lisp_Object terminal)
3764 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3765 Lisp_Object result;
3767 switch (DoesBackingStore (dpyinfo->screen))
3769 case Always:
3770 result = intern ("always");
3771 break;
3773 case WhenMapped:
3774 result = intern ("when-mapped");
3775 break;
3777 case NotUseful:
3778 result = intern ("not-useful");
3779 break;
3781 default:
3782 error ("Strange value for BackingStore parameter of screen");
3783 result = Qnil;
3786 return result;
3789 DEFUN ("x-display-visual-class", Fx_display_visual_class,
3790 Sx_display_visual_class, 0, 1, 0,
3791 doc: /* Return the visual class of the X display TERMINAL.
3792 The value is one of the symbols `static-gray', `gray-scale',
3793 `static-color', `pseudo-color', `true-color', or `direct-color'.
3795 The optional argument TERMINAL specifies which display to ask about.
3796 TERMINAL should a terminal object, a frame or a display name (a string).
3797 If omitted or nil, that stands for the selected frame's display. */)
3798 (Lisp_Object terminal)
3800 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3801 Lisp_Object result;
3803 switch (dpyinfo->visual->class)
3805 case StaticGray:
3806 result = intern ("static-gray");
3807 break;
3808 case GrayScale:
3809 result = intern ("gray-scale");
3810 break;
3811 case StaticColor:
3812 result = intern ("static-color");
3813 break;
3814 case PseudoColor:
3815 result = intern ("pseudo-color");
3816 break;
3817 case TrueColor:
3818 result = intern ("true-color");
3819 break;
3820 case DirectColor:
3821 result = intern ("direct-color");
3822 break;
3823 default:
3824 error ("Display has an unknown visual class");
3825 result = Qnil;
3828 return result;
3831 DEFUN ("x-display-save-under", Fx_display_save_under,
3832 Sx_display_save_under, 0, 1, 0,
3833 doc: /* Return t if the X display TERMINAL supports the save-under feature.
3834 The optional argument TERMINAL specifies which display to ask about.
3835 TERMINAL should be a terminal object, a frame or a display name (a string).
3836 If omitted or nil, that stands for the selected frame's display. */)
3837 (Lisp_Object terminal)
3839 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3841 if (DoesSaveUnders (dpyinfo->screen) == True)
3842 return Qt;
3843 else
3844 return Qnil;
3848 x_pixel_width (register struct frame *f)
3850 return FRAME_PIXEL_WIDTH (f);
3854 x_pixel_height (register struct frame *f)
3856 return FRAME_PIXEL_HEIGHT (f);
3860 x_char_width (register struct frame *f)
3862 return FRAME_COLUMN_WIDTH (f);
3866 x_char_height (register struct frame *f)
3868 return FRAME_LINE_HEIGHT (f);
3873 /************************************************************************
3874 X Displays
3875 ************************************************************************/
3878 /* Mapping visual names to visuals. */
3880 static struct visual_class
3882 const char *name;
3883 int class;
3885 visual_classes[] =
3887 {"StaticGray", StaticGray},
3888 {"GrayScale", GrayScale},
3889 {"StaticColor", StaticColor},
3890 {"PseudoColor", PseudoColor},
3891 {"TrueColor", TrueColor},
3892 {"DirectColor", DirectColor},
3893 {NULL, 0}
3897 #ifndef HAVE_XSCREENNUMBEROFSCREEN
3899 /* Value is the screen number of screen SCR. This is a substitute for
3900 the X function with the same name when that doesn't exist. */
3903 XScreenNumberOfScreen (scr)
3904 register Screen *scr;
3906 Display *dpy = scr->display;
3907 int i;
3909 for (i = 0; i < dpy->nscreens; ++i)
3910 if (scr == dpy->screens + i)
3911 break;
3913 return i;
3916 #endif /* not HAVE_XSCREENNUMBEROFSCREEN */
3919 /* Select the visual that should be used on display DPYINFO. Set
3920 members of DPYINFO appropriately. Called from x_term_init. */
3922 void
3923 select_visual (struct x_display_info *dpyinfo)
3925 Display *dpy = dpyinfo->display;
3926 Screen *screen = dpyinfo->screen;
3927 Lisp_Object value;
3929 /* See if a visual is specified. */
3930 value = display_x_get_resource (dpyinfo,
3931 build_string ("visualClass"),
3932 build_string ("VisualClass"),
3933 Qnil, Qnil);
3934 if (STRINGP (value))
3936 /* VALUE should be of the form CLASS-DEPTH, where CLASS is one
3937 of `PseudoColor', `TrueColor' etc. and DEPTH is the color
3938 depth, a decimal number. NAME is compared with case ignored. */
3939 char *s = (char *) alloca (SBYTES (value) + 1);
3940 char *dash;
3941 int i, class = -1;
3942 XVisualInfo vinfo;
3944 strcpy (s, SSDATA (value));
3945 dash = strchr (s, '-');
3946 if (dash)
3948 dpyinfo->n_planes = atoi (dash + 1);
3949 *dash = '\0';
3951 else
3952 /* We won't find a matching visual with depth 0, so that
3953 an error will be printed below. */
3954 dpyinfo->n_planes = 0;
3956 /* Determine the visual class. */
3957 for (i = 0; visual_classes[i].name; ++i)
3958 if (xstrcasecmp (s, visual_classes[i].name) == 0)
3960 class = visual_classes[i].class;
3961 break;
3964 /* Look up a matching visual for the specified class. */
3965 if (class == -1
3966 || !XMatchVisualInfo (dpy, XScreenNumberOfScreen (screen),
3967 dpyinfo->n_planes, class, &vinfo))
3968 fatal ("Invalid visual specification `%s'", SDATA (value));
3970 dpyinfo->visual = vinfo.visual;
3972 else
3974 int n_visuals;
3975 XVisualInfo *vinfo, vinfo_template;
3977 dpyinfo->visual = DefaultVisualOfScreen (screen);
3979 vinfo_template.visualid = XVisualIDFromVisual (dpyinfo->visual);
3980 vinfo_template.screen = XScreenNumberOfScreen (screen);
3981 vinfo = XGetVisualInfo (dpy, VisualIDMask | VisualScreenMask,
3982 &vinfo_template, &n_visuals);
3983 if (n_visuals <= 0)
3984 fatal ("Can't get proper X visual info");
3986 dpyinfo->n_planes = vinfo->depth;
3987 XFree ((char *) vinfo);
3992 /* Return the X display structure for the display named NAME.
3993 Open a new connection if necessary. */
3995 static struct x_display_info *
3996 x_display_info_for_name (Lisp_Object name)
3998 Lisp_Object names;
3999 struct x_display_info *dpyinfo;
4001 CHECK_STRING (name);
4003 #if 0
4004 if (! EQ (Vinitial_window_system, intern ("x")))
4005 error ("Not using X Windows"); /* That doesn't stop us anymore. */
4006 #endif
4008 for (dpyinfo = x_display_list, names = x_display_name_list;
4009 dpyinfo;
4010 dpyinfo = dpyinfo->next, names = XCDR (names))
4012 Lisp_Object tem;
4013 tem = Fstring_equal (XCAR (XCAR (names)), name);
4014 if (!NILP (tem))
4015 return dpyinfo;
4018 /* Use this general default value to start with. */
4019 Vx_resource_name = Vinvocation_name;
4021 validate_x_resource_name ();
4023 dpyinfo = x_term_init (name, (char *)0,
4024 SSDATA (Vx_resource_name));
4026 if (dpyinfo == 0)
4027 error ("Cannot connect to X server %s", SDATA (name));
4029 x_in_use = 1;
4030 XSETFASTINT (Vwindow_system_version, 11);
4032 return dpyinfo;
4036 DEFUN ("x-open-connection", Fx_open_connection, Sx_open_connection,
4037 1, 3, 0,
4038 doc: /* Open a connection to a display server.
4039 DISPLAY is the name of the display to connect to.
4040 Optional second arg XRM-STRING is a string of resources in xrdb format.
4041 If the optional third arg MUST-SUCCEED is non-nil,
4042 terminate Emacs if we can't open the connection.
4043 \(In the Nextstep version, the last two arguments are currently ignored.) */)
4044 (Lisp_Object display, Lisp_Object xrm_string, Lisp_Object must_succeed)
4046 char *xrm_option;
4047 struct x_display_info *dpyinfo;
4049 CHECK_STRING (display);
4050 if (! NILP (xrm_string))
4051 CHECK_STRING (xrm_string);
4053 #if 0
4054 if (! EQ (Vinitial_window_system, intern ("x")))
4055 error ("Not using X Windows"); /* That doesn't stop us anymore. */
4056 #endif
4058 if (! NILP (xrm_string))
4059 xrm_option = SSDATA (xrm_string);
4060 else
4061 xrm_option = (char *) 0;
4063 validate_x_resource_name ();
4065 /* This is what opens the connection and sets x_current_display.
4066 This also initializes many symbols, such as those used for input. */
4067 dpyinfo = x_term_init (display, xrm_option,
4068 SSDATA (Vx_resource_name));
4070 if (dpyinfo == 0)
4072 if (!NILP (must_succeed))
4073 fatal ("Cannot connect to X server %s.\n\
4074 Check the DISPLAY environment variable or use `-d'.\n\
4075 Also use the `xauth' program to verify that you have the proper\n\
4076 authorization information needed to connect the X server.\n\
4077 An insecure way to solve the problem may be to use `xhost'.\n",
4078 SDATA (display));
4079 else
4080 error ("Cannot connect to X server %s", SDATA (display));
4083 x_in_use = 1;
4085 XSETFASTINT (Vwindow_system_version, 11);
4086 return Qnil;
4089 DEFUN ("x-close-connection", Fx_close_connection,
4090 Sx_close_connection, 1, 1, 0,
4091 doc: /* Close the connection to TERMINAL's X server.
4092 For TERMINAL, specify a terminal object, a frame or a display name (a
4093 string). If TERMINAL is nil, that stands for the selected frame's
4094 terminal. */)
4095 (Lisp_Object terminal)
4097 struct x_display_info *dpyinfo = check_x_display_info (terminal);
4099 if (dpyinfo->reference_count > 0)
4100 error ("Display still has frames on it");
4102 x_delete_terminal (dpyinfo->terminal);
4104 return Qnil;
4107 DEFUN ("x-display-list", Fx_display_list, Sx_display_list, 0, 0, 0,
4108 doc: /* Return the list of display names that Emacs has connections to. */)
4109 (void)
4111 Lisp_Object tail, result;
4113 result = Qnil;
4114 for (tail = x_display_name_list; CONSP (tail); tail = XCDR (tail))
4115 result = Fcons (XCAR (XCAR (tail)), result);
4117 return result;
4120 DEFUN ("x-synchronize", Fx_synchronize, Sx_synchronize, 1, 2, 0,
4121 doc: /* If ON is non-nil, report X errors as soon as the erring request is made.
4122 This function only has an effect on X Windows. With MS Windows, it is
4123 defined but does nothing.
4125 If ON is nil, allow buffering of requests.
4126 Turning on synchronization prohibits the Xlib routines from buffering
4127 requests and seriously degrades performance, but makes debugging much
4128 easier.
4129 The optional second argument TERMINAL specifies which display to act on.
4130 TERMINAL should be a terminal object, a frame or a display name (a string).
4131 If TERMINAL is omitted or nil, that stands for the selected frame's display. */)
4132 (Lisp_Object on, Lisp_Object terminal)
4134 struct x_display_info *dpyinfo = check_x_display_info (terminal);
4136 XSynchronize (dpyinfo->display, !EQ (on, Qnil));
4138 return Qnil;
4141 /* Wait for responses to all X commands issued so far for frame F. */
4143 void
4144 x_sync (FRAME_PTR f)
4146 BLOCK_INPUT;
4147 XSync (FRAME_X_DISPLAY (f), False);
4148 UNBLOCK_INPUT;
4152 /***********************************************************************
4153 Window properties
4154 ***********************************************************************/
4156 DEFUN ("x-change-window-property", Fx_change_window_property,
4157 Sx_change_window_property, 2, 6, 0,
4158 doc: /* Change window property PROP to VALUE on the X window of FRAME.
4159 PROP must be a string. VALUE may be a string or a list of conses,
4160 numbers and/or strings. If an element in the list is a string, it is
4161 converted to an atom and the value of the atom is used. If an element
4162 is a cons, it is converted to a 32 bit number where the car is the 16
4163 top bits and the cdr is the lower 16 bits.
4165 FRAME nil or omitted means use the selected frame.
4166 If TYPE is given and non-nil, it is the name of the type of VALUE.
4167 If TYPE is not given or nil, the type is STRING.
4168 FORMAT gives the size in bits of each element if VALUE is a list.
4169 It must be one of 8, 16 or 32.
4170 If VALUE is a string or FORMAT is nil or not given, FORMAT defaults to 8.
4171 If OUTER_P is non-nil, the property is changed for the outer X window of
4172 FRAME. Default is to change on the edit X window. */)
4173 (Lisp_Object prop, Lisp_Object value, Lisp_Object frame, Lisp_Object type, Lisp_Object format, Lisp_Object outer_p)
4175 struct frame *f = check_x_frame (frame);
4176 Atom prop_atom;
4177 Atom target_type = XA_STRING;
4178 int element_format = 8;
4179 unsigned char *data;
4180 int nelements;
4181 Window w;
4183 CHECK_STRING (prop);
4185 if (! NILP (format))
4187 CHECK_NUMBER (format);
4188 element_format = XFASTINT (format);
4190 if (element_format != 8 && element_format != 16
4191 && element_format != 32)
4192 error ("FORMAT must be one of 8, 16 or 32");
4195 if (CONSP (value))
4197 nelements = x_check_property_data (value);
4198 if (nelements == -1)
4199 error ("Bad data in VALUE, must be number, string or cons");
4201 if (element_format == 8)
4202 data = (unsigned char *) xmalloc (nelements);
4203 else if (element_format == 16)
4204 data = (unsigned char *) xmalloc (nelements*2);
4205 else /* format == 32 */
4206 /* The man page for XChangeProperty:
4207 "If the specified format is 32, the property data must be a
4208 long array."
4209 This applies even if long is more than 64 bits. The X library
4210 converts to 32 bits before sending to the X server. */
4211 data = (unsigned char *) xmalloc (nelements * sizeof(long));
4213 x_fill_property_data (FRAME_X_DISPLAY (f), value, data, element_format);
4215 else
4217 CHECK_STRING (value);
4218 data = SDATA (value);
4219 nelements = SCHARS (value);
4222 BLOCK_INPUT;
4223 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (prop), False);
4224 if (! NILP (type))
4226 CHECK_STRING (type);
4227 target_type = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (type), False);
4230 if (! NILP (outer_p)) w = FRAME_OUTER_WINDOW (f);
4231 else w = FRAME_X_WINDOW (f);
4233 XChangeProperty (FRAME_X_DISPLAY (f), w,
4234 prop_atom, target_type, element_format, PropModeReplace,
4235 data, nelements);
4237 if (CONSP (value)) xfree (data);
4239 /* Make sure the property is set when we return. */
4240 XFlush (FRAME_X_DISPLAY (f));
4241 UNBLOCK_INPUT;
4243 return value;
4247 DEFUN ("x-delete-window-property", Fx_delete_window_property,
4248 Sx_delete_window_property, 1, 2, 0,
4249 doc: /* Remove window property PROP from X window of FRAME.
4250 FRAME nil or omitted means use the selected frame. Value is PROP. */)
4251 (Lisp_Object prop, Lisp_Object frame)
4253 struct frame *f = check_x_frame (frame);
4254 Atom prop_atom;
4256 CHECK_STRING (prop);
4257 BLOCK_INPUT;
4258 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (prop), False);
4259 XDeleteProperty (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), prop_atom);
4261 /* Make sure the property is removed when we return. */
4262 XFlush (FRAME_X_DISPLAY (f));
4263 UNBLOCK_INPUT;
4265 return prop;
4269 DEFUN ("x-window-property", Fx_window_property, Sx_window_property,
4270 1, 6, 0,
4271 doc: /* Value is the value of window property PROP on FRAME.
4272 If FRAME is nil or omitted, use the selected frame.
4274 On MS Windows, this function only accepts the PROP and FRAME arguments.
4276 On X Windows, the following optional arguments are also accepted:
4277 If TYPE is nil or omitted, get the property as a string.
4278 Otherwise TYPE is the name of the atom that denotes the type expected.
4279 If SOURCE is non-nil, get the property on that window instead of from
4280 FRAME. The number 0 denotes the root window.
4281 If DELETE_P is non-nil, delete the property after retreiving it.
4282 If VECTOR_RET_P is non-nil, don't return a string but a vector of values.
4284 Value is nil if FRAME hasn't a property with name PROP or if PROP has
4285 no value of TYPE (always string in the MS Windows case). */)
4286 (Lisp_Object prop, Lisp_Object frame, Lisp_Object type, Lisp_Object source, Lisp_Object delete_p, Lisp_Object vector_ret_p)
4288 struct frame *f = check_x_frame (frame);
4289 Atom prop_atom;
4290 int rc;
4291 Lisp_Object prop_value = Qnil;
4292 unsigned char *tmp_data = NULL;
4293 Atom actual_type;
4294 Atom target_type = XA_STRING;
4295 int actual_format;
4296 unsigned long actual_size, bytes_remaining;
4297 Window target_window = FRAME_X_WINDOW (f);
4298 struct gcpro gcpro1;
4300 GCPRO1 (prop_value);
4301 CHECK_STRING (prop);
4303 if (! NILP (source))
4305 CONS_TO_INTEGER (source, Window, target_window);
4306 if (! target_window)
4307 target_window = FRAME_X_DISPLAY_INFO (f)->root_window;
4310 BLOCK_INPUT;
4311 if (STRINGP (type))
4313 if (strcmp ("AnyPropertyType", SSDATA (type)) == 0)
4314 target_type = AnyPropertyType;
4315 else
4316 target_type = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (type), False);
4319 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (prop), False);
4320 rc = XGetWindowProperty (FRAME_X_DISPLAY (f), target_window,
4321 prop_atom, 0, 0, False, target_type,
4322 &actual_type, &actual_format, &actual_size,
4323 &bytes_remaining, &tmp_data);
4324 if (rc == Success)
4326 int size = bytes_remaining;
4328 XFree (tmp_data);
4329 tmp_data = NULL;
4331 rc = XGetWindowProperty (FRAME_X_DISPLAY (f), target_window,
4332 prop_atom, 0, bytes_remaining,
4333 ! NILP (delete_p), target_type,
4334 &actual_type, &actual_format,
4335 &actual_size, &bytes_remaining,
4336 &tmp_data);
4337 if (rc == Success && tmp_data)
4339 /* The man page for XGetWindowProperty says:
4340 "If the returned format is 32, the returned data is represented
4341 as a long array and should be cast to that type to obtain the
4342 elements."
4343 This applies even if long is more than 32 bits, the X library
4344 converts from 32 bit elements received from the X server to long
4345 and passes the long array to us. Thus, for that case memcpy can not
4346 be used. We convert to a 32 bit type here, because so much code
4347 assume on that.
4349 The bytes and offsets passed to XGetWindowProperty refers to the
4350 property and those are indeed in 32 bit quantities if format is
4351 32. */
4353 if (32 < BITS_PER_LONG && actual_format == 32)
4355 unsigned long i;
4356 int *idata = (int *) tmp_data;
4357 long *ldata = (long *) tmp_data;
4359 for (i = 0; i < actual_size; ++i)
4360 idata[i] = (int) ldata[i];
4363 if (NILP (vector_ret_p))
4364 prop_value = make_string ((char *) tmp_data, size);
4365 else
4366 prop_value = x_property_data_to_lisp (f,
4367 tmp_data,
4368 actual_type,
4369 actual_format,
4370 actual_size);
4373 if (tmp_data) XFree (tmp_data);
4376 UNBLOCK_INPUT;
4377 UNGCPRO;
4378 return prop_value;
4383 /***********************************************************************
4384 Busy cursor
4385 ***********************************************************************/
4387 /* Timer function of hourglass_atimer. TIMER is equal to
4388 hourglass_atimer.
4390 Display an hourglass pointer on all frames by mapping the frames'
4391 hourglass_window. Set the hourglass_p flag in the frames'
4392 output_data.x structure to indicate that an hourglass cursor is
4393 shown on the frames. */
4395 void
4396 show_hourglass (struct atimer *timer)
4398 /* The timer implementation will cancel this timer automatically
4399 after this function has run. Set hourglass_atimer to null
4400 so that we know the timer doesn't have to be canceled. */
4401 hourglass_atimer = NULL;
4403 if (!hourglass_shown_p)
4405 Lisp_Object rest, frame;
4407 BLOCK_INPUT;
4409 FOR_EACH_FRAME (rest, frame)
4411 struct frame *f = XFRAME (frame);
4413 if (FRAME_LIVE_P (f) && FRAME_X_P (f) && FRAME_X_DISPLAY (f))
4415 Display *dpy = FRAME_X_DISPLAY (f);
4417 #ifdef USE_X_TOOLKIT
4418 if (f->output_data.x->widget)
4419 #else
4420 if (FRAME_OUTER_WINDOW (f))
4421 #endif
4423 f->output_data.x->hourglass_p = 1;
4425 if (!f->output_data.x->hourglass_window)
4427 unsigned long mask = CWCursor;
4428 XSetWindowAttributes attrs;
4429 #ifdef USE_GTK
4430 Window parent = FRAME_X_WINDOW (f);
4431 #else
4432 Window parent = FRAME_OUTER_WINDOW (f);
4433 #endif
4434 attrs.cursor = f->output_data.x->hourglass_cursor;
4436 f->output_data.x->hourglass_window
4437 = XCreateWindow (dpy, parent,
4438 0, 0, 32000, 32000, 0, 0,
4439 InputOnly,
4440 CopyFromParent,
4441 mask, &attrs);
4444 XMapRaised (dpy, f->output_data.x->hourglass_window);
4445 XFlush (dpy);
4450 hourglass_shown_p = 1;
4451 UNBLOCK_INPUT;
4456 /* Hide the hourglass pointer on all frames, if it is currently
4457 shown. */
4459 void
4460 hide_hourglass (void)
4462 if (hourglass_shown_p)
4464 Lisp_Object rest, frame;
4466 BLOCK_INPUT;
4467 FOR_EACH_FRAME (rest, frame)
4469 struct frame *f = XFRAME (frame);
4471 if (FRAME_X_P (f)
4472 /* Watch out for newly created frames. */
4473 && f->output_data.x->hourglass_window)
4475 XUnmapWindow (FRAME_X_DISPLAY (f),
4476 f->output_data.x->hourglass_window);
4477 /* Sync here because XTread_socket looks at the
4478 hourglass_p flag that is reset to zero below. */
4479 XSync (FRAME_X_DISPLAY (f), False);
4480 f->output_data.x->hourglass_p = 0;
4484 hourglass_shown_p = 0;
4485 UNBLOCK_INPUT;
4491 /***********************************************************************
4492 Tool tips
4493 ***********************************************************************/
4495 static Lisp_Object x_create_tip_frame (struct x_display_info *,
4496 Lisp_Object, Lisp_Object);
4497 static void compute_tip_xy (struct frame *, Lisp_Object, Lisp_Object,
4498 Lisp_Object, int, int, int *, int *);
4500 /* The frame of a currently visible tooltip. */
4502 Lisp_Object tip_frame;
4504 /* If non-nil, a timer started that hides the last tooltip when it
4505 fires. */
4507 static Lisp_Object tip_timer;
4508 Window tip_window;
4510 /* If non-nil, a vector of 3 elements containing the last args
4511 with which x-show-tip was called. See there. */
4513 static Lisp_Object last_show_tip_args;
4516 static Lisp_Object
4517 unwind_create_tip_frame (Lisp_Object frame)
4519 Lisp_Object deleted;
4521 deleted = unwind_create_frame (frame);
4522 if (EQ (deleted, Qt))
4524 tip_window = None;
4525 tip_frame = Qnil;
4528 return deleted;
4532 /* Create a frame for a tooltip on the display described by DPYINFO.
4533 PARMS is a list of frame parameters. TEXT is the string to
4534 display in the tip frame. Value is the frame.
4536 Note that functions called here, esp. x_default_parameter can
4537 signal errors, for instance when a specified color name is
4538 undefined. We have to make sure that we're in a consistent state
4539 when this happens. */
4541 static Lisp_Object
4542 x_create_tip_frame (struct x_display_info *dpyinfo,
4543 Lisp_Object parms,
4544 Lisp_Object text)
4546 struct frame *f;
4547 Lisp_Object frame;
4548 Lisp_Object name;
4549 int width, height;
4550 int count = SPECPDL_INDEX ();
4551 struct gcpro gcpro1, gcpro2, gcpro3;
4552 int face_change_count_before = face_change_count;
4553 Lisp_Object buffer;
4554 struct buffer *old_buffer;
4556 check_x ();
4558 if (!dpyinfo->terminal->name)
4559 error ("Terminal is not live, can't create new frames on it");
4561 parms = Fcopy_alist (parms);
4563 /* Get the name of the frame to use for resource lookup. */
4564 name = x_get_arg (dpyinfo, parms, Qname, "name", "Name", RES_TYPE_STRING);
4565 if (!STRINGP (name)
4566 && !EQ (name, Qunbound)
4567 && !NILP (name))
4568 error ("Invalid frame name--not a string or nil");
4570 frame = Qnil;
4571 GCPRO3 (parms, name, frame);
4572 f = make_frame (1);
4573 XSETFRAME (frame, f);
4575 buffer = Fget_buffer_create (build_string (" *tip*"));
4576 Fset_window_buffer (FRAME_ROOT_WINDOW (f), buffer, Qnil);
4577 old_buffer = current_buffer;
4578 set_buffer_internal_1 (XBUFFER (buffer));
4579 BVAR (current_buffer, truncate_lines) = Qnil;
4580 specbind (Qinhibit_read_only, Qt);
4581 specbind (Qinhibit_modification_hooks, Qt);
4582 Ferase_buffer ();
4583 Finsert (1, &text);
4584 set_buffer_internal_1 (old_buffer);
4586 FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
4587 record_unwind_protect (unwind_create_tip_frame, frame);
4589 f->terminal = dpyinfo->terminal;
4590 f->terminal->reference_count++;
4592 /* By setting the output method, we're essentially saying that
4593 the frame is live, as per FRAME_LIVE_P. If we get a signal
4594 from this point on, x_destroy_window might screw up reference
4595 counts etc. */
4596 f->output_method = output_x_window;
4597 f->output_data.x = (struct x_output *) xmalloc (sizeof (struct x_output));
4598 memset (f->output_data.x, 0, sizeof (struct x_output));
4599 f->output_data.x->icon_bitmap = -1;
4600 FRAME_FONTSET (f) = -1;
4601 f->output_data.x->scroll_bar_foreground_pixel = -1;
4602 f->output_data.x->scroll_bar_background_pixel = -1;
4603 #ifdef USE_TOOLKIT_SCROLL_BARS
4604 f->output_data.x->scroll_bar_top_shadow_pixel = -1;
4605 f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
4606 #endif /* USE_TOOLKIT_SCROLL_BARS */
4607 f->icon_name = Qnil;
4608 FRAME_X_DISPLAY_INFO (f) = dpyinfo;
4609 #if GLYPH_DEBUG
4610 image_cache_refcount = FRAME_IMAGE_CACHE (f)->refcount;
4611 dpyinfo_refcount = dpyinfo->reference_count;
4612 #endif /* GLYPH_DEBUG */
4613 f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
4614 f->output_data.x->explicit_parent = 0;
4616 /* These colors will be set anyway later, but it's important
4617 to get the color reference counts right, so initialize them! */
4619 Lisp_Object black;
4620 struct gcpro inner_gcpro1;
4622 /* Function x_decode_color can signal an error. Make
4623 sure to initialize color slots so that we won't try
4624 to free colors we haven't allocated. */
4625 FRAME_FOREGROUND_PIXEL (f) = -1;
4626 FRAME_BACKGROUND_PIXEL (f) = -1;
4627 f->output_data.x->cursor_pixel = -1;
4628 f->output_data.x->cursor_foreground_pixel = -1;
4629 f->output_data.x->border_pixel = -1;
4630 f->output_data.x->mouse_pixel = -1;
4632 black = build_string ("black");
4633 GCPRO1_VAR (black, inner_gcpro);
4634 FRAME_FOREGROUND_PIXEL (f)
4635 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4636 FRAME_BACKGROUND_PIXEL (f)
4637 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4638 f->output_data.x->cursor_pixel
4639 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4640 f->output_data.x->cursor_foreground_pixel
4641 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4642 f->output_data.x->border_pixel
4643 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4644 f->output_data.x->mouse_pixel
4645 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4646 UNGCPRO_VAR (inner_gcpro);
4649 /* Set the name; the functions to which we pass f expect the name to
4650 be set. */
4651 if (EQ (name, Qunbound) || NILP (name))
4653 f->name = build_string (dpyinfo->x_id_name);
4654 f->explicit_name = 0;
4656 else
4658 f->name = name;
4659 f->explicit_name = 1;
4660 /* use the frame's title when getting resources for this frame. */
4661 specbind (Qx_resource_name, name);
4664 f->resx = dpyinfo->resx;
4665 f->resy = dpyinfo->resy;
4667 register_font_driver (&xfont_driver, f);
4668 #ifdef HAVE_FREETYPE
4669 #ifdef HAVE_XFT
4670 register_font_driver (&xftfont_driver, f);
4671 #else /* not HAVE_XFT */
4672 register_font_driver (&ftxfont_driver, f);
4673 #endif /* not HAVE_XFT */
4674 #endif /* HAVE_FREETYPE */
4676 x_default_parameter (f, parms, Qfont_backend, Qnil,
4677 "fontBackend", "FontBackend", RES_TYPE_STRING);
4679 /* Extract the window parameters from the supplied values that are
4680 needed to determine window geometry. */
4681 x_default_font_parameter (f, parms);
4683 x_default_parameter (f, parms, Qborder_width, make_number (0),
4684 "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
4686 /* This defaults to 2 in order to match xterm. We recognize either
4687 internalBorderWidth or internalBorder (which is what xterm calls
4688 it). */
4689 if (NILP (Fassq (Qinternal_border_width, parms)))
4691 Lisp_Object value;
4693 value = x_get_arg (dpyinfo, parms, Qinternal_border_width,
4694 "internalBorder", "internalBorder", RES_TYPE_NUMBER);
4695 if (! EQ (value, Qunbound))
4696 parms = Fcons (Fcons (Qinternal_border_width, value),
4697 parms);
4700 x_default_parameter (f, parms, Qinternal_border_width, make_number (1),
4701 "internalBorderWidth", "internalBorderWidth",
4702 RES_TYPE_NUMBER);
4704 /* Also do the stuff which must be set before the window exists. */
4705 x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
4706 "foreground", "Foreground", RES_TYPE_STRING);
4707 x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
4708 "background", "Background", RES_TYPE_STRING);
4709 x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
4710 "pointerColor", "Foreground", RES_TYPE_STRING);
4711 x_default_parameter (f, parms, Qcursor_color, build_string ("black"),
4712 "cursorColor", "Foreground", RES_TYPE_STRING);
4713 x_default_parameter (f, parms, Qborder_color, build_string ("black"),
4714 "borderColor", "BorderColor", RES_TYPE_STRING);
4716 /* Init faces before x_default_parameter is called for scroll-bar
4717 parameters because that function calls x_set_scroll_bar_width,
4718 which calls change_frame_size, which calls Fset_window_buffer,
4719 which runs hooks, which call Fvertical_motion. At the end, we
4720 end up in init_iterator with a null face cache, which should not
4721 happen. */
4722 init_frame_faces (f);
4724 f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
4726 x_figure_window_size (f, parms, 0);
4729 XSetWindowAttributes attrs;
4730 unsigned long mask;
4731 Atom type = FRAME_X_DISPLAY_INFO (f)->Xatom_net_window_type_tooltip;
4733 BLOCK_INPUT;
4734 mask = CWBackPixel | CWOverrideRedirect | CWEventMask;
4735 if (DoesSaveUnders (dpyinfo->screen))
4736 mask |= CWSaveUnder;
4738 /* Window managers look at the override-redirect flag to determine
4739 whether or net to give windows a decoration (Xlib spec, chapter
4740 3.2.8). */
4741 attrs.override_redirect = True;
4742 attrs.save_under = True;
4743 attrs.background_pixel = FRAME_BACKGROUND_PIXEL (f);
4744 /* Arrange for getting MapNotify and UnmapNotify events. */
4745 attrs.event_mask = StructureNotifyMask;
4746 tip_window
4747 = FRAME_X_WINDOW (f)
4748 = XCreateWindow (FRAME_X_DISPLAY (f),
4749 FRAME_X_DISPLAY_INFO (f)->root_window,
4750 /* x, y, width, height */
4751 0, 0, 1, 1,
4752 /* Border. */
4753 f->border_width,
4754 CopyFromParent, InputOutput, CopyFromParent,
4755 mask, &attrs);
4756 XChangeProperty (FRAME_X_DISPLAY (f), tip_window,
4757 FRAME_X_DISPLAY_INFO (f)->Xatom_net_window_type,
4758 XA_ATOM, 32, PropModeReplace,
4759 (unsigned char *)&type, 1);
4760 UNBLOCK_INPUT;
4763 x_make_gc (f);
4765 x_default_parameter (f, parms, Qauto_raise, Qnil,
4766 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
4767 x_default_parameter (f, parms, Qauto_lower, Qnil,
4768 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
4769 x_default_parameter (f, parms, Qcursor_type, Qbox,
4770 "cursorType", "CursorType", RES_TYPE_SYMBOL);
4772 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
4773 Change will not be effected unless different from the current
4774 FRAME_LINES (f). */
4775 width = FRAME_COLS (f);
4776 height = FRAME_LINES (f);
4777 SET_FRAME_COLS (f, 0);
4778 FRAME_LINES (f) = 0;
4779 change_frame_size (f, height, width, 1, 0, 0);
4781 /* Add `tooltip' frame parameter's default value. */
4782 if (NILP (Fframe_parameter (frame, Qtooltip)))
4783 Fmodify_frame_parameters (frame, Fcons (Fcons (Qtooltip, Qt), Qnil));
4785 /* FIXME - can this be done in a similar way to normal frames?
4786 http://lists.gnu.org/archive/html/emacs-devel/2007-10/msg00641.html */
4788 /* Set the `display-type' frame parameter before setting up faces. */
4790 Lisp_Object disptype;
4792 if (FRAME_X_DISPLAY_INFO (f)->n_planes == 1)
4793 disptype = intern ("mono");
4794 else if (FRAME_X_DISPLAY_INFO (f)->visual->class == GrayScale
4795 || FRAME_X_DISPLAY_INFO (f)->visual->class == StaticGray)
4796 disptype = intern ("grayscale");
4797 else
4798 disptype = intern ("color");
4800 if (NILP (Fframe_parameter (frame, Qdisplay_type)))
4801 Fmodify_frame_parameters (frame, Fcons (Fcons (Qdisplay_type, disptype),
4802 Qnil));
4805 /* Set up faces after all frame parameters are known. This call
4806 also merges in face attributes specified for new frames.
4808 Frame parameters may be changed if .Xdefaults contains
4809 specifications for the default font. For example, if there is an
4810 `Emacs.default.attributeBackground: pink', the `background-color'
4811 attribute of the frame get's set, which let's the internal border
4812 of the tooltip frame appear in pink. Prevent this. */
4814 Lisp_Object bg = Fframe_parameter (frame, Qbackground_color);
4816 /* Set tip_frame here, so that */
4817 tip_frame = frame;
4818 call2 (Qface_set_after_frame_default, frame, Qnil);
4820 if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
4821 Fmodify_frame_parameters (frame, Fcons (Fcons (Qbackground_color, bg),
4822 Qnil));
4825 f->no_split = 1;
4827 UNGCPRO;
4829 /* It is now ok to make the frame official even if we get an error
4830 below. And the frame needs to be on Vframe_list or making it
4831 visible won't work. */
4832 Vframe_list = Fcons (frame, Vframe_list);
4834 /* Now that the frame is official, it counts as a reference to
4835 its display. */
4836 FRAME_X_DISPLAY_INFO (f)->reference_count++;
4838 /* Setting attributes of faces of the tooltip frame from resources
4839 and similar will increment face_change_count, which leads to the
4840 clearing of all current matrices. Since this isn't necessary
4841 here, avoid it by resetting face_change_count to the value it
4842 had before we created the tip frame. */
4843 face_change_count = face_change_count_before;
4845 /* Discard the unwind_protect. */
4846 return unbind_to (count, frame);
4850 /* Compute where to display tip frame F. PARMS is the list of frame
4851 parameters for F. DX and DY are specified offsets from the current
4852 location of the mouse. WIDTH and HEIGHT are the width and height
4853 of the tooltip. Return coordinates relative to the root window of
4854 the display in *ROOT_X, and *ROOT_Y. */
4856 static void
4857 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)
4859 Lisp_Object left, top;
4860 int win_x, win_y;
4861 Window root, child;
4862 unsigned pmask;
4864 /* User-specified position? */
4865 left = Fcdr (Fassq (Qleft, parms));
4866 top = Fcdr (Fassq (Qtop, parms));
4868 /* Move the tooltip window where the mouse pointer is. Resize and
4869 show it. */
4870 if (!INTEGERP (left) || !INTEGERP (top))
4872 BLOCK_INPUT;
4873 XQueryPointer (FRAME_X_DISPLAY (f), FRAME_X_DISPLAY_INFO (f)->root_window,
4874 &root, &child, root_x, root_y, &win_x, &win_y, &pmask);
4875 UNBLOCK_INPUT;
4878 if (INTEGERP (top))
4879 *root_y = XINT (top);
4880 else if (*root_y + XINT (dy) <= 0)
4881 *root_y = 0; /* Can happen for negative dy */
4882 else if (*root_y + XINT (dy) + height
4883 <= x_display_pixel_height (FRAME_X_DISPLAY_INFO (f)))
4884 /* It fits below the pointer */
4885 *root_y += XINT (dy);
4886 else if (height + XINT (dy) <= *root_y)
4887 /* It fits above the pointer. */
4888 *root_y -= height + XINT (dy);
4889 else
4890 /* Put it on the top. */
4891 *root_y = 0;
4893 if (INTEGERP (left))
4894 *root_x = XINT (left);
4895 else if (*root_x + XINT (dx) <= 0)
4896 *root_x = 0; /* Can happen for negative dx */
4897 else if (*root_x + XINT (dx) + width
4898 <= x_display_pixel_width (FRAME_X_DISPLAY_INFO (f)))
4899 /* It fits to the right of the pointer. */
4900 *root_x += XINT (dx);
4901 else if (width + XINT (dx) <= *root_x)
4902 /* It fits to the left of the pointer. */
4903 *root_x -= width + XINT (dx);
4904 else
4905 /* Put it left-justified on the screen--it ought to fit that way. */
4906 *root_x = 0;
4910 DEFUN ("x-show-tip", Fx_show_tip, Sx_show_tip, 1, 6, 0,
4911 doc: /* Show STRING in a "tooltip" window on frame FRAME.
4912 A tooltip window is a small X window displaying a string.
4914 This is an internal function; Lisp code should call `tooltip-show'.
4916 FRAME nil or omitted means use the selected frame.
4918 PARMS is an optional list of frame parameters which can be used to
4919 change the tooltip's appearance.
4921 Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
4922 means use the default timeout of 5 seconds.
4924 If the list of frame parameters PARMS contains a `left' parameters,
4925 the tooltip is displayed at that x-position. Otherwise it is
4926 displayed at the mouse position, with offset DX added (default is 5 if
4927 DX isn't specified). Likewise for the y-position; if a `top' frame
4928 parameter is specified, it determines the y-position of the tooltip
4929 window, otherwise it is displayed at the mouse position, with offset
4930 DY added (default is -10).
4932 A tooltip's maximum size is specified by `x-max-tooltip-size'.
4933 Text larger than the specified size is clipped. */)
4934 (Lisp_Object string, Lisp_Object frame, Lisp_Object parms, Lisp_Object timeout, Lisp_Object dx, Lisp_Object dy)
4936 struct frame *f;
4937 struct window *w;
4938 int root_x, root_y;
4939 struct buffer *old_buffer;
4940 struct text_pos pos;
4941 int i, width, height, seen_reversed_p;
4942 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
4943 int old_windows_or_buffers_changed = windows_or_buffers_changed;
4944 int count = SPECPDL_INDEX ();
4946 specbind (Qinhibit_redisplay, Qt);
4948 GCPRO4 (string, parms, frame, timeout);
4950 CHECK_STRING (string);
4951 if (SCHARS (string) == 0)
4952 string = make_unibyte_string (" ", 1);
4954 f = check_x_frame (frame);
4955 if (NILP (timeout))
4956 timeout = make_number (5);
4957 else
4958 CHECK_NATNUM (timeout);
4960 if (NILP (dx))
4961 dx = make_number (5);
4962 else
4963 CHECK_NUMBER (dx);
4965 if (NILP (dy))
4966 dy = make_number (-10);
4967 else
4968 CHECK_NUMBER (dy);
4970 #ifdef USE_GTK
4971 if (x_gtk_use_system_tooltips)
4973 int ok;
4975 /* Hide a previous tip, if any. */
4976 Fx_hide_tip ();
4978 BLOCK_INPUT;
4979 if ((ok = xg_prepare_tooltip (f, string, &width, &height)) != 0)
4981 compute_tip_xy (f, parms, dx, dy, width, height, &root_x, &root_y);
4982 xg_show_tooltip (f, root_x, root_y);
4983 /* This is used in Fx_hide_tip. */
4984 XSETFRAME (tip_frame, f);
4986 UNBLOCK_INPUT;
4987 if (ok) goto start_timer;
4989 #endif /* USE_GTK */
4991 if (NILP (last_show_tip_args))
4992 last_show_tip_args = Fmake_vector (make_number (3), Qnil);
4994 if (!NILP (tip_frame))
4996 Lisp_Object last_string = AREF (last_show_tip_args, 0);
4997 Lisp_Object last_frame = AREF (last_show_tip_args, 1);
4998 Lisp_Object last_parms = AREF (last_show_tip_args, 2);
5000 if (EQ (frame, last_frame)
5001 && !NILP (Fequal (last_string, string))
5002 && !NILP (Fequal (last_parms, parms)))
5004 struct frame *tip_f = XFRAME (tip_frame);
5006 /* Only DX and DY have changed. */
5007 if (!NILP (tip_timer))
5009 Lisp_Object timer = tip_timer;
5010 tip_timer = Qnil;
5011 call1 (Qcancel_timer, timer);
5014 BLOCK_INPUT;
5015 compute_tip_xy (tip_f, parms, dx, dy, FRAME_PIXEL_WIDTH (tip_f),
5016 FRAME_PIXEL_HEIGHT (tip_f), &root_x, &root_y);
5017 XMoveWindow (FRAME_X_DISPLAY (tip_f), FRAME_X_WINDOW (tip_f),
5018 root_x, root_y);
5019 UNBLOCK_INPUT;
5020 goto start_timer;
5024 /* Hide a previous tip, if any. */
5025 Fx_hide_tip ();
5027 ASET (last_show_tip_args, 0, string);
5028 ASET (last_show_tip_args, 1, frame);
5029 ASET (last_show_tip_args, 2, parms);
5031 /* Add default values to frame parameters. */
5032 if (NILP (Fassq (Qname, parms)))
5033 parms = Fcons (Fcons (Qname, build_string ("tooltip")), parms);
5034 if (NILP (Fassq (Qinternal_border_width, parms)))
5035 parms = Fcons (Fcons (Qinternal_border_width, make_number (3)), parms);
5036 if (NILP (Fassq (Qborder_width, parms)))
5037 parms = Fcons (Fcons (Qborder_width, make_number (1)), parms);
5038 if (NILP (Fassq (Qborder_color, parms)))
5039 parms = Fcons (Fcons (Qborder_color, build_string ("lightyellow")), parms);
5040 if (NILP (Fassq (Qbackground_color, parms)))
5041 parms = Fcons (Fcons (Qbackground_color, build_string ("lightyellow")),
5042 parms);
5044 /* Create a frame for the tooltip, and record it in the global
5045 variable tip_frame. */
5046 frame = x_create_tip_frame (FRAME_X_DISPLAY_INFO (f), parms, string);
5047 f = XFRAME (frame);
5049 /* Set up the frame's root window. */
5050 w = XWINDOW (FRAME_ROOT_WINDOW (f));
5051 w->left_col = w->top_line = make_number (0);
5053 if (CONSP (Vx_max_tooltip_size)
5054 && INTEGERP (XCAR (Vx_max_tooltip_size))
5055 && XINT (XCAR (Vx_max_tooltip_size)) > 0
5056 && INTEGERP (XCDR (Vx_max_tooltip_size))
5057 && XINT (XCDR (Vx_max_tooltip_size)) > 0)
5059 w->total_cols = XCAR (Vx_max_tooltip_size);
5060 w->total_lines = XCDR (Vx_max_tooltip_size);
5062 else
5064 w->total_cols = make_number (80);
5065 w->total_lines = make_number (40);
5068 FRAME_TOTAL_COLS (f) = XINT (w->total_cols);
5069 adjust_glyphs (f);
5070 w->pseudo_window_p = 1;
5072 /* Display the tooltip text in a temporary buffer. */
5073 old_buffer = current_buffer;
5074 set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f))->buffer));
5075 BVAR (current_buffer, truncate_lines) = Qnil;
5076 clear_glyph_matrix (w->desired_matrix);
5077 clear_glyph_matrix (w->current_matrix);
5078 SET_TEXT_POS (pos, BEGV, BEGV_BYTE);
5079 try_window (FRAME_ROOT_WINDOW (f), pos, TRY_WINDOW_IGNORE_FONTS_CHANGE);
5081 /* Compute width and height of the tooltip. */
5082 width = height = seen_reversed_p = 0;
5083 for (i = 0; i < w->desired_matrix->nrows; ++i)
5085 struct glyph_row *row = &w->desired_matrix->rows[i];
5086 struct glyph *last;
5087 int row_width;
5089 /* Stop at the first empty row at the end. */
5090 if (!row->enabled_p || !row->displays_text_p)
5091 break;
5093 /* Let the row go over the full width of the frame. */
5094 row->full_width_p = 1;
5096 row_width = row->pixel_width;
5097 if (row->used[TEXT_AREA])
5099 /* There's a glyph at the end of rows that is used to place
5100 the cursor there. Don't include the width of this glyph. */
5101 if (!row->reversed_p)
5103 last = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
5104 if (INTEGERP (last->object))
5105 row_width -= last->pixel_width;
5107 else
5109 /* There could be a stretch glyph at the beginning of R2L
5110 rows that is produced by extend_face_to_end_of_line.
5111 Don't count that glyph. */
5112 struct glyph *g = row->glyphs[TEXT_AREA];
5114 if (g->type == STRETCH_GLYPH && INTEGERP (g->object))
5116 row_width -= g->pixel_width;
5117 seen_reversed_p = 1;
5122 height += row->height;
5123 width = max (width, row_width);
5126 /* If we've seen partial-length R2L rows, we need to re-adjust the
5127 tool-tip frame width and redisplay it again, to avoid over-wide
5128 tips due to the stretch glyph that extends R2L lines to full
5129 width of the frame. */
5130 if (seen_reversed_p)
5132 /* w->total_cols and FRAME_TOTAL_COLS want the width in columns,
5133 not in pixels. */
5134 width /= WINDOW_FRAME_COLUMN_WIDTH (w);
5135 w->total_cols = make_number (width);
5136 FRAME_TOTAL_COLS (f) = width;
5137 adjust_glyphs (f);
5138 clear_glyph_matrix (w->desired_matrix);
5139 clear_glyph_matrix (w->current_matrix);
5140 try_window (FRAME_ROOT_WINDOW (f), pos, 0);
5141 width = height = 0;
5142 /* Recompute width and height of the tooltip. */
5143 for (i = 0; i < w->desired_matrix->nrows; ++i)
5145 struct glyph_row *row = &w->desired_matrix->rows[i];
5146 struct glyph *last;
5147 int row_width;
5149 if (!row->enabled_p || !row->displays_text_p)
5150 break;
5151 row->full_width_p = 1;
5152 row_width = row->pixel_width;
5153 if (row->used[TEXT_AREA] && !row->reversed_p)
5155 last = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
5156 if (INTEGERP (last->object))
5157 row_width -= last->pixel_width;
5160 height += row->height;
5161 width = max (width, row_width);
5165 /* Add the frame's internal border to the width and height the X
5166 window should have. */
5167 height += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
5168 width += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
5170 /* Move the tooltip window where the mouse pointer is. Resize and
5171 show it. */
5172 compute_tip_xy (f, parms, dx, dy, width, height, &root_x, &root_y);
5174 BLOCK_INPUT;
5175 XMoveResizeWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
5176 root_x, root_y, width, height);
5177 XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
5178 UNBLOCK_INPUT;
5180 /* Draw into the window. */
5181 w->must_be_updated_p = 1;
5182 update_single_window (w, 1);
5184 /* Restore original current buffer. */
5185 set_buffer_internal_1 (old_buffer);
5186 windows_or_buffers_changed = old_windows_or_buffers_changed;
5188 start_timer:
5189 /* Let the tip disappear after timeout seconds. */
5190 tip_timer = call3 (intern ("run-at-time"), timeout, Qnil,
5191 intern ("x-hide-tip"));
5193 UNGCPRO;
5194 return unbind_to (count, Qnil);
5198 DEFUN ("x-hide-tip", Fx_hide_tip, Sx_hide_tip, 0, 0, 0,
5199 doc: /* Hide the current tooltip window, if there is any.
5200 Value is t if tooltip was open, nil otherwise. */)
5201 (void)
5203 int count;
5204 Lisp_Object deleted, frame, timer;
5205 struct gcpro gcpro1, gcpro2;
5207 /* Return quickly if nothing to do. */
5208 if (NILP (tip_timer) && NILP (tip_frame))
5209 return Qnil;
5211 frame = tip_frame;
5212 timer = tip_timer;
5213 GCPRO2 (frame, timer);
5214 tip_frame = tip_timer = deleted = Qnil;
5216 count = SPECPDL_INDEX ();
5217 specbind (Qinhibit_redisplay, Qt);
5218 specbind (Qinhibit_quit, Qt);
5220 if (!NILP (timer))
5221 call1 (Qcancel_timer, timer);
5223 #ifdef USE_GTK
5225 /* When using system tooltip, tip_frame is the Emacs frame on which
5226 the tip is shown. */
5227 struct frame *f = XFRAME (frame);
5228 if (FRAME_LIVE_P (f) && xg_hide_tooltip (f))
5229 frame = Qnil;
5231 #endif
5233 if (FRAMEP (frame))
5235 delete_frame (frame, Qnil);
5236 deleted = Qt;
5238 #ifdef USE_LUCID
5239 /* Bloodcurdling hack alert: The Lucid menu bar widget's
5240 redisplay procedure is not called when a tip frame over menu
5241 items is unmapped. Redisplay the menu manually... */
5243 Widget w;
5244 struct frame *f = SELECTED_FRAME ();
5245 w = f->output_data.x->menubar_widget;
5247 if (!DoesSaveUnders (FRAME_X_DISPLAY_INFO (f)->screen)
5248 && w != NULL)
5250 BLOCK_INPUT;
5251 xlwmenu_redisplay (w);
5252 UNBLOCK_INPUT;
5255 #endif /* USE_LUCID */
5258 UNGCPRO;
5259 return unbind_to (count, deleted);
5264 /***********************************************************************
5265 File selection dialog
5266 ***********************************************************************/
5268 DEFUN ("x-uses-old-gtk-dialog", Fx_uses_old_gtk_dialog,
5269 Sx_uses_old_gtk_dialog,
5270 0, 0, 0,
5271 doc: /* Return t if the old Gtk+ file selection dialog is used. */)
5272 (void)
5274 #ifdef USE_GTK
5275 if (use_dialog_box
5276 && use_file_dialog
5277 && have_menus_p ()
5278 && xg_uses_old_file_dialog ())
5279 return Qt;
5280 #endif
5281 return Qnil;
5285 #ifdef USE_MOTIF
5286 /* Callback for "OK" and "Cancel" on file selection dialog. */
5288 static void
5289 file_dialog_cb (Widget widget, XtPointer client_data, XtPointer call_data)
5291 int *result = (int *) client_data;
5292 XmAnyCallbackStruct *cb = (XmAnyCallbackStruct *) call_data;
5293 *result = cb->reason;
5297 /* Callback for unmapping a file selection dialog. This is used to
5298 capture the case where a dialog is closed via a window manager's
5299 closer button, for example. Using a XmNdestroyCallback didn't work
5300 in this case. */
5302 static void
5303 file_dialog_unmap_cb (Widget widget, XtPointer client_data, XtPointer call_data)
5305 int *result = (int *) client_data;
5306 *result = XmCR_CANCEL;
5309 static Lisp_Object
5310 clean_up_file_dialog (Lisp_Object arg)
5312 struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
5313 Widget dialog = (Widget) p->pointer;
5315 /* Clean up. */
5316 BLOCK_INPUT;
5317 XtUnmanageChild (dialog);
5318 XtDestroyWidget (dialog);
5319 x_menu_set_in_use (0);
5320 UNBLOCK_INPUT;
5322 return Qnil;
5326 DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
5327 doc: /* Read file name, prompting with PROMPT in directory DIR.
5328 Use a file selection dialog. Select DEFAULT-FILENAME in the dialog's file
5329 selection box, if specified. If MUSTMATCH is non-nil, the returned file
5330 or directory must exist.
5332 This function is only defined on MS Windows, and X Windows with the
5333 Motif or Gtk toolkits. With the Motif toolkit, ONLY-DIR-P is ignored.
5334 Otherwise, if ONLY-DIR-P is non-nil, the user can only select directories. */)
5335 (Lisp_Object prompt, Lisp_Object dir, Lisp_Object default_filename, Lisp_Object mustmatch, Lisp_Object only_dir_p)
5337 int result;
5338 struct frame *f = SELECTED_FRAME ();
5339 Lisp_Object file = Qnil;
5340 Lisp_Object decoded_file;
5341 Widget dialog, text, help;
5342 Arg al[10];
5343 int ac = 0;
5344 XmString dir_xmstring, pattern_xmstring;
5345 int count = SPECPDL_INDEX ();
5346 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
5348 check_x ();
5350 GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
5352 if (popup_activated ())
5353 error ("Trying to use a menu from within a menu-entry");
5355 CHECK_STRING (prompt);
5356 CHECK_STRING (dir);
5358 /* Prevent redisplay. */
5359 specbind (Qinhibit_redisplay, Qt);
5361 BLOCK_INPUT;
5363 /* Create the dialog with PROMPT as title, using DIR as initial
5364 directory and using "*" as pattern. */
5365 dir = Fexpand_file_name (dir, Qnil);
5366 dir_xmstring = XmStringCreateLocalized (SDATA (dir));
5367 pattern_xmstring = XmStringCreateLocalized ("*");
5369 XtSetArg (al[ac], XmNtitle, SDATA (prompt)); ++ac;
5370 XtSetArg (al[ac], XmNdirectory, dir_xmstring); ++ac;
5371 XtSetArg (al[ac], XmNpattern, pattern_xmstring); ++ac;
5372 XtSetArg (al[ac], XmNresizePolicy, XmRESIZE_GROW); ++ac;
5373 XtSetArg (al[ac], XmNdialogStyle, XmDIALOG_APPLICATION_MODAL); ++ac;
5374 dialog = XmCreateFileSelectionDialog (f->output_data.x->widget,
5375 "fsb", al, ac);
5376 XmStringFree (dir_xmstring);
5377 XmStringFree (pattern_xmstring);
5379 /* Add callbacks for OK and Cancel. */
5380 XtAddCallback (dialog, XmNokCallback, file_dialog_cb,
5381 (XtPointer) &result);
5382 XtAddCallback (dialog, XmNcancelCallback, file_dialog_cb,
5383 (XtPointer) &result);
5384 XtAddCallback (dialog, XmNunmapCallback, file_dialog_unmap_cb,
5385 (XtPointer) &result);
5387 /* Remove the help button since we can't display help. */
5388 help = XmFileSelectionBoxGetChild (dialog, XmDIALOG_HELP_BUTTON);
5389 XtUnmanageChild (help);
5391 /* Mark OK button as default. */
5392 XtVaSetValues (XmFileSelectionBoxGetChild (dialog, XmDIALOG_OK_BUTTON),
5393 XmNshowAsDefault, True, NULL);
5395 /* If MUSTMATCH is non-nil, disable the file entry field of the
5396 dialog, so that the user must select a file from the files list
5397 box. We can't remove it because we wouldn't have a way to get at
5398 the result file name, then. */
5399 text = XmFileSelectionBoxGetChild (dialog, XmDIALOG_TEXT);
5400 if (!NILP (mustmatch))
5402 Widget label;
5403 label = XmFileSelectionBoxGetChild (dialog, XmDIALOG_SELECTION_LABEL);
5404 XtSetSensitive (text, False);
5405 XtSetSensitive (label, False);
5408 /* Manage the dialog, so that list boxes get filled. */
5409 XtManageChild (dialog);
5411 if (STRINGP (default_filename))
5413 XmString default_xmstring;
5414 Widget wtext = XmFileSelectionBoxGetChild (dialog, XmDIALOG_TEXT);
5415 Widget list = XmFileSelectionBoxGetChild (dialog, XmDIALOG_LIST);
5417 XmTextPosition last_pos = XmTextFieldGetLastPosition (wtext);
5418 XmTextFieldReplace (wtext, 0, last_pos,
5419 (SDATA (Ffile_name_nondirectory (default_filename))));
5421 /* Select DEFAULT_FILENAME in the files list box. DEFAULT_FILENAME
5422 must include the path for this to work. */
5424 default_xmstring = XmStringCreateLocalized (SDATA (default_filename));
5426 if (XmListItemExists (list, default_xmstring))
5428 int item_pos = XmListItemPos (list, default_xmstring);
5429 /* Select the item and scroll it into view. */
5430 XmListSelectPos (list, item_pos, True);
5431 XmListSetPos (list, item_pos);
5434 XmStringFree (default_xmstring);
5437 record_unwind_protect (clean_up_file_dialog, make_save_value (dialog, 0));
5439 /* Process events until the user presses Cancel or OK. */
5440 x_menu_set_in_use (1);
5441 result = 0;
5442 while (result == 0)
5444 XEvent event;
5445 x_menu_wait_for_event (0);
5446 XtAppNextEvent (Xt_app_con, &event);
5447 if (event.type == KeyPress
5448 && FRAME_X_DISPLAY (f) == event.xkey.display)
5450 KeySym keysym = XLookupKeysym (&event.xkey, 0);
5452 /* Pop down on C-g. */
5453 if (keysym == XK_g && (event.xkey.state & ControlMask) != 0)
5454 XtUnmanageChild (dialog);
5457 (void) x_dispatch_event (&event, FRAME_X_DISPLAY (f));
5460 /* Get the result. */
5461 if (result == XmCR_OK)
5463 XmString text_string;
5464 String data;
5466 XtVaGetValues (dialog, XmNtextString, &text_string, NULL);
5467 XmStringGetLtoR (text_string, XmFONTLIST_DEFAULT_TAG, &data);
5468 XmStringFree (text_string);
5469 file = build_string (data);
5470 XtFree (data);
5472 else
5473 file = Qnil;
5475 UNBLOCK_INPUT;
5476 UNGCPRO;
5478 /* Make "Cancel" equivalent to C-g. */
5479 if (NILP (file))
5480 Fsignal (Qquit, Qnil);
5482 decoded_file = DECODE_FILE (file);
5484 return unbind_to (count, decoded_file);
5487 #endif /* USE_MOTIF */
5489 #ifdef USE_GTK
5491 static Lisp_Object
5492 clean_up_dialog (Lisp_Object arg)
5494 x_menu_set_in_use (0);
5496 return Qnil;
5499 DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
5500 doc: /* Read file name, prompting with PROMPT in directory DIR.
5501 Use a file selection dialog. Select DEFAULT-FILENAME in the dialog's file
5502 selection box, if specified. If MUSTMATCH is non-nil, the returned file
5503 or directory must exist.
5505 This function is only defined on MS Windows, and X Windows with the
5506 Motif or Gtk toolkits. With the Motif toolkit, ONLY-DIR-P is ignored.
5507 Otherwise, if ONLY-DIR-P is non-nil, the user can only select directories. */)
5508 (Lisp_Object prompt, Lisp_Object dir, Lisp_Object default_filename, Lisp_Object mustmatch, Lisp_Object only_dir_p)
5510 FRAME_PTR f = SELECTED_FRAME ();
5511 char *fn;
5512 Lisp_Object file = Qnil;
5513 Lisp_Object decoded_file;
5514 int count = SPECPDL_INDEX ();
5515 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
5516 char *cdef_file;
5518 check_x ();
5520 GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
5522 if (popup_activated ())
5523 error ("Trying to use a menu from within a menu-entry");
5525 CHECK_STRING (prompt);
5526 CHECK_STRING (dir);
5528 /* Prevent redisplay. */
5529 specbind (Qinhibit_redisplay, Qt);
5530 record_unwind_protect (clean_up_dialog, Qnil);
5532 BLOCK_INPUT;
5534 if (STRINGP (default_filename))
5535 cdef_file = SSDATA (default_filename);
5536 else
5537 cdef_file = SSDATA (dir);
5539 fn = xg_get_file_name (f, SSDATA (prompt), cdef_file,
5540 ! NILP (mustmatch),
5541 ! NILP (only_dir_p));
5543 if (fn)
5545 file = build_string (fn);
5546 xfree (fn);
5549 UNBLOCK_INPUT;
5550 UNGCPRO;
5552 /* Make "Cancel" equivalent to C-g. */
5553 if (NILP (file))
5554 Fsignal (Qquit, Qnil);
5556 decoded_file = DECODE_FILE (file);
5558 return unbind_to (count, decoded_file);
5562 #ifdef HAVE_FREETYPE
5564 DEFUN ("x-select-font", Fx_select_font, Sx_select_font, 0, 2, 0,
5565 doc: /* Read a font name using a GTK font selection dialog.
5566 Return a GTK-style font string corresponding to the selection.
5568 If FRAME is omitted or nil, it defaults to the selected frame. */)
5569 (Lisp_Object frame, Lisp_Object ignored)
5571 FRAME_PTR f = check_x_frame (frame);
5572 char *name;
5573 Lisp_Object font;
5574 Lisp_Object font_param;
5575 char *default_name = NULL;
5576 struct gcpro gcpro1, gcpro2;
5577 int count = SPECPDL_INDEX ();
5579 check_x ();
5581 if (popup_activated ())
5582 error ("Trying to use a menu from within a menu-entry");
5584 /* Prevent redisplay. */
5585 specbind (Qinhibit_redisplay, Qt);
5586 record_unwind_protect (clean_up_dialog, Qnil);
5588 BLOCK_INPUT;
5590 GCPRO2(font_param, font);
5592 XSETFONT (font, FRAME_FONT (f));
5593 font_param = Ffont_get (font, intern (":name"));
5594 if (STRINGP (font_param))
5595 default_name = xstrdup (SSDATA (font_param));
5596 else
5598 font_param = Fframe_parameter (frame, Qfont_param);
5599 if (STRINGP (font_param))
5600 default_name = xstrdup (SSDATA (font_param));
5603 if (default_name == NULL && x_last_font_name != NULL)
5604 default_name = xstrdup (x_last_font_name);
5606 /* Convert fontconfig names to Gtk names, i.e. remove - before number */
5607 if (default_name)
5609 char *p = strrchr (default_name, '-');
5610 if (p)
5612 char *ep = p+1;
5613 while (isdigit (*ep))
5614 ++ep;
5615 if (*ep == '\0') *p = ' ';
5619 name = xg_get_font_name (f, default_name);
5620 xfree (default_name);
5622 if (name)
5624 font = build_string (name);
5625 g_free (x_last_font_name);
5626 x_last_font_name = name;
5629 UNBLOCK_INPUT;
5631 if (NILP (font))
5632 Fsignal (Qquit, Qnil);
5634 return unbind_to (count, font);
5636 #endif /* HAVE_FREETYPE */
5638 #endif /* USE_GTK */
5641 /***********************************************************************
5642 Keyboard
5643 ***********************************************************************/
5645 #ifdef HAVE_XKBGETKEYBOARD
5646 #include <X11/XKBlib.h>
5647 #include <X11/keysym.h>
5648 #endif
5650 DEFUN ("x-backspace-delete-keys-p", Fx_backspace_delete_keys_p,
5651 Sx_backspace_delete_keys_p, 0, 1, 0,
5652 doc: /* Check if both Backspace and Delete keys are on the keyboard of FRAME.
5653 FRAME nil means use the selected frame.
5654 Value is t if we know that both keys are present, and are mapped to the
5655 usual X keysyms. Value is `lambda' if we cannot determine if both keys are
5656 present and mapped to the usual X keysyms. */)
5657 (Lisp_Object frame)
5659 #ifdef HAVE_XKBGETKEYBOARD
5660 XkbDescPtr kb;
5661 struct frame *f = check_x_frame (frame);
5662 Display *dpy = FRAME_X_DISPLAY (f);
5663 Lisp_Object have_keys;
5664 int major, minor, op, event, error_code;
5666 BLOCK_INPUT;
5668 /* Check library version in case we're dynamically linked. */
5669 major = XkbMajorVersion;
5670 minor = XkbMinorVersion;
5671 if (!XkbLibraryVersion (&major, &minor))
5673 UNBLOCK_INPUT;
5674 return Qlambda;
5677 /* Check that the server supports XKB. */
5678 major = XkbMajorVersion;
5679 minor = XkbMinorVersion;
5680 if (!XkbQueryExtension (dpy, &op, &event, &error_code, &major, &minor))
5682 UNBLOCK_INPUT;
5683 return Qlambda;
5686 /* In this code we check that the keyboard has physical keys with names
5687 that start with BKSP (Backspace) and DELE (Delete), and that they
5688 generate keysym XK_BackSpace and XK_Delete respectively.
5689 This function is used to test if normal-erase-is-backspace should be
5690 turned on.
5691 An alternative approach would be to just check if XK_BackSpace and
5692 XK_Delete are mapped to any key. But if any of those are mapped to
5693 some non-intuitive key combination (Meta-Shift-Ctrl-whatever) and the
5694 user doesn't know about it, it is better to return false here.
5695 It is more obvious to the user what to do if she/he has two keys
5696 clearly marked with names/symbols and one key does something not
5697 expected (i.e. she/he then tries the other).
5698 The cases where Backspace/Delete is mapped to some other key combination
5699 are rare, and in those cases, normal-erase-is-backspace can be turned on
5700 manually. */
5702 have_keys = Qnil;
5703 kb = XkbGetMap (dpy, XkbAllMapComponentsMask, XkbUseCoreKbd);
5704 if (kb)
5706 int delete_keycode = 0, backspace_keycode = 0, i;
5708 if (XkbGetNames (dpy, XkbAllNamesMask, kb) == Success)
5710 for (i = kb->min_key_code;
5711 (i < kb->max_key_code
5712 && (delete_keycode == 0 || backspace_keycode == 0));
5713 ++i)
5715 /* The XKB symbolic key names can be seen most easily in
5716 the PS file generated by `xkbprint -label name
5717 $DISPLAY'. */
5718 if (memcmp ("DELE", kb->names->keys[i].name, 4) == 0)
5719 delete_keycode = i;
5720 else if (memcmp ("BKSP", kb->names->keys[i].name, 4) == 0)
5721 backspace_keycode = i;
5724 XkbFreeNames (kb, 0, True);
5727 XkbFreeClientMap (kb, 0, True);
5729 if (delete_keycode
5730 && backspace_keycode
5731 && XKeysymToKeycode (dpy, XK_Delete) == delete_keycode
5732 && XKeysymToKeycode (dpy, XK_BackSpace) == backspace_keycode)
5733 have_keys = Qt;
5735 UNBLOCK_INPUT;
5736 return have_keys;
5737 #else /* not HAVE_XKBGETKEYBOARD */
5738 return Qlambda;
5739 #endif /* not HAVE_XKBGETKEYBOARD */
5744 /***********************************************************************
5745 Initialization
5746 ***********************************************************************/
5748 /* Keep this list in the same order as frame_parms in frame.c.
5749 Use 0 for unsupported frame parameters. */
5751 frame_parm_handler x_frame_parm_handlers[] =
5753 x_set_autoraise,
5754 x_set_autolower,
5755 x_set_background_color,
5756 x_set_border_color,
5757 x_set_border_width,
5758 x_set_cursor_color,
5759 x_set_cursor_type,
5760 x_set_font,
5761 x_set_foreground_color,
5762 x_set_icon_name,
5763 x_set_icon_type,
5764 x_set_internal_border_width,
5765 x_set_menu_bar_lines,
5766 x_set_mouse_color,
5767 x_explicitly_set_name,
5768 x_set_scroll_bar_width,
5769 x_set_title,
5770 x_set_unsplittable,
5771 x_set_vertical_scroll_bars,
5772 x_set_visibility,
5773 x_set_tool_bar_lines,
5774 x_set_scroll_bar_foreground,
5775 x_set_scroll_bar_background,
5776 x_set_screen_gamma,
5777 x_set_line_spacing,
5778 x_set_fringe_width,
5779 x_set_fringe_width,
5780 x_set_wait_for_wm,
5781 x_set_fullscreen,
5782 x_set_font_backend,
5783 x_set_alpha,
5784 x_set_sticky,
5785 x_set_tool_bar_position,
5788 void
5789 syms_of_xfns (void)
5791 /* This is zero if not using X windows. */
5792 x_in_use = 0;
5794 /* The section below is built by the lisp expression at the top of the file,
5795 just above where these variables are declared. */
5796 /*&&& init symbols here &&&*/
5797 Qnone = intern_c_string ("none");
5798 staticpro (&Qnone);
5799 Qsuppress_icon = intern_c_string ("suppress-icon");
5800 staticpro (&Qsuppress_icon);
5801 Qundefined_color = intern_c_string ("undefined-color");
5802 staticpro (&Qundefined_color);
5803 Qcompound_text = intern_c_string ("compound-text");
5804 staticpro (&Qcompound_text);
5805 Qcancel_timer = intern_c_string ("cancel-timer");
5806 staticpro (&Qcancel_timer);
5807 Qfont_param = intern_c_string ("font-parameter");
5808 staticpro (&Qfont_param);
5809 /* This is the end of symbol initialization. */
5811 /* Text property `display' should be nonsticky by default. */
5812 Vtext_property_default_nonsticky
5813 = Fcons (Fcons (Qdisplay, Qt), Vtext_property_default_nonsticky);
5816 Fput (Qundefined_color, Qerror_conditions,
5817 pure_cons (Qundefined_color, pure_cons (Qerror, Qnil)));
5818 Fput (Qundefined_color, Qerror_message,
5819 make_pure_c_string ("Undefined color"));
5821 DEFVAR_LISP ("x-pointer-shape", Vx_pointer_shape,
5822 doc: /* The shape of the pointer when over text.
5823 Changing the value does not affect existing frames
5824 unless you set the mouse color. */);
5825 Vx_pointer_shape = Qnil;
5827 #if 0 /* This doesn't really do anything. */
5828 DEFVAR_LISP ("x-nontext-pointer-shape", Vx_nontext_pointer_shape,
5829 doc: /* The shape of the pointer when not over text.
5830 This variable takes effect when you create a new frame
5831 or when you set the mouse color. */);
5832 #endif
5833 Vx_nontext_pointer_shape = Qnil;
5835 DEFVAR_LISP ("x-hourglass-pointer-shape", Vx_hourglass_pointer_shape,
5836 doc: /* The shape of the pointer when Emacs is busy.
5837 This variable takes effect when you create a new frame
5838 or when you set the mouse color. */);
5839 Vx_hourglass_pointer_shape = Qnil;
5841 #if 0 /* This doesn't really do anything. */
5842 DEFVAR_LISP ("x-mode-pointer-shape", Vx_mode_pointer_shape,
5843 doc: /* The shape of the pointer when over the mode line.
5844 This variable takes effect when you create a new frame
5845 or when you set the mouse color. */);
5846 #endif
5847 Vx_mode_pointer_shape = Qnil;
5849 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
5850 Vx_sensitive_text_pointer_shape,
5851 doc: /* The shape of the pointer when over mouse-sensitive text.
5852 This variable takes effect when you create a new frame
5853 or when you set the mouse color. */);
5854 Vx_sensitive_text_pointer_shape = Qnil;
5856 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
5857 Vx_window_horizontal_drag_shape,
5858 doc: /* Pointer shape to use for indicating a window can be dragged horizontally.
5859 This variable takes effect when you create a new frame
5860 or when you set the mouse color. */);
5861 Vx_window_horizontal_drag_shape = Qnil;
5863 DEFVAR_LISP ("x-cursor-fore-pixel", Vx_cursor_fore_pixel,
5864 doc: /* A string indicating the foreground color of the cursor box. */);
5865 Vx_cursor_fore_pixel = Qnil;
5867 DEFVAR_LISP ("x-max-tooltip-size", Vx_max_tooltip_size,
5868 doc: /* Maximum size for tooltips.
5869 Value is a pair (COLUMNS . ROWS). Text larger than this is clipped. */);
5870 Vx_max_tooltip_size = Fcons (make_number (80), make_number (40));
5872 DEFVAR_LISP ("x-no-window-manager", Vx_no_window_manager,
5873 doc: /* Non-nil if no X window manager is in use.
5874 Emacs doesn't try to figure this out; this is always nil
5875 unless you set it to something else. */);
5876 /* We don't have any way to find this out, so set it to nil
5877 and maybe the user would like to set it to t. */
5878 Vx_no_window_manager = Qnil;
5880 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
5881 Vx_pixel_size_width_font_regexp,
5882 doc: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
5884 Since Emacs gets width of a font matching with this regexp from
5885 PIXEL_SIZE field of the name, font finding mechanism gets faster for
5886 such a font. This is especially effective for such large fonts as
5887 Chinese, Japanese, and Korean. */);
5888 Vx_pixel_size_width_font_regexp = Qnil;
5890 /* This is not ifdef:ed, so other builds than GTK can customize it. */
5891 DEFVAR_BOOL ("x-gtk-use-old-file-dialog", x_gtk_use_old_file_dialog,
5892 doc: /* *Non-nil means prompt with the old GTK file selection dialog.
5893 If nil or if the file selection dialog is not available, the new GTK file
5894 chooser is used instead. To turn off all file dialogs set the
5895 variable `use-file-dialog'. */);
5896 x_gtk_use_old_file_dialog = 0;
5898 DEFVAR_BOOL ("x-gtk-show-hidden-files", x_gtk_show_hidden_files,
5899 doc: /* *If non-nil, the GTK file chooser will by default show hidden files.
5900 Note that this is just the default, there is a toggle button on the file
5901 chooser to show or not show hidden files on a case by case basis. */);
5902 x_gtk_show_hidden_files = 0;
5904 DEFVAR_BOOL ("x-gtk-file-dialog-help-text", x_gtk_file_dialog_help_text,
5905 doc: /* *If non-nil, the GTK file chooser will show additional help text.
5906 If more space for files in the file chooser dialog is wanted, set this to nil
5907 to turn the additional text off. */);
5908 x_gtk_file_dialog_help_text = 1;
5910 DEFVAR_BOOL ("x-gtk-whole-detached-tool-bar", x_gtk_whole_detached_tool_bar,
5911 doc: /* *If non-nil, a detached tool bar is shown in full.
5912 The default is to just show an arrow and pressing on that arrow shows
5913 the tool bar buttons. */);
5914 x_gtk_whole_detached_tool_bar = 0;
5916 DEFVAR_BOOL ("x-gtk-use-system-tooltips", x_gtk_use_system_tooltips,
5917 doc: /* *If non-nil with a Gtk+ built Emacs, the Gtk+ toolip is used.
5918 Otherwise use Emacs own tooltip implementation.
5919 When using Gtk+ tooltips, the tooltip face is not used. */);
5920 x_gtk_use_system_tooltips = 1;
5922 Fprovide (intern_c_string ("x"), Qnil);
5924 #ifdef USE_X_TOOLKIT
5925 Fprovide (intern_c_string ("x-toolkit"), Qnil);
5926 #ifdef USE_MOTIF
5927 Fprovide (intern_c_string ("motif"), Qnil);
5929 DEFVAR_LISP ("motif-version-string", Vmotif_version_string,
5930 doc: /* Version info for LessTif/Motif. */);
5931 Vmotif_version_string = build_string (XmVERSION_STRING);
5932 #endif /* USE_MOTIF */
5933 #endif /* USE_X_TOOLKIT */
5935 #ifdef USE_GTK
5936 /* Provide x-toolkit also for GTK. Internally GTK does not use Xt so it
5937 is not an X toolkit in that sense (USE_X_TOOLKIT is not defined).
5938 But for a user it is a toolkit for X, and indeed, configure
5939 accepts --with-x-toolkit=gtk. */
5940 Fprovide (intern_c_string ("x-toolkit"), Qnil);
5941 Fprovide (intern_c_string ("gtk"), Qnil);
5942 Fprovide (intern_c_string ("move-toolbar"), Qnil);
5944 DEFVAR_LISP ("gtk-version-string", Vgtk_version_string,
5945 doc: /* Version info for GTK+. */);
5947 char gtk_version[40];
5948 g_snprintf (gtk_version, sizeof (gtk_version), "%u.%u.%u",
5949 GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION);
5950 Vgtk_version_string = make_pure_string (gtk_version, strlen (gtk_version), strlen (gtk_version), 0);
5952 #endif /* USE_GTK */
5954 /* X window properties. */
5955 defsubr (&Sx_change_window_property);
5956 defsubr (&Sx_delete_window_property);
5957 defsubr (&Sx_window_property);
5959 defsubr (&Sxw_display_color_p);
5960 defsubr (&Sx_display_grayscale_p);
5961 defsubr (&Sxw_color_defined_p);
5962 defsubr (&Sxw_color_values);
5963 defsubr (&Sx_server_max_request_size);
5964 defsubr (&Sx_server_vendor);
5965 defsubr (&Sx_server_version);
5966 defsubr (&Sx_display_pixel_width);
5967 defsubr (&Sx_display_pixel_height);
5968 defsubr (&Sx_display_mm_width);
5969 defsubr (&Sx_display_mm_height);
5970 defsubr (&Sx_display_screens);
5971 defsubr (&Sx_display_planes);
5972 defsubr (&Sx_display_color_cells);
5973 defsubr (&Sx_display_visual_class);
5974 defsubr (&Sx_display_backing_store);
5975 defsubr (&Sx_display_save_under);
5976 defsubr (&Sx_wm_set_size_hint);
5977 defsubr (&Sx_create_frame);
5978 defsubr (&Sx_open_connection);
5979 defsubr (&Sx_close_connection);
5980 defsubr (&Sx_display_list);
5981 defsubr (&Sx_synchronize);
5982 defsubr (&Sx_focus_frame);
5983 defsubr (&Sx_backspace_delete_keys_p);
5985 /* Setting callback functions for fontset handler. */
5986 check_window_system_func = check_x;
5988 defsubr (&Sx_show_tip);
5989 defsubr (&Sx_hide_tip);
5990 tip_timer = Qnil;
5991 staticpro (&tip_timer);
5992 tip_frame = Qnil;
5993 staticpro (&tip_frame);
5995 last_show_tip_args = Qnil;
5996 staticpro (&last_show_tip_args);
5998 defsubr (&Sx_uses_old_gtk_dialog);
5999 #if defined (USE_MOTIF) || defined (USE_GTK)
6000 defsubr (&Sx_file_dialog);
6001 #endif
6003 #if defined (USE_GTK) && defined (HAVE_FREETYPE)
6004 defsubr (&Sx_select_font);
6005 x_last_font_name = NULL;
6006 #endif
6009 #endif /* HAVE_X_WINDOWS */