(Fx_create_frame): Move unwind_create_frame setup down.
[emacs.git] / src / xfns.c
blobdd0510cf0fa1fc056923c9eb9117a7141a8d4a5c
1 /* Functions for the X window system.
2 Copyright (C) 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
22 #include <config.h>
23 #include <stdio.h>
24 #include <math.h>
26 #ifdef HAVE_UNISTD_H
27 #include <unistd.h>
28 #endif
30 /* This makes the fields of a Display accessible, in Xlib header files. */
32 #define XLIB_ILLEGAL_ACCESS
34 #include "lisp.h"
35 #include "xterm.h"
36 #include "frame.h"
37 #include "window.h"
38 #include "buffer.h"
39 #include "intervals.h"
40 #include "dispextern.h"
41 #include "keyboard.h"
42 #include "blockinput.h"
43 #include <epaths.h>
44 #include "charset.h"
45 #include "coding.h"
46 #include "fontset.h"
47 #include "systime.h"
48 #include "termhooks.h"
49 #include "atimer.h"
51 #ifdef HAVE_X_WINDOWS
53 #include <ctype.h>
54 #include <sys/types.h>
55 #include <sys/stat.h>
57 #ifndef VMS
58 #if 1 /* Used to be #ifdef EMACS_BITMAP_FILES, but this should always work. */
59 #include "bitmaps/gray.xbm"
60 #else
61 #include <X11/bitmaps/gray>
62 #endif
63 #else
64 #include "[.bitmaps]gray.xbm"
65 #endif
67 #ifdef USE_GTK
68 #include "gtkutil.h"
69 #endif
71 #ifdef USE_X_TOOLKIT
72 #include <X11/Shell.h>
74 #ifndef USE_MOTIF
75 #include <X11/Xaw/Paned.h>
76 #include <X11/Xaw/Label.h>
77 #endif /* USE_MOTIF */
79 #ifdef USG
80 #undef USG /* ####KLUDGE for Solaris 2.2 and up */
81 #include <X11/Xos.h>
82 #define USG
83 #else
84 #include <X11/Xos.h>
85 #endif
87 #include "widget.h"
89 #include "../lwlib/lwlib.h"
91 #ifdef USE_MOTIF
92 #include <Xm/Xm.h>
93 #include <Xm/DialogS.h>
94 #include <Xm/FileSB.h>
95 #endif
97 /* Do the EDITRES protocol if running X11R5
98 Exception: HP-UX (at least version A.09.05) has X11R5 without EditRes */
100 #if (XtSpecificationRelease >= 5) && !defined(NO_EDITRES)
101 #define HACK_EDITRES
102 extern void _XEditResCheckMessages ();
103 #endif /* R5 + Athena */
105 /* Unique id counter for widgets created by the Lucid Widget Library. */
107 extern LWLIB_ID widget_id_tick;
109 #ifdef USE_LUCID
110 /* This is part of a kludge--see lwlib/xlwmenu.c. */
111 extern XFontStruct *xlwmenu_default_font;
112 #endif
114 extern void free_frame_menubar ();
115 extern double atof ();
117 #ifdef USE_MOTIF
119 /* LessTif/Motif version info. */
121 static Lisp_Object Vmotif_version_string;
123 #endif /* USE_MOTIF */
125 #endif /* USE_X_TOOLKIT */
127 #ifdef USE_GTK
129 /* GTK+ version info */
131 static Lisp_Object Vgtk_version_string;
133 #endif /* USE_GTK */
135 #ifdef HAVE_X11R4
136 #define MAXREQUEST(dpy) (XMaxRequestSize (dpy))
137 #else
138 #define MAXREQUEST(dpy) ((dpy)->max_request_size)
139 #endif
141 /* The gray bitmap `bitmaps/gray'. This is done because xterm.c uses
142 it, and including `bitmaps/gray' more than once is a problem when
143 config.h defines `static' as an empty replacement string. */
145 int gray_bitmap_width = gray_width;
146 int gray_bitmap_height = gray_height;
147 char *gray_bitmap_bits = gray_bits;
149 /* Non-zero means we're allowed to display an hourglass cursor. */
151 int display_hourglass_p;
153 /* Non-zero means prompt with the old GTK file selection dialog. */
155 int x_use_old_gtk_file_dialog;
157 /* If non-zero, by default show hidden files in the GTK file chooser. */
159 int x_gtk_show_hidden_files;
161 /* If non-zero, don't collapse to tool bar when it is detached. */
163 int x_gtk_whole_detached_tool_bar;
165 /* The background and shape of the mouse pointer, and shape when not
166 over text or in the modeline. */
168 Lisp_Object Vx_pointer_shape, Vx_nontext_pointer_shape, Vx_mode_pointer_shape;
169 Lisp_Object Vx_hourglass_pointer_shape;
171 /* The shape when over mouse-sensitive text. */
173 Lisp_Object Vx_sensitive_text_pointer_shape;
175 /* If non-nil, the pointer shape to indicate that windows can be
176 dragged horizontally. */
178 Lisp_Object Vx_window_horizontal_drag_shape;
180 /* Color of chars displayed in cursor box. */
182 Lisp_Object Vx_cursor_fore_pixel;
184 /* Nonzero if using X. */
186 static int x_in_use;
188 /* Non nil if no window manager is in use. */
190 Lisp_Object Vx_no_window_manager;
192 /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'. */
194 Lisp_Object Vx_pixel_size_width_font_regexp;
196 Lisp_Object Qnone;
197 Lisp_Object Qsuppress_icon;
198 Lisp_Object Qundefined_color;
199 Lisp_Object Qcompound_text, Qcancel_timer;
201 /* In dispnew.c */
203 extern Lisp_Object Vwindow_system_version;
205 /* The below are defined in frame.c. */
207 #if GLYPH_DEBUG
208 int image_cache_refcount, dpyinfo_refcount;
209 #endif
213 /* Error if we are not connected to X. */
215 void
216 check_x ()
218 if (! x_in_use)
219 error ("X windows are not in use or not initialized");
222 /* Nonzero if we can use mouse menus.
223 You should not call this unless HAVE_MENUS is defined. */
226 have_menus_p ()
228 return x_in_use;
231 /* Extract a frame as a FRAME_PTR, defaulting to the selected frame
232 and checking validity for X. */
234 FRAME_PTR
235 check_x_frame (frame)
236 Lisp_Object frame;
238 FRAME_PTR f;
240 if (NILP (frame))
241 frame = selected_frame;
242 CHECK_LIVE_FRAME (frame);
243 f = XFRAME (frame);
244 if (! FRAME_X_P (f))
245 error ("Non-X frame used");
246 return f;
249 /* Let the user specify an X display with a frame.
250 nil stands for the selected frame--or, if that is not an X frame,
251 the first X display on the list. */
253 struct x_display_info *
254 check_x_display_info (frame)
255 Lisp_Object frame;
257 struct x_display_info *dpyinfo = NULL;
259 if (NILP (frame))
261 struct frame *sf = XFRAME (selected_frame);
263 if (FRAME_X_P (sf) && FRAME_LIVE_P (sf))
264 dpyinfo = FRAME_X_DISPLAY_INFO (sf);
265 else if (x_display_list != 0)
266 dpyinfo = x_display_list;
267 else
268 error ("X windows are not in use or not initialized");
270 else if (STRINGP (frame))
271 dpyinfo = x_display_info_for_name (frame);
272 else
274 FRAME_PTR f = check_x_frame (frame);
275 dpyinfo = FRAME_X_DISPLAY_INFO (f);
278 return dpyinfo;
282 /* Return the Emacs frame-object corresponding to an X window.
283 It could be the frame's main window or an icon window. */
285 /* This function can be called during GC, so use GC_xxx type test macros. */
287 struct frame *
288 x_window_to_frame (dpyinfo, wdesc)
289 struct x_display_info *dpyinfo;
290 int wdesc;
292 Lisp_Object tail, frame;
293 struct frame *f;
295 if (wdesc == None) return 0;
297 for (tail = Vframe_list; GC_CONSP (tail); tail = XCDR (tail))
299 frame = XCAR (tail);
300 if (!GC_FRAMEP (frame))
301 continue;
302 f = XFRAME (frame);
303 if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
304 continue;
305 if (f->output_data.x->hourglass_window == wdesc)
306 return f;
307 #ifdef USE_X_TOOLKIT
308 if ((f->output_data.x->edit_widget
309 && XtWindow (f->output_data.x->edit_widget) == wdesc)
310 /* A tooltip frame? */
311 || (!f->output_data.x->edit_widget
312 && FRAME_X_WINDOW (f) == wdesc)
313 || f->output_data.x->icon_desc == wdesc)
314 return f;
315 #else /* not USE_X_TOOLKIT */
316 #ifdef USE_GTK
317 if (f->output_data.x->edit_widget)
319 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
320 struct x_output *x = f->output_data.x;
321 if (gwdesc != 0 && gwdesc == x->edit_widget)
322 return f;
324 #endif /* USE_GTK */
325 if (FRAME_X_WINDOW (f) == wdesc
326 || f->output_data.x->icon_desc == wdesc)
327 return f;
328 #endif /* not USE_X_TOOLKIT */
330 return 0;
333 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
334 /* Like x_window_to_frame but also compares the window with the widget's
335 windows. */
337 struct frame *
338 x_any_window_to_frame (dpyinfo, wdesc)
339 struct x_display_info *dpyinfo;
340 int wdesc;
342 Lisp_Object tail, frame;
343 struct frame *f, *found;
344 struct x_output *x;
346 if (wdesc == None) return NULL;
348 found = NULL;
349 for (tail = Vframe_list; GC_CONSP (tail) && !found; tail = XCDR (tail))
351 frame = XCAR (tail);
352 if (!GC_FRAMEP (frame))
353 continue;
355 f = XFRAME (frame);
356 if (FRAME_X_P (f) && FRAME_X_DISPLAY_INFO (f) == dpyinfo)
358 /* This frame matches if the window is any of its widgets. */
359 x = f->output_data.x;
360 if (x->hourglass_window == wdesc)
361 found = f;
362 else if (x->widget)
364 #ifdef USE_GTK
365 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
366 if (gwdesc != 0
367 && (gwdesc == x->widget
368 || gwdesc == x->edit_widget
369 || gwdesc == x->vbox_widget
370 || gwdesc == x->menubar_widget))
371 found = f;
372 #else
373 if (wdesc == XtWindow (x->widget)
374 || wdesc == XtWindow (x->column_widget)
375 || wdesc == XtWindow (x->edit_widget))
376 found = f;
377 /* Match if the window is this frame's menubar. */
378 else if (lw_window_is_in_menubar (wdesc, x->menubar_widget))
379 found = f;
380 #endif
382 else if (FRAME_X_WINDOW (f) == wdesc)
383 /* A tooltip frame. */
384 found = f;
388 return found;
391 /* Likewise, but exclude the menu bar widget. */
393 struct frame *
394 x_non_menubar_window_to_frame (dpyinfo, wdesc)
395 struct x_display_info *dpyinfo;
396 int wdesc;
398 Lisp_Object tail, frame;
399 struct frame *f;
400 struct x_output *x;
402 if (wdesc == None) return 0;
404 for (tail = Vframe_list; GC_CONSP (tail); tail = XCDR (tail))
406 frame = XCAR (tail);
407 if (!GC_FRAMEP (frame))
408 continue;
409 f = XFRAME (frame);
410 if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
411 continue;
412 x = f->output_data.x;
413 /* This frame matches if the window is any of its widgets. */
414 if (x->hourglass_window == wdesc)
415 return f;
416 else if (x->widget)
418 #ifdef USE_GTK
419 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
420 if (gwdesc != 0
421 && (gwdesc == x->widget
422 || gwdesc == x->edit_widget
423 || gwdesc == x->vbox_widget))
424 return f;
425 #else
426 if (wdesc == XtWindow (x->widget)
427 || wdesc == XtWindow (x->column_widget)
428 || wdesc == XtWindow (x->edit_widget))
429 return f;
430 #endif
432 else if (FRAME_X_WINDOW (f) == wdesc)
433 /* A tooltip frame. */
434 return f;
436 return 0;
439 /* Likewise, but consider only the menu bar widget. */
441 struct frame *
442 x_menubar_window_to_frame (dpyinfo, wdesc)
443 struct x_display_info *dpyinfo;
444 int wdesc;
446 Lisp_Object tail, frame;
447 struct frame *f;
448 struct x_output *x;
450 if (wdesc == None) return 0;
452 for (tail = Vframe_list; GC_CONSP (tail); tail = XCDR (tail))
454 frame = XCAR (tail);
455 if (!GC_FRAMEP (frame))
456 continue;
457 f = XFRAME (frame);
458 if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
459 continue;
460 x = f->output_data.x;
461 /* Match if the window is this frame's menubar. */
462 #ifdef USE_GTK
463 if (x->menubar_widget)
465 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
466 int found = 0;
468 BLOCK_INPUT;
469 if (gwdesc != 0
470 && (gwdesc == x->menubar_widget
471 || gtk_widget_get_parent (gwdesc) == x->menubar_widget))
472 found = 1;
473 UNBLOCK_INPUT;
474 if (found) return f;
476 #else
477 if (x->menubar_widget
478 && lw_window_is_in_menubar (wdesc, x->menubar_widget))
479 return f;
480 #endif
482 return 0;
485 /* Return the frame whose principal (outermost) window is WDESC.
486 If WDESC is some other (smaller) window, we return 0. */
488 struct frame *
489 x_top_window_to_frame (dpyinfo, wdesc)
490 struct x_display_info *dpyinfo;
491 int wdesc;
493 Lisp_Object tail, frame;
494 struct frame *f;
495 struct x_output *x;
497 if (wdesc == None) return 0;
499 for (tail = Vframe_list; GC_CONSP (tail); tail = XCDR (tail))
501 frame = XCAR (tail);
502 if (!GC_FRAMEP (frame))
503 continue;
504 f = XFRAME (frame);
505 if (!FRAME_X_P (f) || FRAME_X_DISPLAY_INFO (f) != dpyinfo)
506 continue;
507 x = f->output_data.x;
509 if (x->widget)
511 /* This frame matches if the window is its topmost widget. */
512 #ifdef USE_GTK
513 GtkWidget *gwdesc = xg_win_to_widget (dpyinfo->display, wdesc);
514 if (gwdesc == x->widget)
515 return f;
516 #else
517 if (wdesc == XtWindow (x->widget))
518 return f;
519 #if 0 /* I don't know why it did this,
520 but it seems logically wrong,
521 and it causes trouble for MapNotify events. */
522 /* Match if the window is this frame's menubar. */
523 if (x->menubar_widget
524 && wdesc == XtWindow (x->menubar_widget))
525 return f;
526 #endif
527 #endif
529 else if (FRAME_X_WINDOW (f) == wdesc)
530 /* Tooltip frame. */
531 return f;
533 return 0;
535 #endif /* USE_X_TOOLKIT || USE_GTK */
539 static Lisp_Object unwind_create_frame P_ ((Lisp_Object));
540 static Lisp_Object unwind_create_tip_frame P_ ((Lisp_Object));
542 void x_set_foreground_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
543 static void x_set_wait_for_wm P_ ((struct frame *, Lisp_Object, Lisp_Object));
544 void x_set_background_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
545 void x_set_mouse_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
546 void x_set_cursor_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
547 void x_set_border_color P_ ((struct frame *, Lisp_Object, Lisp_Object));
548 void x_set_cursor_type P_ ((struct frame *, Lisp_Object, Lisp_Object));
549 void x_set_icon_type P_ ((struct frame *, Lisp_Object, Lisp_Object));
550 void x_set_icon_name P_ ((struct frame *, Lisp_Object, Lisp_Object));
551 void x_explicitly_set_name P_ ((struct frame *, Lisp_Object, Lisp_Object));
552 void x_set_menu_bar_lines P_ ((struct frame *, Lisp_Object, Lisp_Object));
553 void x_set_title P_ ((struct frame *, Lisp_Object, Lisp_Object));
554 void x_set_tool_bar_lines P_ ((struct frame *, Lisp_Object, Lisp_Object));
555 void x_set_scroll_bar_foreground P_ ((struct frame *, Lisp_Object,
556 Lisp_Object));
557 void x_set_scroll_bar_background P_ ((struct frame *, Lisp_Object,
558 Lisp_Object));
559 static Lisp_Object x_default_scroll_bar_color_parameter P_ ((struct frame *,
560 Lisp_Object,
561 Lisp_Object,
562 char *, char *,
563 int));
566 /* Store the screen positions of frame F into XPTR and YPTR.
567 These are the positions of the containing window manager window,
568 not Emacs's own window. */
570 void
571 x_real_positions (f, xptr, yptr)
572 FRAME_PTR f;
573 int *xptr, *yptr;
575 int win_x, win_y, outer_x, outer_y;
576 int real_x = 0, real_y = 0;
577 int had_errors = 0;
578 Window win = f->output_data.x->parent_desc;
580 BLOCK_INPUT;
582 x_catch_errors (FRAME_X_DISPLAY (f));
584 if (win == FRAME_X_DISPLAY_INFO (f)->root_window)
585 win = FRAME_OUTER_WINDOW (f);
587 /* This loop traverses up the containment tree until we hit the root
588 window. Window managers may intersect many windows between our window
589 and the root window. The window we find just before the root window
590 should be the outer WM window. */
591 for (;;)
593 Window wm_window, rootw;
594 Window *tmp_children;
595 unsigned int tmp_nchildren;
596 int success;
598 success = XQueryTree (FRAME_X_DISPLAY (f), win, &rootw,
599 &wm_window, &tmp_children, &tmp_nchildren);
601 had_errors = x_had_errors_p (FRAME_X_DISPLAY (f));
603 /* Don't free tmp_children if XQueryTree failed. */
604 if (! success)
605 break;
607 XFree ((char *) tmp_children);
609 if (wm_window == rootw || had_errors)
610 break;
612 win = wm_window;
615 if (! had_errors)
617 unsigned int ign;
618 Window child, rootw;
620 /* Get the real coordinates for the WM window upper left corner */
621 XGetGeometry (FRAME_X_DISPLAY (f), win,
622 &rootw, &real_x, &real_y, &ign, &ign, &ign, &ign);
624 /* Translate real coordinates to coordinates relative to our
625 window. For our window, the upper left corner is 0, 0.
626 Since the upper left corner of the WM window is outside
627 our window, win_x and win_y will be negative:
629 ------------------ ---> x
630 | title |
631 | ----------------- v y
632 | | our window
634 XTranslateCoordinates (FRAME_X_DISPLAY (f),
636 /* From-window, to-window. */
637 FRAME_X_DISPLAY_INFO (f)->root_window,
638 FRAME_X_WINDOW (f),
640 /* From-position, to-position. */
641 real_x, real_y, &win_x, &win_y,
643 /* Child of win. */
644 &child);
646 if (FRAME_X_WINDOW (f) == FRAME_OUTER_WINDOW (f))
648 outer_x = win_x;
649 outer_y = win_y;
651 else
653 XTranslateCoordinates (FRAME_X_DISPLAY (f),
655 /* From-window, to-window. */
656 FRAME_X_DISPLAY_INFO (f)->root_window,
657 FRAME_OUTER_WINDOW (f),
659 /* From-position, to-position. */
660 real_x, real_y, &outer_x, &outer_y,
662 /* Child of win. */
663 &child);
666 had_errors = x_had_errors_p (FRAME_X_DISPLAY (f));
669 x_uncatch_errors ();
671 UNBLOCK_INPUT;
673 if (had_errors) return;
675 f->x_pixels_diff = -win_x;
676 f->y_pixels_diff = -win_y;
678 FRAME_X_OUTPUT (f)->x_pixels_outer_diff = -outer_x;
679 FRAME_X_OUTPUT (f)->y_pixels_outer_diff = -outer_y;
681 *xptr = real_x;
682 *yptr = real_y;
688 /* Gamma-correct COLOR on frame F. */
690 void
691 gamma_correct (f, color)
692 struct frame *f;
693 XColor *color;
695 if (f->gamma)
697 color->red = pow (color->red / 65535.0, f->gamma) * 65535.0 + 0.5;
698 color->green = pow (color->green / 65535.0, f->gamma) * 65535.0 + 0.5;
699 color->blue = pow (color->blue / 65535.0, f->gamma) * 65535.0 + 0.5;
704 /* Decide if color named COLOR_NAME is valid for use on frame F. If
705 so, return the RGB values in COLOR. If ALLOC_P is non-zero,
706 allocate the color. Value is zero if COLOR_NAME is invalid, or
707 no color could be allocated. */
710 x_defined_color (f, color_name, color, alloc_p)
711 struct frame *f;
712 char *color_name;
713 XColor *color;
714 int alloc_p;
716 int success_p;
717 Display *dpy = FRAME_X_DISPLAY (f);
718 Colormap cmap = FRAME_X_COLORMAP (f);
720 BLOCK_INPUT;
721 success_p = XParseColor (dpy, cmap, color_name, color);
722 if (success_p && alloc_p)
723 success_p = x_alloc_nearest_color (f, cmap, color);
724 UNBLOCK_INPUT;
726 return success_p;
730 /* Return the pixel color value for color COLOR_NAME on frame F. If F
731 is a monochrome frame, return MONO_COLOR regardless of what ARG says.
732 Signal an error if color can't be allocated. */
735 x_decode_color (f, color_name, mono_color)
736 FRAME_PTR f;
737 Lisp_Object color_name;
738 int mono_color;
740 XColor cdef;
742 CHECK_STRING (color_name);
744 #if 0 /* Don't do this. It's wrong when we're not using the default
745 colormap, it makes freeing difficult, and it's probably not
746 an important optimization. */
747 if (strcmp (SDATA (color_name), "black") == 0)
748 return BLACK_PIX_DEFAULT (f);
749 else if (strcmp (SDATA (color_name), "white") == 0)
750 return WHITE_PIX_DEFAULT (f);
751 #endif
753 /* Return MONO_COLOR for monochrome frames. */
754 if (FRAME_X_DISPLAY_INFO (f)->n_planes == 1)
755 return mono_color;
757 /* x_defined_color is responsible for coping with failures
758 by looking for a near-miss. */
759 if (x_defined_color (f, SDATA (color_name), &cdef, 1))
760 return cdef.pixel;
762 Fsignal (Qerror, Fcons (build_string ("Undefined color"),
763 Fcons (color_name, Qnil)));
764 return 0;
769 /* Change the `wait-for-wm' frame parameter of frame F. OLD_VALUE is
770 the previous value of that parameter, NEW_VALUE is the new value.
771 See also the comment of wait_for_wm in struct x_output. */
773 static void
774 x_set_wait_for_wm (f, new_value, old_value)
775 struct frame *f;
776 Lisp_Object new_value, old_value;
778 f->output_data.x->wait_for_wm = !NILP (new_value);
781 #ifdef USE_GTK
783 /* Set icon from FILE for frame F. By using GTK functions the icon
784 may be any format that GdkPixbuf knows about, i.e. not just bitmaps. */
787 xg_set_icon (f, file)
788 FRAME_PTR f;
789 Lisp_Object file;
791 int result = 0;
792 Lisp_Object found;
794 found = x_find_image_file (file);
796 if (! NILP (found))
798 GdkPixbuf *pixbuf;
799 GError *err = NULL;
800 char *filename = (char *) SDATA (found);
801 BLOCK_INPUT;
803 pixbuf = gdk_pixbuf_new_from_file (filename, &err);
805 if (pixbuf)
807 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
808 pixbuf);
809 g_object_unref (pixbuf);
811 result = 1;
813 else
814 g_error_free (err);
816 UNBLOCK_INPUT;
819 return result;
823 xg_set_icon_from_xpm_data (f, data)
824 FRAME_PTR f;
825 char **data;
827 int result = 0;
828 GdkPixbuf *pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) data);
830 if (!pixbuf)
831 return 0;
833 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)), pixbuf);
834 g_object_unref (pixbuf);
835 return 1;
837 #endif /* USE_GTK */
840 /* Functions called only from `x_set_frame_param'
841 to set individual parameters.
843 If FRAME_X_WINDOW (f) is 0,
844 the frame is being created and its X-window does not exist yet.
845 In that case, just record the parameter's new value
846 in the standard place; do not attempt to change the window. */
848 void
849 x_set_foreground_color (f, arg, oldval)
850 struct frame *f;
851 Lisp_Object arg, oldval;
853 struct x_output *x = f->output_data.x;
854 unsigned long fg, old_fg;
856 fg = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
857 old_fg = x->foreground_pixel;
858 x->foreground_pixel = fg;
860 if (FRAME_X_WINDOW (f) != 0)
862 Display *dpy = FRAME_X_DISPLAY (f);
864 BLOCK_INPUT;
865 XSetForeground (dpy, x->normal_gc, fg);
866 XSetBackground (dpy, x->reverse_gc, fg);
868 if (x->cursor_pixel == old_fg)
870 unload_color (f, x->cursor_pixel);
871 x->cursor_pixel = x_copy_color (f, fg);
872 XSetBackground (dpy, x->cursor_gc, x->cursor_pixel);
875 UNBLOCK_INPUT;
877 update_face_from_frame_parameter (f, Qforeground_color, arg);
879 if (FRAME_VISIBLE_P (f))
880 redraw_frame (f);
883 unload_color (f, old_fg);
886 void
887 x_set_background_color (f, arg, oldval)
888 struct frame *f;
889 Lisp_Object arg, oldval;
891 struct x_output *x = f->output_data.x;
892 unsigned long bg;
894 bg = x_decode_color (f, arg, WHITE_PIX_DEFAULT (f));
895 unload_color (f, x->background_pixel);
896 x->background_pixel = bg;
898 if (FRAME_X_WINDOW (f) != 0)
900 Display *dpy = FRAME_X_DISPLAY (f);
902 BLOCK_INPUT;
903 XSetBackground (dpy, x->normal_gc, bg);
904 XSetForeground (dpy, x->reverse_gc, bg);
905 XSetWindowBackground (dpy, FRAME_X_WINDOW (f), bg);
906 XSetForeground (dpy, x->cursor_gc, bg);
908 #ifdef USE_GTK
909 xg_set_background_color (f, bg);
910 #endif
912 #ifndef USE_TOOLKIT_SCROLL_BARS /* Turns out to be annoying with
913 toolkit scroll bars. */
915 Lisp_Object bar;
916 for (bar = FRAME_SCROLL_BARS (f);
917 !NILP (bar);
918 bar = XSCROLL_BAR (bar)->next)
920 Window window = SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar));
921 XSetWindowBackground (dpy, window, bg);
924 #endif /* USE_TOOLKIT_SCROLL_BARS */
926 UNBLOCK_INPUT;
927 update_face_from_frame_parameter (f, Qbackground_color, arg);
929 if (FRAME_VISIBLE_P (f))
930 redraw_frame (f);
934 void
935 x_set_mouse_color (f, arg, oldval)
936 struct frame *f;
937 Lisp_Object arg, oldval;
939 struct x_output *x = f->output_data.x;
940 Display *dpy = FRAME_X_DISPLAY (f);
941 Cursor cursor, nontext_cursor, mode_cursor, hand_cursor;
942 Cursor hourglass_cursor, horizontal_drag_cursor;
943 unsigned long pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
944 unsigned long mask_color = x->background_pixel;
946 /* Don't let pointers be invisible. */
947 if (mask_color == pixel)
949 x_free_colors (f, &pixel, 1);
950 pixel = x_copy_color (f, x->foreground_pixel);
953 unload_color (f, x->mouse_pixel);
954 x->mouse_pixel = pixel;
956 BLOCK_INPUT;
958 /* It's not okay to crash if the user selects a screwy cursor. */
959 x_catch_errors (dpy);
961 if (!NILP (Vx_pointer_shape))
963 CHECK_NUMBER (Vx_pointer_shape);
964 cursor = XCreateFontCursor (dpy, XINT (Vx_pointer_shape));
966 else
967 cursor = XCreateFontCursor (dpy, XC_xterm);
968 x_check_errors (dpy, "bad text pointer cursor: %s");
970 if (!NILP (Vx_nontext_pointer_shape))
972 CHECK_NUMBER (Vx_nontext_pointer_shape);
973 nontext_cursor
974 = XCreateFontCursor (dpy, XINT (Vx_nontext_pointer_shape));
976 else
977 nontext_cursor = XCreateFontCursor (dpy, XC_left_ptr);
978 x_check_errors (dpy, "bad nontext pointer cursor: %s");
980 if (!NILP (Vx_hourglass_pointer_shape))
982 CHECK_NUMBER (Vx_hourglass_pointer_shape);
983 hourglass_cursor
984 = XCreateFontCursor (dpy, XINT (Vx_hourglass_pointer_shape));
986 else
987 hourglass_cursor = XCreateFontCursor (dpy, XC_watch);
988 x_check_errors (dpy, "bad hourglass pointer cursor: %s");
990 if (!NILP (Vx_mode_pointer_shape))
992 CHECK_NUMBER (Vx_mode_pointer_shape);
993 mode_cursor = XCreateFontCursor (dpy, XINT (Vx_mode_pointer_shape));
995 else
996 mode_cursor = XCreateFontCursor (dpy, XC_xterm);
997 x_check_errors (dpy, "bad modeline pointer cursor: %s");
999 if (!NILP (Vx_sensitive_text_pointer_shape))
1001 CHECK_NUMBER (Vx_sensitive_text_pointer_shape);
1002 hand_cursor
1003 = XCreateFontCursor (dpy, XINT (Vx_sensitive_text_pointer_shape));
1005 else
1006 hand_cursor = XCreateFontCursor (dpy, XC_hand2);
1008 if (!NILP (Vx_window_horizontal_drag_shape))
1010 CHECK_NUMBER (Vx_window_horizontal_drag_shape);
1011 horizontal_drag_cursor
1012 = XCreateFontCursor (dpy, XINT (Vx_window_horizontal_drag_shape));
1014 else
1015 horizontal_drag_cursor
1016 = XCreateFontCursor (dpy, XC_sb_h_double_arrow);
1018 /* Check and report errors with the above calls. */
1019 x_check_errors (dpy, "can't set cursor shape: %s");
1020 x_uncatch_errors ();
1023 XColor fore_color, back_color;
1025 fore_color.pixel = x->mouse_pixel;
1026 x_query_color (f, &fore_color);
1027 back_color.pixel = mask_color;
1028 x_query_color (f, &back_color);
1030 XRecolorCursor (dpy, cursor, &fore_color, &back_color);
1031 XRecolorCursor (dpy, nontext_cursor, &fore_color, &back_color);
1032 XRecolorCursor (dpy, mode_cursor, &fore_color, &back_color);
1033 XRecolorCursor (dpy, hand_cursor, &fore_color, &back_color);
1034 XRecolorCursor (dpy, hourglass_cursor, &fore_color, &back_color);
1035 XRecolorCursor (dpy, horizontal_drag_cursor, &fore_color, &back_color);
1038 if (FRAME_X_WINDOW (f) != 0)
1039 XDefineCursor (dpy, FRAME_X_WINDOW (f), cursor);
1041 if (cursor != x->text_cursor
1042 && x->text_cursor != 0)
1043 XFreeCursor (dpy, x->text_cursor);
1044 x->text_cursor = cursor;
1046 if (nontext_cursor != x->nontext_cursor
1047 && x->nontext_cursor != 0)
1048 XFreeCursor (dpy, x->nontext_cursor);
1049 x->nontext_cursor = nontext_cursor;
1051 if (hourglass_cursor != x->hourglass_cursor
1052 && x->hourglass_cursor != 0)
1053 XFreeCursor (dpy, x->hourglass_cursor);
1054 x->hourglass_cursor = hourglass_cursor;
1056 if (mode_cursor != x->modeline_cursor
1057 && x->modeline_cursor != 0)
1058 XFreeCursor (dpy, f->output_data.x->modeline_cursor);
1059 x->modeline_cursor = mode_cursor;
1061 if (hand_cursor != x->hand_cursor
1062 && x->hand_cursor != 0)
1063 XFreeCursor (dpy, x->hand_cursor);
1064 x->hand_cursor = hand_cursor;
1066 if (horizontal_drag_cursor != x->horizontal_drag_cursor
1067 && x->horizontal_drag_cursor != 0)
1068 XFreeCursor (dpy, x->horizontal_drag_cursor);
1069 x->horizontal_drag_cursor = horizontal_drag_cursor;
1071 XFlush (dpy);
1072 UNBLOCK_INPUT;
1074 update_face_from_frame_parameter (f, Qmouse_color, arg);
1077 void
1078 x_set_cursor_color (f, arg, oldval)
1079 struct frame *f;
1080 Lisp_Object arg, oldval;
1082 unsigned long fore_pixel, pixel;
1083 int fore_pixel_allocated_p = 0, pixel_allocated_p = 0;
1084 struct x_output *x = f->output_data.x;
1086 if (!NILP (Vx_cursor_fore_pixel))
1088 fore_pixel = x_decode_color (f, Vx_cursor_fore_pixel,
1089 WHITE_PIX_DEFAULT (f));
1090 fore_pixel_allocated_p = 1;
1092 else
1093 fore_pixel = x->background_pixel;
1095 pixel = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
1096 pixel_allocated_p = 1;
1098 /* Make sure that the cursor color differs from the background color. */
1099 if (pixel == x->background_pixel)
1101 if (pixel_allocated_p)
1103 x_free_colors (f, &pixel, 1);
1104 pixel_allocated_p = 0;
1107 pixel = x->mouse_pixel;
1108 if (pixel == fore_pixel)
1110 if (fore_pixel_allocated_p)
1112 x_free_colors (f, &fore_pixel, 1);
1113 fore_pixel_allocated_p = 0;
1115 fore_pixel = x->background_pixel;
1119 unload_color (f, x->cursor_foreground_pixel);
1120 if (!fore_pixel_allocated_p)
1121 fore_pixel = x_copy_color (f, fore_pixel);
1122 x->cursor_foreground_pixel = fore_pixel;
1124 unload_color (f, x->cursor_pixel);
1125 if (!pixel_allocated_p)
1126 pixel = x_copy_color (f, pixel);
1127 x->cursor_pixel = pixel;
1129 if (FRAME_X_WINDOW (f) != 0)
1131 BLOCK_INPUT;
1132 XSetBackground (FRAME_X_DISPLAY (f), x->cursor_gc, x->cursor_pixel);
1133 XSetForeground (FRAME_X_DISPLAY (f), x->cursor_gc, fore_pixel);
1134 UNBLOCK_INPUT;
1136 if (FRAME_VISIBLE_P (f))
1138 x_update_cursor (f, 0);
1139 x_update_cursor (f, 1);
1143 update_face_from_frame_parameter (f, Qcursor_color, arg);
1146 /* Set the border-color of frame F to pixel value PIX.
1147 Note that this does not fully take effect if done before
1148 F has an x-window. */
1150 void
1151 x_set_border_pixel (f, pix)
1152 struct frame *f;
1153 int pix;
1155 unload_color (f, f->output_data.x->border_pixel);
1156 f->output_data.x->border_pixel = pix;
1158 if (FRAME_X_WINDOW (f) != 0 && f->border_width > 0)
1160 BLOCK_INPUT;
1161 XSetWindowBorder (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1162 (unsigned long)pix);
1163 UNBLOCK_INPUT;
1165 if (FRAME_VISIBLE_P (f))
1166 redraw_frame (f);
1170 /* Set the border-color of frame F to value described by ARG.
1171 ARG can be a string naming a color.
1172 The border-color is used for the border that is drawn by the X server.
1173 Note that this does not fully take effect if done before
1174 F has an x-window; it must be redone when the window is created.
1176 Note: this is done in two routines because of the way X10 works.
1178 Note: under X11, this is normally the province of the window manager,
1179 and so emacs' border colors may be overridden. */
1181 void
1182 x_set_border_color (f, arg, oldval)
1183 struct frame *f;
1184 Lisp_Object arg, oldval;
1186 int pix;
1188 CHECK_STRING (arg);
1189 pix = x_decode_color (f, arg, BLACK_PIX_DEFAULT (f));
1190 x_set_border_pixel (f, pix);
1191 update_face_from_frame_parameter (f, Qborder_color, arg);
1195 void
1196 x_set_cursor_type (f, arg, oldval)
1197 FRAME_PTR f;
1198 Lisp_Object arg, oldval;
1200 set_frame_cursor_types (f, arg);
1202 /* Make sure the cursor gets redrawn. */
1203 cursor_type_changed = 1;
1206 void
1207 x_set_icon_type (f, arg, oldval)
1208 struct frame *f;
1209 Lisp_Object arg, oldval;
1211 int result;
1213 if (STRINGP (arg))
1215 if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
1216 return;
1218 else if (!STRINGP (oldval) && EQ (oldval, Qnil) == EQ (arg, Qnil))
1219 return;
1221 BLOCK_INPUT;
1222 if (NILP (arg))
1223 result = x_text_icon (f,
1224 (char *) SDATA ((!NILP (f->icon_name)
1225 ? f->icon_name
1226 : f->name)));
1227 else
1228 result = x_bitmap_icon (f, arg);
1230 if (result)
1232 UNBLOCK_INPUT;
1233 error ("No icon window available");
1236 XFlush (FRAME_X_DISPLAY (f));
1237 UNBLOCK_INPUT;
1240 void
1241 x_set_icon_name (f, arg, oldval)
1242 struct frame *f;
1243 Lisp_Object arg, oldval;
1245 int result;
1247 if (STRINGP (arg))
1249 if (STRINGP (oldval) && EQ (Fstring_equal (oldval, arg), Qt))
1250 return;
1252 else if (!NILP (arg) || NILP (oldval))
1253 return;
1255 f->icon_name = arg;
1257 if (f->output_data.x->icon_bitmap != 0)
1258 return;
1260 BLOCK_INPUT;
1262 result = x_text_icon (f,
1263 (char *) SDATA ((!NILP (f->icon_name)
1264 ? f->icon_name
1265 : !NILP (f->title)
1266 ? f->title
1267 : f->name)));
1269 if (result)
1271 UNBLOCK_INPUT;
1272 error ("No icon window available");
1275 XFlush (FRAME_X_DISPLAY (f));
1276 UNBLOCK_INPUT;
1280 void
1281 x_set_menu_bar_lines (f, value, oldval)
1282 struct frame *f;
1283 Lisp_Object value, oldval;
1285 int nlines;
1286 #if ! defined (USE_X_TOOLKIT) && ! defined (USE_GTK)
1287 int olines = FRAME_MENU_BAR_LINES (f);
1288 #endif
1290 /* Right now, menu bars don't work properly in minibuf-only frames;
1291 most of the commands try to apply themselves to the minibuffer
1292 frame itself, and get an error because you can't switch buffers
1293 in or split the minibuffer window. */
1294 if (FRAME_MINIBUF_ONLY_P (f))
1295 return;
1297 if (INTEGERP (value))
1298 nlines = XINT (value);
1299 else
1300 nlines = 0;
1302 /* Make sure we redisplay all windows in this frame. */
1303 windows_or_buffers_changed++;
1305 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1306 FRAME_MENU_BAR_LINES (f) = 0;
1307 if (nlines)
1309 FRAME_EXTERNAL_MENU_BAR (f) = 1;
1310 if (FRAME_X_P (f) && f->output_data.x->menubar_widget == 0)
1311 /* Make sure next redisplay shows the menu bar. */
1312 XWINDOW (FRAME_SELECTED_WINDOW (f))->update_mode_line = Qt;
1314 else
1316 if (FRAME_EXTERNAL_MENU_BAR (f) == 1)
1317 free_frame_menubar (f);
1318 FRAME_EXTERNAL_MENU_BAR (f) = 0;
1319 if (FRAME_X_P (f))
1320 f->output_data.x->menubar_widget = 0;
1322 #else /* not USE_X_TOOLKIT && not USE_GTK */
1323 FRAME_MENU_BAR_LINES (f) = nlines;
1324 change_window_heights (f->root_window, nlines - olines);
1325 #endif /* not USE_X_TOOLKIT */
1326 adjust_glyphs (f);
1330 /* Set the number of lines used for the tool bar of frame F to VALUE.
1331 VALUE not an integer, or < 0 means set the lines to zero. OLDVAL
1332 is the old number of tool bar lines. This function changes the
1333 height of all windows on frame F to match the new tool bar height.
1334 The frame's height doesn't change. */
1336 void
1337 x_set_tool_bar_lines (f, value, oldval)
1338 struct frame *f;
1339 Lisp_Object value, oldval;
1341 int delta, nlines, root_height;
1342 Lisp_Object root_window;
1344 /* Treat tool bars like menu bars. */
1345 if (FRAME_MINIBUF_ONLY_P (f))
1346 return;
1348 /* Use VALUE only if an integer >= 0. */
1349 if (INTEGERP (value) && XINT (value) >= 0)
1350 nlines = XFASTINT (value);
1351 else
1352 nlines = 0;
1354 #ifdef USE_GTK
1355 FRAME_TOOL_BAR_LINES (f) = 0;
1356 if (nlines)
1358 FRAME_EXTERNAL_TOOL_BAR (f) = 1;
1359 if (FRAME_X_P (f) && f->output_data.x->toolbar_widget == 0)
1360 /* Make sure next redisplay shows the tool bar. */
1361 XWINDOW (FRAME_SELECTED_WINDOW (f))->update_mode_line = Qt;
1362 update_frame_tool_bar (f);
1364 else
1366 if (FRAME_EXTERNAL_TOOL_BAR (f))
1367 free_frame_tool_bar (f);
1368 FRAME_EXTERNAL_TOOL_BAR (f) = 0;
1371 return;
1372 #endif
1374 /* Make sure we redisplay all windows in this frame. */
1375 ++windows_or_buffers_changed;
1377 delta = nlines - FRAME_TOOL_BAR_LINES (f);
1379 /* Don't resize the tool-bar to more than we have room for. */
1380 root_window = FRAME_ROOT_WINDOW (f);
1381 root_height = WINDOW_TOTAL_LINES (XWINDOW (root_window));
1382 if (root_height - delta < 1)
1384 delta = root_height - 1;
1385 nlines = FRAME_TOOL_BAR_LINES (f) + delta;
1388 FRAME_TOOL_BAR_LINES (f) = nlines;
1389 change_window_heights (root_window, delta);
1390 adjust_glyphs (f);
1392 /* We also have to make sure that the internal border at the top of
1393 the frame, below the menu bar or tool bar, is redrawn when the
1394 tool bar disappears. This is so because the internal border is
1395 below the tool bar if one is displayed, but is below the menu bar
1396 if there isn't a tool bar. The tool bar draws into the area
1397 below the menu bar. */
1398 if (FRAME_X_WINDOW (f) && FRAME_TOOL_BAR_LINES (f) == 0)
1400 updating_frame = f;
1401 clear_frame ();
1402 clear_current_matrices (f);
1403 updating_frame = NULL;
1406 /* If the tool bar gets smaller, the internal border below it
1407 has to be cleared. It was formerly part of the display
1408 of the larger tool bar, and updating windows won't clear it. */
1409 if (delta < 0)
1411 int height = FRAME_INTERNAL_BORDER_WIDTH (f);
1412 int width = FRAME_PIXEL_WIDTH (f);
1413 int y = nlines * FRAME_LINE_HEIGHT (f);
1415 /* height can be zero here. */
1416 if (height > 0 && width > 0)
1418 BLOCK_INPUT;
1419 x_clear_area (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1420 0, y, width, height, False);
1421 UNBLOCK_INPUT;
1424 if (WINDOWP (f->tool_bar_window))
1425 clear_glyph_matrix (XWINDOW (f->tool_bar_window)->current_matrix);
1430 /* Set the foreground color for scroll bars on frame F to VALUE.
1431 VALUE should be a string, a color name. If it isn't a string or
1432 isn't a valid color name, do nothing. OLDVAL is the old value of
1433 the frame parameter. */
1435 void
1436 x_set_scroll_bar_foreground (f, value, oldval)
1437 struct frame *f;
1438 Lisp_Object value, oldval;
1440 unsigned long pixel;
1442 if (STRINGP (value))
1443 pixel = x_decode_color (f, value, BLACK_PIX_DEFAULT (f));
1444 else
1445 pixel = -1;
1447 if (f->output_data.x->scroll_bar_foreground_pixel != -1)
1448 unload_color (f, f->output_data.x->scroll_bar_foreground_pixel);
1450 f->output_data.x->scroll_bar_foreground_pixel = pixel;
1451 if (FRAME_X_WINDOW (f) && FRAME_VISIBLE_P (f))
1453 /* Remove all scroll bars because they have wrong colors. */
1454 if (condemn_scroll_bars_hook)
1455 (*condemn_scroll_bars_hook) (f);
1456 if (judge_scroll_bars_hook)
1457 (*judge_scroll_bars_hook) (f);
1459 update_face_from_frame_parameter (f, Qscroll_bar_foreground, value);
1460 redraw_frame (f);
1465 /* Set the background color for scroll bars on frame F to VALUE VALUE
1466 should be a string, a color name. If it isn't a string or isn't a
1467 valid color name, do nothing. OLDVAL is the old value of the frame
1468 parameter. */
1470 void
1471 x_set_scroll_bar_background (f, value, oldval)
1472 struct frame *f;
1473 Lisp_Object value, oldval;
1475 unsigned long pixel;
1477 if (STRINGP (value))
1478 pixel = x_decode_color (f, value, WHITE_PIX_DEFAULT (f));
1479 else
1480 pixel = -1;
1482 if (f->output_data.x->scroll_bar_background_pixel != -1)
1483 unload_color (f, f->output_data.x->scroll_bar_background_pixel);
1485 #ifdef USE_TOOLKIT_SCROLL_BARS
1486 /* Scrollbar shadow colors. */
1487 if (f->output_data.x->scroll_bar_top_shadow_pixel != -1)
1489 unload_color (f, f->output_data.x->scroll_bar_top_shadow_pixel);
1490 f->output_data.x->scroll_bar_top_shadow_pixel = -1;
1492 if (f->output_data.x->scroll_bar_bottom_shadow_pixel != -1)
1494 unload_color (f, f->output_data.x->scroll_bar_bottom_shadow_pixel);
1495 f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
1497 #endif /* USE_TOOLKIT_SCROLL_BARS */
1499 f->output_data.x->scroll_bar_background_pixel = pixel;
1500 if (FRAME_X_WINDOW (f) && FRAME_VISIBLE_P (f))
1502 /* Remove all scroll bars because they have wrong colors. */
1503 if (condemn_scroll_bars_hook)
1504 (*condemn_scroll_bars_hook) (f);
1505 if (judge_scroll_bars_hook)
1506 (*judge_scroll_bars_hook) (f);
1508 update_face_from_frame_parameter (f, Qscroll_bar_background, value);
1509 redraw_frame (f);
1514 /* Encode Lisp string STRING as a text in a format appropriate for
1515 XICCC (X Inter Client Communication Conventions).
1517 If STRING contains only ASCII characters, do no conversion and
1518 return the string data of STRING. Otherwise, encode the text by
1519 CODING_SYSTEM, and return a newly allocated memory area which
1520 should be freed by `xfree' by a caller.
1522 SELECTIONP non-zero means the string is being encoded for an X
1523 selection, so it is safe to run pre-write conversions (which
1524 may run Lisp code).
1526 Store the byte length of resulting text in *TEXT_BYTES.
1528 If the text contains only ASCII and Latin-1, store 1 in *STRING_P,
1529 which means that the `encoding' of the result can be `STRING'.
1530 Otherwise store 0 in *STRINGP, which means that the `encoding' of
1531 the result should be `COMPOUND_TEXT'. */
1533 static unsigned char *
1534 x_encode_text (string, coding_system, selectionp, text_bytes, stringp, freep)
1535 Lisp_Object string, coding_system;
1536 int *text_bytes, *stringp;
1537 int selectionp;
1538 int *freep;
1540 unsigned char *str = SDATA (string);
1541 int chars = SCHARS (string);
1542 int bytes = SBYTES (string);
1543 int charset_info;
1544 int bufsize;
1545 unsigned char *buf;
1546 struct coding_system coding;
1547 extern Lisp_Object Qcompound_text_with_extensions;
1549 charset_info = find_charset_in_text (str, chars, bytes, NULL, Qnil);
1550 if (charset_info == 0)
1552 /* No multibyte character in OBJ. We need not encode it. */
1553 *text_bytes = bytes;
1554 *stringp = 1;
1555 *freep = 0;
1556 return str;
1559 setup_coding_system (coding_system, &coding);
1560 if (selectionp
1561 && SYMBOLP (coding.pre_write_conversion)
1562 && !NILP (Ffboundp (coding.pre_write_conversion)))
1564 string = run_pre_post_conversion_on_str (string, &coding, 1);
1565 str = SDATA (string);
1566 chars = SCHARS (string);
1567 bytes = SBYTES (string);
1569 coding.src_multibyte = 1;
1570 coding.dst_multibyte = 0;
1571 coding.mode |= CODING_MODE_LAST_BLOCK;
1572 if (coding.type == coding_type_iso2022)
1573 coding.flags |= CODING_FLAG_ISO_SAFE;
1574 /* We suppress producing escape sequences for composition. */
1575 coding.composing = COMPOSITION_DISABLED;
1576 bufsize = encoding_buffer_size (&coding, bytes);
1577 buf = (unsigned char *) xmalloc (bufsize);
1578 encode_coding (&coding, str, buf, bytes, bufsize);
1579 *text_bytes = coding.produced;
1580 *stringp = (charset_info == 1
1581 || (!EQ (coding_system, Qcompound_text)
1582 && !EQ (coding_system, Qcompound_text_with_extensions)));
1583 *freep = 1;
1584 return buf;
1588 /* Set the WM name to NAME for frame F. Also set the icon name.
1589 If the frame already has an icon name, use that, otherwise set the
1590 icon name to NAME. */
1592 static void
1593 x_set_name_internal (f, name)
1594 FRAME_PTR f;
1595 Lisp_Object name;
1597 if (FRAME_X_WINDOW (f))
1599 BLOCK_INPUT;
1600 #ifdef HAVE_X11R4
1602 XTextProperty text, icon;
1603 int bytes, stringp;
1604 int do_free_icon_value = 0, do_free_text_value = 0;
1605 Lisp_Object coding_system;
1607 coding_system = Qcompound_text;
1608 /* Note: Encoding strategy
1610 We encode NAME by compound-text and use "COMPOUND-TEXT" in
1611 text.encoding. But, there are non-internationalized window
1612 managers which don't support that encoding. So, if NAME
1613 contains only ASCII and 8859-1 characters, encode it by
1614 iso-latin-1, and use "STRING" in text.encoding hoping that
1615 such window managers at least analyze this format correctly,
1616 i.e. treat 8-bit bytes as 8859-1 characters.
1618 We may also be able to use "UTF8_STRING" in text.encoding
1619 in the future which can encode all Unicode characters.
1620 But, for the moment, there's no way to know that the
1621 current window manager supports it or not. */
1622 text.value = x_encode_text (name, coding_system, 0, &bytes, &stringp,
1623 &do_free_text_value);
1624 text.encoding = (stringp ? XA_STRING
1625 : FRAME_X_DISPLAY_INFO (f)->Xatom_COMPOUND_TEXT);
1626 text.format = 8;
1627 text.nitems = bytes;
1629 if (!STRINGP (f->icon_name))
1631 icon = text;
1633 else
1635 /* See the above comment "Note: Encoding strategy". */
1636 icon.value = x_encode_text (f->icon_name, coding_system, 0,
1637 &bytes, &stringp, &do_free_icon_value);
1638 icon.encoding = (stringp ? XA_STRING
1639 : FRAME_X_DISPLAY_INFO (f)->Xatom_COMPOUND_TEXT);
1640 icon.format = 8;
1641 icon.nitems = bytes;
1644 #ifdef USE_GTK
1645 gtk_window_set_title (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f)),
1646 (char *) SDATA (ENCODE_UTF_8 (name)));
1647 #else /* not USE_GTK */
1648 XSetWMName (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &text);
1649 #endif /* not USE_GTK */
1651 XSetWMIconName (FRAME_X_DISPLAY (f), FRAME_OUTER_WINDOW (f), &icon);
1653 if (do_free_icon_value)
1654 xfree (icon.value);
1655 if (do_free_text_value)
1656 xfree (text.value);
1658 #else /* not HAVE_X11R4 */
1659 XSetIconName (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1660 SDATA (name));
1661 XStoreName (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
1662 SDATA (name));
1663 #endif /* not HAVE_X11R4 */
1664 UNBLOCK_INPUT;
1668 /* Change the name of frame F to NAME. If NAME is nil, set F's name to
1669 x_id_name.
1671 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1672 name; if NAME is a string, set F's name to NAME and set
1673 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1675 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1676 suggesting a new name, which lisp code should override; if
1677 F->explicit_name is set, ignore the new name; otherwise, set it. */
1679 void
1680 x_set_name (f, name, explicit)
1681 struct frame *f;
1682 Lisp_Object name;
1683 int explicit;
1685 /* Make sure that requests from lisp code override requests from
1686 Emacs redisplay code. */
1687 if (explicit)
1689 /* If we're switching from explicit to implicit, we had better
1690 update the mode lines and thereby update the title. */
1691 if (f->explicit_name && NILP (name))
1692 update_mode_lines = 1;
1694 f->explicit_name = ! NILP (name);
1696 else if (f->explicit_name)
1697 return;
1699 /* If NAME is nil, set the name to the x_id_name. */
1700 if (NILP (name))
1702 /* Check for no change needed in this very common case
1703 before we do any consing. */
1704 if (!strcmp (FRAME_X_DISPLAY_INFO (f)->x_id_name,
1705 SDATA (f->name)))
1706 return;
1707 name = build_string (FRAME_X_DISPLAY_INFO (f)->x_id_name);
1709 else
1710 CHECK_STRING (name);
1712 /* Don't change the name if it's already NAME. */
1713 if (! NILP (Fstring_equal (name, f->name)))
1714 return;
1716 f->name = name;
1718 /* For setting the frame title, the title parameter should override
1719 the name parameter. */
1720 if (! NILP (f->title))
1721 name = f->title;
1723 x_set_name_internal (f, name);
1726 /* This function should be called when the user's lisp code has
1727 specified a name for the frame; the name will override any set by the
1728 redisplay code. */
1729 void
1730 x_explicitly_set_name (f, arg, oldval)
1731 FRAME_PTR f;
1732 Lisp_Object arg, oldval;
1734 x_set_name (f, arg, 1);
1737 /* This function should be called by Emacs redisplay code to set the
1738 name; names set this way will never override names set by the user's
1739 lisp code. */
1740 void
1741 x_implicitly_set_name (f, arg, oldval)
1742 FRAME_PTR f;
1743 Lisp_Object arg, oldval;
1745 x_set_name (f, arg, 0);
1748 /* Change the title of frame F to NAME.
1749 If NAME is nil, use the frame name as the title.
1751 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1752 name; if NAME is a string, set F's name to NAME and set
1753 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1755 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1756 suggesting a new name, which lisp code should override; if
1757 F->explicit_name is set, ignore the new name; otherwise, set it. */
1759 void
1760 x_set_title (f, name, old_name)
1761 struct frame *f;
1762 Lisp_Object name, old_name;
1764 /* Don't change the title if it's already NAME. */
1765 if (EQ (name, f->title))
1766 return;
1768 update_mode_lines = 1;
1770 f->title = name;
1772 if (NILP (name))
1773 name = f->name;
1774 else
1775 CHECK_STRING (name);
1777 x_set_name_internal (f, name);
1780 void
1781 x_set_scroll_bar_default_width (f)
1782 struct frame *f;
1784 int wid = FRAME_COLUMN_WIDTH (f);
1786 #ifdef USE_TOOLKIT_SCROLL_BARS
1787 /* A minimum width of 14 doesn't look good for toolkit scroll bars. */
1788 int width = 16 + 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM;
1789 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (width + wid - 1) / wid;
1790 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = width;
1791 #else
1792 /* Make the actual width at least 14 pixels and a multiple of a
1793 character width. */
1794 FRAME_CONFIG_SCROLL_BAR_COLS (f) = (14 + wid - 1) / wid;
1796 /* Use all of that space (aside from required margins) for the
1797 scroll bar. */
1798 FRAME_CONFIG_SCROLL_BAR_WIDTH (f) = 0;
1799 #endif
1803 /* Record in frame F the specified or default value according to ALIST
1804 of the parameter named PROP (a Lisp symbol). If no value is
1805 specified for PROP, look for an X default for XPROP on the frame
1806 named NAME. If that is not found either, use the value DEFLT. */
1808 static Lisp_Object
1809 x_default_scroll_bar_color_parameter (f, alist, prop, xprop, xclass,
1810 foreground_p)
1811 struct frame *f;
1812 Lisp_Object alist;
1813 Lisp_Object prop;
1814 char *xprop;
1815 char *xclass;
1816 int foreground_p;
1818 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
1819 Lisp_Object tem;
1821 tem = x_get_arg (dpyinfo, alist, prop, xprop, xclass, RES_TYPE_STRING);
1822 if (EQ (tem, Qunbound))
1824 #ifdef USE_TOOLKIT_SCROLL_BARS
1826 /* See if an X resource for the scroll bar color has been
1827 specified. */
1828 tem = display_x_get_resource (dpyinfo,
1829 build_string (foreground_p
1830 ? "foreground"
1831 : "background"),
1832 empty_string,
1833 build_string ("verticalScrollBar"),
1834 empty_string);
1835 if (!STRINGP (tem))
1837 /* If nothing has been specified, scroll bars will use a
1838 toolkit-dependent default. Because these defaults are
1839 difficult to get at without actually creating a scroll
1840 bar, use nil to indicate that no color has been
1841 specified. */
1842 tem = Qnil;
1845 #else /* not USE_TOOLKIT_SCROLL_BARS */
1847 tem = Qnil;
1849 #endif /* not USE_TOOLKIT_SCROLL_BARS */
1852 x_set_frame_parameters (f, Fcons (Fcons (prop, tem), Qnil));
1853 return tem;
1858 #if !defined (HAVE_X11R4) && !defined (HAVE_XSETWMPROTOCOLS)
1860 Status
1861 XSetWMProtocols (dpy, w, protocols, count)
1862 Display *dpy;
1863 Window w;
1864 Atom *protocols;
1865 int count;
1867 Atom prop;
1868 prop = XInternAtom (dpy, "WM_PROTOCOLS", False);
1869 if (prop == None) return False;
1870 XChangeProperty (dpy, w, prop, XA_ATOM, 32, PropModeReplace,
1871 (unsigned char *) protocols, count);
1872 return True;
1874 #endif /* not HAVE_X11R4 && not HAVE_XSETWMPROTOCOLS */
1876 #ifdef USE_X_TOOLKIT
1878 /* If the WM_PROTOCOLS property does not already contain WM_TAKE_FOCUS,
1879 WM_DELETE_WINDOW, and WM_SAVE_YOURSELF, then add them. (They may
1880 already be present because of the toolkit (Motif adds some of them,
1881 for example, but Xt doesn't). */
1883 static void
1884 hack_wm_protocols (f, widget)
1885 FRAME_PTR f;
1886 Widget widget;
1888 Display *dpy = XtDisplay (widget);
1889 Window w = XtWindow (widget);
1890 int need_delete = 1;
1891 int need_focus = 1;
1892 int need_save = 1;
1894 BLOCK_INPUT;
1896 Atom type;
1897 unsigned char *catoms;
1898 int format = 0;
1899 unsigned long nitems = 0;
1900 unsigned long bytes_after;
1902 if ((XGetWindowProperty (dpy, w,
1903 FRAME_X_DISPLAY_INFO (f)->Xatom_wm_protocols,
1904 (long)0, (long)100, False, XA_ATOM,
1905 &type, &format, &nitems, &bytes_after,
1906 &catoms)
1907 == Success)
1908 && format == 32 && type == XA_ATOM)
1910 Atom *atoms = (Atom *) catoms;
1911 while (nitems > 0)
1913 nitems--;
1914 if (atoms[nitems]
1915 == FRAME_X_DISPLAY_INFO (f)->Xatom_wm_delete_window)
1916 need_delete = 0;
1917 else if (atoms[nitems]
1918 == FRAME_X_DISPLAY_INFO (f)->Xatom_wm_take_focus)
1919 need_focus = 0;
1920 else if (atoms[nitems]
1921 == FRAME_X_DISPLAY_INFO (f)->Xatom_wm_save_yourself)
1922 need_save = 0;
1925 if (catoms)
1926 XFree (catoms);
1929 Atom props [10];
1930 int count = 0;
1931 if (need_delete)
1932 props[count++] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_delete_window;
1933 if (need_focus)
1934 props[count++] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_take_focus;
1935 if (need_save)
1936 props[count++] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_save_yourself;
1937 if (count)
1938 XChangeProperty (dpy, w, FRAME_X_DISPLAY_INFO (f)->Xatom_wm_protocols,
1939 XA_ATOM, 32, PropModeAppend,
1940 (unsigned char *) props, count);
1942 UNBLOCK_INPUT;
1944 #endif
1948 /* Support routines for XIC (X Input Context). */
1950 #ifdef HAVE_X_I18N
1952 static XFontSet xic_create_xfontset P_ ((struct frame *, char *));
1953 static XIMStyle best_xim_style P_ ((XIMStyles *, XIMStyles *));
1956 /* Supported XIM styles, ordered by preference. */
1958 static XIMStyle supported_xim_styles[] =
1960 XIMPreeditPosition | XIMStatusArea,
1961 XIMPreeditPosition | XIMStatusNothing,
1962 XIMPreeditPosition | XIMStatusNone,
1963 XIMPreeditNothing | XIMStatusArea,
1964 XIMPreeditNothing | XIMStatusNothing,
1965 XIMPreeditNothing | XIMStatusNone,
1966 XIMPreeditNone | XIMStatusArea,
1967 XIMPreeditNone | XIMStatusNothing,
1968 XIMPreeditNone | XIMStatusNone,
1973 /* Create an X fontset on frame F with base font name BASE_FONTNAME. */
1975 char xic_defaut_fontset[] = "-*-*-*-r-normal--14-*-*-*-*-*-*-*";
1977 /* Create an Xt fontset spec from the name of a base font.
1978 If `motif' is True use the Motif syntax. */
1979 char *
1980 xic_create_fontsetname (base_fontname, motif)
1981 char *base_fontname;
1982 Bool motif;
1984 const char *sep = motif ? ";" : ",";
1985 char *fontsetname;
1987 /* Make a fontset name from the base font name. */
1988 if (xic_defaut_fontset == base_fontname)
1989 { /* There is no base font name, use the default. */
1990 int len = strlen (base_fontname) + 2;
1991 fontsetname = xmalloc (len);
1992 bzero (fontsetname, len);
1993 strcpy (fontsetname, base_fontname);
1995 else
1997 /* Make a fontset name from the base font name.
1998 The font set will be made of the following elements:
1999 - the base font.
2000 - the base font where the charset spec is replaced by -*-*.
2001 - the same but with the family also replaced with -*-*-. */
2002 char *p = base_fontname;
2003 int i;
2005 for (i = 0; *p; p++)
2006 if (*p == '-') i++;
2007 if (i != 14)
2008 { /* As the font name doesn't conform to XLFD, we can't
2009 modify it to generalize it to allcs and allfamilies.
2010 Use the specified font plus the default. */
2011 int len = strlen (base_fontname) + strlen (xic_defaut_fontset) + 3;
2012 fontsetname = xmalloc (len);
2013 bzero (fontsetname, len);
2014 strcpy (fontsetname, base_fontname);
2015 strcat (fontsetname, sep);
2016 strcat (fontsetname, xic_defaut_fontset);
2018 else
2020 int len;
2021 char *p1 = NULL, *p2 = NULL;
2022 char *font_allcs = NULL;
2023 char *font_allfamilies = NULL;
2024 char *font_all = NULL;
2025 char *allcs = "*-*-*-*-*-*-*";
2026 char *allfamilies = "-*-*-";
2027 char *all = "*-*-*-*-";
2029 for (i = 0, p = base_fontname; i < 8; p++)
2031 if (*p == '-')
2033 i++;
2034 if (i == 3)
2035 p1 = p + 1;
2036 else if (i == 7)
2037 p2 = p + 1;
2040 /* Build the font spec that matches all charsets. */
2041 len = p - base_fontname + strlen (allcs) + 1;
2042 font_allcs = (char *) alloca (len);
2043 bzero (font_allcs, len);
2044 bcopy (base_fontname, font_allcs, p - base_fontname);
2045 strcat (font_allcs, allcs);
2047 /* Build the font spec that matches all families. */
2048 len = p - p1 + strlen (allcs) + strlen (allfamilies) + 1;
2049 font_allfamilies = (char *) alloca (len);
2050 bzero (font_allfamilies, len);
2051 strcpy (font_allfamilies, allfamilies);
2052 bcopy (p1, font_allfamilies + strlen (allfamilies), p - p1);
2053 strcat (font_allfamilies, allcs);
2055 /* Build the font spec that matches all. */
2056 len = p - p2 + strlen (allcs) + strlen (all) + strlen (allfamilies) + 1;
2057 font_all = (char *) alloca (len);
2058 bzero (font_all, len);
2059 strcpy (font_all, allfamilies);
2060 strcat (font_all, all);
2061 bcopy (p2, font_all + strlen (all) + strlen (allfamilies), p - p2);
2062 strcat (font_all, allcs);
2064 /* Build the actual font set name. */
2065 len = strlen (base_fontname) + strlen (font_allcs)
2066 + strlen (font_allfamilies) + strlen (font_all) + 5;
2067 fontsetname = xmalloc (len);
2068 bzero (fontsetname, len);
2069 strcpy (fontsetname, base_fontname);
2070 strcat (fontsetname, sep);
2071 strcat (fontsetname, font_allcs);
2072 strcat (fontsetname, sep);
2073 strcat (fontsetname, font_allfamilies);
2074 strcat (fontsetname, sep);
2075 strcat (fontsetname, font_all);
2078 if (motif)
2079 strcat (fontsetname, ":");
2080 return fontsetname;
2083 static XFontSet
2084 xic_create_xfontset (f, base_fontname)
2085 struct frame *f;
2086 char *base_fontname;
2088 XFontSet xfs = NULL;
2089 char **missing_list = NULL;
2090 int missing_count;
2091 char *def_string;
2092 Lisp_Object rest, frame;
2094 if (!base_fontname)
2095 base_fontname = xic_defaut_fontset;
2097 /* See if there is another frame already using same fontset. */
2098 FOR_EACH_FRAME (rest, frame)
2100 struct frame *cf = XFRAME (frame);
2101 if (cf != f && FRAME_LIVE_P (f) && FRAME_X_P (cf)
2102 && FRAME_X_DISPLAY_INFO (cf) == FRAME_X_DISPLAY_INFO (f)
2103 && FRAME_XIC_BASE_FONTNAME (cf)
2104 && !strcmp (FRAME_XIC_BASE_FONTNAME (cf), base_fontname))
2106 xfs = FRAME_XIC_FONTSET (cf);
2107 break;
2111 if (!xfs)
2113 char *fontsetname = xic_create_fontsetname (base_fontname, False);
2115 /* New fontset. */
2116 xfs = XCreateFontSet (FRAME_X_DISPLAY (f),
2117 fontsetname, &missing_list,
2118 &missing_count, &def_string);
2119 if (missing_list)
2120 XFreeStringList (missing_list);
2121 xfree (fontsetname);
2124 if (FRAME_XIC_BASE_FONTNAME (f))
2125 xfree (FRAME_XIC_BASE_FONTNAME (f));
2126 FRAME_XIC_BASE_FONTNAME (f) = xstrdup (base_fontname);
2128 /* No need to free def_string. */
2129 return xfs;
2132 /* Free the X fontset of frame F if it is the last frame using it. */
2134 void
2135 xic_free_xfontset (f)
2136 struct frame *f;
2138 Lisp_Object rest, frame;
2139 int shared_p = 0;
2141 if (!FRAME_XIC_FONTSET (f))
2142 return;
2144 /* See if there is another frame sharing the same fontset. */
2145 FOR_EACH_FRAME (rest, frame)
2147 struct frame *cf = XFRAME (frame);
2148 if (cf != f && FRAME_LIVE_P (f) && FRAME_X_P (cf)
2149 && FRAME_X_DISPLAY_INFO (cf) == FRAME_X_DISPLAY_INFO (f)
2150 && FRAME_XIC_FONTSET (cf) == FRAME_XIC_FONTSET (f))
2152 shared_p = 1;
2153 break;
2157 if (!shared_p)
2158 /* The fontset is not used anymore. It is safe to free it. */
2159 XFreeFontSet (FRAME_X_DISPLAY (f), FRAME_XIC_FONTSET (f));
2161 if (FRAME_XIC_BASE_FONTNAME (f))
2162 xfree (FRAME_XIC_BASE_FONTNAME (f));
2163 FRAME_XIC_BASE_FONTNAME (f) = NULL;
2164 FRAME_XIC_FONTSET (f) = NULL;
2168 /* Value is the best input style, given user preferences USER (already
2169 checked to be supported by Emacs), and styles supported by the
2170 input method XIM. */
2172 static XIMStyle
2173 best_xim_style (user, xim)
2174 XIMStyles *user;
2175 XIMStyles *xim;
2177 int i, j;
2179 for (i = 0; i < user->count_styles; ++i)
2180 for (j = 0; j < xim->count_styles; ++j)
2181 if (user->supported_styles[i] == xim->supported_styles[j])
2182 return user->supported_styles[i];
2184 /* Return the default style. */
2185 return XIMPreeditNothing | XIMStatusNothing;
2188 /* Create XIC for frame F. */
2190 static XIMStyle xic_style;
2192 void
2193 create_frame_xic (f)
2194 struct frame *f;
2196 XIM xim;
2197 XIC xic = NULL;
2198 XFontSet xfs = NULL;
2200 if (FRAME_XIC (f))
2201 return;
2203 /* Create X fontset. */
2204 xfs = xic_create_xfontset
2205 (f, (FRAME_FONTSET (f) < 0) ? NULL
2206 : (char *) SDATA (fontset_ascii (FRAME_FONTSET (f))));
2208 xim = FRAME_X_XIM (f);
2209 if (xim)
2211 XRectangle s_area;
2212 XPoint spot;
2213 XVaNestedList preedit_attr;
2214 XVaNestedList status_attr;
2216 s_area.x = 0; s_area.y = 0; s_area.width = 1; s_area.height = 1;
2217 spot.x = 0; spot.y = 1;
2219 /* Determine XIC style. */
2220 if (xic_style == 0)
2222 XIMStyles supported_list;
2223 supported_list.count_styles = (sizeof supported_xim_styles
2224 / sizeof supported_xim_styles[0]);
2225 supported_list.supported_styles = supported_xim_styles;
2226 xic_style = best_xim_style (&supported_list,
2227 FRAME_X_XIM_STYLES (f));
2230 preedit_attr = XVaCreateNestedList (0,
2231 XNFontSet, xfs,
2232 XNForeground,
2233 FRAME_FOREGROUND_PIXEL (f),
2234 XNBackground,
2235 FRAME_BACKGROUND_PIXEL (f),
2236 (xic_style & XIMPreeditPosition
2237 ? XNSpotLocation
2238 : NULL),
2239 &spot,
2240 NULL);
2241 status_attr = XVaCreateNestedList (0,
2242 XNArea,
2243 &s_area,
2244 XNFontSet,
2245 xfs,
2246 XNForeground,
2247 FRAME_FOREGROUND_PIXEL (f),
2248 XNBackground,
2249 FRAME_BACKGROUND_PIXEL (f),
2250 NULL);
2252 xic = XCreateIC (xim,
2253 XNInputStyle, xic_style,
2254 XNClientWindow, FRAME_X_WINDOW (f),
2255 XNFocusWindow, FRAME_X_WINDOW (f),
2256 XNStatusAttributes, status_attr,
2257 XNPreeditAttributes, preedit_attr,
2258 NULL);
2259 XFree (preedit_attr);
2260 XFree (status_attr);
2263 FRAME_XIC (f) = xic;
2264 FRAME_XIC_STYLE (f) = xic_style;
2265 FRAME_XIC_FONTSET (f) = xfs;
2269 /* Destroy XIC and free XIC fontset of frame F, if any. */
2271 void
2272 free_frame_xic (f)
2273 struct frame *f;
2275 if (FRAME_XIC (f) == NULL)
2276 return;
2278 XDestroyIC (FRAME_XIC (f));
2279 xic_free_xfontset (f);
2281 FRAME_XIC (f) = NULL;
2285 /* Place preedit area for XIC of window W's frame to specified
2286 pixel position X/Y. X and Y are relative to window W. */
2288 void
2289 xic_set_preeditarea (w, x, y)
2290 struct window *w;
2291 int x, y;
2293 struct frame *f = XFRAME (w->frame);
2294 XVaNestedList attr;
2295 XPoint spot;
2297 spot.x = WINDOW_TO_FRAME_PIXEL_X (w, x) + WINDOW_LEFT_FRINGE_WIDTH (w);
2298 spot.y = WINDOW_TO_FRAME_PIXEL_Y (w, y) + FONT_BASE (FRAME_FONT (f));
2299 attr = XVaCreateNestedList (0, XNSpotLocation, &spot, NULL);
2300 XSetICValues (FRAME_XIC (f), XNPreeditAttributes, attr, NULL);
2301 XFree (attr);
2305 /* Place status area for XIC in bottom right corner of frame F.. */
2307 void
2308 xic_set_statusarea (f)
2309 struct frame *f;
2311 XIC xic = FRAME_XIC (f);
2312 XVaNestedList attr;
2313 XRectangle area;
2314 XRectangle *needed;
2316 /* Negotiate geometry of status area. If input method has existing
2317 status area, use its current size. */
2318 area.x = area.y = area.width = area.height = 0;
2319 attr = XVaCreateNestedList (0, XNAreaNeeded, &area, NULL);
2320 XSetICValues (xic, XNStatusAttributes, attr, NULL);
2321 XFree (attr);
2323 attr = XVaCreateNestedList (0, XNAreaNeeded, &needed, NULL);
2324 XGetICValues (xic, XNStatusAttributes, attr, NULL);
2325 XFree (attr);
2327 if (needed->width == 0) /* Use XNArea instead of XNAreaNeeded */
2329 attr = XVaCreateNestedList (0, XNArea, &needed, NULL);
2330 XGetICValues (xic, XNStatusAttributes, attr, NULL);
2331 XFree (attr);
2334 area.width = needed->width;
2335 area.height = needed->height;
2336 area.x = FRAME_PIXEL_WIDTH (f) - area.width - FRAME_INTERNAL_BORDER_WIDTH (f);
2337 area.y = (FRAME_PIXEL_HEIGHT (f) - area.height
2338 - FRAME_MENUBAR_HEIGHT (f)
2339 - FRAME_TOOLBAR_HEIGHT (f)
2340 - FRAME_INTERNAL_BORDER_WIDTH (f));
2341 XFree (needed);
2343 attr = XVaCreateNestedList (0, XNArea, &area, NULL);
2344 XSetICValues (xic, XNStatusAttributes, attr, NULL);
2345 XFree (attr);
2349 /* Set X fontset for XIC of frame F, using base font name
2350 BASE_FONTNAME. Called when a new Emacs fontset is chosen. */
2352 void
2353 xic_set_xfontset (f, base_fontname)
2354 struct frame *f;
2355 char *base_fontname;
2357 XVaNestedList attr;
2358 XFontSet xfs;
2360 xic_free_xfontset (f);
2362 xfs = xic_create_xfontset (f, base_fontname);
2364 attr = XVaCreateNestedList (0, XNFontSet, xfs, NULL);
2365 if (FRAME_XIC_STYLE (f) & XIMPreeditPosition)
2366 XSetICValues (FRAME_XIC (f), XNPreeditAttributes, attr, NULL);
2367 if (FRAME_XIC_STYLE (f) & XIMStatusArea)
2368 XSetICValues (FRAME_XIC (f), XNStatusAttributes, attr, NULL);
2369 XFree (attr);
2371 FRAME_XIC_FONTSET (f) = xfs;
2374 #endif /* HAVE_X_I18N */
2378 #ifdef USE_X_TOOLKIT
2380 /* Create and set up the X widget for frame F. */
2382 static void
2383 x_window (f, window_prompting, minibuffer_only)
2384 struct frame *f;
2385 long window_prompting;
2386 int minibuffer_only;
2388 XClassHint class_hints;
2389 XSetWindowAttributes attributes;
2390 unsigned long attribute_mask;
2391 Widget shell_widget;
2392 Widget pane_widget;
2393 Widget frame_widget;
2394 Arg al [25];
2395 int ac;
2397 BLOCK_INPUT;
2399 /* Use the resource name as the top-level widget name
2400 for looking up resources. Make a non-Lisp copy
2401 for the window manager, so GC relocation won't bother it.
2403 Elsewhere we specify the window name for the window manager. */
2406 char *str = (char *) SDATA (Vx_resource_name);
2407 f->namebuf = (char *) xmalloc (strlen (str) + 1);
2408 strcpy (f->namebuf, str);
2411 ac = 0;
2412 XtSetArg (al[ac], XtNallowShellResize, 1); ac++;
2413 XtSetArg (al[ac], XtNinput, 1); ac++;
2414 XtSetArg (al[ac], XtNmappedWhenManaged, 0); ac++;
2415 XtSetArg (al[ac], XtNborderWidth, f->border_width); ac++;
2416 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2417 XtSetArg (al[ac], XtNdepth, FRAME_X_DISPLAY_INFO (f)->n_planes); ac++;
2418 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2419 shell_widget = XtAppCreateShell (f->namebuf, EMACS_CLASS,
2420 applicationShellWidgetClass,
2421 FRAME_X_DISPLAY (f), al, ac);
2423 f->output_data.x->widget = shell_widget;
2424 /* maybe_set_screen_title_format (shell_widget); */
2426 pane_widget = lw_create_widget ("main", "pane", widget_id_tick++,
2427 (widget_value *) NULL,
2428 shell_widget, False,
2429 (lw_callback) NULL,
2430 (lw_callback) NULL,
2431 (lw_callback) NULL,
2432 (lw_callback) NULL);
2434 ac = 0;
2435 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2436 XtSetArg (al[ac], XtNdepth, FRAME_X_DISPLAY_INFO (f)->n_planes); ac++;
2437 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2438 XtSetValues (pane_widget, al, ac);
2439 f->output_data.x->column_widget = pane_widget;
2441 /* mappedWhenManaged to false tells to the paned window to not map/unmap
2442 the emacs screen when changing menubar. This reduces flickering. */
2444 ac = 0;
2445 XtSetArg (al[ac], XtNmappedWhenManaged, 0); ac++;
2446 XtSetArg (al[ac], XtNshowGrip, 0); ac++;
2447 XtSetArg (al[ac], XtNallowResize, 1); ac++;
2448 XtSetArg (al[ac], XtNresizeToPreferred, 1); ac++;
2449 XtSetArg (al[ac], XtNemacsFrame, f); ac++;
2450 XtSetArg (al[ac], XtNvisual, FRAME_X_VISUAL (f)); ac++;
2451 XtSetArg (al[ac], XtNdepth, FRAME_X_DISPLAY_INFO (f)->n_planes); ac++;
2452 XtSetArg (al[ac], XtNcolormap, FRAME_X_COLORMAP (f)); ac++;
2453 frame_widget = XtCreateWidget (f->namebuf, emacsFrameClass, pane_widget,
2454 al, ac);
2456 f->output_data.x->edit_widget = frame_widget;
2458 XtManageChild (frame_widget);
2460 /* Do some needed geometry management. */
2462 int len;
2463 char *tem, shell_position[32];
2464 Arg al[10];
2465 int ac = 0;
2466 int extra_borders = 0;
2467 int menubar_size
2468 = (f->output_data.x->menubar_widget
2469 ? (f->output_data.x->menubar_widget->core.height
2470 + f->output_data.x->menubar_widget->core.border_width)
2471 : 0);
2473 #if 0 /* Experimentally, we now get the right results
2474 for -geometry -0-0 without this. 24 Aug 96, rms. */
2475 if (FRAME_EXTERNAL_MENU_BAR (f))
2477 Dimension ibw = 0;
2478 XtVaGetValues (pane_widget, XtNinternalBorderWidth, &ibw, NULL);
2479 menubar_size += ibw;
2481 #endif
2483 f->output_data.x->menubar_height = menubar_size;
2485 #ifndef USE_LUCID
2486 /* Motif seems to need this amount added to the sizes
2487 specified for the shell widget. The Athena/Lucid widgets don't.
2488 Both conclusions reached experimentally. -- rms. */
2489 XtVaGetValues (f->output_data.x->edit_widget, XtNinternalBorderWidth,
2490 &extra_borders, NULL);
2491 extra_borders *= 2;
2492 #endif
2494 /* Convert our geometry parameters into a geometry string
2495 and specify it.
2496 Note that we do not specify here whether the position
2497 is a user-specified or program-specified one.
2498 We pass that information later, in x_wm_set_size_hints. */
2500 int left = f->left_pos;
2501 int xneg = window_prompting & XNegative;
2502 int top = f->top_pos;
2503 int yneg = window_prompting & YNegative;
2504 if (xneg)
2505 left = -left;
2506 if (yneg)
2507 top = -top;
2509 if (window_prompting & USPosition)
2510 sprintf (shell_position, "=%dx%d%c%d%c%d",
2511 FRAME_PIXEL_WIDTH (f) + extra_borders,
2512 FRAME_PIXEL_HEIGHT (f) + menubar_size + extra_borders,
2513 (xneg ? '-' : '+'), left,
2514 (yneg ? '-' : '+'), top);
2515 else
2517 sprintf (shell_position, "=%dx%d",
2518 FRAME_PIXEL_WIDTH (f) + extra_borders,
2519 FRAME_PIXEL_HEIGHT (f) + menubar_size + extra_borders);
2521 /* Setting x and y when the position is not specified in
2522 the geometry string will set program position in the WM hints.
2523 If Emacs had just one program position, we could set it in
2524 fallback resources, but since each make-frame call can specify
2525 different program positions, this is easier. */
2526 XtSetArg (al[ac], XtNx, left); ac++;
2527 XtSetArg (al[ac], XtNy, top); ac++;
2531 len = strlen (shell_position) + 1;
2532 /* We don't free this because we don't know whether
2533 it is safe to free it while the frame exists.
2534 It isn't worth the trouble of arranging to free it
2535 when the frame is deleted. */
2536 tem = (char *) xmalloc (len);
2537 strncpy (tem, shell_position, len);
2538 XtSetArg (al[ac], XtNgeometry, tem); ac++;
2539 XtSetValues (shell_widget, al, ac);
2542 XtManageChild (pane_widget);
2543 XtRealizeWidget (shell_widget);
2545 FRAME_X_WINDOW (f) = XtWindow (frame_widget);
2547 validate_x_resource_name ();
2549 class_hints.res_name = (char *) SDATA (Vx_resource_name);
2550 class_hints.res_class = (char *) SDATA (Vx_resource_class);
2551 XSetClassHint (FRAME_X_DISPLAY (f), XtWindow (shell_widget), &class_hints);
2553 #ifdef HAVE_X_I18N
2554 FRAME_XIC (f) = NULL;
2555 if (use_xim)
2556 create_frame_xic (f);
2557 #endif
2559 f->output_data.x->wm_hints.input = True;
2560 f->output_data.x->wm_hints.flags |= InputHint;
2561 XSetWMHints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2562 &f->output_data.x->wm_hints);
2564 hack_wm_protocols (f, shell_widget);
2566 #ifdef HACK_EDITRES
2567 XtAddEventHandler (shell_widget, 0, True, _XEditResCheckMessages, 0);
2568 #endif
2570 /* Do a stupid property change to force the server to generate a
2571 PropertyNotify event so that the event_stream server timestamp will
2572 be initialized to something relevant to the time we created the window.
2574 XChangeProperty (XtDisplay (frame_widget), XtWindow (frame_widget),
2575 FRAME_X_DISPLAY_INFO (f)->Xatom_wm_protocols,
2576 XA_ATOM, 32, PropModeAppend,
2577 (unsigned char*) NULL, 0);
2579 /* Make all the standard events reach the Emacs frame. */
2580 attributes.event_mask = STANDARD_EVENT_SET;
2582 #ifdef HAVE_X_I18N
2583 if (FRAME_XIC (f))
2585 /* XIM server might require some X events. */
2586 unsigned long fevent = NoEventMask;
2587 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2588 attributes.event_mask |= fevent;
2590 #endif /* HAVE_X_I18N */
2592 attribute_mask = CWEventMask;
2593 XChangeWindowAttributes (XtDisplay (shell_widget), XtWindow (shell_widget),
2594 attribute_mask, &attributes);
2596 XtMapWidget (frame_widget);
2598 /* x_set_name normally ignores requests to set the name if the
2599 requested name is the same as the current name. This is the one
2600 place where that assumption isn't correct; f->name is set, but
2601 the X server hasn't been told. */
2603 Lisp_Object name;
2604 int explicit = f->explicit_name;
2606 f->explicit_name = 0;
2607 name = f->name;
2608 f->name = Qnil;
2609 x_set_name (f, name, explicit);
2612 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2613 f->output_data.x->text_cursor);
2615 UNBLOCK_INPUT;
2617 /* This is a no-op, except under Motif. Make sure main areas are
2618 set to something reasonable, in case we get an error later. */
2619 lw_set_main_areas (pane_widget, 0, frame_widget);
2622 #else /* not USE_X_TOOLKIT */
2623 #ifdef USE_GTK
2624 void
2625 x_window (f)
2626 FRAME_PTR f;
2628 if (! xg_create_frame_widgets (f))
2629 error ("Unable to create window");
2631 #ifdef HAVE_X_I18N
2632 FRAME_XIC (f) = NULL;
2633 if (use_xim)
2635 BLOCK_INPUT;
2636 create_frame_xic (f);
2637 if (FRAME_XIC (f))
2639 /* XIM server might require some X events. */
2640 unsigned long fevent = NoEventMask;
2641 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2643 if (fevent != NoEventMask)
2645 XSetWindowAttributes attributes;
2646 XWindowAttributes wattr;
2647 unsigned long attribute_mask;
2649 XGetWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2650 &wattr);
2651 attributes.event_mask = wattr.your_event_mask | fevent;
2652 attribute_mask = CWEventMask;
2653 XChangeWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2654 attribute_mask, &attributes);
2657 UNBLOCK_INPUT;
2659 #endif
2662 #else /*! USE_GTK */
2663 /* Create and set up the X window for frame F. */
2665 void
2666 x_window (f)
2667 struct frame *f;
2670 XClassHint class_hints;
2671 XSetWindowAttributes attributes;
2672 unsigned long attribute_mask;
2674 attributes.background_pixel = f->output_data.x->background_pixel;
2675 attributes.border_pixel = f->output_data.x->border_pixel;
2676 attributes.bit_gravity = StaticGravity;
2677 attributes.backing_store = NotUseful;
2678 attributes.save_under = True;
2679 attributes.event_mask = STANDARD_EVENT_SET;
2680 attributes.colormap = FRAME_X_COLORMAP (f);
2681 attribute_mask = (CWBackPixel | CWBorderPixel | CWBitGravity | CWEventMask
2682 | CWColormap);
2684 BLOCK_INPUT;
2685 FRAME_X_WINDOW (f)
2686 = XCreateWindow (FRAME_X_DISPLAY (f),
2687 f->output_data.x->parent_desc,
2688 f->left_pos,
2689 f->top_pos,
2690 FRAME_PIXEL_WIDTH (f), FRAME_PIXEL_HEIGHT (f),
2691 f->border_width,
2692 CopyFromParent, /* depth */
2693 InputOutput, /* class */
2694 FRAME_X_VISUAL (f),
2695 attribute_mask, &attributes);
2697 #ifdef HAVE_X_I18N
2698 if (use_xim)
2700 create_frame_xic (f);
2701 if (FRAME_XIC (f))
2703 /* XIM server might require some X events. */
2704 unsigned long fevent = NoEventMask;
2705 XGetICValues (FRAME_XIC (f), XNFilterEvents, &fevent, NULL);
2706 attributes.event_mask |= fevent;
2707 attribute_mask = CWEventMask;
2708 XChangeWindowAttributes (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2709 attribute_mask, &attributes);
2712 #endif /* HAVE_X_I18N */
2714 validate_x_resource_name ();
2716 class_hints.res_name = (char *) SDATA (Vx_resource_name);
2717 class_hints.res_class = (char *) SDATA (Vx_resource_class);
2718 XSetClassHint (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), &class_hints);
2720 /* The menubar is part of the ordinary display;
2721 it does not count in addition to the height of the window. */
2722 f->output_data.x->menubar_height = 0;
2724 /* This indicates that we use the "Passive Input" input model.
2725 Unless we do this, we don't get the Focus{In,Out} events that we
2726 need to draw the cursor correctly. Accursed bureaucrats.
2727 XWhipsAndChains (FRAME_X_DISPLAY (f), IronMaiden, &TheRack); */
2729 f->output_data.x->wm_hints.input = True;
2730 f->output_data.x->wm_hints.flags |= InputHint;
2731 XSetWMHints (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2732 &f->output_data.x->wm_hints);
2733 f->output_data.x->wm_hints.icon_pixmap = None;
2735 /* Request "save yourself" and "delete window" commands from wm. */
2737 Atom protocols[2];
2738 protocols[0] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_delete_window;
2739 protocols[1] = FRAME_X_DISPLAY_INFO (f)->Xatom_wm_save_yourself;
2740 XSetWMProtocols (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), protocols, 2);
2743 /* x_set_name normally ignores requests to set the name if the
2744 requested name is the same as the current name. This is the one
2745 place where that assumption isn't correct; f->name is set, but
2746 the X server hasn't been told. */
2748 Lisp_Object name;
2749 int explicit = f->explicit_name;
2751 f->explicit_name = 0;
2752 name = f->name;
2753 f->name = Qnil;
2754 x_set_name (f, name, explicit);
2757 XDefineCursor (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2758 f->output_data.x->text_cursor);
2760 UNBLOCK_INPUT;
2762 if (FRAME_X_WINDOW (f) == 0)
2763 error ("Unable to create window");
2766 #endif /* not USE_GTK */
2767 #endif /* not USE_X_TOOLKIT */
2769 /* Verify that the icon position args for this window are valid. */
2771 static void
2772 x_icon_verify (f, parms)
2773 struct frame *f;
2774 Lisp_Object parms;
2776 Lisp_Object icon_x, icon_y;
2778 /* Set the position of the icon. Note that twm groups all
2779 icons in an icon window. */
2780 icon_x = x_frame_get_and_record_arg (f, parms, Qicon_left, 0, 0, RES_TYPE_NUMBER);
2781 icon_y = x_frame_get_and_record_arg (f, parms, Qicon_top, 0, 0, RES_TYPE_NUMBER);
2782 if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
2784 CHECK_NUMBER (icon_x);
2785 CHECK_NUMBER (icon_y);
2787 else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
2788 error ("Both left and top icon corners of icon must be specified");
2791 /* Handle the icon stuff for this window. Perhaps later we might
2792 want an x_set_icon_position which can be called interactively as
2793 well. */
2795 static void
2796 x_icon (f, parms)
2797 struct frame *f;
2798 Lisp_Object parms;
2800 Lisp_Object icon_x, icon_y;
2801 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
2803 /* Set the position of the icon. Note that twm groups all
2804 icons in an icon window. */
2805 icon_x = x_frame_get_and_record_arg (f, parms, Qicon_left, 0, 0, RES_TYPE_NUMBER);
2806 icon_y = x_frame_get_and_record_arg (f, parms, Qicon_top, 0, 0, RES_TYPE_NUMBER);
2807 if (!EQ (icon_x, Qunbound) && !EQ (icon_y, Qunbound))
2809 CHECK_NUMBER (icon_x);
2810 CHECK_NUMBER (icon_y);
2812 else if (!EQ (icon_x, Qunbound) || !EQ (icon_y, Qunbound))
2813 error ("Both left and top icon corners of icon must be specified");
2815 BLOCK_INPUT;
2817 if (! EQ (icon_x, Qunbound))
2818 x_wm_set_icon_position (f, XINT (icon_x), XINT (icon_y));
2820 #if 0 /* x_get_arg removes the visibility parameter as a side effect,
2821 but x_create_frame still needs it. */
2822 /* Start up iconic or window? */
2823 x_wm_set_window_state
2824 (f, (EQ (x_get_arg (dpyinfo, parms, Qvisibility, 0, 0, RES_TYPE_SYMBOL),
2825 Qicon)
2826 ? IconicState
2827 : NormalState));
2828 #endif
2830 x_text_icon (f, (char *) SDATA ((!NILP (f->icon_name)
2831 ? f->icon_name
2832 : f->name)));
2834 UNBLOCK_INPUT;
2837 /* Make the GCs needed for this window, setting the
2838 background, border and mouse colors; also create the
2839 mouse cursor and the gray border tile. */
2841 static char cursor_bits[] =
2843 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2844 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2845 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2846 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2849 static void
2850 x_make_gc (f)
2851 struct frame *f;
2853 XGCValues gc_values;
2855 BLOCK_INPUT;
2857 /* Create the GCs of this frame.
2858 Note that many default values are used. */
2860 /* Normal video */
2861 gc_values.font = FRAME_FONT (f)->fid;
2862 gc_values.foreground = f->output_data.x->foreground_pixel;
2863 gc_values.background = f->output_data.x->background_pixel;
2864 gc_values.line_width = 0; /* Means 1 using fast algorithm. */
2865 f->output_data.x->normal_gc
2866 = XCreateGC (FRAME_X_DISPLAY (f),
2867 FRAME_X_WINDOW (f),
2868 GCLineWidth | GCFont | GCForeground | GCBackground,
2869 &gc_values);
2871 /* Reverse video style. */
2872 gc_values.foreground = f->output_data.x->background_pixel;
2873 gc_values.background = f->output_data.x->foreground_pixel;
2874 f->output_data.x->reverse_gc
2875 = XCreateGC (FRAME_X_DISPLAY (f),
2876 FRAME_X_WINDOW (f),
2877 GCFont | GCForeground | GCBackground | GCLineWidth,
2878 &gc_values);
2880 /* Cursor has cursor-color background, background-color foreground. */
2881 gc_values.foreground = f->output_data.x->background_pixel;
2882 gc_values.background = f->output_data.x->cursor_pixel;
2883 gc_values.fill_style = FillOpaqueStippled;
2884 gc_values.stipple
2885 = XCreateBitmapFromData (FRAME_X_DISPLAY (f),
2886 FRAME_X_DISPLAY_INFO (f)->root_window,
2887 cursor_bits, 16, 16);
2888 f->output_data.x->cursor_gc
2889 = XCreateGC (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
2890 (GCFont | GCForeground | GCBackground
2891 | GCFillStyle /* | GCStipple */ | GCLineWidth),
2892 &gc_values);
2894 /* Reliefs. */
2895 f->output_data.x->white_relief.gc = 0;
2896 f->output_data.x->black_relief.gc = 0;
2898 /* Create the gray border tile used when the pointer is not in
2899 the frame. Since this depends on the frame's pixel values,
2900 this must be done on a per-frame basis. */
2901 f->output_data.x->border_tile
2902 = (XCreatePixmapFromBitmapData
2903 (FRAME_X_DISPLAY (f), FRAME_X_DISPLAY_INFO (f)->root_window,
2904 gray_bits, gray_width, gray_height,
2905 f->output_data.x->foreground_pixel,
2906 f->output_data.x->background_pixel,
2907 DefaultDepth (FRAME_X_DISPLAY (f), FRAME_X_SCREEN_NUMBER (f))));
2909 UNBLOCK_INPUT;
2913 /* Free what was was allocated in x_make_gc. */
2915 void
2916 x_free_gcs (f)
2917 struct frame *f;
2919 Display *dpy = FRAME_X_DISPLAY (f);
2921 BLOCK_INPUT;
2923 if (f->output_data.x->normal_gc)
2925 XFreeGC (dpy, f->output_data.x->normal_gc);
2926 f->output_data.x->normal_gc = 0;
2929 if (f->output_data.x->reverse_gc)
2931 XFreeGC (dpy, f->output_data.x->reverse_gc);
2932 f->output_data.x->reverse_gc = 0;
2935 if (f->output_data.x->cursor_gc)
2937 XFreeGC (dpy, f->output_data.x->cursor_gc);
2938 f->output_data.x->cursor_gc = 0;
2941 if (f->output_data.x->border_tile)
2943 XFreePixmap (dpy, f->output_data.x->border_tile);
2944 f->output_data.x->border_tile = 0;
2947 UNBLOCK_INPUT;
2951 /* Handler for signals raised during x_create_frame and
2952 x_create_top_frame. FRAME is the frame which is partially
2953 constructed. */
2955 static Lisp_Object
2956 unwind_create_frame (frame)
2957 Lisp_Object frame;
2959 struct frame *f = XFRAME (frame);
2961 /* If frame is ``official'', nothing to do. */
2962 if (!CONSP (Vframe_list) || !EQ (XCAR (Vframe_list), frame))
2964 #if GLYPH_DEBUG
2965 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (f);
2966 #endif
2968 x_free_frame_resources (f);
2970 #if GLYPH_DEBUG
2971 /* Check that reference counts are indeed correct. */
2972 xassert (dpyinfo->reference_count == dpyinfo_refcount);
2973 xassert (dpyinfo->image_cache->refcount == image_cache_refcount);
2974 #endif
2975 return Qt;
2978 return Qnil;
2982 DEFUN ("x-create-frame", Fx_create_frame, Sx_create_frame,
2983 1, 1, 0,
2984 doc: /* Make a new X window, which is called a "frame" in Emacs terms.
2985 Returns an Emacs frame object.
2986 ALIST is an alist of frame parameters.
2987 If the parameters specify that the frame should not have a minibuffer,
2988 and do not specify a specific minibuffer window to use,
2989 then `default-minibuffer-frame' must be a frame whose minibuffer can
2990 be shared by the new frame.
2992 This function is an internal primitive--use `make-frame' instead. */)
2993 (parms)
2994 Lisp_Object parms;
2996 struct frame *f;
2997 Lisp_Object frame, tem;
2998 Lisp_Object name;
2999 int minibuffer_only = 0;
3000 long window_prompting = 0;
3001 int width, height;
3002 int count = SPECPDL_INDEX ();
3003 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
3004 Lisp_Object display;
3005 struct x_display_info *dpyinfo = NULL;
3006 Lisp_Object parent;
3007 struct kboard *kb;
3009 check_x ();
3011 parms = Fcopy_alist (parms);
3013 /* Use this general default value to start with
3014 until we know if this frame has a specified name. */
3015 Vx_resource_name = Vinvocation_name;
3017 display = x_get_arg (dpyinfo, parms, Qdisplay, 0, 0, RES_TYPE_STRING);
3018 if (EQ (display, Qunbound))
3019 display = Qnil;
3020 dpyinfo = check_x_display_info (display);
3021 #ifdef MULTI_KBOARD
3022 kb = dpyinfo->kboard;
3023 #else
3024 kb = &the_only_kboard;
3025 #endif
3027 name = x_get_arg (dpyinfo, parms, Qname, "name", "Name", RES_TYPE_STRING);
3028 if (!STRINGP (name)
3029 && ! EQ (name, Qunbound)
3030 && ! NILP (name))
3031 error ("Invalid frame name--not a string or nil");
3033 if (STRINGP (name))
3034 Vx_resource_name = name;
3036 /* See if parent window is specified. */
3037 parent = x_get_arg (dpyinfo, parms, Qparent_id, NULL, NULL, RES_TYPE_NUMBER);
3038 if (EQ (parent, Qunbound))
3039 parent = Qnil;
3040 if (! NILP (parent))
3041 CHECK_NUMBER (parent);
3043 /* make_frame_without_minibuffer can run Lisp code and garbage collect. */
3044 /* No need to protect DISPLAY because that's not used after passing
3045 it to make_frame_without_minibuffer. */
3046 frame = Qnil;
3047 GCPRO4 (parms, parent, name, frame);
3048 tem = x_get_arg (dpyinfo, parms, Qminibuffer, "minibuffer", "Minibuffer",
3049 RES_TYPE_SYMBOL);
3050 if (EQ (tem, Qnone) || NILP (tem))
3051 f = make_frame_without_minibuffer (Qnil, kb, display);
3052 else if (EQ (tem, Qonly))
3054 f = make_minibuffer_frame ();
3055 minibuffer_only = 1;
3057 else if (WINDOWP (tem))
3058 f = make_frame_without_minibuffer (tem, kb, display);
3059 else
3060 f = make_frame (1);
3062 XSETFRAME (frame, f);
3064 /* Note that X Windows does support scroll bars. */
3065 FRAME_CAN_HAVE_SCROLL_BARS (f) = 1;
3067 f->output_method = output_x_window;
3068 f->output_data.x = (struct x_output *) xmalloc (sizeof (struct x_output));
3069 bzero (f->output_data.x, sizeof (struct x_output));
3070 f->output_data.x->icon_bitmap = -1;
3071 FRAME_FONTSET (f) = -1;
3072 f->output_data.x->scroll_bar_foreground_pixel = -1;
3073 f->output_data.x->scroll_bar_background_pixel = -1;
3074 #ifdef USE_TOOLKIT_SCROLL_BARS
3075 f->output_data.x->scroll_bar_top_shadow_pixel = -1;
3076 f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
3077 #endif /* USE_TOOLKIT_SCROLL_BARS */
3079 f->icon_name
3080 = x_get_arg (dpyinfo, parms, Qicon_name, "iconName", "Title",
3081 RES_TYPE_STRING);
3082 if (! STRINGP (f->icon_name))
3083 f->icon_name = Qnil;
3085 FRAME_X_DISPLAY_INFO (f) = dpyinfo;
3087 /* With FRAME_X_DISPLAY_INFO set up, this unwind-protect is safe. */
3088 record_unwind_protect (unwind_create_frame, frame);
3089 #if GLYPH_DEBUG
3090 image_cache_refcount = FRAME_X_IMAGE_CACHE (f)->refcount;
3091 dpyinfo_refcount = dpyinfo->reference_count;
3092 #endif /* GLYPH_DEBUG */
3093 #ifdef MULTI_KBOARD
3094 FRAME_KBOARD (f) = kb;
3095 #endif
3097 /* These colors will be set anyway later, but it's important
3098 to get the color reference counts right, so initialize them! */
3100 Lisp_Object black;
3101 struct gcpro gcpro1;
3103 /* Function x_decode_color can signal an error. Make
3104 sure to initialize color slots so that we won't try
3105 to free colors we haven't allocated. */
3106 f->output_data.x->foreground_pixel = -1;
3107 f->output_data.x->background_pixel = -1;
3108 f->output_data.x->cursor_pixel = -1;
3109 f->output_data.x->cursor_foreground_pixel = -1;
3110 f->output_data.x->border_pixel = -1;
3111 f->output_data.x->mouse_pixel = -1;
3113 black = build_string ("black");
3114 GCPRO1 (black);
3115 f->output_data.x->foreground_pixel
3116 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3117 f->output_data.x->background_pixel
3118 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3119 f->output_data.x->cursor_pixel
3120 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3121 f->output_data.x->cursor_foreground_pixel
3122 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3123 f->output_data.x->border_pixel
3124 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3125 f->output_data.x->mouse_pixel
3126 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
3127 UNGCPRO;
3130 /* Specify the parent under which to make this X window. */
3132 if (!NILP (parent))
3134 f->output_data.x->parent_desc = (Window) XFASTINT (parent);
3135 f->output_data.x->explicit_parent = 1;
3137 else
3139 f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
3140 f->output_data.x->explicit_parent = 0;
3143 /* Set the name; the functions to which we pass f expect the name to
3144 be set. */
3145 if (EQ (name, Qunbound) || NILP (name))
3147 f->name = build_string (dpyinfo->x_id_name);
3148 f->explicit_name = 0;
3150 else
3152 f->name = name;
3153 f->explicit_name = 1;
3154 /* use the frame's title when getting resources for this frame. */
3155 specbind (Qx_resource_name, name);
3158 /* Extract the window parameters from the supplied values
3159 that are needed to determine window geometry. */
3161 Lisp_Object font;
3163 font = x_get_arg (dpyinfo, parms, Qfont, "font", "Font", RES_TYPE_STRING);
3165 BLOCK_INPUT;
3166 /* First, try whatever font the caller has specified. */
3167 if (STRINGP (font))
3169 tem = Fquery_fontset (font, Qnil);
3170 if (STRINGP (tem))
3171 font = x_new_fontset (f, SDATA (tem));
3172 else
3173 font = x_new_font (f, SDATA (font));
3176 /* Try out a font which we hope has bold and italic variations. */
3177 if (!STRINGP (font))
3178 font = x_new_font (f, "-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1");
3179 if (!STRINGP (font))
3180 font = x_new_font (f, "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
3181 if (! STRINGP (font))
3182 font = x_new_font (f, "-*-*-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
3183 if (! STRINGP (font))
3184 /* This was formerly the first thing tried, but it finds too many fonts
3185 and takes too long. */
3186 font = x_new_font (f, "-*-*-medium-r-*-*-*-*-*-*-c-*-iso8859-1");
3187 /* If those didn't work, look for something which will at least work. */
3188 if (! STRINGP (font))
3189 font = x_new_font (f, "-*-fixed-*-*-*-*-*-140-*-*-c-*-iso8859-1");
3190 UNBLOCK_INPUT;
3191 if (! STRINGP (font))
3192 font = build_string ("fixed");
3194 x_set_frame_parameters (f, Fcons (Fcons (Qfont, font), Qnil));
3197 #ifdef USE_LUCID
3198 /* Prevent lwlib/xlwmenu.c from crashing because of a bug
3199 whereby it fails to get any font. */
3200 xlwmenu_default_font = FRAME_FONT (f);
3201 #endif
3203 x_default_parameter (f, parms, Qborder_width, make_number (2),
3204 "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
3206 /* This defaults to 1 in order to match xterm. We recognize either
3207 internalBorderWidth or internalBorder (which is what xterm calls
3208 it). */
3209 if (NILP (Fassq (Qinternal_border_width, parms)))
3211 Lisp_Object value;
3213 value = x_get_arg (dpyinfo, parms, Qinternal_border_width,
3214 "internalBorder", "internalBorder", RES_TYPE_NUMBER);
3215 if (! EQ (value, Qunbound))
3216 parms = Fcons (Fcons (Qinternal_border_width, value),
3217 parms);
3219 x_default_parameter (f, parms, Qinternal_border_width, make_number (1),
3220 "internalBorderWidth", "internalBorderWidth",
3221 RES_TYPE_NUMBER);
3222 x_default_parameter (f, parms, Qvertical_scroll_bars, Qleft,
3223 "verticalScrollBars", "ScrollBars",
3224 RES_TYPE_SYMBOL);
3226 /* Also do the stuff which must be set before the window exists. */
3227 x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
3228 "foreground", "Foreground", RES_TYPE_STRING);
3229 x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
3230 "background", "Background", RES_TYPE_STRING);
3231 x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
3232 "pointerColor", "Foreground", RES_TYPE_STRING);
3233 x_default_parameter (f, parms, Qcursor_color, build_string ("black"),
3234 "cursorColor", "Foreground", RES_TYPE_STRING);
3235 x_default_parameter (f, parms, Qborder_color, build_string ("black"),
3236 "borderColor", "BorderColor", RES_TYPE_STRING);
3237 x_default_parameter (f, parms, Qscreen_gamma, Qnil,
3238 "screenGamma", "ScreenGamma", RES_TYPE_FLOAT);
3239 x_default_parameter (f, parms, Qline_spacing, Qnil,
3240 "lineSpacing", "LineSpacing", RES_TYPE_NUMBER);
3241 x_default_parameter (f, parms, Qleft_fringe, Qnil,
3242 "leftFringe", "LeftFringe", RES_TYPE_NUMBER);
3243 x_default_parameter (f, parms, Qright_fringe, Qnil,
3244 "rightFringe", "RightFringe", RES_TYPE_NUMBER);
3246 x_default_scroll_bar_color_parameter (f, parms, Qscroll_bar_foreground,
3247 "scrollBarForeground",
3248 "ScrollBarForeground", 1);
3249 x_default_scroll_bar_color_parameter (f, parms, Qscroll_bar_background,
3250 "scrollBarBackground",
3251 "ScrollBarBackground", 0);
3253 /* Init faces before x_default_parameter is called for scroll-bar
3254 parameters because that function calls x_set_scroll_bar_width,
3255 which calls change_frame_size, which calls Fset_window_buffer,
3256 which runs hooks, which call Fvertical_motion. At the end, we
3257 end up in init_iterator with a null face cache, which should not
3258 happen. */
3259 init_frame_faces (f);
3261 x_default_parameter (f, parms, Qmenu_bar_lines, make_number (1),
3262 "menuBar", "MenuBar", RES_TYPE_NUMBER);
3263 x_default_parameter (f, parms, Qtool_bar_lines, make_number (1),
3264 "toolBar", "ToolBar", RES_TYPE_NUMBER);
3265 x_default_parameter (f, parms, Qbuffer_predicate, Qnil,
3266 "bufferPredicate", "BufferPredicate",
3267 RES_TYPE_SYMBOL);
3268 x_default_parameter (f, parms, Qtitle, Qnil,
3269 "title", "Title", RES_TYPE_STRING);
3270 x_default_parameter (f, parms, Qwait_for_wm, Qt,
3271 "waitForWM", "WaitForWM", RES_TYPE_BOOLEAN);
3272 x_default_parameter (f, parms, Qfullscreen, Qnil,
3273 "fullscreen", "Fullscreen", RES_TYPE_SYMBOL);
3275 f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
3277 /* Compute the size of the X window. */
3278 window_prompting = x_figure_window_size (f, parms, 1);
3280 tem = x_get_arg (dpyinfo, parms, Qunsplittable, 0, 0, RES_TYPE_BOOLEAN);
3281 f->no_split = minibuffer_only || EQ (tem, Qt);
3283 x_icon_verify (f, parms);
3285 /* Create the X widget or window. */
3286 #ifdef USE_X_TOOLKIT
3287 x_window (f, window_prompting, minibuffer_only);
3288 #else
3289 x_window (f);
3290 #endif
3292 x_icon (f, parms);
3293 x_make_gc (f);
3295 /* Now consider the frame official. */
3296 FRAME_X_DISPLAY_INFO (f)->reference_count++;
3297 Vframe_list = Fcons (frame, Vframe_list);
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_SYMBOL);
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);
3314 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
3315 Change will not be effected unless different from the current
3316 FRAME_LINES (f). */
3317 width = FRAME_COLS (f);
3318 height = FRAME_LINES (f);
3320 SET_FRAME_COLS (f, 0);
3321 FRAME_LINES (f) = 0;
3322 change_frame_size (f, height, width, 1, 0, 0);
3324 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
3325 /* Create the menu bar. */
3326 if (!minibuffer_only && FRAME_EXTERNAL_MENU_BAR (f))
3328 /* If this signals an error, we haven't set size hints for the
3329 frame and we didn't make it visible. */
3330 initialize_frame_menubar (f);
3332 #ifndef USE_GTK
3333 /* This is a no-op, except under Motif where it arranges the
3334 main window for the widgets on it. */
3335 lw_set_main_areas (f->output_data.x->column_widget,
3336 f->output_data.x->menubar_widget,
3337 f->output_data.x->edit_widget);
3338 #endif /* not USE_GTK */
3340 #endif /* USE_X_TOOLKIT || USE_GTK */
3342 /* Tell the server what size and position, etc, we want, and how
3343 badly we want them. This should be done after we have the menu
3344 bar so that its size can be taken into account. */
3345 BLOCK_INPUT;
3346 x_wm_set_size_hint (f, window_prompting, 0);
3347 UNBLOCK_INPUT;
3349 /* Make the window appear on the frame and enable display, unless
3350 the caller says not to. However, with explicit parent, Emacs
3351 cannot control visibility, so don't try. */
3352 if (! f->output_data.x->explicit_parent)
3354 Lisp_Object visibility;
3356 visibility = x_get_arg (dpyinfo, parms, Qvisibility, 0, 0,
3357 RES_TYPE_SYMBOL);
3358 if (EQ (visibility, Qunbound))
3359 visibility = Qt;
3361 if (EQ (visibility, Qicon))
3362 x_iconify_frame (f);
3363 else if (! NILP (visibility))
3364 x_make_frame_visible (f);
3365 else
3366 /* Must have been Qnil. */
3370 /* Set the WM leader property. GTK does this itself, so this is not
3371 needed when using GTK. */
3372 if (dpyinfo->client_leader_window != 0)
3374 BLOCK_INPUT;
3375 XChangeProperty (FRAME_X_DISPLAY (f),
3376 FRAME_OUTER_WINDOW (f),
3377 dpyinfo->Xatom_wm_client_leader,
3378 XA_WINDOW, 32, PropModeReplace,
3379 (unsigned char *) &dpyinfo->client_leader_window, 1);
3380 UNBLOCK_INPUT;
3383 /* Initialize `default-minibuffer-frame' in case this is the first
3384 frame on this display device. */
3385 if (FRAME_HAS_MINIBUF_P (f)
3386 && (!FRAMEP (kb->Vdefault_minibuffer_frame)
3387 || !FRAME_LIVE_P (XFRAME (kb->Vdefault_minibuffer_frame))))
3388 kb->Vdefault_minibuffer_frame = frame;
3390 /* All remaining specified parameters, which have not been "used"
3391 by x_get_arg and friends, now go in the misc. alist of the frame. */
3392 for (tem = parms; !NILP (tem); tem = XCDR (tem))
3393 if (CONSP (XCAR (tem)) && !NILP (XCAR (XCAR (tem))))
3394 f->param_alist = Fcons (XCAR (tem), f->param_alist);
3396 UNGCPRO;
3398 /* Make sure windows on this frame appear in calls to next-window
3399 and similar functions. */
3400 Vwindow_list = Qnil;
3402 return unbind_to (count, frame);
3406 /* FRAME is used only to get a handle on the X display. We don't pass the
3407 display info directly because we're called from frame.c, which doesn't
3408 know about that structure. */
3410 Lisp_Object
3411 x_get_focus_frame (frame)
3412 struct frame *frame;
3414 struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (frame);
3415 Lisp_Object xfocus;
3416 if (! dpyinfo->x_focus_frame)
3417 return Qnil;
3419 XSETFRAME (xfocus, dpyinfo->x_focus_frame);
3420 return xfocus;
3424 /* In certain situations, when the window manager follows a
3425 click-to-focus policy, there seems to be no way around calling
3426 XSetInputFocus to give another frame the input focus .
3428 In an ideal world, XSetInputFocus should generally be avoided so
3429 that applications don't interfere with the window manager's focus
3430 policy. But I think it's okay to use when it's clearly done
3431 following a user-command. */
3433 DEFUN ("x-focus-frame", Fx_focus_frame, Sx_focus_frame, 1, 1, 0,
3434 doc: /* Set the input focus to FRAME.
3435 FRAME nil means use the selected frame. */)
3436 (frame)
3437 Lisp_Object frame;
3439 struct frame *f = check_x_frame (frame);
3440 Display *dpy = FRAME_X_DISPLAY (f);
3442 BLOCK_INPUT;
3443 x_catch_errors (dpy);
3444 XSetInputFocus (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
3445 RevertToParent, CurrentTime);
3446 x_uncatch_errors ();
3447 UNBLOCK_INPUT;
3449 return Qnil;
3453 DEFUN ("xw-color-defined-p", Fxw_color_defined_p, Sxw_color_defined_p, 1, 2, 0,
3454 doc: /* Internal function called by `color-defined-p', which see. */)
3455 (color, frame)
3456 Lisp_Object color, frame;
3458 XColor foo;
3459 FRAME_PTR f = check_x_frame (frame);
3461 CHECK_STRING (color);
3463 if (x_defined_color (f, SDATA (color), &foo, 0))
3464 return Qt;
3465 else
3466 return Qnil;
3469 DEFUN ("xw-color-values", Fxw_color_values, Sxw_color_values, 1, 2, 0,
3470 doc: /* Internal function called by `color-values', which see. */)
3471 (color, frame)
3472 Lisp_Object color, frame;
3474 XColor foo;
3475 FRAME_PTR f = check_x_frame (frame);
3477 CHECK_STRING (color);
3479 if (x_defined_color (f, SDATA (color), &foo, 0))
3481 Lisp_Object rgb[3];
3483 rgb[0] = make_number (foo.red);
3484 rgb[1] = make_number (foo.green);
3485 rgb[2] = make_number (foo.blue);
3486 return Flist (3, rgb);
3488 else
3489 return Qnil;
3492 DEFUN ("xw-display-color-p", Fxw_display_color_p, Sxw_display_color_p, 0, 1, 0,
3493 doc: /* Internal function called by `display-color-p', which see. */)
3494 (display)
3495 Lisp_Object display;
3497 struct x_display_info *dpyinfo = check_x_display_info (display);
3499 if (dpyinfo->n_planes <= 2)
3500 return Qnil;
3502 switch (dpyinfo->visual->class)
3504 case StaticColor:
3505 case PseudoColor:
3506 case TrueColor:
3507 case DirectColor:
3508 return Qt;
3510 default:
3511 return Qnil;
3515 DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p, Sx_display_grayscale_p,
3516 0, 1, 0,
3517 doc: /* Return t if the X display supports shades of gray.
3518 Note that color displays do support shades of gray.
3519 The optional argument DISPLAY specifies which display to ask about.
3520 DISPLAY should be either a frame or a display name (a string).
3521 If omitted or nil, that stands for the selected frame's display. */)
3522 (display)
3523 Lisp_Object display;
3525 struct x_display_info *dpyinfo = check_x_display_info (display);
3527 if (dpyinfo->n_planes <= 1)
3528 return Qnil;
3530 switch (dpyinfo->visual->class)
3532 case StaticColor:
3533 case PseudoColor:
3534 case TrueColor:
3535 case DirectColor:
3536 case StaticGray:
3537 case GrayScale:
3538 return Qt;
3540 default:
3541 return Qnil;
3545 DEFUN ("x-display-pixel-width", Fx_display_pixel_width, Sx_display_pixel_width,
3546 0, 1, 0,
3547 doc: /* Returns the width in pixels of the X display DISPLAY.
3548 The optional argument DISPLAY specifies which display to ask about.
3549 DISPLAY should be either a frame or a display name (a string).
3550 If omitted or nil, that stands for the selected frame's display. */)
3551 (display)
3552 Lisp_Object display;
3554 struct x_display_info *dpyinfo = check_x_display_info (display);
3556 return make_number (dpyinfo->width);
3559 DEFUN ("x-display-pixel-height", Fx_display_pixel_height,
3560 Sx_display_pixel_height, 0, 1, 0,
3561 doc: /* Returns the height in pixels of the X display DISPLAY.
3562 The optional argument DISPLAY specifies which display to ask about.
3563 DISPLAY should be either a frame or a display name (a string).
3564 If omitted or nil, that stands for the selected frame's display. */)
3565 (display)
3566 Lisp_Object display;
3568 struct x_display_info *dpyinfo = check_x_display_info (display);
3570 return make_number (dpyinfo->height);
3573 DEFUN ("x-display-planes", Fx_display_planes, Sx_display_planes,
3574 0, 1, 0,
3575 doc: /* Returns the number of bitplanes of the X display DISPLAY.
3576 The optional argument DISPLAY specifies which display to ask about.
3577 DISPLAY should be either a frame or a display name (a string).
3578 If omitted or nil, that stands for the selected frame's display. */)
3579 (display)
3580 Lisp_Object display;
3582 struct x_display_info *dpyinfo = check_x_display_info (display);
3584 return make_number (dpyinfo->n_planes);
3587 DEFUN ("x-display-color-cells", Fx_display_color_cells, Sx_display_color_cells,
3588 0, 1, 0,
3589 doc: /* Returns the number of color cells of the X display DISPLAY.
3590 The optional argument DISPLAY specifies which display to ask about.
3591 DISPLAY should be either a frame or a display name (a string).
3592 If omitted or nil, that stands for the selected frame's display. */)
3593 (display)
3594 Lisp_Object display;
3596 struct x_display_info *dpyinfo = check_x_display_info (display);
3598 int nr_planes = DisplayPlanes (dpyinfo->display,
3599 XScreenNumberOfScreen (dpyinfo->screen));
3601 /* Truncate nr_planes to 24 to avoid integer overflow.
3602 Some displays says 32, but only 24 bits are actually significant.
3603 There are only very few and rare video cards that have more than
3604 24 significant bits. Also 24 bits is more than 16 million colors,
3605 it "should be enough for everyone". */
3606 if (nr_planes > 24) nr_planes = 24;
3608 return make_number (1 << nr_planes);
3611 DEFUN ("x-server-max-request-size", Fx_server_max_request_size,
3612 Sx_server_max_request_size,
3613 0, 1, 0,
3614 doc: /* Returns the maximum request size of the X server of display DISPLAY.
3615 The optional argument DISPLAY specifies which display to ask about.
3616 DISPLAY should be either a frame or a display name (a string).
3617 If omitted or nil, that stands for the selected frame's display. */)
3618 (display)
3619 Lisp_Object display;
3621 struct x_display_info *dpyinfo = check_x_display_info (display);
3623 return make_number (MAXREQUEST (dpyinfo->display));
3626 DEFUN ("x-server-vendor", Fx_server_vendor, Sx_server_vendor, 0, 1, 0,
3627 doc: /* Returns the "vendor ID" string of the X server of display DISPLAY.
3628 \(Labelling every distributor as a "vendor" embodies the false assumption
3629 that operating systems cannot be developed and distributed noncommercially.)
3630 The optional argument DISPLAY specifies which display to ask about.
3631 DISPLAY should be either a frame or a display name (a string).
3632 If omitted or nil, that stands for the selected frame's display. */)
3633 (display)
3634 Lisp_Object display;
3636 struct x_display_info *dpyinfo = check_x_display_info (display);
3637 char *vendor = ServerVendor (dpyinfo->display);
3639 if (! vendor) vendor = "";
3640 return build_string (vendor);
3643 DEFUN ("x-server-version", Fx_server_version, Sx_server_version, 0, 1, 0,
3644 doc: /* Returns the version numbers of the X server of display DISPLAY.
3645 The value is a list of three integers: the major and minor
3646 version numbers of the X Protocol in use, and the distributor-specific release
3647 number. See also the function `x-server-vendor'.
3649 The optional argument DISPLAY specifies which display to ask about.
3650 DISPLAY should be either a frame or a display name (a string).
3651 If omitted or nil, that stands for the selected frame's display. */)
3652 (display)
3653 Lisp_Object display;
3655 struct x_display_info *dpyinfo = check_x_display_info (display);
3656 Display *dpy = dpyinfo->display;
3658 return Fcons (make_number (ProtocolVersion (dpy)),
3659 Fcons (make_number (ProtocolRevision (dpy)),
3660 Fcons (make_number (VendorRelease (dpy)), Qnil)));
3663 DEFUN ("x-display-screens", Fx_display_screens, Sx_display_screens, 0, 1, 0,
3664 doc: /* Return the number of screens on the X server of display DISPLAY.
3665 The optional argument DISPLAY specifies which display to ask about.
3666 DISPLAY should be either a frame or a display name (a string).
3667 If omitted or nil, that stands for the selected frame's display. */)
3668 (display)
3669 Lisp_Object display;
3671 struct x_display_info *dpyinfo = check_x_display_info (display);
3673 return make_number (ScreenCount (dpyinfo->display));
3676 DEFUN ("x-display-mm-height", Fx_display_mm_height, Sx_display_mm_height, 0, 1, 0,
3677 doc: /* Return the height in millimeters of the X display DISPLAY.
3678 The optional argument DISPLAY specifies which display to ask about.
3679 DISPLAY should be either a frame or a display name (a string).
3680 If omitted or nil, that stands for the selected frame's display. */)
3681 (display)
3682 Lisp_Object display;
3684 struct x_display_info *dpyinfo = check_x_display_info (display);
3686 return make_number (HeightMMOfScreen (dpyinfo->screen));
3689 DEFUN ("x-display-mm-width", Fx_display_mm_width, Sx_display_mm_width, 0, 1, 0,
3690 doc: /* Return the width in millimeters of the X display DISPLAY.
3691 The optional argument DISPLAY specifies which display to ask about.
3692 DISPLAY should be either a frame or a display name (a string).
3693 If omitted or nil, that stands for the selected frame's display. */)
3694 (display)
3695 Lisp_Object display;
3697 struct x_display_info *dpyinfo = check_x_display_info (display);
3699 return make_number (WidthMMOfScreen (dpyinfo->screen));
3702 DEFUN ("x-display-backing-store", Fx_display_backing_store,
3703 Sx_display_backing_store, 0, 1, 0,
3704 doc: /* Returns an indication of whether X display DISPLAY does backing store.
3705 The value may be `always', `when-mapped', or `not-useful'.
3706 The optional argument DISPLAY specifies which display to ask about.
3707 DISPLAY should be either a frame or a display name (a string).
3708 If omitted or nil, that stands for the selected frame's display. */)
3709 (display)
3710 Lisp_Object display;
3712 struct x_display_info *dpyinfo = check_x_display_info (display);
3713 Lisp_Object result;
3715 switch (DoesBackingStore (dpyinfo->screen))
3717 case Always:
3718 result = intern ("always");
3719 break;
3721 case WhenMapped:
3722 result = intern ("when-mapped");
3723 break;
3725 case NotUseful:
3726 result = intern ("not-useful");
3727 break;
3729 default:
3730 error ("Strange value for BackingStore parameter of screen");
3731 result = Qnil;
3734 return result;
3737 DEFUN ("x-display-visual-class", Fx_display_visual_class,
3738 Sx_display_visual_class, 0, 1, 0,
3739 doc: /* Return the visual class of the X display DISPLAY.
3740 The value is one of the symbols `static-gray', `gray-scale',
3741 `static-color', `pseudo-color', `true-color', or `direct-color'.
3743 The optional argument DISPLAY specifies which display to ask about.
3744 DISPLAY should be either a frame or a display name (a string).
3745 If omitted or nil, that stands for the selected frame's display. */)
3746 (display)
3747 Lisp_Object display;
3749 struct x_display_info *dpyinfo = check_x_display_info (display);
3750 Lisp_Object result;
3752 switch (dpyinfo->visual->class)
3754 case StaticGray:
3755 result = intern ("static-gray");
3756 break;
3757 case GrayScale:
3758 result = intern ("gray-scale");
3759 break;
3760 case StaticColor:
3761 result = intern ("static-color");
3762 break;
3763 case PseudoColor:
3764 result = intern ("pseudo-color");
3765 break;
3766 case TrueColor:
3767 result = intern ("true-color");
3768 break;
3769 case DirectColor:
3770 result = intern ("direct-color");
3771 break;
3772 default:
3773 error ("Display has an unknown visual class");
3774 result = Qnil;
3777 return result;
3780 DEFUN ("x-display-save-under", Fx_display_save_under,
3781 Sx_display_save_under, 0, 1, 0,
3782 doc: /* Returns t if the X display DISPLAY supports the save-under feature.
3783 The optional argument DISPLAY specifies which display to ask about.
3784 DISPLAY should be either a frame or a display name (a string).
3785 If omitted or nil, that stands for the selected frame's display. */)
3786 (display)
3787 Lisp_Object display;
3789 struct x_display_info *dpyinfo = check_x_display_info (display);
3791 if (DoesSaveUnders (dpyinfo->screen) == True)
3792 return Qt;
3793 else
3794 return Qnil;
3798 x_pixel_width (f)
3799 register struct frame *f;
3801 return FRAME_PIXEL_WIDTH (f);
3805 x_pixel_height (f)
3806 register struct frame *f;
3808 return FRAME_PIXEL_HEIGHT (f);
3812 x_char_width (f)
3813 register struct frame *f;
3815 return FRAME_COLUMN_WIDTH (f);
3819 x_char_height (f)
3820 register struct frame *f;
3822 return FRAME_LINE_HEIGHT (f);
3826 x_screen_planes (f)
3827 register struct frame *f;
3829 return FRAME_X_DISPLAY_INFO (f)->n_planes;
3834 /************************************************************************
3835 X Displays
3836 ************************************************************************/
3839 /* Mapping visual names to visuals. */
3841 static struct visual_class
3843 char *name;
3844 int class;
3846 visual_classes[] =
3848 {"StaticGray", StaticGray},
3849 {"GrayScale", GrayScale},
3850 {"StaticColor", StaticColor},
3851 {"PseudoColor", PseudoColor},
3852 {"TrueColor", TrueColor},
3853 {"DirectColor", DirectColor},
3854 {NULL, 0}
3858 #ifndef HAVE_XSCREENNUMBEROFSCREEN
3860 /* Value is the screen number of screen SCR. This is a substitute for
3861 the X function with the same name when that doesn't exist. */
3864 XScreenNumberOfScreen (scr)
3865 register Screen *scr;
3867 Display *dpy = scr->display;
3868 int i;
3870 for (i = 0; i < dpy->nscreens; ++i)
3871 if (scr == dpy->screens + i)
3872 break;
3874 return i;
3877 #endif /* not HAVE_XSCREENNUMBEROFSCREEN */
3880 /* Select the visual that should be used on display DPYINFO. Set
3881 members of DPYINFO appropriately. Called from x_term_init. */
3883 void
3884 select_visual (dpyinfo)
3885 struct x_display_info *dpyinfo;
3887 Display *dpy = dpyinfo->display;
3888 Screen *screen = dpyinfo->screen;
3889 Lisp_Object value;
3891 /* See if a visual is specified. */
3892 value = display_x_get_resource (dpyinfo,
3893 build_string ("visualClass"),
3894 build_string ("VisualClass"),
3895 Qnil, Qnil);
3896 if (STRINGP (value))
3898 /* VALUE should be of the form CLASS-DEPTH, where CLASS is one
3899 of `PseudoColor', `TrueColor' etc. and DEPTH is the color
3900 depth, a decimal number. NAME is compared with case ignored. */
3901 char *s = (char *) alloca (SBYTES (value) + 1);
3902 char *dash;
3903 int i, class = -1;
3904 XVisualInfo vinfo;
3906 strcpy (s, SDATA (value));
3907 dash = index (s, '-');
3908 if (dash)
3910 dpyinfo->n_planes = atoi (dash + 1);
3911 *dash = '\0';
3913 else
3914 /* We won't find a matching visual with depth 0, so that
3915 an error will be printed below. */
3916 dpyinfo->n_planes = 0;
3918 /* Determine the visual class. */
3919 for (i = 0; visual_classes[i].name; ++i)
3920 if (xstricmp (s, visual_classes[i].name) == 0)
3922 class = visual_classes[i].class;
3923 break;
3926 /* Look up a matching visual for the specified class. */
3927 if (class == -1
3928 || !XMatchVisualInfo (dpy, XScreenNumberOfScreen (screen),
3929 dpyinfo->n_planes, class, &vinfo))
3930 fatal ("Invalid visual specification `%s'", SDATA (value));
3932 dpyinfo->visual = vinfo.visual;
3934 else
3936 int n_visuals;
3937 XVisualInfo *vinfo, vinfo_template;
3939 dpyinfo->visual = DefaultVisualOfScreen (screen);
3941 #ifdef HAVE_X11R4
3942 vinfo_template.visualid = XVisualIDFromVisual (dpyinfo->visual);
3943 #else
3944 vinfo_template.visualid = dpyinfo->visual->visualid;
3945 #endif
3946 vinfo_template.screen = XScreenNumberOfScreen (screen);
3947 vinfo = XGetVisualInfo (dpy, VisualIDMask | VisualScreenMask,
3948 &vinfo_template, &n_visuals);
3949 if (n_visuals != 1)
3950 fatal ("Can't get proper X visual info");
3952 dpyinfo->n_planes = vinfo->depth;
3953 XFree ((char *) vinfo);
3958 /* Return the X display structure for the display named NAME.
3959 Open a new connection if necessary. */
3961 struct x_display_info *
3962 x_display_info_for_name (name)
3963 Lisp_Object name;
3965 Lisp_Object names;
3966 struct x_display_info *dpyinfo;
3968 CHECK_STRING (name);
3970 if (! EQ (Vwindow_system, intern ("x")))
3971 error ("Not using X Windows");
3973 for (dpyinfo = x_display_list, names = x_display_name_list;
3974 dpyinfo;
3975 dpyinfo = dpyinfo->next, names = XCDR (names))
3977 Lisp_Object tem;
3978 tem = Fstring_equal (XCAR (XCAR (names)), name);
3979 if (!NILP (tem))
3980 return dpyinfo;
3983 /* Use this general default value to start with. */
3984 Vx_resource_name = Vinvocation_name;
3986 validate_x_resource_name ();
3988 dpyinfo = x_term_init (name, (char *)0,
3989 (char *) SDATA (Vx_resource_name));
3991 if (dpyinfo == 0)
3992 error ("Cannot connect to X server %s", SDATA (name));
3994 x_in_use = 1;
3995 XSETFASTINT (Vwindow_system_version, 11);
3997 return dpyinfo;
4001 DEFUN ("x-open-connection", Fx_open_connection, Sx_open_connection,
4002 1, 3, 0,
4003 doc: /* Open a connection to an X server.
4004 DISPLAY is the name of the display to connect to.
4005 Optional second arg XRM-STRING is a string of resources in xrdb format.
4006 If the optional third arg MUST-SUCCEED is non-nil,
4007 terminate Emacs if we can't open the connection. */)
4008 (display, xrm_string, must_succeed)
4009 Lisp_Object display, xrm_string, must_succeed;
4011 unsigned char *xrm_option;
4012 struct x_display_info *dpyinfo;
4014 CHECK_STRING (display);
4015 if (! NILP (xrm_string))
4016 CHECK_STRING (xrm_string);
4018 if (! EQ (Vwindow_system, intern ("x")))
4019 error ("Not using X Windows");
4021 if (! NILP (xrm_string))
4022 xrm_option = (unsigned char *) SDATA (xrm_string);
4023 else
4024 xrm_option = (unsigned char *) 0;
4026 validate_x_resource_name ();
4028 /* This is what opens the connection and sets x_current_display.
4029 This also initializes many symbols, such as those used for input. */
4030 dpyinfo = x_term_init (display, xrm_option,
4031 (char *) SDATA (Vx_resource_name));
4033 if (dpyinfo == 0)
4035 if (!NILP (must_succeed))
4036 fatal ("Cannot connect to X server %s.\n\
4037 Check the DISPLAY environment variable or use `-d'.\n\
4038 Also use the `xauth' program to verify that you have the proper\n\
4039 authorization information needed to connect the X server.\n\
4040 An insecure way to solve the problem may be to use `xhost'.\n",
4041 SDATA (display));
4042 else
4043 error ("Cannot connect to X server %s", SDATA (display));
4046 x_in_use = 1;
4048 XSETFASTINT (Vwindow_system_version, 11);
4049 return Qnil;
4052 DEFUN ("x-close-connection", Fx_close_connection,
4053 Sx_close_connection, 1, 1, 0,
4054 doc: /* Close the connection to DISPLAY's X server.
4055 For DISPLAY, specify either a frame or a display name (a string).
4056 If DISPLAY is nil, that stands for the selected frame's display. */)
4057 (display)
4058 Lisp_Object display;
4060 struct x_display_info *dpyinfo = check_x_display_info (display);
4061 int i;
4063 if (dpyinfo->reference_count > 0)
4064 error ("Display still has frames on it");
4066 BLOCK_INPUT;
4067 /* Free the fonts in the font table. */
4068 for (i = 0; i < dpyinfo->n_fonts; i++)
4069 if (dpyinfo->font_table[i].name)
4071 XFreeFont (dpyinfo->display, dpyinfo->font_table[i].font);
4074 x_destroy_all_bitmaps (dpyinfo);
4075 XSetCloseDownMode (dpyinfo->display, DestroyAll);
4077 #ifdef USE_X_TOOLKIT
4078 XtCloseDisplay (dpyinfo->display);
4079 #else
4080 XCloseDisplay (dpyinfo->display);
4081 #endif
4083 x_delete_display (dpyinfo);
4084 UNBLOCK_INPUT;
4086 return Qnil;
4089 DEFUN ("x-display-list", Fx_display_list, Sx_display_list, 0, 0, 0,
4090 doc: /* Return the list of display names that Emacs has connections to. */)
4093 Lisp_Object tail, result;
4095 result = Qnil;
4096 for (tail = x_display_name_list; ! NILP (tail); tail = XCDR (tail))
4097 result = Fcons (XCAR (XCAR (tail)), result);
4099 return result;
4102 DEFUN ("x-synchronize", Fx_synchronize, Sx_synchronize, 1, 2, 0,
4103 doc: /* If ON is non-nil, report X errors as soon as the erring request is made.
4104 If ON is nil, allow buffering of requests.
4105 Turning on synchronization prohibits the Xlib routines from buffering
4106 requests and seriously degrades performance, but makes debugging much
4107 easier.
4108 The optional second argument DISPLAY specifies which display to act on.
4109 DISPLAY should be either a frame or a display name (a string).
4110 If DISPLAY is omitted or nil, that stands for the selected frame's display. */)
4111 (on, display)
4112 Lisp_Object display, on;
4114 struct x_display_info *dpyinfo = check_x_display_info (display);
4116 XSynchronize (dpyinfo->display, !EQ (on, Qnil));
4118 return Qnil;
4121 /* Wait for responses to all X commands issued so far for frame F. */
4123 void
4124 x_sync (f)
4125 FRAME_PTR f;
4127 BLOCK_INPUT;
4128 XSync (FRAME_X_DISPLAY (f), False);
4129 UNBLOCK_INPUT;
4133 /***********************************************************************
4134 Window properties
4135 ***********************************************************************/
4137 DEFUN ("x-change-window-property", Fx_change_window_property,
4138 Sx_change_window_property, 2, 6, 0,
4139 doc: /* Change window property PROP to VALUE on the X window of FRAME.
4140 PROP must be a string.
4141 VALUE may be a string or a list of conses, numbers and/or strings.
4142 If an element in the list is a string, it is converted to
4143 an Atom and the value of the Atom is used. If an element is a cons,
4144 it is converted to a 32 bit number where the car is the 16 top bits and the
4145 cdr is the lower 16 bits.
4146 FRAME nil or omitted means use the selected frame.
4147 If TYPE is given and non-nil, it is the name of the type of VALUE.
4148 If TYPE is not given or nil, the type is STRING.
4149 FORMAT gives the size in bits of each element if VALUE is a list.
4150 It must be one of 8, 16 or 32.
4151 If VALUE is a string or FORMAT is nil or not given, FORMAT defaults to 8.
4152 If OUTER_P is non-nil, the property is changed for the outer X window of
4153 FRAME. Default is to change on the edit X window.
4155 Value is VALUE. */)
4156 (prop, value, frame, type, format, outer_p)
4157 Lisp_Object prop, value, frame, type, format, outer_p;
4159 struct frame *f = check_x_frame (frame);
4160 Atom prop_atom;
4161 Atom target_type = XA_STRING;
4162 int element_format = 8;
4163 unsigned char *data;
4164 int nelements;
4165 Window w;
4167 CHECK_STRING (prop);
4169 if (! NILP (format))
4171 CHECK_NUMBER (format);
4172 element_format = XFASTINT (format);
4174 if (element_format != 8 && element_format != 16
4175 && element_format != 32)
4176 error ("FORMAT must be one of 8, 16 or 32");
4179 if (CONSP (value))
4181 nelements = x_check_property_data (value);
4182 if (nelements == -1)
4183 error ("Bad data in VALUE, must be number, string or cons");
4185 if (element_format == 8)
4186 data = (unsigned char *) xmalloc (nelements);
4187 else if (element_format == 16)
4188 data = (unsigned char *) xmalloc (nelements*2);
4189 else /* format == 32 */
4190 /* The man page for XChangeProperty:
4191 "If the specified format is 32, the property data must be a
4192 long array."
4193 This applies even if long is more than 64 bits. The X library
4194 converts to 32 bits before sending to the X server. */
4195 data = (unsigned char *) xmalloc (nelements * sizeof(long));
4197 x_fill_property_data (FRAME_X_DISPLAY (f), value, data, element_format);
4199 else
4201 CHECK_STRING (value);
4202 data = SDATA (value);
4203 nelements = SCHARS (value);
4206 BLOCK_INPUT;
4207 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SDATA (prop), False);
4208 if (! NILP (type))
4210 CHECK_STRING (type);
4211 target_type = XInternAtom (FRAME_X_DISPLAY (f), SDATA (type), False);
4214 if (! NILP (outer_p)) w = FRAME_OUTER_WINDOW (f);
4215 else w = FRAME_X_WINDOW (f);
4217 XChangeProperty (FRAME_X_DISPLAY (f), w,
4218 prop_atom, target_type, element_format, PropModeReplace,
4219 data, nelements);
4221 if (CONSP (value)) xfree (data);
4223 /* Make sure the property is set when we return. */
4224 XFlush (FRAME_X_DISPLAY (f));
4225 UNBLOCK_INPUT;
4227 return value;
4231 DEFUN ("x-delete-window-property", Fx_delete_window_property,
4232 Sx_delete_window_property, 1, 2, 0,
4233 doc: /* Remove window property PROP from X window of FRAME.
4234 FRAME nil or omitted means use the selected frame. Value is PROP. */)
4235 (prop, frame)
4236 Lisp_Object prop, frame;
4238 struct frame *f = check_x_frame (frame);
4239 Atom prop_atom;
4241 CHECK_STRING (prop);
4242 BLOCK_INPUT;
4243 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SDATA (prop), False);
4244 XDeleteProperty (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f), prop_atom);
4246 /* Make sure the property is removed when we return. */
4247 XFlush (FRAME_X_DISPLAY (f));
4248 UNBLOCK_INPUT;
4250 return prop;
4254 DEFUN ("x-window-property", Fx_window_property, Sx_window_property,
4255 1, 6, 0,
4256 doc: /* Value is the value of window property PROP on FRAME.
4257 If FRAME is nil or omitted, use the selected frame.
4258 If TYPE is nil or omitted, get the property as a string. Otherwise TYPE
4259 is the name of the Atom that denotes the type expected.
4260 If SOURCE is non-nil, get the property on that window instead of from
4261 FRAME. The number 0 denotes the root window.
4262 If DELETE_P is non-nil, delete the property after retreiving it.
4263 If VECTOR_RET_P is non-nil, don't return a string but a vector of values.
4265 Value is nil if FRAME hasn't a property with name PROP or if PROP has
4266 no value of TYPE. */)
4267 (prop, frame, type, source, delete_p, vector_ret_p)
4268 Lisp_Object prop, frame, type, source, delete_p, vector_ret_p;
4270 struct frame *f = check_x_frame (frame);
4271 Atom prop_atom;
4272 int rc;
4273 Lisp_Object prop_value = Qnil;
4274 unsigned char *tmp_data = NULL;
4275 Atom actual_type;
4276 Atom target_type = XA_STRING;
4277 int actual_format;
4278 unsigned long actual_size, bytes_remaining;
4279 Window target_window = FRAME_X_WINDOW (f);
4280 struct gcpro gcpro1;
4282 GCPRO1 (prop_value);
4283 CHECK_STRING (prop);
4285 if (! NILP (source))
4287 if (NUMBERP (source))
4289 if (FLOATP (source))
4290 target_window = (Window) XFLOAT (source);
4291 else
4292 target_window = XFASTINT (source);
4294 if (target_window == 0)
4295 target_window = FRAME_X_DISPLAY_INFO (f)->root_window;
4297 else if (CONSP (source))
4298 target_window = cons_to_long (source);
4301 BLOCK_INPUT;
4302 if (STRINGP (type))
4304 if (strcmp ("AnyPropertyType", SDATA (type)) == 0)
4305 target_type = AnyPropertyType;
4306 else
4307 target_type = XInternAtom (FRAME_X_DISPLAY (f), SDATA (type), False);
4310 prop_atom = XInternAtom (FRAME_X_DISPLAY (f), SDATA (prop), False);
4311 rc = XGetWindowProperty (FRAME_X_DISPLAY (f), target_window,
4312 prop_atom, 0, 0, False, target_type,
4313 &actual_type, &actual_format, &actual_size,
4314 &bytes_remaining, &tmp_data);
4315 if (rc == Success)
4317 int size = bytes_remaining;
4319 XFree (tmp_data);
4320 tmp_data = NULL;
4322 rc = XGetWindowProperty (FRAME_X_DISPLAY (f), target_window,
4323 prop_atom, 0, bytes_remaining,
4324 ! NILP (delete_p), target_type,
4325 &actual_type, &actual_format,
4326 &actual_size, &bytes_remaining,
4327 &tmp_data);
4328 if (rc == Success && tmp_data)
4330 /* The man page for XGetWindowProperty says:
4331 "If the returned format is 32, the returned data is represented
4332 as a long array and should be cast to that type to obtain the
4333 elements."
4334 This applies even if long is more than 32 bits, the X library
4335 converts from 32 bit elements received from the X server to long
4336 and passes the long array to us. Thus, for that case bcopy can not
4337 be used. We convert to a 32 bit type here, because so much code
4338 assume on that.
4340 The bytes and offsets passed to XGetWindowProperty refers to the
4341 property and those are indeed in 32 bit quantities if format is
4342 32. */
4344 if (actual_format == 32 && actual_format < BITS_PER_LONG)
4346 unsigned long i;
4347 int *idata = (int *) tmp_data;
4348 long *ldata = (long *) tmp_data;
4350 for (i = 0; i < actual_size; ++i)
4351 idata[i] = (int) ldata[i];
4354 if (NILP (vector_ret_p))
4355 prop_value = make_string (tmp_data, size);
4356 else
4357 prop_value = x_property_data_to_lisp (f,
4358 tmp_data,
4359 actual_type,
4360 actual_format,
4361 actual_size);
4364 if (tmp_data) XFree (tmp_data);
4367 UNBLOCK_INPUT;
4368 UNGCPRO;
4369 return prop_value;
4374 /***********************************************************************
4375 Busy cursor
4376 ***********************************************************************/
4378 /* If non-null, an asynchronous timer that, when it expires, displays
4379 an hourglass cursor on all frames. */
4381 static struct atimer *hourglass_atimer;
4383 /* Non-zero means an hourglass cursor is currently shown. */
4385 static int hourglass_shown_p;
4387 /* Number of seconds to wait before displaying an hourglass cursor. */
4389 static Lisp_Object Vhourglass_delay;
4391 /* Default number of seconds to wait before displaying an hourglass
4392 cursor. */
4394 #define DEFAULT_HOURGLASS_DELAY 1
4396 /* Function prototypes. */
4398 static void show_hourglass P_ ((struct atimer *));
4399 static void hide_hourglass P_ ((void));
4401 /* Return non-zero if houglass timer has been started or hourglass is shown. */
4404 hourglass_started ()
4406 return hourglass_shown_p || hourglass_atimer != NULL;
4410 /* Cancel a currently active hourglass timer, and start a new one. */
4412 void
4413 start_hourglass ()
4415 EMACS_TIME delay;
4416 int secs, usecs = 0;
4418 /* Don't bother for ttys. */
4419 if (NILP (Vwindow_system))
4420 return;
4422 cancel_hourglass ();
4424 if (INTEGERP (Vhourglass_delay)
4425 && XINT (Vhourglass_delay) > 0)
4426 secs = XFASTINT (Vhourglass_delay);
4427 else if (FLOATP (Vhourglass_delay)
4428 && XFLOAT_DATA (Vhourglass_delay) > 0)
4430 Lisp_Object tem;
4431 tem = Ftruncate (Vhourglass_delay, Qnil);
4432 secs = XFASTINT (tem);
4433 usecs = (XFLOAT_DATA (Vhourglass_delay) - secs) * 1000000;
4435 else
4436 secs = DEFAULT_HOURGLASS_DELAY;
4438 EMACS_SET_SECS_USECS (delay, secs, usecs);
4439 hourglass_atimer = start_atimer (ATIMER_RELATIVE, delay,
4440 show_hourglass, NULL);
4444 /* Cancel the hourglass cursor timer if active, hide a busy cursor if
4445 shown. */
4447 void
4448 cancel_hourglass ()
4450 if (hourglass_atimer)
4452 cancel_atimer (hourglass_atimer);
4453 hourglass_atimer = NULL;
4456 if (hourglass_shown_p)
4457 hide_hourglass ();
4461 /* Timer function of hourglass_atimer. TIMER is equal to
4462 hourglass_atimer.
4464 Display an hourglass pointer on all frames by mapping the frames'
4465 hourglass_window. Set the hourglass_p flag in the frames'
4466 output_data.x structure to indicate that an hourglass cursor is
4467 shown on the frames. */
4469 static void
4470 show_hourglass (timer)
4471 struct atimer *timer;
4473 /* The timer implementation will cancel this timer automatically
4474 after this function has run. Set hourglass_atimer to null
4475 so that we know the timer doesn't have to be canceled. */
4476 hourglass_atimer = NULL;
4478 if (!hourglass_shown_p)
4480 Lisp_Object rest, frame;
4482 BLOCK_INPUT;
4484 FOR_EACH_FRAME (rest, frame)
4486 struct frame *f = XFRAME (frame);
4488 if (FRAME_LIVE_P (f) && FRAME_X_P (f) && FRAME_X_DISPLAY (f))
4490 Display *dpy = FRAME_X_DISPLAY (f);
4492 #ifdef USE_X_TOOLKIT
4493 if (f->output_data.x->widget)
4494 #else
4495 if (FRAME_OUTER_WINDOW (f))
4496 #endif
4498 f->output_data.x->hourglass_p = 1;
4500 if (!f->output_data.x->hourglass_window)
4502 unsigned long mask = CWCursor;
4503 XSetWindowAttributes attrs;
4504 #ifdef USE_GTK
4505 Window parent = FRAME_X_WINDOW (f);
4506 #else
4507 Window parent = FRAME_OUTER_WINDOW (f);
4508 #endif
4509 attrs.cursor = f->output_data.x->hourglass_cursor;
4511 f->output_data.x->hourglass_window
4512 = XCreateWindow (dpy, parent,
4513 0, 0, 32000, 32000, 0, 0,
4514 InputOnly,
4515 CopyFromParent,
4516 mask, &attrs);
4519 XMapRaised (dpy, f->output_data.x->hourglass_window);
4520 XFlush (dpy);
4525 hourglass_shown_p = 1;
4526 UNBLOCK_INPUT;
4531 /* Hide the hourglass pointer on all frames, if it is currently
4532 shown. */
4534 static void
4535 hide_hourglass ()
4537 if (hourglass_shown_p)
4539 Lisp_Object rest, frame;
4541 BLOCK_INPUT;
4542 FOR_EACH_FRAME (rest, frame)
4544 struct frame *f = XFRAME (frame);
4546 if (FRAME_X_P (f)
4547 /* Watch out for newly created frames. */
4548 && f->output_data.x->hourglass_window)
4550 XUnmapWindow (FRAME_X_DISPLAY (f),
4551 f->output_data.x->hourglass_window);
4552 /* Sync here because XTread_socket looks at the
4553 hourglass_p flag that is reset to zero below. */
4554 XSync (FRAME_X_DISPLAY (f), False);
4555 f->output_data.x->hourglass_p = 0;
4559 hourglass_shown_p = 0;
4560 UNBLOCK_INPUT;
4566 /***********************************************************************
4567 Tool tips
4568 ***********************************************************************/
4570 static Lisp_Object x_create_tip_frame P_ ((struct x_display_info *,
4571 Lisp_Object, Lisp_Object));
4572 static void compute_tip_xy P_ ((struct frame *, Lisp_Object, Lisp_Object,
4573 Lisp_Object, int, int, int *, int *));
4575 /* The frame of a currently visible tooltip. */
4577 Lisp_Object tip_frame;
4579 /* If non-nil, a timer started that hides the last tooltip when it
4580 fires. */
4582 Lisp_Object tip_timer;
4583 Window tip_window;
4585 /* If non-nil, a vector of 3 elements containing the last args
4586 with which x-show-tip was called. See there. */
4588 Lisp_Object last_show_tip_args;
4590 /* Maximum size for tooltips; a cons (COLUMNS . ROWS). */
4592 Lisp_Object Vx_max_tooltip_size;
4595 static Lisp_Object
4596 unwind_create_tip_frame (frame)
4597 Lisp_Object frame;
4599 Lisp_Object deleted;
4601 deleted = unwind_create_frame (frame);
4602 if (EQ (deleted, Qt))
4604 tip_window = None;
4605 tip_frame = Qnil;
4608 return deleted;
4612 /* Create a frame for a tooltip on the display described by DPYINFO.
4613 PARMS is a list of frame parameters. TEXT is the string to
4614 display in the tip frame. Value is the frame.
4616 Note that functions called here, esp. x_default_parameter can
4617 signal errors, for instance when a specified color name is
4618 undefined. We have to make sure that we're in a consistent state
4619 when this happens. */
4621 static Lisp_Object
4622 x_create_tip_frame (dpyinfo, parms, text)
4623 struct x_display_info *dpyinfo;
4624 Lisp_Object parms, text;
4626 struct frame *f;
4627 Lisp_Object frame, tem;
4628 Lisp_Object name;
4629 long window_prompting = 0;
4630 int width, height;
4631 int count = SPECPDL_INDEX ();
4632 struct gcpro gcpro1, gcpro2, gcpro3;
4633 struct kboard *kb;
4634 int face_change_count_before = face_change_count;
4635 Lisp_Object buffer;
4636 struct buffer *old_buffer;
4638 check_x ();
4640 parms = Fcopy_alist (parms);
4642 #ifdef MULTI_KBOARD
4643 kb = dpyinfo->kboard;
4644 #else
4645 kb = &the_only_kboard;
4646 #endif
4648 /* Get the name of the frame to use for resource lookup. */
4649 name = x_get_arg (dpyinfo, parms, Qname, "name", "Name", RES_TYPE_STRING);
4650 if (!STRINGP (name)
4651 && !EQ (name, Qunbound)
4652 && !NILP (name))
4653 error ("Invalid frame name--not a string or nil");
4655 frame = Qnil;
4656 GCPRO3 (parms, name, frame);
4657 f = make_frame (1);
4658 XSETFRAME (frame, f);
4660 buffer = Fget_buffer_create (build_string (" *tip*"));
4661 Fset_window_buffer (FRAME_ROOT_WINDOW (f), buffer, Qnil);
4662 old_buffer = current_buffer;
4663 set_buffer_internal_1 (XBUFFER (buffer));
4664 current_buffer->truncate_lines = Qnil;
4665 specbind (Qinhibit_read_only, Qt);
4666 specbind (Qinhibit_modification_hooks, Qt);
4667 Ferase_buffer ();
4668 Finsert (1, &text);
4669 set_buffer_internal_1 (old_buffer);
4671 FRAME_CAN_HAVE_SCROLL_BARS (f) = 0;
4672 record_unwind_protect (unwind_create_tip_frame, frame);
4674 /* By setting the output method, we're essentially saying that
4675 the frame is live, as per FRAME_LIVE_P. If we get a signal
4676 from this point on, x_destroy_window might screw up reference
4677 counts etc. */
4678 f->output_method = output_x_window;
4679 f->output_data.x = (struct x_output *) xmalloc (sizeof (struct x_output));
4680 bzero (f->output_data.x, sizeof (struct x_output));
4681 f->output_data.x->icon_bitmap = -1;
4682 FRAME_FONTSET (f) = -1;
4683 f->output_data.x->scroll_bar_foreground_pixel = -1;
4684 f->output_data.x->scroll_bar_background_pixel = -1;
4685 #ifdef USE_TOOLKIT_SCROLL_BARS
4686 f->output_data.x->scroll_bar_top_shadow_pixel = -1;
4687 f->output_data.x->scroll_bar_bottom_shadow_pixel = -1;
4688 #endif /* USE_TOOLKIT_SCROLL_BARS */
4689 f->icon_name = Qnil;
4690 FRAME_X_DISPLAY_INFO (f) = dpyinfo;
4691 #if GLYPH_DEBUG
4692 image_cache_refcount = FRAME_X_IMAGE_CACHE (f)->refcount;
4693 dpyinfo_refcount = dpyinfo->reference_count;
4694 #endif /* GLYPH_DEBUG */
4695 #ifdef MULTI_KBOARD
4696 FRAME_KBOARD (f) = kb;
4697 #endif
4698 f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
4699 f->output_data.x->explicit_parent = 0;
4701 /* These colors will be set anyway later, but it's important
4702 to get the color reference counts right, so initialize them! */
4704 Lisp_Object black;
4705 struct gcpro gcpro1;
4707 black = build_string ("black");
4708 GCPRO1 (black);
4709 f->output_data.x->foreground_pixel
4710 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4711 f->output_data.x->background_pixel
4712 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4713 f->output_data.x->cursor_pixel
4714 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4715 f->output_data.x->cursor_foreground_pixel
4716 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4717 f->output_data.x->border_pixel
4718 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4719 f->output_data.x->mouse_pixel
4720 = x_decode_color (f, black, BLACK_PIX_DEFAULT (f));
4721 UNGCPRO;
4724 /* Set the name; the functions to which we pass f expect the name to
4725 be set. */
4726 if (EQ (name, Qunbound) || NILP (name))
4728 f->name = build_string (dpyinfo->x_id_name);
4729 f->explicit_name = 0;
4731 else
4733 f->name = name;
4734 f->explicit_name = 1;
4735 /* use the frame's title when getting resources for this frame. */
4736 specbind (Qx_resource_name, name);
4739 /* Extract the window parameters from the supplied values that are
4740 needed to determine window geometry. */
4742 Lisp_Object font;
4744 font = x_get_arg (dpyinfo, parms, Qfont, "font", "Font", RES_TYPE_STRING);
4746 BLOCK_INPUT;
4747 /* First, try whatever font the caller has specified. */
4748 if (STRINGP (font))
4750 tem = Fquery_fontset (font, Qnil);
4751 if (STRINGP (tem))
4752 font = x_new_fontset (f, SDATA (tem));
4753 else
4754 font = x_new_font (f, SDATA (font));
4757 /* Try out a font which we hope has bold and italic variations. */
4758 if (!STRINGP (font))
4759 font = x_new_font (f, "-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1");
4760 if (!STRINGP (font))
4761 font = x_new_font (f, "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
4762 if (! STRINGP (font))
4763 font = x_new_font (f, "-*-*-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
4764 if (! STRINGP (font))
4765 /* This was formerly the first thing tried, but it finds too many fonts
4766 and takes too long. */
4767 font = x_new_font (f, "-*-*-medium-r-*-*-*-*-*-*-c-*-iso8859-1");
4768 /* If those didn't work, look for something which will at least work. */
4769 if (! STRINGP (font))
4770 font = x_new_font (f, "-*-fixed-*-*-*-*-*-140-*-*-c-*-iso8859-1");
4771 UNBLOCK_INPUT;
4772 if (! STRINGP (font))
4773 font = build_string ("fixed");
4775 x_default_parameter (f, parms, Qfont, font,
4776 "font", "Font", RES_TYPE_STRING);
4779 x_default_parameter (f, parms, Qborder_width, make_number (2),
4780 "borderWidth", "BorderWidth", RES_TYPE_NUMBER);
4782 /* This defaults to 2 in order to match xterm. We recognize either
4783 internalBorderWidth or internalBorder (which is what xterm calls
4784 it). */
4785 if (NILP (Fassq (Qinternal_border_width, parms)))
4787 Lisp_Object value;
4789 value = x_get_arg (dpyinfo, parms, Qinternal_border_width,
4790 "internalBorder", "internalBorder", RES_TYPE_NUMBER);
4791 if (! EQ (value, Qunbound))
4792 parms = Fcons (Fcons (Qinternal_border_width, value),
4793 parms);
4796 x_default_parameter (f, parms, Qinternal_border_width, make_number (1),
4797 "internalBorderWidth", "internalBorderWidth",
4798 RES_TYPE_NUMBER);
4800 /* Also do the stuff which must be set before the window exists. */
4801 x_default_parameter (f, parms, Qforeground_color, build_string ("black"),
4802 "foreground", "Foreground", RES_TYPE_STRING);
4803 x_default_parameter (f, parms, Qbackground_color, build_string ("white"),
4804 "background", "Background", RES_TYPE_STRING);
4805 x_default_parameter (f, parms, Qmouse_color, build_string ("black"),
4806 "pointerColor", "Foreground", RES_TYPE_STRING);
4807 x_default_parameter (f, parms, Qcursor_color, build_string ("black"),
4808 "cursorColor", "Foreground", RES_TYPE_STRING);
4809 x_default_parameter (f, parms, Qborder_color, build_string ("black"),
4810 "borderColor", "BorderColor", RES_TYPE_STRING);
4812 /* Init faces before x_default_parameter is called for scroll-bar
4813 parameters because that function calls x_set_scroll_bar_width,
4814 which calls change_frame_size, which calls Fset_window_buffer,
4815 which runs hooks, which call Fvertical_motion. At the end, we
4816 end up in init_iterator with a null face cache, which should not
4817 happen. */
4818 init_frame_faces (f);
4820 f->output_data.x->parent_desc = FRAME_X_DISPLAY_INFO (f)->root_window;
4822 window_prompting = x_figure_window_size (f, parms, 0);
4825 XSetWindowAttributes attrs;
4826 unsigned long mask;
4828 BLOCK_INPUT;
4829 mask = CWBackPixel | CWOverrideRedirect | CWEventMask;
4830 if (DoesSaveUnders (dpyinfo->screen))
4831 mask |= CWSaveUnder;
4833 /* Window managers look at the override-redirect flag to determine
4834 whether or net to give windows a decoration (Xlib spec, chapter
4835 3.2.8). */
4836 attrs.override_redirect = True;
4837 attrs.save_under = True;
4838 attrs.background_pixel = FRAME_BACKGROUND_PIXEL (f);
4839 /* Arrange for getting MapNotify and UnmapNotify events. */
4840 attrs.event_mask = StructureNotifyMask;
4841 tip_window
4842 = FRAME_X_WINDOW (f)
4843 = XCreateWindow (FRAME_X_DISPLAY (f),
4844 FRAME_X_DISPLAY_INFO (f)->root_window,
4845 /* x, y, width, height */
4846 0, 0, 1, 1,
4847 /* Border. */
4849 CopyFromParent, InputOutput, CopyFromParent,
4850 mask, &attrs);
4851 UNBLOCK_INPUT;
4854 x_make_gc (f);
4856 x_default_parameter (f, parms, Qauto_raise, Qnil,
4857 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN);
4858 x_default_parameter (f, parms, Qauto_lower, Qnil,
4859 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN);
4860 x_default_parameter (f, parms, Qcursor_type, Qbox,
4861 "cursorType", "CursorType", RES_TYPE_SYMBOL);
4863 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
4864 Change will not be effected unless different from the current
4865 FRAME_LINES (f). */
4866 width = FRAME_COLS (f);
4867 height = FRAME_LINES (f);
4868 SET_FRAME_COLS (f, 0);
4869 FRAME_LINES (f) = 0;
4870 change_frame_size (f, height, width, 1, 0, 0);
4872 /* Add `tooltip' frame parameter's default value. */
4873 if (NILP (Fframe_parameter (frame, intern ("tooltip"))))
4874 Fmodify_frame_parameters (frame, Fcons (Fcons (intern ("tooltip"), Qt),
4875 Qnil));
4877 /* Set up faces after all frame parameters are known. This call
4878 also merges in face attributes specified for new frames.
4880 Frame parameters may be changed if .Xdefaults contains
4881 specifications for the default font. For example, if there is an
4882 `Emacs.default.attributeBackground: pink', the `background-color'
4883 attribute of the frame get's set, which let's the internal border
4884 of the tooltip frame appear in pink. Prevent this. */
4886 Lisp_Object bg = Fframe_parameter (frame, Qbackground_color);
4888 /* Set tip_frame here, so that */
4889 tip_frame = frame;
4890 call1 (Qface_set_after_frame_default, frame);
4892 if (!EQ (bg, Fframe_parameter (frame, Qbackground_color)))
4893 Fmodify_frame_parameters (frame, Fcons (Fcons (Qbackground_color, bg),
4894 Qnil));
4897 f->no_split = 1;
4899 UNGCPRO;
4901 /* It is now ok to make the frame official even if we get an error
4902 below. And the frame needs to be on Vframe_list or making it
4903 visible won't work. */
4904 Vframe_list = Fcons (frame, Vframe_list);
4906 /* Now that the frame is official, it counts as a reference to
4907 its display. */
4908 FRAME_X_DISPLAY_INFO (f)->reference_count++;
4910 /* Setting attributes of faces of the tooltip frame from resources
4911 and similar will increment face_change_count, which leads to the
4912 clearing of all current matrices. Since this isn't necessary
4913 here, avoid it by resetting face_change_count to the value it
4914 had before we created the tip frame. */
4915 face_change_count = face_change_count_before;
4917 /* Discard the unwind_protect. */
4918 return unbind_to (count, frame);
4922 /* Compute where to display tip frame F. PARMS is the list of frame
4923 parameters for F. DX and DY are specified offsets from the current
4924 location of the mouse. WIDTH and HEIGHT are the width and height
4925 of the tooltip. Return coordinates relative to the root window of
4926 the display in *ROOT_X, and *ROOT_Y. */
4928 static void
4929 compute_tip_xy (f, parms, dx, dy, width, height, root_x, root_y)
4930 struct frame *f;
4931 Lisp_Object parms, dx, dy;
4932 int width, height;
4933 int *root_x, *root_y;
4935 Lisp_Object left, top;
4936 int win_x, win_y;
4937 Window root, child;
4938 unsigned pmask;
4940 /* User-specified position? */
4941 left = Fcdr (Fassq (Qleft, parms));
4942 top = Fcdr (Fassq (Qtop, parms));
4944 /* Move the tooltip window where the mouse pointer is. Resize and
4945 show it. */
4946 if (!INTEGERP (left) || !INTEGERP (top))
4948 BLOCK_INPUT;
4949 XQueryPointer (FRAME_X_DISPLAY (f), FRAME_X_DISPLAY_INFO (f)->root_window,
4950 &root, &child, root_x, root_y, &win_x, &win_y, &pmask);
4951 UNBLOCK_INPUT;
4954 if (INTEGERP (top))
4955 *root_y = XINT (top);
4956 else if (*root_y + XINT (dy) <= 0)
4957 *root_y = 0; /* Can happen for negative dy */
4958 else if (*root_y + XINT (dy) + height <= FRAME_X_DISPLAY_INFO (f)->height)
4959 /* It fits below the pointer */
4960 *root_y += XINT (dy);
4961 else if (height + XINT (dy) <= *root_y)
4962 /* It fits above the pointer. */
4963 *root_y -= height + XINT (dy);
4964 else
4965 /* Put it on the top. */
4966 *root_y = 0;
4968 if (INTEGERP (left))
4969 *root_x = XINT (left);
4970 else if (*root_x + XINT (dx) <= 0)
4971 *root_x = 0; /* Can happen for negative dx */
4972 else if (*root_x + XINT (dx) + width <= FRAME_X_DISPLAY_INFO (f)->width)
4973 /* It fits to the right of the pointer. */
4974 *root_x += XINT (dx);
4975 else if (width + XINT (dx) <= *root_x)
4976 /* It fits to the left of the pointer. */
4977 *root_x -= width + XINT (dx);
4978 else
4979 /* Put it left-justified on the screen--it ought to fit that way. */
4980 *root_x = 0;
4984 DEFUN ("x-show-tip", Fx_show_tip, Sx_show_tip, 1, 6, 0,
4985 doc: /* Show STRING in a "tooltip" window on frame FRAME.
4986 A tooltip window is a small X window displaying a string.
4988 FRAME nil or omitted means use the selected frame.
4990 PARMS is an optional list of frame parameters which can be used to
4991 change the tooltip's appearance.
4993 Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
4994 means use the default timeout of 5 seconds.
4996 If the list of frame parameters PARAMS contains a `left' parameters,
4997 the tooltip is displayed at that x-position. Otherwise it is
4998 displayed at the mouse position, with offset DX added (default is 5 if
4999 DX isn't specified). Likewise for the y-position; if a `top' frame
5000 parameter is specified, it determines the y-position of the tooltip
5001 window, otherwise it is displayed at the mouse position, with offset
5002 DY added (default is -10).
5004 A tooltip's maximum size is specified by `x-max-tooltip-size'.
5005 Text larger than the specified size is clipped. */)
5006 (string, frame, parms, timeout, dx, dy)
5007 Lisp_Object string, frame, parms, timeout, dx, dy;
5009 struct frame *f;
5010 struct window *w;
5011 int root_x, root_y;
5012 struct buffer *old_buffer;
5013 struct text_pos pos;
5014 int i, width, height;
5015 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4;
5016 int old_windows_or_buffers_changed = windows_or_buffers_changed;
5017 int count = SPECPDL_INDEX ();
5019 specbind (Qinhibit_redisplay, Qt);
5021 GCPRO4 (string, parms, frame, timeout);
5023 CHECK_STRING (string);
5024 f = check_x_frame (frame);
5025 if (NILP (timeout))
5026 timeout = make_number (5);
5027 else
5028 CHECK_NATNUM (timeout);
5030 if (NILP (dx))
5031 dx = make_number (5);
5032 else
5033 CHECK_NUMBER (dx);
5035 if (NILP (dy))
5036 dy = make_number (-10);
5037 else
5038 CHECK_NUMBER (dy);
5040 if (NILP (last_show_tip_args))
5041 last_show_tip_args = Fmake_vector (make_number (3), Qnil);
5043 if (!NILP (tip_frame))
5045 Lisp_Object last_string = AREF (last_show_tip_args, 0);
5046 Lisp_Object last_frame = AREF (last_show_tip_args, 1);
5047 Lisp_Object last_parms = AREF (last_show_tip_args, 2);
5049 if (EQ (frame, last_frame)
5050 && !NILP (Fequal (last_string, string))
5051 && !NILP (Fequal (last_parms, parms)))
5053 struct frame *f = XFRAME (tip_frame);
5055 /* Only DX and DY have changed. */
5056 if (!NILP (tip_timer))
5058 Lisp_Object timer = tip_timer;
5059 tip_timer = Qnil;
5060 call1 (Qcancel_timer, timer);
5063 BLOCK_INPUT;
5064 compute_tip_xy (f, parms, dx, dy, FRAME_PIXEL_WIDTH (f),
5065 FRAME_PIXEL_HEIGHT (f), &root_x, &root_y);
5066 XMoveWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
5067 root_x, root_y);
5068 UNBLOCK_INPUT;
5069 goto start_timer;
5073 /* Hide a previous tip, if any. */
5074 Fx_hide_tip ();
5076 ASET (last_show_tip_args, 0, string);
5077 ASET (last_show_tip_args, 1, frame);
5078 ASET (last_show_tip_args, 2, parms);
5080 /* Add default values to frame parameters. */
5081 if (NILP (Fassq (Qname, parms)))
5082 parms = Fcons (Fcons (Qname, build_string ("tooltip")), parms);
5083 if (NILP (Fassq (Qinternal_border_width, parms)))
5084 parms = Fcons (Fcons (Qinternal_border_width, make_number (3)), parms);
5085 if (NILP (Fassq (Qborder_width, parms)))
5086 parms = Fcons (Fcons (Qborder_width, make_number (1)), parms);
5087 if (NILP (Fassq (Qborder_color, parms)))
5088 parms = Fcons (Fcons (Qborder_color, build_string ("lightyellow")), parms);
5089 if (NILP (Fassq (Qbackground_color, parms)))
5090 parms = Fcons (Fcons (Qbackground_color, build_string ("lightyellow")),
5091 parms);
5093 /* Create a frame for the tooltip, and record it in the global
5094 variable tip_frame. */
5095 frame = x_create_tip_frame (FRAME_X_DISPLAY_INFO (f), parms, string);
5096 f = XFRAME (frame);
5098 /* Set up the frame's root window. */
5099 w = XWINDOW (FRAME_ROOT_WINDOW (f));
5100 w->left_col = w->top_line = make_number (0);
5102 if (CONSP (Vx_max_tooltip_size)
5103 && INTEGERP (XCAR (Vx_max_tooltip_size))
5104 && XINT (XCAR (Vx_max_tooltip_size)) > 0
5105 && INTEGERP (XCDR (Vx_max_tooltip_size))
5106 && XINT (XCDR (Vx_max_tooltip_size)) > 0)
5108 w->total_cols = XCAR (Vx_max_tooltip_size);
5109 w->total_lines = XCDR (Vx_max_tooltip_size);
5111 else
5113 w->total_cols = make_number (80);
5114 w->total_lines = make_number (40);
5117 FRAME_TOTAL_COLS (f) = XINT (w->total_cols);
5118 adjust_glyphs (f);
5119 w->pseudo_window_p = 1;
5121 /* Display the tooltip text in a temporary buffer. */
5122 old_buffer = current_buffer;
5123 set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f))->buffer));
5124 current_buffer->truncate_lines = Qnil;
5125 clear_glyph_matrix (w->desired_matrix);
5126 clear_glyph_matrix (w->current_matrix);
5127 SET_TEXT_POS (pos, BEGV, BEGV_BYTE);
5128 try_window (FRAME_ROOT_WINDOW (f), pos, 0);
5130 /* Compute width and height of the tooltip. */
5131 width = height = 0;
5132 for (i = 0; i < w->desired_matrix->nrows; ++i)
5134 struct glyph_row *row = &w->desired_matrix->rows[i];
5135 struct glyph *last;
5136 int row_width;
5138 /* Stop at the first empty row at the end. */
5139 if (!row->enabled_p || !row->displays_text_p)
5140 break;
5142 /* Let the row go over the full width of the frame. */
5143 row->full_width_p = 1;
5145 /* There's a glyph at the end of rows that is used to place
5146 the cursor there. Don't include the width of this glyph. */
5147 if (row->used[TEXT_AREA])
5149 last = &row->glyphs[TEXT_AREA][row->used[TEXT_AREA] - 1];
5150 row_width = row->pixel_width - last->pixel_width;
5152 else
5153 row_width = row->pixel_width;
5155 height += row->height;
5156 width = max (width, row_width);
5159 /* Add the frame's internal border to the width and height the X
5160 window should have. */
5161 height += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
5162 width += 2 * FRAME_INTERNAL_BORDER_WIDTH (f);
5164 /* Move the tooltip window where the mouse pointer is. Resize and
5165 show it. */
5166 compute_tip_xy (f, parms, dx, dy, width, height, &root_x, &root_y);
5168 BLOCK_INPUT;
5169 XMoveResizeWindow (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f),
5170 root_x, root_y, width, height);
5171 XMapRaised (FRAME_X_DISPLAY (f), FRAME_X_WINDOW (f));
5172 UNBLOCK_INPUT;
5174 /* Draw into the window. */
5175 w->must_be_updated_p = 1;
5176 update_single_window (w, 1);
5178 /* Restore original current buffer. */
5179 set_buffer_internal_1 (old_buffer);
5180 windows_or_buffers_changed = old_windows_or_buffers_changed;
5182 start_timer:
5183 /* Let the tip disappear after timeout seconds. */
5184 tip_timer = call3 (intern ("run-at-time"), timeout, Qnil,
5185 intern ("x-hide-tip"));
5187 UNGCPRO;
5188 return unbind_to (count, Qnil);
5192 DEFUN ("x-hide-tip", Fx_hide_tip, Sx_hide_tip, 0, 0, 0,
5193 doc: /* Hide the current tooltip window, if there is any.
5194 Value is t if tooltip was open, nil otherwise. */)
5197 int count;
5198 Lisp_Object deleted, frame, timer;
5199 struct gcpro gcpro1, gcpro2;
5201 /* Return quickly if nothing to do. */
5202 if (NILP (tip_timer) && NILP (tip_frame))
5203 return Qnil;
5205 frame = tip_frame;
5206 timer = tip_timer;
5207 GCPRO2 (frame, timer);
5208 tip_frame = tip_timer = deleted = Qnil;
5210 count = SPECPDL_INDEX ();
5211 specbind (Qinhibit_redisplay, Qt);
5212 specbind (Qinhibit_quit, Qt);
5214 if (!NILP (timer))
5215 call1 (Qcancel_timer, timer);
5217 if (FRAMEP (frame))
5219 Fdelete_frame (frame, Qnil);
5220 deleted = Qt;
5222 #ifdef USE_LUCID
5223 /* Bloodcurdling hack alert: The Lucid menu bar widget's
5224 redisplay procedure is not called when a tip frame over menu
5225 items is unmapped. Redisplay the menu manually... */
5227 struct frame *f = SELECTED_FRAME ();
5228 Widget w = f->output_data.x->menubar_widget;
5229 extern void xlwmenu_redisplay P_ ((Widget));
5231 if (!DoesSaveUnders (FRAME_X_DISPLAY_INFO (f)->screen)
5232 && w != NULL)
5234 BLOCK_INPUT;
5235 xlwmenu_redisplay (w);
5236 UNBLOCK_INPUT;
5239 #endif /* USE_LUCID */
5242 UNGCPRO;
5243 return unbind_to (count, deleted);
5248 /***********************************************************************
5249 File selection dialog
5250 ***********************************************************************/
5252 DEFUN ("x-uses-old-gtk-dialog", Fx_uses_old_gtk_dialog,
5253 Sx_uses_old_gtk_dialog,
5254 0, 0, 0,
5255 doc: /* Return t if the old Gtk+ file selection dialog is used. */)
5258 #ifdef USE_GTK
5259 extern int use_dialog_box;
5260 extern int use_file_dialog;
5262 if (use_dialog_box
5263 && use_file_dialog
5264 && have_menus_p ()
5265 && xg_uses_old_file_dialog ())
5266 return Qt;
5267 #endif
5268 return Qnil;
5272 #ifdef USE_MOTIF
5273 /* Callback for "OK" and "Cancel" on file selection dialog. */
5275 static void
5276 file_dialog_cb (widget, client_data, call_data)
5277 Widget widget;
5278 XtPointer call_data, client_data;
5280 int *result = (int *) client_data;
5281 XmAnyCallbackStruct *cb = (XmAnyCallbackStruct *) call_data;
5282 *result = cb->reason;
5286 /* Callback for unmapping a file selection dialog. This is used to
5287 capture the case where a dialog is closed via a window manager's
5288 closer button, for example. Using a XmNdestroyCallback didn't work
5289 in this case. */
5291 static void
5292 file_dialog_unmap_cb (widget, client_data, call_data)
5293 Widget widget;
5294 XtPointer call_data, client_data;
5296 int *result = (int *) client_data;
5297 *result = XmCR_CANCEL;
5300 static Lisp_Object
5301 clean_up_file_dialog (arg)
5302 Lisp_Object arg;
5304 struct Lisp_Save_Value *p = XSAVE_VALUE (arg);
5305 Widget dialog = (Widget) p->pointer;
5307 /* Clean up. */
5308 BLOCK_INPUT;
5309 XtUnmanageChild (dialog);
5310 XtDestroyWidget (dialog);
5311 x_menu_set_in_use (0);
5312 UNBLOCK_INPUT;
5314 return Qnil;
5318 DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
5319 doc: /* Read file name, prompting with PROMPT in directory DIR.
5320 Use a file selection dialog. Select DEFAULT-FILENAME in the dialog's file
5321 selection box, if specified. If MUSTMATCH is non-nil, the returned file
5322 or directory must exist. ONLY-DIR-P is ignored." */)
5323 (prompt, dir, default_filename, mustmatch, only_dir_p)
5324 Lisp_Object prompt, dir, default_filename, mustmatch, only_dir_p;
5326 int result;
5327 struct frame *f = SELECTED_FRAME ();
5328 Lisp_Object file = Qnil;
5329 Lisp_Object decoded_file;
5330 Widget dialog, text, help;
5331 Arg al[10];
5332 int ac = 0;
5333 extern XtAppContext Xt_app_con;
5334 XmString dir_xmstring, pattern_xmstring;
5335 int count = SPECPDL_INDEX ();
5336 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
5338 GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
5340 if (popup_activated ())
5341 error ("Trying to use a menu from within a menu-entry");
5343 CHECK_STRING (prompt);
5344 CHECK_STRING (dir);
5346 /* Prevent redisplay. */
5347 specbind (Qinhibit_redisplay, Qt);
5349 BLOCK_INPUT;
5351 /* Create the dialog with PROMPT as title, using DIR as initial
5352 directory and using "*" as pattern. */
5353 dir = Fexpand_file_name (dir, Qnil);
5354 dir_xmstring = XmStringCreateLocalized (SDATA (dir));
5355 pattern_xmstring = XmStringCreateLocalized ("*");
5357 XtSetArg (al[ac], XmNtitle, SDATA (prompt)); ++ac;
5358 XtSetArg (al[ac], XmNdirectory, dir_xmstring); ++ac;
5359 XtSetArg (al[ac], XmNpattern, pattern_xmstring); ++ac;
5360 XtSetArg (al[ac], XmNresizePolicy, XmRESIZE_GROW); ++ac;
5361 XtSetArg (al[ac], XmNdialogStyle, XmDIALOG_APPLICATION_MODAL); ++ac;
5362 dialog = XmCreateFileSelectionDialog (f->output_data.x->widget,
5363 "fsb", al, ac);
5364 XmStringFree (dir_xmstring);
5365 XmStringFree (pattern_xmstring);
5367 /* Add callbacks for OK and Cancel. */
5368 XtAddCallback (dialog, XmNokCallback, file_dialog_cb,
5369 (XtPointer) &result);
5370 XtAddCallback (dialog, XmNcancelCallback, file_dialog_cb,
5371 (XtPointer) &result);
5372 XtAddCallback (dialog, XmNunmapCallback, file_dialog_unmap_cb,
5373 (XtPointer) &result);
5375 /* Remove the help button since we can't display help. */
5376 help = XmFileSelectionBoxGetChild (dialog, XmDIALOG_HELP_BUTTON);
5377 XtUnmanageChild (help);
5379 /* Mark OK button as default. */
5380 XtVaSetValues (XmFileSelectionBoxGetChild (dialog, XmDIALOG_OK_BUTTON),
5381 XmNshowAsDefault, True, NULL);
5383 /* If MUSTMATCH is non-nil, disable the file entry field of the
5384 dialog, so that the user must select a file from the files list
5385 box. We can't remove it because we wouldn't have a way to get at
5386 the result file name, then. */
5387 text = XmFileSelectionBoxGetChild (dialog, XmDIALOG_TEXT);
5388 if (!NILP (mustmatch))
5390 Widget label;
5391 label = XmFileSelectionBoxGetChild (dialog, XmDIALOG_SELECTION_LABEL);
5392 XtSetSensitive (text, False);
5393 XtSetSensitive (label, False);
5396 /* Manage the dialog, so that list boxes get filled. */
5397 XtManageChild (dialog);
5399 if (STRINGP (default_filename))
5401 XmString default_xmstring;
5402 Widget wtext = XmFileSelectionBoxGetChild (dialog, XmDIALOG_TEXT);
5403 Widget list = XmFileSelectionBoxGetChild (dialog, XmDIALOG_LIST);
5405 XmTextPosition last_pos = XmTextFieldGetLastPosition (wtext);
5406 XmTextFieldReplace (wtext, 0, last_pos,
5407 (SDATA (Ffile_name_nondirectory (default_filename))));
5409 /* Select DEFAULT_FILENAME in the files list box. DEFAULT_FILENAME
5410 must include the path for this to work. */
5412 default_xmstring = XmStringCreateLocalized (SDATA (default_filename));
5414 if (XmListItemExists (list, default_xmstring))
5416 int item_pos = XmListItemPos (list, default_xmstring);
5417 /* Select the item and scroll it into view. */
5418 XmListSelectPos (list, item_pos, True);
5419 XmListSetPos (list, item_pos);
5422 XmStringFree (default_xmstring);
5425 record_unwind_protect (clean_up_file_dialog, make_save_value (dialog, 0));
5427 /* Process events until the user presses Cancel or OK. */
5428 x_menu_set_in_use (1);
5429 result = 0;
5430 while (result == 0)
5432 XEvent event;
5433 x_menu_wait_for_event (0);
5434 XtAppNextEvent (Xt_app_con, &event);
5435 if (event.type == KeyPress
5436 && FRAME_X_DISPLAY (f) == event.xkey.display)
5438 KeySym keysym = XLookupKeysym (&event.xkey, 0);
5440 /* Pop down on C-g. */
5441 if (keysym == XK_g && (event.xkey.state & ControlMask) != 0)
5442 XtUnmanageChild (dialog);
5445 (void) x_dispatch_event (&event, FRAME_X_DISPLAY (f));
5448 /* Get the result. */
5449 if (result == XmCR_OK)
5451 XmString text;
5452 String data;
5454 XtVaGetValues (dialog, XmNtextString, &text, NULL);
5455 XmStringGetLtoR (text, XmFONTLIST_DEFAULT_TAG, &data);
5456 XmStringFree (text);
5457 file = build_string (data);
5458 XtFree (data);
5460 else
5461 file = Qnil;
5463 UNBLOCK_INPUT;
5464 UNGCPRO;
5466 /* Make "Cancel" equivalent to C-g. */
5467 if (NILP (file))
5468 Fsignal (Qquit, Qnil);
5470 decoded_file = DECODE_FILE (file);
5472 return unbind_to (count, decoded_file);
5475 #endif /* USE_MOTIF */
5477 #ifdef USE_GTK
5479 static Lisp_Object
5480 clean_up_dialog (arg)
5481 Lisp_Object arg;
5483 x_menu_set_in_use (0);
5485 return Qnil;
5488 DEFUN ("x-file-dialog", Fx_file_dialog, Sx_file_dialog, 2, 5, 0,
5489 doc: /* Read file name, prompting with PROMPT in directory DIR.
5490 Use a file selection dialog. Select DEFAULT-FILENAME in the dialog's file
5491 selection box, if specified. If MUSTMATCH is non-nil, the returned file
5492 or directory must exist. If ONLY-DIR-P is non-nil, the user can only select
5493 directories. */)
5494 (prompt, dir, default_filename, mustmatch, only_dir_p)
5495 Lisp_Object prompt, dir, default_filename, mustmatch, only_dir_p;
5497 FRAME_PTR f = SELECTED_FRAME ();
5498 char *fn;
5499 Lisp_Object file = Qnil;
5500 Lisp_Object decoded_file;
5501 int count = SPECPDL_INDEX ();
5502 struct gcpro gcpro1, gcpro2, gcpro3, gcpro4, gcpro5, gcpro6;
5503 char *cdef_file;
5505 GCPRO6 (prompt, dir, default_filename, mustmatch, only_dir_p, file);
5507 if (popup_activated ())
5508 error ("Trying to use a menu from within a menu-entry");
5510 CHECK_STRING (prompt);
5511 CHECK_STRING (dir);
5513 /* Prevent redisplay. */
5514 specbind (Qinhibit_redisplay, Qt);
5515 record_unwind_protect (clean_up_dialog, Qnil);
5517 BLOCK_INPUT;
5519 if (STRINGP (default_filename))
5520 cdef_file = SDATA (default_filename);
5521 else
5522 cdef_file = SDATA (dir);
5524 fn = xg_get_file_name (f, SDATA (prompt), cdef_file,
5525 ! NILP (mustmatch),
5526 ! NILP (only_dir_p));
5528 if (fn)
5530 file = build_string (fn);
5531 xfree (fn);
5534 UNBLOCK_INPUT;
5535 UNGCPRO;
5537 /* Make "Cancel" equivalent to C-g. */
5538 if (NILP (file))
5539 Fsignal (Qquit, Qnil);
5541 decoded_file = DECODE_FILE (file);
5543 return unbind_to (count, decoded_file);
5546 #endif /* USE_GTK */
5549 /***********************************************************************
5550 Keyboard
5551 ***********************************************************************/
5553 #ifdef HAVE_XKBGETKEYBOARD
5554 #include <X11/XKBlib.h>
5555 #include <X11/keysym.h>
5556 #endif
5558 DEFUN ("x-backspace-delete-keys-p", Fx_backspace_delete_keys_p,
5559 Sx_backspace_delete_keys_p, 0, 1, 0,
5560 doc: /* Check if both Backspace and Delete keys are on the keyboard of FRAME.
5561 FRAME nil means use the selected frame.
5562 Value is t if we know that both keys are present, and are mapped to the
5563 usual X keysyms. Value is `lambda' if we cannot determine if both keys are
5564 present and mapped to the usual X keysyms. */)
5565 (frame)
5566 Lisp_Object frame;
5568 #ifdef HAVE_XKBGETKEYBOARD
5569 XkbDescPtr kb;
5570 struct frame *f = check_x_frame (frame);
5571 Display *dpy = FRAME_X_DISPLAY (f);
5572 Lisp_Object have_keys;
5573 int major, minor, op, event, error;
5575 BLOCK_INPUT;
5577 /* Check library version in case we're dynamically linked. */
5578 major = XkbMajorVersion;
5579 minor = XkbMinorVersion;
5580 if (!XkbLibraryVersion (&major, &minor))
5582 UNBLOCK_INPUT;
5583 return Qlambda;
5586 /* Check that the server supports XKB. */
5587 major = XkbMajorVersion;
5588 minor = XkbMinorVersion;
5589 if (!XkbQueryExtension (dpy, &op, &event, &error, &major, &minor))
5591 UNBLOCK_INPUT;
5592 return Qlambda;
5595 /* In this code we check that the keyboard has physical keys with names
5596 that start with BKSP (Backspace) and DELE (Delete), and that they
5597 generate keysym XK_BackSpace and XK_Delete respectively.
5598 This function is used to test if normal-erase-is-backspace should be
5599 turned on.
5600 An alternative approach would be to just check if XK_BackSpace and
5601 XK_Delete are mapped to any key. But if any of those are mapped to
5602 some non-intuitive key combination (Meta-Shift-Ctrl-whatever) and the
5603 user doesn't know about it, it is better to return false here.
5604 It is more obvious to the user what to do if she/he has two keys
5605 clearly marked with names/symbols and one key does something not
5606 expected (i.e. she/he then tries the other).
5607 The cases where Backspace/Delete is mapped to some other key combination
5608 are rare, and in those cases, normal-erase-is-backspace can be turned on
5609 manually. */
5611 have_keys = Qnil;
5612 kb = XkbGetMap (dpy, XkbAllMapComponentsMask, XkbUseCoreKbd);
5613 if (kb)
5615 int delete_keycode = 0, backspace_keycode = 0, i;
5617 if (XkbGetNames (dpy, XkbAllNamesMask, kb) == Success)
5619 for (i = kb->min_key_code;
5620 (i < kb->max_key_code
5621 && (delete_keycode == 0 || backspace_keycode == 0));
5622 ++i)
5624 /* The XKB symbolic key names can be seen most easily in
5625 the PS file generated by `xkbprint -label name
5626 $DISPLAY'. */
5627 if (bcmp ("DELE", kb->names->keys[i].name, 4) == 0)
5628 delete_keycode = i;
5629 else if (bcmp ("BKSP", kb->names->keys[i].name, 4) == 0)
5630 backspace_keycode = i;
5633 XkbFreeNames (kb, 0, True);
5636 XkbFreeClientMap (kb, 0, True);
5638 if (delete_keycode
5639 && backspace_keycode
5640 && XKeysymToKeycode (dpy, XK_Delete) == delete_keycode
5641 && XKeysymToKeycode (dpy, XK_BackSpace) == backspace_keycode)
5642 have_keys = Qt;
5644 UNBLOCK_INPUT;
5645 return have_keys;
5646 #else /* not HAVE_XKBGETKEYBOARD */
5647 return Qlambda;
5648 #endif /* not HAVE_XKBGETKEYBOARD */
5653 /***********************************************************************
5654 Initialization
5655 ***********************************************************************/
5657 /* Keep this list in the same order as frame_parms in frame.c.
5658 Use 0 for unsupported frame parameters. */
5660 frame_parm_handler x_frame_parm_handlers[] =
5662 x_set_autoraise,
5663 x_set_autolower,
5664 x_set_background_color,
5665 x_set_border_color,
5666 x_set_border_width,
5667 x_set_cursor_color,
5668 x_set_cursor_type,
5669 x_set_font,
5670 x_set_foreground_color,
5671 x_set_icon_name,
5672 x_set_icon_type,
5673 x_set_internal_border_width,
5674 x_set_menu_bar_lines,
5675 x_set_mouse_color,
5676 x_explicitly_set_name,
5677 x_set_scroll_bar_width,
5678 x_set_title,
5679 x_set_unsplittable,
5680 x_set_vertical_scroll_bars,
5681 x_set_visibility,
5682 x_set_tool_bar_lines,
5683 x_set_scroll_bar_foreground,
5684 x_set_scroll_bar_background,
5685 x_set_screen_gamma,
5686 x_set_line_spacing,
5687 x_set_fringe_width,
5688 x_set_fringe_width,
5689 x_set_wait_for_wm,
5690 x_set_fullscreen,
5693 void
5694 syms_of_xfns ()
5696 /* This is zero if not using X windows. */
5697 x_in_use = 0;
5699 /* The section below is built by the lisp expression at the top of the file,
5700 just above where these variables are declared. */
5701 /*&&& init symbols here &&&*/
5702 Qnone = intern ("none");
5703 staticpro (&Qnone);
5704 Qsuppress_icon = intern ("suppress-icon");
5705 staticpro (&Qsuppress_icon);
5706 Qundefined_color = intern ("undefined-color");
5707 staticpro (&Qundefined_color);
5708 Qcompound_text = intern ("compound-text");
5709 staticpro (&Qcompound_text);
5710 Qcancel_timer = intern ("cancel-timer");
5711 staticpro (&Qcancel_timer);
5712 /* This is the end of symbol initialization. */
5714 /* Text property `display' should be nonsticky by default. */
5715 Vtext_property_default_nonsticky
5716 = Fcons (Fcons (Qdisplay, Qt), Vtext_property_default_nonsticky);
5719 Fput (Qundefined_color, Qerror_conditions,
5720 Fcons (Qundefined_color, Fcons (Qerror, Qnil)));
5721 Fput (Qundefined_color, Qerror_message,
5722 build_string ("Undefined color"));
5724 DEFVAR_LISP ("x-pointer-shape", &Vx_pointer_shape,
5725 doc: /* The shape of the pointer when over text.
5726 Changing the value does not affect existing frames
5727 unless you set the mouse color. */);
5728 Vx_pointer_shape = Qnil;
5730 #if 0 /* This doesn't really do anything. */
5731 DEFVAR_LISP ("x-nontext-pointer-shape", &Vx_nontext_pointer_shape,
5732 doc: /* The shape of the pointer when not over text.
5733 This variable takes effect when you create a new frame
5734 or when you set the mouse color. */);
5735 #endif
5736 Vx_nontext_pointer_shape = Qnil;
5738 DEFVAR_LISP ("x-hourglass-pointer-shape", &Vx_hourglass_pointer_shape,
5739 doc: /* The shape of the pointer when Emacs is busy.
5740 This variable takes effect when you create a new frame
5741 or when you set the mouse color. */);
5742 Vx_hourglass_pointer_shape = Qnil;
5744 DEFVAR_BOOL ("display-hourglass", &display_hourglass_p,
5745 doc: /* Non-zero means Emacs displays an hourglass pointer on window systems. */);
5746 display_hourglass_p = 1;
5748 DEFVAR_LISP ("hourglass-delay", &Vhourglass_delay,
5749 doc: /* *Seconds to wait before displaying an hourglass pointer.
5750 Value must be an integer or float. */);
5751 Vhourglass_delay = make_number (DEFAULT_HOURGLASS_DELAY);
5753 #if 0 /* This doesn't really do anything. */
5754 DEFVAR_LISP ("x-mode-pointer-shape", &Vx_mode_pointer_shape,
5755 doc: /* The shape of the pointer when over the mode line.
5756 This variable takes effect when you create a new frame
5757 or when you set the mouse color. */);
5758 #endif
5759 Vx_mode_pointer_shape = Qnil;
5761 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
5762 &Vx_sensitive_text_pointer_shape,
5763 doc: /* The shape of the pointer when over mouse-sensitive text.
5764 This variable takes effect when you create a new frame
5765 or when you set the mouse color. */);
5766 Vx_sensitive_text_pointer_shape = Qnil;
5768 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
5769 &Vx_window_horizontal_drag_shape,
5770 doc: /* Pointer shape to use for indicating a window can be dragged horizontally.
5771 This variable takes effect when you create a new frame
5772 or when you set the mouse color. */);
5773 Vx_window_horizontal_drag_shape = Qnil;
5775 DEFVAR_LISP ("x-cursor-fore-pixel", &Vx_cursor_fore_pixel,
5776 doc: /* A string indicating the foreground color of the cursor box. */);
5777 Vx_cursor_fore_pixel = Qnil;
5779 DEFVAR_LISP ("x-max-tooltip-size", &Vx_max_tooltip_size,
5780 doc: /* Maximum size for tooltips. Value is a pair (COLUMNS . ROWS).
5781 Text larger than this is clipped. */);
5782 Vx_max_tooltip_size = Fcons (make_number (80), make_number (40));
5784 DEFVAR_LISP ("x-no-window-manager", &Vx_no_window_manager,
5785 doc: /* Non-nil if no X window manager is in use.
5786 Emacs doesn't try to figure this out; this is always nil
5787 unless you set it to something else. */);
5788 /* We don't have any way to find this out, so set it to nil
5789 and maybe the user would like to set it to t. */
5790 Vx_no_window_manager = Qnil;
5792 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
5793 &Vx_pixel_size_width_font_regexp,
5794 doc: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
5796 Since Emacs gets width of a font matching with this regexp from
5797 PIXEL_SIZE field of the name, font finding mechanism gets faster for
5798 such a font. This is especially effective for such large fonts as
5799 Chinese, Japanese, and Korean. */);
5800 Vx_pixel_size_width_font_regexp = Qnil;
5802 /* This is not ifdef:ed, so other builds than GTK can customize it. */
5803 DEFVAR_BOOL ("x-use-old-gtk-file-dialog", &x_use_old_gtk_file_dialog,
5804 doc: /* *Non-nil means prompt with the old GTK file selection dialog.
5805 If nil or if the file selection dialog is not available, the new GTK file
5806 chooser is used instead. To turn off all file dialogs set the
5807 variable `use-file-dialog'. */);
5808 x_use_old_gtk_file_dialog = 0;
5810 DEFVAR_BOOL ("x-gtk-show-hidden-files", &x_gtk_show_hidden_files,
5811 doc: /* *If non-nil, the GTK file chooser will by default show hidden files.
5812 Note that this is just the default, there is a toggle button on the file
5813 chooser to show or not show hidden files on a case by case basis. */);
5814 x_gtk_show_hidden_files = 0;
5816 DEFVAR_BOOL ("x-gtk-whole-detached-tool-bar", &x_gtk_whole_detached_tool_bar,
5817 doc: /* *If non-nil, a detached tool bar is shown in full.
5818 The default is to just show an arrow and pressing on that arrow shows
5819 the tool bar buttons. */);
5820 x_gtk_whole_detached_tool_bar = 0;
5822 Fprovide (intern ("x"), Qnil);
5824 #ifdef USE_X_TOOLKIT
5825 Fprovide (intern ("x-toolkit"), Qnil);
5826 #ifdef USE_MOTIF
5827 Fprovide (intern ("motif"), Qnil);
5829 DEFVAR_LISP ("motif-version-string", &Vmotif_version_string,
5830 doc: /* Version info for LessTif/Motif. */);
5831 Vmotif_version_string = build_string (XmVERSION_STRING);
5832 #endif /* USE_MOTIF */
5833 #endif /* USE_X_TOOLKIT */
5835 #ifdef USE_GTK
5836 /* Provide x-toolkit also for GTK. Internally GTK does not use Xt so it
5837 is not an X toolkit in that sense (USE_X_TOOLKIT is not defined).
5838 But for a user it is a toolkit for X, and indeed, configure
5839 accepts --with-x-toolkit=gtk. */
5840 Fprovide (intern ("x-toolkit"), Qnil);
5841 Fprovide (intern ("gtk"), Qnil);
5843 DEFVAR_LISP ("gtk-version-string", &Vgtk_version_string,
5844 doc: /* Version info for GTK+. */);
5846 char gtk_version[40];
5847 g_snprintf (gtk_version, sizeof (gtk_version), "%u.%u.%u",
5848 GTK_MAJOR_VERSION, GTK_MINOR_VERSION, GTK_MICRO_VERSION);
5849 Vgtk_version_string = build_string (gtk_version);
5851 #endif /* USE_GTK */
5853 /* X window properties. */
5854 defsubr (&Sx_change_window_property);
5855 defsubr (&Sx_delete_window_property);
5856 defsubr (&Sx_window_property);
5858 defsubr (&Sxw_display_color_p);
5859 defsubr (&Sx_display_grayscale_p);
5860 defsubr (&Sxw_color_defined_p);
5861 defsubr (&Sxw_color_values);
5862 defsubr (&Sx_server_max_request_size);
5863 defsubr (&Sx_server_vendor);
5864 defsubr (&Sx_server_version);
5865 defsubr (&Sx_display_pixel_width);
5866 defsubr (&Sx_display_pixel_height);
5867 defsubr (&Sx_display_mm_width);
5868 defsubr (&Sx_display_mm_height);
5869 defsubr (&Sx_display_screens);
5870 defsubr (&Sx_display_planes);
5871 defsubr (&Sx_display_color_cells);
5872 defsubr (&Sx_display_visual_class);
5873 defsubr (&Sx_display_backing_store);
5874 defsubr (&Sx_display_save_under);
5875 defsubr (&Sx_create_frame);
5876 defsubr (&Sx_open_connection);
5877 defsubr (&Sx_close_connection);
5878 defsubr (&Sx_display_list);
5879 defsubr (&Sx_synchronize);
5880 defsubr (&Sx_focus_frame);
5881 defsubr (&Sx_backspace_delete_keys_p);
5883 /* Setting callback functions for fontset handler. */
5884 get_font_info_func = x_get_font_info;
5886 #if 0 /* This function pointer doesn't seem to be used anywhere.
5887 And the pointer assigned has the wrong type, anyway. */
5888 list_fonts_func = x_list_fonts;
5889 #endif
5891 load_font_func = x_load_font;
5892 find_ccl_program_func = x_find_ccl_program;
5893 query_font_func = x_query_font;
5894 set_frame_fontset_func = x_set_font;
5895 check_window_system_func = check_x;
5897 hourglass_atimer = NULL;
5898 hourglass_shown_p = 0;
5900 defsubr (&Sx_show_tip);
5901 defsubr (&Sx_hide_tip);
5902 tip_timer = Qnil;
5903 staticpro (&tip_timer);
5904 tip_frame = Qnil;
5905 staticpro (&tip_frame);
5907 last_show_tip_args = Qnil;
5908 staticpro (&last_show_tip_args);
5910 defsubr (&Sx_uses_old_gtk_dialog);
5911 #if defined (USE_MOTIF) || defined (USE_GTK)
5912 defsubr (&Sx_file_dialog);
5913 #endif
5916 #endif /* HAVE_X_WINDOWS */
5918 /* arch-tag: 55040d02-5485-4d58-8b22-95a7a05f3288
5919 (do not change this comment) */