Merge from origin/emacs-24
[emacs.git] / src / xfns.c
blobbd1db1013d0a9c03f8712c8d11f35c5f635755ba
1 /* Functions for the X window system.
3 Copyright (C) 1989, 1992-2015 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 <unistd.h>
25 #include "lisp.h"
26 #include "xterm.h"
27 #include "menu.h"
28 #include "frame.h"
29 #include "window.h"
30 #include "character.h"
31 #include "buffer.h"
32 #include "intervals.h"
33 #include "dispextern.h"
34 #include "keyboard.h"
35 #include "blockinput.h"
36 #include <epaths.h>
37 #include "charset.h"
38 #include "coding.h"
39 #include "fontset.h"
40 #include "systime.h"
41 #include "termhooks.h"
42 #include "atimer.h"
43 #include "termchar.h"
44 #include "font.h"
46 #include <sys/types.h>
47 #include <sys/stat.h>
49 #include "bitmaps/gray.xbm"
50 #include "xsettings.h"
52 #ifdef HAVE_XRANDR
53 #include <X11/extensions/Xrandr.h>
54 #endif
55 #ifdef HAVE_XINERAMA
56 #include <X11/extensions/Xinerama.h>
57 #endif
59 #ifdef USE_GTK
60 #include "gtkutil.h"
61 #endif
63 #ifdef USE_X_TOOLKIT
64 #include <X11/Shell.h>
66 #ifndef USE_MOTIF
67 #ifdef HAVE_XAW3D
68 #include <X11/Xaw3d/Paned.h>
69 #include <X11/Xaw3d/Label.h>
70 #else /* !HAVE_XAW3D */
71 #include <X11/Xaw/Paned.h>
72 #include <X11/Xaw/Label.h>
73 #endif /* HAVE_XAW3D */
74 #endif /* USE_MOTIF */
76 #ifdef USG
77 #undef USG /* ####KLUDGE for Solaris 2.2 and up */
78 #include <X11/Xos.h>
79 #define USG
80 #ifdef USG /* Pacify gcc -Wunused-macros. */
81 #endif
82 #else
83 #include <X11/Xos.h>
84 #endif
86 #include "widget.h"
88 #include "../lwlib/lwlib.h"
90 #ifdef USE_MOTIF
91 #include <Xm/Xm.h>
92 #include <Xm/DialogS.h>
93 #include <Xm/FileSB.h>
94 #include <Xm/List.h>
95 #include <Xm/TextF.h>
96 #endif
98 #ifdef USE_LUCID
99 #include "../lwlib/xlwmenu.h"
100 #endif
102 #if !defined (NO_EDITRES)
103 #define HACK_EDITRES
104 extern void _XEditResCheckMessages (Widget, XtPointer, XEvent *, Boolean *);
105 #endif /* not defined NO_EDITRES */
107 /* Unique id counter for widgets created by the Lucid Widget Library. */
109 extern LWLIB_ID widget_id_tick;
111 #ifdef USE_MOTIF
113 #endif /* USE_MOTIF */
115 #endif /* USE_X_TOOLKIT */
117 #ifdef USE_GTK
119 #endif /* USE_GTK */
121 #define MAXREQUEST(dpy) (XMaxRequestSize (dpy))
123 #ifdef GLYPH_DEBUG
124 static ptrdiff_t image_cache_refcount;
125 static int dpyinfo_refcount;
126 #endif
128 static struct x_display_info *x_display_info_for_name (Lisp_Object);
130 /* Let the user specify an X display with a Lisp object.
131 OBJECT may be nil, a frame or a terminal object.
132 nil stands for the selected frame--or, if that is not an X frame,
133 the first X display on the list. */
135 struct x_display_info *
136 check_x_display_info (Lisp_Object object)
138 struct x_display_info *dpyinfo = NULL;
140 if (NILP (object))
142 struct frame *sf = XFRAME (selected_frame);
144 if (FRAME_X_P (sf) && FRAME_LIVE_P (sf))
145 dpyinfo = FRAME_DISPLAY_INFO (sf);
146 else if (x_display_list != 0)
147 dpyinfo = x_display_list;
148 else
149 error ("X windows are not in use or not initialized");
151 else if (TERMINALP (object))
153 struct terminal *t = decode_live_terminal (object);
155 if (t->type != output_x_window)
156 error ("Terminal %d is not an X display", t->id);
158 dpyinfo = t->display_info.x;
160 else if (STRINGP (object))
161 dpyinfo = x_display_info_for_name (object);
162 else
164 struct frame *f = decode_window_system_frame (object);
165 dpyinfo = FRAME_DISPLAY_INFO (f);
168 return dpyinfo;
171 /* Return the screen positions and offsets of frame F.
172 Store the offsets between FRAME_OUTER_WINDOW and the containing
173 window manager window into LEFT_OFFSET_X, RIGHT_OFFSET_X,
174 TOP_OFFSET_Y and BOTTOM_OFFSET_Y.
175 Store the offsets between FRAME_X_WINDOW and the containing
176 window manager window into X_PIXELS_DIFF and Y_PIXELS_DIFF.
177 Store the screen positions of frame F into XPTR and YPTR.
178 These are the positions of the containing window manager window,
179 not Emacs's own window. */
180 void
181 x_real_pos_and_offsets (struct frame *f,
182 int *left_offset_x,
183 int *right_offset_x,
184 int *top_offset_y,
185 int *bottom_offset_y,
186 int *x_pixels_diff,
187 int *y_pixels_diff,
188 int *xptr,
189 int *yptr,
190 int *outer_border)
192 int win_x, win_y, outer_x IF_LINT (= 0), outer_y IF_LINT (= 0);
193 int real_x = 0, real_y = 0;
194 bool had_errors = false;
195 Window win = f->output_data.x->parent_desc;
196 Atom actual_type;
197 unsigned long actual_size, bytes_remaining;
198 int rc, actual_format;
199 struct x_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
200 long max_len = 400;
201 Display *dpy = FRAME_X_DISPLAY (f);
202 unsigned char *tmp_data = NULL;
203 Atom target_type = XA_CARDINAL;
204 unsigned int ow IF_LINT (= 0), oh IF_LINT (= 0);
206 block_input ();
208 x_catch_errors (dpy);
210 if (x_pixels_diff) *x_pixels_diff = 0;
211 if (y_pixels_diff) *y_pixels_diff = 0;
212 if (left_offset_x) *left_offset_x = 0;
213 if (top_offset_y) *top_offset_y = 0;
214 if (right_offset_x) *right_offset_x = 0;
215 if (bottom_offset_y) *bottom_offset_y = 0;
216 if (xptr) *xptr = 0;
217 if (yptr) *yptr = 0;
218 if (outer_border) *outer_border = 0;
220 if (win == dpyinfo->root_window)
221 win = FRAME_OUTER_WINDOW (f);
223 /* This loop traverses up the containment tree until we hit the root
224 window. Window managers may intersect many windows between our window
225 and the root window. The window we find just before the root window
226 should be the outer WM window. */
227 for (;;)
229 Window wm_window, rootw;
230 Window *tmp_children;
231 unsigned int tmp_nchildren;
232 int success;
234 success = XQueryTree (FRAME_X_DISPLAY (f), win, &rootw,
235 &wm_window, &tmp_children, &tmp_nchildren);
237 had_errors = x_had_errors_p (FRAME_X_DISPLAY (f));
239 /* Don't free tmp_children if XQueryTree failed. */
240 if (! success)
241 break;
243 XFree (tmp_children);
245 if (wm_window == rootw || had_errors)
246 break;
248 win = wm_window;
251 if (! had_errors)
253 unsigned int ign;
254 Window child, rootw;
256 /* Get the real coordinates for the WM window upper left corner */
257 XGetGeometry (FRAME_X_DISPLAY (f), win,
258 &rootw, &real_x, &real_y, &ow, &oh, &ign, &ign);
260 if (outer_border)
262 XWindowAttributes atts;
263 XGetWindowAttributes (FRAME_X_DISPLAY (f), win, &atts);
264 *outer_border = atts.border_width;
267 /* Translate real coordinates to coordinates relative to our
268 window. For our window, the upper left corner is 0, 0.
269 Since the upper left corner of the WM window is outside
270 our window, win_x and win_y will be negative:
272 ------------------ ---> x
273 | title |
274 | ----------------- v y
275 | | our window
277 XTranslateCoordinates (FRAME_X_DISPLAY (f),
279 /* From-window, to-window. */
280 FRAME_DISPLAY_INFO (f)->root_window,
281 FRAME_X_WINDOW (f),
283 /* From-position, to-position. */
284 real_x, real_y, &win_x, &win_y,
286 /* Child of win. */
287 &child);
289 if (FRAME_X_WINDOW (f) == FRAME_OUTER_WINDOW (f))
291 outer_x = win_x;
292 outer_y = win_y;
294 else
296 XTranslateCoordinates (FRAME_X_DISPLAY (f),
298 /* From-window, to-window. */
299 FRAME_DISPLAY_INFO (f)->root_window,
300 FRAME_OUTER_WINDOW (f),
302 /* From-position, to-position. */
303 real_x, real_y, &outer_x, &outer_y,
305 /* Child of win. */
306 &child);
309 had_errors = x_had_errors_p (FRAME_X_DISPLAY (f));
313 if (dpyinfo->root_window == f->output_data.x->parent_desc)
315 /* Try _NET_FRAME_EXTENTS if our parent is the root window. */
316 rc = XGetWindowProperty (dpy, win, dpyinfo->Xatom_net_frame_extents,
317 0, max_len, False, target_type,
318 &actual_type, &actual_format, &actual_size,
319 &bytes_remaining, &tmp_data);
321 if (rc == Success && actual_type == target_type && !x_had_errors_p (dpy)
322 && actual_size == 4 && actual_format == 32)
324 unsigned int ign;
325 Window rootw;
326 long *fe = (long *)tmp_data;
328 XGetGeometry (FRAME_X_DISPLAY (f), win,
329 &rootw, &real_x, &real_y, &ign, &ign, &ign, &ign);
330 outer_x = -fe[0];
331 outer_y = -fe[2];
332 real_x -= fe[0];
333 real_y -= fe[2];
337 if (tmp_data) XFree (tmp_data);
339 x_uncatch_errors ();
341 unblock_input ();
343 if (had_errors) return;
345 if (x_pixels_diff) *x_pixels_diff = -win_x;
346 if (y_pixels_diff) *y_pixels_diff = -win_y;
348 if (left_offset_x) *left_offset_x = -outer_x;
349 if (top_offset_y) *top_offset_y = -outer_y;
351 if (xptr) *xptr = real_x;
352 if (yptr) *yptr = real_y;
354 if (right_offset_x || bottom_offset_y)
356 int xy_ign;
357 unsigned int ign, fw, fh;
358 Window rootw;
360 XGetGeometry (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
361 &rootw, &xy_ign, &xy_ign, &fw, &fh, &ign, &ign);
362 if (right_offset_x) *right_offset_x = ow - fw + outer_x;
363 if (bottom_offset_y) *bottom_offset_y = oh - fh + outer_y;
367 /* Store the screen positions of frame F into XPTR and YPTR.
368 These are the positions of the containing window manager window,
369 not Emacs's own window. */
371 void
372 x_real_positions (struct frame *f, int *xptr, int *yptr)
374 x_real_pos_and_offsets (f, NULL, NULL, NULL, NULL, NULL, NULL, xptr, yptr,
375 NULL);
379 /* Get the mouse position in frame relative coordinates. */
381 void
382 x_relative_mouse_position (struct frame *f, int *x, int *y)
384 Window root, dummy_window;
385 int dummy;
387 eassert (FRAME_X_P (f));
389 block_input ();
391 XQueryPointer (FRAME_X_DISPLAY (f),
392 DefaultRootWindow (FRAME_X_DISPLAY (f)),
394 /* The root window which contains the pointer. */
395 &root,
397 /* Window pointer is on, not used */
398 &dummy_window,
400 /* The position on that root window. */
401 x, y,
403 /* x/y in dummy_window coordinates, not used. */
404 &dummy, &dummy,
406 /* Modifier keys and pointer buttons, about which
407 we don't care. */
408 (unsigned int *) &dummy);
410 XTranslateCoordinates (FRAME_X_DISPLAY (f),
412 /* From-window, to-window. */
413 FRAME_DISPLAY_INFO (f)->root_window,
414 FRAME_X_WINDOW (f),
416 /* From-position, to-position. */
417 *x, *y, x, y,
419 /* Child of win. */
420 &dummy_window);
422 unblock_input ();
425 /* Gamma-correct COLOR on frame F. */
427 void
428 gamma_correct (struct frame *f, XColor *color)
430 if (f->gamma)
432 color->red = pow (color->red / 65535.0, f->gamma) * 65535.0 + 0.5;
433 color->green = pow (color->green / 65535.0, f->gamma) * 65535.0 + 0.5;
434 color->blue = pow (color->blue / 65535.0, f->gamma) * 65535.0 + 0.5;
439 /* Decide if color named COLOR_NAME is valid for use on frame F. If
440 so, return the RGB values in COLOR. If ALLOC_P,
441 allocate the color. Value is false if COLOR_NAME is invalid, or
442 no color could be allocated. */
444 bool
445 x_defined_color (struct frame *f, const char *color_name,
446 XColor *color, bool alloc_p)
448 bool success_p = false;
449 Display *dpy = FRAME_X_DISPLAY (f);
450 Colormap cmap = FRAME_X_COLORMAP (f);
452 block_input ();
453 #ifdef USE_GTK
454 success_p = xg_check_special_colors (f, color_name, color);
455 #endif
456 if (!success_p)
457 success_p = XParseColor (dpy, cmap, color_name, color) != 0;
458 if (success_p && alloc_p)
459 success_p = x_alloc_nearest_color (f, cmap, color);
460 unblock_input ();
462 return success_p;
466 /* Return the pixel color value for color COLOR_NAME on frame F. If F
467 is a monochrome frame, return MONO_COLOR regardless of what ARG says.
468 Signal an error if color can't be allocated. */
470 static int
471 x_decode_color (struct frame *f, Lisp_Object color_name, int mono_color)
473 XColor cdef;
475 CHECK_STRING (color_name);
477 #if false /* Don't do this. It's wrong when we're not using the default
478 colormap, it makes freeing difficult, and it's probably not
479 an important optimization. */
480 if (strcmp (SDATA (color_name), "black") == 0)
481 return BLACK_PIX_DEFAULT (f);
482 else if (strcmp (SDATA (color_name), "white") == 0)
483 return WHITE_PIX_DEFAULT (f);
484 #endif
486 /* Return MONO_COLOR for monochrome frames. */
487 if (FRAME_DISPLAY_INFO (f)->n_planes == 1)
488 return mono_color;
490 /* x_defined_color is responsible for coping with failures
491 by looking for a near-miss. */
492 if (x_defined_color (f, SSDATA (color_name), &cdef, true))
493 return cdef.pixel;
495 signal_error ("Undefined color", color_name);
500 /* Change the `wait-for-wm' frame parameter of frame F. OLD_VALUE is
501 the previous value of that parameter, NEW_VALUE is the new value.
502 See also the comment of wait_for_wm in struct x_output. */
504 static void
505 x_set_wait_for_wm (struct frame *f, Lisp_Object new_value, Lisp_Object old_value)
507 f->output_data.x->wait_for_wm = !NILP (new_value);
510 static void
511 x_set_tool_bar_position (struct frame *f,
512 Lisp_Object new_value,
513 Lisp_Object old_value)
515 Lisp_Object choice = list4 (Qleft, Qright, Qtop, Qbottom);
517 if (!NILP (Fmemq (new_value, choice)))
519 #ifdef USE_GTK
520 if (!EQ (new_value, old_value))
522 xg_change_toolbar_position (f, new_value);
523 fset_tool_bar_position (f, new_value);
525 #else
526 if (!EQ (new_value, Qtop))
527 error ("The only supported tool bar position is top");
528 #endif
530 else
531 wrong_choice (choice, new_value);
534 #ifdef USE_GTK
536 /* Set icon from FILE for frame F. By using GTK functions the icon
537 may be any format that GdkPixbuf knows about, i.e. not just bitmaps. */
539 bool
540 xg_set_icon (struct frame *f, Lisp_Object file)
542 bool result = false;
543 Lisp_Object found;
545 found = x_find_image_file (file);
547 if (! NILP (found))
549 GdkPixbuf *pixbuf;
550 GError *err = NULL;
551 char *filename = SSDATA (found);
552 block_input ();
554 pixbuf = gdk_pixbuf_new_from_file (filename, &err);
556 if (pixbuf)
558 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
559 pixbuf);
560 g_object_unref (pixbuf);
562 result = true;
564 else
565 g_error_free (err);
567 unblock_input ();
570 return result;
573 bool
574 xg_set_icon_from_xpm_data (struct frame *f, const char **data)
576 GdkPixbuf *pixbuf = gdk_pixbuf_new_from_xpm_data (data);
578 if (!pixbuf)
579 return false;
581 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)), pixbuf);
582 g_object_unref (pixbuf);
583 return true;
585 #endif /* USE_GTK */
588 /* Functions called only from `x_set_frame_param'
589 to set individual parameters.
591 If FRAME_X_WINDOW (f) is 0,
592 the frame is being created and its X-window does not exist yet.
593 In that case, just record the parameter's new value
594 in the standard place; do not attempt to change the window. */
596 static void
597 x_set_foreground_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
599 struct x_output *x = f->output_data.x;
600 unsigned long fg, old_fg;
602 fg = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
603 old_fg = FRAME_FOREGROUND_PIXEL (f);
604 FRAME_FOREGROUND_PIXEL (f) = fg;
606 if (FRAME_X_WINDOW (f) != 0)
608 Display *dpy = FRAME_X_DISPLAY (f);
610 block_input ();
611 XSetForeground (dpy, x->normal_gc, fg);
612 XSetBackground (dpy, x->reverse_gc, fg);
614 if (x->cursor_pixel == old_fg)
616 unload_color (f, x->cursor_pixel);
617 x->cursor_pixel = x_copy_color (f, fg);
618 XSetBackground (dpy, x->cursor_gc, x->cursor_pixel);
621 unblock_input ();
623 update_face_from_frame_parameter (f, Qforeground_color, arg);
625 if (FRAME_VISIBLE_P (f))
626 redraw_frame (f);
629 unload_color (f, old_fg);
632 static void
633 x_set_background_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
635 struct x_output *x = f->output_data.x;
636 unsigned long bg;
638 bg = x_decode_color (f, arg, WHITE_PIX_DEFAULT (f));
639 unload_color (f, FRAME_BACKGROUND_PIXEL (f));
640 FRAME_BACKGROUND_PIXEL (f) = bg;
642 if (FRAME_X_WINDOW (f) != 0)
644 Display *dpy = FRAME_X_DISPLAY (f);
646 block_input ();
647 XSetBackground (dpy, x->normal_gc, bg);
648 XSetForeground (dpy, x->reverse_gc, bg);
649 XSetWindowBackground (dpy, FRAME_X_WINDOW (f), bg);
650 XSetForeground (dpy, x->cursor_gc, bg);
652 #ifdef USE_GTK
653 xg_set_background_color (f, bg);
654 #endif
656 #ifndef USE_TOOLKIT_SCROLL_BARS /* Turns out to be annoying with
657 toolkit scroll bars. */
659 Lisp_Object bar;
660 for (bar = FRAME_SCROLL_BARS (f);
661 !NILP (bar);
662 bar = XSCROLL_BAR (bar)->next)
664 Window window = XSCROLL_BAR (bar)->x_window;
665 XSetWindowBackground (dpy, window, bg);
668 #endif /* USE_TOOLKIT_SCROLL_BARS */
670 unblock_input ();
671 update_face_from_frame_parameter (f, Qbackground_color, arg);
673 if (FRAME_VISIBLE_P (f))
674 redraw_frame (f);
678 static void
679 x_set_mouse_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
681 struct x_output *x = f->output_data.x;
682 Display *dpy = FRAME_X_DISPLAY (f);
683 Cursor cursor, nontext_cursor, mode_cursor, hand_cursor;
684 Cursor hourglass_cursor, horizontal_drag_cursor, vertical_drag_cursor;
685 unsigned long pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
686 unsigned long mask_color = FRAME_BACKGROUND_PIXEL (f);
688 /* Don't let pointers be invisible. */
689 if (mask_color == pixel)
691 x_free_colors (f, &pixel, 1);
692 pixel = x_copy_color (f, FRAME_FOREGROUND_PIXEL (f));
695 unload_color (f, x->mouse_pixel);
696 x->mouse_pixel = pixel;
698 block_input ();
700 /* It's not okay to crash if the user selects a screwy cursor. */
701 x_catch_errors (dpy);
703 if (!NILP (Vx_pointer_shape))
705 CHECK_NUMBER (Vx_pointer_shape);
706 cursor = XCreateFontCursor (dpy, XINT (Vx_pointer_shape));
708 else
709 cursor = XCreateFontCursor (dpy, XC_xterm);
710 x_check_errors (dpy, "bad text pointer cursor: %s");
712 if (!NILP (Vx_nontext_pointer_shape))
714 CHECK_NUMBER (Vx_nontext_pointer_shape);
715 nontext_cursor
716 = XCreateFontCursor (dpy, XINT (Vx_nontext_pointer_shape));
718 else
719 nontext_cursor = XCreateFontCursor (dpy, XC_left_ptr);
720 x_check_errors (dpy, "bad nontext pointer cursor: %s");
722 if (!NILP (Vx_hourglass_pointer_shape))
724 CHECK_NUMBER (Vx_hourglass_pointer_shape);
725 hourglass_cursor
726 = XCreateFontCursor (dpy, XINT (Vx_hourglass_pointer_shape));
728 else
729 hourglass_cursor = XCreateFontCursor (dpy, XC_watch);
730 x_check_errors (dpy, "bad hourglass pointer cursor: %s");
732 if (!NILP (Vx_mode_pointer_shape))
734 CHECK_NUMBER (Vx_mode_pointer_shape);
735 mode_cursor = XCreateFontCursor (dpy, XINT (Vx_mode_pointer_shape));
737 else
738 mode_cursor = XCreateFontCursor (dpy, XC_xterm);
739 x_check_errors (dpy, "bad modeline pointer cursor: %s");
741 if (!NILP (Vx_sensitive_text_pointer_shape))
743 CHECK_NUMBER (Vx_sensitive_text_pointer_shape);
744 hand_cursor
745 = XCreateFontCursor (dpy, XINT (Vx_sensitive_text_pointer_shape));
747 else
748 hand_cursor = XCreateFontCursor (dpy, XC_hand2);
750 if (!NILP (Vx_window_horizontal_drag_shape))
752 CHECK_TYPE_RANGED_INTEGER (unsigned, Vx_window_horizontal_drag_shape);
753 horizontal_drag_cursor
754 = XCreateFontCursor (dpy, XINT (Vx_window_horizontal_drag_shape));
756 else
757 horizontal_drag_cursor
758 = XCreateFontCursor (dpy, XC_sb_h_double_arrow);
760 if (!NILP (Vx_window_vertical_drag_shape))
762 CHECK_NUMBER (Vx_window_vertical_drag_shape);
763 vertical_drag_cursor
764 = XCreateFontCursor (dpy, XINT (Vx_window_vertical_drag_shape));
766 else
767 vertical_drag_cursor
768 = XCreateFontCursor (dpy, XC_sb_v_double_arrow);
770 /* Check and report errors with the above calls. */
771 x_check_errors (dpy, "can't set cursor shape: %s");
772 x_uncatch_errors ();
775 XColor fore_color, back_color;
777 fore_color.pixel = x->mouse_pixel;
778 x_query_color (f, &fore_color);
779 back_color.pixel = mask_color;
780 x_query_color (f, &back_color);
782 XRecolorCursor (dpy, cursor, &fore_color, &back_color);
783 XRecolorCursor (dpy, nontext_cursor, &fore_color, &back_color);
784 XRecolorCursor (dpy, mode_cursor, &fore_color, &back_color);
785 XRecolorCursor (dpy, hand_cursor, &fore_color, &back_color);
786 XRecolorCursor (dpy, hourglass_cursor, &fore_color, &back_color);
787 XRecolorCursor (dpy, horizontal_drag_cursor, &fore_color, &back_color);
788 XRecolorCursor (dpy, vertical_drag_cursor, &fore_color, &back_color);
791 if (FRAME_X_WINDOW (f) != 0)
792 XDefineCursor (dpy, FRAME_X_WINDOW (f),
793 f->output_data.x->current_cursor = cursor);
795 if (cursor != x->text_cursor
796 && x->text_cursor != 0)
797 XFreeCursor (dpy, x->text_cursor);
798 x->text_cursor = cursor;
800 if (nontext_cursor != x->nontext_cursor
801 && x->nontext_cursor != 0)
802 XFreeCursor (dpy, x->nontext_cursor);
803 x->nontext_cursor = nontext_cursor;
805 if (hourglass_cursor != x->hourglass_cursor
806 && x->hourglass_cursor != 0)
807 XFreeCursor (dpy, x->hourglass_cursor);
808 x->hourglass_cursor = hourglass_cursor;
810 if (mode_cursor != x->modeline_cursor
811 && x->modeline_cursor != 0)
812 XFreeCursor (dpy, f->output_data.x->modeline_cursor);
813 x->modeline_cursor = mode_cursor;
815 if (hand_cursor != x->hand_cursor
816 && x->hand_cursor != 0)
817 XFreeCursor (dpy, x->hand_cursor);
818 x->hand_cursor = hand_cursor;
820 if (horizontal_drag_cursor != x->horizontal_drag_cursor
821 && x->horizontal_drag_cursor != 0)
822 XFreeCursor (dpy, x->horizontal_drag_cursor);
823 x->horizontal_drag_cursor = horizontal_drag_cursor;
825 if (vertical_drag_cursor != x->vertical_drag_cursor
826 && x->vertical_drag_cursor != 0)
827 XFreeCursor (dpy, x->vertical_drag_cursor);
828 x->vertical_drag_cursor = vertical_drag_cursor;
830 XFlush (dpy);
831 unblock_input ();
833 update_face_from_frame_parameter (f, Qmouse_color, arg);
836 static void
837 x_set_cursor_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
839 unsigned long fore_pixel, pixel;
840 bool fore_pixel_allocated_p = false, pixel_allocated_p = false;
841 struct x_output *x = f->output_data.x;
843 if (!NILP (Vx_cursor_fore_pixel))
845 fore_pixel = x_decode_color (f, Vx_cursor_fore_pixel,
846 WHITE_PIX_DEFAULT (f));
847 fore_pixel_allocated_p = true;
849 else
850 fore_pixel = FRAME_BACKGROUND_PIXEL (f);
852 pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
853 pixel_allocated_p = true;
855 /* Make sure that the cursor color differs from the background color. */
856 if (pixel == FRAME_BACKGROUND_PIXEL (f))
858 if (pixel_allocated_p)
860 x_free_colors (f, &pixel, 1);
861 pixel_allocated_p = false;
864 pixel = x->mouse_pixel;
865 if (pixel == fore_pixel)
867 if (fore_pixel_allocated_p)
869 x_free_colors (f, &fore_pixel, 1);
870 fore_pixel_allocated_p = false;
872 fore_pixel = FRAME_BACKGROUND_PIXEL (f);
876 unload_color (f, x->cursor_foreground_pixel);
877 if (!fore_pixel_allocated_p)
878 fore_pixel = x_copy_color (f, fore_pixel);
879 x->cursor_foreground_pixel = fore_pixel;
881 unload_color (f, x->cursor_pixel);
882 if (!pixel_allocated_p)
883 pixel = x_copy_color (f, pixel);
884 x->cursor_pixel = pixel;
886 if (FRAME_X_WINDOW (f) != 0)
888 block_input ();
889 XSetBackground (FRAME_X_DISPLAY (f), x->cursor_gc, x->cursor_pixel);
890 XSetForeground (FRAME_X_DISPLAY (f), x->cursor_gc, fore_pixel);
891 unblock_input ();
893 if (FRAME_VISIBLE_P (f))
895 x_update_cursor (f, false);
896 x_update_cursor (f, true);
900 update_face_from_frame_parameter (f, Qcursor_color, arg);
903 /* Set the border-color of frame F to pixel value PIX.
904 Note that this does not fully take effect if done before
905 F has an x-window. */
907 static void
908 x_set_border_pixel (struct frame *f, int pix)
910 unload_color (f, f->output_data.x->border_pixel);
911 f->output_data.x->border_pixel = pix;
913 if (FRAME_X_WINDOW (f) != 0 && f->border_width > 0)
915 block_input ();
916 XSetWindowBorder (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), pix);
917 unblock_input ();
919 if (FRAME_VISIBLE_P (f))
920 redraw_frame (f);
924 /* Set the border-color of frame F to value described by ARG.
925 ARG can be a string naming a color.
926 The border-color is used for the border that is drawn by the X server.
927 Note that this does not fully take effect if done before
928 F has an x-window; it must be redone when the window is created.
930 Note: this is done in two routines because of the way X10 works.
932 Note: under X11, this is normally the province of the window manager,
933 and so emacs's border colors may be overridden. */
935 static void
936 x_set_border_color (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
938 int pix;
940 CHECK_STRING (arg);
941 pix = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
942 x_set_border_pixel (f, pix);
943 update_face_from_frame_parameter (f, Qborder_color, arg);
947 static void
948 x_set_cursor_type (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
950 set_frame_cursor_types (f, arg);
953 static void
954 x_set_icon_type (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
956 bool result;
958 if (STRINGP (arg))
960 if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
961 return;
963 else if (!STRINGP (oldval) && EQ (oldval, Qnil) == EQ (arg, Qnil))
964 return;
966 block_input ();
967 if (NILP (arg))
968 result = x_text_icon (f,
969 SSDATA ((!NILP (f->icon_name)
970 ? f->icon_name
971 : f->name)));
972 else
973 result = x_bitmap_icon (f, arg);
975 if (result)
977 unblock_input ();
978 error ("No icon window available");
981 XFlush (FRAME_X_DISPLAY (f));
982 unblock_input ();
985 static void
986 x_set_icon_name (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
988 bool result;
990 if (STRINGP (arg))
992 if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
993 return;
995 else if (!NILP (arg) || NILP (oldval))
996 return;
998 fset_icon_name (f, arg);
1000 if (f->output_data.x->icon_bitmap != 0)
1001 return;
1003 block_input ();
1005 result = x_text_icon (f,
1006 SSDATA ((!NILP (f->icon_name)
1007 ? f->icon_name
1008 : !NILP (f->title)
1009 ? f->title
1010 : f->name)));
1012 if (result)
1014 unblock_input ();
1015 error ("No icon window available");
1018 XFlush (FRAME_X_DISPLAY (f));
1019 unblock_input ();
1023 static void
1024 x_set_menu_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
1026 int nlines;
1027 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1028 int olines = FRAME_MENU_BAR_LINES (f);
1029 #endif
1031 /* Right now, menu bars don't work properly in minibuf-only frames;
1032 most of the commands try to apply themselves to the minibuffer
1033 frame itself, and get an error because you can't switch buffers
1034 in or split the minibuffer window. */
1035 if (FRAME_MINIBUF_ONLY_P (f))
1036 return;
1038 if (TYPE_RANGED_INTEGERP (int, value))
1039 nlines = XINT (value);
1040 else
1041 nlines = 0;
1043 /* Make sure we redisplay all windows in this frame. */
1044 windows_or_buffers_changed = 59;
1046 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1047 FRAME_MENU_BAR_LINES (f) = 0;
1048 FRAME_MENU_BAR_HEIGHT (f) = 0;
1049 if (nlines)
1051 FRAME_EXTERNAL_MENU_BAR (f) = 1;
1052 if (FRAME_X_P (f) && f->output_data.x->menubar_widget == 0)
1053 /* Make sure next redisplay shows the menu bar. */
1054 XWINDOW (FRAME_SELECTED_WINDOW (f))->update_mode_line = true;
1056 else
1058 if (FRAME_EXTERNAL_MENU_BAR (f) == 1)
1059 free_frame_menubar (f);
1060 FRAME_EXTERNAL_MENU_BAR (f) = 0;
1061 if (FRAME_X_P (f))
1062 f->output_data.x->menubar_widget = 0;
1064 #else /* not USE_X_TOOLKIT && not USE_GTK */
1065 FRAME_MENU_BAR_LINES (f) = nlines;
1066 FRAME_MENU_BAR_HEIGHT (f) = nlines * FRAME_LINE_HEIGHT (f);
1067 adjust_frame_size (f, -1, -1, 2, true, Qmenu_bar_lines);
1068 if (FRAME_X_WINDOW (f))
1069 x_clear_under_internal_border (f);
1071 /* If the menu bar height gets changed, the internal border below
1072 the top margin has to be cleared. Also, if the menu bar gets
1073 larger, the area for the added lines has to be cleared except for
1074 the first menu bar line that is to be drawn later. */
1075 if (nlines != olines)
1077 int height = FRAME_INTERNAL_BORDER_WIDTH (f);
1078 int width = FRAME_PIXEL_WIDTH (f);
1079 int y;
1081 /* height can be zero here. */
1082 if (FRAME_X_WINDOW (f) && height > 0 && width > 0)
1084 y = FRAME_TOP_MARGIN_HEIGHT (f);
1086 block_input ();
1087 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1088 0, y, width, height);
1089 unblock_input ();
1092 if (nlines > 1 && nlines > olines)
1094 y = (olines == 0 ? 1 : olines) * FRAME_LINE_HEIGHT (f);
1095 height = nlines * FRAME_LINE_HEIGHT (f) - y;
1097 block_input ();
1098 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1099 0, y, width, height);
1100 unblock_input ();
1103 if (nlines == 0 && WINDOWP (f->menu_bar_window))
1104 clear_glyph_matrix (XWINDOW (f->menu_bar_window)->current_matrix);
1106 #endif /* not USE_X_TOOLKIT && not USE_GTK */
1107 adjust_frame_glyphs (f);
1108 run_window_configuration_change_hook (f);
1112 /* Set the number of lines used for the tool bar of frame F to VALUE.
1113 VALUE not an integer, or < 0 means set the lines to zero. OLDVAL
1114 is the old number of tool bar lines. This function changes the
1115 height of all windows on frame F to match the new tool bar height.
1116 The frame's height doesn't change. */
1118 static void
1119 x_set_tool_bar_lines (struct frame *f, Lisp_Object value, Lisp_Object oldval)
1121 int nlines;
1123 /* Treat tool bars like menu bars. */
1124 if (FRAME_MINIBUF_ONLY_P (f))
1125 return;
1127 /* Use VALUE only if an int >= 0. */
1128 if (RANGED_INTEGERP (0, value, INT_MAX))
1129 nlines = XFASTINT (value);
1130 else
1131 nlines = 0;
1133 x_change_tool_bar_height (f, nlines * FRAME_LINE_HEIGHT (f));
1137 /* Set the pixel height of the tool bar of frame F to HEIGHT. */
1138 void
1139 x_change_tool_bar_height (struct frame *f, int height)
1141 #ifdef USE_GTK
1142 FRAME_TOOL_BAR_LINES (f) = 0;
1143 FRAME_TOOL_BAR_HEIGHT (f) = 0;
1144 if (height)
1146 FRAME_EXTERNAL_TOOL_BAR (f) = true;
1147 if (FRAME_X_P (f) && f->output_data.x->toolbar_widget == 0)
1148 /* Make sure next redisplay shows the tool bar. */
1149 XWINDOW (FRAME_SELECTED_WINDOW (f))->update_mode_line = true;
1150 update_frame_tool_bar (f);
1152 else
1154 if (FRAME_EXTERNAL_TOOL_BAR (f))
1155 free_frame_tool_bar (f);
1156 FRAME_EXTERNAL_TOOL_BAR (f) = false;
1158 #else /* !USE_GTK */
1159 int unit = FRAME_LINE_HEIGHT (f);
1160 int old_height = FRAME_TOOL_BAR_HEIGHT (f);
1161 int lines = (height + unit - 1) / unit;
1162 Lisp_Object fullscreen;
1164 /* Make sure we redisplay all windows in this frame. */
1165 windows_or_buffers_changed = 60;
1168 /* Recalculate tool bar and frame text sizes. */
1169 FRAME_TOOL_BAR_HEIGHT (f) = height;
1170 FRAME_TOOL_BAR_LINES (f) = lines;
1171 /* Store the `tool-bar-lines' and `height' frame parameters. */
1172 store_frame_param (f, Qtool_bar_lines, make_number (lines));
1173 store_frame_param (f, Qheight, make_number (FRAME_LINES (f)));
1175 /* We also have to make sure that the internal border at the top of
1176 the frame, below the menu bar or tool bar, is redrawn when the
1177 tool bar disappears. This is so because the internal border is
1178 below the tool bar if one is displayed, but is below the menu bar
1179 if there isn't a tool bar. The tool bar draws into the area
1180 below the menu bar. */
1181 if (FRAME_X_WINDOW (f) && FRAME_TOOL_BAR_HEIGHT (f) == 0)
1183 clear_frame (f);
1184 clear_current_matrices (f);
1187 if ((height < old_height) && WINDOWP (f->tool_bar_window))
1188 clear_glyph_matrix (XWINDOW (f->tool_bar_window)->current_matrix);
1190 /* Recalculate toolbar height. */
1191 f->n_tool_bar_rows = 0;
1193 adjust_frame_size (f, -1, -1,
1194 ((!f->tool_bar_redisplayed_once
1195 && (NILP (fullscreen =
1196 get_frame_param (f, Qfullscreen))
1197 || EQ (fullscreen, Qfullwidth))) ? 1
1198 : (old_height == 0 || height == 0) ? 2
1199 : 4),
1200 false, Qtool_bar_lines);
1202 /* adjust_frame_size might not have done anything, garbage frame
1203 here. */
1204 adjust_frame_glyphs (f);
1205 SET_FRAME_GARBAGED (f);
1206 if (FRAME_X_WINDOW (f))
1207 x_clear_under_internal_border (f);
1209 #endif /* USE_GTK */
1213 static void
1214 x_set_internal_border_width (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1216 int border;
1218 CHECK_TYPE_RANGED_INTEGER (int, arg);
1219 border = max (XINT (arg), 0);
1221 if (border != FRAME_INTERNAL_BORDER_WIDTH (f))
1223 FRAME_INTERNAL_BORDER_WIDTH (f) = border;
1225 #ifdef USE_X_TOOLKIT
1226 if (FRAME_X_OUTPUT (f)->edit_widget)
1227 widget_store_internal_border (FRAME_X_OUTPUT (f)->edit_widget);
1228 #endif
1230 if (FRAME_X_WINDOW (f) != 0)
1232 adjust_frame_size (f, -1, -1, 3, false, Qinternal_border_width);
1234 #ifdef USE_GTK
1235 xg_clear_under_internal_border (f);
1236 #else
1237 x_clear_under_internal_border (f);
1238 #endif
1245 /* Set the foreground color for scroll bars on frame F to VALUE.
1246 VALUE should be a string, a color name. If it isn't a string or
1247 isn't a valid color name, do nothing. OLDVAL is the old value of
1248 the frame parameter. */
1250 static void
1251 x_set_scroll_bar_foreground (struct frame *f, Lisp_Object value, Lisp_Object oldval)
1253 unsigned long pixel;
1255 if (STRINGP (value))
1256 pixel = x_decode_color (f, value, BLACK_PIX_DEFAULT (f));
1257 else
1258 pixel = -1;
1260 if (f->output_data.x->scroll_bar_foreground_pixel != -1)
1261 unload_color (f, f->output_data.x->scroll_bar_foreground_pixel);
1263 f->output_data.x->scroll_bar_foreground_pixel = pixel;
1264 if (FRAME_X_WINDOW (f) && FRAME_VISIBLE_P (f))
1266 /* Remove all scroll bars because they have wrong colors. */
1267 if (FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
1268 (*FRAME_TERMINAL (f)->condemn_scroll_bars_hook) (f);
1269 if (FRAME_TERMINAL (f)->judge_scroll_bars_hook)
1270 (*FRAME_TERMINAL (f)->judge_scroll_bars_hook) (f);
1272 update_face_from_frame_parameter (f, Qscroll_bar_foreground, value);
1273 redraw_frame (f);
1278 /* Set the background color for scroll bars on frame F to VALUE VALUE
1279 should be a string, a color name. If it isn't a string or isn't a
1280 valid color name, do nothing. OLDVAL is the old value of the frame
1281 parameter. */
1283 static void
1284 x_set_scroll_bar_background (struct frame *f, Lisp_Object value, Lisp_Object oldval)
1286 unsigned long pixel;
1288 if (STRINGP (value))
1289 pixel = x_decode_color (f, value, WHITE_PIX_DEFAULT (f));
1290 else
1291 pixel = -1;
1293 if (f->output_data.x->scroll_bar_background_pixel != -1)
1294 unload_color (f, f->output_data.x->scroll_bar_background_pixel);
1296 #if defined (USE_LUCID) && defined (USE_TOOLKIT_SCROLL_BARS)
1297 /* Scrollbar shadow colors. */
1298 if (f->output_data.x->scroll_bar_top_shadow_pixel != -1)
1300 unload_color (f, f->output_data.x->scroll_bar_top_shadow_pixel);
1301 f->output_data.x->scroll_bar_top_shadow_pixel = -1;
1303 if (f->output_data.x->scroll_bar_bottom_shadow_pixel != -1)
1305 unload_color (f, f->output_data.x->scroll_bar_bottom_shadow_pixel);
1306 f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
1308 #endif /* USE_LUCID && USE_TOOLKIT_SCROLL_BARS */
1310 f->output_data.x->scroll_bar_background_pixel = pixel;
1311 if (FRAME_X_WINDOW (f) && FRAME_VISIBLE_P (f))
1313 /* Remove all scroll bars because they have wrong colors. */
1314 if (FRAME_TERMINAL (f)->condemn_scroll_bars_hook)
1315 (*FRAME_TERMINAL (f)->condemn_scroll_bars_hook) (f);
1316 if (FRAME_TERMINAL (f)->judge_scroll_bars_hook)
1317 (*FRAME_TERMINAL (f)->judge_scroll_bars_hook) (f);
1319 update_face_from_frame_parameter (f, Qscroll_bar_background, value);
1320 redraw_frame (f);
1325 /* Encode Lisp string STRING as a text in a format appropriate for
1326 XICCC (X Inter Client Communication Conventions).
1328 This can call Lisp code, so callers must GCPRO.
1330 If STRING contains only ASCII characters, do no conversion and
1331 return the string data of STRING. Otherwise, encode the text by
1332 CODING_SYSTEM, and return a newly allocated memory area which
1333 should be freed by `xfree' by a caller.
1335 Store the byte length of resulting text in *TEXT_BYTES.
1337 If the text contains only ASCII and Latin-1, store true in *STRING_P,
1338 which means that the `encoding' of the result can be `STRING'.
1339 Otherwise store false in *STRINGP, which means that the `encoding' of
1340 the result should be `COMPOUND_TEXT'. */
1342 static unsigned char *
1343 x_encode_text (Lisp_Object string, Lisp_Object coding_system,
1344 ptrdiff_t *text_bytes, bool *stringp, bool *freep)
1346 int result = string_xstring_p (string);
1347 struct coding_system coding;
1349 if (result == 0)
1351 /* No multibyte character in OBJ. We need not encode it. */
1352 *text_bytes = SBYTES (string);
1353 *stringp = true;
1354 *freep = false;
1355 return SDATA (string);
1358 setup_coding_system (coding_system, &coding);
1359 coding.mode |= (CODING_MODE_SAFE_ENCODING | CODING_MODE_LAST_BLOCK);
1360 /* We suppress producing escape sequences for composition. */
1361 coding.common_flags &= ~CODING_ANNOTATION_MASK;
1362 coding.destination = xnmalloc (SCHARS (string), 2);
1363 coding.dst_bytes = SCHARS (string) * 2;
1364 encode_coding_object (&coding, string, 0, 0,
1365 SCHARS (string), SBYTES (string), Qnil);
1366 *text_bytes = coding.produced;
1367 *stringp = (result == 1 || !EQ (coding_system, Qcompound_text));
1368 *freep = true;
1369 return coding.destination;
1373 /* Set the WM name to NAME for frame F. Also set the icon name.
1374 If the frame already has an icon name, use that, otherwise set the
1375 icon name to NAME. */
1377 static void
1378 x_set_name_internal (struct frame *f, Lisp_Object name)
1380 if (FRAME_X_WINDOW (f))
1382 block_input ();
1384 XTextProperty text, icon;
1385 ptrdiff_t bytes;
1386 bool stringp;
1387 bool do_free_icon_value = false, do_free_text_value = false;
1388 Lisp_Object coding_system;
1389 Lisp_Object encoded_name;
1390 Lisp_Object encoded_icon_name;
1391 struct gcpro gcpro1;
1393 /* As ENCODE_UTF_8 may cause GC and relocation of string data,
1394 we use it before x_encode_text that may return string data. */
1395 GCPRO1 (name);
1396 encoded_name = ENCODE_UTF_8 (name);
1397 UNGCPRO;
1399 coding_system = Qcompound_text;
1400 /* Note: Encoding strategy
1402 We encode NAME by compound-text and use "COMPOUND-TEXT" in
1403 text.encoding. But, there are non-internationalized window
1404 managers which don't support that encoding. So, if NAME
1405 contains only ASCII and 8859-1 characters, encode it by
1406 iso-latin-1, and use "STRING" in text.encoding hoping that
1407 such window managers at least analyze this format correctly,
1408 i.e. treat 8-bit bytes as 8859-1 characters.
1410 We may also be able to use "UTF8_STRING" in text.encoding
1411 in the future which can encode all Unicode characters.
1412 But, for the moment, there's no way to know that the
1413 current window manager supports it or not.
1415 Either way, we also set the _NET_WM_NAME and _NET_WM_ICON_NAME
1416 properties. Per the EWMH specification, those two properties
1417 are always UTF8_STRING. This matches what gtk_window_set_title()
1418 does in the USE_GTK case. */
1419 text.value = x_encode_text (name, coding_system, &bytes,
1420 &stringp, &do_free_text_value);
1421 text.encoding = (stringp ? XA_STRING
1422 : FRAME_DISPLAY_INFO (f)->Xatom_COMPOUND_TEXT);
1423 text.format = 8;
1424 text.nitems = bytes;
1426 if (!STRINGP (f->icon_name))
1428 icon = text;
1429 encoded_icon_name = encoded_name;
1431 else
1433 /* See the above comment "Note: Encoding strategy". */
1434 icon.value = x_encode_text (f->icon_name, coding_system, &bytes,
1435 &stringp, &do_free_icon_value);
1436 icon.encoding = (stringp ? XA_STRING
1437 : FRAME_DISPLAY_INFO (f)->Xatom_COMPOUND_TEXT);
1438 icon.format = 8;
1439 icon.nitems = bytes;
1441 encoded_icon_name = ENCODE_UTF_8 (f->icon_name);
1444 #ifdef USE_GTK
1445 gtk_window_set_title (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
1446 SSDATA (encoded_name));
1447 #else /* not USE_GTK */
1448 XSetWMName (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &text);
1449 XChangeProperty (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
1450 FRAME_DISPLAY_INFO (f)->Xatom_net_wm_name,
1451 FRAME_DISPLAY_INFO (f)->Xatom_UTF8_STRING,
1452 8, PropModeReplace,
1453 SDATA (encoded_name),
1454 SBYTES (encoded_name));
1455 #endif /* not USE_GTK */
1457 XSetWMIconName (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &icon);
1458 XChangeProperty (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f),
1459 FRAME_DISPLAY_INFO (f)->Xatom_net_wm_icon_name,
1460 FRAME_DISPLAY_INFO (f)->Xatom_UTF8_STRING,
1461 8, PropModeReplace,
1462 SDATA (encoded_icon_name),
1463 SBYTES (encoded_icon_name));
1465 if (do_free_icon_value)
1466 xfree (icon.value);
1467 if (do_free_text_value)
1468 xfree (text.value);
1470 unblock_input ();
1474 /* Change the name of frame F to NAME. If NAME is nil, set F's name to
1475 x_id_name.
1477 If EXPLICIT is true, that indicates that lisp code is setting the
1478 name; if NAME is a string, set F's name to NAME and set
1479 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1481 If EXPLICIT is false, that indicates that Emacs redisplay code is
1482 suggesting a new name, which lisp code should override; if
1483 F->explicit_name is set, ignore the new name; otherwise, set it. */
1485 static void
1486 x_set_name (struct frame *f, Lisp_Object name, bool explicit)
1488 /* Make sure that requests from lisp code override requests from
1489 Emacs redisplay code. */
1490 if (explicit)
1492 /* If we're switching from explicit to implicit, we had better
1493 update the mode lines and thereby update the title. */
1494 if (f->explicit_name && NILP (name))
1495 update_mode_lines = 37;
1497 f->explicit_name = ! NILP (name);
1499 else if (f->explicit_name)
1500 return;
1502 /* If NAME is nil, set the name to the x_id_name. */
1503 if (NILP (name))
1505 /* Check for no change needed in this very common case
1506 before we do any consing. */
1507 if (!strcmp (FRAME_DISPLAY_INFO (f)->x_id_name,
1508 SSDATA (f->name)))
1509 return;
1510 name = build_string (FRAME_DISPLAY_INFO (f)->x_id_name);
1512 else
1513 CHECK_STRING (name);
1515 /* Don't change the name if it's already NAME. */
1516 if (! NILP (Fstring_equal (name, f->name)))
1517 return;
1519 fset_name (f, name);
1521 /* For setting the frame title, the title parameter should override
1522 the name parameter. */
1523 if (! NILP (f->title))
1524 name = f->title;
1526 x_set_name_internal (f, name);
1529 /* This function should be called when the user's lisp code has
1530 specified a name for the frame; the name will override any set by the
1531 redisplay code. */
1532 static void
1533 x_explicitly_set_name (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1535 x_set_name (f, arg, true);
1538 /* This function should be called by Emacs redisplay code to set the
1539 name; names set this way will never override names set by the user's
1540 lisp code. */
1541 void
1542 x_implicitly_set_name (struct frame *f, Lisp_Object arg, Lisp_Object oldval)
1544 x_set_name (f, arg, false);
1547 /* Change the title of frame F to NAME.
1548 If NAME is nil, use the frame name as the title. */
1550 static void
1551 x_set_title (struct frame *f, Lisp_Object name, Lisp_Object old_name)
1553 /* Don't change the title if it's already NAME. */
1554 if (EQ (name, f->title))
1555 return;
1557 update_mode_lines = 38;
1559 fset_title (f, name);
1561 if (NILP (name))
1562 name = f->name;
1563 else
1564 CHECK_STRING (name);
1566 x_set_name_internal (f, name);
1569 void
1570 x_set_scroll_bar_default_width (struct frame *f)
1572 int unit = FRAME_COLUMN_WIDTH (f);
1573 #ifdef USE_TOOLKIT_SCROLL_BARS
1574 #ifdef USE_GTK
1575 int minw = xg_get_default_scrollbar_width ();
1576 #else
1577 int minw = 16;
1578 #endif
1579 /* A minimum width of 14 doesn't look good for toolkit scroll bars. */
1580 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (minw + unit - 1) / unit;
1581 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = minw;
1582 #else
1583 /* The width of a non-toolkit scrollbar is 14 pixels. */
1584 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + unit - 1) / unit;
1585 FRAME_CONFIG_SCROLL_BAR_WIDTH (f)
1586 = FRAME_CONFIG_SCROLL_BAR_COLS (f) * unit;
1587 #endif
1590 void
1591 x_set_scroll_bar_default_height (struct frame *f)
1593 int height = FRAME_LINE_HEIGHT (f);
1594 #ifdef USE_TOOLKIT_SCROLL_BARS
1595 #ifdef USE_GTK
1596 int min_height = xg_get_default_scrollbar_height ();
1597 #else
1598 int min_height = 16;
1599 #endif
1600 /* A minimum height of 14 doesn't look good for toolkit scroll bars. */
1601 FRAME_CONFIG_SCROLL_BAR_HEIGHT (f) = min_height;
1602 FRAME_CONFIG_SCROLL_BAR_LINES (f) = (min_height + height - 1) / height;
1603 #else
1604 /* The height of a non-toolkit scrollbar is 14 pixels. */
1605 FRAME_CONFIG_SCROLL_BAR_LINES (f) = (14 + height - 1) / height;
1607 /* Use all of that space (aside from required margins) for the
1608 scroll bar. */
1609 FRAME_CONFIG_SCROLL_BAR_HEIGHT (f) = 14;
1610 #endif
1614 /* Record in frame F the specified or default value according to ALIST
1615 of the parameter named PROP (a Lisp symbol). If no value is
1616 specified for PROP, look for an X default for XPROP on the frame
1617 named NAME. If that is not found either, use the value DEFLT. */
1619 static Lisp_Object
1620 x_default_scroll_bar_color_parameter (struct frame *f,
1621 Lisp_Object alist, Lisp_Object prop,
1622 const char *xprop, const char *xclass,
1623 bool foreground_p)
1625 struct x_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
1626 Lisp_Object tem;
1628 tem = x_get_arg (dpyinfo, alist, prop, xprop, xclass, RES_TYPE_STRING);
1629 if (EQ (tem, Qunbound))
1631 #ifdef USE_TOOLKIT_SCROLL_BARS
1633 /* See if an X resource for the scroll bar color has been
1634 specified. */
1635 AUTO_STRING (foreground, "foreground");
1636 AUTO_STRING (background, "foreground");
1637 AUTO_STRING (verticalScrollBar, "verticalScrollBar");
1638 tem = (display_x_get_resource
1639 (dpyinfo, foreground_p ? foreground : background,
1640 empty_unibyte_string,
1641 verticalScrollBar,
1642 empty_unibyte_string));
1643 if (!STRINGP (tem))
1645 /* If nothing has been specified, scroll bars will use a
1646 toolkit-dependent default. Because these defaults are
1647 difficult to get at without actually creating a scroll
1648 bar, use nil to indicate that no color has been
1649 specified. */
1650 tem = Qnil;
1653 #else /* not USE_TOOLKIT_SCROLL_BARS */
1655 tem = Qnil;
1657 #endif /* not USE_TOOLKIT_SCROLL_BARS */
1660 AUTO_FRAME_ARG (arg, prop, tem);
1661 x_set_frame_parameters (f, arg);
1662 return tem;
1668 #ifdef USE_X_TOOLKIT
1670 /* If the WM_PROTOCOLS property does not already contain WM_TAKE_FOCUS,
1671 WM_DELETE_WINDOW, and WM_SAVE_YOURSELF, then add them. (They may
1672 already be present because of the toolkit (Motif adds some of them,
1673 for example, but Xt doesn't). */
1675 static void
1676 hack_wm_protocols (struct frame *f, Widget widget)
1678 Display *dpy = XtDisplay (widget);
1679 Window w = XtWindow (widget);
1680 bool need_delete = true;
1681 bool need_focus = true;
1682 bool need_save = true;
1684 block_input ();
1686 Atom type;
1687 unsigned char *catoms;
1688 int format = 0;
1689 unsigned long nitems = 0;
1690 unsigned long bytes_after;
1692 if ((XGetWindowProperty (dpy, w,
1693 FRAME_DISPLAY_INFO (f)->Xatom_wm_protocols,
1694 0, 100, False, XA_ATOM,
1695 &type, &format, &nitems, &bytes_after,
1696 &catoms)
1697 == Success)
1698 && format == 32 && type == XA_ATOM)
1700 Atom *atoms = (Atom *) catoms;
1701 while (nitems > 0)
1703 nitems--;
1704 if (atoms[nitems]
1705 == FRAME_DISPLAY_INFO (f)->Xatom_wm_delete_window)
1706 need_delete = false;
1707 else if (atoms[nitems]
1708 == FRAME_DISPLAY_INFO (f)->Xatom_wm_take_focus)
1709 need_focus = false;
1710 else if (atoms[nitems]
1711 == FRAME_DISPLAY_INFO (f)->Xatom_wm_save_yourself)
1712 need_save = false;
1715 if (catoms)
1716 XFree (catoms);
1719 Atom props[10];
1720 int count = 0;
1721 if (need_delete)
1722 props[count++] = FRAME_DISPLAY_INFO (f)->Xatom_wm_delete_window;
1723 if (need_focus)
1724 props[count++] = FRAME_DISPLAY_INFO (f)->Xatom_wm_take_focus;
1725 if (need_save)
1726 props[count++] = FRAME_DISPLAY_INFO (f)->Xatom_wm_save_yourself;
1727 if (count)
1728 XChangeProperty (dpy, w, FRAME_DISPLAY_INFO (f)->Xatom_wm_protocols,
1729 XA_ATOM, 32, PropModeAppend,
1730 (unsigned char *) props, count);
1732 unblock_input ();
1734 #endif
1738 /* Support routines for XIC (X Input Context). */
1740 #ifdef HAVE_X_I18N
1742 static XFontSet xic_create_xfontset (struct frame *);
1743 static XIMStyle best_xim_style (XIMStyles *);
1746 /* Supported XIM styles, ordered by preference. */
1748 static const XIMStyle supported_xim_styles[] =
1750 XIMPreeditPosition | XIMStatusArea,
1751 XIMPreeditPosition | XIMStatusNothing,
1752 XIMPreeditPosition | XIMStatusNone,
1753 XIMPreeditNothing | XIMStatusArea,
1754 XIMPreeditNothing | XIMStatusNothing,
1755 XIMPreeditNothing | XIMStatusNone,
1756 XIMPreeditNone | XIMStatusArea,
1757 XIMPreeditNone | XIMStatusNothing,
1758 XIMPreeditNone | XIMStatusNone,
1763 #if defined HAVE_X_WINDOWS && defined USE_X_TOOLKIT
1764 /* Create an X fontset on frame F with base font name BASE_FONTNAME. */
1766 static const char xic_default_fontset[] = "-*-*-*-r-normal--14-*-*-*-*-*-*-*";
1768 /* Create an Xt fontset spec from the name of a base font.
1769 If `motif' is True use the Motif syntax. */
1770 char *
1771 xic_create_fontsetname (const char *base_fontname, bool motif)
1773 const char *sep = motif ? ";" : ",";
1774 char *fontsetname;
1775 char *z;
1777 /* Make a fontset name from the base font name. */
1778 if (xic_default_fontset == base_fontname)
1780 /* There is no base font name, use the default. */
1781 fontsetname = xmalloc (strlen (base_fontname) + 2);
1782 z = stpcpy (fontsetname, base_fontname);
1784 else
1786 /* Make a fontset name from the base font name.
1787 The font set will be made of the following elements:
1788 - the base font.
1789 - the base font where the charset spec is replaced by -*-*.
1790 - the same but with the family also replaced with -*-*-. */
1791 const char *p = base_fontname;
1792 ptrdiff_t i;
1794 for (i = 0; *p; p++)
1795 if (*p == '-') i++;
1796 if (i != 14)
1798 /* As the font name doesn't conform to XLFD, we can't
1799 modify it to generalize it to allcs and allfamilies.
1800 Use the specified font plus the default. */
1801 fontsetname = xmalloc (strlen (base_fontname)
1802 + strlen (xic_default_fontset) + 3);
1803 z = stpcpy (fontsetname, base_fontname);
1804 z = stpcpy (z, sep);
1805 z = stpcpy (z, xic_default_fontset);
1807 else
1809 ptrdiff_t len;
1810 const char *p1 = NULL, *p2 = NULL, *p3 = NULL;
1811 char *font_allcs = NULL;
1812 char *font_allfamilies = NULL;
1813 char *font_all = NULL;
1814 const char *allcs = "*-*-*-*-*-*-*";
1815 const char *allfamilies = "-*-*-";
1816 const char *all = "*-*-*-*-";
1817 char *base;
1819 for (i = 0, p = base_fontname; i < 8; p++)
1821 if (*p == '-')
1823 i++;
1824 if (i == 3)
1825 p1 = p + 1;
1826 else if (i == 7)
1827 p2 = p + 1;
1828 else if (i == 6)
1829 p3 = p + 1;
1832 /* If base_fontname specifies ADSTYLE, make it a
1833 wildcard. */
1834 if (*p3 != '*')
1836 ptrdiff_t diff = (p2 - p3) - 2;
1838 base = alloca (strlen (base_fontname) + 1);
1839 memcpy (base, base_fontname, p3 - base_fontname);
1840 base[p3 - base_fontname] = '*';
1841 base[(p3 - base_fontname) + 1] = '-';
1842 strcpy (base + (p3 - base_fontname) + 2, p2);
1843 p = base + (p - base_fontname) - diff;
1844 p1 = base + (p1 - base_fontname);
1845 p2 = base + (p2 - base_fontname) - diff;
1846 base_fontname = base;
1849 /* Build the font spec that matches all charsets. */
1850 len = p - base_fontname + strlen (allcs) + 1;
1851 font_allcs = alloca (len);
1852 memcpy (font_allcs, base_fontname, p - base_fontname);
1853 strcpy (font_allcs + (p - base_fontname), allcs);
1855 /* Build the font spec that matches all families and
1856 add-styles. */
1857 len = p - p1 + strlen (allcs) + strlen (allfamilies) + 1;
1858 font_allfamilies = alloca (len);
1859 strcpy (font_allfamilies, allfamilies);
1860 memcpy (font_allfamilies + strlen (allfamilies), p1, p - p1);
1861 strcpy (font_allfamilies + strlen (allfamilies) + (p - p1), allcs);
1863 /* Build the font spec that matches all. */
1864 len = p - p2 + strlen (allcs) + strlen (all) + strlen (allfamilies) + 1;
1865 font_all = alloca (len);
1866 z = stpcpy (font_all, allfamilies);
1867 z = stpcpy (z, all);
1868 memcpy (z, p2, p - p2);
1869 strcpy (z + (p - p2), allcs);
1871 /* Build the actual font set name. */
1872 len = strlen (base_fontname) + strlen (font_allcs)
1873 + strlen (font_allfamilies) + strlen (font_all) + 5;
1874 fontsetname = xmalloc (len);
1875 z = stpcpy (fontsetname, base_fontname);
1876 z = stpcpy (z, sep);
1877 z = stpcpy (z, font_allcs);
1878 z = stpcpy (z, sep);
1879 z = stpcpy (z, font_allfamilies);
1880 z = stpcpy (z, sep);
1881 z = stpcpy (z, font_all);
1884 if (motif)
1885 strcpy (z, ":");
1886 return fontsetname;
1888 #endif /* HAVE_X_WINDOWS && USE_X_TOOLKIT */
1890 #ifdef DEBUG_XIC_FONTSET
1891 static void
1892 print_fontset_result (XFontSet xfs, char *name, char **missing_list,
1893 int missing_count)
1895 if (xfs)
1896 fprintf (stderr, "XIC Fontset created: %s\n", name);
1897 else
1899 fprintf (stderr, "XIC Fontset failed: %s\n", name);
1900 while (missing_count-- > 0)
1902 fprintf (stderr, " missing: %s\n", *missing_list);
1903 missing_list++;
1908 #endif
1910 static XFontSet
1911 xic_create_xfontset (struct frame *f)
1913 XFontSet xfs = NULL;
1914 struct font *font = FRAME_FONT (f);
1915 int pixel_size = font->pixel_size;
1916 Lisp_Object rest, frame;
1918 /* See if there is another frame already using same fontset. */
1919 FOR_EACH_FRAME (rest, frame)
1921 struct frame *cf = XFRAME (frame);
1923 if (cf != f && FRAME_LIVE_P (f) && FRAME_X_P (cf)
1924 && FRAME_DISPLAY_INFO (cf) == FRAME_DISPLAY_INFO (f)
1925 && FRAME_FONT (f)
1926 && FRAME_FONT (f)->pixel_size == pixel_size)
1928 xfs = FRAME_XIC_FONTSET (cf);
1929 break;
1933 if (! xfs)
1935 char buf[256];
1936 char **missing_list;
1937 int missing_count;
1938 char *def_string;
1939 const char *xlfd_format = "-*-*-medium-r-normal--%d-*-*-*-*-*";
1941 sprintf (buf, xlfd_format, pixel_size);
1942 missing_list = NULL;
1943 xfs = XCreateFontSet (FRAME_X_DISPLAY (f), buf,
1944 &missing_list, &missing_count, &def_string);
1945 #ifdef DEBUG_XIC_FONTSET
1946 print_fontset_result (xfs, buf, missing_list, missing_count);
1947 #endif
1948 if (missing_list)
1949 XFreeStringList (missing_list);
1950 if (! xfs)
1952 /* List of pixel sizes most likely available. Find one that
1953 is closest to pixel_size. */
1954 int sizes[] = {0, 8, 10, 11, 12, 14, 17, 18, 20, 24, 26, 34, 0};
1955 int *smaller, *larger;
1957 for (smaller = sizes; smaller[1]; smaller++)
1958 if (smaller[1] >= pixel_size)
1959 break;
1960 larger = smaller + 1;
1961 if (*larger == pixel_size)
1962 larger++;
1963 while (*smaller || *larger)
1965 int this_size;
1967 if (! *larger)
1968 this_size = *smaller--;
1969 else if (! *smaller)
1970 this_size = *larger++;
1971 else if (pixel_size - *smaller < *larger - pixel_size)
1972 this_size = *smaller--;
1973 else
1974 this_size = *larger++;
1975 sprintf (buf, xlfd_format, this_size);
1976 missing_list = NULL;
1977 xfs = XCreateFontSet (FRAME_X_DISPLAY (f), buf,
1978 &missing_list, &missing_count, &def_string);
1979 #ifdef DEBUG_XIC_FONTSET
1980 print_fontset_result (xfs, buf, missing_list, missing_count);
1981 #endif
1982 if (missing_list)
1983 XFreeStringList (missing_list);
1984 if (xfs)
1985 break;
1988 if (! xfs)
1990 const char *last_resort = "-*-*-*-r-normal--*-*-*-*-*-*";
1992 missing_list = NULL;
1993 xfs = XCreateFontSet (FRAME_X_DISPLAY (f), last_resort,
1994 &missing_list, &missing_count, &def_string);
1995 #ifdef DEBUG_XIC_FONTSET
1996 print_fontset_result (xfs, last_resort, missing_list, missing_count);
1997 #endif
1998 if (missing_list)
1999 XFreeStringList (missing_list);
2004 return xfs;
2007 /* Free the X fontset of frame F if it is the last frame using it. */
2009 void
2010 xic_free_xfontset (struct frame *f)
2012 Lisp_Object rest, frame;
2013 bool shared_p = false;
2015 if (!FRAME_XIC_FONTSET (f))
2016 return;
2018 /* See if there is another frame sharing the same fontset. */
2019 FOR_EACH_FRAME (rest, frame)
2021 struct frame *cf = XFRAME (frame);
2022 if (cf != f && FRAME_LIVE_P (f) && FRAME_X_P (cf)
2023 && FRAME_DISPLAY_INFO (cf) == FRAME_DISPLAY_INFO (f)
2024 && FRAME_XIC_FONTSET (cf) == FRAME_XIC_FONTSET (f))
2026 shared_p = true;
2027 break;
2031 if (!shared_p)
2032 /* The fontset is not used anymore. It is safe to free it. */
2033 XFreeFontSet (FRAME_X_DISPLAY (f), FRAME_XIC_FONTSET (f));
2035 FRAME_XIC_FONTSET (f) = NULL;
2039 /* Value is the best input style, given user preferences USER (already
2040 checked to be supported by Emacs), and styles supported by the
2041 input method XIM. */
2043 static XIMStyle
2044 best_xim_style (XIMStyles *xim)
2046 int i, j;
2047 int nr_supported = ARRAYELTS (supported_xim_styles);
2049 for (i = 0; i < nr_supported; ++i)
2050 for (j = 0; j < xim->count_styles; ++j)
2051 if (supported_xim_styles[i] == xim->supported_styles[j])
2052 return supported_xim_styles[i];
2054 /* Return the default style. */
2055 return XIMPreeditNothing | XIMStatusNothing;
2058 /* Create XIC for frame F. */
2060 void
2061 create_frame_xic (struct frame *f)
2063 XIM xim;
2064 XIC xic = NULL;
2065 XFontSet xfs = NULL;
2066 XVaNestedList status_attr = NULL;
2067 XVaNestedList preedit_attr = NULL;
2068 XRectangle s_area;
2069 XPoint spot;
2070 XIMStyle xic_style;
2072 if (FRAME_XIC (f))
2073 goto out;
2075 xim = FRAME_X_XIM (f);
2076 if (!xim)
2077 goto out;
2079 /* Determine XIC style. */
2080 xic_style = best_xim_style (FRAME_X_XIM_STYLES (f));
2082 /* Create X fontset. */
2083 if (xic_style & (XIMPreeditPosition | XIMStatusArea))
2085 xfs = xic_create_xfontset (f);
2086 if (!xfs)
2087 goto out;
2089 FRAME_XIC_FONTSET (f) = xfs;
2092 if (xic_style & XIMPreeditPosition)
2094 spot.x = 0; spot.y = 1;
2095 preedit_attr = XVaCreateNestedList (0,
2096 XNFontSet, xfs,
2097 XNForeground,
2098 FRAME_FOREGROUND_PIXEL (f),
2099 XNBackground,
2100 FRAME_BACKGROUND_PIXEL (f),
2101 (xic_style & XIMPreeditPosition
2102 ? XNSpotLocation
2103 : NULL),
2104 &spot,
2105 NULL);
2107 if (!preedit_attr)
2108 goto out;
2111 if (xic_style & XIMStatusArea)
2113 s_area.x = 0; s_area.y = 0; s_area.width = 1; s_area.height = 1;
2114 status_attr = XVaCreateNestedList (0,
2115 XNArea,
2116 &s_area,
2117 XNFontSet,
2118 xfs,
2119 XNForeground,
2120 FRAME_FOREGROUND_PIXEL (f),
2121 XNBackground,
2122 FRAME_BACKGROUND_PIXEL (f),
2123 NULL);
2125 if (!status_attr)
2126 goto out;
2129 if (preedit_attr && status_attr)
2130 xic = XCreateIC (xim,
2131 XNInputStyle, xic_style,
2132 XNClientWindow, FRAME_X_WINDOW (f),
2133 XNFocusWindow, FRAME_X_WINDOW (f),
2134 XNStatusAttributes, status_attr,
2135 XNPreeditAttributes, preedit_attr,
2136 NULL);
2137 else if (preedit_attr)
2138 xic = XCreateIC (xim,
2139 XNInputStyle, xic_style,
2140 XNClientWindow, FRAME_X_WINDOW (f),
2141 XNFocusWindow, FRAME_X_WINDOW (f),
2142 XNPreeditAttributes, preedit_attr,
2143 NULL);
2144 else if (status_attr)
2145 xic = XCreateIC (xim,
2146 XNInputStyle, xic_style,
2147 XNClientWindow, FRAME_X_WINDOW (f),
2148 XNFocusWindow, FRAME_X_WINDOW (f),
2149 XNStatusAttributes, status_attr,
2150 NULL);
2151 else
2152 xic = XCreateIC (xim,
2153 XNInputStyle, xic_style,
2154 XNClientWindow, FRAME_X_WINDOW (f),
2155 XNFocusWindow, FRAME_X_WINDOW (f),
2156 NULL);
2158 if (!xic)
2159 goto out;
2161 FRAME_XIC (f) = xic;
2162 FRAME_XIC_STYLE (f) = xic_style;
2163 xfs = NULL; /* Don't free below. */
2165 out:
2167 if (xfs)
2168 free_frame_xic (f);
2170 if (preedit_attr)
2171 XFree (preedit_attr);
2173 if (status_attr)
2174 XFree (status_attr);
2178 /* Destroy XIC and free XIC fontset of frame F, if any. */
2180 void
2181 free_frame_xic (struct frame *f)
2183 if (FRAME_XIC (f) == NULL)
2184 return;
2186 XDestroyIC (FRAME_XIC (f));
2187 xic_free_xfontset (f);
2189 FRAME_XIC (f) = NULL;
2193 /* Place preedit area for XIC of window W's frame to specified
2194 pixel position X/Y. X and Y are relative to window W. */
2196 void
2197 xic_set_preeditarea (struct window *w, int x, int y)
2199 struct frame *f = XFRAME (w->frame);
2200 XVaNestedList attr;
2201 XPoint spot;
2203 spot.x = WINDOW_TO_FRAME_PIXEL_X (w, x) + WINDOW_LEFT_FRINGE_WIDTH (w);
2204 spot.y = WINDOW_TO_FRAME_PIXEL_Y (w, y) + FONT_BASE (FRAME_FONT (f));
2205 attr = XVaCreateNestedList (0, XNSpotLocation, &spot, NULL);
2206 XSetICValues (FRAME_XIC (f), XNPreeditAttributes, attr, NULL);
2207 XFree (attr);
2211 /* Place status area for XIC in bottom right corner of frame F.. */
2213 void
2214 xic_set_statusarea (struct frame *f)
2216 XIC xic = FRAME_XIC (f);
2217 XVaNestedList attr;
2218 XRectangle area;
2219 XRectangle *needed;
2221 /* Negotiate geometry of status area. If input method has existing
2222 status area, use its current size. */
2223 area.x = area.y = area.width = area.height = 0;
2224 attr = XVaCreateNestedList (0, XNAreaNeeded, &area, NULL);
2225 XSetICValues (xic, XNStatusAttributes, attr, NULL);
2226 XFree (attr);
2228 attr = XVaCreateNestedList (0, XNAreaNeeded, &needed, NULL);
2229 XGetICValues (xic, XNStatusAttributes, attr, NULL);
2230 XFree (attr);
2232 if (needed->width == 0) /* Use XNArea instead of XNAreaNeeded */
2234 attr = XVaCreateNestedList (0, XNArea, &needed, NULL);
2235 XGetICValues (xic, XNStatusAttributes, attr, NULL);
2236 XFree (attr);
2239 area.width = needed->width;
2240 area.height = needed->height;
2241 area.x = FRAME_PIXEL_WIDTH (f) - area.width - FRAME_INTERNAL_BORDER_WIDTH (f);
2242 area.y = (FRAME_PIXEL_HEIGHT (f) - area.height
2243 - FRAME_MENUBAR_HEIGHT (f)
2244 - FRAME_TOOLBAR_TOP_HEIGHT (f)
2245 - FRAME_INTERNAL_BORDER_WIDTH (f));
2246 XFree (needed);
2248 attr = XVaCreateNestedList (0, XNArea, &area, NULL);
2249 XSetICValues (xic, XNStatusAttributes, attr, NULL);
2250 XFree (attr);
2254 /* Set X fontset for XIC of frame F, using base font name
2255 BASE_FONTNAME. Called when a new Emacs fontset is chosen. */
2257 void
2258 xic_set_xfontset (struct frame *f, const char *base_fontname)
2260 XVaNestedList attr;
2261 XFontSet xfs;
2263 xic_free_xfontset (f);
2265 xfs = xic_create_xfontset (f);
2267 attr = XVaCreateNestedList (0, XNFontSet, xfs, NULL);
2268 if (FRAME_XIC_STYLE (f) & XIMPreeditPosition)
2269 XSetICValues (FRAME_XIC (f), XNPreeditAttributes, attr, NULL);
2270 if (FRAME_XIC_STYLE (f) & XIMStatusArea)
2271 XSetICValues (FRAME_XIC (f), XNStatusAttributes, attr, NULL);
2272 XFree (attr);
2274 FRAME_XIC_FONTSET (f) = xfs;
2277 #endif /* HAVE_X_I18N */
2281 #ifdef USE_X_TOOLKIT
2283 /* Create and set up the X widget for frame F. */
2285 static void
2286 x_window (struct frame *f, long window_prompting)
2288 XClassHint class_hints;
2289 XSetWindowAttributes attributes;
2290 unsigned long attribute_mask;
2291 Widget shell_widget;
2292 Widget pane_widget;
2293 Widget frame_widget;
2294 Arg al[25];
2295 int ac;
2297 block_input ();
2299 /* Use the resource name as the top-level widget name
2300 for looking up resources. Make a non-Lisp copy
2301 for the window manager, so GC relocation won't bother it.
2303 Elsewhere we specify the window name for the window manager. */
2304 f->namebuf = xlispstrdup (Vx_resource_name);
2306 ac = 0;
2307 XtSetArg (al[ac], XtNallowShellResize, 1); ac++;
2308 XtSetArg (al[ac], XtNinput, 1); ac++;
2309 XtSetArg (al[ac], XtNmappedWhenManaged, 0); ac++;
2310 XtSetArg (al[ac], XtNborderWidth, f->border_width); ac++;
2311 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2312 XtSetArg (al[ac], XtNdepth, FRAME_DISPLAY_INFO (f)->n_planes); ac++;
2313 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2314 shell_widget = XtAppCreateShell (f->namebuf, EMACS_CLASS,
2315 applicationShellWidgetClass,
2316 FRAME_X_DISPLAY (f), al, ac);
2318 f->output_data.x->widget = shell_widget;
2319 /* maybe_set_screen_title_format (shell_widget); */
2321 pane_widget = lw_create_widget ("main", "pane", widget_id_tick++,
2322 NULL, shell_widget, False,
2323 NULL, NULL, NULL, NULL);
2325 ac = 0;
2326 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2327 XtSetArg (al[ac], XtNdepth, FRAME_DISPLAY_INFO (f)->n_planes); ac++;
2328 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2329 XtSetArg (al[ac], XtNborderWidth, 0); ac++;
2330 XtSetValues (pane_widget, al, ac);
2331 f->output_data.x->column_widget = pane_widget;
2333 /* mappedWhenManaged to false tells to the paned window to not map/unmap
2334 the emacs screen when changing menubar. This reduces flickering. */
2336 ac = 0;
2337 XtSetArg (al[ac], XtNmappedWhenManaged, 0); ac++;
2338 XtSetArg (al[ac], XtNshowGrip, 0); ac++;
2339 XtSetArg (al[ac], XtNallowResize, 1); ac++;
2340 XtSetArg (al[ac], XtNresizeToPreferred, 1); ac++;
2341 XtSetArg (al[ac], XtNemacsFrame, f); ac++;
2342 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2343 XtSetArg (al[ac], XtNdepth, FRAME_DISPLAY_INFO (f)->n_planes); ac++;
2344 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2345 XtSetArg (al[ac], XtNborderWidth, 0); ac++;
2346 frame_widget = XtCreateWidget (f->namebuf, emacsFrameClass, pane_widget,
2347 al, ac);
2349 f->output_data.x->edit_widget = frame_widget;
2351 XtManageChild (frame_widget);
2353 /* Do some needed geometry management. */
2355 Arg gal[3];
2356 int gac = 0;
2357 int extra_borders = 0;
2358 int menubar_size
2359 = (f->output_data.x->menubar_widget
2360 ? (f->output_data.x->menubar_widget->core.height
2361 + f->output_data.x->menubar_widget->core.border_width)
2362 : 0);
2364 #if false /* Experimentally, we now get the right results
2365 for -geometry -0-0 without this. 24 Aug 96, rms. */
2366 if (FRAME_EXTERNAL_MENU_BAR (f))
2368 Dimension ibw = 0;
2369 XtVaGetValues (pane_widget, XtNinternalBorderWidth, &ibw, NULL);
2370 menubar_size += ibw;
2372 #endif
2374 FRAME_MENUBAR_HEIGHT (f) = menubar_size;
2376 #ifndef USE_LUCID
2377 /* Motif seems to need this amount added to the sizes
2378 specified for the shell widget. The Athena/Lucid widgets don't.
2379 Both conclusions reached experimentally. -- rms. */
2380 XtVaGetValues (f->output_data.x->edit_widget, XtNinternalBorderWidth,
2381 &extra_borders, NULL);
2382 extra_borders *= 2;
2383 #endif
2385 f->shell_position = xmalloc (sizeof "=x++" + 4 * INT_STRLEN_BOUND (int));
2387 /* Convert our geometry parameters into a geometry string
2388 and specify it.
2389 Note that we do not specify here whether the position
2390 is a user-specified or program-specified one.
2391 We pass that information later, in x_wm_set_size_hints. */
2393 int left = f->left_pos;
2394 bool xneg = (window_prompting & XNegative) != 0;
2395 int top = f->top_pos;
2396 bool yneg = (window_prompting & YNegative) != 0;
2397 if (xneg)
2398 left = -left;
2399 if (yneg)
2400 top = -top;
2402 if (window_prompting & USPosition)
2403 sprintf (f->shell_position, "=%dx%d%c%d%c%d",
2404 FRAME_PIXEL_WIDTH (f) + extra_borders,
2405 FRAME_PIXEL_HEIGHT (f) + menubar_size + extra_borders,
2406 (xneg ? '-' : '+'), left,
2407 (yneg ? '-' : '+'), top);
2408 else
2410 sprintf (f->shell_position, "=%dx%d",
2411 FRAME_PIXEL_WIDTH (f) + extra_borders,
2412 FRAME_PIXEL_HEIGHT (f) + menubar_size + extra_borders);
2414 /* Setting x and y when the position is not specified in
2415 the geometry string will set program position in the WM hints.
2416 If Emacs had just one program position, we could set it in
2417 fallback resources, but since each make-frame call can specify
2418 different program positions, this is easier. */
2419 XtSetArg (gal[gac], XtNx, left); gac++;
2420 XtSetArg (gal[gac], XtNy, top); gac++;
2424 XtSetArg (gal[gac], XtNgeometry, f->shell_position); gac++;
2425 XtSetValues (shell_widget, gal, gac);
2428 XtManageChild (pane_widget);
2429 XtRealizeWidget (shell_widget);
2431 if (FRAME_X_EMBEDDED_P (f))
2432 XReparentWindow (FRAME_X_DISPLAY (f), XtWindow (shell_widget),
2433 f->output_data.x->parent_desc, 0, 0);
2435 FRAME_X_WINDOW (f) = XtWindow (frame_widget);
2437 validate_x_resource_name ();
2439 class_hints.res_name = SSDATA (Vx_resource_name);
2440 class_hints.res_class = SSDATA (Vx_resource_class);
2441 XSetClassHint (FRAME_X_DISPLAY (f), XtWindow (shell_widget), &class_hints);
2443 #ifdef HAVE_X_I18N
2444 FRAME_XIC (f) = NULL;
2445 if (use_xim)
2446 create_frame_xic (f);
2447 #endif
2449 f->output_data.x->wm_hints.input = True;
2450 f->output_data.x->wm_hints.flags |= InputHint;
2451 XSetWMHints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2452 &f->output_data.x->wm_hints);
2454 hack_wm_protocols (f, shell_widget);
2456 #ifdef HACK_EDITRES
2457 XtAddEventHandler (shell_widget, 0, True, _XEditResCheckMessages, 0);
2458 #endif
2460 /* Do a stupid property change to force the server to generate a
2461 PropertyNotify event so that the event_stream server timestamp will
2462 be initialized to something relevant to the time we created the window.
2464 XChangeProperty (XtDisplay (frame_widget), XtWindow (frame_widget),
2465 FRAME_DISPLAY_INFO (f)->Xatom_wm_protocols,
2466 XA_ATOM, 32, PropModeAppend, NULL, 0);
2468 /* Make all the standard events reach the Emacs frame. */
2469 attributes.event_mask = STANDARD_EVENT_SET;
2471 #ifdef HAVE_X_I18N
2472 if (FRAME_XIC (f))
2474 /* XIM server might require some X events. */
2475 unsigned long fevent = NoEventMask;
2476 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2477 attributes.event_mask |= fevent;
2479 #endif /* HAVE_X_I18N */
2481 attribute_mask = CWEventMask;
2482 XChangeWindowAttributes (XtDisplay (shell_widget), XtWindow (shell_widget),
2483 attribute_mask, &attributes);
2485 XtMapWidget (frame_widget);
2487 /* x_set_name normally ignores requests to set the name if the
2488 requested name is the same as the current name. This is the one
2489 place where that assumption isn't correct; f->name is set, but
2490 the X server hasn't been told. */
2492 Lisp_Object name;
2493 bool explicit = f->explicit_name;
2495 f->explicit_name = false;
2496 name = f->name;
2497 fset_name (f, Qnil);
2498 x_set_name (f, name, explicit);
2501 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2502 f->output_data.x->current_cursor
2503 = f->output_data.x->text_cursor);
2505 unblock_input ();
2507 /* This is a no-op, except under Motif. Make sure main areas are
2508 set to something reasonable, in case we get an error later. */
2509 lw_set_main_areas (pane_widget, 0, frame_widget);
2512 #else /* not USE_X_TOOLKIT */
2513 #ifdef USE_GTK
2514 static void
2515 x_window (struct frame *f)
2517 if (! xg_create_frame_widgets (f))
2518 error ("Unable to create window");
2520 #ifdef HAVE_X_I18N
2521 FRAME_XIC (f) = NULL;
2522 if (use_xim)
2524 block_input ();
2525 create_frame_xic (f);
2526 if (FRAME_XIC (f))
2528 /* XIM server might require some X events. */
2529 unsigned long fevent = NoEventMask;
2530 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2532 if (fevent != NoEventMask)
2534 XSetWindowAttributes attributes;
2535 XWindowAttributes wattr;
2536 unsigned long attribute_mask;
2538 XGetWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2539 &wattr);
2540 attributes.event_mask = wattr.your_event_mask | fevent;
2541 attribute_mask = CWEventMask;
2542 XChangeWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2543 attribute_mask, &attributes);
2546 unblock_input ();
2548 #endif
2551 #else /*! USE_GTK */
2552 /* Create and set up the X window for frame F. */
2554 static void
2555 x_window (struct frame *f)
2557 XClassHint class_hints;
2558 XSetWindowAttributes attributes;
2559 unsigned long attribute_mask;
2561 attributes.background_pixel = FRAME_BACKGROUND_PIXEL (f);
2562 attributes.border_pixel = f->output_data.x->border_pixel;
2563 attributes.bit_gravity = StaticGravity;
2564 attributes.backing_store = NotUseful;
2565 attributes.save_under = True;
2566 attributes.event_mask = STANDARD_EVENT_SET;
2567 attributes.colormap = FRAME_X_COLORMAP (f);
2568 attribute_mask = (CWBackPixel | CWBorderPixel | CWBitGravity | CWEventMask
2569 | CWColormap);
2571 block_input ();
2572 FRAME_X_WINDOW (f)
2573 = XCreateWindow (FRAME_X_DISPLAY (f),
2574 f->output_data.x->parent_desc,
2575 f->left_pos,
2576 f->top_pos,
2577 FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f),
2578 f->border_width,
2579 CopyFromParent, /* depth */
2580 InputOutput, /* class */
2581 FRAME_X_VISUAL (f),
2582 attribute_mask, &attributes);
2584 #ifdef HAVE_X_I18N
2585 if (use_xim)
2587 create_frame_xic (f);
2588 if (FRAME_XIC (f))
2590 /* XIM server might require some X events. */
2591 unsigned long fevent = NoEventMask;
2592 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2593 attributes.event_mask |= fevent;
2594 attribute_mask = CWEventMask;
2595 XChangeWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2596 attribute_mask, &attributes);
2599 #endif /* HAVE_X_I18N */
2601 validate_x_resource_name ();
2603 class_hints.res_name = SSDATA (Vx_resource_name);
2604 class_hints.res_class = SSDATA (Vx_resource_class);
2605 XSetClassHint (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), &class_hints);
2607 /* This indicates that we use the "Passive Input" input model.
2608 Unless we do this, we don't get the Focus{In,Out} events that we
2609 need to draw the cursor correctly. Accursed bureaucrats.
2610 XWhipsAndChains (FRAME_X_DISPLAY (f), IronMaiden, &TheRack); */
2612 f->output_data.x->wm_hints.input = True;
2613 f->output_data.x->wm_hints.flags |= InputHint;
2614 XSetWMHints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2615 &f->output_data.x->wm_hints);
2616 f->output_data.x->wm_hints.icon_pixmap = None;
2618 /* Request "save yourself" and "delete window" commands from wm. */
2620 Atom protocols[2];
2621 protocols[0] = FRAME_DISPLAY_INFO (f)->Xatom_wm_delete_window;
2622 protocols[1] = FRAME_DISPLAY_INFO (f)->Xatom_wm_save_yourself;
2623 XSetWMProtocols (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), protocols, 2);
2626 /* x_set_name normally ignores requests to set the name if the
2627 requested name is the same as the current name. This is the one
2628 place where that assumption isn't correct; f->name is set, but
2629 the X server hasn't been told. */
2631 Lisp_Object name;
2632 bool explicit = f->explicit_name;
2634 f->explicit_name = false;
2635 name = f->name;
2636 fset_name (f, Qnil);
2637 x_set_name (f, name, explicit);
2640 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2641 f->output_data.x->current_cursor
2642 = f->output_data.x->text_cursor);
2644 unblock_input ();
2646 if (FRAME_X_WINDOW (f) == 0)
2647 error ("Unable to create window");
2650 #endif /* not USE_GTK */
2651 #endif /* not USE_X_TOOLKIT */
2653 /* Verify that the icon position args for this window are valid. */
2655 static void
2656 x_icon_verify (struct frame *f, Lisp_Object parms)
2658 Lisp_Object icon_x, icon_y;
2660 /* Set the position of the icon. Note that twm groups all
2661 icons in an icon window. */
2662 icon_x = x_frame_get_and_record_arg (f, parms, Qicon_left, 0, 0, RES_TYPE_NUMBER);
2663 icon_y = x_frame_get_and_record_arg (f, parms, Qicon_top, 0, 0, RES_TYPE_NUMBER);
2664 if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
2666 CHECK_NUMBER (icon_x);
2667 CHECK_NUMBER (icon_y);
2669 else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
2670 error ("Both left and top icon corners of icon must be specified");
2673 /* Handle the icon stuff for this window. Perhaps later we might
2674 want an x_set_icon_position which can be called interactively as
2675 well. */
2677 static void
2678 x_icon (struct frame *f, Lisp_Object parms)
2680 /* Set the position of the icon. Note that twm groups all
2681 icons in an icon window. */
2682 Lisp_Object icon_x
2683 = x_frame_get_and_record_arg (f, parms, Qicon_left, 0, 0, RES_TYPE_NUMBER);
2684 Lisp_Object icon_y
2685 = x_frame_get_and_record_arg (f, parms, Qicon_top, 0, 0, RES_TYPE_NUMBER);
2686 if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
2688 CHECK_TYPE_RANGED_INTEGER (int, icon_x);
2689 CHECK_TYPE_RANGED_INTEGER (int, icon_y);
2691 else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
2692 error ("Both left and top icon corners of icon must be specified");
2694 block_input ();
2696 if (! EQ (icon_x, Qunbound))
2697 x_wm_set_icon_position (f, XINT (icon_x), XINT (icon_y));
2699 #if false /* x_get_arg removes the visibility parameter as a side effect,
2700 but x_create_frame still needs it. */
2701 /* Start up iconic or window? */
2702 struct x_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
2703 x_wm_set_window_state
2704 (f, (EQ (x_get_arg (dpyinfo, parms, Qvisibility, 0, 0, RES_TYPE_SYMBOL),
2705 Qicon)
2706 ? IconicState
2707 : NormalState));
2708 #endif
2710 x_text_icon (f, SSDATA ((!NILP (f->icon_name)
2711 ? f->icon_name
2712 : f->name)));
2714 unblock_input ();
2717 /* Make the GCs needed for this window, setting the
2718 background, border and mouse colors; also create the
2719 mouse cursor and the gray border tile. */
2721 static void
2722 x_make_gc (struct frame *f)
2724 XGCValues gc_values;
2726 block_input ();
2728 /* Create the GCs of this frame.
2729 Note that many default values are used. */
2731 gc_values.foreground = FRAME_FOREGROUND_PIXEL (f);
2732 gc_values.background = FRAME_BACKGROUND_PIXEL (f);
2733 gc_values.line_width = 0; /* Means 1 using fast algorithm. */
2734 f->output_data.x->normal_gc
2735 = XCreateGC (FRAME_X_DISPLAY (f),
2736 FRAME_X_WINDOW (f),
2737 GCLineWidth | GCForeground | GCBackground,
2738 &gc_values);
2740 /* Reverse video style. */
2741 gc_values.foreground = FRAME_BACKGROUND_PIXEL (f);
2742 gc_values.background = FRAME_FOREGROUND_PIXEL (f);
2743 f->output_data.x->reverse_gc
2744 = XCreateGC (FRAME_X_DISPLAY (f),
2745 FRAME_X_WINDOW (f),
2746 GCForeground | GCBackground | GCLineWidth,
2747 &gc_values);
2749 /* Cursor has cursor-color background, background-color foreground. */
2750 gc_values.foreground = FRAME_BACKGROUND_PIXEL (f);
2751 gc_values.background = f->output_data.x->cursor_pixel;
2752 gc_values.fill_style = FillOpaqueStippled;
2753 f->output_data.x->cursor_gc
2754 = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2755 (GCForeground | GCBackground
2756 | GCFillStyle | GCLineWidth),
2757 &gc_values);
2759 /* Create the gray border tile used when the pointer is not in
2760 the frame. Since this depends on the frame's pixel values,
2761 this must be done on a per-frame basis. */
2762 f->output_data.x->border_tile
2763 = (XCreatePixmapFromBitmapData
2764 (FRAME_X_DISPLAY (f), FRAME_DISPLAY_INFO (f)->root_window,
2765 gray_bits, gray_width, gray_height,
2766 FRAME_FOREGROUND_PIXEL (f),
2767 FRAME_BACKGROUND_PIXEL (f),
2768 DefaultDepth (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f))));
2770 unblock_input ();
2774 /* Free what was allocated in x_make_gc. */
2776 void
2777 x_free_gcs (struct frame *f)
2779 Display *dpy = FRAME_X_DISPLAY (f);
2781 block_input ();
2783 if (f->output_data.x->normal_gc)
2785 XFreeGC (dpy, f->output_data.x->normal_gc);
2786 f->output_data.x->normal_gc = 0;
2789 if (f->output_data.x->reverse_gc)
2791 XFreeGC (dpy, f->output_data.x->reverse_gc);
2792 f->output_data.x->reverse_gc = 0;
2795 if (f->output_data.x->cursor_gc)
2797 XFreeGC (dpy, f->output_data.x->cursor_gc);
2798 f->output_data.x->cursor_gc = 0;
2801 if (f->output_data.x->border_tile)
2803 XFreePixmap (dpy, f->output_data.x->border_tile);
2804 f->output_data.x->border_tile = 0;
2807 unblock_input ();
2811 /* Handler for signals raised during x_create_frame and
2812 x_create_tip_frame. FRAME is the frame which is partially
2813 constructed. */
2815 static Lisp_Object
2816 unwind_create_frame (Lisp_Object frame)
2818 struct frame *f = XFRAME (frame);
2820 /* If frame is already dead, nothing to do. This can happen if the
2821 display is disconnected after the frame has become official, but
2822 before x_create_frame removes the unwind protect. */
2823 if (!FRAME_LIVE_P (f))
2824 return Qnil;
2826 /* If frame is ``official'', nothing to do. */
2827 if (NILP (Fmemq (frame, Vframe_list)))
2829 #if defined GLYPH_DEBUG && defined ENABLE_CHECKING
2830 struct x_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
2831 #endif
2833 x_free_frame_resources (f);
2834 free_glyphs (f);
2836 #if defined GLYPH_DEBUG && defined ENABLE_CHECKING
2837 /* Check that reference counts are indeed correct. */
2838 eassert (dpyinfo->reference_count == dpyinfo_refcount);
2839 eassert (dpyinfo->terminal->image_cache->refcount == image_cache_refcount);
2840 #endif
2841 return Qt;
2844 return Qnil;
2847 static void
2848 do_unwind_create_frame (Lisp_Object frame)
2850 unwind_create_frame (frame);
2853 static void
2854 x_default_font_parameter (struct frame *f, Lisp_Object parms)
2856 struct x_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
2857 Lisp_Object font_param = x_get_arg (dpyinfo, parms, Qfont, NULL, NULL,
2858 RES_TYPE_STRING);
2859 Lisp_Object font = Qnil;
2860 if (EQ (font_param, Qunbound))
2861 font_param = Qnil;
2863 if (NILP (font_param))
2865 /* System font should take precedence over X resources. We suggest this
2866 regardless of font-use-system-font because .emacs may not have been
2867 read yet. */
2868 const char *system_font = xsettings_get_system_font ();
2869 if (system_font)
2870 font = font_open_by_name (f, build_unibyte_string (system_font));
2873 if (NILP (font))
2874 font = !NILP (font_param) ? font_param
2875 : x_get_arg (dpyinfo, parms, Qfont, "font", "Font", RES_TYPE_STRING);
2877 if (! FONTP (font) && ! STRINGP (font))
2879 const char *names[]
2881 #ifdef HAVE_XFT
2882 /* This will find the normal Xft font. */
2883 "monospace-10",
2884 #endif
2885 "-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1",
2886 "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1",
2887 "-*-*-medium-r-normal-*-*-140-*-*-c-*-iso8859-1",
2888 /* This was formerly the first thing tried, but it finds
2889 too many fonts and takes too long. */
2890 "-*-*-medium-r-*-*-*-*-*-*-c-*-iso8859-1",
2891 /* If those didn't work, look for something which will
2892 at least work. */
2893 "-*-fixed-*-*-*-*-*-140-*-*-c-*-iso8859-1",
2894 "fixed",
2895 NULL };
2896 int i;
2898 for (i = 0; names[i]; i++)
2900 font = font_open_by_name (f, build_unibyte_string (names[i]));
2901 if (! NILP (font))
2902 break;
2904 if (NILP (font))
2905 error ("No suitable font was found");
2907 else if (!NILP (font_param))
2909 /* Remember the explicit font parameter, so we can re-apply it after
2910 we've applied the `default' face settings. */
2911 AUTO_FRAME_ARG (arg, Qfont_param, font_param);
2912 x_set_frame_parameters (f, arg);
2915 /* This call will make X resources override any system font setting. */
2916 x_default_parameter (f, parms, Qfont, font, "font", "Font", RES_TYPE_STRING);
2920 DEFUN ("x-wm-set-size-hint", Fx_wm_set_size_hint, Sx_wm_set_size_hint,
2921 0, 1, 0,
2922 doc: /* Send the size hints for frame FRAME to the window manager.
2923 If FRAME is omitted or nil, use the selected frame.
2924 Signal error if FRAME is not an X frame. */)
2925 (Lisp_Object frame)
2927 struct frame *f = decode_window_system_frame (frame);
2929 block_input ();
2930 x_wm_set_size_hint (f, 0, false);
2931 unblock_input ();
2932 return Qnil;
2935 static void
2936 set_machine_and_pid_properties (struct frame *f)
2938 /* This will set WM_CLIENT_MACHINE and WM_LOCALE_NAME. */
2939 XSetWMProperties (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), NULL, NULL,
2940 NULL, 0, NULL, NULL, NULL);
2941 pid_t pid = getpid ();
2942 if (pid <= 0xffffffffu)
2944 unsigned long xpid = pid;
2945 XChangeProperty (FRAME_X_DISPLAY (f),
2946 FRAME_OUTER_WINDOW (f),
2947 XInternAtom (FRAME_X_DISPLAY (f),
2948 "_NET_WM_PID",
2949 False),
2950 XA_CARDINAL, 32, PropModeReplace,
2951 (unsigned char *) &xpid, 1);
2955 DEFUN ("x-create-frame", Fx_create_frame, Sx_create_frame,
2956 1, 1, 0,
2957 doc: /* Make a new X window, which is called a "frame" in Emacs terms.
2958 Return an Emacs frame object. PARMS is an alist of frame parameters.
2959 If the parameters specify that the frame should not have a minibuffer,
2960 and do not specify a specific minibuffer window to use, then
2961 `default-minibuffer-frame' must be a frame whose minibuffer can be
2962 shared by the new frame.
2964 This function is an internal primitive--use `make-frame' instead. */)
2965 (Lisp_Object parms)
2967 struct frame *f;
2968 Lisp_Object frame, tem;
2969 Lisp_Object name;
2970 bool minibuffer_only = false;
2971 long window_prompting = 0;
2972 ptrdiff_t count = SPECPDL_INDEX ();
2973 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
2974 Lisp_Object display;
2975 struct x_display_info *dpyinfo = NULL;
2976 Lisp_Object parent;
2977 struct kboard *kb;
2979 parms = Fcopy_alist (parms);
2981 /* Use this general default value to start with
2982 until we know if this frame has a specified name. */
2983 Vx_resource_name = Vinvocation_name;
2985 display = x_get_arg (dpyinfo, parms, Qterminal, 0, 0, RES_TYPE_NUMBER);
2986 if (EQ (display, Qunbound))
2987 display = x_get_arg (dpyinfo, parms, Qdisplay, 0, 0, RES_TYPE_STRING);
2988 if (EQ (display, Qunbound))
2989 display = Qnil;
2990 dpyinfo = check_x_display_info (display);
2991 kb = dpyinfo->terminal->kboard;
2993 if (!dpyinfo->terminal->name)
2994 error ("Terminal is not live, can't create new frames on it");
2996 name = x_get_arg (dpyinfo, parms, Qname, "name", "Name", RES_TYPE_STRING);
2997 if (!STRINGP (name)
2998 && ! EQ (name, Qunbound)
2999 && ! NILP (name))
3000 error ("Invalid frame name--not a string or nil");
3002 if (STRINGP (name))
3003 Vx_resource_name = name;
3005 /* See if parent window is specified. */
3006 parent = x_get_arg (dpyinfo, parms, Qparent_id, NULL, NULL, RES_TYPE_NUMBER);
3007 if (EQ (parent, Qunbound))
3008 parent = Qnil;
3009 if (! NILP (parent))
3010 CHECK_NUMBER (parent);
3012 /* make_frame_without_minibuffer can run Lisp code and garbage collect. */
3013 /* No need to protect DISPLAY because that's not used after passing
3014 it to make_frame_without_minibuffer. */
3015 frame = Qnil;
3016 GCPRO4 (parms, parent, name, frame);
3017 tem = x_get_arg (dpyinfo, parms, Qminibuffer, "minibuffer", "Minibuffer",
3018 RES_TYPE_SYMBOL);
3019 if (EQ (tem, Qnone) || NILP (tem))
3020 f = make_frame_without_minibuffer (Qnil, kb, display);
3021 else if (EQ (tem, Qonly))
3023 f = make_minibuffer_frame ();
3024 minibuffer_only = true;
3026 else if (WINDOWP (tem))
3027 f = make_frame_without_minibuffer (tem, kb, display);
3028 else
3029 f = make_frame (true);
3031 XSETFRAME (frame, f);
3033 f->terminal = dpyinfo->terminal;
3035 f->output_method = output_x_window;
3036 f->output_data.x = xzalloc (sizeof *f->output_data.x);
3037 f->output_data.x->icon_bitmap = -1;
3038 FRAME_FONTSET (f) = -1;
3039 f->output_data.x->scroll_bar_foreground_pixel = -1;
3040 f->output_data.x->scroll_bar_background_pixel = -1;
3041 #if defined (USE_LUCID) && defined (USE_TOOLKIT_SCROLL_BARS)
3042 f->output_data.x->scroll_bar_top_shadow_pixel = -1;
3043 f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
3044 #endif /* USE_LUCID && USE_TOOLKIT_SCROLL_BARS */
3045 f->output_data.x->white_relief.pixel = -1;
3046 f->output_data.x->black_relief.pixel = -1;
3048 fset_icon_name (f,
3049 x_get_arg (dpyinfo, parms, Qicon_name, "iconName", "Title",
3050 RES_TYPE_STRING));
3051 if (! STRINGP (f->icon_name))
3052 fset_icon_name (f, Qnil);
3054 FRAME_DISPLAY_INFO (f) = dpyinfo;
3056 /* With FRAME_DISPLAY_INFO set up, this unwind-protect is safe. */
3057 record_unwind_protect (do_unwind_create_frame, frame);
3059 /* These colors will be set anyway later, but it's important
3060 to get the color reference counts right, so initialize them! */
3062 Lisp_Object black;
3063 struct gcpro gcpro1;
3065 /* Function x_decode_color can signal an error. Make
3066 sure to initialize color slots so that we won't try
3067 to free colors we haven't allocated. */
3068 FRAME_FOREGROUND_PIXEL (f) = -1;
3069 FRAME_BACKGROUND_PIXEL (f) = -1;
3070 f->output_data.x->cursor_pixel = -1;
3071 f->output_data.x->cursor_foreground_pixel = -1;
3072 f->output_data.x->border_pixel = -1;
3073 f->output_data.x->mouse_pixel = -1;
3075 black = build_string ("black");
3076 GCPRO1 (black);
3077 FRAME_FOREGROUND_PIXEL (f)
3078 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3079 FRAME_BACKGROUND_PIXEL (f)
3080 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3081 f->output_data.x->cursor_pixel
3082 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3083 f->output_data.x->cursor_foreground_pixel
3084 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3085 f->output_data.x->border_pixel
3086 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3087 f->output_data.x->mouse_pixel
3088 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3089 UNGCPRO;
3092 /* Specify the parent under which to make this X window. */
3093 if (!NILP (parent))
3095 f->output_data.x->parent_desc = (Window) XFASTINT (parent);
3096 f->output_data.x->explicit_parent = true;
3098 else
3100 f->output_data.x->parent_desc = FRAME_DISPLAY_INFO (f)->root_window;
3101 f->output_data.x->explicit_parent = false;
3104 /* Set the name; the functions to which we pass f expect the name to
3105 be set. */
3106 if (EQ (name, Qunbound) || NILP (name))
3108 fset_name (f, build_string (dpyinfo->x_id_name));
3109 f->explicit_name = false;
3111 else
3113 fset_name (f, name);
3114 f->explicit_name = true;
3115 /* Use the frame's title when getting resources for this frame. */
3116 specbind (Qx_resource_name, name);
3119 #ifdef HAVE_FREETYPE
3120 #ifdef HAVE_XFT
3121 register_font_driver (&xftfont_driver, f);
3122 #else /* not HAVE_XFT */
3123 register_font_driver (&ftxfont_driver, f);
3124 #endif /* not HAVE_XFT */
3125 #endif /* HAVE_FREETYPE */
3126 register_font_driver (&xfont_driver, f);
3128 x_default_parameter (f, parms, Qfont_backend, Qnil,
3129 "fontBackend", "FontBackend", RES_TYPE_STRING);
3131 /* Extract the window parameters from the supplied values
3132 that are needed to determine window geometry. */
3133 x_default_font_parameter (f, parms);
3134 if (!FRAME_FONT (f))
3136 delete_frame (frame, Qnoelisp);
3137 error ("Invalid frame font");
3140 /* Frame contents get displaced if an embedded X window has a border. */
3141 if (! FRAME_X_EMBEDDED_P (f))
3142 x_default_parameter (f, parms, Qborder_width, make_number (0),
3143 "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
3145 /* This defaults to 1 in order to match xterm. We recognize either
3146 internalBorderWidth or internalBorder (which is what xterm calls
3147 it). */
3148 if (NILP (Fassq (Qinternal_border_width, parms)))
3150 Lisp_Object value;
3152 value = x_get_arg (dpyinfo, parms, Qinternal_border_width,
3153 "internalBorder", "internalBorder", RES_TYPE_NUMBER);
3154 if (! EQ (value, Qunbound))
3155 parms = Fcons (Fcons (Qinternal_border_width, value),
3156 parms);
3158 x_default_parameter (f, parms, Qinternal_border_width,
3159 #ifdef USE_GTK /* We used to impose 0 in xg_create_frame_widgets. */
3160 make_number (0),
3161 #else
3162 make_number (1),
3163 #endif
3164 "internalBorderWidth", "internalBorderWidth",
3165 RES_TYPE_NUMBER);
3166 x_default_parameter (f, parms, Qright_divider_width, make_number (0),
3167 NULL, NULL, RES_TYPE_NUMBER);
3168 x_default_parameter (f, parms, Qbottom_divider_width, make_number (0),
3169 NULL, NULL, RES_TYPE_NUMBER);
3170 x_default_parameter (f, parms, Qvertical_scroll_bars,
3171 #if defined (USE_GTK) && defined (USE_TOOLKIT_SCROLL_BARS)
3172 Qright,
3173 #else
3174 Qleft,
3175 #endif
3176 "verticalScrollBars", "ScrollBars",
3177 RES_TYPE_SYMBOL);
3178 x_default_parameter (f, parms, Qhorizontal_scroll_bars, Qnil,
3179 "horizontalScrollBars", "ScrollBars",
3180 RES_TYPE_SYMBOL);
3181 /* Also do the stuff which must be set before the window exists. */
3182 x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
3183 "foreground", "Foreground", RES_TYPE_STRING);
3184 x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
3185 "background", "Background", RES_TYPE_STRING);
3186 x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
3187 "pointerColor", "Foreground", RES_TYPE_STRING);
3188 x_default_parameter (f, parms, Qborder_color, build_string ("black"),
3189 "borderColor", "BorderColor", RES_TYPE_STRING);
3190 x_default_parameter (f, parms, Qscreen_gamma, Qnil,
3191 "screenGamma", "ScreenGamma", RES_TYPE_FLOAT);
3192 x_default_parameter (f, parms, Qline_spacing, Qnil,
3193 "lineSpacing", "LineSpacing", RES_TYPE_NUMBER);
3194 x_default_parameter (f, parms, Qleft_fringe, Qnil,
3195 "leftFringe", "LeftFringe", RES_TYPE_NUMBER);
3196 x_default_parameter (f, parms, Qright_fringe, Qnil,
3197 "rightFringe", "RightFringe", RES_TYPE_NUMBER);
3199 x_default_scroll_bar_color_parameter (f, parms, Qscroll_bar_foreground,
3200 "scrollBarForeground",
3201 "ScrollBarForeground", true);
3202 x_default_scroll_bar_color_parameter (f, parms, Qscroll_bar_background,
3203 "scrollBarBackground",
3204 "ScrollBarBackground", false);
3206 #ifdef GLYPH_DEBUG
3207 image_cache_refcount =
3208 FRAME_IMAGE_CACHE (f) ? FRAME_IMAGE_CACHE (f)->refcount : 0;
3209 dpyinfo_refcount = dpyinfo->reference_count;
3210 #endif /* GLYPH_DEBUG */
3212 /* Init faces before x_default_parameter is called for the
3213 scroll-bar-width parameter because otherwise we end up in
3214 init_iterator with a null face cache, which should not happen. */
3215 init_frame_faces (f);
3217 /* The following call of change_frame_size is needed since otherwise
3218 x_set_tool_bar_lines will already work with the character sizes
3219 installed by init_frame_faces while the frame's pixel size is
3220 still calculated from a character size of 1 and we subsequently
3221 hit the (height >= 0) assertion in window_box_height.
3223 The non-pixelwise code apparently worked around this because it
3224 had one frame line vs one toolbar line which left us with a zero
3225 root window height which was obviously wrong as well ... */
3226 adjust_frame_size (f, FRAME_COLS (f) * FRAME_COLUMN_WIDTH (f),
3227 FRAME_LINES (f) * FRAME_LINE_HEIGHT (f), 5, true,
3228 Qx_create_frame_1);
3230 /* Set the menu-bar-lines and tool-bar-lines parameters. We don't
3231 look up the X resources controlling the menu-bar and tool-bar
3232 here; they are processed specially at startup, and reflected in
3233 the values of the mode variables. */
3235 x_default_parameter (f, parms, Qmenu_bar_lines,
3236 NILP (Vmenu_bar_mode)
3237 ? make_number (0) : make_number (1),
3238 NULL, NULL, RES_TYPE_NUMBER);
3239 x_default_parameter (f, parms, Qtool_bar_lines,
3240 NILP (Vtool_bar_mode)
3241 ? make_number (0) : make_number (1),
3242 NULL, NULL, RES_TYPE_NUMBER);
3244 x_default_parameter (f, parms, Qbuffer_predicate, Qnil,
3245 "bufferPredicate", "BufferPredicate",
3246 RES_TYPE_SYMBOL);
3247 x_default_parameter (f, parms, Qtitle, Qnil,
3248 "title", "Title", RES_TYPE_STRING);
3249 x_default_parameter (f, parms, Qwait_for_wm, Qt,
3250 "waitForWM", "WaitForWM", RES_TYPE_BOOLEAN);
3251 x_default_parameter (f, parms, Qtool_bar_position,
3252 FRAME_TOOL_BAR_POSITION (f), 0, 0, RES_TYPE_SYMBOL);
3254 /* Compute the size of the X window. */
3255 window_prompting = x_figure_window_size (f, parms, true);
3257 tem = x_get_arg (dpyinfo, parms, Qunsplittable, 0, 0, RES_TYPE_BOOLEAN);
3258 f->no_split = minibuffer_only || EQ (tem, Qt);
3260 x_icon_verify (f, parms);
3262 /* Create the X widget or window. */
3263 #ifdef USE_X_TOOLKIT
3264 x_window (f, window_prompting);
3265 #else
3266 x_window (f);
3267 #endif
3269 x_icon (f, parms);
3270 x_make_gc (f);
3272 /* Now consider the frame official. */
3273 f->terminal->reference_count++;
3274 FRAME_DISPLAY_INFO (f)->reference_count++;
3275 Vframe_list = Fcons (frame, Vframe_list);
3277 /* We need to do this after creating the X window, so that the
3278 icon-creation functions can say whose icon they're describing. */
3279 x_default_parameter (f, parms, Qicon_type, Qt,
3280 "bitmapIcon", "BitmapIcon", RES_TYPE_BOOLEAN);
3282 x_default_parameter (f, parms, Qauto_raise, Qnil,
3283 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
3284 x_default_parameter (f, parms, Qauto_lower, Qnil,
3285 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
3286 x_default_parameter (f, parms, Qcursor_type, Qbox,
3287 "cursorType", "CursorType", RES_TYPE_SYMBOL);
3288 x_default_parameter (f, parms, Qscroll_bar_width, Qnil,
3289 "scrollBarWidth", "ScrollBarWidth",
3290 RES_TYPE_NUMBER);
3291 x_default_parameter (f, parms, Qscroll_bar_height, Qnil,
3292 "scrollBarHeight", "ScrollBarHeight",
3293 RES_TYPE_NUMBER);
3294 x_default_parameter (f, parms, Qalpha, Qnil,
3295 "alpha", "Alpha", RES_TYPE_NUMBER);
3297 /* Consider frame official, now. */
3298 f->can_x_set_window_size = true;
3300 adjust_frame_size (f, FRAME_TEXT_WIDTH (f), FRAME_TEXT_HEIGHT (f), 0, true,
3301 Qx_create_frame_2);
3303 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
3304 /* Create the menu bar. */
3305 if (!minibuffer_only && FRAME_EXTERNAL_MENU_BAR (f))
3307 /* If this signals an error, we haven't set size hints for the
3308 frame and we didn't make it visible. */
3309 initialize_frame_menubar (f);
3311 #ifndef USE_GTK
3312 /* This is a no-op, except under Motif where it arranges the
3313 main window for the widgets on it. */
3314 lw_set_main_areas (f->output_data.x->column_widget,
3315 f->output_data.x->menubar_widget,
3316 f->output_data.x->edit_widget);
3317 #endif /* not USE_GTK */
3319 #endif /* USE_X_TOOLKIT || USE_GTK */
3321 /* Tell the server what size and position, etc, we want, and how
3322 badly we want them. This should be done after we have the menu
3323 bar so that its size can be taken into account. */
3324 block_input ();
3325 x_wm_set_size_hint (f, window_prompting, false);
3326 unblock_input ();
3328 /* Process fullscreen parameter here in the hope that normalizing a
3329 fullheight/fullwidth frame will produce the size set by the last
3330 adjust_frame_size call. */
3331 x_default_parameter (f, parms, Qfullscreen, Qnil,
3332 "fullscreen", "Fullscreen", RES_TYPE_SYMBOL);
3334 /* Make the window appear on the frame and enable display, unless
3335 the caller says not to. However, with explicit parent, Emacs
3336 cannot control visibility, so don't try. */
3337 if (! f->output_data.x->explicit_parent)
3339 Lisp_Object visibility;
3341 visibility = x_get_arg (dpyinfo, parms, Qvisibility, 0, 0,
3342 RES_TYPE_SYMBOL);
3343 if (EQ (visibility, Qunbound))
3344 visibility = Qt;
3346 if (EQ (visibility, Qicon))
3347 x_iconify_frame (f);
3348 else if (! NILP (visibility))
3349 x_make_frame_visible (f);
3350 else
3352 /* Must have been Qnil. */
3356 block_input ();
3358 /* Set machine name and pid for the purpose of window managers. */
3359 set_machine_and_pid_properties (f);
3361 /* Set the WM leader property. GTK does this itself, so this is not
3362 needed when using GTK. */
3363 if (dpyinfo->client_leader_window != 0)
3365 XChangeProperty (FRAME_X_DISPLAY (f),
3366 FRAME_OUTER_WINDOW (f),
3367 dpyinfo->Xatom_wm_client_leader,
3368 XA_WINDOW, 32, PropModeReplace,
3369 (unsigned char *) &dpyinfo->client_leader_window, 1);
3372 unblock_input ();
3374 /* Initialize `default-minibuffer-frame' in case this is the first
3375 frame on this terminal. */
3376 if (FRAME_HAS_MINIBUF_P (f)
3377 && (!FRAMEP (KVAR (kb, Vdefault_minibuffer_frame))
3378 || !FRAME_LIVE_P (XFRAME (KVAR (kb, Vdefault_minibuffer_frame)))))
3379 kset_default_minibuffer_frame (kb, frame);
3381 /* All remaining specified parameters, which have not been "used"
3382 by x_get_arg and friends, now go in the misc. alist of the frame. */
3383 for (tem = parms; CONSP (tem); tem = XCDR (tem))
3384 if (CONSP (XCAR (tem)) && !NILP (XCAR (XCAR (tem))))
3385 fset_param_alist (f, Fcons (XCAR (tem), f->param_alist));
3387 UNGCPRO;
3389 /* Make sure windows on this frame appear in calls to next-window
3390 and similar functions. */
3391 Vwindow_list = Qnil;
3393 return unbind_to (count, frame);
3397 /* FRAME is used only to get a handle on the X display. We don't pass the
3398 display info directly because we're called from frame.c, which doesn't
3399 know about that structure. */
3401 Lisp_Object
3402 x_get_focus_frame (struct frame *frame)
3404 struct x_display_info *dpyinfo = FRAME_DISPLAY_INFO (frame);
3405 Lisp_Object xfocus;
3406 if (! dpyinfo->x_focus_frame)
3407 return Qnil;
3409 XSETFRAME (xfocus, dpyinfo->x_focus_frame);
3410 return xfocus;
3414 /* In certain situations, when the window manager follows a
3415 click-to-focus policy, there seems to be no way around calling
3416 XSetInputFocus to give another frame the input focus .
3418 In an ideal world, XSetInputFocus should generally be avoided so
3419 that applications don't interfere with the window manager's focus
3420 policy. But I think it's okay to use when it's clearly done
3421 following a user-command. */
3423 void
3424 x_focus_frame (struct frame *f)
3426 Display *dpy = FRAME_X_DISPLAY (f);
3428 block_input ();
3429 x_catch_errors (dpy);
3431 if (FRAME_X_EMBEDDED_P (f))
3433 /* For Xembedded frames, normally the embedder forwards key
3434 events. See XEmbed Protocol Specification at
3435 http://freedesktop.org/wiki/Specifications/xembed-spec */
3436 xembed_request_focus (f);
3438 else
3440 XSetInputFocus (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3441 RevertToParent, CurrentTime);
3442 x_ewmh_activate_frame (f);
3445 x_uncatch_errors ();
3446 unblock_input ();
3450 DEFUN ("xw-color-defined-p", Fxw_color_defined_p, Sxw_color_defined_p, 1, 2, 0,
3451 doc: /* Internal function called by `color-defined-p', which see
3452 .\(Note that the Nextstep version of this function ignores FRAME.) */)
3453 (Lisp_Object color, Lisp_Object frame)
3455 XColor foo;
3456 struct frame *f = decode_window_system_frame (frame);
3458 CHECK_STRING (color);
3460 if (x_defined_color (f, SSDATA (color), &foo, false))
3461 return Qt;
3462 else
3463 return Qnil;
3466 DEFUN ("xw-color-values", Fxw_color_values, Sxw_color_values, 1, 2, 0,
3467 doc: /* Internal function called by `color-values', which see. */)
3468 (Lisp_Object color, Lisp_Object frame)
3470 XColor foo;
3471 struct frame *f = decode_window_system_frame (frame);
3473 CHECK_STRING (color);
3475 if (x_defined_color (f, SSDATA (color), &foo, false))
3476 return list3i (foo.red, foo.green, foo.blue);
3477 else
3478 return Qnil;
3481 DEFUN ("xw-display-color-p", Fxw_display_color_p, Sxw_display_color_p, 0, 1, 0,
3482 doc: /* Internal function called by `display-color-p', which see. */)
3483 (Lisp_Object terminal)
3485 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3487 if (dpyinfo->n_planes <= 2)
3488 return Qnil;
3490 switch (dpyinfo->visual->class)
3492 case StaticColor:
3493 case PseudoColor:
3494 case TrueColor:
3495 case DirectColor:
3496 return Qt;
3498 default:
3499 return Qnil;
3503 DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p, Sx_display_grayscale_p,
3504 0, 1, 0,
3505 doc: /* Return t if the X display supports shades of gray.
3506 Note that color displays do support shades of gray.
3507 The optional argument TERMINAL specifies which display to ask about.
3508 TERMINAL should be a terminal object, a frame or a display name (a string).
3509 If omitted or nil, that stands for the selected frame's display. */)
3510 (Lisp_Object terminal)
3512 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3514 if (dpyinfo->n_planes <= 1)
3515 return Qnil;
3517 switch (dpyinfo->visual->class)
3519 case StaticColor:
3520 case PseudoColor:
3521 case TrueColor:
3522 case DirectColor:
3523 case StaticGray:
3524 case GrayScale:
3525 return Qt;
3527 default:
3528 return Qnil;
3532 DEFUN ("x-display-pixel-width", Fx_display_pixel_width, Sx_display_pixel_width,
3533 0, 1, 0,
3534 doc: /* Return the width in pixels of the X display TERMINAL.
3535 The optional argument TERMINAL specifies which display to ask about.
3536 TERMINAL should be a terminal object, a frame or a display name (a string).
3537 If omitted or nil, that stands for the selected frame's display.
3539 On \"multi-monitor\" setups this refers to the pixel width for all
3540 physical monitors associated with TERMINAL. To get information for
3541 each physical monitor, use `display-monitor-attributes-list'. */)
3542 (Lisp_Object terminal)
3544 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3546 return make_number (x_display_pixel_width (dpyinfo));
3549 DEFUN ("x-display-pixel-height", Fx_display_pixel_height,
3550 Sx_display_pixel_height, 0, 1, 0,
3551 doc: /* Return the height in pixels of the X display TERMINAL.
3552 The optional argument TERMINAL specifies which display to ask about.
3553 TERMINAL should be a terminal object, a frame or a display name (a string).
3554 If omitted or nil, that stands for the selected frame's display.
3556 On \"multi-monitor\" setups this refers to the pixel height for all
3557 physical monitors associated with TERMINAL. To get information for
3558 each physical monitor, use `display-monitor-attributes-list'. */)
3559 (Lisp_Object terminal)
3561 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3563 return make_number (x_display_pixel_height (dpyinfo));
3566 DEFUN ("x-display-planes", Fx_display_planes, Sx_display_planes,
3567 0, 1, 0,
3568 doc: /* Return the number of bitplanes of the X display TERMINAL.
3569 The optional argument TERMINAL specifies which display to ask about.
3570 TERMINAL should be a terminal object, a frame or a display name (a string).
3571 If omitted or nil, that stands for the selected frame's display. */)
3572 (Lisp_Object terminal)
3574 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3576 return make_number (dpyinfo->n_planes);
3579 DEFUN ("x-display-color-cells", Fx_display_color_cells, Sx_display_color_cells,
3580 0, 1, 0,
3581 doc: /* Return the number of color cells of the X display TERMINAL.
3582 The optional argument TERMINAL specifies which display to ask about.
3583 TERMINAL should be a terminal object, a frame or a display name (a string).
3584 If omitted or nil, that stands for the selected frame's display. */)
3585 (Lisp_Object terminal)
3587 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3589 int nr_planes = DisplayPlanes (dpyinfo->display,
3590 XScreenNumberOfScreen (dpyinfo->screen));
3592 /* Truncate nr_planes to 24 to avoid integer overflow.
3593 Some displays says 32, but only 24 bits are actually significant.
3594 There are only very few and rare video cards that have more than
3595 24 significant bits. Also 24 bits is more than 16 million colors,
3596 it "should be enough for everyone". */
3597 if (nr_planes > 24) nr_planes = 24;
3599 return make_number (1 << nr_planes);
3602 DEFUN ("x-server-max-request-size", Fx_server_max_request_size,
3603 Sx_server_max_request_size,
3604 0, 1, 0,
3605 doc: /* Return the maximum request size of the X server of display TERMINAL.
3606 The optional argument TERMINAL specifies which display to ask about.
3607 TERMINAL should be a terminal object, a frame or a display name (a string).
3608 If omitted or nil, that stands for the selected frame's display. */)
3609 (Lisp_Object terminal)
3611 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3613 return make_number (MAXREQUEST (dpyinfo->display));
3616 DEFUN ("x-server-vendor", Fx_server_vendor, Sx_server_vendor, 0, 1, 0,
3617 doc: /* Return the "vendor ID" string of the GUI software on TERMINAL.
3619 \(Labeling every distributor as a "vendor" embodies the false assumption
3620 that operating systems cannot be developed and distributed noncommercially.)
3621 The optional argument TERMINAL specifies which display to ask about.
3623 For GNU and Unix systems, this queries the X server software; for
3624 MS-Windows, this queries the OS.
3626 TERMINAL should be a terminal object, a frame or a display name (a string).
3627 If omitted or nil, that stands for the selected frame's display. */)
3628 (Lisp_Object terminal)
3630 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3631 const char *vendor = ServerVendor (dpyinfo->display);
3633 if (! vendor) vendor = "";
3634 return build_string (vendor);
3637 DEFUN ("x-server-version", Fx_server_version, Sx_server_version, 0, 1, 0,
3638 doc: /* Return the version numbers of the GUI software on TERMINAL.
3639 The value is a list of three integers specifying the version of the GUI
3640 software in use.
3642 For GNU and Unix system, the first 2 numbers are the version of the X
3643 Protocol used on TERMINAL and the 3rd number is the distributor-specific
3644 release number. For MS-Windows, the 3 numbers report the version and
3645 the build number of the OS.
3647 See also the function `x-server-vendor'.
3649 The optional argument TERMINAL specifies which display to ask about.
3650 TERMINAL should be a terminal object, a frame or a display name (a string).
3651 If omitted or nil, that stands for the selected frame's display. */)
3652 (Lisp_Object terminal)
3654 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3655 Display *dpy = dpyinfo->display;
3657 return list3i (ProtocolVersion (dpy), ProtocolRevision (dpy),
3658 VendorRelease (dpy));
3661 DEFUN ("x-display-screens", Fx_display_screens, Sx_display_screens, 0, 1, 0,
3662 doc: /* Return the number of screens on the X server of display TERMINAL.
3663 The optional argument TERMINAL specifies which display to ask about.
3664 TERMINAL should be a terminal object, a frame or a display name (a string).
3665 If omitted or nil, that stands for the selected frame's display. */)
3666 (Lisp_Object terminal)
3668 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3670 return make_number (ScreenCount (dpyinfo->display));
3673 DEFUN ("x-display-mm-height", Fx_display_mm_height, Sx_display_mm_height, 0, 1, 0,
3674 doc: /* Return the height in millimeters of the X display TERMINAL.
3675 The optional argument TERMINAL specifies which display to ask about.
3676 TERMINAL should be a terminal object, a frame or a display name (a string).
3677 If omitted or nil, that stands for the selected frame's display.
3679 On \"multi-monitor\" setups this refers to the height in millimeters for
3680 all physical monitors associated with TERMINAL. To get information
3681 for each physical monitor, use `display-monitor-attributes-list'. */)
3682 (Lisp_Object terminal)
3684 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3686 return make_number (HeightMMOfScreen (dpyinfo->screen));
3689 DEFUN ("x-display-mm-width", Fx_display_mm_width, Sx_display_mm_width, 0, 1, 0,
3690 doc: /* Return the width in millimeters of the X display TERMINAL.
3691 The optional argument TERMINAL specifies which display to ask about.
3692 TERMINAL should be a terminal object, a frame or a display name (a string).
3693 If omitted or nil, that stands for the selected frame's display.
3695 On \"multi-monitor\" setups this refers to the width in millimeters for
3696 all physical monitors associated with TERMINAL. To get information
3697 for each physical monitor, use `display-monitor-attributes-list'. */)
3698 (Lisp_Object terminal)
3700 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3702 return make_number (WidthMMOfScreen (dpyinfo->screen));
3705 DEFUN ("x-display-backing-store", Fx_display_backing_store,
3706 Sx_display_backing_store, 0, 1, 0,
3707 doc: /* Return an indication of whether X display TERMINAL does backing store.
3708 The value may be `always', `when-mapped', or `not-useful'.
3709 The optional argument TERMINAL specifies which display to ask about.
3710 TERMINAL should be a terminal object, a frame or a display name (a string).
3711 If omitted or nil, that stands for the selected frame's display. */)
3712 (Lisp_Object terminal)
3714 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3715 Lisp_Object result;
3717 switch (DoesBackingStore (dpyinfo->screen))
3719 case Always:
3720 result = intern ("always");
3721 break;
3723 case WhenMapped:
3724 result = intern ("when-mapped");
3725 break;
3727 case NotUseful:
3728 result = intern ("not-useful");
3729 break;
3731 default:
3732 error ("Strange value for BackingStore parameter of screen");
3735 return result;
3738 DEFUN ("x-display-visual-class", Fx_display_visual_class,
3739 Sx_display_visual_class, 0, 1, 0,
3740 doc: /* Return the visual class of the X display TERMINAL.
3741 The value is one of the symbols `static-gray', `gray-scale',
3742 `static-color', `pseudo-color', `true-color', or `direct-color'.
3744 The optional argument TERMINAL specifies which display to ask about.
3745 TERMINAL should a terminal object, a frame or a display name (a string).
3746 If omitted or nil, that stands for the selected frame's display. */)
3747 (Lisp_Object terminal)
3749 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3750 Lisp_Object result;
3752 switch (dpyinfo->visual->class)
3754 case StaticGray:
3755 result = intern ("static-gray");
3756 break;
3757 case GrayScale:
3758 result = intern ("gray-scale");
3759 break;
3760 case StaticColor:
3761 result = intern ("static-color");
3762 break;
3763 case PseudoColor:
3764 result = intern ("pseudo-color");
3765 break;
3766 case TrueColor:
3767 result = intern ("true-color");
3768 break;
3769 case DirectColor:
3770 result = intern ("direct-color");
3771 break;
3772 default:
3773 error ("Display has an unknown visual class");
3776 return result;
3779 DEFUN ("x-display-save-under", Fx_display_save_under,
3780 Sx_display_save_under, 0, 1, 0,
3781 doc: /* Return t if the X display TERMINAL supports the save-under feature.
3782 The optional argument TERMINAL specifies which display to ask about.
3783 TERMINAL should be a terminal object, a frame or a display name (a string).
3784 If omitted or nil, that stands for the selected frame's display. */)
3785 (Lisp_Object terminal)
3787 struct x_display_info *dpyinfo = check_x_display_info (terminal);
3789 if (DoesSaveUnders (dpyinfo->screen) == True)
3790 return Qt;
3791 else
3792 return Qnil;
3795 /* Store the geometry of the workarea on display DPYINFO into *RECT.
3796 Return false if and only if the workarea information cannot be
3797 obtained via the _NET_WORKAREA root window property. */
3799 #if ! GTK_CHECK_VERSION (3, 4, 0)
3800 static bool
3801 x_get_net_workarea (struct x_display_info *dpyinfo, XRectangle *rect)
3803 Display *dpy = dpyinfo->display;
3804 long offset, max_len;
3805 Atom target_type, actual_type;
3806 unsigned long actual_size, bytes_remaining;
3807 int rc, actual_format;
3808 unsigned char *tmp_data = NULL;
3809 bool result = false;
3811 x_catch_errors (dpy);
3812 offset = 0;
3813 max_len = 1;
3814 target_type = XA_CARDINAL;
3815 rc = XGetWindowProperty (dpy, dpyinfo->root_window,
3816 dpyinfo->Xatom_net_current_desktop,
3817 offset, max_len, False, target_type,
3818 &actual_type, &actual_format, &actual_size,
3819 &bytes_remaining, &tmp_data);
3820 if (rc == Success && actual_type == target_type && !x_had_errors_p (dpy)
3821 && actual_format == 32 && actual_size == max_len)
3823 long current_desktop = ((long *) tmp_data)[0];
3825 XFree (tmp_data);
3826 tmp_data = NULL;
3828 offset = 4 * current_desktop;
3829 max_len = 4;
3830 rc = XGetWindowProperty (dpy, dpyinfo->root_window,
3831 dpyinfo->Xatom_net_workarea,
3832 offset, max_len, False, target_type,
3833 &actual_type, &actual_format, &actual_size,
3834 &bytes_remaining, &tmp_data);
3835 if (rc == Success && actual_type == target_type && !x_had_errors_p (dpy)
3836 && actual_format == 32 && actual_size == max_len)
3838 long *values = (long *) tmp_data;
3840 rect->x = values[0];
3841 rect->y = values[1];
3842 rect->width = values[2];
3843 rect->height = values[3];
3845 XFree (tmp_data);
3846 tmp_data = NULL;
3848 result = true;
3851 if (tmp_data)
3852 XFree (tmp_data);
3853 x_uncatch_errors ();
3855 return result;
3857 #endif
3859 #ifndef USE_GTK
3861 /* Return monitor number where F is "most" or closest to. */
3862 static int
3863 x_get_monitor_for_frame (struct frame *f,
3864 struct MonitorInfo *monitors,
3865 int n_monitors)
3867 XRectangle frect;
3868 int area = 0, dist = -1;
3869 int best_area = -1, best_dist = -1;
3870 int i;
3872 if (n_monitors == 1) return 0;
3873 frect.x = f->left_pos;
3874 frect.y = f->top_pos;
3875 frect.width = FRAME_PIXEL_WIDTH (f);
3876 frect.height = FRAME_PIXEL_HEIGHT (f);
3878 for (i = 0; i < n_monitors; ++i)
3880 struct MonitorInfo *mi = &monitors[i];
3881 XRectangle res;
3882 int a = 0;
3884 if (mi->geom.width == 0) continue;
3886 if (x_intersect_rectangles (&mi->geom, &frect, &res))
3888 a = res.width * res.height;
3889 if (a > area)
3891 area = a;
3892 best_area = i;
3896 if (a == 0 && area == 0)
3898 int dx, dy, d;
3899 if (frect.x + frect.width < mi->geom.x)
3900 dx = mi->geom.x - frect.x + frect.width;
3901 else if (frect.x > mi->geom.x + mi->geom.width)
3902 dx = frect.x - mi->geom.x + mi->geom.width;
3903 else
3904 dx = 0;
3905 if (frect.y + frect.height < mi->geom.y)
3906 dy = mi->geom.y - frect.y + frect.height;
3907 else if (frect.y > mi->geom.y + mi->geom.height)
3908 dy = frect.y - mi->geom.y + mi->geom.height;
3909 else
3910 dy = 0;
3912 d = dx*dx + dy*dy;
3913 if (dist == -1 || dist > d)
3915 dist = d;
3916 best_dist = i;
3921 return best_area != -1 ? best_area : (best_dist != -1 ? best_dist : 0);
3924 static Lisp_Object
3925 x_make_monitor_attribute_list (struct MonitorInfo *monitors,
3926 int n_monitors,
3927 int primary_monitor,
3928 struct x_display_info *dpyinfo,
3929 const char *source)
3931 Lisp_Object monitor_frames = Fmake_vector (make_number (n_monitors), Qnil);
3932 Lisp_Object frame, rest;
3934 FOR_EACH_FRAME (rest, frame)
3936 struct frame *f = XFRAME (frame);
3938 if (FRAME_X_P (f) && FRAME_DISPLAY_INFO (f) == dpyinfo
3939 && !EQ (frame, tip_frame))
3941 int i = x_get_monitor_for_frame (f, monitors, n_monitors);
3942 ASET (monitor_frames, i, Fcons (frame, AREF (monitor_frames, i)));
3946 return make_monitor_attribute_list (monitors, n_monitors, primary_monitor,
3947 monitor_frames, source);
3950 static Lisp_Object
3951 x_get_monitor_attributes_fallback (struct x_display_info *dpyinfo)
3953 struct MonitorInfo monitor;
3954 XRectangle workarea_r;
3956 /* Fallback: treat (possibly) multiple physical monitors as if they
3957 formed a single monitor as a whole. This should provide a
3958 consistent result at least on single monitor environments. */
3959 monitor.geom.x = monitor.geom.y = 0;
3960 monitor.geom.width = x_display_pixel_width (dpyinfo);
3961 monitor.geom.height = x_display_pixel_height (dpyinfo);
3962 monitor.mm_width = WidthMMOfScreen (dpyinfo->screen);
3963 monitor.mm_height = HeightMMOfScreen (dpyinfo->screen);
3964 monitor.name = xstrdup ("combined screen");
3966 if (x_get_net_workarea (dpyinfo, &workarea_r))
3967 monitor.work = workarea_r;
3968 else
3969 monitor.work = monitor.geom;
3970 return x_make_monitor_attribute_list (&monitor, 1, 0, dpyinfo, "fallback");
3974 #ifdef HAVE_XINERAMA
3975 static Lisp_Object
3976 x_get_monitor_attributes_xinerama (struct x_display_info *dpyinfo)
3978 int n_monitors, i;
3979 Lisp_Object attributes_list = Qnil;
3980 Display *dpy = dpyinfo->display;
3981 XineramaScreenInfo *info = XineramaQueryScreens (dpy, &n_monitors);
3982 struct MonitorInfo *monitors;
3983 double mm_width_per_pixel, mm_height_per_pixel;
3985 if (! info || n_monitors == 0)
3987 if (info)
3988 XFree (info);
3989 return attributes_list;
3992 mm_width_per_pixel = ((double) WidthMMOfScreen (dpyinfo->screen)
3993 / x_display_pixel_width (dpyinfo));
3994 mm_height_per_pixel = ((double) HeightMMOfScreen (dpyinfo->screen)
3995 / x_display_pixel_height (dpyinfo));
3996 monitors = xzalloc (n_monitors * sizeof *monitors);
3997 for (i = 0; i < n_monitors; ++i)
3999 struct MonitorInfo *mi = &monitors[i];
4000 XRectangle workarea_r;
4002 mi->geom.x = info[i].x_org;
4003 mi->geom.y = info[i].y_org;
4004 mi->geom.width = info[i].width;
4005 mi->geom.height = info[i].height;
4006 mi->mm_width = mi->geom.width * mm_width_per_pixel + 0.5;
4007 mi->mm_height = mi->geom.height * mm_height_per_pixel + 0.5;
4008 mi->name = 0;
4010 /* Xinerama usually have primary monitor first, just use that. */
4011 if (i == 0 && x_get_net_workarea (dpyinfo, &workarea_r))
4013 mi->work = workarea_r;
4014 if (! x_intersect_rectangles (&mi->geom, &mi->work, &mi->work))
4015 mi->work = mi->geom;
4017 else
4018 mi->work = mi->geom;
4020 XFree (info);
4022 attributes_list = x_make_monitor_attribute_list (monitors,
4023 n_monitors,
4025 dpyinfo,
4026 "Xinerama");
4027 free_monitors (monitors, n_monitors);
4028 return attributes_list;
4030 #endif /* HAVE_XINERAMA */
4033 #ifdef HAVE_XRANDR
4034 static Lisp_Object
4035 x_get_monitor_attributes_xrandr (struct x_display_info *dpyinfo)
4037 Lisp_Object attributes_list = Qnil;
4038 XRRScreenResources *resources;
4039 Display *dpy = dpyinfo->display;
4040 int i, n_monitors, primary = -1;
4041 RROutput pxid = None;
4042 struct MonitorInfo *monitors;
4044 #ifdef HAVE_XRRGETSCREENRESOURCESCURRENT
4045 resources = XRRGetScreenResourcesCurrent (dpy, dpyinfo->root_window);
4046 #else
4047 resources = XRRGetScreenResources (dpy, dpyinfo->root_window);
4048 #endif
4049 if (! resources || resources->noutput == 0)
4051 if (resources)
4052 XRRFreeScreenResources (resources);
4053 return Qnil;
4055 n_monitors = resources->noutput;
4056 monitors = xzalloc (n_monitors * sizeof *monitors);
4058 #ifdef HAVE_XRRGETOUTPUTPRIMARY
4059 pxid = XRRGetOutputPrimary (dpy, dpyinfo->root_window);
4060 #endif
4062 for (i = 0; i < n_monitors; ++i)
4064 XRROutputInfo *info = XRRGetOutputInfo (dpy, resources,
4065 resources->outputs[i]);
4066 Connection conn = info ? info->connection : RR_Disconnected;
4067 RRCrtc id = info ? info->crtc : None;
4069 if (strcmp (info->name, "default") == 0)
4071 /* Non XRandr 1.2 driver, does not give useful data. */
4072 XRRFreeOutputInfo (info);
4073 XRRFreeScreenResources (resources);
4074 free_monitors (monitors, n_monitors);
4075 return Qnil;
4078 if (conn != RR_Disconnected && id != None)
4080 XRRCrtcInfo *crtc = XRRGetCrtcInfo (dpy, resources, id);
4081 struct MonitorInfo *mi = &monitors[i];
4082 XRectangle workarea_r;
4084 if (! crtc)
4086 XRRFreeOutputInfo (info);
4087 continue;
4090 mi->geom.x = crtc->x;
4091 mi->geom.y = crtc->y;
4092 mi->geom.width = crtc->width;
4093 mi->geom.height = crtc->height;
4094 mi->mm_width = info->mm_width;
4095 mi->mm_height = info->mm_height;
4096 mi->name = xstrdup (info->name);
4098 if (pxid != None && pxid == resources->outputs[i])
4099 primary = i;
4100 else if (primary == -1 && strcmp (info->name, "LVDS") == 0)
4101 primary = i;
4103 if (i == primary && x_get_net_workarea (dpyinfo, &workarea_r))
4105 mi->work= workarea_r;
4106 if (! x_intersect_rectangles (&mi->geom, &mi->work, &mi->work))
4107 mi->work = mi->geom;
4109 else
4110 mi->work = mi->geom;
4112 XRRFreeCrtcInfo (crtc);
4114 XRRFreeOutputInfo (info);
4116 XRRFreeScreenResources (resources);
4118 attributes_list = x_make_monitor_attribute_list (monitors,
4119 n_monitors,
4120 primary,
4121 dpyinfo,
4122 "XRandr");
4123 free_monitors (monitors, n_monitors);
4124 return attributes_list;
4126 #endif /* HAVE_XRANDR */
4128 static Lisp_Object
4129 x_get_monitor_attributes (struct x_display_info *dpyinfo)
4131 Lisp_Object attributes_list = Qnil;
4132 Display *dpy = dpyinfo->display;
4134 (void) dpy; /* Suppress unused variable warning. */
4136 #ifdef HAVE_XRANDR
4137 int xrr_event_base, xrr_error_base;
4138 bool xrr_ok = false;
4139 xrr_ok = XRRQueryExtension (dpy, &xrr_event_base, &xrr_error_base);
4140 if (xrr_ok)
4142 int xrr_major, xrr_minor;
4143 XRRQueryVersion (dpy, &xrr_major, &xrr_minor);
4144 xrr_ok = (xrr_major == 1 && xrr_minor >= 2) || xrr_major > 1;
4147 if (xrr_ok)
4148 attributes_list = x_get_monitor_attributes_xrandr (dpyinfo);
4149 #endif /* HAVE_XRANDR */
4151 #ifdef HAVE_XINERAMA
4152 if (NILP (attributes_list))
4154 int xin_event_base, xin_error_base;
4155 bool xin_ok = false;
4156 xin_ok = XineramaQueryExtension (dpy, &xin_event_base, &xin_error_base);
4157 if (xin_ok && XineramaIsActive (dpy))
4158 attributes_list = x_get_monitor_attributes_xinerama (dpyinfo);
4160 #endif /* HAVE_XINERAMA */
4162 if (NILP (attributes_list))
4163 attributes_list = x_get_monitor_attributes_fallback (dpyinfo);
4165 return attributes_list;
4168 #endif /* !USE_GTK */
4170 DEFUN ("x-display-monitor-attributes-list", Fx_display_monitor_attributes_list,
4171 Sx_display_monitor_attributes_list,
4172 0, 1, 0,
4173 doc: /* Return a list of physical monitor attributes on the X display TERMINAL.
4175 The optional argument TERMINAL specifies which display to ask about.
4176 TERMINAL should be a terminal object, a frame or a display name (a string).
4177 If omitted or nil, that stands for the selected frame's display.
4179 In addition to the standard attribute keys listed in
4180 `display-monitor-attributes-list', the following keys are contained in
4181 the attributes:
4183 source -- String describing the source from which multi-monitor
4184 information is obtained, one of \"Gdk\", \"XRandr\",
4185 \"Xinerama\", or \"fallback\"
4187 Internal use only, use `display-monitor-attributes-list' instead. */)
4188 (Lisp_Object terminal)
4190 struct x_display_info *dpyinfo = check_x_display_info (terminal);
4191 Lisp_Object attributes_list = Qnil;
4193 #ifdef USE_GTK
4194 double mm_width_per_pixel, mm_height_per_pixel;
4195 GdkDisplay *gdpy;
4196 GdkScreen *gscreen;
4197 gint primary_monitor = 0, n_monitors, i;
4198 Lisp_Object monitor_frames, rest, frame;
4199 static const char *source = "Gdk";
4200 struct MonitorInfo *monitors;
4202 block_input ();
4203 mm_width_per_pixel = ((double) WidthMMOfScreen (dpyinfo->screen)
4204 / x_display_pixel_width (dpyinfo));
4205 mm_height_per_pixel = ((double) HeightMMOfScreen (dpyinfo->screen)
4206 / x_display_pixel_height (dpyinfo));
4207 gdpy = gdk_x11_lookup_xdisplay (dpyinfo->display);
4208 gscreen = gdk_display_get_default_screen (gdpy);
4209 #if GTK_CHECK_VERSION (2, 20, 0)
4210 primary_monitor = gdk_screen_get_primary_monitor (gscreen);
4211 #endif
4212 n_monitors = gdk_screen_get_n_monitors (gscreen);
4213 monitor_frames = Fmake_vector (make_number (n_monitors), Qnil);
4214 monitors = xzalloc (n_monitors * sizeof *monitors);
4216 FOR_EACH_FRAME (rest, frame)
4218 struct frame *f = XFRAME (frame);
4220 if (FRAME_X_P (f) && FRAME_DISPLAY_INFO (f) == dpyinfo
4221 && !EQ (frame, tip_frame))
4223 GdkWindow *gwin = gtk_widget_get_window (FRAME_GTK_WIDGET (f));
4225 i = gdk_screen_get_monitor_at_window (gscreen, gwin);
4226 ASET (monitor_frames, i, Fcons (frame, AREF (monitor_frames, i)));
4230 for (i = 0; i < n_monitors; ++i)
4232 gint width_mm = -1, height_mm = -1;
4233 GdkRectangle rec, work;
4234 struct MonitorInfo *mi = &monitors[i];
4236 gdk_screen_get_monitor_geometry (gscreen, i, &rec);
4238 #if GTK_CHECK_VERSION (2, 14, 0)
4239 width_mm = gdk_screen_get_monitor_width_mm (gscreen, i);
4240 height_mm = gdk_screen_get_monitor_height_mm (gscreen, i);
4241 #endif
4242 if (width_mm < 0)
4243 width_mm = rec.width * mm_width_per_pixel + 0.5;
4244 if (height_mm < 0)
4245 height_mm = rec.height * mm_height_per_pixel + 0.5;
4247 #if GTK_CHECK_VERSION (3, 4, 0)
4248 gdk_screen_get_monitor_workarea (gscreen, i, &work);
4249 #else
4250 /* Emulate the behavior of GTK+ 3.4. */
4252 XRectangle workarea_r;
4254 if (i == primary_monitor && x_get_net_workarea (dpyinfo, &workarea_r))
4256 work.x = workarea_r.x;
4257 work.y = workarea_r.y;
4258 work.width = workarea_r.width;
4259 work.height = workarea_r.height;
4260 if (! gdk_rectangle_intersect (&rec, &work, &work))
4261 work = rec;
4263 else
4264 work = rec;
4266 #endif
4269 mi->geom.x = rec.x;
4270 mi->geom.y = rec.y;
4271 mi->geom.width = rec.width;
4272 mi->geom.height = rec.height;
4273 mi->work.x = work.x;
4274 mi->work.y = work.y;
4275 mi->work.width = work.width;
4276 mi->work.height = work.height;
4277 mi->mm_width = width_mm;
4278 mi->mm_height = height_mm;
4280 #if GTK_CHECK_VERSION (2, 14, 0)
4281 mi->name = gdk_screen_get_monitor_plug_name (gscreen, i);
4282 #endif
4285 attributes_list = make_monitor_attribute_list (monitors,
4286 n_monitors,
4287 primary_monitor,
4288 monitor_frames,
4289 source);
4290 unblock_input ();
4291 #else /* not USE_GTK */
4293 block_input ();
4294 attributes_list = x_get_monitor_attributes (dpyinfo);
4295 unblock_input ();
4297 #endif /* not USE_GTK */
4299 return attributes_list;
4302 DEFUN ("x-frame-geometry", Fx_frame_geometry, Sx_frame_geometry, 0, 1, 0,
4303 doc: /* Return geometric attributes of frame FRAME.
4305 FRAME must be a live frame and defaults to the selected one.
4307 The return value is an association list containing the following
4308 elements (all size values are in pixels).
4310 - `frame-outer-size' is a cons of the outer width and height of FRAME.
4311 The outer size include the title bar and the external borders as well
4312 as any menu and/or tool bar of frame.
4314 - `border' is a cons of the horizontal and vertical width of FRAME's
4315 external borders.
4317 - `title-bar-height' is the height of the title bar of FRAME.
4319 - `menu-bar-external' if `t' means the menu bar is external (not
4320 included in the inner edges of FRAME).
4322 - `menu-bar-size' is a cons of the width and height of the menu bar of
4323 FRAME.
4325 - `tool-bar-external' if `t' means the tool bar is external (not
4326 included in the inner edges of FRAME).
4328 - `tool-bar-side' tells tells on which side the tool bar on FRAME is and
4329 can be one of `left', `top', `right' or `bottom'.
4331 - `tool-bar-size' is a cons of the width and height of the tool bar of
4332 FRAME.
4334 - `frame-inner-size' is a cons of the inner width and height of FRAME.
4335 This excludes FRAME's title bar and external border as well as any
4336 external menu and/or tool bar. */)
4337 (Lisp_Object frame)
4339 struct frame *f = decode_live_frame (frame);
4340 int inner_width = FRAME_PIXEL_WIDTH (f);
4341 int inner_height = FRAME_PIXEL_HEIGHT (f);
4342 int outer_width, outer_height, border, title;
4343 Lisp_Object fullscreen = Fframe_parameter (frame, Qfullscreen);
4344 int menu_bar_height, menu_bar_width, tool_bar_height, tool_bar_width;
4346 int left_off, right_off, top_off, bottom_off, outer_border;
4347 XWindowAttributes atts;
4349 block_input ();
4351 XGetWindowAttributes (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &atts);
4353 x_real_pos_and_offsets (f, &left_off, &right_off, &top_off, &bottom_off,
4354 NULL, NULL, NULL, NULL, &outer_border);
4357 unblock_input ();
4359 border = atts.border_width;
4360 title = top_off;
4362 outer_width = atts.width + 2 * border + right_off + left_off
4363 + 2 * outer_border;
4364 outer_height = atts.height + 2 * border + top_off + bottom_off
4365 + 2 * outer_border;
4367 #if defined (USE_GTK)
4369 bool tool_bar_left_right = (EQ (FRAME_TOOL_BAR_POSITION (f), Qleft)
4370 || EQ (FRAME_TOOL_BAR_POSITION (f), Qright));
4372 tool_bar_width = (tool_bar_left_right
4373 ? FRAME_TOOLBAR_WIDTH (f)
4374 : FRAME_PIXEL_WIDTH (f));
4375 tool_bar_height = (tool_bar_left_right
4376 ? FRAME_PIXEL_HEIGHT (f)
4377 : FRAME_TOOLBAR_HEIGHT (f));
4379 #else
4380 tool_bar_height = FRAME_TOOL_BAR_HEIGHT (f);
4381 tool_bar_width = tool_bar_height > 0 ? FRAME_PIXEL_WIDTH (f) : 0;
4382 #endif
4384 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
4385 menu_bar_height = FRAME_MENUBAR_HEIGHT (f);
4386 #else
4387 menu_bar_height = FRAME_MENU_BAR_HEIGHT (f);
4388 #endif
4390 menu_bar_width = menu_bar_height > 0 ? FRAME_PIXEL_WIDTH (f) : 0;
4392 if (!FRAME_EXTERNAL_MENU_BAR (f))
4393 inner_height -= menu_bar_height;
4394 if (!FRAME_EXTERNAL_TOOL_BAR (f))
4395 inner_height -= tool_bar_height;
4397 return
4398 listn (CONSTYPE_HEAP, 10,
4399 Fcons (Qframe_position,
4400 Fcons (make_number (f->left_pos), make_number (f->top_pos))),
4401 Fcons (Qframe_outer_size,
4402 Fcons (make_number (outer_width), make_number (outer_height))),
4403 Fcons (Qexternal_border_size,
4404 ((EQ (fullscreen, Qfullboth) || EQ (fullscreen, Qfullscreen))
4405 ? Fcons (make_number (0), make_number (0))
4406 : Fcons (make_number (border), make_number (border)))),
4407 Fcons (Qtitle_height,
4408 ((EQ (fullscreen, Qfullboth) || EQ (fullscreen, Qfullscreen))
4409 ? make_number (0)
4410 : make_number (title))),
4411 Fcons (Qmenu_bar_external, FRAME_EXTERNAL_MENU_BAR (f) ? Qt : Qnil),
4412 Fcons (Qmenu_bar_size,
4413 Fcons (make_number (menu_bar_width),
4414 make_number (menu_bar_height))),
4415 Fcons (Qtool_bar_external, FRAME_EXTERNAL_TOOL_BAR (f) ? Qt : Qnil),
4416 Fcons (Qtool_bar_position, FRAME_TOOL_BAR_POSITION (f)),
4417 Fcons (Qtool_bar_size,
4418 Fcons (make_number (tool_bar_width),
4419 make_number (tool_bar_height))),
4420 Fcons (Qframe_inner_size,
4421 Fcons (make_number (inner_width),
4422 make_number (inner_height))));
4425 /************************************************************************
4426 X Displays
4427 ************************************************************************/
4430 /* Mapping visual names to visuals. */
4432 static struct visual_class
4434 const char *name;
4435 int class;
4437 visual_classes[] =
4439 {"StaticGray", StaticGray},
4440 {"GrayScale", GrayScale},
4441 {"StaticColor", StaticColor},
4442 {"PseudoColor", PseudoColor},
4443 {"TrueColor", TrueColor},
4444 {"DirectColor", DirectColor},
4445 {NULL, 0}
4449 #ifndef HAVE_XSCREENNUMBEROFSCREEN
4451 /* Value is the screen number of screen SCR. This is a substitute for
4452 the X function with the same name when that doesn't exist. */
4455 XScreenNumberOfScreen (scr)
4456 register Screen *scr;
4458 Display *dpy = scr->display;
4459 int i;
4461 for (i = 0; i < dpy->nscreens; ++i)
4462 if (scr == dpy->screens + i)
4463 break;
4465 return i;
4468 #endif /* not HAVE_XSCREENNUMBEROFSCREEN */
4471 /* Select the visual that should be used on display DPYINFO. Set
4472 members of DPYINFO appropriately. Called from x_term_init. */
4474 void
4475 select_visual (struct x_display_info *dpyinfo)
4477 Display *dpy = dpyinfo->display;
4478 Screen *screen = dpyinfo->screen;
4480 /* See if a visual is specified. */
4481 AUTO_STRING (visualClass, "visualClass");
4482 AUTO_STRING (VisualClass, "VisualClass");
4483 Lisp_Object value = display_x_get_resource (dpyinfo, visualClass,
4484 VisualClass, Qnil, Qnil);
4486 if (STRINGP (value))
4488 /* VALUE should be of the form CLASS-DEPTH, where CLASS is one
4489 of `PseudoColor', `TrueColor' etc. and DEPTH is the color
4490 depth, a decimal number. NAME is compared with case ignored. */
4491 char *s = alloca (SBYTES (value) + 1);
4492 char *dash;
4493 int i, class = -1;
4494 XVisualInfo vinfo;
4496 lispstpcpy (s, value);
4497 dash = strchr (s, '-');
4498 if (dash)
4500 dpyinfo->n_planes = atoi (dash + 1);
4501 *dash = '\0';
4503 else
4504 /* We won't find a matching visual with depth 0, so that
4505 an error will be printed below. */
4506 dpyinfo->n_planes = 0;
4508 /* Determine the visual class. */
4509 for (i = 0; visual_classes[i].name; ++i)
4510 if (xstrcasecmp (s, visual_classes[i].name) == 0)
4512 class = visual_classes[i].class;
4513 break;
4516 /* Look up a matching visual for the specified class. */
4517 if (class == -1
4518 || !XMatchVisualInfo (dpy, XScreenNumberOfScreen (screen),
4519 dpyinfo->n_planes, class, &vinfo))
4520 fatal ("Invalid visual specification `%s'", SDATA (value));
4522 dpyinfo->visual = vinfo.visual;
4524 else
4526 int n_visuals;
4527 XVisualInfo *vinfo, vinfo_template;
4529 dpyinfo->visual = DefaultVisualOfScreen (screen);
4531 vinfo_template.visualid = XVisualIDFromVisual (dpyinfo->visual);
4532 vinfo_template.screen = XScreenNumberOfScreen (screen);
4533 vinfo = XGetVisualInfo (dpy, VisualIDMask | VisualScreenMask,
4534 &vinfo_template, &n_visuals);
4535 if (n_visuals <= 0)
4536 fatal ("Can't get proper X visual info");
4538 dpyinfo->n_planes = vinfo->depth;
4539 XFree (vinfo);
4544 /* Return the X display structure for the display named NAME.
4545 Open a new connection if necessary. */
4547 static struct x_display_info *
4548 x_display_info_for_name (Lisp_Object name)
4550 struct x_display_info *dpyinfo;
4552 CHECK_STRING (name);
4554 for (dpyinfo = x_display_list; dpyinfo; dpyinfo = dpyinfo->next)
4555 if (!NILP (Fstring_equal (XCAR (dpyinfo->name_list_element), name)))
4556 return dpyinfo;
4558 /* Use this general default value to start with. */
4559 Vx_resource_name = Vinvocation_name;
4561 validate_x_resource_name ();
4563 dpyinfo = x_term_init (name, 0, SSDATA (Vx_resource_name));
4565 if (dpyinfo == 0)
4566 error ("Cannot connect to X server %s", SDATA (name));
4568 XSETFASTINT (Vwindow_system_version, 11);
4570 return dpyinfo;
4574 DEFUN ("x-open-connection", Fx_open_connection, Sx_open_connection,
4575 1, 3, 0,
4576 doc: /* Open a connection to a display server.
4577 DISPLAY is the name of the display to connect to.
4578 Optional second arg XRM-STRING is a string of resources in xrdb format.
4579 If the optional third arg MUST-SUCCEED is non-nil,
4580 terminate Emacs if we can't open the connection.
4581 \(In the Nextstep version, the last two arguments are currently ignored.) */)
4582 (Lisp_Object display, Lisp_Object xrm_string, Lisp_Object must_succeed)
4584 char *xrm_option;
4585 struct x_display_info *dpyinfo;
4587 CHECK_STRING (display);
4588 if (! NILP (xrm_string))
4589 CHECK_STRING (xrm_string);
4591 xrm_option = NILP (xrm_string) ? 0 : SSDATA (xrm_string);
4593 validate_x_resource_name ();
4595 /* This is what opens the connection and sets x_current_display.
4596 This also initializes many symbols, such as those used for input. */
4597 dpyinfo = x_term_init (display, xrm_option,
4598 SSDATA (Vx_resource_name));
4600 if (dpyinfo == 0)
4602 if (!NILP (must_succeed))
4603 fatal ("Cannot connect to X server %s.\n\
4604 Check the DISPLAY environment variable or use `-d'.\n\
4605 Also use the `xauth' program to verify that you have the proper\n\
4606 authorization information needed to connect the X server.\n\
4607 An insecure way to solve the problem may be to use `xhost'.\n",
4608 SDATA (display));
4609 else
4610 error ("Cannot connect to X server %s", SDATA (display));
4613 XSETFASTINT (Vwindow_system_version, 11);
4614 return Qnil;
4617 DEFUN ("x-close-connection", Fx_close_connection,
4618 Sx_close_connection, 1, 1, 0,
4619 doc: /* Close the connection to TERMINAL's X server.
4620 For TERMINAL, specify a terminal object, a frame or a display name (a
4621 string). If TERMINAL is nil, that stands for the selected frame's
4622 terminal. */)
4623 (Lisp_Object terminal)
4625 struct x_display_info *dpyinfo = check_x_display_info (terminal);
4627 if (dpyinfo->reference_count > 0)
4628 error ("Display still has frames on it");
4630 x_delete_terminal (dpyinfo->terminal);
4632 return Qnil;
4635 DEFUN ("x-display-list", Fx_display_list, Sx_display_list, 0, 0, 0,
4636 doc: /* Return the list of display names that Emacs has connections to. */)
4637 (void)
4639 Lisp_Object result = Qnil;
4640 struct x_display_info *xdi;
4642 for (xdi = x_display_list; xdi; xdi = xdi->next)
4643 result = Fcons (XCAR (xdi->name_list_element), result);
4645 return result;
4648 DEFUN ("x-synchronize", Fx_synchronize, Sx_synchronize, 1, 2, 0,
4649 doc: /* If ON is non-nil, report X errors as soon as the erring request is made.
4650 This function only has an effect on X Windows. With MS Windows, it is
4651 defined but does nothing.
4653 If ON is nil, allow buffering of requests.
4654 Turning on synchronization prohibits the Xlib routines from buffering
4655 requests and seriously degrades performance, but makes debugging much
4656 easier.
4657 The optional second argument TERMINAL specifies which display to act on.
4658 TERMINAL should be a terminal object, a frame or a display name (a string).
4659 If TERMINAL is omitted or nil, that stands for the selected frame's display. */)
4660 (Lisp_Object on, Lisp_Object terminal)
4662 struct x_display_info *dpyinfo = check_x_display_info (terminal);
4664 XSynchronize (dpyinfo->display, !EQ (on, Qnil));
4666 return Qnil;
4669 /* Wait for responses to all X commands issued so far for frame F. */
4671 void
4672 x_sync (struct frame *f)
4674 block_input ();
4675 XSync (FRAME_X_DISPLAY (f), False);
4676 unblock_input ();
4680 /***********************************************************************
4681 Window properties
4682 ***********************************************************************/
4684 DEFUN ("x-change-window-property", Fx_change_window_property,
4685 Sx_change_window_property, 2, 6, 0,
4686 doc: /* Change window property PROP to VALUE on the X window of FRAME.
4687 PROP must be a string. VALUE may be a string or a list of conses,
4688 numbers and/or strings. If an element in the list is a string, it is
4689 converted to an atom and the value of the atom is used. If an element
4690 is a cons, it is converted to a 32 bit number where the car is the 16
4691 top bits and the cdr is the lower 16 bits.
4693 FRAME nil or omitted means use the selected frame.
4694 If TYPE is given and non-nil, it is the name of the type of VALUE.
4695 If TYPE is not given or nil, the type is STRING.
4696 FORMAT gives the size in bits of each element if VALUE is a list.
4697 It must be one of 8, 16 or 32.
4698 If VALUE is a string or FORMAT is nil or not given, FORMAT defaults to 8.
4699 If OUTER-P is non-nil, the property is changed for the outer X window of
4700 FRAME. Default is to change on the edit X window. */)
4701 (Lisp_Object prop, Lisp_Object value, Lisp_Object frame,
4702 Lisp_Object type, Lisp_Object format, Lisp_Object outer_p)
4704 struct frame *f = decode_window_system_frame (frame);
4705 Atom prop_atom;
4706 Atom target_type = XA_STRING;
4707 int element_format = 8;
4708 unsigned char *data;
4709 int nelements;
4710 Window w;
4712 CHECK_STRING (prop);
4714 if (! NILP (format))
4716 CHECK_NUMBER (format);
4718 if (XINT (format) != 8 && XINT (format) != 16
4719 && XINT (format) != 32)
4720 error ("FORMAT must be one of 8, 16 or 32");
4721 element_format = XINT (format);
4724 if (CONSP (value))
4726 ptrdiff_t elsize;
4728 nelements = x_check_property_data (value);
4729 if (nelements == -1)
4730 error ("Bad data in VALUE, must be number, string or cons");
4732 /* The man page for XChangeProperty:
4733 "If the specified format is 32, the property data must be a
4734 long array."
4735 This applies even if long is more than 32 bits. The X library
4736 converts to 32 bits before sending to the X server. */
4737 elsize = element_format == 32 ? sizeof (long) : element_format >> 3;
4738 data = xnmalloc (nelements, elsize);
4740 x_fill_property_data (FRAME_X_DISPLAY (f), value, data, element_format);
4742 else
4744 CHECK_STRING (value);
4745 data = SDATA (value);
4746 if (INT_MAX < SBYTES (value))
4747 error ("VALUE too long");
4748 nelements = SBYTES (value);
4751 block_input ();
4752 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (prop), False);
4753 if (! NILP (type))
4755 CHECK_STRING (type);
4756 target_type = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (type), False);
4759 if (! NILP (outer_p)) w = FRAME_OUTER_WINDOW (f);
4760 else w = FRAME_X_WINDOW (f);
4762 XChangeProperty (FRAME_X_DISPLAY (f), w,
4763 prop_atom, target_type, element_format, PropModeReplace,
4764 data, nelements);
4766 if (CONSP (value)) xfree (data);
4768 /* Make sure the property is set when we return. */
4769 XFlush (FRAME_X_DISPLAY (f));
4770 unblock_input ();
4772 return value;
4776 DEFUN ("x-delete-window-property", Fx_delete_window_property,
4777 Sx_delete_window_property, 1, 2, 0,
4778 doc: /* Remove window property PROP from X window of FRAME.
4779 FRAME nil or omitted means use the selected frame. Value is PROP. */)
4780 (Lisp_Object prop, Lisp_Object frame)
4782 struct frame *f = decode_window_system_frame (frame);
4783 Atom prop_atom;
4785 CHECK_STRING (prop);
4786 block_input ();
4787 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (prop), False);
4788 XDeleteProperty (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), prop_atom);
4790 /* Make sure the property is removed when we return. */
4791 XFlush (FRAME_X_DISPLAY (f));
4792 unblock_input ();
4794 return prop;
4798 static Lisp_Object
4799 x_window_property_intern (struct frame *f,
4800 Window target_window,
4801 Atom prop_atom,
4802 Atom target_type,
4803 Lisp_Object delete_p,
4804 Lisp_Object vector_ret_p,
4805 bool *found)
4807 unsigned char *tmp_data = NULL;
4808 Lisp_Object prop_value = Qnil;
4809 Atom actual_type;
4810 int actual_format;
4811 unsigned long actual_size, bytes_remaining;
4812 int rc;
4813 struct gcpro gcpro1;
4815 GCPRO1 (prop_value);
4817 rc = XGetWindowProperty (FRAME_X_DISPLAY (f), target_window,
4818 prop_atom, 0, 0, False, target_type,
4819 &actual_type, &actual_format, &actual_size,
4820 &bytes_remaining, &tmp_data);
4822 *found = actual_format != 0;
4824 if (rc == Success && *found)
4826 XFree (tmp_data);
4827 tmp_data = NULL;
4829 rc = XGetWindowProperty (FRAME_X_DISPLAY (f), target_window,
4830 prop_atom, 0, bytes_remaining,
4831 ! NILP (delete_p), target_type,
4832 &actual_type, &actual_format,
4833 &actual_size, &bytes_remaining,
4834 &tmp_data);
4835 if (rc == Success && tmp_data)
4837 /* The man page for XGetWindowProperty says:
4838 "If the returned format is 32, the returned data is represented
4839 as a long array and should be cast to that type to obtain the
4840 elements."
4841 This applies even if long is more than 32 bits, the X library
4842 converts from 32 bit elements received from the X server to long
4843 and passes the long array to us. Thus, for that case memcpy can not
4844 be used. We convert to a 32 bit type here, because so much code
4845 assume on that.
4847 The bytes and offsets passed to XGetWindowProperty refers to the
4848 property and those are indeed in 32 bit quantities if format is
4849 32. */
4851 if (BITS_PER_LONG > 32 && actual_format == 32)
4853 unsigned long i;
4854 int *idata = (int *) tmp_data;
4855 long *ldata = (long *) tmp_data;
4857 for (i = 0; i < actual_size; ++i)
4858 idata[i] = (int) ldata[i];
4861 if (NILP (vector_ret_p))
4862 prop_value = make_string ((char *) tmp_data, actual_size);
4863 else
4864 prop_value = x_property_data_to_lisp (f,
4865 tmp_data,
4866 actual_type,
4867 actual_format,
4868 actual_size);
4871 if (tmp_data) XFree (tmp_data);
4874 UNGCPRO;
4875 return prop_value;
4878 DEFUN ("x-window-property", Fx_window_property, Sx_window_property,
4879 1, 6, 0,
4880 doc: /* Value is the value of window property PROP on FRAME.
4881 If FRAME is nil or omitted, use the selected frame.
4883 On X Windows, the following optional arguments are also accepted:
4884 If TYPE is nil or omitted, get the property as a string.
4885 Otherwise TYPE is the name of the atom that denotes the type expected.
4886 If SOURCE is non-nil, get the property on that window instead of from
4887 FRAME. The number 0 denotes the root window.
4888 If DELETE-P is non-nil, delete the property after retrieving it.
4889 If VECTOR-RET-P is non-nil, don't return a string but a vector of values.
4891 On MS Windows, this function accepts but ignores those optional arguments.
4893 Value is nil if FRAME hasn't a property with name PROP or if PROP has
4894 no value of TYPE (always string in the MS Windows case). */)
4895 (Lisp_Object prop, Lisp_Object frame, Lisp_Object type,
4896 Lisp_Object source, Lisp_Object delete_p, Lisp_Object vector_ret_p)
4898 struct frame *f = decode_window_system_frame (frame);
4899 Atom prop_atom;
4900 Lisp_Object prop_value = Qnil;
4901 Atom target_type = XA_STRING;
4902 Window target_window = FRAME_X_WINDOW (f);
4903 struct gcpro gcpro1;
4904 bool found;
4906 GCPRO1 (prop_value);
4907 CHECK_STRING (prop);
4909 if (! NILP (source))
4911 CONS_TO_INTEGER (source, Window, target_window);
4912 if (! target_window)
4913 target_window = FRAME_DISPLAY_INFO (f)->root_window;
4916 block_input ();
4917 if (STRINGP (type))
4919 if (strcmp ("AnyPropertyType", SSDATA (type)) == 0)
4920 target_type = AnyPropertyType;
4921 else
4922 target_type = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (type), False);
4925 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SSDATA (prop), False);
4926 prop_value = x_window_property_intern (f,
4927 target_window,
4928 prop_atom,
4929 target_type,
4930 delete_p,
4931 vector_ret_p,
4932 &found);
4933 if (NILP (prop_value)
4934 && ! found
4935 && NILP (source)
4936 && target_window != FRAME_OUTER_WINDOW (f))
4938 prop_value = x_window_property_intern (f,
4939 FRAME_OUTER_WINDOW (f),
4940 prop_atom,
4941 target_type,
4942 delete_p,
4943 vector_ret_p,
4944 &found);
4948 unblock_input ();
4949 UNGCPRO;
4950 return prop_value;
4953 /***********************************************************************
4954 Tool tips
4955 ***********************************************************************/
4957 static Lisp_Object x_create_tip_frame (struct x_display_info *,
4958 Lisp_Object, Lisp_Object);
4959 static void compute_tip_xy (struct frame *, Lisp_Object, Lisp_Object,
4960 Lisp_Object, int, int, int *, int *);
4962 /* The frame of a currently visible tooltip. */
4964 Lisp_Object tip_frame;
4966 /* If non-nil, a timer started that hides the last tooltip when it
4967 fires. */
4969 static Lisp_Object tip_timer;
4970 Window tip_window;
4972 /* If non-nil, a vector of 3 elements containing the last args
4973 with which x-show-tip was called. See there. */
4975 static Lisp_Object last_show_tip_args;
4978 static void
4979 unwind_create_tip_frame (Lisp_Object frame)
4981 Lisp_Object deleted;
4983 deleted = unwind_create_frame (frame);
4984 if (EQ (deleted, Qt))
4986 tip_window = None;
4987 tip_frame = Qnil;
4992 /* Create a frame for a tooltip on the display described by DPYINFO.
4993 PARMS is a list of frame parameters. TEXT is the string to
4994 display in the tip frame. Value is the frame.
4996 Note that functions called here, esp. x_default_parameter can
4997 signal errors, for instance when a specified color name is
4998 undefined. We have to make sure that we're in a consistent state
4999 when this happens. */
5001 static Lisp_Object
5002 x_create_tip_frame (struct x_display_info *dpyinfo,
5003 Lisp_Object parms,
5004 Lisp_Object text)
5006 struct frame *f;
5007 Lisp_Object frame;
5008 Lisp_Object name;
5009 int width, height;
5010 ptrdiff_t count = SPECPDL_INDEX ();
5011 struct gcpro gcpro1, gcpro2, gcpro3;
5012 bool face_change_before = face_change;
5013 Lisp_Object buffer;
5014 struct buffer *old_buffer;
5016 if (!dpyinfo->terminal->name)
5017 error ("Terminal is not live, can't create new frames on it");
5019 parms = Fcopy_alist (parms);
5021 /* Get the name of the frame to use for resource lookup. */
5022 name = x_get_arg (dpyinfo, parms, Qname, "name", "Name", RES_TYPE_STRING);
5023 if (!STRINGP (name)
5024 && !EQ (name, Qunbound)
5025 && !NILP (name))
5026 error ("Invalid frame name--not a string or nil");
5028 frame = Qnil;
5029 GCPRO3 (parms, name, frame);
5030 f = make_frame (true);
5031 XSETFRAME (frame, f);
5033 AUTO_STRING (tip, " *tip*");
5034 buffer = Fget_buffer_create (tip);
5035 /* Use set_window_buffer instead of Fset_window_buffer (see
5036 discussion of bug#11984, bug#12025, bug#12026). */
5037 set_window_buffer (FRAME_ROOT_WINDOW (f), buffer, false, false);
5038 old_buffer = current_buffer;
5039 set_buffer_internal_1 (XBUFFER (buffer));
5040 bset_truncate_lines (current_buffer, Qnil);
5041 specbind (Qinhibit_read_only, Qt);
5042 specbind (Qinhibit_modification_hooks, Qt);
5043 Ferase_buffer ();
5044 Finsert (1, &text);
5045 set_buffer_internal_1 (old_buffer);
5047 record_unwind_protect (unwind_create_tip_frame, frame);
5049 f->terminal = dpyinfo->terminal;
5051 /* By setting the output method, we're essentially saying that
5052 the frame is live, as per FRAME_LIVE_P. If we get a signal
5053 from this point on, x_destroy_window might screw up reference
5054 counts etc. */
5055 f->output_method = output_x_window;
5056 f->output_data.x = xzalloc (sizeof *f->output_data.x);
5057 f->output_data.x->icon_bitmap = -1;
5058 FRAME_FONTSET (f) = -1;
5059 f->output_data.x->scroll_bar_foreground_pixel = -1;
5060 f->output_data.x->scroll_bar_background_pixel = -1;
5061 #if defined (USE_LUCID) && defined (USE_TOOLKIT_SCROLL_BARS)
5062 f->output_data.x->scroll_bar_top_shadow_pixel = -1;
5063 f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
5064 #endif /* USE_LUCID && USE_TOOLKIT_SCROLL_BARS */
5065 f->output_data.x->white_relief.pixel = -1;
5066 f->output_data.x->black_relief.pixel = -1;
5068 fset_icon_name (f, Qnil);
5069 FRAME_DISPLAY_INFO (f) = dpyinfo;
5070 f->output_data.x->parent_desc = FRAME_DISPLAY_INFO (f)->root_window;
5071 f->output_data.x->explicit_parent = false;
5073 /* These colors will be set anyway later, but it's important
5074 to get the color reference counts right, so initialize them! */
5076 Lisp_Object black;
5077 struct gcpro gcpro1;
5079 /* Function x_decode_color can signal an error. Make
5080 sure to initialize color slots so that we won't try
5081 to free colors we haven't allocated. */
5082 FRAME_FOREGROUND_PIXEL (f) = -1;
5083 FRAME_BACKGROUND_PIXEL (f) = -1;
5084 f->output_data.x->cursor_pixel = -1;
5085 f->output_data.x->cursor_foreground_pixel = -1;
5086 f->output_data.x->border_pixel = -1;
5087 f->output_data.x->mouse_pixel = -1;
5089 black = build_string ("black");
5090 GCPRO1 (black);
5091 FRAME_FOREGROUND_PIXEL (f)
5092 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
5093 FRAME_BACKGROUND_PIXEL (f)
5094 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
5095 f->output_data.x->cursor_pixel
5096 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
5097 f->output_data.x->cursor_foreground_pixel
5098 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
5099 f->output_data.x->border_pixel
5100 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
5101 f->output_data.x->mouse_pixel
5102 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
5103 UNGCPRO;
5106 /* Set the name; the functions to which we pass f expect the name to
5107 be set. */
5108 if (EQ (name, Qunbound) || NILP (name))
5110 fset_name (f, build_string (dpyinfo->x_id_name));
5111 f->explicit_name = false;
5113 else
5115 fset_name (f, name);
5116 f->explicit_name = true;
5117 /* use the frame's title when getting resources for this frame. */
5118 specbind (Qx_resource_name, name);
5121 register_font_driver (&xfont_driver, f);
5122 #ifdef HAVE_FREETYPE
5123 #ifdef HAVE_XFT
5124 register_font_driver (&xftfont_driver, f);
5125 #else /* not HAVE_XFT */
5126 register_font_driver (&ftxfont_driver, f);
5127 #endif /* not HAVE_XFT */
5128 #endif /* HAVE_FREETYPE */
5130 x_default_parameter (f, parms, Qfont_backend, Qnil,
5131 "fontBackend", "FontBackend", RES_TYPE_STRING);
5133 /* Extract the window parameters from the supplied values that are
5134 needed to determine window geometry. */
5135 x_default_font_parameter (f, parms);
5137 x_default_parameter (f, parms, Qborder_width, make_number (0),
5138 "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
5140 /* This defaults to 2 in order to match xterm. We recognize either
5141 internalBorderWidth or internalBorder (which is what xterm calls
5142 it). */
5143 if (NILP (Fassq (Qinternal_border_width, parms)))
5145 Lisp_Object value;
5147 value = x_get_arg (dpyinfo, parms, Qinternal_border_width,
5148 "internalBorder", "internalBorder", RES_TYPE_NUMBER);
5149 if (! EQ (value, Qunbound))
5150 parms = Fcons (Fcons (Qinternal_border_width, value),
5151 parms);
5154 x_default_parameter (f, parms, Qinternal_border_width, make_number (1),
5155 "internalBorderWidth", "internalBorderWidth",
5156 RES_TYPE_NUMBER);
5157 x_default_parameter (f, parms, Qright_divider_width, make_number (0),
5158 NULL, NULL, RES_TYPE_NUMBER);
5159 x_default_parameter (f, parms, Qbottom_divider_width, make_number (0),
5160 NULL, NULL, RES_TYPE_NUMBER);
5162 /* Also do the stuff which must be set before the window exists. */
5163 x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
5164 "foreground", "Foreground", RES_TYPE_STRING);
5165 x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
5166 "background", "Background", RES_TYPE_STRING);
5167 x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
5168 "pointerColor", "Foreground", RES_TYPE_STRING);
5169 x_default_parameter (f, parms, Qcursor_color, build_string ("black"),
5170 "cursorColor", "Foreground", RES_TYPE_STRING);
5171 x_default_parameter (f, parms, Qborder_color, build_string ("black"),
5172 "borderColor", "BorderColor", RES_TYPE_STRING);
5174 #ifdef GLYPH_DEBUG
5175 image_cache_refcount =
5176 FRAME_IMAGE_CACHE (f) ? FRAME_IMAGE_CACHE (f)->refcount : 0;
5177 dpyinfo_refcount = dpyinfo->reference_count;
5178 #endif /* GLYPH_DEBUG */
5180 /* Init faces before x_default_parameter is called for the
5181 scroll-bar-width parameter because otherwise we end up in
5182 init_iterator with a null face cache, which should not happen. */
5183 init_frame_faces (f);
5185 f->output_data.x->parent_desc = FRAME_DISPLAY_INFO (f)->root_window;
5187 x_figure_window_size (f, parms, false);
5190 XSetWindowAttributes attrs;
5191 unsigned long mask;
5192 Atom type = FRAME_DISPLAY_INFO (f)->Xatom_net_window_type_tooltip;
5194 block_input ();
5195 mask = CWBackPixel | CWOverrideRedirect | CWEventMask;
5196 if (DoesSaveUnders (dpyinfo->screen))
5197 mask |= CWSaveUnder;
5199 /* Window managers look at the override-redirect flag to determine
5200 whether or net to give windows a decoration (Xlib spec, chapter
5201 3.2.8). */
5202 attrs.override_redirect = True;
5203 attrs.save_under = True;
5204 attrs.background_pixel = FRAME_BACKGROUND_PIXEL (f);
5205 /* Arrange for getting MapNotify and UnmapNotify events. */
5206 attrs.event_mask = StructureNotifyMask;
5207 tip_window
5208 = FRAME_X_WINDOW (f)
5209 = XCreateWindow (FRAME_X_DISPLAY (f),
5210 FRAME_DISPLAY_INFO (f)->root_window,
5211 /* x, y, width, height */
5212 0, 0, 1, 1,
5213 /* Border. */
5214 f->border_width,
5215 CopyFromParent, InputOutput, CopyFromParent,
5216 mask, &attrs);
5217 XChangeProperty (FRAME_X_DISPLAY (f), tip_window,
5218 FRAME_DISPLAY_INFO (f)->Xatom_net_window_type,
5219 XA_ATOM, 32, PropModeReplace,
5220 (unsigned char *)&type, 1);
5221 unblock_input ();
5224 x_make_gc (f);
5226 x_default_parameter (f, parms, Qauto_raise, Qnil,
5227 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
5228 x_default_parameter (f, parms, Qauto_lower, Qnil,
5229 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
5230 x_default_parameter (f, parms, Qcursor_type, Qbox,
5231 "cursorType", "CursorType", RES_TYPE_SYMBOL);
5233 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
5234 Change will not be effected unless different from the current
5235 FRAME_LINES (f). */
5236 width = FRAME_COLS (f);
5237 height = FRAME_LINES (f);
5238 SET_FRAME_COLS (f, 0);
5239 SET_FRAME_LINES (f, 0);
5240 change_frame_size (f, width, height, true, false, false, false);
5242 /* Add `tooltip' frame parameter's default value. */
5243 if (NILP (Fframe_parameter (frame, Qtooltip)))
5245 AUTO_FRAME_ARG (arg, Qtooltip, Qt);
5246 Fmodify_frame_parameters (frame, arg);
5249 /* FIXME - can this be done in a similar way to normal frames?
5250 http://lists.gnu.org/archive/html/emacs-devel/2007-10/msg00641.html */
5252 /* Set the `display-type' frame parameter before setting up faces. */
5254 Lisp_Object disptype;
5256 if (FRAME_DISPLAY_INFO (f)->n_planes == 1)
5257 disptype = Qmono;
5258 else if (FRAME_DISPLAY_INFO (f)->visual->class == GrayScale
5259 || FRAME_DISPLAY_INFO (f)->visual->class == StaticGray)
5260 disptype = intern ("grayscale");
5261 else
5262 disptype = intern ("color");
5264 if (NILP (Fframe_parameter (frame, Qdisplay_type)))
5266 AUTO_FRAME_ARG (arg, Qdisplay_type, disptype);
5267 Fmodify_frame_parameters (frame, arg);
5271 /* Set up faces after all frame parameters are known. This call
5272 also merges in face attributes specified for new frames.
5274 Frame parameters may be changed if .Xdefaults contains
5275 specifications for the default font. For example, if there is an
5276 `Emacs.default.attributeBackground: pink', the `background-color'
5277 attribute of the frame get's set, which let's the internal border
5278 of the tooltip frame appear in pink. Prevent this. */
5280 Lisp_Object bg = Fframe_parameter (frame, Qbackground_color);
5282 /* Set tip_frame here, so that */
5283 tip_frame = frame;
5284 call2 (Qface_set_after_frame_default, frame, Qnil);
5286 if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
5288 AUTO_FRAME_ARG (arg, Qbackground_color, bg);
5289 Fmodify_frame_parameters (frame, arg);
5293 f->no_split = true;
5295 UNGCPRO;
5297 /* Now that the frame will be official, it counts as a reference to
5298 its display and terminal. */
5299 FRAME_DISPLAY_INFO (f)->reference_count++;
5300 f->terminal->reference_count++;
5302 /* It is now ok to make the frame official even if we get an error
5303 below. And the frame needs to be on Vframe_list or making it
5304 visible won't work. */
5305 Vframe_list = Fcons (frame, Vframe_list);
5306 f->can_x_set_window_size = true;
5308 /* Setting attributes of faces of the tooltip frame from resources
5309 and similar will set face_change, which leads to the clearing of
5310 all current matrices. Since this isn't necessary here, avoid it
5311 by resetting face_change to the value it had before we created
5312 the tip frame. */
5313 face_change = face_change_before;
5315 /* Discard the unwind_protect. */
5316 return unbind_to (count, frame);
5320 /* Compute where to display tip frame F. PARMS is the list of frame
5321 parameters for F. DX and DY are specified offsets from the current
5322 location of the mouse. WIDTH and HEIGHT are the width and height
5323 of the tooltip. Return coordinates relative to the root window of
5324 the display in *ROOT_X, and *ROOT_Y. */
5326 static void
5327 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)
5329 Lisp_Object left, top;
5330 int win_x, win_y;
5331 Window root, child;
5332 unsigned pmask;
5334 /* User-specified position? */
5335 left = Fcdr (Fassq (Qleft, parms));
5336 top = Fcdr (Fassq (Qtop, parms));
5338 /* Move the tooltip window where the mouse pointer is. Resize and
5339 show it. */
5340 if (!INTEGERP (left) || !INTEGERP (top))
5342 block_input ();
5343 XQueryPointer (FRAME_X_DISPLAY (f), FRAME_DISPLAY_INFO (f)->root_window,
5344 &root, &child, root_x, root_y, &win_x, &win_y, &pmask);
5345 unblock_input ();
5348 if (INTEGERP (top))
5349 *root_y = XINT (top);
5350 else if (*root_y + XINT (dy) <= 0)
5351 *root_y = 0; /* Can happen for negative dy */
5352 else if (*root_y + XINT (dy) + height
5353 <= x_display_pixel_height (FRAME_DISPLAY_INFO (f)))
5354 /* It fits below the pointer */
5355 *root_y += XINT (dy);
5356 else if (height + XINT (dy) <= *root_y)
5357 /* It fits above the pointer. */
5358 *root_y -= height + XINT (dy);
5359 else
5360 /* Put it on the top. */
5361 *root_y = 0;
5363 if (INTEGERP (left))
5364 *root_x = XINT (left);
5365 else if (*root_x + XINT (dx) <= 0)
5366 *root_x = 0; /* Can happen for negative dx */
5367 else if (*root_x + XINT (dx) + width
5368 <= x_display_pixel_width (FRAME_DISPLAY_INFO (f)))
5369 /* It fits to the right of the pointer. */
5370 *root_x += XINT (dx);
5371 else if (width + XINT (dx) <= *root_x)
5372 /* It fits to the left of the pointer. */
5373 *root_x -= width + XINT (dx);
5374 else
5375 /* Put it left-justified on the screen--it ought to fit that way. */
5376 *root_x = 0;
5380 DEFUN ("x-show-tip", Fx_show_tip, Sx_show_tip, 1, 6, 0,
5381 doc: /* Show STRING in a "tooltip" window on frame FRAME.
5382 A tooltip window is a small X window displaying a string.
5384 This is an internal function; Lisp code should call `tooltip-show'.
5386 FRAME nil or omitted means use the selected frame.
5388 PARMS is an optional list of frame parameters which can be used to
5389 change the tooltip's appearance.
5391 Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
5392 means use the default timeout of 5 seconds.
5394 If the list of frame parameters PARMS contains a `left' parameters,
5395 the tooltip is displayed at that x-position. Otherwise it is
5396 displayed at the mouse position, with offset DX added (default is 5 if
5397 DX isn't specified). Likewise for the y-position; if a `top' frame
5398 parameter is specified, it determines the y-position of the tooltip
5399 window, otherwise it is displayed at the mouse position, with offset
5400 DY added (default is -10).
5402 A tooltip's maximum size is specified by `x-max-tooltip-size'.
5403 Text larger than the specified size is clipped. */)
5404 (Lisp_Object string, Lisp_Object frame, Lisp_Object parms, Lisp_Object timeout, Lisp_Object dx, Lisp_Object dy)
5406 struct frame *f;
5407 struct window *w;
5408 int root_x, root_y;
5409 struct buffer *old_buffer;
5410 struct text_pos pos;
5411 int i, width, height;
5412 bool seen_reversed_p;
5413 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
5414 int old_windows_or_buffers_changed = windows_or_buffers_changed;
5415 ptrdiff_t count = SPECPDL_INDEX ();
5417 specbind (Qinhibit_redisplay, Qt);
5419 GCPRO4 (string, parms, frame, timeout);
5421 CHECK_STRING (string);
5422 if (SCHARS (string) == 0)
5423 string = make_unibyte_string (" ", 1);
5425 f = decode_window_system_frame (frame);
5426 if (NILP (timeout))
5427 timeout = make_number (5);
5428 else
5429 CHECK_NATNUM (timeout);
5431 if (NILP (dx))
5432 dx = make_number (5);
5433 else
5434 CHECK_NUMBER (dx);
5436 if (NILP (dy))
5437 dy = make_number (-10);
5438 else
5439 CHECK_NUMBER (dy);
5441 #ifdef USE_GTK
5442 if (x_gtk_use_system_tooltips)
5444 bool ok;
5446 /* Hide a previous tip, if any. */
5447 Fx_hide_tip ();
5449 block_input ();
5450 ok = xg_prepare_tooltip (f, string, &width, &height);
5451 if (ok)
5453 compute_tip_xy (f, parms, dx, dy, width, height, &root_x, &root_y);
5454 xg_show_tooltip (f, root_x, root_y);
5455 /* This is used in Fx_hide_tip. */
5456 XSETFRAME (tip_frame, f);
5458 unblock_input ();
5459 if (ok) goto start_timer;
5461 #endif /* USE_GTK */
5463 if (NILP (last_show_tip_args))
5464 last_show_tip_args = Fmake_vector (make_number (3), Qnil);
5466 if (!NILP (tip_frame))
5468 Lisp_Object last_string = AREF (last_show_tip_args, 0);
5469 Lisp_Object last_frame = AREF (last_show_tip_args, 1);
5470 Lisp_Object last_parms = AREF (last_show_tip_args, 2);
5472 if (EQ (frame, last_frame)
5473 && !NILP (Fequal (last_string, string))
5474 && !NILP (Fequal (last_parms, parms)))
5476 struct frame *tip_f = XFRAME (tip_frame);
5478 /* Only DX and DY have changed. */
5479 if (!NILP (tip_timer))
5481 Lisp_Object timer = tip_timer;
5482 tip_timer = Qnil;
5483 call1 (Qcancel_timer, timer);
5486 block_input ();
5487 compute_tip_xy (tip_f, parms, dx, dy, FRAME_PIXEL_WIDTH (tip_f),
5488 FRAME_PIXEL_HEIGHT (tip_f), &root_x, &root_y);
5489 XMoveWindow (FRAME_X_DISPLAY (tip_f), FRAME_X_WINDOW (tip_f),
5490 root_x, root_y);
5491 unblock_input ();
5492 goto start_timer;
5496 /* Hide a previous tip, if any. */
5497 Fx_hide_tip ();
5499 ASET (last_show_tip_args, 0, string);
5500 ASET (last_show_tip_args, 1, frame);
5501 ASET (last_show_tip_args, 2, parms);
5503 /* Add default values to frame parameters. */
5504 if (NILP (Fassq (Qname, parms)))
5505 parms = Fcons (Fcons (Qname, build_string ("tooltip")), parms);
5506 if (NILP (Fassq (Qinternal_border_width, parms)))
5507 parms = Fcons (Fcons (Qinternal_border_width, make_number (3)), parms);
5508 if (NILP (Fassq (Qborder_width, parms)))
5509 parms = Fcons (Fcons (Qborder_width, make_number (1)), parms);
5510 if (NILP (Fassq (Qbottom_divider_width, parms)))
5511 parms = Fcons (Fcons (Qbottom_divider_width, make_number (0)), parms);
5512 if (NILP (Fassq (Qright_divider_width, parms)))
5513 parms = Fcons (Fcons (Qright_divider_width, make_number (0)), parms);
5514 if (NILP (Fassq (Qborder_color, parms)))
5515 parms = Fcons (Fcons (Qborder_color, build_string ("lightyellow")), parms);
5516 if (NILP (Fassq (Qbackground_color, parms)))
5517 parms = Fcons (Fcons (Qbackground_color, build_string ("lightyellow")),
5518 parms);
5520 /* Create a frame for the tooltip, and record it in the global
5521 variable tip_frame. */
5522 frame = x_create_tip_frame (FRAME_DISPLAY_INFO (f), parms, string);
5523 f = XFRAME (frame);
5525 /* Set up the frame's root window. */
5526 w = XWINDOW (FRAME_ROOT_WINDOW (f));
5527 w->left_col = 0;
5528 w->top_line = 0;
5529 w->pixel_left = 0;
5530 w->pixel_top = 0;
5532 if (CONSP (Vx_max_tooltip_size)
5533 && RANGED_INTEGERP (1, XCAR (Vx_max_tooltip_size), INT_MAX)
5534 && RANGED_INTEGERP (1, XCDR (Vx_max_tooltip_size), INT_MAX))
5536 w->total_cols = XFASTINT (XCAR (Vx_max_tooltip_size));
5537 w->total_lines = XFASTINT (XCDR (Vx_max_tooltip_size));
5539 else
5541 w->total_cols = 80;
5542 w->total_lines = 40;
5545 w->pixel_width = w->total_cols * FRAME_COLUMN_WIDTH (f);
5546 w->pixel_height = w->total_lines * FRAME_LINE_HEIGHT (f);
5548 FRAME_TOTAL_COLS (f) = w->total_cols;
5549 adjust_frame_glyphs (f);
5550 w->pseudo_window_p = true;
5552 /* Display the tooltip text in a temporary buffer. */
5553 old_buffer = current_buffer;
5554 set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f))->contents));
5555 bset_truncate_lines (current_buffer, Qnil);
5556 clear_glyph_matrix (w->desired_matrix);
5557 clear_glyph_matrix (w->current_matrix);
5558 SET_TEXT_POS (pos, BEGV, BEGV_BYTE);
5559 try_window (FRAME_ROOT_WINDOW (f), pos, TRY_WINDOW_IGNORE_FONTS_CHANGE);
5561 /* Compute width and height of the tooltip. */
5562 width = height = 0;
5563 seen_reversed_p = false;
5564 for (i = 0; i < w->desired_matrix->nrows; ++i)
5566 struct glyph_row *row = &w->desired_matrix->rows[i];
5567 struct glyph *last;
5568 int row_width;
5570 /* Stop at the first empty row at the end. */
5571 if (!row->enabled_p || !MATRIX_ROW_DISPLAYS_TEXT_P (row))
5572 break;
5574 /* Let the row go over the full width of the frame. */
5575 row->full_width_p = true;
5577 row_width = row->pixel_width;
5578 if (row->used[TEXT_AREA])
5580 /* There's a glyph at the end of rows that is used to place
5581 the cursor there. Don't include the width of this glyph. */
5582 if (!row->reversed_p)
5584 last = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
5585 if (NILP (last->object))
5586 row_width -= last->pixel_width;
5588 else
5590 /* There could be a stretch glyph at the beginning of R2L
5591 rows that is produced by extend_face_to_end_of_line.
5592 Don't count that glyph. */
5593 struct glyph *g = row->glyphs[TEXT_AREA];
5595 if (g->type == STRETCH_GLYPH && NILP (g->object))
5597 row_width -= g->pixel_width;
5598 seen_reversed_p = true;
5603 height += row->height;
5604 width = max (width, row_width);
5607 /* If we've seen partial-length R2L rows, we need to re-adjust the
5608 tool-tip frame width and redisplay it again, to avoid over-wide
5609 tips due to the stretch glyph that extends R2L lines to full
5610 width of the frame. */
5611 if (seen_reversed_p)
5613 /* w->total_cols and FRAME_TOTAL_COLS want the width in columns,
5614 not in pixels. */
5615 w->pixel_width = width;
5616 width /= WINDOW_FRAME_COLUMN_WIDTH (w);
5617 w->total_cols = width;
5618 FRAME_TOTAL_COLS (f) = width;
5619 SET_FRAME_WIDTH (f, width);
5620 adjust_frame_glyphs (f);
5621 clear_glyph_matrix (w->desired_matrix);
5622 clear_glyph_matrix (w->current_matrix);
5623 try_window (FRAME_ROOT_WINDOW (f), pos, 0);
5624 width = height = 0;
5625 /* Recompute width and height of the tooltip. */
5626 for (i = 0; i < w->desired_matrix->nrows; ++i)
5628 struct glyph_row *row = &w->desired_matrix->rows[i];
5629 struct glyph *last;
5630 int row_width;
5632 if (!row->enabled_p || !MATRIX_ROW_DISPLAYS_TEXT_P (row))
5633 break;
5634 row->full_width_p = true;
5635 row_width = row->pixel_width;
5636 if (row->used[TEXT_AREA] && !row->reversed_p)
5638 last = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
5639 if (NILP (last->object))
5640 row_width -= last->pixel_width;
5643 height += row->height;
5644 width = max (width, row_width);
5648 /* Add the frame's internal border to the width and height the X
5649 window should have. */
5650 height += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
5651 width += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
5653 /* Move the tooltip window where the mouse pointer is. Resize and
5654 show it. */
5655 compute_tip_xy (f, parms, dx, dy, width, height, &root_x, &root_y);
5657 block_input ();
5658 XMoveResizeWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
5659 root_x, root_y, width, height);
5660 XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
5661 unblock_input ();
5663 /* Draw into the window. */
5664 w->must_be_updated_p = true;
5665 update_single_window (w);
5667 /* Restore original current buffer. */
5668 set_buffer_internal_1 (old_buffer);
5669 windows_or_buffers_changed = old_windows_or_buffers_changed;
5671 start_timer:
5672 /* Let the tip disappear after timeout seconds. */
5673 tip_timer = call3 (intern ("run-at-time"), timeout, Qnil,
5674 intern ("x-hide-tip"));
5676 UNGCPRO;
5677 return unbind_to (count, Qnil);
5681 DEFUN ("x-hide-tip", Fx_hide_tip, Sx_hide_tip, 0, 0, 0,
5682 doc: /* Hide the current tooltip window, if there is any.
5683 Value is t if tooltip was open, nil otherwise. */)
5684 (void)
5686 ptrdiff_t count;
5687 Lisp_Object deleted, frame, timer;
5688 struct gcpro gcpro1, gcpro2;
5690 /* Return quickly if nothing to do. */
5691 if (NILP (tip_timer) && NILP (tip_frame))
5692 return Qnil;
5694 frame = tip_frame;
5695 timer = tip_timer;
5696 GCPRO2 (frame, timer);
5697 tip_frame = tip_timer = deleted = Qnil;
5699 count = SPECPDL_INDEX ();
5700 specbind (Qinhibit_redisplay, Qt);
5701 specbind (Qinhibit_quit, Qt);
5703 if (!NILP (timer))
5704 call1 (Qcancel_timer, timer);
5706 #ifdef USE_GTK
5708 /* When using system tooltip, tip_frame is the Emacs frame on which
5709 the tip is shown. */
5710 struct frame *f = XFRAME (frame);
5711 if (FRAME_LIVE_P (f) && xg_hide_tooltip (f))
5712 frame = Qnil;
5714 #endif
5716 if (FRAMEP (frame))
5718 delete_frame (frame, Qnil);
5719 deleted = Qt;
5721 #ifdef USE_LUCID
5722 /* Bloodcurdling hack alert: The Lucid menu bar widget's
5723 redisplay procedure is not called when a tip frame over menu
5724 items is unmapped. Redisplay the menu manually... */
5726 Widget w;
5727 struct frame *f = SELECTED_FRAME ();
5728 w = f->output_data.x->menubar_widget;
5730 if (!DoesSaveUnders (FRAME_DISPLAY_INFO (f)->screen)
5731 && w != NULL)
5733 block_input ();
5734 xlwmenu_redisplay (w);
5735 unblock_input ();
5738 #endif /* USE_LUCID */
5741 UNGCPRO;
5742 return unbind_to (count, deleted);
5747 /***********************************************************************
5748 File selection dialog
5749 ***********************************************************************/
5751 DEFUN ("x-uses-old-gtk-dialog", Fx_uses_old_gtk_dialog,
5752 Sx_uses_old_gtk_dialog,
5753 0, 0, 0,
5754 doc: /* Return t if the old Gtk+ file selection dialog is used. */)
5755 (void)
5757 #ifdef USE_GTK
5758 if (use_dialog_box
5759 && use_file_dialog
5760 && window_system_available (SELECTED_FRAME ())
5761 && xg_uses_old_file_dialog ())
5762 return Qt;
5763 #endif
5764 return Qnil;
5768 #ifdef USE_MOTIF
5769 /* Callback for "OK" and "Cancel" on file selection dialog. */
5771 static void
5772 file_dialog_cb (Widget widget, XtPointer client_data, XtPointer call_data)
5774 int *result = client_data;
5775 XmAnyCallbackStruct *cb = call_data;
5776 *result = cb->reason;
5780 /* Callback for unmapping a file selection dialog. This is used to
5781 capture the case where a dialog is closed via a window manager's
5782 closer button, for example. Using a XmNdestroyCallback didn't work
5783 in this case. */
5785 static void
5786 file_dialog_unmap_cb (Widget widget, XtPointer client_data, XtPointer call_data)
5788 int *result = client_data;
5789 *result = XmCR_CANCEL;
5792 static void
5793 clean_up_file_dialog (void *arg)
5795 Widget dialog = arg;
5797 /* Clean up. */
5798 block_input ();
5799 XtUnmanageChild (dialog);
5800 XtDestroyWidget (dialog);
5801 x_menu_set_in_use (false);
5802 unblock_input ();
5806 DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
5807 doc: /* Read file name, prompting with PROMPT in directory DIR.
5808 Use a file selection dialog. Select DEFAULT-FILENAME in the dialog's file
5809 selection box, if specified. If MUSTMATCH is non-nil, the returned file
5810 or directory must exist.
5812 This function is only defined on NS, MS Windows, and X Windows with the
5813 Motif or Gtk toolkits. With the Motif toolkit, ONLY-DIR-P is ignored.
5814 Otherwise, if ONLY-DIR-P is non-nil, the user can only select directories.
5815 On Windows 7 and later, the file selection dialog "remembers" the last
5816 directory where the user selected a file, and will open that directory
5817 instead of DIR on subsequent invocations of this function with the same
5818 value of DIR as in previous invocations; this is standard Windows behavior. */)
5819 (Lisp_Object prompt, Lisp_Object dir, Lisp_Object default_filename,
5820 Lisp_Object mustmatch, Lisp_Object only_dir_p)
5822 int result;
5823 struct frame *f = SELECTED_FRAME ();
5824 Lisp_Object file = Qnil;
5825 Lisp_Object decoded_file;
5826 Widget dialog, text, help;
5827 Arg al[10];
5828 int ac = 0;
5829 XmString dir_xmstring, pattern_xmstring;
5830 ptrdiff_t count = SPECPDL_INDEX ();
5831 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
5833 check_window_system (f);
5835 GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
5837 if (popup_activated ())
5838 error ("Trying to use a menu from within a menu-entry");
5840 CHECK_STRING (prompt);
5841 CHECK_STRING (dir);
5843 /* Prevent redisplay. */
5844 specbind (Qinhibit_redisplay, Qt);
5846 block_input ();
5848 /* Create the dialog with PROMPT as title, using DIR as initial
5849 directory and using "*" as pattern. */
5850 dir = Fexpand_file_name (dir, Qnil);
5851 dir_xmstring = XmStringCreateLocalized (SSDATA (dir));
5852 pattern_xmstring = XmStringCreateLocalized ("*");
5854 XtSetArg (al[ac], XmNtitle, SDATA (prompt)); ++ac;
5855 XtSetArg (al[ac], XmNdirectory, dir_xmstring); ++ac;
5856 XtSetArg (al[ac], XmNpattern, pattern_xmstring); ++ac;
5857 XtSetArg (al[ac], XmNresizePolicy, XmRESIZE_GROW); ++ac;
5858 XtSetArg (al[ac], XmNdialogStyle, XmDIALOG_APPLICATION_MODAL); ++ac;
5859 dialog = XmCreateFileSelectionDialog (f->output_data.x->widget,
5860 "fsb", al, ac);
5861 XmStringFree (dir_xmstring);
5862 XmStringFree (pattern_xmstring);
5864 /* Add callbacks for OK and Cancel. */
5865 XtAddCallback (dialog, XmNokCallback, file_dialog_cb,
5866 (XtPointer) &result);
5867 XtAddCallback (dialog, XmNcancelCallback, file_dialog_cb,
5868 (XtPointer) &result);
5869 XtAddCallback (dialog, XmNunmapCallback, file_dialog_unmap_cb,
5870 (XtPointer) &result);
5872 /* Remove the help button since we can't display help. */
5873 help = XmFileSelectionBoxGetChild (dialog, XmDIALOG_HELP_BUTTON);
5874 XtUnmanageChild (help);
5876 /* Mark OK button as default. */
5877 XtVaSetValues (XmFileSelectionBoxGetChild (dialog, XmDIALOG_OK_BUTTON),
5878 XmNshowAsDefault, True, NULL);
5880 /* If MUSTMATCH is non-nil, disable the file entry field of the
5881 dialog, so that the user must select a file from the files list
5882 box. We can't remove it because we wouldn't have a way to get at
5883 the result file name, then. */
5884 text = XmFileSelectionBoxGetChild (dialog, XmDIALOG_TEXT);
5885 if (!NILP (mustmatch))
5887 Widget label;
5888 label = XmFileSelectionBoxGetChild (dialog, XmDIALOG_SELECTION_LABEL);
5889 XtSetSensitive (text, False);
5890 XtSetSensitive (label, False);
5893 /* Manage the dialog, so that list boxes get filled. */
5894 XtManageChild (dialog);
5896 if (STRINGP (default_filename))
5898 XmString default_xmstring;
5899 Widget wtext = XmFileSelectionBoxGetChild (dialog, XmDIALOG_TEXT);
5900 Widget list = XmFileSelectionBoxGetChild (dialog, XmDIALOG_LIST);
5902 XmTextPosition last_pos = XmTextFieldGetLastPosition (wtext);
5903 XmTextFieldReplace (wtext, 0, last_pos,
5904 (SSDATA (Ffile_name_nondirectory (default_filename))));
5906 /* Select DEFAULT_FILENAME in the files list box. DEFAULT_FILENAME
5907 must include the path for this to work. */
5909 default_xmstring = XmStringCreateLocalized (SSDATA (default_filename));
5911 if (XmListItemExists (list, default_xmstring))
5913 int item_pos = XmListItemPos (list, default_xmstring);
5914 /* Select the item and scroll it into view. */
5915 XmListSelectPos (list, item_pos, True);
5916 XmListSetPos (list, item_pos);
5919 XmStringFree (default_xmstring);
5922 record_unwind_protect_ptr (clean_up_file_dialog, dialog);
5924 /* Process events until the user presses Cancel or OK. */
5925 x_menu_set_in_use (true);
5926 result = 0;
5927 while (result == 0)
5929 XEvent event;
5930 x_menu_wait_for_event (0);
5931 XtAppNextEvent (Xt_app_con, &event);
5932 if (event.type == KeyPress
5933 && FRAME_X_DISPLAY (f) == event.xkey.display)
5935 KeySym keysym = XLookupKeysym (&event.xkey, 0);
5937 /* Pop down on C-g. */
5938 if (keysym == XK_g && (event.xkey.state & ControlMask) != 0)
5939 XtUnmanageChild (dialog);
5942 (void) x_dispatch_event (&event, FRAME_X_DISPLAY (f));
5945 /* Get the result. */
5946 if (result == XmCR_OK)
5948 XmString text_string;
5949 String data;
5951 XtVaGetValues (dialog, XmNtextString, &text_string, NULL);
5952 XmStringGetLtoR (text_string, XmFONTLIST_DEFAULT_TAG, &data);
5953 XmStringFree (text_string);
5954 file = build_string (data);
5955 XtFree (data);
5957 else
5958 file = Qnil;
5960 unblock_input ();
5961 UNGCPRO;
5963 /* Make "Cancel" equivalent to C-g. */
5964 if (NILP (file))
5965 Fsignal (Qquit, Qnil);
5967 decoded_file = DECODE_FILE (file);
5969 return unbind_to (count, decoded_file);
5972 #endif /* USE_MOTIF */
5974 #ifdef USE_GTK
5976 static void
5977 clean_up_dialog (void)
5979 x_menu_set_in_use (false);
5982 DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
5983 doc: /* Read file name, prompting with PROMPT in directory DIR.
5984 Use a file selection dialog. Select DEFAULT-FILENAME in the dialog's file
5985 selection box, if specified. If MUSTMATCH is non-nil, the returned file
5986 or directory must exist.
5988 This function is only defined on NS, MS Windows, and X Windows with the
5989 Motif or Gtk toolkits. With the Motif toolkit, ONLY-DIR-P is ignored.
5990 Otherwise, if ONLY-DIR-P is non-nil, the user can only select directories.
5991 On Windows 7 and later, the file selection dialog "remembers" the last
5992 directory where the user selected a file, and will open that directory
5993 instead of DIR on subsequent invocations of this function with the same
5994 value of DIR as in previous invocations; this is standard Windows behavior. */)
5995 (Lisp_Object prompt, Lisp_Object dir, Lisp_Object default_filename, Lisp_Object mustmatch, Lisp_Object only_dir_p)
5997 struct frame *f = SELECTED_FRAME ();
5998 char *fn;
5999 Lisp_Object file = Qnil;
6000 Lisp_Object decoded_file;
6001 ptrdiff_t count = SPECPDL_INDEX ();
6002 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
6003 char *cdef_file;
6005 check_window_system (f);
6007 GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
6009 if (popup_activated ())
6010 error ("Trying to use a menu from within a menu-entry");
6012 CHECK_STRING (prompt);
6013 CHECK_STRING (dir);
6015 /* Prevent redisplay. */
6016 specbind (Qinhibit_redisplay, Qt);
6017 record_unwind_protect_void (clean_up_dialog);
6019 block_input ();
6021 if (STRINGP (default_filename))
6022 cdef_file = SSDATA (default_filename);
6023 else
6024 cdef_file = SSDATA (dir);
6026 fn = xg_get_file_name (f, SSDATA (prompt), cdef_file,
6027 ! NILP (mustmatch),
6028 ! NILP (only_dir_p));
6030 if (fn)
6032 file = build_string (fn);
6033 xfree (fn);
6036 unblock_input ();
6037 UNGCPRO;
6039 /* Make "Cancel" equivalent to C-g. */
6040 if (NILP (file))
6041 Fsignal (Qquit, Qnil);
6043 decoded_file = DECODE_FILE (file);
6045 return unbind_to (count, decoded_file);
6049 #ifdef HAVE_FREETYPE
6051 DEFUN ("x-select-font", Fx_select_font, Sx_select_font, 0, 2, 0,
6052 doc: /* Read a font using a GTK dialog.
6053 Return either a font spec (for GTK versions >= 3.2) or a string
6054 containing a GTK-style font name.
6056 FRAME is the frame on which to pop up the font chooser. If omitted or
6057 nil, it defaults to the selected frame. */)
6058 (Lisp_Object frame, Lisp_Object ignored)
6060 struct frame *f = decode_window_system_frame (frame);
6061 Lisp_Object font;
6062 Lisp_Object font_param;
6063 char *default_name = NULL;
6064 struct gcpro gcpro1, gcpro2;
6065 ptrdiff_t count = SPECPDL_INDEX ();
6067 if (popup_activated ())
6068 error ("Trying to use a menu from within a menu-entry");
6070 /* Prevent redisplay. */
6071 specbind (Qinhibit_redisplay, Qt);
6072 record_unwind_protect_void (clean_up_dialog);
6074 block_input ();
6076 GCPRO2 (font_param, font);
6078 XSETFONT (font, FRAME_FONT (f));
6079 font_param = Ffont_get (font, QCname);
6080 if (STRINGP (font_param))
6081 default_name = xlispstrdup (font_param);
6082 else
6084 font_param = Fframe_parameter (frame, Qfont_param);
6085 if (STRINGP (font_param))
6086 default_name = xlispstrdup (font_param);
6089 font = xg_get_font (f, default_name);
6090 xfree (default_name);
6092 unblock_input ();
6094 if (NILP (font))
6095 Fsignal (Qquit, Qnil);
6097 return unbind_to (count, font);
6099 #endif /* HAVE_FREETYPE */
6101 #endif /* USE_GTK */
6104 /***********************************************************************
6105 Keyboard
6106 ***********************************************************************/
6108 #ifdef HAVE_XKB
6109 #include <X11/XKBlib.h>
6110 #include <X11/keysym.h>
6111 #endif
6113 DEFUN ("x-backspace-delete-keys-p", Fx_backspace_delete_keys_p,
6114 Sx_backspace_delete_keys_p, 0, 1, 0,
6115 doc: /* Check if both Backspace and Delete keys are on the keyboard of FRAME.
6116 FRAME nil means use the selected frame.
6117 Value is t if we know that both keys are present, and are mapped to the
6118 usual X keysyms. Value is `lambda' if we cannot determine if both keys are
6119 present and mapped to the usual X keysyms. */)
6120 (Lisp_Object frame)
6122 #ifndef HAVE_XKB
6123 return Qlambda;
6124 #else
6125 XkbDescPtr kb;
6126 struct frame *f = decode_window_system_frame (frame);
6127 Display *dpy = FRAME_X_DISPLAY (f);
6128 Lisp_Object have_keys;
6129 int major, minor, op, event, error_code;
6131 block_input ();
6133 /* Check library version in case we're dynamically linked. */
6134 major = XkbMajorVersion;
6135 minor = XkbMinorVersion;
6136 if (!XkbLibraryVersion (&major, &minor))
6138 unblock_input ();
6139 return Qlambda;
6142 /* Check that the server supports XKB. */
6143 major = XkbMajorVersion;
6144 minor = XkbMinorVersion;
6145 if (!XkbQueryExtension (dpy, &op, &event, &error_code, &major, &minor))
6147 unblock_input ();
6148 return Qlambda;
6151 /* In this code we check that the keyboard has physical keys with names
6152 that start with BKSP (Backspace) and DELE (Delete), and that they
6153 generate keysym XK_BackSpace and XK_Delete respectively.
6154 This function is used to test if normal-erase-is-backspace should be
6155 turned on.
6156 An alternative approach would be to just check if XK_BackSpace and
6157 XK_Delete are mapped to any key. But if any of those are mapped to
6158 some non-intuitive key combination (Meta-Shift-Ctrl-whatever) and the
6159 user doesn't know about it, it is better to return false here.
6160 It is more obvious to the user what to do if she/he has two keys
6161 clearly marked with names/symbols and one key does something not
6162 expected (i.e. she/he then tries the other).
6163 The cases where Backspace/Delete is mapped to some other key combination
6164 are rare, and in those cases, normal-erase-is-backspace can be turned on
6165 manually. */
6167 have_keys = Qnil;
6168 kb = XkbGetMap (dpy, XkbAllMapComponentsMask, XkbUseCoreKbd);
6169 if (kb)
6171 int delete_keycode = 0, backspace_keycode = 0, i;
6173 if (XkbGetNames (dpy, XkbAllNamesMask, kb) == Success)
6175 for (i = kb->min_key_code;
6176 (i < kb->max_key_code
6177 && (delete_keycode == 0 || backspace_keycode == 0));
6178 ++i)
6180 /* The XKB symbolic key names can be seen most easily in
6181 the PS file generated by `xkbprint -label name
6182 $DISPLAY'. */
6183 if (memcmp ("DELE", kb->names->keys[i].name, 4) == 0)
6184 delete_keycode = i;
6185 else if (memcmp ("BKSP", kb->names->keys[i].name, 4) == 0)
6186 backspace_keycode = i;
6189 XkbFreeNames (kb, 0, True);
6192 /* As of libX11-1.6.2, XkbGetMap manual says that you should use
6193 XkbFreeClientMap to free the data returned by XkbGetMap. But
6194 this function just frees the data referenced from KB and not
6195 KB itself. To free KB as well, call XkbFreeKeyboard. */
6196 XkbFreeKeyboard (kb, XkbAllMapComponentsMask, True);
6198 if (delete_keycode
6199 && backspace_keycode
6200 && XKeysymToKeycode (dpy, XK_Delete) == delete_keycode
6201 && XKeysymToKeycode (dpy, XK_BackSpace) == backspace_keycode)
6202 have_keys = Qt;
6204 unblock_input ();
6205 return have_keys;
6206 #endif
6211 /***********************************************************************
6212 Initialization
6213 ***********************************************************************/
6215 /* Keep this list in the same order as frame_parms in frame.c.
6216 Use 0 for unsupported frame parameters. */
6218 frame_parm_handler x_frame_parm_handlers[] =
6220 x_set_autoraise,
6221 x_set_autolower,
6222 x_set_background_color,
6223 x_set_border_color,
6224 x_set_border_width,
6225 x_set_cursor_color,
6226 x_set_cursor_type,
6227 x_set_font,
6228 x_set_foreground_color,
6229 x_set_icon_name,
6230 x_set_icon_type,
6231 x_set_internal_border_width,
6232 x_set_right_divider_width,
6233 x_set_bottom_divider_width,
6234 x_set_menu_bar_lines,
6235 x_set_mouse_color,
6236 x_explicitly_set_name,
6237 x_set_scroll_bar_width,
6238 x_set_scroll_bar_height,
6239 x_set_title,
6240 x_set_unsplittable,
6241 x_set_vertical_scroll_bars,
6242 x_set_horizontal_scroll_bars,
6243 x_set_visibility,
6244 x_set_tool_bar_lines,
6245 x_set_scroll_bar_foreground,
6246 x_set_scroll_bar_background,
6247 x_set_screen_gamma,
6248 x_set_line_spacing,
6249 x_set_left_fringe,
6250 x_set_right_fringe,
6251 x_set_wait_for_wm,
6252 x_set_fullscreen,
6253 x_set_font_backend,
6254 x_set_alpha,
6255 x_set_sticky,
6256 x_set_tool_bar_position,
6259 void
6260 syms_of_xfns (void)
6262 DEFSYM (Qundefined_color, "undefined-color");
6263 DEFSYM (Qcompound_text, "compound-text");
6264 DEFSYM (Qcancel_timer, "cancel-timer");
6265 DEFSYM (Qfont_param, "font-parameter");
6266 DEFSYM (Qmono, "mono");
6268 Fput (Qundefined_color, Qerror_conditions,
6269 listn (CONSTYPE_PURE, 2, Qundefined_color, Qerror));
6270 Fput (Qundefined_color, Qerror_message,
6271 build_pure_c_string ("Undefined color"));
6273 DEFVAR_LISP ("x-pointer-shape", Vx_pointer_shape,
6274 doc: /* The shape of the pointer when over text.
6275 Changing the value does not affect existing frames
6276 unless you set the mouse color. */);
6277 Vx_pointer_shape = Qnil;
6279 #if false /* This doesn't really do anything. */
6280 DEFVAR_LISP ("x-nontext-pointer-shape", Vx_nontext_pointer_shape,
6281 doc: /* The shape of the pointer when not over text.
6282 This variable takes effect when you create a new frame
6283 or when you set the mouse color. */);
6284 #endif
6285 Vx_nontext_pointer_shape = Qnil;
6287 DEFVAR_LISP ("x-hourglass-pointer-shape", Vx_hourglass_pointer_shape,
6288 doc: /* The shape of the pointer when Emacs is busy.
6289 This variable takes effect when you create a new frame
6290 or when you set the mouse color. */);
6291 Vx_hourglass_pointer_shape = Qnil;
6293 #if false /* This doesn't really do anything. */
6294 DEFVAR_LISP ("x-mode-pointer-shape", Vx_mode_pointer_shape,
6295 doc: /* The shape of the pointer when over the mode line.
6296 This variable takes effect when you create a new frame
6297 or when you set the mouse color. */);
6298 #endif
6299 Vx_mode_pointer_shape = Qnil;
6301 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
6302 Vx_sensitive_text_pointer_shape,
6303 doc: /* The shape of the pointer when over mouse-sensitive text.
6304 This variable takes effect when you create a new frame
6305 or when you set the mouse color. */);
6306 Vx_sensitive_text_pointer_shape = Qnil;
6308 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
6309 Vx_window_horizontal_drag_shape,
6310 doc: /* Pointer shape to use for indicating a window can be dragged horizontally.
6311 This variable takes effect when you create a new frame
6312 or when you set the mouse color. */);
6313 Vx_window_horizontal_drag_shape = Qnil;
6315 DEFVAR_LISP ("x-window-vertical-drag-cursor",
6316 Vx_window_vertical_drag_shape,
6317 doc: /* Pointer shape to use for indicating a window can be dragged vertically.
6318 This variable takes effect when you create a new frame
6319 or when you set the mouse color. */);
6320 Vx_window_vertical_drag_shape = Qnil;
6322 DEFVAR_LISP ("x-cursor-fore-pixel", Vx_cursor_fore_pixel,
6323 doc: /* A string indicating the foreground color of the cursor box. */);
6324 Vx_cursor_fore_pixel = Qnil;
6326 DEFVAR_LISP ("x-max-tooltip-size", Vx_max_tooltip_size,
6327 doc: /* Maximum size for tooltips.
6328 Value is a pair (COLUMNS . ROWS). Text larger than this is clipped. */);
6329 Vx_max_tooltip_size = Fcons (make_number (80), make_number (40));
6331 DEFVAR_LISP ("x-no-window-manager", Vx_no_window_manager,
6332 doc: /* Non-nil if no X window manager is in use.
6333 Emacs doesn't try to figure this out; this is always nil
6334 unless you set it to something else. */);
6335 /* We don't have any way to find this out, so set it to nil
6336 and maybe the user would like to set it to t. */
6337 Vx_no_window_manager = Qnil;
6339 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
6340 Vx_pixel_size_width_font_regexp,
6341 doc: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
6343 Since Emacs gets width of a font matching with this regexp from
6344 PIXEL_SIZE field of the name, font finding mechanism gets faster for
6345 such a font. This is especially effective for such large fonts as
6346 Chinese, Japanese, and Korean. */);
6347 Vx_pixel_size_width_font_regexp = Qnil;
6349 /* This is not ifdef:ed, so other builds than GTK can customize it. */
6350 DEFVAR_BOOL ("x-gtk-use-old-file-dialog", x_gtk_use_old_file_dialog,
6351 doc: /* Non-nil means prompt with the old GTK file selection dialog.
6352 If nil or if the file selection dialog is not available, the new GTK file
6353 chooser is used instead. To turn off all file dialogs set the
6354 variable `use-file-dialog'. */);
6355 x_gtk_use_old_file_dialog = false;
6357 DEFVAR_BOOL ("x-gtk-show-hidden-files", x_gtk_show_hidden_files,
6358 doc: /* If non-nil, the GTK file chooser will by default show hidden files.
6359 Note that this is just the default, there is a toggle button on the file
6360 chooser to show or not show hidden files on a case by case basis. */);
6361 x_gtk_show_hidden_files = false;
6363 DEFVAR_BOOL ("x-gtk-file-dialog-help-text", x_gtk_file_dialog_help_text,
6364 doc: /* If non-nil, the GTK file chooser will show additional help text.
6365 If more space for files in the file chooser dialog is wanted, set this to nil
6366 to turn the additional text off. */);
6367 x_gtk_file_dialog_help_text = true;
6369 DEFVAR_BOOL ("x-gtk-use-system-tooltips", x_gtk_use_system_tooltips,
6370 doc: /* If non-nil with a Gtk+ built Emacs, the Gtk+ tooltip is used.
6371 Otherwise use Emacs own tooltip implementation.
6372 When using Gtk+ tooltips, the tooltip face is not used. */);
6373 x_gtk_use_system_tooltips = true;
6375 /* Tell Emacs about this window system. */
6376 Fprovide (Qx, Qnil);
6378 #ifdef USE_X_TOOLKIT
6379 Fprovide (intern_c_string ("x-toolkit"), Qnil);
6380 #ifdef USE_MOTIF
6381 Fprovide (intern_c_string ("motif"), Qnil);
6383 DEFVAR_LISP ("motif-version-string", Vmotif_version_string,
6384 doc: /* Version info for LessTif/Motif. */);
6385 Vmotif_version_string = build_string (XmVERSION_STRING);
6386 #endif /* USE_MOTIF */
6387 #endif /* USE_X_TOOLKIT */
6389 #ifdef USE_GTK
6390 /* Provide x-toolkit also for GTK. Internally GTK does not use Xt so it
6391 is not an X toolkit in that sense (USE_X_TOOLKIT is not defined).
6392 But for a user it is a toolkit for X, and indeed, configure
6393 accepts --with-x-toolkit=gtk. */
6394 Fprovide (intern_c_string ("x-toolkit"), Qnil);
6395 Fprovide (intern_c_string ("gtk"), Qnil);
6396 Fprovide (intern_c_string ("move-toolbar"), Qnil);
6398 DEFVAR_LISP ("gtk-version-string", Vgtk_version_string,
6399 doc: /* Version info for GTK+. */);
6401 char gtk_version[sizeof ".." + 3 * INT_STRLEN_BOUND (int)];
6402 int len = sprintf (gtk_version, "%d.%d.%d",
6403 GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION);
6404 Vgtk_version_string = make_pure_string (gtk_version, len, len, false);
6406 #endif /* USE_GTK */
6408 /* X window properties. */
6409 defsubr (&Sx_change_window_property);
6410 defsubr (&Sx_delete_window_property);
6411 defsubr (&Sx_window_property);
6413 defsubr (&Sxw_display_color_p);
6414 defsubr (&Sx_display_grayscale_p);
6415 defsubr (&Sxw_color_defined_p);
6416 defsubr (&Sxw_color_values);
6417 defsubr (&Sx_server_max_request_size);
6418 defsubr (&Sx_server_vendor);
6419 defsubr (&Sx_server_version);
6420 defsubr (&Sx_display_pixel_width);
6421 defsubr (&Sx_display_pixel_height);
6422 defsubr (&Sx_display_mm_width);
6423 defsubr (&Sx_display_mm_height);
6424 defsubr (&Sx_display_screens);
6425 defsubr (&Sx_display_planes);
6426 defsubr (&Sx_display_color_cells);
6427 defsubr (&Sx_display_visual_class);
6428 defsubr (&Sx_display_backing_store);
6429 defsubr (&Sx_display_save_under);
6430 defsubr (&Sx_display_monitor_attributes_list);
6431 defsubr (&Sx_frame_geometry);
6432 defsubr (&Sx_wm_set_size_hint);
6433 defsubr (&Sx_create_frame);
6434 defsubr (&Sx_open_connection);
6435 defsubr (&Sx_close_connection);
6436 defsubr (&Sx_display_list);
6437 defsubr (&Sx_synchronize);
6438 defsubr (&Sx_backspace_delete_keys_p);
6440 defsubr (&Sx_show_tip);
6441 defsubr (&Sx_hide_tip);
6442 tip_timer = Qnil;
6443 staticpro (&tip_timer);
6444 tip_frame = Qnil;
6445 staticpro (&tip_frame);
6447 last_show_tip_args = Qnil;
6448 staticpro (&last_show_tip_args);
6450 defsubr (&Sx_uses_old_gtk_dialog);
6451 #if defined (USE_MOTIF) || defined (USE_GTK)
6452 defsubr (&Sx_file_dialog);
6453 #endif
6455 #if defined (USE_GTK) && defined (HAVE_FREETYPE)
6456 defsubr (&Sx_select_font);
6457 #endif