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