1 /* Functions for the X window system.
2 Copyright (C) 1989, 92, 93, 94, 95, 96, 97, 98, 99, 2000, 01, 02, 03
3 Free Software Foundation.
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)
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., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
31 /* This makes the fields of a Display accessible, in Xlib header files. */
33 #define XLIB_ILLEGAL_ACCESS
40 #include "intervals.h"
41 #include "dispextern.h"
43 #include "blockinput.h"
45 #include "character.h"
50 #include "termhooks.h"
56 #include <sys/types.h>
60 #if 1 /* Used to be #ifdef EMACS_BITMAP_FILES, but this should always work. */
61 #include "bitmaps/gray.xbm"
63 #include <X11/bitmaps/gray>
66 #include "[.bitmaps]gray.xbm"
74 #include <X11/Shell.h>
77 #include <X11/Xaw/Paned.h>
78 #include <X11/Xaw/Label.h>
79 #endif /* USE_MOTIF */
82 #undef USG /* ####KLUDGE for Solaris 2.2 and up */
91 #include "../lwlib/lwlib.h"
95 #include <Xm/DialogS.h>
96 #include <Xm/FileSB.h>
99 /* Do the EDITRES protocol if running X11R5
100 Exception: HP-UX (at least version A.09.05) has X11R5 without EditRes */
102 #if (XtSpecificationRelease >= 5) && !defined(NO_EDITRES)
104 extern void _XEditResCheckMessages ();
105 #endif /* R5 + Athena */
107 /* Unique id counter for widgets created by the Lucid Widget Library. */
109 extern LWLIB_ID widget_id_tick
;
112 /* This is part of a kludge--see lwlib/xlwmenu.c. */
113 extern XFontStruct
*xlwmenu_default_font
;
116 extern void free_frame_menubar ();
117 extern double atof ();
121 /* LessTif/Motif version info. */
123 static Lisp_Object Vmotif_version_string
;
125 #endif /* USE_MOTIF */
127 #endif /* USE_X_TOOLKIT */
130 #define MAXREQUEST(dpy) (XMaxRequestSize (dpy))
132 #define MAXREQUEST(dpy) ((dpy)->max_request_size)
135 /* The gray bitmap `bitmaps/gray'. This is done because xterm.c uses
136 it, and including `bitmaps/gray' more than once is a problem when
137 config.h defines `static' as an empty replacement string. */
139 int gray_bitmap_width
= gray_width
;
140 int gray_bitmap_height
= gray_height
;
141 char *gray_bitmap_bits
= gray_bits
;
143 /* Non-zero means we're allowed to display an hourglass cursor. */
145 int display_hourglass_p
;
147 /* The background and shape of the mouse pointer, and shape when not
148 over text or in the modeline. */
150 Lisp_Object Vx_pointer_shape
, Vx_nontext_pointer_shape
, Vx_mode_pointer_shape
;
151 Lisp_Object Vx_hourglass_pointer_shape
;
153 /* The shape when over mouse-sensitive text. */
155 Lisp_Object Vx_sensitive_text_pointer_shape
;
157 /* If non-nil, the pointer shape to indicate that windows can be
158 dragged horizontally. */
160 Lisp_Object Vx_window_horizontal_drag_shape
;
162 /* Color of chars displayed in cursor box. */
164 Lisp_Object Vx_cursor_fore_pixel
;
166 /* Nonzero if using X. */
170 /* Non nil if no window manager is in use. */
172 Lisp_Object Vx_no_window_manager
;
174 /* Search path for bitmap files. */
176 Lisp_Object Vx_bitmap_file_path
;
178 /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'. */
180 Lisp_Object Vx_pixel_size_width_font_regexp
;
183 Lisp_Object Qsuppress_icon
;
184 Lisp_Object Qundefined_color
;
186 Lisp_Object Qcompound_text
, Qcancel_timer
;
190 extern Lisp_Object Vwindow_system_version
;
192 /* The below are defined in frame.c. */
195 int image_cache_refcount
, dpyinfo_refcount
;
200 /* Error if we are not connected to X. */
206 error ("X windows are not in use or not initialized");
209 /* Nonzero if we can use mouse menus.
210 You should not call this unless HAVE_MENUS is defined. */
218 /* Extract a frame as a FRAME_PTR, defaulting to the selected frame
219 and checking validity for X. */
222 check_x_frame (frame
)
228 frame
= selected_frame
;
229 CHECK_LIVE_FRAME (frame
);
232 error ("Non-X frame used");
236 /* Let the user specify an X display with a frame.
237 nil stands for the selected frame--or, if that is not an X frame,
238 the first X display on the list. */
240 struct x_display_info
*
241 check_x_display_info (frame
)
244 struct x_display_info
*dpyinfo
= NULL
;
248 struct frame
*sf
= XFRAME (selected_frame
);
250 if (FRAME_X_P (sf
) && FRAME_LIVE_P (sf
))
251 dpyinfo
= FRAME_X_DISPLAY_INFO (sf
);
252 else if (x_display_list
!= 0)
253 dpyinfo
= x_display_list
;
255 error ("X windows are not in use or not initialized");
257 else if (STRINGP (frame
))
258 dpyinfo
= x_display_info_for_name (frame
);
261 FRAME_PTR f
= check_x_frame (frame
);
262 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
269 /* Return the Emacs frame-object corresponding to an X window.
270 It could be the frame's main window or an icon window. */
272 /* This function can be called during GC, so use GC_xxx type test macros. */
275 x_window_to_frame (dpyinfo
, wdesc
)
276 struct x_display_info
*dpyinfo
;
279 Lisp_Object tail
, frame
;
282 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
285 if (!GC_FRAMEP (frame
))
288 if (!FRAME_X_P (f
) || FRAME_X_DISPLAY_INFO (f
) != dpyinfo
)
290 if (f
->output_data
.x
->hourglass_window
== wdesc
)
293 if ((f
->output_data
.x
->edit_widget
294 && XtWindow (f
->output_data
.x
->edit_widget
) == wdesc
)
295 /* A tooltip frame? */
296 || (!f
->output_data
.x
->edit_widget
297 && FRAME_X_WINDOW (f
) == wdesc
)
298 || f
->output_data
.x
->icon_desc
== wdesc
)
300 #else /* not USE_X_TOOLKIT */
302 if (f
->output_data
.x
->edit_widget
)
304 GtkWidget
*gwdesc
= xg_win_to_widget (wdesc
);
305 struct x_output
*x
= f
->output_data
.x
;
306 if (gwdesc
!= 0 && gwdesc
== x
->edit_widget
)
310 if (FRAME_X_WINDOW (f
) == wdesc
311 || f
->output_data
.x
->icon_desc
== wdesc
)
313 #endif /* not USE_X_TOOLKIT */
318 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
319 /* Like x_window_to_frame but also compares the window with the widget's
323 x_any_window_to_frame (dpyinfo
, wdesc
)
324 struct x_display_info
*dpyinfo
;
327 Lisp_Object tail
, frame
;
328 struct frame
*f
, *found
;
332 for (tail
= Vframe_list
; GC_CONSP (tail
) && !found
; tail
= XCDR (tail
))
335 if (!GC_FRAMEP (frame
))
339 if (FRAME_X_P (f
) && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
341 /* This frame matches if the window is any of its widgets. */
342 x
= f
->output_data
.x
;
343 if (x
->hourglass_window
== wdesc
)
348 GtkWidget
*gwdesc
= xg_win_to_widget (wdesc
);
350 && (gwdesc
== x
->widget
351 || gwdesc
== x
->edit_widget
352 || gwdesc
== x
->vbox_widget
353 || gwdesc
== x
->menubar_widget
))
356 if (wdesc
== XtWindow (x
->widget
)
357 || wdesc
== XtWindow (x
->column_widget
)
358 || wdesc
== XtWindow (x
->edit_widget
))
360 /* Match if the window is this frame's menubar. */
361 else if (lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
365 else if (FRAME_X_WINDOW (f
) == wdesc
)
366 /* A tooltip frame. */
374 /* Likewise, but exclude the menu bar widget. */
377 x_non_menubar_window_to_frame (dpyinfo
, wdesc
)
378 struct x_display_info
*dpyinfo
;
381 Lisp_Object tail
, frame
;
385 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
388 if (!GC_FRAMEP (frame
))
391 if (!FRAME_X_P (f
) || FRAME_X_DISPLAY_INFO (f
) != dpyinfo
)
393 x
= f
->output_data
.x
;
394 /* This frame matches if the window is any of its widgets. */
395 if (x
->hourglass_window
== wdesc
)
400 GtkWidget
*gwdesc
= xg_win_to_widget (wdesc
);
402 && (gwdesc
== x
->widget
403 || gwdesc
== x
->edit_widget
404 || gwdesc
== x
->vbox_widget
))
407 if (wdesc
== XtWindow (x
->widget
)
408 || wdesc
== XtWindow (x
->column_widget
)
409 || wdesc
== XtWindow (x
->edit_widget
))
413 else if (FRAME_X_WINDOW (f
) == wdesc
)
414 /* A tooltip frame. */
420 /* Likewise, but consider only the menu bar widget. */
423 x_menubar_window_to_frame (dpyinfo
, wdesc
)
424 struct x_display_info
*dpyinfo
;
427 Lisp_Object tail
, frame
;
431 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
434 if (!GC_FRAMEP (frame
))
437 if (!FRAME_X_P (f
) || FRAME_X_DISPLAY_INFO (f
) != dpyinfo
)
439 x
= f
->output_data
.x
;
440 /* Match if the window is this frame's menubar. */
442 if (x
->menubar_widget
)
444 GtkWidget
*gwdesc
= xg_win_to_widget (wdesc
);
449 && (gwdesc
== x
->menubar_widget
450 || gtk_widget_get_parent (gwdesc
) == x
->menubar_widget
))
456 if (x
->menubar_widget
457 && lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
464 /* Return the frame whose principal (outermost) window is WDESC.
465 If WDESC is some other (smaller) window, we return 0. */
468 x_top_window_to_frame (dpyinfo
, wdesc
)
469 struct x_display_info
*dpyinfo
;
472 Lisp_Object tail
, frame
;
476 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
479 if (!GC_FRAMEP (frame
))
482 if (!FRAME_X_P (f
) || FRAME_X_DISPLAY_INFO (f
) != dpyinfo
)
484 x
= f
->output_data
.x
;
488 /* This frame matches if the window is its topmost widget. */
490 GtkWidget
*gwdesc
= xg_win_to_widget (wdesc
);
491 if (gwdesc
== x
->widget
)
494 if (wdesc
== XtWindow (x
->widget
))
496 #if 0 /* I don't know why it did this,
497 but it seems logically wrong,
498 and it causes trouble for MapNotify events. */
499 /* Match if the window is this frame's menubar. */
500 if (x
->menubar_widget
501 && wdesc
== XtWindow (x
->menubar_widget
))
506 else if (FRAME_X_WINDOW (f
) == wdesc
)
512 #endif /* USE_X_TOOLKIT || USE_GTK */
516 /* Code to deal with bitmaps. Bitmaps are referenced by their bitmap
517 id, which is just an int that this section returns. Bitmaps are
518 reference counted so they can be shared among frames.
520 Bitmap indices are guaranteed to be > 0, so a negative number can
521 be used to indicate no bitmap.
523 If you use x_create_bitmap_from_data, then you must keep track of
524 the bitmaps yourself. That is, creating a bitmap from the same
525 data more than once will not be caught. */
528 /* Functions to access the contents of a bitmap, given an id. */
531 x_bitmap_height (f
, id
)
535 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].height
;
539 x_bitmap_width (f
, id
)
543 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].width
;
547 x_bitmap_pixmap (f
, id
)
551 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].pixmap
;
555 x_bitmap_mask (f
, id
)
559 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].mask
;
563 /* Allocate a new bitmap record. Returns index of new record. */
566 x_allocate_bitmap_record (f
)
569 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
572 if (dpyinfo
->bitmaps
== NULL
)
574 dpyinfo
->bitmaps_size
= 10;
576 = (struct x_bitmap_record
*) xmalloc (dpyinfo
->bitmaps_size
* sizeof (struct x_bitmap_record
));
577 dpyinfo
->bitmaps_last
= 1;
581 if (dpyinfo
->bitmaps_last
< dpyinfo
->bitmaps_size
)
582 return ++dpyinfo
->bitmaps_last
;
584 for (i
= 0; i
< dpyinfo
->bitmaps_size
; ++i
)
585 if (dpyinfo
->bitmaps
[i
].refcount
== 0)
588 dpyinfo
->bitmaps_size
*= 2;
590 = (struct x_bitmap_record
*) xrealloc (dpyinfo
->bitmaps
,
591 dpyinfo
->bitmaps_size
* sizeof (struct x_bitmap_record
));
592 return ++dpyinfo
->bitmaps_last
;
595 /* Add one reference to the reference count of the bitmap with id ID. */
598 x_reference_bitmap (f
, id
)
602 ++FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].refcount
;
605 /* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS. */
608 x_create_bitmap_from_data (f
, bits
, width
, height
)
611 unsigned int width
, height
;
613 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
617 bitmap
= XCreateBitmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
618 bits
, width
, height
);
625 id
= x_allocate_bitmap_record (f
);
626 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
627 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
628 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
629 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
630 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
631 dpyinfo
->bitmaps
[id
- 1].height
= height
;
632 dpyinfo
->bitmaps
[id
- 1].width
= width
;
637 /* Create bitmap from file FILE for frame F. */
640 x_create_bitmap_from_file (f
, file
)
644 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
645 unsigned int width
, height
;
647 int xhot
, yhot
, result
, id
;
652 /* Look for an existing bitmap with the same name. */
653 for (id
= 0; id
< dpyinfo
->bitmaps_last
; ++id
)
655 if (dpyinfo
->bitmaps
[id
].refcount
656 && dpyinfo
->bitmaps
[id
].file
657 && !strcmp (dpyinfo
->bitmaps
[id
].file
, (char *) SDATA (file
)))
659 ++dpyinfo
->bitmaps
[id
].refcount
;
664 /* Search bitmap-file-path for the file, if appropriate. */
665 fd
= openp (Vx_bitmap_file_path
, file
, Qnil
, &found
, Qnil
);
670 filename
= (char *) SDATA (found
);
672 result
= XReadBitmapFile (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
673 filename
, &width
, &height
, &bitmap
, &xhot
, &yhot
);
674 if (result
!= BitmapSuccess
)
677 id
= x_allocate_bitmap_record (f
);
678 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
679 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
680 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
681 dpyinfo
->bitmaps
[id
- 1].file
682 = (char *) xmalloc (SBYTES (file
) + 1);
683 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
684 dpyinfo
->bitmaps
[id
- 1].height
= height
;
685 dpyinfo
->bitmaps
[id
- 1].width
= width
;
686 strcpy (dpyinfo
->bitmaps
[id
- 1].file
, SDATA (file
));
691 /* Remove reference to bitmap with id number ID. */
694 x_destroy_bitmap (f
, id
)
698 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
702 --dpyinfo
->bitmaps
[id
- 1].refcount
;
703 if (dpyinfo
->bitmaps
[id
- 1].refcount
== 0)
706 XFreePixmap (FRAME_X_DISPLAY (f
), dpyinfo
->bitmaps
[id
- 1].pixmap
);
707 if (dpyinfo
->bitmaps
[id
- 1].have_mask
)
708 XFreePixmap (FRAME_X_DISPLAY (f
), dpyinfo
->bitmaps
[id
- 1].mask
);
709 if (dpyinfo
->bitmaps
[id
- 1].file
)
711 xfree (dpyinfo
->bitmaps
[id
- 1].file
);
712 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
719 /* Free all the bitmaps for the display specified by DPYINFO. */
722 x_destroy_all_bitmaps (dpyinfo
)
723 struct x_display_info
*dpyinfo
;
726 for (i
= 0; i
< dpyinfo
->bitmaps_last
; i
++)
727 if (dpyinfo
->bitmaps
[i
].refcount
> 0)
729 XFreePixmap (dpyinfo
->display
, dpyinfo
->bitmaps
[i
].pixmap
);
730 if (dpyinfo
->bitmaps
[i
].have_mask
)
731 XFreePixmap (dpyinfo
->display
, dpyinfo
->bitmaps
[i
].mask
);
732 if (dpyinfo
->bitmaps
[i
].file
)
733 xfree (dpyinfo
->bitmaps
[i
].file
);
735 dpyinfo
->bitmaps_last
= 0;
741 /* Useful functions defined in the section
742 `Image type independent image structures' below. */
744 static unsigned long four_corners_best
P_ ((XImage
*ximg
, unsigned long width
,
745 unsigned long height
));
747 static int x_create_x_image_and_pixmap
P_ ((struct frame
*f
, int width
, int height
,
748 int depth
, XImage
**ximg
,
751 static void x_destroy_x_image
P_ ((XImage
*ximg
));
754 /* Create a mask of a bitmap. Note is this not a perfect mask.
755 It's nicer with some borders in this context */
758 x_create_bitmap_mask(f
, id
)
763 XImage
*ximg
, *mask_img
;
764 unsigned long width
, height
;
767 unsigned long x
, y
, xp
, xm
, yp
, ym
;
770 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
775 pixmap
= x_bitmap_pixmap(f
, id
);
776 width
= x_bitmap_width(f
, id
);
777 height
= x_bitmap_height(f
, id
);
780 ximg
= XGetImage (FRAME_X_DISPLAY (f
), pixmap
, 0, 0, width
, height
,
789 result
= x_create_x_image_and_pixmap (f
, width
, height
, 1, &mask_img
, &mask
);
798 bg
= four_corners_best (ximg
, width
, height
);
800 for (y
= 0; y
< ximg
->height
; ++y
)
802 for (x
= 0; x
< ximg
->width
; ++x
)
804 xp
= x
!= ximg
->width
- 1 ? x
+ 1 : 0;
805 xm
= x
!= 0 ? x
- 1 : ximg
->width
- 1;
806 yp
= y
!= ximg
->height
- 1 ? y
+ 1 : 0;
807 ym
= y
!= 0 ? y
- 1 : ximg
->height
- 1;
808 if (XGetPixel (ximg
, x
, y
) == bg
809 && XGetPixel (ximg
, x
, yp
) == bg
810 && XGetPixel (ximg
, x
, ym
) == bg
811 && XGetPixel (ximg
, xp
, y
) == bg
812 && XGetPixel (ximg
, xp
, yp
) == bg
813 && XGetPixel (ximg
, xp
, ym
) == bg
814 && XGetPixel (ximg
, xm
, y
) == bg
815 && XGetPixel (ximg
, xm
, yp
) == bg
816 && XGetPixel (ximg
, xm
, ym
) == bg
)
817 XPutPixel (mask_img
, x
, y
, 0);
819 XPutPixel (mask_img
, x
, y
, 1);
823 xassert (interrupt_input_blocked
);
824 gc
= XCreateGC (FRAME_X_DISPLAY (f
), mask
, 0, NULL
);
825 XPutImage (FRAME_X_DISPLAY (f
), mask
, gc
, mask_img
, 0, 0, 0, 0,
827 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
829 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
830 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
832 XDestroyImage (ximg
);
833 x_destroy_x_image(mask_img
);
838 static Lisp_Object unwind_create_frame
P_ ((Lisp_Object
));
839 static Lisp_Object unwind_create_tip_frame
P_ ((Lisp_Object
));
840 static void x_disable_image
P_ ((struct frame
*, struct image
*));
842 void x_set_foreground_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
843 static void x_set_wait_for_wm
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
844 void x_set_background_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
845 void x_set_mouse_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
846 void x_set_cursor_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
847 void x_set_border_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
848 void x_set_cursor_type
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
849 void x_set_icon_type
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
850 void x_set_icon_name
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
851 void x_explicitly_set_name
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
852 void x_set_menu_bar_lines
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
853 void x_set_title
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
854 void x_set_tool_bar_lines
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
855 void x_set_scroll_bar_foreground
P_ ((struct frame
*, Lisp_Object
,
857 void x_set_scroll_bar_background
P_ ((struct frame
*, Lisp_Object
,
859 static Lisp_Object x_default_scroll_bar_color_parameter
P_ ((struct frame
*,
864 static void x_edge_detection
P_ ((struct frame
*, struct image
*, Lisp_Object
,
866 static void init_color_table
P_ ((void));
867 static void free_color_table
P_ ((void));
868 static unsigned long *colors_in_color_table
P_ ((int *n
));
869 static unsigned long lookup_rgb_color
P_ ((struct frame
*f
, int r
, int g
, int b
));
870 static unsigned long lookup_pixel_color
P_ ((struct frame
*f
, unsigned long p
));
876 /* Store the screen positions of frame F into XPTR and YPTR.
877 These are the positions of the containing window manager window,
878 not Emacs's own window. */
881 x_real_positions (f
, xptr
, yptr
)
885 int win_x
, win_y
, outer_x
, outer_y
;
886 int real_x
= 0, real_y
= 0;
888 Window win
= f
->output_data
.x
->parent_desc
;
894 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
896 if (win
== FRAME_X_DISPLAY_INFO (f
)->root_window
)
897 win
= FRAME_OUTER_WINDOW (f
);
899 /* This loop traverses up the containment tree until we hit the root
900 window. Window managers may intersect many windows between our window
901 and the root window. The window we find just before the root window
902 should be the outer WM window. */
905 Window wm_window
, rootw
;
906 Window
*tmp_children
;
907 unsigned int tmp_nchildren
;
910 success
= XQueryTree (FRAME_X_DISPLAY (f
), win
, &rootw
,
911 &wm_window
, &tmp_children
, &tmp_nchildren
);
913 had_errors
= x_had_errors_p (FRAME_X_DISPLAY (f
));
915 /* Don't free tmp_children if XQueryTree failed. */
919 XFree ((char *) tmp_children
);
921 if (wm_window
== rootw
|| had_errors
)
932 /* Get the real coordinates for the WM window upper left corner */
933 XGetGeometry (FRAME_X_DISPLAY (f
), win
,
934 &rootw
, &real_x
, &real_y
, &ign
, &ign
, &ign
, &ign
);
936 /* Translate real coordinates to coordinates relative to our
937 window. For our window, the upper left corner is 0, 0.
938 Since the upper left corner of the WM window is outside
939 our window, win_x and win_y will be negative:
941 ------------------ ---> x
943 | ----------------- v y
946 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
948 /* From-window, to-window. */
949 FRAME_X_DISPLAY_INFO (f
)->root_window
,
952 /* From-position, to-position. */
953 real_x
, real_y
, &win_x
, &win_y
,
958 if (FRAME_X_WINDOW (f
) == FRAME_OUTER_WINDOW (f
))
965 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
967 /* From-window, to-window. */
968 FRAME_X_DISPLAY_INFO (f
)->root_window
,
969 FRAME_OUTER_WINDOW (f
),
971 /* From-position, to-position. */
972 real_x
, real_y
, &outer_x
, &outer_y
,
978 had_errors
= x_had_errors_p (FRAME_X_DISPLAY (f
));
981 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
985 if (had_errors
) return;
987 f
->x_pixels_diff
= -win_x
;
988 f
->y_pixels_diff
= -win_y
;
990 FRAME_X_OUTPUT (f
)->x_pixels_outer_diff
= -outer_x
;
991 FRAME_X_OUTPUT (f
)->y_pixels_outer_diff
= -outer_y
;
1000 /* Gamma-correct COLOR on frame F. */
1003 gamma_correct (f
, color
)
1009 color
->red
= pow (color
->red
/ 65535.0, f
->gamma
) * 65535.0 + 0.5;
1010 color
->green
= pow (color
->green
/ 65535.0, f
->gamma
) * 65535.0 + 0.5;
1011 color
->blue
= pow (color
->blue
/ 65535.0, f
->gamma
) * 65535.0 + 0.5;
1016 /* Decide if color named COLOR_NAME is valid for use on frame F. If
1017 so, return the RGB values in COLOR. If ALLOC_P is non-zero,
1018 allocate the color. Value is zero if COLOR_NAME is invalid, or
1019 no color could be allocated. */
1022 x_defined_color (f
, color_name
, color
, alloc_p
)
1029 Display
*dpy
= FRAME_X_DISPLAY (f
);
1030 Colormap cmap
= FRAME_X_COLORMAP (f
);
1033 success_p
= XParseColor (dpy
, cmap
, color_name
, color
);
1034 if (success_p
&& alloc_p
)
1035 success_p
= x_alloc_nearest_color (f
, cmap
, color
);
1042 /* Return the pixel color value for color COLOR_NAME on frame F. If F
1043 is a monochrome frame, return MONO_COLOR regardless of what ARG says.
1044 Signal an error if color can't be allocated. */
1047 x_decode_color (f
, color_name
, mono_color
)
1049 Lisp_Object color_name
;
1054 CHECK_STRING (color_name
);
1056 #if 0 /* Don't do this. It's wrong when we're not using the default
1057 colormap, it makes freeing difficult, and it's probably not
1058 an important optimization. */
1059 if (strcmp (SDATA (color_name
), "black") == 0)
1060 return BLACK_PIX_DEFAULT (f
);
1061 else if (strcmp (SDATA (color_name
), "white") == 0)
1062 return WHITE_PIX_DEFAULT (f
);
1065 /* Return MONO_COLOR for monochrome frames. */
1066 if (FRAME_X_DISPLAY_INFO (f
)->n_planes
== 1)
1069 /* x_defined_color is responsible for coping with failures
1070 by looking for a near-miss. */
1071 if (x_defined_color (f
, SDATA (color_name
), &cdef
, 1))
1074 Fsignal (Qerror
, Fcons (build_string ("Undefined color"),
1075 Fcons (color_name
, Qnil
)));
1081 /* Change the `wait-for-wm' frame parameter of frame F. OLD_VALUE is
1082 the previous value of that parameter, NEW_VALUE is the new value.
1083 See also the comment of wait_for_wm in struct x_output. */
1086 x_set_wait_for_wm (f
, new_value
, old_value
)
1088 Lisp_Object new_value
, old_value
;
1090 f
->output_data
.x
->wait_for_wm
= !NILP (new_value
);
1095 static Lisp_Object x_find_image_file
P_ ((Lisp_Object file
));
1097 /* Set icon from FILE for frame F. By using GTK functions the icon
1098 may be any format that GdkPixbuf knows about, i.e. not just bitmaps. */
1101 xg_set_icon(f
, file
)
1105 struct gcpro gcpro1
;
1111 found
= x_find_image_file (file
);
1119 filename
= SDATA (found
);
1122 pixbuf
= gdk_pixbuf_new_from_file (filename
, &err
);
1126 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1128 g_object_unref (pixbuf
);
1141 #endif /* USE_GTK */
1144 /* Functions called only from `x_set_frame_param'
1145 to set individual parameters.
1147 If FRAME_X_WINDOW (f) is 0,
1148 the frame is being created and its X-window does not exist yet.
1149 In that case, just record the parameter's new value
1150 in the standard place; do not attempt to change the window. */
1153 x_set_foreground_color (f
, arg
, oldval
)
1155 Lisp_Object arg
, oldval
;
1157 struct x_output
*x
= f
->output_data
.x
;
1158 unsigned long fg
, old_fg
;
1160 fg
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1161 old_fg
= x
->foreground_pixel
;
1162 x
->foreground_pixel
= fg
;
1164 if (FRAME_X_WINDOW (f
) != 0)
1166 Display
*dpy
= FRAME_X_DISPLAY (f
);
1169 XSetForeground (dpy
, x
->normal_gc
, fg
);
1170 XSetBackground (dpy
, x
->reverse_gc
, fg
);
1172 if (x
->cursor_pixel
== old_fg
)
1174 unload_color (f
, x
->cursor_pixel
);
1175 x
->cursor_pixel
= x_copy_color (f
, fg
);
1176 XSetBackground (dpy
, x
->cursor_gc
, x
->cursor_pixel
);
1181 update_face_from_frame_parameter (f
, Qforeground_color
, arg
);
1183 if (FRAME_VISIBLE_P (f
))
1187 unload_color (f
, old_fg
);
1191 x_set_background_color (f
, arg
, oldval
)
1193 Lisp_Object arg
, oldval
;
1195 struct x_output
*x
= f
->output_data
.x
;
1198 bg
= x_decode_color (f
, arg
, WHITE_PIX_DEFAULT (f
));
1199 unload_color (f
, x
->background_pixel
);
1200 x
->background_pixel
= bg
;
1202 if (FRAME_X_WINDOW (f
) != 0)
1204 Display
*dpy
= FRAME_X_DISPLAY (f
);
1207 XSetBackground (dpy
, x
->normal_gc
, bg
);
1208 XSetForeground (dpy
, x
->reverse_gc
, bg
);
1209 XSetWindowBackground (dpy
, FRAME_X_WINDOW (f
), bg
);
1210 XSetForeground (dpy
, x
->cursor_gc
, bg
);
1213 xg_set_background_color (f
, bg
);
1216 #ifndef USE_TOOLKIT_SCROLL_BARS /* Turns out to be annoying with
1217 toolkit scroll bars. */
1220 for (bar
= FRAME_SCROLL_BARS (f
);
1222 bar
= XSCROLL_BAR (bar
)->next
)
1224 Window window
= SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
));
1225 XSetWindowBackground (dpy
, window
, bg
);
1228 #endif /* USE_TOOLKIT_SCROLL_BARS */
1231 update_face_from_frame_parameter (f
, Qbackground_color
, arg
);
1233 if (FRAME_VISIBLE_P (f
))
1239 x_set_mouse_color (f
, arg
, oldval
)
1241 Lisp_Object arg
, oldval
;
1243 struct x_output
*x
= f
->output_data
.x
;
1244 Display
*dpy
= FRAME_X_DISPLAY (f
);
1245 Cursor cursor
, nontext_cursor
, mode_cursor
, hand_cursor
;
1246 Cursor hourglass_cursor
, horizontal_drag_cursor
;
1248 unsigned long pixel
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1249 unsigned long mask_color
= x
->background_pixel
;
1251 /* Don't let pointers be invisible. */
1252 if (mask_color
== pixel
)
1254 x_free_colors (f
, &pixel
, 1);
1255 pixel
= x_copy_color (f
, x
->foreground_pixel
);
1258 unload_color (f
, x
->mouse_pixel
);
1259 x
->mouse_pixel
= pixel
;
1263 /* It's not okay to crash if the user selects a screwy cursor. */
1264 count
= x_catch_errors (dpy
);
1266 if (!NILP (Vx_pointer_shape
))
1268 CHECK_NUMBER (Vx_pointer_shape
);
1269 cursor
= XCreateFontCursor (dpy
, XINT (Vx_pointer_shape
));
1272 cursor
= XCreateFontCursor (dpy
, XC_xterm
);
1273 x_check_errors (dpy
, "bad text pointer cursor: %s");
1275 if (!NILP (Vx_nontext_pointer_shape
))
1277 CHECK_NUMBER (Vx_nontext_pointer_shape
);
1279 = XCreateFontCursor (dpy
, XINT (Vx_nontext_pointer_shape
));
1282 nontext_cursor
= XCreateFontCursor (dpy
, XC_left_ptr
);
1283 x_check_errors (dpy
, "bad nontext pointer cursor: %s");
1285 if (!NILP (Vx_hourglass_pointer_shape
))
1287 CHECK_NUMBER (Vx_hourglass_pointer_shape
);
1289 = XCreateFontCursor (dpy
, XINT (Vx_hourglass_pointer_shape
));
1292 hourglass_cursor
= XCreateFontCursor (dpy
, XC_watch
);
1293 x_check_errors (dpy
, "bad hourglass pointer cursor: %s");
1295 x_check_errors (dpy
, "bad nontext pointer cursor: %s");
1296 if (!NILP (Vx_mode_pointer_shape
))
1298 CHECK_NUMBER (Vx_mode_pointer_shape
);
1299 mode_cursor
= XCreateFontCursor (dpy
, XINT (Vx_mode_pointer_shape
));
1302 mode_cursor
= XCreateFontCursor (dpy
, XC_xterm
);
1303 x_check_errors (dpy
, "bad modeline pointer cursor: %s");
1305 if (!NILP (Vx_sensitive_text_pointer_shape
))
1307 CHECK_NUMBER (Vx_sensitive_text_pointer_shape
);
1309 = XCreateFontCursor (dpy
, XINT (Vx_sensitive_text_pointer_shape
));
1312 hand_cursor
= XCreateFontCursor (dpy
, XC_hand2
);
1314 if (!NILP (Vx_window_horizontal_drag_shape
))
1316 CHECK_NUMBER (Vx_window_horizontal_drag_shape
);
1317 horizontal_drag_cursor
1318 = XCreateFontCursor (dpy
, XINT (Vx_window_horizontal_drag_shape
));
1321 horizontal_drag_cursor
1322 = XCreateFontCursor (dpy
, XC_sb_h_double_arrow
);
1324 /* Check and report errors with the above calls. */
1325 x_check_errors (dpy
, "can't set cursor shape: %s");
1326 x_uncatch_errors (dpy
, count
);
1329 XColor fore_color
, back_color
;
1331 fore_color
.pixel
= x
->mouse_pixel
;
1332 x_query_color (f
, &fore_color
);
1333 back_color
.pixel
= mask_color
;
1334 x_query_color (f
, &back_color
);
1336 XRecolorCursor (dpy
, cursor
, &fore_color
, &back_color
);
1337 XRecolorCursor (dpy
, nontext_cursor
, &fore_color
, &back_color
);
1338 XRecolorCursor (dpy
, mode_cursor
, &fore_color
, &back_color
);
1339 XRecolorCursor (dpy
, hand_cursor
, &fore_color
, &back_color
);
1340 XRecolorCursor (dpy
, hourglass_cursor
, &fore_color
, &back_color
);
1341 XRecolorCursor (dpy
, horizontal_drag_cursor
, &fore_color
, &back_color
);
1344 if (FRAME_X_WINDOW (f
) != 0)
1345 XDefineCursor (dpy
, FRAME_X_WINDOW (f
), cursor
);
1347 if (cursor
!= x
->text_cursor
1348 && x
->text_cursor
!= 0)
1349 XFreeCursor (dpy
, x
->text_cursor
);
1350 x
->text_cursor
= cursor
;
1352 if (nontext_cursor
!= x
->nontext_cursor
1353 && x
->nontext_cursor
!= 0)
1354 XFreeCursor (dpy
, x
->nontext_cursor
);
1355 x
->nontext_cursor
= nontext_cursor
;
1357 if (hourglass_cursor
!= x
->hourglass_cursor
1358 && x
->hourglass_cursor
!= 0)
1359 XFreeCursor (dpy
, x
->hourglass_cursor
);
1360 x
->hourglass_cursor
= hourglass_cursor
;
1362 if (mode_cursor
!= x
->modeline_cursor
1363 && x
->modeline_cursor
!= 0)
1364 XFreeCursor (dpy
, f
->output_data
.x
->modeline_cursor
);
1365 x
->modeline_cursor
= mode_cursor
;
1367 if (hand_cursor
!= x
->hand_cursor
1368 && x
->hand_cursor
!= 0)
1369 XFreeCursor (dpy
, x
->hand_cursor
);
1370 x
->hand_cursor
= hand_cursor
;
1372 if (horizontal_drag_cursor
!= x
->horizontal_drag_cursor
1373 && x
->horizontal_drag_cursor
!= 0)
1374 XFreeCursor (dpy
, x
->horizontal_drag_cursor
);
1375 x
->horizontal_drag_cursor
= horizontal_drag_cursor
;
1380 update_face_from_frame_parameter (f
, Qmouse_color
, arg
);
1384 x_set_cursor_color (f
, arg
, oldval
)
1386 Lisp_Object arg
, oldval
;
1388 unsigned long fore_pixel
, pixel
;
1389 int fore_pixel_allocated_p
= 0, pixel_allocated_p
= 0;
1390 struct x_output
*x
= f
->output_data
.x
;
1392 if (!NILP (Vx_cursor_fore_pixel
))
1394 fore_pixel
= x_decode_color (f
, Vx_cursor_fore_pixel
,
1395 WHITE_PIX_DEFAULT (f
));
1396 fore_pixel_allocated_p
= 1;
1399 fore_pixel
= x
->background_pixel
;
1401 pixel
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1402 pixel_allocated_p
= 1;
1404 /* Make sure that the cursor color differs from the background color. */
1405 if (pixel
== x
->background_pixel
)
1407 if (pixel_allocated_p
)
1409 x_free_colors (f
, &pixel
, 1);
1410 pixel_allocated_p
= 0;
1413 pixel
= x
->mouse_pixel
;
1414 if (pixel
== fore_pixel
)
1416 if (fore_pixel_allocated_p
)
1418 x_free_colors (f
, &fore_pixel
, 1);
1419 fore_pixel_allocated_p
= 0;
1421 fore_pixel
= x
->background_pixel
;
1425 unload_color (f
, x
->cursor_foreground_pixel
);
1426 if (!fore_pixel_allocated_p
)
1427 fore_pixel
= x_copy_color (f
, fore_pixel
);
1428 x
->cursor_foreground_pixel
= fore_pixel
;
1430 unload_color (f
, x
->cursor_pixel
);
1431 if (!pixel_allocated_p
)
1432 pixel
= x_copy_color (f
, pixel
);
1433 x
->cursor_pixel
= pixel
;
1435 if (FRAME_X_WINDOW (f
) != 0)
1438 XSetBackground (FRAME_X_DISPLAY (f
), x
->cursor_gc
, x
->cursor_pixel
);
1439 XSetForeground (FRAME_X_DISPLAY (f
), x
->cursor_gc
, fore_pixel
);
1442 if (FRAME_VISIBLE_P (f
))
1444 x_update_cursor (f
, 0);
1445 x_update_cursor (f
, 1);
1449 update_face_from_frame_parameter (f
, Qcursor_color
, arg
);
1452 /* Set the border-color of frame F to pixel value PIX.
1453 Note that this does not fully take effect if done before
1454 F has an x-window. */
1457 x_set_border_pixel (f
, pix
)
1461 unload_color (f
, f
->output_data
.x
->border_pixel
);
1462 f
->output_data
.x
->border_pixel
= pix
;
1464 if (FRAME_X_WINDOW (f
) != 0 && f
->border_width
> 0)
1467 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1468 (unsigned long)pix
);
1471 if (FRAME_VISIBLE_P (f
))
1476 /* Set the border-color of frame F to value described by ARG.
1477 ARG can be a string naming a color.
1478 The border-color is used for the border that is drawn by the X server.
1479 Note that this does not fully take effect if done before
1480 F has an x-window; it must be redone when the window is created.
1482 Note: this is done in two routines because of the way X10 works.
1484 Note: under X11, this is normally the province of the window manager,
1485 and so emacs' border colors may be overridden. */
1488 x_set_border_color (f
, arg
, oldval
)
1490 Lisp_Object arg
, oldval
;
1495 pix
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1496 x_set_border_pixel (f
, pix
);
1497 update_face_from_frame_parameter (f
, Qborder_color
, arg
);
1502 x_set_cursor_type (f
, arg
, oldval
)
1504 Lisp_Object arg
, oldval
;
1506 set_frame_cursor_types (f
, arg
);
1508 /* Make sure the cursor gets redrawn. */
1509 cursor_type_changed
= 1;
1513 x_set_icon_type (f
, arg
, oldval
)
1515 Lisp_Object arg
, oldval
;
1521 if (STRINGP (oldval
) && EQ (Fstring_equal (oldval
, arg
), Qt
))
1524 else if (!STRINGP (oldval
) && EQ (oldval
, Qnil
) == EQ (arg
, Qnil
))
1529 result
= x_text_icon (f
,
1530 (char *) SDATA ((!NILP (f
->icon_name
)
1534 result
= x_bitmap_icon (f
, arg
);
1539 error ("No icon window available");
1542 XFlush (FRAME_X_DISPLAY (f
));
1547 x_set_icon_name (f
, arg
, oldval
)
1549 Lisp_Object arg
, oldval
;
1555 if (STRINGP (oldval
) && EQ (Fstring_equal (oldval
, arg
), Qt
))
1558 else if (!STRINGP (oldval
) && EQ (oldval
, Qnil
) == EQ (arg
, Qnil
))
1563 if (f
->output_data
.x
->icon_bitmap
!= 0)
1568 result
= x_text_icon (f
,
1569 (char *) SDATA ((!NILP (f
->icon_name
)
1578 error ("No icon window available");
1581 XFlush (FRAME_X_DISPLAY (f
));
1587 x_set_menu_bar_lines (f
, value
, oldval
)
1589 Lisp_Object value
, oldval
;
1592 #ifndef USE_X_TOOLKIT
1593 int olines
= FRAME_MENU_BAR_LINES (f
);
1596 /* Right now, menu bars don't work properly in minibuf-only frames;
1597 most of the commands try to apply themselves to the minibuffer
1598 frame itself, and get an error because you can't switch buffers
1599 in or split the minibuffer window. */
1600 if (FRAME_MINIBUF_ONLY_P (f
))
1603 if (INTEGERP (value
))
1604 nlines
= XINT (value
);
1608 /* Make sure we redisplay all windows in this frame. */
1609 windows_or_buffers_changed
++;
1611 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1612 FRAME_MENU_BAR_LINES (f
) = 0;
1615 FRAME_EXTERNAL_MENU_BAR (f
) = 1;
1616 if (FRAME_X_P (f
) && f
->output_data
.x
->menubar_widget
== 0)
1617 /* Make sure next redisplay shows the menu bar. */
1618 XWINDOW (FRAME_SELECTED_WINDOW (f
))->update_mode_line
= Qt
;
1622 if (FRAME_EXTERNAL_MENU_BAR (f
) == 1)
1623 free_frame_menubar (f
);
1624 FRAME_EXTERNAL_MENU_BAR (f
) = 0;
1626 f
->output_data
.x
->menubar_widget
= 0;
1628 #else /* not USE_X_TOOLKIT && not USE_GTK */
1629 FRAME_MENU_BAR_LINES (f
) = nlines
;
1630 change_window_heights (f
->root_window
, nlines
- olines
);
1631 #endif /* not USE_X_TOOLKIT */
1636 /* Set the number of lines used for the tool bar of frame F to VALUE.
1637 VALUE not an integer, or < 0 means set the lines to zero. OLDVAL
1638 is the old number of tool bar lines. This function changes the
1639 height of all windows on frame F to match the new tool bar height.
1640 The frame's height doesn't change. */
1643 x_set_tool_bar_lines (f
, value
, oldval
)
1645 Lisp_Object value
, oldval
;
1647 int delta
, nlines
, root_height
;
1648 Lisp_Object root_window
;
1650 /* Treat tool bars like menu bars. */
1651 if (FRAME_MINIBUF_ONLY_P (f
))
1654 /* Use VALUE only if an integer >= 0. */
1655 if (INTEGERP (value
) && XINT (value
) >= 0)
1656 nlines
= XFASTINT (value
);
1661 FRAME_TOOL_BAR_LINES (f
) = 0;
1664 FRAME_EXTERNAL_TOOL_BAR (f
) = 1;
1665 if (FRAME_X_P (f
) && f
->output_data
.x
->toolbar_widget
== 0)
1666 /* Make sure next redisplay shows the tool bar. */
1667 XWINDOW (FRAME_SELECTED_WINDOW (f
))->update_mode_line
= Qt
;
1668 update_frame_tool_bar (f
);
1672 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1673 free_frame_tool_bar (f
);
1674 FRAME_EXTERNAL_TOOL_BAR (f
) = 0;
1680 /* Make sure we redisplay all windows in this frame. */
1681 ++windows_or_buffers_changed
;
1683 delta
= nlines
- FRAME_TOOL_BAR_LINES (f
);
1685 /* Don't resize the tool-bar to more than we have room for. */
1686 root_window
= FRAME_ROOT_WINDOW (f
);
1687 root_height
= WINDOW_TOTAL_LINES (XWINDOW (root_window
));
1688 if (root_height
- delta
< 1)
1690 delta
= root_height
- 1;
1691 nlines
= FRAME_TOOL_BAR_LINES (f
) + delta
;
1694 FRAME_TOOL_BAR_LINES (f
) = nlines
;
1695 change_window_heights (root_window
, delta
);
1698 /* We also have to make sure that the internal border at the top of
1699 the frame, below the menu bar or tool bar, is redrawn when the
1700 tool bar disappears. This is so because the internal border is
1701 below the tool bar if one is displayed, but is below the menu bar
1702 if there isn't a tool bar. The tool bar draws into the area
1703 below the menu bar. */
1704 if (FRAME_X_WINDOW (f
) && FRAME_TOOL_BAR_LINES (f
) == 0)
1708 clear_current_matrices (f
);
1709 updating_frame
= NULL
;
1712 /* If the tool bar gets smaller, the internal border below it
1713 has to be cleared. It was formerly part of the display
1714 of the larger tool bar, and updating windows won't clear it. */
1717 int height
= FRAME_INTERNAL_BORDER_WIDTH (f
);
1718 int width
= FRAME_PIXEL_WIDTH (f
);
1719 int y
= nlines
* FRAME_LINE_HEIGHT (f
);
1722 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1723 0, y
, width
, height
, False
);
1726 if (WINDOWP (f
->tool_bar_window
))
1727 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
1732 /* Set the foreground color for scroll bars on frame F to VALUE.
1733 VALUE should be a string, a color name. If it isn't a string or
1734 isn't a valid color name, do nothing. OLDVAL is the old value of
1735 the frame parameter. */
1738 x_set_scroll_bar_foreground (f
, value
, oldval
)
1740 Lisp_Object value
, oldval
;
1742 unsigned long pixel
;
1744 if (STRINGP (value
))
1745 pixel
= x_decode_color (f
, value
, BLACK_PIX_DEFAULT (f
));
1749 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
1750 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
1752 f
->output_data
.x
->scroll_bar_foreground_pixel
= pixel
;
1753 if (FRAME_X_WINDOW (f
) && FRAME_VISIBLE_P (f
))
1755 /* Remove all scroll bars because they have wrong colors. */
1756 if (condemn_scroll_bars_hook
)
1757 (*condemn_scroll_bars_hook
) (f
);
1758 if (judge_scroll_bars_hook
)
1759 (*judge_scroll_bars_hook
) (f
);
1761 update_face_from_frame_parameter (f
, Qscroll_bar_foreground
, value
);
1767 /* Set the background color for scroll bars on frame F to VALUE VALUE
1768 should be a string, a color name. If it isn't a string or isn't a
1769 valid color name, do nothing. OLDVAL is the old value of the frame
1773 x_set_scroll_bar_background (f
, value
, oldval
)
1775 Lisp_Object value
, oldval
;
1777 unsigned long pixel
;
1779 if (STRINGP (value
))
1780 pixel
= x_decode_color (f
, value
, WHITE_PIX_DEFAULT (f
));
1784 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
1785 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
1787 #ifdef USE_TOOLKIT_SCROLL_BARS
1788 /* Scrollbar shadow colors. */
1789 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
1791 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
1792 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= -1;
1794 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
1796 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
1797 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= -1;
1799 #endif /* USE_TOOLKIT_SCROLL_BARS */
1801 f
->output_data
.x
->scroll_bar_background_pixel
= pixel
;
1802 if (FRAME_X_WINDOW (f
) && FRAME_VISIBLE_P (f
))
1804 /* Remove all scroll bars because they have wrong colors. */
1805 if (condemn_scroll_bars_hook
)
1806 (*condemn_scroll_bars_hook
) (f
);
1807 if (judge_scroll_bars_hook
)
1808 (*judge_scroll_bars_hook
) (f
);
1810 update_face_from_frame_parameter (f
, Qscroll_bar_background
, value
);
1816 /* Encode Lisp string STRING as a text in a format appropriate for
1817 XICCC (X Inter Client Communication Conventions).
1819 If STRING contains only ASCII characters, do no conversion and
1820 return the string data of STRING. Otherwise, encode the text by
1821 CODING_SYSTEM, and return a newly allocated memory area which
1822 should be freed by `xfree' by a caller.
1824 SELECTIONP non-zero means the string is being encoded for an X
1825 selection, so it is safe to run pre-write conversions (which
1828 Store the byte length of resulting text in *TEXT_BYTES.
1830 If the text contains only ASCII and Latin-1, store 1 in *STRING_P,
1831 which means that the `encoding' of the result can be `STRING'.
1832 Otherwise store 0 in *STRINGP, which means that the `encoding' of
1833 the result should be `COMPOUND_TEXT'. */
1836 x_encode_text (string
, coding_system
, selectionp
, text_bytes
, stringp
)
1837 Lisp_Object string
, coding_system
;
1838 int *text_bytes
, *stringp
;
1841 int result
= string_xstring_p (string
);
1842 struct coding_system coding
;
1846 /* No multibyte character in OBJ. We need not encode it. */
1847 *text_bytes
= SBYTES (string
);
1849 return SDATA (string
);
1852 setup_coding_system (coding_system
, &coding
);
1853 coding
.mode
|= (CODING_MODE_SAFE_ENCODING
| CODING_MODE_LAST_BLOCK
);
1854 /* We suppress producing escape sequences for composition. */
1855 coding
.common_flags
&= ~CODING_ANNOTATION_MASK
;
1856 coding
.dst_bytes
= SCHARS (string
) * 2;
1857 coding
.destination
= (unsigned char *) xmalloc (coding
.dst_bytes
);
1858 encode_coding_object (&coding
, string
, 0, 0,
1859 SCHARS (string
), SBYTES (string
), Qnil
);
1860 *text_bytes
= coding
.produced
;
1861 *stringp
= (result
== 1 || !EQ (coding_system
, Qcompound_text
));
1862 return coding
.destination
;
1866 /* Change the name of frame F to NAME. If NAME is nil, set F's name to
1869 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1870 name; if NAME is a string, set F's name to NAME and set
1871 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1873 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1874 suggesting a new name, which lisp code should override; if
1875 F->explicit_name is set, ignore the new name; otherwise, set it. */
1878 x_set_name (f
, name
, explicit)
1883 /* Make sure that requests from lisp code override requests from
1884 Emacs redisplay code. */
1887 /* If we're switching from explicit to implicit, we had better
1888 update the mode lines and thereby update the title. */
1889 if (f
->explicit_name
&& NILP (name
))
1890 update_mode_lines
= 1;
1892 f
->explicit_name
= ! NILP (name
);
1894 else if (f
->explicit_name
)
1897 /* If NAME is nil, set the name to the x_id_name. */
1900 /* Check for no change needed in this very common case
1901 before we do any consing. */
1902 if (!strcmp (FRAME_X_DISPLAY_INFO (f
)->x_id_name
,
1905 name
= build_string (FRAME_X_DISPLAY_INFO (f
)->x_id_name
);
1908 CHECK_STRING (name
);
1910 /* Don't change the name if it's already NAME. */
1911 if (! NILP (Fstring_equal (name
, f
->name
)))
1916 /* For setting the frame title, the title parameter should override
1917 the name parameter. */
1918 if (! NILP (f
->title
))
1921 if (FRAME_X_WINDOW (f
))
1926 XTextProperty text
, icon
;
1928 Lisp_Object coding_system
;
1930 /* Note: Encoding strategy
1932 We encode NAME by compound-text and use "COMPOUND-TEXT" in
1933 text.encoding. But, there are non-internationalized window
1934 managers which don't support that encoding. So, if NAME
1935 contains only ASCII and 8859-1 characters, encode it by
1936 iso-latin-1, and use "STRING" in text.encoding hoping that
1937 such window managers at least analyze this format correctly,
1938 i.e. treat 8-bit bytes as 8859-1 characters.
1940 We may also be able to use "UTF8_STRING" in text.encoding
1941 in the future which can encode all Unicode characters.
1942 But, for the moment, there's no way to know that the
1943 current window manager supports it or not. */
1944 coding_system
= Qcompound_text
;
1945 text
.value
= x_encode_text (name
, coding_system
, 0, &bytes
, &stringp
);
1946 text
.encoding
= (stringp
? XA_STRING
1947 : FRAME_X_DISPLAY_INFO (f
)->Xatom_COMPOUND_TEXT
);
1949 text
.nitems
= bytes
;
1951 if (NILP (f
->icon_name
))
1957 /* See the above comment "Note: Encoding strategy". */
1958 icon
.value
= x_encode_text (f
->icon_name
, coding_system
, 0,
1960 icon
.encoding
= (stringp
? XA_STRING
1961 : FRAME_X_DISPLAY_INFO (f
)->Xatom_COMPOUND_TEXT
);
1963 icon
.nitems
= bytes
;
1966 gtk_window_set_title (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1968 #else /* not USE_GTK */
1969 XSetWMName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
1970 #endif /* not USE_GTK */
1972 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &icon
);
1974 if (!NILP (f
->icon_name
)
1975 && icon
.value
!= (unsigned char *) SDATA (f
->icon_name
))
1977 if (text
.value
!= (unsigned char *) SDATA (name
))
1980 #else /* not HAVE_X11R4 */
1981 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1983 XStoreName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1985 #endif /* not HAVE_X11R4 */
1990 /* This function should be called when the user's lisp code has
1991 specified a name for the frame; the name will override any set by the
1994 x_explicitly_set_name (f
, arg
, oldval
)
1996 Lisp_Object arg
, oldval
;
1998 x_set_name (f
, arg
, 1);
2001 /* This function should be called by Emacs redisplay code to set the
2002 name; names set this way will never override names set by the user's
2005 x_implicitly_set_name (f
, arg
, oldval
)
2007 Lisp_Object arg
, oldval
;
2009 x_set_name (f
, arg
, 0);
2012 /* Change the title of frame F to NAME.
2013 If NAME is nil, use the frame name as the title.
2015 If EXPLICIT is non-zero, that indicates that lisp code is setting the
2016 name; if NAME is a string, set F's name to NAME and set
2017 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
2019 If EXPLICIT is zero, that indicates that Emacs redisplay code is
2020 suggesting a new name, which lisp code should override; if
2021 F->explicit_name is set, ignore the new name; otherwise, set it. */
2024 x_set_title (f
, name
, old_name
)
2026 Lisp_Object name
, old_name
;
2028 /* Don't change the title if it's already NAME. */
2029 if (EQ (name
, f
->title
))
2032 update_mode_lines
= 1;
2039 CHECK_STRING (name
);
2041 if (FRAME_X_WINDOW (f
))
2046 XTextProperty text
, icon
;
2048 Lisp_Object coding_system
;
2050 coding_system
= Qcompound_text
;
2051 /* See the comment "Note: Encoding strategy" in x_set_name. */
2052 text
.value
= x_encode_text (name
, coding_system
, 0, &bytes
, &stringp
);
2053 text
.encoding
= (stringp
? XA_STRING
2054 : FRAME_X_DISPLAY_INFO (f
)->Xatom_COMPOUND_TEXT
);
2056 text
.nitems
= bytes
;
2058 if (NILP (f
->icon_name
))
2064 /* See the comment "Note: Encoding strategy" in x_set_name. */
2065 icon
.value
= x_encode_text (f
->icon_name
, coding_system
, 0,
2067 icon
.encoding
= (stringp
? XA_STRING
2068 : FRAME_X_DISPLAY_INFO (f
)->Xatom_COMPOUND_TEXT
);
2070 icon
.nitems
= bytes
;
2074 gtk_window_set_title (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
2076 #else /* not USE_GTK */
2077 XSetWMName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
2078 #endif /* not USE_GTK */
2080 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
2083 if (!NILP (f
->icon_name
)
2084 && icon
.value
!= (unsigned char *) SDATA (f
->icon_name
))
2086 if (text
.value
!= (unsigned char *) SDATA (name
))
2089 #else /* not HAVE_X11R4 */
2090 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2092 XStoreName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2094 #endif /* not HAVE_X11R4 */
2100 x_set_scroll_bar_default_width (f
)
2103 int wid
= FRAME_COLUMN_WIDTH (f
);
2105 #ifdef USE_TOOLKIT_SCROLL_BARS
2106 /* A minimum width of 14 doesn't look good for toolkit scroll bars. */
2107 int width
= 16 + 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
2108 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (width
+ wid
- 1) / wid
;
2109 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) = width
;
2111 /* Make the actual width at least 14 pixels and a multiple of a
2113 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
2115 /* Use all of that space (aside from required margins) for the
2117 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) = 0;
2122 /* Record in frame F the specified or default value according to ALIST
2123 of the parameter named PROP (a Lisp symbol). If no value is
2124 specified for PROP, look for an X default for XPROP on the frame
2125 named NAME. If that is not found either, use the value DEFLT. */
2128 x_default_scroll_bar_color_parameter (f
, alist
, prop
, xprop
, xclass
,
2137 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2140 tem
= x_get_arg (dpyinfo
, alist
, prop
, xprop
, xclass
, RES_TYPE_STRING
);
2141 if (EQ (tem
, Qunbound
))
2143 #ifdef USE_TOOLKIT_SCROLL_BARS
2145 /* See if an X resource for the scroll bar color has been
2147 tem
= display_x_get_resource (dpyinfo
,
2148 build_string (foreground_p
2152 build_string ("verticalScrollBar"),
2156 /* If nothing has been specified, scroll bars will use a
2157 toolkit-dependent default. Because these defaults are
2158 difficult to get at without actually creating a scroll
2159 bar, use nil to indicate that no color has been
2164 #else /* not USE_TOOLKIT_SCROLL_BARS */
2168 #endif /* not USE_TOOLKIT_SCROLL_BARS */
2171 x_set_frame_parameters (f
, Fcons (Fcons (prop
, tem
), Qnil
));
2177 #if !defined (HAVE_X11R4) && !defined (HAVE_XSETWMPROTOCOLS)
2180 XSetWMProtocols (dpy
, w
, protocols
, count
)
2187 prop
= XInternAtom (dpy
, "WM_PROTOCOLS", False
);
2188 if (prop
== None
) return False
;
2189 XChangeProperty (dpy
, w
, prop
, XA_ATOM
, 32, PropModeReplace
,
2190 (unsigned char *) protocols
, count
);
2193 #endif /* not HAVE_X11R4 && not HAVE_XSETWMPROTOCOLS */
2195 #ifdef USE_X_TOOLKIT
2197 /* If the WM_PROTOCOLS property does not already contain WM_TAKE_FOCUS,
2198 WM_DELETE_WINDOW, and WM_SAVE_YOURSELF, then add them. (They may
2199 already be present because of the toolkit (Motif adds some of them,
2200 for example, but Xt doesn't). */
2203 hack_wm_protocols (f
, widget
)
2207 Display
*dpy
= XtDisplay (widget
);
2208 Window w
= XtWindow (widget
);
2209 int need_delete
= 1;
2215 Atom type
, *atoms
= 0;
2217 unsigned long nitems
= 0;
2218 unsigned long bytes_after
;
2220 if ((XGetWindowProperty (dpy
, w
,
2221 FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_protocols
,
2222 (long)0, (long)100, False
, XA_ATOM
,
2223 &type
, &format
, &nitems
, &bytes_after
,
2224 (unsigned char **) &atoms
)
2226 && format
== 32 && type
== XA_ATOM
)
2230 if (atoms
[nitems
] == FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_delete_window
)
2232 else if (atoms
[nitems
] == FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_take_focus
)
2234 else if (atoms
[nitems
] == FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_save_yourself
)
2237 if (atoms
) XFree ((char *) atoms
);
2243 props
[count
++] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_delete_window
;
2245 props
[count
++] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_take_focus
;
2247 props
[count
++] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_save_yourself
;
2249 XChangeProperty (dpy
, w
, FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_protocols
,
2250 XA_ATOM
, 32, PropModeAppend
,
2251 (unsigned char *) props
, count
);
2259 /* Support routines for XIC (X Input Context). */
2263 static XFontSet xic_create_xfontset
P_ ((struct frame
*, char *));
2264 static XIMStyle best_xim_style
P_ ((XIMStyles
*, XIMStyles
*));
2267 /* Supported XIM styles, ordered by preference. */
2269 static XIMStyle supported_xim_styles
[] =
2271 XIMPreeditPosition
| XIMStatusArea
,
2272 XIMPreeditPosition
| XIMStatusNothing
,
2273 XIMPreeditPosition
| XIMStatusNone
,
2274 XIMPreeditNothing
| XIMStatusArea
,
2275 XIMPreeditNothing
| XIMStatusNothing
,
2276 XIMPreeditNothing
| XIMStatusNone
,
2277 XIMPreeditNone
| XIMStatusArea
,
2278 XIMPreeditNone
| XIMStatusNothing
,
2279 XIMPreeditNone
| XIMStatusNone
,
2284 /* Create an X fontset on frame F with base font name
2288 xic_create_xfontset (f
, base_fontname
)
2290 char *base_fontname
;
2293 char **missing_list
;
2297 xfs
= XCreateFontSet (FRAME_X_DISPLAY (f
),
2298 base_fontname
, &missing_list
,
2299 &missing_count
, &def_string
);
2301 XFreeStringList (missing_list
);
2303 /* No need to free def_string. */
2308 /* Value is the best input style, given user preferences USER (already
2309 checked to be supported by Emacs), and styles supported by the
2310 input method XIM. */
2313 best_xim_style (user
, xim
)
2319 for (i
= 0; i
< user
->count_styles
; ++i
)
2320 for (j
= 0; j
< xim
->count_styles
; ++j
)
2321 if (user
->supported_styles
[i
] == xim
->supported_styles
[j
])
2322 return user
->supported_styles
[i
];
2324 /* Return the default style. */
2325 return XIMPreeditNothing
| XIMStatusNothing
;
2328 /* Create XIC for frame F. */
2330 static XIMStyle xic_style
;
2333 create_frame_xic (f
)
2338 XFontSet xfs
= NULL
;
2343 xim
= FRAME_X_XIM (f
);
2348 XVaNestedList preedit_attr
;
2349 XVaNestedList status_attr
;
2350 char *base_fontname
;
2353 s_area
.x
= 0; s_area
.y
= 0; s_area
.width
= 1; s_area
.height
= 1;
2354 spot
.x
= 0; spot
.y
= 1;
2355 /* Create X fontset. */
2356 fontset
= FRAME_FONTSET (f
);
2358 base_fontname
= "-*-*-*-r-normal--14-*-*-*-*-*-*-*";
2361 /* Determine the base fontname from the ASCII font name of
2363 char *ascii_font
= (char *) SDATA (fontset_ascii (fontset
));
2364 char *p
= ascii_font
;
2367 for (i
= 0; *p
; p
++)
2370 /* As the font name doesn't conform to XLFD, we can't
2371 modify it to get a suitable base fontname for the
2373 base_fontname
= "-*-*-*-r-normal--14-*-*-*-*-*-*-*";
2376 int len
= strlen (ascii_font
) + 1;
2379 for (i
= 0, p
= ascii_font
; i
< 8; p
++)
2388 base_fontname
= (char *) alloca (len
);
2389 bzero (base_fontname
, len
);
2390 strcpy (base_fontname
, "-*-*-");
2391 bcopy (p1
, base_fontname
+ 5, p
- p1
);
2392 strcat (base_fontname
, "*-*-*-*-*-*-*");
2395 xfs
= xic_create_xfontset (f
, base_fontname
);
2397 /* Determine XIC style. */
2400 XIMStyles supported_list
;
2401 supported_list
.count_styles
= (sizeof supported_xim_styles
2402 / sizeof supported_xim_styles
[0]);
2403 supported_list
.supported_styles
= supported_xim_styles
;
2404 xic_style
= best_xim_style (&supported_list
,
2405 FRAME_X_XIM_STYLES (f
));
2408 preedit_attr
= XVaCreateNestedList (0,
2411 FRAME_FOREGROUND_PIXEL (f
),
2413 FRAME_BACKGROUND_PIXEL (f
),
2414 (xic_style
& XIMPreeditPosition
2419 status_attr
= XVaCreateNestedList (0,
2425 FRAME_FOREGROUND_PIXEL (f
),
2427 FRAME_BACKGROUND_PIXEL (f
),
2430 xic
= XCreateIC (xim
,
2431 XNInputStyle
, xic_style
,
2432 XNClientWindow
, FRAME_X_WINDOW(f
),
2433 XNFocusWindow
, FRAME_X_WINDOW(f
),
2434 XNStatusAttributes
, status_attr
,
2435 XNPreeditAttributes
, preedit_attr
,
2437 XFree (preedit_attr
);
2438 XFree (status_attr
);
2441 FRAME_XIC (f
) = xic
;
2442 FRAME_XIC_STYLE (f
) = xic_style
;
2443 FRAME_XIC_FONTSET (f
) = xfs
;
2447 /* Destroy XIC and free XIC fontset of frame F, if any. */
2453 if (FRAME_XIC (f
) == NULL
)
2456 XDestroyIC (FRAME_XIC (f
));
2457 if (FRAME_XIC_FONTSET (f
))
2458 XFreeFontSet (FRAME_X_DISPLAY (f
), FRAME_XIC_FONTSET (f
));
2460 FRAME_XIC (f
) = NULL
;
2461 FRAME_XIC_FONTSET (f
) = NULL
;
2465 /* Place preedit area for XIC of window W's frame to specified
2466 pixel position X/Y. X and Y are relative to window W. */
2469 xic_set_preeditarea (w
, x
, y
)
2473 struct frame
*f
= XFRAME (w
->frame
);
2477 spot
.x
= WINDOW_TO_FRAME_PIXEL_X (w
, x
) + WINDOW_LEFT_FRINGE_WIDTH (w
);
2478 spot
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, y
) + FONT_BASE (FRAME_FONT (f
));
2479 attr
= XVaCreateNestedList (0, XNSpotLocation
, &spot
, NULL
);
2480 XSetICValues (FRAME_XIC (f
), XNPreeditAttributes
, attr
, NULL
);
2485 /* Place status area for XIC in bottom right corner of frame F.. */
2488 xic_set_statusarea (f
)
2491 XIC xic
= FRAME_XIC (f
);
2496 /* Negotiate geometry of status area. If input method has existing
2497 status area, use its current size. */
2498 area
.x
= area
.y
= area
.width
= area
.height
= 0;
2499 attr
= XVaCreateNestedList (0, XNAreaNeeded
, &area
, NULL
);
2500 XSetICValues (xic
, XNStatusAttributes
, attr
, NULL
);
2503 attr
= XVaCreateNestedList (0, XNAreaNeeded
, &needed
, NULL
);
2504 XGetICValues (xic
, XNStatusAttributes
, attr
, NULL
);
2507 if (needed
->width
== 0) /* Use XNArea instead of XNAreaNeeded */
2509 attr
= XVaCreateNestedList (0, XNArea
, &needed
, NULL
);
2510 XGetICValues (xic
, XNStatusAttributes
, attr
, NULL
);
2514 area
.width
= needed
->width
;
2515 area
.height
= needed
->height
;
2516 area
.x
= FRAME_PIXEL_WIDTH (f
) - area
.width
- FRAME_INTERNAL_BORDER_WIDTH (f
);
2517 area
.y
= (FRAME_PIXEL_HEIGHT (f
) - area
.height
2518 - FRAME_MENUBAR_HEIGHT (f
)
2519 - FRAME_TOOLBAR_HEIGHT (f
)
2520 - FRAME_INTERNAL_BORDER_WIDTH (f
));
2523 attr
= XVaCreateNestedList (0, XNArea
, &area
, NULL
);
2524 XSetICValues(xic
, XNStatusAttributes
, attr
, NULL
);
2529 /* Set X fontset for XIC of frame F, using base font name
2530 BASE_FONTNAME. Called when a new Emacs fontset is chosen. */
2533 xic_set_xfontset (f
, base_fontname
)
2535 char *base_fontname
;
2540 xfs
= xic_create_xfontset (f
, base_fontname
);
2542 attr
= XVaCreateNestedList (0, XNFontSet
, xfs
, NULL
);
2543 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
2544 XSetICValues (FRAME_XIC (f
), XNPreeditAttributes
, attr
, NULL
);
2545 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
2546 XSetICValues (FRAME_XIC (f
), XNStatusAttributes
, attr
, NULL
);
2549 if (FRAME_XIC_FONTSET (f
))
2550 XFreeFontSet (FRAME_X_DISPLAY (f
), FRAME_XIC_FONTSET (f
));
2551 FRAME_XIC_FONTSET (f
) = xfs
;
2554 #endif /* HAVE_X_I18N */
2558 #ifdef USE_X_TOOLKIT
2560 /* Create and set up the X widget for frame F. */
2563 x_window (f
, window_prompting
, minibuffer_only
)
2565 long window_prompting
;
2566 int minibuffer_only
;
2568 XClassHint class_hints
;
2569 XSetWindowAttributes attributes
;
2570 unsigned long attribute_mask
;
2571 Widget shell_widget
;
2573 Widget frame_widget
;
2579 /* Use the resource name as the top-level widget name
2580 for looking up resources. Make a non-Lisp copy
2581 for the window manager, so GC relocation won't bother it.
2583 Elsewhere we specify the window name for the window manager. */
2586 char *str
= (char *) SDATA (Vx_resource_name
);
2587 f
->namebuf
= (char *) xmalloc (strlen (str
) + 1);
2588 strcpy (f
->namebuf
, str
);
2592 XtSetArg (al
[ac
], XtNallowShellResize
, 1); ac
++;
2593 XtSetArg (al
[ac
], XtNinput
, 1); ac
++;
2594 XtSetArg (al
[ac
], XtNmappedWhenManaged
, 0); ac
++;
2595 XtSetArg (al
[ac
], XtNborderWidth
, f
->border_width
); ac
++;
2596 XtSetArg (al
[ac
], XtNvisual
, FRAME_X_VISUAL (f
)); ac
++;
2597 XtSetArg (al
[ac
], XtNdepth
, FRAME_X_DISPLAY_INFO (f
)->n_planes
); ac
++;
2598 XtSetArg (al
[ac
], XtNcolormap
, FRAME_X_COLORMAP (f
)); ac
++;
2599 shell_widget
= XtAppCreateShell (f
->namebuf
, EMACS_CLASS
,
2600 applicationShellWidgetClass
,
2601 FRAME_X_DISPLAY (f
), al
, ac
);
2603 f
->output_data
.x
->widget
= shell_widget
;
2604 /* maybe_set_screen_title_format (shell_widget); */
2606 pane_widget
= lw_create_widget ("main", "pane", widget_id_tick
++,
2607 (widget_value
*) NULL
,
2608 shell_widget
, False
,
2612 (lw_callback
) NULL
);
2615 XtSetArg (al
[ac
], XtNvisual
, FRAME_X_VISUAL (f
)); ac
++;
2616 XtSetArg (al
[ac
], XtNdepth
, FRAME_X_DISPLAY_INFO (f
)->n_planes
); ac
++;
2617 XtSetArg (al
[ac
], XtNcolormap
, FRAME_X_COLORMAP (f
)); ac
++;
2618 XtSetValues (pane_widget
, al
, ac
);
2619 f
->output_data
.x
->column_widget
= pane_widget
;
2621 /* mappedWhenManaged to false tells to the paned window to not map/unmap
2622 the emacs screen when changing menubar. This reduces flickering. */
2625 XtSetArg (al
[ac
], XtNmappedWhenManaged
, 0); ac
++;
2626 XtSetArg (al
[ac
], XtNshowGrip
, 0); ac
++;
2627 XtSetArg (al
[ac
], XtNallowResize
, 1); ac
++;
2628 XtSetArg (al
[ac
], XtNresizeToPreferred
, 1); ac
++;
2629 XtSetArg (al
[ac
], XtNemacsFrame
, f
); ac
++;
2630 XtSetArg (al
[ac
], XtNvisual
, FRAME_X_VISUAL (f
)); ac
++;
2631 XtSetArg (al
[ac
], XtNdepth
, FRAME_X_DISPLAY_INFO (f
)->n_planes
); ac
++;
2632 XtSetArg (al
[ac
], XtNcolormap
, FRAME_X_COLORMAP (f
)); ac
++;
2633 frame_widget
= XtCreateWidget (f
->namebuf
, emacsFrameClass
, pane_widget
,
2636 f
->output_data
.x
->edit_widget
= frame_widget
;
2638 XtManageChild (frame_widget
);
2640 /* Do some needed geometry management. */
2643 char *tem
, shell_position
[32];
2646 int extra_borders
= 0;
2648 = (f
->output_data
.x
->menubar_widget
2649 ? (f
->output_data
.x
->menubar_widget
->core
.height
2650 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
2653 #if 0 /* Experimentally, we now get the right results
2654 for -geometry -0-0 without this. 24 Aug 96, rms. */
2655 if (FRAME_EXTERNAL_MENU_BAR (f
))
2658 XtVaGetValues (pane_widget
, XtNinternalBorderWidth
, &ibw
, NULL
);
2659 menubar_size
+= ibw
;
2663 f
->output_data
.x
->menubar_height
= menubar_size
;
2666 /* Motif seems to need this amount added to the sizes
2667 specified for the shell widget. The Athena/Lucid widgets don't.
2668 Both conclusions reached experimentally. -- rms. */
2669 XtVaGetValues (f
->output_data
.x
->edit_widget
, XtNinternalBorderWidth
,
2670 &extra_borders
, NULL
);
2674 /* Convert our geometry parameters into a geometry string
2676 Note that we do not specify here whether the position
2677 is a user-specified or program-specified one.
2678 We pass that information later, in x_wm_set_size_hints. */
2680 int left
= f
->left_pos
;
2681 int xneg
= window_prompting
& XNegative
;
2682 int top
= f
->top_pos
;
2683 int yneg
= window_prompting
& YNegative
;
2689 if (window_prompting
& USPosition
)
2690 sprintf (shell_position
, "=%dx%d%c%d%c%d",
2691 FRAME_PIXEL_WIDTH (f
) + extra_borders
,
2692 FRAME_PIXEL_HEIGHT (f
) + menubar_size
+ extra_borders
,
2693 (xneg
? '-' : '+'), left
,
2694 (yneg
? '-' : '+'), top
);
2696 sprintf (shell_position
, "=%dx%d",
2697 FRAME_PIXEL_WIDTH (f
) + extra_borders
,
2698 FRAME_PIXEL_HEIGHT (f
) + menubar_size
+ extra_borders
);
2701 len
= strlen (shell_position
) + 1;
2702 /* We don't free this because we don't know whether
2703 it is safe to free it while the frame exists.
2704 It isn't worth the trouble of arranging to free it
2705 when the frame is deleted. */
2706 tem
= (char *) xmalloc (len
);
2707 strncpy (tem
, shell_position
, len
);
2708 XtSetArg (al
[ac
], XtNgeometry
, tem
); ac
++;
2709 XtSetValues (shell_widget
, al
, ac
);
2712 XtManageChild (pane_widget
);
2713 XtRealizeWidget (shell_widget
);
2715 FRAME_X_WINDOW (f
) = XtWindow (frame_widget
);
2717 validate_x_resource_name ();
2719 class_hints
.res_name
= (char *) SDATA (Vx_resource_name
);
2720 class_hints
.res_class
= (char *) SDATA (Vx_resource_class
);
2721 XSetClassHint (FRAME_X_DISPLAY (f
), XtWindow (shell_widget
), &class_hints
);
2724 FRAME_XIC (f
) = NULL
;
2726 create_frame_xic (f
);
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
);
2734 hack_wm_protocols (f
, shell_widget
);
2737 XtAddEventHandler (shell_widget
, 0, True
, _XEditResCheckMessages
, 0);
2740 /* Do a stupid property change to force the server to generate a
2741 PropertyNotify event so that the event_stream server timestamp will
2742 be initialized to something relevant to the time we created the window.
2744 XChangeProperty (XtDisplay (frame_widget
), XtWindow (frame_widget
),
2745 FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_protocols
,
2746 XA_ATOM
, 32, PropModeAppend
,
2747 (unsigned char*) NULL
, 0);
2749 /* Make all the standard events reach the Emacs frame. */
2750 attributes
.event_mask
= STANDARD_EVENT_SET
;
2755 /* XIM server might require some X events. */
2756 unsigned long fevent
= NoEventMask
;
2757 XGetICValues(FRAME_XIC (f
), XNFilterEvents
, &fevent
, NULL
);
2758 attributes
.event_mask
|= fevent
;
2760 #endif /* HAVE_X_I18N */
2762 attribute_mask
= CWEventMask
;
2763 XChangeWindowAttributes (XtDisplay (shell_widget
), XtWindow (shell_widget
),
2764 attribute_mask
, &attributes
);
2766 XtMapWidget (frame_widget
);
2768 /* x_set_name normally ignores requests to set the name if the
2769 requested name is the same as the current name. This is the one
2770 place where that assumption isn't correct; f->name is set, but
2771 the X server hasn't been told. */
2774 int explicit = f
->explicit_name
;
2776 f
->explicit_name
= 0;
2779 x_set_name (f
, name
, explicit);
2782 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2783 f
->output_data
.x
->text_cursor
);
2787 /* This is a no-op, except under Motif. Make sure main areas are
2788 set to something reasonable, in case we get an error later. */
2789 lw_set_main_areas (pane_widget
, 0, frame_widget
);
2792 #else /* not USE_X_TOOLKIT */
2798 if (! xg_create_frame_widgets (f
))
2799 error ("Unable to create window");
2802 FRAME_XIC (f
) = NULL
;
2806 create_frame_xic (f
);
2809 /* XIM server might require some X events. */
2810 unsigned long fevent
= NoEventMask
;
2811 XGetICValues(FRAME_XIC (f
), XNFilterEvents
, &fevent
, NULL
);
2813 if (fevent
!= NoEventMask
)
2815 XSetWindowAttributes attributes
;
2816 XWindowAttributes wattr
;
2817 unsigned long attribute_mask
;
2819 XGetWindowAttributes (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2821 attributes
.event_mask
= wattr
.your_event_mask
| fevent
;
2822 attribute_mask
= CWEventMask
;
2823 XChangeWindowAttributes (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2824 attribute_mask
, &attributes
);
2832 #else /*! USE_GTK */
2833 /* Create and set up the X window for frame F. */
2840 XClassHint class_hints
;
2841 XSetWindowAttributes attributes
;
2842 unsigned long attribute_mask
;
2844 attributes
.background_pixel
= f
->output_data
.x
->background_pixel
;
2845 attributes
.border_pixel
= f
->output_data
.x
->border_pixel
;
2846 attributes
.bit_gravity
= StaticGravity
;
2847 attributes
.backing_store
= NotUseful
;
2848 attributes
.save_under
= True
;
2849 attributes
.event_mask
= STANDARD_EVENT_SET
;
2850 attributes
.colormap
= FRAME_X_COLORMAP (f
);
2851 attribute_mask
= (CWBackPixel
| CWBorderPixel
| CWBitGravity
| CWEventMask
2856 = XCreateWindow (FRAME_X_DISPLAY (f
),
2857 f
->output_data
.x
->parent_desc
,
2860 FRAME_PIXEL_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
),
2862 CopyFromParent
, /* depth */
2863 InputOutput
, /* class */
2865 attribute_mask
, &attributes
);
2870 create_frame_xic (f
);
2873 /* XIM server might require some X events. */
2874 unsigned long fevent
= NoEventMask
;
2875 XGetICValues(FRAME_XIC (f
), XNFilterEvents
, &fevent
, NULL
);
2876 attributes
.event_mask
|= fevent
;
2877 attribute_mask
= CWEventMask
;
2878 XChangeWindowAttributes (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2879 attribute_mask
, &attributes
);
2882 #endif /* HAVE_X_I18N */
2884 validate_x_resource_name ();
2886 class_hints
.res_name
= (char *) SDATA (Vx_resource_name
);
2887 class_hints
.res_class
= (char *) SDATA (Vx_resource_class
);
2888 XSetClassHint (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &class_hints
);
2890 /* The menubar is part of the ordinary display;
2891 it does not count in addition to the height of the window. */
2892 f
->output_data
.x
->menubar_height
= 0;
2894 /* This indicates that we use the "Passive Input" input model.
2895 Unless we do this, we don't get the Focus{In,Out} events that we
2896 need to draw the cursor correctly. Accursed bureaucrats.
2897 XWhipsAndChains (FRAME_X_DISPLAY (f), IronMaiden, &TheRack); */
2899 f
->output_data
.x
->wm_hints
.input
= True
;
2900 f
->output_data
.x
->wm_hints
.flags
|= InputHint
;
2901 XSetWMHints (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2902 &f
->output_data
.x
->wm_hints
);
2903 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
2905 /* Request "save yourself" and "delete window" commands from wm. */
2908 protocols
[0] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_delete_window
;
2909 protocols
[1] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_save_yourself
;
2910 XSetWMProtocols (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), protocols
, 2);
2913 /* x_set_name normally ignores requests to set the name if the
2914 requested name is the same as the current name. This is the one
2915 place where that assumption isn't correct; f->name is set, but
2916 the X server hasn't been told. */
2919 int explicit = f
->explicit_name
;
2921 f
->explicit_name
= 0;
2924 x_set_name (f
, name
, explicit);
2927 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2928 f
->output_data
.x
->text_cursor
);
2932 if (FRAME_X_WINDOW (f
) == 0)
2933 error ("Unable to create window");
2936 #endif /* not USE_GTK */
2937 #endif /* not USE_X_TOOLKIT */
2939 /* Handle the icon stuff for this window. Perhaps later we might
2940 want an x_set_icon_position which can be called interactively as
2948 Lisp_Object icon_x
, icon_y
;
2949 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2951 /* Set the position of the icon. Note that twm groups all
2952 icons in an icon window. */
2953 icon_x
= x_frame_get_and_record_arg (f
, parms
, Qicon_left
, 0, 0, RES_TYPE_NUMBER
);
2954 icon_y
= x_frame_get_and_record_arg (f
, parms
, Qicon_top
, 0, 0, RES_TYPE_NUMBER
);
2955 if (!EQ (icon_x
, Qunbound
) && !EQ (icon_y
, Qunbound
))
2957 CHECK_NUMBER (icon_x
);
2958 CHECK_NUMBER (icon_y
);
2960 else if (!EQ (icon_x
, Qunbound
) || !EQ (icon_y
, Qunbound
))
2961 error ("Both left and top icon corners of icon must be specified");
2965 if (! EQ (icon_x
, Qunbound
))
2966 x_wm_set_icon_position (f
, XINT (icon_x
), XINT (icon_y
));
2968 /* Start up iconic or window? */
2969 x_wm_set_window_state
2970 (f
, (EQ (x_get_arg (dpyinfo
, parms
, Qvisibility
, 0, 0, RES_TYPE_SYMBOL
),
2975 x_text_icon (f
, (char *) SDATA ((!NILP (f
->icon_name
)
2982 /* Make the GCs needed for this window, setting the
2983 background, border and mouse colors; also create the
2984 mouse cursor and the gray border tile. */
2986 static char cursor_bits
[] =
2988 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2989 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2990 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2991 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2998 XGCValues gc_values
;
3002 /* Create the GCs of this frame.
3003 Note that many default values are used. */
3006 gc_values
.font
= FRAME_FONT (f
)->fid
;
3007 gc_values
.foreground
= f
->output_data
.x
->foreground_pixel
;
3008 gc_values
.background
= f
->output_data
.x
->background_pixel
;
3009 gc_values
.line_width
= 0; /* Means 1 using fast algorithm. */
3010 f
->output_data
.x
->normal_gc
3011 = XCreateGC (FRAME_X_DISPLAY (f
),
3013 GCLineWidth
| GCFont
| GCForeground
| GCBackground
,
3016 /* Reverse video style. */
3017 gc_values
.foreground
= f
->output_data
.x
->background_pixel
;
3018 gc_values
.background
= f
->output_data
.x
->foreground_pixel
;
3019 f
->output_data
.x
->reverse_gc
3020 = XCreateGC (FRAME_X_DISPLAY (f
),
3022 GCFont
| GCForeground
| GCBackground
| GCLineWidth
,
3025 /* Cursor has cursor-color background, background-color foreground. */
3026 gc_values
.foreground
= f
->output_data
.x
->background_pixel
;
3027 gc_values
.background
= f
->output_data
.x
->cursor_pixel
;
3028 gc_values
.fill_style
= FillOpaqueStippled
;
3030 = XCreateBitmapFromData (FRAME_X_DISPLAY (f
),
3031 FRAME_X_DISPLAY_INFO (f
)->root_window
,
3032 cursor_bits
, 16, 16);
3033 f
->output_data
.x
->cursor_gc
3034 = XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3035 (GCFont
| GCForeground
| GCBackground
3036 | GCFillStyle
/* | GCStipple */ | GCLineWidth
),
3040 f
->output_data
.x
->white_relief
.gc
= 0;
3041 f
->output_data
.x
->black_relief
.gc
= 0;
3043 /* Create the gray border tile used when the pointer is not in
3044 the frame. Since this depends on the frame's pixel values,
3045 this must be done on a per-frame basis. */
3046 f
->output_data
.x
->border_tile
3047 = (XCreatePixmapFromBitmapData
3048 (FRAME_X_DISPLAY (f
), FRAME_X_DISPLAY_INFO (f
)->root_window
,
3049 gray_bits
, gray_width
, gray_height
,
3050 f
->output_data
.x
->foreground_pixel
,
3051 f
->output_data
.x
->background_pixel
,
3052 DefaultDepth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
))));
3058 /* Free what was was allocated in x_make_gc. */
3064 Display
*dpy
= FRAME_X_DISPLAY (f
);
3068 if (f
->output_data
.x
->normal_gc
)
3070 XFreeGC (dpy
, f
->output_data
.x
->normal_gc
);
3071 f
->output_data
.x
->normal_gc
= 0;
3074 if (f
->output_data
.x
->reverse_gc
)
3076 XFreeGC (dpy
, f
->output_data
.x
->reverse_gc
);
3077 f
->output_data
.x
->reverse_gc
= 0;
3080 if (f
->output_data
.x
->cursor_gc
)
3082 XFreeGC (dpy
, f
->output_data
.x
->cursor_gc
);
3083 f
->output_data
.x
->cursor_gc
= 0;
3086 if (f
->output_data
.x
->border_tile
)
3088 XFreePixmap (dpy
, f
->output_data
.x
->border_tile
);
3089 f
->output_data
.x
->border_tile
= 0;
3096 /* Handler for signals raised during x_create_frame and
3097 x_create_top_frame. FRAME is the frame which is partially
3101 unwind_create_frame (frame
)
3104 struct frame
*f
= XFRAME (frame
);
3106 /* If frame is ``official'', nothing to do. */
3107 if (!CONSP (Vframe_list
) || !EQ (XCAR (Vframe_list
), frame
))
3110 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3113 x_free_frame_resources (f
);
3115 /* Check that reference counts are indeed correct. */
3116 xassert (dpyinfo
->reference_count
== dpyinfo_refcount
);
3117 xassert (dpyinfo
->image_cache
->refcount
== image_cache_refcount
);
3125 DEFUN ("x-create-frame", Fx_create_frame
, Sx_create_frame
,
3127 doc
: /* Make a new X window, which is called a "frame" in Emacs terms.
3128 Returns an Emacs frame object.
3129 ALIST is an alist of frame parameters.
3130 If the parameters specify that the frame should not have a minibuffer,
3131 and do not specify a specific minibuffer window to use,
3132 then `default-minibuffer-frame' must be a frame whose minibuffer can
3133 be shared by the new frame.
3135 This function is an internal primitive--use `make-frame' instead. */)
3140 Lisp_Object frame
, tem
;
3142 int minibuffer_only
= 0;
3143 long window_prompting
= 0;
3145 int count
= SPECPDL_INDEX ();
3146 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
3147 Lisp_Object display
;
3148 struct x_display_info
*dpyinfo
= NULL
;
3154 /* Use this general default value to start with
3155 until we know if this frame has a specified name. */
3156 Vx_resource_name
= Vinvocation_name
;
3158 display
= x_get_arg (dpyinfo
, parms
, Qdisplay
, 0, 0, RES_TYPE_STRING
);
3159 if (EQ (display
, Qunbound
))
3161 dpyinfo
= check_x_display_info (display
);
3163 kb
= dpyinfo
->kboard
;
3165 kb
= &the_only_kboard
;
3168 name
= x_get_arg (dpyinfo
, parms
, Qname
, "name", "Name", RES_TYPE_STRING
);
3170 && ! EQ (name
, Qunbound
)
3172 error ("Invalid frame name--not a string or nil");
3175 Vx_resource_name
= name
;
3177 /* See if parent window is specified. */
3178 parent
= x_get_arg (dpyinfo
, parms
, Qparent_id
, NULL
, NULL
, RES_TYPE_NUMBER
);
3179 if (EQ (parent
, Qunbound
))
3181 if (! NILP (parent
))
3182 CHECK_NUMBER (parent
);
3184 /* make_frame_without_minibuffer can run Lisp code and garbage collect. */
3185 /* No need to protect DISPLAY because that's not used after passing
3186 it to make_frame_without_minibuffer. */
3188 GCPRO4 (parms
, parent
, name
, frame
);
3189 tem
= x_get_arg (dpyinfo
, parms
, Qminibuffer
, "minibuffer", "Minibuffer",
3191 if (EQ (tem
, Qnone
) || NILP (tem
))
3192 f
= make_frame_without_minibuffer (Qnil
, kb
, display
);
3193 else if (EQ (tem
, Qonly
))
3195 f
= make_minibuffer_frame ();
3196 minibuffer_only
= 1;
3198 else if (WINDOWP (tem
))
3199 f
= make_frame_without_minibuffer (tem
, kb
, display
);
3203 XSETFRAME (frame
, f
);
3205 /* Note that X Windows does support scroll bars. */
3206 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 1;
3208 f
->output_method
= output_x_window
;
3209 f
->output_data
.x
= (struct x_output
*) xmalloc (sizeof (struct x_output
));
3210 bzero (f
->output_data
.x
, sizeof (struct x_output
));
3211 f
->output_data
.x
->icon_bitmap
= -1;
3212 FRAME_FONTSET (f
) = -1;
3213 f
->output_data
.x
->scroll_bar_foreground_pixel
= -1;
3214 f
->output_data
.x
->scroll_bar_background_pixel
= -1;
3215 #ifdef USE_TOOLKIT_SCROLL_BARS
3216 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= -1;
3217 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= -1;
3218 #endif /* USE_TOOLKIT_SCROLL_BARS */
3219 record_unwind_protect (unwind_create_frame
, frame
);
3222 = x_get_arg (dpyinfo
, parms
, Qicon_name
, "iconName", "Title",
3224 if (! STRINGP (f
->icon_name
))
3225 f
->icon_name
= Qnil
;
3227 FRAME_X_DISPLAY_INFO (f
) = dpyinfo
;
3229 image_cache_refcount
= FRAME_X_IMAGE_CACHE (f
)->refcount
;
3230 dpyinfo_refcount
= dpyinfo
->reference_count
;
3231 #endif /* GLYPH_DEBUG */
3233 FRAME_KBOARD (f
) = kb
;
3236 /* These colors will be set anyway later, but it's important
3237 to get the color reference counts right, so initialize them! */
3240 struct gcpro gcpro1
;
3242 /* Function x_decode_color can signal an error. Make
3243 sure to initialize color slots so that we won't try
3244 to free colors we haven't allocated. */
3245 f
->output_data
.x
->foreground_pixel
= -1;
3246 f
->output_data
.x
->background_pixel
= -1;
3247 f
->output_data
.x
->cursor_pixel
= -1;
3248 f
->output_data
.x
->cursor_foreground_pixel
= -1;
3249 f
->output_data
.x
->border_pixel
= -1;
3250 f
->output_data
.x
->mouse_pixel
= -1;
3252 black
= build_string ("black");
3254 f
->output_data
.x
->foreground_pixel
3255 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3256 f
->output_data
.x
->background_pixel
3257 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3258 f
->output_data
.x
->cursor_pixel
3259 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3260 f
->output_data
.x
->cursor_foreground_pixel
3261 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3262 f
->output_data
.x
->border_pixel
3263 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3264 f
->output_data
.x
->mouse_pixel
3265 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3269 /* Specify the parent under which to make this X window. */
3273 f
->output_data
.x
->parent_desc
= (Window
) XFASTINT (parent
);
3274 f
->output_data
.x
->explicit_parent
= 1;
3278 f
->output_data
.x
->parent_desc
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
3279 f
->output_data
.x
->explicit_parent
= 0;
3282 /* Set the name; the functions to which we pass f expect the name to
3284 if (EQ (name
, Qunbound
) || NILP (name
))
3286 f
->name
= build_string (dpyinfo
->x_id_name
);
3287 f
->explicit_name
= 0;
3292 f
->explicit_name
= 1;
3293 /* use the frame's title when getting resources for this frame. */
3294 specbind (Qx_resource_name
, name
);
3297 /* Extract the window parameters from the supplied values
3298 that are needed to determine window geometry. */
3302 font
= x_get_arg (dpyinfo
, parms
, Qfont
, "font", "Font", RES_TYPE_STRING
);
3304 /* If the caller has specified no font, try out fonts which we
3305 hope have bold and italic variations. */
3306 if (!STRINGP (font
))
3309 = { "-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1",
3310 "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1",
3311 "-*-*-medium-r-normal-*-*-140-*-*-c-*-iso8859-1",
3312 /* This was formerly the first thing tried, but it finds
3313 too many fonts and takes too long. */
3314 "-*-*-medium-r-*-*-*-*-*-*-c-*-iso8859-1",
3315 /* If those didn't work, look for something which will
3317 "-*-fixed-*-*-*-*-*-140-*-*-c-*-iso8859-1",
3322 for (i
= 0; names
[i
]; i
++)
3326 list
= x_list_fonts (f
, build_string (names
[i
]), 0, 1);
3334 if (! STRINGP (font
))
3335 font
= build_string ("fixed");
3337 x_default_parameter (f
, parms
, Qfont
, font
,
3338 "font", "Font", RES_TYPE_STRING
);
3342 /* Prevent lwlib/xlwmenu.c from crashing because of a bug
3343 whereby it fails to get any font. */
3344 xlwmenu_default_font
= FRAME_FONT (f
);
3347 x_default_parameter (f
, parms
, Qborder_width
, make_number (2),
3348 "borderWidth", "BorderWidth", RES_TYPE_NUMBER
);
3350 /* This defaults to 1 in order to match xterm. We recognize either
3351 internalBorderWidth or internalBorder (which is what xterm calls
3353 if (NILP (Fassq (Qinternal_border_width
, parms
)))
3357 value
= x_get_arg (dpyinfo
, parms
, Qinternal_border_width
,
3358 "internalBorder", "internalBorder", RES_TYPE_NUMBER
);
3359 if (! EQ (value
, Qunbound
))
3360 parms
= Fcons (Fcons (Qinternal_border_width
, value
),
3363 x_default_parameter (f
, parms
, Qinternal_border_width
, make_number (1),
3364 "internalBorderWidth", "internalBorderWidth",
3366 x_default_parameter (f
, parms
, Qvertical_scroll_bars
, Qleft
,
3367 "verticalScrollBars", "ScrollBars",
3370 /* Also do the stuff which must be set before the window exists. */
3371 x_default_parameter (f
, parms
, Qforeground_color
, build_string ("black"),
3372 "foreground", "Foreground", RES_TYPE_STRING
);
3373 x_default_parameter (f
, parms
, Qbackground_color
, build_string ("white"),
3374 "background", "Background", RES_TYPE_STRING
);
3375 x_default_parameter (f
, parms
, Qmouse_color
, build_string ("black"),
3376 "pointerColor", "Foreground", RES_TYPE_STRING
);
3377 x_default_parameter (f
, parms
, Qcursor_color
, build_string ("black"),
3378 "cursorColor", "Foreground", RES_TYPE_STRING
);
3379 x_default_parameter (f
, parms
, Qborder_color
, build_string ("black"),
3380 "borderColor", "BorderColor", RES_TYPE_STRING
);
3381 x_default_parameter (f
, parms
, Qscreen_gamma
, Qnil
,
3382 "screenGamma", "ScreenGamma", RES_TYPE_FLOAT
);
3383 x_default_parameter (f
, parms
, Qline_spacing
, Qnil
,
3384 "lineSpacing", "LineSpacing", RES_TYPE_NUMBER
);
3385 x_default_parameter (f
, parms
, Qleft_fringe
, Qnil
,
3386 "leftFringe", "LeftFringe", RES_TYPE_NUMBER
);
3387 x_default_parameter (f
, parms
, Qright_fringe
, Qnil
,
3388 "rightFringe", "RightFringe", RES_TYPE_NUMBER
);
3390 x_default_scroll_bar_color_parameter (f
, parms
, Qscroll_bar_foreground
,
3391 "scrollBarForeground",
3392 "ScrollBarForeground", 1);
3393 x_default_scroll_bar_color_parameter (f
, parms
, Qscroll_bar_background
,
3394 "scrollBarBackground",
3395 "ScrollBarBackground", 0);
3397 /* Init faces before x_default_parameter is called for scroll-bar
3398 parameters because that function calls x_set_scroll_bar_width,
3399 which calls change_frame_size, which calls Fset_window_buffer,
3400 which runs hooks, which call Fvertical_motion. At the end, we
3401 end up in init_iterator with a null face cache, which should not
3403 init_frame_faces (f
);
3405 x_default_parameter (f
, parms
, Qmenu_bar_lines
, make_number (1),
3406 "menuBar", "MenuBar", RES_TYPE_NUMBER
);
3407 x_default_parameter (f
, parms
, Qtool_bar_lines
, make_number (1),
3408 "toolBar", "ToolBar", RES_TYPE_NUMBER
);
3409 x_default_parameter (f
, parms
, Qbuffer_predicate
, Qnil
,
3410 "bufferPredicate", "BufferPredicate",
3412 x_default_parameter (f
, parms
, Qtitle
, Qnil
,
3413 "title", "Title", RES_TYPE_STRING
);
3414 x_default_parameter (f
, parms
, Qwait_for_wm
, Qt
,
3415 "waitForWM", "WaitForWM", RES_TYPE_BOOLEAN
);
3416 x_default_parameter (f
, parms
, Qfullscreen
, Qnil
,
3417 "fullscreen", "Fullscreen", RES_TYPE_SYMBOL
);
3419 f
->output_data
.x
->parent_desc
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
3421 /* Compute the size of the X window. */
3422 window_prompting
= x_figure_window_size (f
, parms
, 1);
3424 tem
= x_get_arg (dpyinfo
, parms
, Qunsplittable
, 0, 0, RES_TYPE_BOOLEAN
);
3425 f
->no_split
= minibuffer_only
|| EQ (tem
, Qt
);
3427 /* Create the X widget or window. */
3428 #ifdef USE_X_TOOLKIT
3429 x_window (f
, window_prompting
, minibuffer_only
);
3437 /* Now consider the frame official. */
3438 FRAME_X_DISPLAY_INFO (f
)->reference_count
++;
3439 Vframe_list
= Fcons (frame
, Vframe_list
);
3441 /* We need to do this after creating the X window, so that the
3442 icon-creation functions can say whose icon they're describing. */
3443 x_default_parameter (f
, parms
, Qicon_type
, Qnil
,
3444 "bitmapIcon", "BitmapIcon", RES_TYPE_SYMBOL
);
3446 x_default_parameter (f
, parms
, Qauto_raise
, Qnil
,
3447 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
3448 x_default_parameter (f
, parms
, Qauto_lower
, Qnil
,
3449 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
3450 x_default_parameter (f
, parms
, Qcursor_type
, Qbox
,
3451 "cursorType", "CursorType", RES_TYPE_SYMBOL
);
3452 x_default_parameter (f
, parms
, Qscroll_bar_width
, Qnil
,
3453 "scrollBarWidth", "ScrollBarWidth",
3456 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
3457 Change will not be effected unless different from the current
3459 width
= FRAME_COLS (f
);
3460 height
= FRAME_LINES (f
);
3462 SET_FRAME_COLS (f
, 0);
3463 FRAME_LINES (f
) = 0;
3464 change_frame_size (f
, height
, width
, 1, 0, 0);
3466 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
3467 /* Create the menu bar. */
3468 if (!minibuffer_only
&& FRAME_EXTERNAL_MENU_BAR (f
))
3470 /* If this signals an error, we haven't set size hints for the
3471 frame and we didn't make it visible. */
3472 initialize_frame_menubar (f
);
3475 /* This is a no-op, except under Motif where it arranges the
3476 main window for the widgets on it. */
3477 lw_set_main_areas (f
->output_data
.x
->column_widget
,
3478 f
->output_data
.x
->menubar_widget
,
3479 f
->output_data
.x
->edit_widget
);
3480 #endif /* not USE_GTK */
3482 #endif /* USE_X_TOOLKIT || USE_GTK */
3484 /* Tell the server what size and position, etc, we want, and how
3485 badly we want them. This should be done after we have the menu
3486 bar so that its size can be taken into account. */
3488 x_wm_set_size_hint (f
, window_prompting
, 0);
3491 /* Make the window appear on the frame and enable display, unless
3492 the caller says not to. However, with explicit parent, Emacs
3493 cannot control visibility, so don't try. */
3494 if (! f
->output_data
.x
->explicit_parent
)
3496 Lisp_Object visibility
;
3498 visibility
= x_get_arg (dpyinfo
, parms
, Qvisibility
, 0, 0,
3500 if (EQ (visibility
, Qunbound
))
3503 if (EQ (visibility
, Qicon
))
3504 x_iconify_frame (f
);
3505 else if (! NILP (visibility
))
3506 x_make_frame_visible (f
);
3508 /* Must have been Qnil. */
3514 /* Make sure windows on this frame appear in calls to next-window
3515 and similar functions. */
3516 Vwindow_list
= Qnil
;
3518 return unbind_to (count
, frame
);
3522 /* FRAME is used only to get a handle on the X display. We don't pass the
3523 display info directly because we're called from frame.c, which doesn't
3524 know about that structure. */
3527 x_get_focus_frame (frame
)
3528 struct frame
*frame
;
3530 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (frame
);
3532 if (! dpyinfo
->x_focus_frame
)
3535 XSETFRAME (xfocus
, dpyinfo
->x_focus_frame
);
3540 /* In certain situations, when the window manager follows a
3541 click-to-focus policy, there seems to be no way around calling
3542 XSetInputFocus to give another frame the input focus .
3544 In an ideal world, XSetInputFocus should generally be avoided so
3545 that applications don't interfere with the window manager's focus
3546 policy. But I think it's okay to use when it's clearly done
3547 following a user-command. */
3549 DEFUN ("x-focus-frame", Fx_focus_frame
, Sx_focus_frame
, 1, 1, 0,
3550 doc
: /* Set the input focus to FRAME.
3551 FRAME nil means use the selected frame. */)
3555 struct frame
*f
= check_x_frame (frame
);
3556 Display
*dpy
= FRAME_X_DISPLAY (f
);
3560 count
= x_catch_errors (dpy
);
3561 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3562 RevertToParent
, CurrentTime
);
3563 x_uncatch_errors (dpy
, count
);
3570 DEFUN ("xw-color-defined-p", Fxw_color_defined_p
, Sxw_color_defined_p
, 1, 2, 0,
3571 doc
: /* Internal function called by `color-defined-p', which see. */)
3573 Lisp_Object color
, frame
;
3576 FRAME_PTR f
= check_x_frame (frame
);
3578 CHECK_STRING (color
);
3580 if (x_defined_color (f
, SDATA (color
), &foo
, 0))
3586 DEFUN ("xw-color-values", Fxw_color_values
, Sxw_color_values
, 1, 2, 0,
3587 doc
: /* Internal function called by `color-values', which see. */)
3589 Lisp_Object color
, frame
;
3592 FRAME_PTR f
= check_x_frame (frame
);
3594 CHECK_STRING (color
);
3596 if (x_defined_color (f
, SDATA (color
), &foo
, 0))
3600 rgb
[0] = make_number (foo
.red
);
3601 rgb
[1] = make_number (foo
.green
);
3602 rgb
[2] = make_number (foo
.blue
);
3603 return Flist (3, rgb
);
3609 DEFUN ("xw-display-color-p", Fxw_display_color_p
, Sxw_display_color_p
, 0, 1, 0,
3610 doc
: /* Internal function called by `display-color-p', which see. */)
3612 Lisp_Object display
;
3614 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3616 if (dpyinfo
->n_planes
<= 2)
3619 switch (dpyinfo
->visual
->class)
3632 DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p
, Sx_display_grayscale_p
,
3634 doc
: /* Return t if the X display supports shades of gray.
3635 Note that color displays do support shades of gray.
3636 The optional argument DISPLAY specifies which display to ask about.
3637 DISPLAY should be either a frame or a display name (a string).
3638 If omitted or nil, that stands for the selected frame's display. */)
3640 Lisp_Object display
;
3642 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3644 if (dpyinfo
->n_planes
<= 1)
3647 switch (dpyinfo
->visual
->class)
3662 DEFUN ("x-display-pixel-width", Fx_display_pixel_width
, Sx_display_pixel_width
,
3664 doc
: /* Returns the width in pixels of the X 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. */)
3669 Lisp_Object display
;
3671 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3673 return make_number (dpyinfo
->width
);
3676 DEFUN ("x-display-pixel-height", Fx_display_pixel_height
,
3677 Sx_display_pixel_height
, 0, 1, 0,
3678 doc
: /* Returns the height in pixels of the X display DISPLAY.
3679 The optional argument DISPLAY specifies which display to ask about.
3680 DISPLAY should be either a frame or a display name (a string).
3681 If omitted or nil, that stands for the selected frame's display. */)
3683 Lisp_Object display
;
3685 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3687 return make_number (dpyinfo
->height
);
3690 DEFUN ("x-display-planes", Fx_display_planes
, Sx_display_planes
,
3692 doc
: /* Returns the number of bitplanes of the X display DISPLAY.
3693 The optional argument DISPLAY specifies which display to ask about.
3694 DISPLAY should be either a frame or a display name (a string).
3695 If omitted or nil, that stands for the selected frame's display. */)
3697 Lisp_Object display
;
3699 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3701 return make_number (dpyinfo
->n_planes
);
3704 DEFUN ("x-display-color-cells", Fx_display_color_cells
, Sx_display_color_cells
,
3706 doc
: /* Returns the number of color cells of the X display DISPLAY.
3707 The optional argument DISPLAY specifies which display to ask about.
3708 DISPLAY should be either a frame or a display name (a string).
3709 If omitted or nil, that stands for the selected frame's display. */)
3711 Lisp_Object display
;
3713 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3715 return make_number (DisplayCells (dpyinfo
->display
,
3716 XScreenNumberOfScreen (dpyinfo
->screen
)));
3719 DEFUN ("x-server-max-request-size", Fx_server_max_request_size
,
3720 Sx_server_max_request_size
,
3722 doc
: /* Returns the maximum request size of the X server of display DISPLAY.
3723 The optional argument DISPLAY specifies which display to ask about.
3724 DISPLAY should be either a frame or a display name (a string).
3725 If omitted or nil, that stands for the selected frame's display. */)
3727 Lisp_Object display
;
3729 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3731 return make_number (MAXREQUEST (dpyinfo
->display
));
3734 DEFUN ("x-server-vendor", Fx_server_vendor
, Sx_server_vendor
, 0, 1, 0,
3735 doc
: /* Returns the vendor ID string of the X server of display DISPLAY.
3736 The optional argument DISPLAY specifies which display to ask about.
3737 DISPLAY should be either a frame or a display name (a string).
3738 If omitted or nil, that stands for the selected frame's display. */)
3740 Lisp_Object display
;
3742 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3743 char *vendor
= ServerVendor (dpyinfo
->display
);
3745 if (! vendor
) vendor
= "";
3746 return build_string (vendor
);
3749 DEFUN ("x-server-version", Fx_server_version
, Sx_server_version
, 0, 1, 0,
3750 doc
: /* Returns the version numbers of the X server of display DISPLAY.
3751 The value is a list of three integers: the major and minor
3752 version numbers of the X Protocol in use, and the vendor-specific release
3753 number. See also the function `x-server-vendor'.
3755 The optional argument DISPLAY specifies which display to ask about.
3756 DISPLAY should be either a frame or a display name (a string).
3757 If omitted or nil, that stands for the selected frame's display. */)
3759 Lisp_Object display
;
3761 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3762 Display
*dpy
= dpyinfo
->display
;
3764 return Fcons (make_number (ProtocolVersion (dpy
)),
3765 Fcons (make_number (ProtocolRevision (dpy
)),
3766 Fcons (make_number (VendorRelease (dpy
)), Qnil
)));
3769 DEFUN ("x-display-screens", Fx_display_screens
, Sx_display_screens
, 0, 1, 0,
3770 doc
: /* Return the number of screens on the X server of display DISPLAY.
3771 The optional argument DISPLAY specifies which display to ask about.
3772 DISPLAY should be either a frame or a display name (a string).
3773 If omitted or nil, that stands for the selected frame's display. */)
3775 Lisp_Object display
;
3777 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3779 return make_number (ScreenCount (dpyinfo
->display
));
3782 DEFUN ("x-display-mm-height", Fx_display_mm_height
, Sx_display_mm_height
, 0, 1, 0,
3783 doc
: /* Return the height in millimeters of the X display DISPLAY.
3784 The optional argument DISPLAY specifies which display to ask about.
3785 DISPLAY should be either a frame or a display name (a string).
3786 If omitted or nil, that stands for the selected frame's display. */)
3788 Lisp_Object display
;
3790 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3792 return make_number (HeightMMOfScreen (dpyinfo
->screen
));
3795 DEFUN ("x-display-mm-width", Fx_display_mm_width
, Sx_display_mm_width
, 0, 1, 0,
3796 doc
: /* Return the width in millimeters of the X display DISPLAY.
3797 The optional argument DISPLAY specifies which display to ask about.
3798 DISPLAY should be either a frame or a display name (a string).
3799 If omitted or nil, that stands for the selected frame's display. */)
3801 Lisp_Object display
;
3803 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3805 return make_number (WidthMMOfScreen (dpyinfo
->screen
));
3808 DEFUN ("x-display-backing-store", Fx_display_backing_store
,
3809 Sx_display_backing_store
, 0, 1, 0,
3810 doc
: /* Returns an indication of whether X display DISPLAY does backing store.
3811 The value may be `always', `when-mapped', or `not-useful'.
3812 The optional argument DISPLAY specifies which display to ask about.
3813 DISPLAY should be either a frame or a display name (a string).
3814 If omitted or nil, that stands for the selected frame's display. */)
3816 Lisp_Object display
;
3818 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3821 switch (DoesBackingStore (dpyinfo
->screen
))
3824 result
= intern ("always");
3828 result
= intern ("when-mapped");
3832 result
= intern ("not-useful");
3836 error ("Strange value for BackingStore parameter of screen");
3843 DEFUN ("x-display-visual-class", Fx_display_visual_class
,
3844 Sx_display_visual_class
, 0, 1, 0,
3845 doc
: /* Return the visual class of the X display DISPLAY.
3846 The value is one of the symbols `static-gray', `gray-scale',
3847 `static-color', `pseudo-color', `true-color', or `direct-color'.
3849 The optional argument DISPLAY specifies which display to ask about.
3850 DISPLAY should be either a frame or a display name (a string).
3851 If omitted or nil, that stands for the selected frame's display. */)
3853 Lisp_Object display
;
3855 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3858 switch (dpyinfo
->visual
->class)
3861 result
= intern ("static-gray");
3864 result
= intern ("gray-scale");
3867 result
= intern ("static-color");
3870 result
= intern ("pseudo-color");
3873 result
= intern ("true-color");
3876 result
= intern ("direct-color");
3879 error ("Display has an unknown visual class");
3886 DEFUN ("x-display-save-under", Fx_display_save_under
,
3887 Sx_display_save_under
, 0, 1, 0,
3888 doc
: /* Returns t if the X display DISPLAY supports the save-under feature.
3889 The optional argument DISPLAY specifies which display to ask about.
3890 DISPLAY should be either a frame or a display name (a string).
3891 If omitted or nil, that stands for the selected frame's display. */)
3893 Lisp_Object display
;
3895 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3897 if (DoesSaveUnders (dpyinfo
->screen
) == True
)
3905 register struct frame
*f
;
3907 return FRAME_PIXEL_WIDTH (f
);
3912 register struct frame
*f
;
3914 return FRAME_PIXEL_HEIGHT (f
);
3919 register struct frame
*f
;
3921 return FRAME_COLUMN_WIDTH (f
);
3926 register struct frame
*f
;
3928 return FRAME_LINE_HEIGHT (f
);
3933 register struct frame
*f
;
3935 return FRAME_X_DISPLAY_INFO (f
)->n_planes
;
3940 /************************************************************************
3942 ************************************************************************/
3945 /* Mapping visual names to visuals. */
3947 static struct visual_class
3954 {"StaticGray", StaticGray
},
3955 {"GrayScale", GrayScale
},
3956 {"StaticColor", StaticColor
},
3957 {"PseudoColor", PseudoColor
},
3958 {"TrueColor", TrueColor
},
3959 {"DirectColor", DirectColor
},
3964 #ifndef HAVE_XSCREENNUMBEROFSCREEN
3966 /* Value is the screen number of screen SCR. This is a substitute for
3967 the X function with the same name when that doesn't exist. */
3970 XScreenNumberOfScreen (scr
)
3971 register Screen
*scr
;
3973 Display
*dpy
= scr
->display
;
3976 for (i
= 0; i
< dpy
->nscreens
; ++i
)
3977 if (scr
== dpy
->screens
+ i
)
3983 #endif /* not HAVE_XSCREENNUMBEROFSCREEN */
3986 /* Select the visual that should be used on display DPYINFO. Set
3987 members of DPYINFO appropriately. Called from x_term_init. */
3990 select_visual (dpyinfo
)
3991 struct x_display_info
*dpyinfo
;
3993 Display
*dpy
= dpyinfo
->display
;
3994 Screen
*screen
= dpyinfo
->screen
;
3997 /* See if a visual is specified. */
3998 value
= display_x_get_resource (dpyinfo
,
3999 build_string ("visualClass"),
4000 build_string ("VisualClass"),
4002 if (STRINGP (value
))
4004 /* VALUE should be of the form CLASS-DEPTH, where CLASS is one
4005 of `PseudoColor', `TrueColor' etc. and DEPTH is the color
4006 depth, a decimal number. NAME is compared with case ignored. */
4007 char *s
= (char *) alloca (SBYTES (value
) + 1);
4012 strcpy (s
, SDATA (value
));
4013 dash
= index (s
, '-');
4016 dpyinfo
->n_planes
= atoi (dash
+ 1);
4020 /* We won't find a matching visual with depth 0, so that
4021 an error will be printed below. */
4022 dpyinfo
->n_planes
= 0;
4024 /* Determine the visual class. */
4025 for (i
= 0; visual_classes
[i
].name
; ++i
)
4026 if (xstricmp (s
, visual_classes
[i
].name
) == 0)
4028 class = visual_classes
[i
].class;
4032 /* Look up a matching visual for the specified class. */
4034 || !XMatchVisualInfo (dpy
, XScreenNumberOfScreen (screen
),
4035 dpyinfo
->n_planes
, class, &vinfo
))
4036 fatal ("Invalid visual specification `%s'", SDATA (value
));
4038 dpyinfo
->visual
= vinfo
.visual
;
4043 XVisualInfo
*vinfo
, vinfo_template
;
4045 dpyinfo
->visual
= DefaultVisualOfScreen (screen
);
4048 vinfo_template
.visualid
= XVisualIDFromVisual (dpyinfo
->visual
);
4050 vinfo_template
.visualid
= dpyinfo
->visual
->visualid
;
4052 vinfo_template
.screen
= XScreenNumberOfScreen (screen
);
4053 vinfo
= XGetVisualInfo (dpy
, VisualIDMask
| VisualScreenMask
,
4054 &vinfo_template
, &n_visuals
);
4056 fatal ("Can't get proper X visual info");
4058 dpyinfo
->n_planes
= vinfo
->depth
;
4059 XFree ((char *) vinfo
);
4064 /* Return the X display structure for the display named NAME.
4065 Open a new connection if necessary. */
4067 struct x_display_info
*
4068 x_display_info_for_name (name
)
4072 struct x_display_info
*dpyinfo
;
4074 CHECK_STRING (name
);
4076 if (! EQ (Vwindow_system
, intern ("x")))
4077 error ("Not using X Windows");
4079 for (dpyinfo
= x_display_list
, names
= x_display_name_list
;
4081 dpyinfo
= dpyinfo
->next
, names
= XCDR (names
))
4084 tem
= Fstring_equal (XCAR (XCAR (names
)), name
);
4089 /* Use this general default value to start with. */
4090 Vx_resource_name
= Vinvocation_name
;
4092 validate_x_resource_name ();
4094 dpyinfo
= x_term_init (name
, (char *)0,
4095 (char *) SDATA (Vx_resource_name
));
4098 error ("Cannot connect to X server %s", SDATA (name
));
4101 XSETFASTINT (Vwindow_system_version
, 11);
4107 DEFUN ("x-open-connection", Fx_open_connection
, Sx_open_connection
,
4109 doc
: /* Open a connection to an X server.
4110 DISPLAY is the name of the display to connect to.
4111 Optional second arg XRM-STRING is a string of resources in xrdb format.
4112 If the optional third arg MUST-SUCCEED is non-nil,
4113 terminate Emacs if we can't open the connection. */)
4114 (display
, xrm_string
, must_succeed
)
4115 Lisp_Object display
, xrm_string
, must_succeed
;
4117 unsigned char *xrm_option
;
4118 struct x_display_info
*dpyinfo
;
4120 CHECK_STRING (display
);
4121 if (! NILP (xrm_string
))
4122 CHECK_STRING (xrm_string
);
4124 if (! EQ (Vwindow_system
, intern ("x")))
4125 error ("Not using X Windows");
4127 if (! NILP (xrm_string
))
4128 xrm_option
= (unsigned char *) SDATA (xrm_string
);
4130 xrm_option
= (unsigned char *) 0;
4132 validate_x_resource_name ();
4134 /* This is what opens the connection and sets x_current_display.
4135 This also initializes many symbols, such as those used for input. */
4136 dpyinfo
= x_term_init (display
, xrm_option
,
4137 (char *) SDATA (Vx_resource_name
));
4141 if (!NILP (must_succeed
))
4142 fatal ("Cannot connect to X server %s.\n\
4143 Check the DISPLAY environment variable or use `-d'.\n\
4144 Also use the `xauth' program to verify that you have the proper\n\
4145 authorization information needed to connect the X server.\n\
4146 An insecure way to solve the problem may be to use `xhost'.\n",
4149 error ("Cannot connect to X server %s", SDATA (display
));
4154 XSETFASTINT (Vwindow_system_version
, 11);
4158 DEFUN ("x-close-connection", Fx_close_connection
,
4159 Sx_close_connection
, 1, 1, 0,
4160 doc
: /* Close the connection to DISPLAY's X server.
4161 For DISPLAY, specify either a frame or a display name (a string).
4162 If DISPLAY is nil, that stands for the selected frame's display. */)
4164 Lisp_Object display
;
4166 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
4169 if (dpyinfo
->reference_count
> 0)
4170 error ("Display still has frames on it");
4173 /* Free the fonts in the font table. */
4174 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
4175 if (dpyinfo
->font_table
[i
].name
)
4177 if (dpyinfo
->font_table
[i
].name
!= dpyinfo
->font_table
[i
].full_name
)
4178 xfree (dpyinfo
->font_table
[i
].full_name
);
4179 xfree (dpyinfo
->font_table
[i
].name
);
4180 XFreeFont (dpyinfo
->display
, dpyinfo
->font_table
[i
].font
);
4183 x_destroy_all_bitmaps (dpyinfo
);
4184 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
4186 #ifdef USE_X_TOOLKIT
4187 XtCloseDisplay (dpyinfo
->display
);
4189 XCloseDisplay (dpyinfo
->display
);
4192 x_delete_display (dpyinfo
);
4198 DEFUN ("x-display-list", Fx_display_list
, Sx_display_list
, 0, 0, 0,
4199 doc
: /* Return the list of display names that Emacs has connections to. */)
4202 Lisp_Object tail
, result
;
4205 for (tail
= x_display_name_list
; ! NILP (tail
); tail
= XCDR (tail
))
4206 result
= Fcons (XCAR (XCAR (tail
)), result
);
4211 DEFUN ("x-synchronize", Fx_synchronize
, Sx_synchronize
, 1, 2, 0,
4212 doc
: /* If ON is non-nil, report X errors as soon as the erring request is made.
4213 If ON is nil, allow buffering of requests.
4214 Turning on synchronization prohibits the Xlib routines from buffering
4215 requests and seriously degrades performance, but makes debugging much
4217 The optional second argument DISPLAY specifies which display to act on.
4218 DISPLAY should be either a frame or a display name (a string).
4219 If DISPLAY is omitted or nil, that stands for the selected frame's display. */)
4221 Lisp_Object display
, on
;
4223 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
4225 XSynchronize (dpyinfo
->display
, !EQ (on
, Qnil
));
4230 /* Wait for responses to all X commands issued so far for frame F. */
4237 XSync (FRAME_X_DISPLAY (f
), False
);
4242 /***********************************************************************
4244 ***********************************************************************/
4246 /* Value is the number of elements of vector VECTOR. */
4248 #define DIM(VECTOR) (sizeof (VECTOR) / sizeof *(VECTOR))
4250 /* List of supported image types. Use define_image_type to add new
4251 types. Use lookup_image_type to find a type for a given symbol. */
4253 static struct image_type
*image_types
;
4255 /* The symbol `image' which is the car of the lists used to represent
4258 extern Lisp_Object Qimage
;
4260 /* The symbol `xbm' which is used as the type symbol for XBM images. */
4266 extern Lisp_Object QCwidth
, QCheight
, QCforeground
, QCbackground
, QCfile
;
4267 extern Lisp_Object QCdata
, QCtype
;
4268 Lisp_Object QCascent
, QCmargin
, QCrelief
;
4269 Lisp_Object QCconversion
, QCcolor_symbols
, QCheuristic_mask
;
4270 Lisp_Object QCindex
, QCmatrix
, QCcolor_adjustment
, QCmask
;
4272 /* Other symbols. */
4274 Lisp_Object Qlaplace
, Qemboss
, Qedge_detection
, Qheuristic
;
4276 /* Time in seconds after which images should be removed from the cache
4277 if not displayed. */
4279 Lisp_Object Vimage_cache_eviction_delay
;
4281 /* Function prototypes. */
4283 static void define_image_type
P_ ((struct image_type
*type
));
4284 static struct image_type
*lookup_image_type
P_ ((Lisp_Object symbol
));
4285 static void image_error
P_ ((char *format
, Lisp_Object
, Lisp_Object
));
4286 static void x_laplace
P_ ((struct frame
*, struct image
*));
4287 static void x_emboss
P_ ((struct frame
*, struct image
*));
4288 static int x_build_heuristic_mask
P_ ((struct frame
*, struct image
*,
4292 /* Define a new image type from TYPE. This adds a copy of TYPE to
4293 image_types and adds the symbol *TYPE->type to Vimage_types. */
4296 define_image_type (type
)
4297 struct image_type
*type
;
4299 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
4300 The initialized data segment is read-only. */
4301 struct image_type
*p
= (struct image_type
*) xmalloc (sizeof *p
);
4302 bcopy (type
, p
, sizeof *p
);
4303 p
->next
= image_types
;
4305 Vimage_types
= Fcons (*p
->type
, Vimage_types
);
4309 /* Look up image type SYMBOL, and return a pointer to its image_type
4310 structure. Value is null if SYMBOL is not a known image type. */
4312 static INLINE
struct image_type
*
4313 lookup_image_type (symbol
)
4316 struct image_type
*type
;
4318 for (type
= image_types
; type
; type
= type
->next
)
4319 if (EQ (symbol
, *type
->type
))
4326 /* Value is non-zero if OBJECT is a valid Lisp image specification. A
4327 valid image specification is a list whose car is the symbol
4328 `image', and whose rest is a property list. The property list must
4329 contain a value for key `:type'. That value must be the name of a
4330 supported image type. The rest of the property list depends on the
4334 valid_image_p (object
)
4339 if (CONSP (object
) && EQ (XCAR (object
), Qimage
))
4343 for (tem
= XCDR (object
); CONSP (tem
); tem
= XCDR (tem
))
4344 if (EQ (XCAR (tem
), QCtype
))
4347 if (CONSP (tem
) && SYMBOLP (XCAR (tem
)))
4349 struct image_type
*type
;
4350 type
= lookup_image_type (XCAR (tem
));
4352 valid_p
= type
->valid_p (object
);
4363 /* Log error message with format string FORMAT and argument ARG.
4364 Signaling an error, e.g. when an image cannot be loaded, is not a
4365 good idea because this would interrupt redisplay, and the error
4366 message display would lead to another redisplay. This function
4367 therefore simply displays a message. */
4370 image_error (format
, arg1
, arg2
)
4372 Lisp_Object arg1
, arg2
;
4374 add_to_log (format
, arg1
, arg2
);
4379 /***********************************************************************
4380 Image specifications
4381 ***********************************************************************/
4383 enum image_value_type
4385 IMAGE_DONT_CHECK_VALUE_TYPE
,
4387 IMAGE_STRING_OR_NIL_VALUE
,
4389 IMAGE_POSITIVE_INTEGER_VALUE
,
4390 IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
,
4391 IMAGE_NON_NEGATIVE_INTEGER_VALUE
,
4393 IMAGE_INTEGER_VALUE
,
4394 IMAGE_FUNCTION_VALUE
,
4399 /* Structure used when parsing image specifications. */
4401 struct image_keyword
4403 /* Name of keyword. */
4406 /* The type of value allowed. */
4407 enum image_value_type type
;
4409 /* Non-zero means key must be present. */
4412 /* Used to recognize duplicate keywords in a property list. */
4415 /* The value that was found. */
4420 static int parse_image_spec
P_ ((Lisp_Object
, struct image_keyword
*,
4422 static Lisp_Object image_spec_value
P_ ((Lisp_Object
, Lisp_Object
, int *));
4425 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
4426 has the format (image KEYWORD VALUE ...). One of the keyword/
4427 value pairs must be `:type TYPE'. KEYWORDS is a vector of
4428 image_keywords structures of size NKEYWORDS describing other
4429 allowed keyword/value pairs. Value is non-zero if SPEC is valid. */
4432 parse_image_spec (spec
, keywords
, nkeywords
, type
)
4434 struct image_keyword
*keywords
;
4441 if (!CONSP (spec
) || !EQ (XCAR (spec
), Qimage
))
4444 plist
= XCDR (spec
);
4445 while (CONSP (plist
))
4447 Lisp_Object key
, value
;
4449 /* First element of a pair must be a symbol. */
4451 plist
= XCDR (plist
);
4455 /* There must follow a value. */
4458 value
= XCAR (plist
);
4459 plist
= XCDR (plist
);
4461 /* Find key in KEYWORDS. Error if not found. */
4462 for (i
= 0; i
< nkeywords
; ++i
)
4463 if (strcmp (keywords
[i
].name
, SDATA (SYMBOL_NAME (key
))) == 0)
4469 /* Record that we recognized the keyword. If a keywords
4470 was found more than once, it's an error. */
4471 keywords
[i
].value
= value
;
4472 ++keywords
[i
].count
;
4474 if (keywords
[i
].count
> 1)
4477 /* Check type of value against allowed type. */
4478 switch (keywords
[i
].type
)
4480 case IMAGE_STRING_VALUE
:
4481 if (!STRINGP (value
))
4485 case IMAGE_STRING_OR_NIL_VALUE
:
4486 if (!STRINGP (value
) && !NILP (value
))
4490 case IMAGE_SYMBOL_VALUE
:
4491 if (!SYMBOLP (value
))
4495 case IMAGE_POSITIVE_INTEGER_VALUE
:
4496 if (!INTEGERP (value
) || XINT (value
) <= 0)
4500 case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
:
4501 if (INTEGERP (value
) && XINT (value
) >= 0)
4504 && INTEGERP (XCAR (value
)) && INTEGERP (XCDR (value
))
4505 && XINT (XCAR (value
)) >= 0 && XINT (XCDR (value
)) >= 0)
4509 case IMAGE_ASCENT_VALUE
:
4510 if (SYMBOLP (value
) && EQ (value
, Qcenter
))
4512 else if (INTEGERP (value
)
4513 && XINT (value
) >= 0
4514 && XINT (value
) <= 100)
4518 case IMAGE_NON_NEGATIVE_INTEGER_VALUE
:
4519 if (!INTEGERP (value
) || XINT (value
) < 0)
4523 case IMAGE_DONT_CHECK_VALUE_TYPE
:
4526 case IMAGE_FUNCTION_VALUE
:
4527 value
= indirect_function (value
);
4529 || COMPILEDP (value
)
4530 || (CONSP (value
) && EQ (XCAR (value
), Qlambda
)))
4534 case IMAGE_NUMBER_VALUE
:
4535 if (!INTEGERP (value
) && !FLOATP (value
))
4539 case IMAGE_INTEGER_VALUE
:
4540 if (!INTEGERP (value
))
4544 case IMAGE_BOOL_VALUE
:
4545 if (!NILP (value
) && !EQ (value
, Qt
))
4554 if (EQ (key
, QCtype
) && !EQ (type
, value
))
4558 /* Check that all mandatory fields are present. */
4559 for (i
= 0; i
< nkeywords
; ++i
)
4560 if (keywords
[i
].mandatory_p
&& keywords
[i
].count
== 0)
4563 return NILP (plist
);
4567 /* Return the value of KEY in image specification SPEC. Value is nil
4568 if KEY is not present in SPEC. if FOUND is not null, set *FOUND
4569 to 1 if KEY was found in SPEC, set it to 0 otherwise. */
4572 image_spec_value (spec
, key
, found
)
4573 Lisp_Object spec
, key
;
4578 xassert (valid_image_p (spec
));
4580 for (tail
= XCDR (spec
);
4581 CONSP (tail
) && CONSP (XCDR (tail
));
4582 tail
= XCDR (XCDR (tail
)))
4584 if (EQ (XCAR (tail
), key
))
4588 return XCAR (XCDR (tail
));
4598 DEFUN ("image-size", Fimage_size
, Simage_size
, 1, 3, 0,
4599 doc
: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
4600 PIXELS non-nil means return the size in pixels, otherwise return the
4601 size in canonical character units.
4602 FRAME is the frame on which the image will be displayed. FRAME nil
4603 or omitted means use the selected frame. */)
4604 (spec
, pixels
, frame
)
4605 Lisp_Object spec
, pixels
, frame
;
4610 if (valid_image_p (spec
))
4612 struct frame
*f
= check_x_frame (frame
);
4613 int id
= lookup_image (f
, spec
);
4614 struct image
*img
= IMAGE_FROM_ID (f
, id
);
4615 int width
= img
->width
+ 2 * img
->hmargin
;
4616 int height
= img
->height
+ 2 * img
->vmargin
;
4619 size
= Fcons (make_float ((double) width
/ FRAME_COLUMN_WIDTH (f
)),
4620 make_float ((double) height
/ FRAME_LINE_HEIGHT (f
)));
4622 size
= Fcons (make_number (width
), make_number (height
));
4625 error ("Invalid image specification");
4631 DEFUN ("image-mask-p", Fimage_mask_p
, Simage_mask_p
, 1, 2, 0,
4632 doc
: /* Return t if image SPEC has a mask bitmap.
4633 FRAME is the frame on which the image will be displayed. FRAME nil
4634 or omitted means use the selected frame. */)
4636 Lisp_Object spec
, frame
;
4641 if (valid_image_p (spec
))
4643 struct frame
*f
= check_x_frame (frame
);
4644 int id
= lookup_image (f
, spec
);
4645 struct image
*img
= IMAGE_FROM_ID (f
, id
);
4650 error ("Invalid image specification");
4657 /***********************************************************************
4658 Image type independent image structures
4659 ***********************************************************************/
4661 static struct image
*make_image
P_ ((Lisp_Object spec
, unsigned hash
));
4662 static void free_image
P_ ((struct frame
*f
, struct image
*img
));
4665 /* Allocate and return a new image structure for image specification
4666 SPEC. SPEC has a hash value of HASH. */
4668 static struct image
*
4669 make_image (spec
, hash
)
4673 struct image
*img
= (struct image
*) xmalloc (sizeof *img
);
4675 xassert (valid_image_p (spec
));
4676 bzero (img
, sizeof *img
);
4677 img
->type
= lookup_image_type (image_spec_value (spec
, QCtype
, NULL
));
4678 xassert (img
->type
!= NULL
);
4680 img
->data
.lisp_val
= Qnil
;
4681 img
->ascent
= DEFAULT_IMAGE_ASCENT
;
4687 /* Free image IMG which was used on frame F, including its resources. */
4696 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
4698 /* Remove IMG from the hash table of its cache. */
4700 img
->prev
->next
= img
->next
;
4702 c
->buckets
[img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
] = img
->next
;
4705 img
->next
->prev
= img
->prev
;
4707 c
->images
[img
->id
] = NULL
;
4709 /* Free resources, then free IMG. */
4710 img
->type
->free (f
, img
);
4716 /* Prepare image IMG for display on frame F. Must be called before
4717 drawing an image. */
4720 prepare_image_for_display (f
, img
)
4726 /* We're about to display IMG, so set its timestamp to `now'. */
4728 img
->timestamp
= EMACS_SECS (t
);
4730 /* If IMG doesn't have a pixmap yet, load it now, using the image
4731 type dependent loader function. */
4732 if (img
->pixmap
== None
&& !img
->load_failed_p
)
4733 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
4737 /* Value is the number of pixels for the ascent of image IMG when
4738 drawn in face FACE. */
4741 image_ascent (img
, face
)
4745 int height
= img
->height
+ img
->vmargin
;
4748 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
4751 /* This expression is arranged so that if the image can't be
4752 exactly centered, it will be moved slightly up. This is
4753 because a typical font is `top-heavy' (due to the presence
4754 uppercase letters), so the image placement should err towards
4755 being top-heavy too. It also just generally looks better. */
4756 ascent
= (height
+ face
->font
->ascent
- face
->font
->descent
+ 1) / 2;
4758 ascent
= height
/ 2;
4761 ascent
= height
* img
->ascent
/ 100.0;
4767 /* Image background colors. */
4769 static unsigned long
4770 four_corners_best (ximg
, width
, height
)
4772 unsigned long width
, height
;
4774 unsigned long corners
[4], best
;
4777 /* Get the colors at the corners of ximg. */
4778 corners
[0] = XGetPixel (ximg
, 0, 0);
4779 corners
[1] = XGetPixel (ximg
, width
- 1, 0);
4780 corners
[2] = XGetPixel (ximg
, width
- 1, height
- 1);
4781 corners
[3] = XGetPixel (ximg
, 0, height
- 1);
4783 /* Choose the most frequently found color as background. */
4784 for (i
= best_count
= 0; i
< 4; ++i
)
4788 for (j
= n
= 0; j
< 4; ++j
)
4789 if (corners
[i
] == corners
[j
])
4793 best
= corners
[i
], best_count
= n
;
4799 /* Return the `background' field of IMG. If IMG doesn't have one yet,
4800 it is guessed heuristically. If non-zero, XIMG is an existing XImage
4801 object to use for the heuristic. */
4804 image_background (img
, f
, ximg
)
4809 if (! img
->background_valid
)
4810 /* IMG doesn't have a background yet, try to guess a reasonable value. */
4812 int free_ximg
= !ximg
;
4815 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4816 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4818 img
->background
= four_corners_best (ximg
, img
->width
, img
->height
);
4821 XDestroyImage (ximg
);
4823 img
->background_valid
= 1;
4826 return img
->background
;
4829 /* Return the `background_transparent' field of IMG. If IMG doesn't
4830 have one yet, it is guessed heuristically. If non-zero, MASK is an
4831 existing XImage object to use for the heuristic. */
4834 image_background_transparent (img
, f
, mask
)
4839 if (! img
->background_transparent_valid
)
4840 /* IMG doesn't have a background yet, try to guess a reasonable value. */
4844 int free_mask
= !mask
;
4847 mask
= XGetImage (FRAME_X_DISPLAY (f
), img
->mask
,
4848 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4850 img
->background_transparent
4851 = !four_corners_best (mask
, img
->width
, img
->height
);
4854 XDestroyImage (mask
);
4857 img
->background_transparent
= 0;
4859 img
->background_transparent_valid
= 1;
4862 return img
->background_transparent
;
4866 /***********************************************************************
4867 Helper functions for X image types
4868 ***********************************************************************/
4870 static void x_clear_image_1
P_ ((struct frame
*, struct image
*, int,
4872 static void x_clear_image
P_ ((struct frame
*f
, struct image
*img
));
4873 static unsigned long x_alloc_image_color
P_ ((struct frame
*f
,
4875 Lisp_Object color_name
,
4876 unsigned long dflt
));
4879 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
4880 free the pixmap if any. MASK_P non-zero means clear the mask
4881 pixmap if any. COLORS_P non-zero means free colors allocated for
4882 the image, if any. */
4885 x_clear_image_1 (f
, img
, pixmap_p
, mask_p
, colors_p
)
4888 int pixmap_p
, mask_p
, colors_p
;
4890 if (pixmap_p
&& img
->pixmap
)
4892 XFreePixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
4894 img
->background_valid
= 0;
4897 if (mask_p
&& img
->mask
)
4899 XFreePixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4901 img
->background_transparent_valid
= 0;
4904 if (colors_p
&& img
->ncolors
)
4906 x_free_colors (f
, img
->colors
, img
->ncolors
);
4907 xfree (img
->colors
);
4913 /* Free X resources of image IMG which is used on frame F. */
4916 x_clear_image (f
, img
)
4921 x_clear_image_1 (f
, img
, 1, 1, 1);
4926 /* Allocate color COLOR_NAME for image IMG on frame F. If color
4927 cannot be allocated, use DFLT. Add a newly allocated color to
4928 IMG->colors, so that it can be freed again. Value is the pixel
4931 static unsigned long
4932 x_alloc_image_color (f
, img
, color_name
, dflt
)
4935 Lisp_Object color_name
;
4939 unsigned long result
;
4941 xassert (STRINGP (color_name
));
4943 if (x_defined_color (f
, SDATA (color_name
), &color
, 1))
4945 /* This isn't called frequently so we get away with simply
4946 reallocating the color vector to the needed size, here. */
4949 (unsigned long *) xrealloc (img
->colors
,
4950 img
->ncolors
* sizeof *img
->colors
);
4951 img
->colors
[img
->ncolors
- 1] = color
.pixel
;
4952 result
= color
.pixel
;
4962 /***********************************************************************
4964 ***********************************************************************/
4966 static void cache_image
P_ ((struct frame
*f
, struct image
*img
));
4967 static void postprocess_image
P_ ((struct frame
*, struct image
*));
4970 /* Return a new, initialized image cache that is allocated from the
4971 heap. Call free_image_cache to free an image cache. */
4973 struct image_cache
*
4976 struct image_cache
*c
= (struct image_cache
*) xmalloc (sizeof *c
);
4979 bzero (c
, sizeof *c
);
4981 c
->images
= (struct image
**) xmalloc (c
->size
* sizeof *c
->images
);
4982 size
= IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
;
4983 c
->buckets
= (struct image
**) xmalloc (size
);
4984 bzero (c
->buckets
, size
);
4989 /* Free image cache of frame F. Be aware that X frames share images
4993 free_image_cache (f
)
4996 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5001 /* Cache should not be referenced by any frame when freed. */
5002 xassert (c
->refcount
== 0);
5004 for (i
= 0; i
< c
->used
; ++i
)
5005 free_image (f
, c
->images
[i
]);
5009 FRAME_X_IMAGE_CACHE (f
) = NULL
;
5014 /* Clear image cache of frame F. FORCE_P non-zero means free all
5015 images. FORCE_P zero means clear only images that haven't been
5016 displayed for some time. Should be called from time to time to
5017 reduce the number of loaded images. If image-eviction-seconds is
5018 non-nil, this frees images in the cache which weren't displayed for
5019 at least that many seconds. */
5022 clear_image_cache (f
, force_p
)
5026 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5028 if (c
&& INTEGERP (Vimage_cache_eviction_delay
))
5035 old
= EMACS_SECS (t
) - XFASTINT (Vimage_cache_eviction_delay
);
5037 /* Block input so that we won't be interrupted by a SIGIO
5038 while being in an inconsistent state. */
5041 for (i
= nfreed
= 0; i
< c
->used
; ++i
)
5043 struct image
*img
= c
->images
[i
];
5045 && (force_p
|| img
->timestamp
< old
))
5047 free_image (f
, img
);
5052 /* We may be clearing the image cache because, for example,
5053 Emacs was iconified for a longer period of time. In that
5054 case, current matrices may still contain references to
5055 images freed above. So, clear these matrices. */
5058 Lisp_Object tail
, frame
;
5060 FOR_EACH_FRAME (tail
, frame
)
5062 struct frame
*f
= XFRAME (frame
);
5064 && FRAME_X_IMAGE_CACHE (f
) == c
)
5065 clear_current_matrices (f
);
5068 ++windows_or_buffers_changed
;
5076 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
5078 doc
: /* Clear the image cache of FRAME.
5079 FRAME nil or omitted means use the selected frame.
5080 FRAME t means clear the image caches of all frames. */)
5088 FOR_EACH_FRAME (tail
, frame
)
5089 if (FRAME_X_P (XFRAME (frame
)))
5090 clear_image_cache (XFRAME (frame
), 1);
5093 clear_image_cache (check_x_frame (frame
), 1);
5099 /* Compute masks and transform image IMG on frame F, as specified
5100 by the image's specification, */
5103 postprocess_image (f
, img
)
5107 /* Manipulation of the image's mask. */
5110 Lisp_Object conversion
, spec
;
5115 /* `:heuristic-mask t'
5117 means build a mask heuristically.
5118 `:heuristic-mask (R G B)'
5119 `:mask (heuristic (R G B))'
5120 means build a mask from color (R G B) in the
5123 means remove a mask, if any. */
5125 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
5127 x_build_heuristic_mask (f
, img
, mask
);
5132 mask
= image_spec_value (spec
, QCmask
, &found_p
);
5134 if (EQ (mask
, Qheuristic
))
5135 x_build_heuristic_mask (f
, img
, Qt
);
5136 else if (CONSP (mask
)
5137 && EQ (XCAR (mask
), Qheuristic
))
5139 if (CONSP (XCDR (mask
)))
5140 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
5142 x_build_heuristic_mask (f
, img
, XCDR (mask
));
5144 else if (NILP (mask
) && found_p
&& img
->mask
)
5146 XFreePixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5152 /* Should we apply an image transformation algorithm? */
5153 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
5154 if (EQ (conversion
, Qdisabled
))
5155 x_disable_image (f
, img
);
5156 else if (EQ (conversion
, Qlaplace
))
5158 else if (EQ (conversion
, Qemboss
))
5160 else if (CONSP (conversion
)
5161 && EQ (XCAR (conversion
), Qedge_detection
))
5164 tem
= XCDR (conversion
);
5166 x_edge_detection (f
, img
,
5167 Fplist_get (tem
, QCmatrix
),
5168 Fplist_get (tem
, QCcolor_adjustment
));
5174 /* Return the id of image with Lisp specification SPEC on frame F.
5175 SPEC must be a valid Lisp image specification (see valid_image_p). */
5178 lookup_image (f
, spec
)
5182 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5186 struct gcpro gcpro1
;
5189 /* F must be a window-system frame, and SPEC must be a valid image
5191 xassert (FRAME_WINDOW_P (f
));
5192 xassert (valid_image_p (spec
));
5196 /* Look up SPEC in the hash table of the image cache. */
5197 hash
= sxhash (spec
, 0);
5198 i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
5200 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
5201 if (img
->hash
== hash
&& !NILP (Fequal (img
->spec
, spec
)))
5204 /* If not found, create a new image and cache it. */
5207 extern Lisp_Object Qpostscript
;
5210 img
= make_image (spec
, hash
);
5211 cache_image (f
, img
);
5212 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
5214 /* If we can't load the image, and we don't have a width and
5215 height, use some arbitrary width and height so that we can
5216 draw a rectangle for it. */
5217 if (img
->load_failed_p
)
5221 value
= image_spec_value (spec
, QCwidth
, NULL
);
5222 img
->width
= (INTEGERP (value
)
5223 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
5224 value
= image_spec_value (spec
, QCheight
, NULL
);
5225 img
->height
= (INTEGERP (value
)
5226 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
5230 /* Handle image type independent image attributes
5231 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
5232 `:background COLOR'. */
5233 Lisp_Object ascent
, margin
, relief
, bg
;
5235 ascent
= image_spec_value (spec
, QCascent
, NULL
);
5236 if (INTEGERP (ascent
))
5237 img
->ascent
= XFASTINT (ascent
);
5238 else if (EQ (ascent
, Qcenter
))
5239 img
->ascent
= CENTERED_IMAGE_ASCENT
;
5241 margin
= image_spec_value (spec
, QCmargin
, NULL
);
5242 if (INTEGERP (margin
) && XINT (margin
) >= 0)
5243 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
5244 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
5245 && INTEGERP (XCDR (margin
)))
5247 if (XINT (XCAR (margin
)) > 0)
5248 img
->hmargin
= XFASTINT (XCAR (margin
));
5249 if (XINT (XCDR (margin
)) > 0)
5250 img
->vmargin
= XFASTINT (XCDR (margin
));
5253 relief
= image_spec_value (spec
, QCrelief
, NULL
);
5254 if (INTEGERP (relief
))
5256 img
->relief
= XINT (relief
);
5257 img
->hmargin
+= abs (img
->relief
);
5258 img
->vmargin
+= abs (img
->relief
);
5261 if (! img
->background_valid
)
5263 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
5267 = x_alloc_image_color (f
, img
, bg
,
5268 FRAME_BACKGROUND_PIXEL (f
));
5269 img
->background_valid
= 1;
5273 /* Do image transformations and compute masks, unless we
5274 don't have the image yet. */
5275 if (!EQ (*img
->type
->type
, Qpostscript
))
5276 postprocess_image (f
, img
);
5280 xassert (!interrupt_input_blocked
);
5283 /* We're using IMG, so set its timestamp to `now'. */
5284 EMACS_GET_TIME (now
);
5285 img
->timestamp
= EMACS_SECS (now
);
5289 /* Value is the image id. */
5294 /* Cache image IMG in the image cache of frame F. */
5297 cache_image (f
, img
)
5301 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5304 /* Find a free slot in c->images. */
5305 for (i
= 0; i
< c
->used
; ++i
)
5306 if (c
->images
[i
] == NULL
)
5309 /* If no free slot found, maybe enlarge c->images. */
5310 if (i
== c
->used
&& c
->used
== c
->size
)
5313 c
->images
= (struct image
**) xrealloc (c
->images
,
5314 c
->size
* sizeof *c
->images
);
5317 /* Add IMG to c->images, and assign IMG an id. */
5323 /* Add IMG to the cache's hash table. */
5324 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
5325 img
->next
= c
->buckets
[i
];
5327 img
->next
->prev
= img
;
5329 c
->buckets
[i
] = img
;
5333 /* Call FN on every image in the image cache of frame F. Used to mark
5334 Lisp Objects in the image cache. */
5337 forall_images_in_image_cache (f
, fn
)
5339 void (*fn
) P_ ((struct image
*img
));
5341 if (FRAME_LIVE_P (f
) && FRAME_X_P (f
))
5343 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5347 for (i
= 0; i
< c
->used
; ++i
)
5356 /***********************************************************************
5358 ***********************************************************************/
5360 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
5361 XImage
**, Pixmap
*));
5362 static void x_destroy_x_image
P_ ((XImage
*));
5363 static void x_put_x_image
P_ ((struct frame
*, XImage
*, Pixmap
, int, int));
5366 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
5367 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
5368 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
5369 via xmalloc. Print error messages via image_error if an error
5370 occurs. Value is non-zero if successful. */
5373 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
5375 int width
, height
, depth
;
5379 Display
*display
= FRAME_X_DISPLAY (f
);
5380 Screen
*screen
= FRAME_X_SCREEN (f
);
5381 Window window
= FRAME_X_WINDOW (f
);
5383 xassert (interrupt_input_blocked
);
5386 depth
= DefaultDepthOfScreen (screen
);
5387 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
5388 depth
, ZPixmap
, 0, NULL
, width
, height
,
5389 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
5392 image_error ("Unable to allocate X image", Qnil
, Qnil
);
5396 /* Allocate image raster. */
5397 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
5399 /* Allocate a pixmap of the same size. */
5400 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
5401 if (*pixmap
== None
)
5403 x_destroy_x_image (*ximg
);
5405 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
5413 /* Destroy XImage XIMG. Free XIMG->data. */
5416 x_destroy_x_image (ximg
)
5419 xassert (interrupt_input_blocked
);
5424 XDestroyImage (ximg
);
5429 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
5430 are width and height of both the image and pixmap. */
5433 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
5441 xassert (interrupt_input_blocked
);
5442 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
5443 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
5444 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
5449 /***********************************************************************
5451 ***********************************************************************/
5453 static Lisp_Object x_find_image_file
P_ ((Lisp_Object
));
5454 static char *slurp_file
P_ ((char *, int *));
5457 /* Find image file FILE. Look in data-directory, then
5458 x-bitmap-file-path. Value is the full name of the file found, or
5459 nil if not found. */
5462 x_find_image_file (file
)
5465 Lisp_Object file_found
, search_path
;
5466 struct gcpro gcpro1
, gcpro2
;
5470 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
5471 GCPRO2 (file_found
, search_path
);
5473 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
5474 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
5486 /* Read FILE into memory. Value is a pointer to a buffer allocated
5487 with xmalloc holding FILE's contents. Value is null if an error
5488 occurred. *SIZE is set to the size of the file. */
5491 slurp_file (file
, size
)
5499 if (stat (file
, &st
) == 0
5500 && (fp
= fopen (file
, "r")) != NULL
5501 && (buf
= (char *) xmalloc (st
.st_size
),
5502 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5523 /***********************************************************************
5525 ***********************************************************************/
5527 static int xbm_scan
P_ ((char **, char *, char *, int *));
5528 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
5529 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
5531 static int xbm_image_p
P_ ((Lisp_Object object
));
5532 static int xbm_read_bitmap_data
P_ ((char *, char *, int *, int *,
5534 static int xbm_file_p
P_ ((Lisp_Object
));
5537 /* Indices of image specification fields in xbm_format, below. */
5539 enum xbm_keyword_index
5557 /* Vector of image_keyword structures describing the format
5558 of valid XBM image specifications. */
5560 static struct image_keyword xbm_format
[XBM_LAST
] =
5562 {":type", IMAGE_SYMBOL_VALUE
, 1},
5563 {":file", IMAGE_STRING_VALUE
, 0},
5564 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
5565 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
5566 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5567 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5568 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
5569 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5570 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5571 {":relief", IMAGE_INTEGER_VALUE
, 0},
5572 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5573 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5574 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
5577 /* Structure describing the image type XBM. */
5579 static struct image_type xbm_type
=
5588 /* Tokens returned from xbm_scan. */
5597 /* Return non-zero if OBJECT is a valid XBM-type image specification.
5598 A valid specification is a list starting with the symbol `image'
5599 The rest of the list is a property list which must contain an
5602 If the specification specifies a file to load, it must contain
5603 an entry `:file FILENAME' where FILENAME is a string.
5605 If the specification is for a bitmap loaded from memory it must
5606 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
5607 WIDTH and HEIGHT are integers > 0. DATA may be:
5609 1. a string large enough to hold the bitmap data, i.e. it must
5610 have a size >= (WIDTH + 7) / 8 * HEIGHT
5612 2. a bool-vector of size >= WIDTH * HEIGHT
5614 3. a vector of strings or bool-vectors, one for each line of the
5617 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
5618 may not be specified in this case because they are defined in the
5621 Both the file and data forms may contain the additional entries
5622 `:background COLOR' and `:foreground COLOR'. If not present,
5623 foreground and background of the frame on which the image is
5624 displayed is used. */
5627 xbm_image_p (object
)
5630 struct image_keyword kw
[XBM_LAST
];
5632 bcopy (xbm_format
, kw
, sizeof kw
);
5633 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
5636 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
5638 if (kw
[XBM_FILE
].count
)
5640 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
5643 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
5645 /* In-memory XBM file. */
5646 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
5654 /* Entries for `:width', `:height' and `:data' must be present. */
5655 if (!kw
[XBM_WIDTH
].count
5656 || !kw
[XBM_HEIGHT
].count
5657 || !kw
[XBM_DATA
].count
)
5660 data
= kw
[XBM_DATA
].value
;
5661 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
5662 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
5664 /* Check type of data, and width and height against contents of
5670 /* Number of elements of the vector must be >= height. */
5671 if (XVECTOR (data
)->size
< height
)
5674 /* Each string or bool-vector in data must be large enough
5675 for one line of the image. */
5676 for (i
= 0; i
< height
; ++i
)
5678 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
5683 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
5686 else if (BOOL_VECTOR_P (elt
))
5688 if (XBOOL_VECTOR (elt
)->size
< width
)
5695 else if (STRINGP (data
))
5698 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
5701 else if (BOOL_VECTOR_P (data
))
5703 if (XBOOL_VECTOR (data
)->size
< width
* height
)
5714 /* Scan a bitmap file. FP is the stream to read from. Value is
5715 either an enumerator from enum xbm_token, or a character for a
5716 single-character token, or 0 at end of file. If scanning an
5717 identifier, store the lexeme of the identifier in SVAL. If
5718 scanning a number, store its value in *IVAL. */
5721 xbm_scan (s
, end
, sval
, ival
)
5730 /* Skip white space. */
5731 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5736 else if (isdigit (c
))
5738 int value
= 0, digit
;
5740 if (c
== '0' && *s
< end
)
5743 if (c
== 'x' || c
== 'X')
5750 else if (c
>= 'a' && c
<= 'f')
5751 digit
= c
- 'a' + 10;
5752 else if (c
>= 'A' && c
<= 'F')
5753 digit
= c
- 'A' + 10;
5756 value
= 16 * value
+ digit
;
5759 else if (isdigit (c
))
5763 && (c
= *(*s
)++, isdigit (c
)))
5764 value
= 8 * value
+ c
- '0';
5771 && (c
= *(*s
)++, isdigit (c
)))
5772 value
= 10 * value
+ c
- '0';
5780 else if (isalpha (c
) || c
== '_')
5784 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
5791 else if (c
== '/' && **s
== '*')
5793 /* C-style comment. */
5795 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
5808 /* Replacement for XReadBitmapFileData which isn't available under old
5809 X versions. CONTENTS is a pointer to a buffer to parse; END is the
5810 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
5811 the image. Return in *DATA the bitmap data allocated with xmalloc.
5812 Value is non-zero if successful. DATA null means just test if
5813 CONTENTS looks like an in-memory XBM file. */
5816 xbm_read_bitmap_data (contents
, end
, width
, height
, data
)
5817 char *contents
, *end
;
5818 int *width
, *height
;
5819 unsigned char **data
;
5822 char buffer
[BUFSIZ
];
5825 int bytes_per_line
, i
, nbytes
;
5831 LA1 = xbm_scan (&s, end, buffer, &value)
5833 #define expect(TOKEN) \
5834 if (LA1 != (TOKEN)) \
5839 #define expect_ident(IDENT) \
5840 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
5845 *width
= *height
= -1;
5848 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
5850 /* Parse defines for width, height and hot-spots. */
5854 expect_ident ("define");
5855 expect (XBM_TK_IDENT
);
5857 if (LA1
== XBM_TK_NUMBER
);
5859 char *p
= strrchr (buffer
, '_');
5860 p
= p
? p
+ 1 : buffer
;
5861 if (strcmp (p
, "width") == 0)
5863 else if (strcmp (p
, "height") == 0)
5866 expect (XBM_TK_NUMBER
);
5869 if (*width
< 0 || *height
< 0)
5871 else if (data
== NULL
)
5874 /* Parse bits. Must start with `static'. */
5875 expect_ident ("static");
5876 if (LA1
== XBM_TK_IDENT
)
5878 if (strcmp (buffer
, "unsigned") == 0)
5881 expect_ident ("char");
5883 else if (strcmp (buffer
, "short") == 0)
5887 if (*width
% 16 && *width
% 16 < 9)
5890 else if (strcmp (buffer
, "char") == 0)
5898 expect (XBM_TK_IDENT
);
5904 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
5905 nbytes
= bytes_per_line
* *height
;
5906 p
= *data
= (char *) xmalloc (nbytes
);
5910 for (i
= 0; i
< nbytes
; i
+= 2)
5913 expect (XBM_TK_NUMBER
);
5916 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
5919 if (LA1
== ',' || LA1
== '}')
5927 for (i
= 0; i
< nbytes
; ++i
)
5930 expect (XBM_TK_NUMBER
);
5934 if (LA1
== ',' || LA1
== '}')
5959 /* Load XBM image IMG which will be displayed on frame F from buffer
5960 CONTENTS. END is the end of the buffer. Value is non-zero if
5964 xbm_load_image (f
, img
, contents
, end
)
5967 char *contents
, *end
;
5970 unsigned char *data
;
5973 rc
= xbm_read_bitmap_data (contents
, end
, &img
->width
, &img
->height
, &data
);
5976 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
5977 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
5978 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
5981 xassert (img
->width
> 0 && img
->height
> 0);
5983 /* Get foreground and background colors, maybe allocate colors. */
5984 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
5986 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
5987 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
5990 background
= x_alloc_image_color (f
, img
, value
, background
);
5991 img
->background
= background
;
5992 img
->background_valid
= 1;
5996 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
5999 img
->width
, img
->height
,
6000 foreground
, background
,
6004 if (img
->pixmap
== None
)
6006 x_clear_image (f
, img
);
6007 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
6013 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
6019 /* Value is non-zero if DATA looks like an in-memory XBM file. */
6026 return (STRINGP (data
)
6027 && xbm_read_bitmap_data (SDATA (data
),
6034 /* Fill image IMG which is used on frame F with pixmap data. Value is
6035 non-zero if successful. */
6043 Lisp_Object file_name
;
6045 xassert (xbm_image_p (img
->spec
));
6047 /* If IMG->spec specifies a file name, create a non-file spec from it. */
6048 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
6049 if (STRINGP (file_name
))
6054 struct gcpro gcpro1
;
6056 file
= x_find_image_file (file_name
);
6058 if (!STRINGP (file
))
6060 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
6065 contents
= slurp_file (SDATA (file
), &size
);
6066 if (contents
== NULL
)
6068 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
6073 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
6078 struct image_keyword fmt
[XBM_LAST
];
6081 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
6082 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
6085 int in_memory_file_p
= 0;
6087 /* See if data looks like an in-memory XBM file. */
6088 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6089 in_memory_file_p
= xbm_file_p (data
);
6091 /* Parse the image specification. */
6092 bcopy (xbm_format
, fmt
, sizeof fmt
);
6093 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
6096 /* Get specified width, and height. */
6097 if (!in_memory_file_p
)
6099 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
6100 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
6101 xassert (img
->width
> 0 && img
->height
> 0);
6104 /* Get foreground and background colors, maybe allocate colors. */
6105 if (fmt
[XBM_FOREGROUND
].count
6106 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
6107 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
6109 if (fmt
[XBM_BACKGROUND
].count
6110 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
6111 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
6114 if (in_memory_file_p
)
6115 success_p
= xbm_load_image (f
, img
, SDATA (data
),
6124 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
6126 p
= bits
= (char *) alloca (nbytes
* img
->height
);
6127 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
6129 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
6131 bcopy (SDATA (line
), p
, nbytes
);
6133 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
6136 else if (STRINGP (data
))
6137 bits
= SDATA (data
);
6139 bits
= XBOOL_VECTOR (data
)->data
;
6141 /* Create the pixmap. */
6142 depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
6144 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
6147 img
->width
, img
->height
,
6148 foreground
, background
,
6154 image_error ("Unable to create pixmap for XBM image `%s'",
6156 x_clear_image (f
, img
);
6166 /***********************************************************************
6168 ***********************************************************************/
6172 static int xpm_image_p
P_ ((Lisp_Object object
));
6173 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
6174 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
6176 #include "X11/xpm.h"
6178 /* The symbol `xpm' identifying XPM-format images. */
6182 /* Indices of image specification fields in xpm_format, below. */
6184 enum xpm_keyword_index
6200 /* Vector of image_keyword structures describing the format
6201 of valid XPM image specifications. */
6203 static struct image_keyword xpm_format
[XPM_LAST
] =
6205 {":type", IMAGE_SYMBOL_VALUE
, 1},
6206 {":file", IMAGE_STRING_VALUE
, 0},
6207 {":data", IMAGE_STRING_VALUE
, 0},
6208 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6209 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6210 {":relief", IMAGE_INTEGER_VALUE
, 0},
6211 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6212 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6213 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6214 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6215 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6218 /* Structure describing the image type XBM. */
6220 static struct image_type xpm_type
=
6230 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
6231 functions for allocating image colors. Our own functions handle
6232 color allocation failures more gracefully than the ones on the XPM
6235 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
6236 #define ALLOC_XPM_COLORS
6239 #ifdef ALLOC_XPM_COLORS
6241 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
6242 static void xpm_free_color_cache
P_ ((void));
6243 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
6244 static int xpm_color_bucket
P_ ((char *));
6245 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
6248 /* An entry in a hash table used to cache color definitions of named
6249 colors. This cache is necessary to speed up XPM image loading in
6250 case we do color allocations ourselves. Without it, we would need
6251 a call to XParseColor per pixel in the image. */
6253 struct xpm_cached_color
6255 /* Next in collision chain. */
6256 struct xpm_cached_color
*next
;
6258 /* Color definition (RGB and pixel color). */
6265 /* The hash table used for the color cache, and its bucket vector
6268 #define XPM_COLOR_CACHE_BUCKETS 1001
6269 struct xpm_cached_color
**xpm_color_cache
;
6271 /* Initialize the color cache. */
6274 xpm_init_color_cache (f
, attrs
)
6276 XpmAttributes
*attrs
;
6278 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
6279 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
6280 memset (xpm_color_cache
, 0, nbytes
);
6281 init_color_table ();
6283 if (attrs
->valuemask
& XpmColorSymbols
)
6288 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
6289 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
6290 attrs
->colorsymbols
[i
].value
, &color
))
6292 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
6294 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
6300 /* Free the color cache. */
6303 xpm_free_color_cache ()
6305 struct xpm_cached_color
*p
, *next
;
6308 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
6309 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
6315 xfree (xpm_color_cache
);
6316 xpm_color_cache
= NULL
;
6317 free_color_table ();
6321 /* Return the bucket index for color named COLOR_NAME in the color
6325 xpm_color_bucket (color_name
)
6331 for (s
= color_name
; *s
; ++s
)
6333 return h
%= XPM_COLOR_CACHE_BUCKETS
;
6337 /* On frame F, cache values COLOR for color with name COLOR_NAME.
6338 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
6341 static struct xpm_cached_color
*
6342 xpm_cache_color (f
, color_name
, color
, bucket
)
6349 struct xpm_cached_color
*p
;
6352 bucket
= xpm_color_bucket (color_name
);
6354 nbytes
= sizeof *p
+ strlen (color_name
);
6355 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
6356 strcpy (p
->name
, color_name
);
6358 p
->next
= xpm_color_cache
[bucket
];
6359 xpm_color_cache
[bucket
] = p
;
6364 /* Look up color COLOR_NAME for frame F in the color cache. If found,
6365 return the cached definition in *COLOR. Otherwise, make a new
6366 entry in the cache and allocate the color. Value is zero if color
6367 allocation failed. */
6370 xpm_lookup_color (f
, color_name
, color
)
6375 struct xpm_cached_color
*p
;
6376 int h
= xpm_color_bucket (color_name
);
6378 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
6379 if (strcmp (p
->name
, color_name
) == 0)
6384 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
6387 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
6389 p
= xpm_cache_color (f
, color_name
, color
, h
);
6391 /* You get `opaque' at least from ImageMagick converting pbm to xpm
6392 with transparency, and it's useful. */
6393 else if (strcmp ("opaque", color_name
) == 0)
6395 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
6396 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
6397 p
= xpm_cache_color (f
, color_name
, color
, h
);
6404 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
6405 CLOSURE is a pointer to the frame on which we allocate the
6406 color. Return in *COLOR the allocated color. Value is non-zero
6410 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
6417 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
6421 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
6422 is a pointer to the frame on which we allocate the color. Value is
6423 non-zero if successful. */
6426 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
6436 #endif /* ALLOC_XPM_COLORS */
6439 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
6440 for XPM images. Such a list must consist of conses whose car and
6444 xpm_valid_color_symbols_p (color_symbols
)
6445 Lisp_Object color_symbols
;
6447 while (CONSP (color_symbols
))
6449 Lisp_Object sym
= XCAR (color_symbols
);
6451 || !STRINGP (XCAR (sym
))
6452 || !STRINGP (XCDR (sym
)))
6454 color_symbols
= XCDR (color_symbols
);
6457 return NILP (color_symbols
);
6461 /* Value is non-zero if OBJECT is a valid XPM image specification. */
6464 xpm_image_p (object
)
6467 struct image_keyword fmt
[XPM_LAST
];
6468 bcopy (xpm_format
, fmt
, sizeof fmt
);
6469 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
6470 /* Either `:file' or `:data' must be present. */
6471 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
6472 /* Either no `:color-symbols' or it's a list of conses
6473 whose car and cdr are strings. */
6474 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
6475 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
6479 /* Load image IMG which will be displayed on frame F. Value is
6480 non-zero if successful. */
6488 XpmAttributes attrs
;
6489 Lisp_Object specified_file
, color_symbols
;
6491 /* Configure the XPM lib. Use the visual of frame F. Allocate
6492 close colors. Return colors allocated. */
6493 bzero (&attrs
, sizeof attrs
);
6494 attrs
.visual
= FRAME_X_VISUAL (f
);
6495 attrs
.colormap
= FRAME_X_COLORMAP (f
);
6496 attrs
.valuemask
|= XpmVisual
;
6497 attrs
.valuemask
|= XpmColormap
;
6499 #ifdef ALLOC_XPM_COLORS
6500 /* Allocate colors with our own functions which handle
6501 failing color allocation more gracefully. */
6502 attrs
.color_closure
= f
;
6503 attrs
.alloc_color
= xpm_alloc_color
;
6504 attrs
.free_colors
= xpm_free_colors
;
6505 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
6506 #else /* not ALLOC_XPM_COLORS */
6507 /* Let the XPM lib allocate colors. */
6508 attrs
.valuemask
|= XpmReturnAllocPixels
;
6509 #ifdef XpmAllocCloseColors
6510 attrs
.alloc_close_colors
= 1;
6511 attrs
.valuemask
|= XpmAllocCloseColors
;
6512 #else /* not XpmAllocCloseColors */
6513 attrs
.closeness
= 600;
6514 attrs
.valuemask
|= XpmCloseness
;
6515 #endif /* not XpmAllocCloseColors */
6516 #endif /* ALLOC_XPM_COLORS */
6518 /* If image specification contains symbolic color definitions, add
6519 these to `attrs'. */
6520 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
6521 if (CONSP (color_symbols
))
6524 XpmColorSymbol
*xpm_syms
;
6527 attrs
.valuemask
|= XpmColorSymbols
;
6529 /* Count number of symbols. */
6530 attrs
.numsymbols
= 0;
6531 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
6534 /* Allocate an XpmColorSymbol array. */
6535 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
6536 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
6537 bzero (xpm_syms
, size
);
6538 attrs
.colorsymbols
= xpm_syms
;
6540 /* Fill the color symbol array. */
6541 for (tail
= color_symbols
, i
= 0;
6543 ++i
, tail
= XCDR (tail
))
6545 Lisp_Object name
= XCAR (XCAR (tail
));
6546 Lisp_Object color
= XCDR (XCAR (tail
));
6547 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
6548 strcpy (xpm_syms
[i
].name
, SDATA (name
));
6549 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
6550 strcpy (xpm_syms
[i
].value
, SDATA (color
));
6554 /* Create a pixmap for the image, either from a file, or from a
6555 string buffer containing data in the same format as an XPM file. */
6556 #ifdef ALLOC_XPM_COLORS
6557 xpm_init_color_cache (f
, &attrs
);
6560 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6561 if (STRINGP (specified_file
))
6563 Lisp_Object file
= x_find_image_file (specified_file
);
6564 if (!STRINGP (file
))
6566 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6570 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6571 SDATA (file
), &img
->pixmap
, &img
->mask
,
6576 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
6577 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6579 &img
->pixmap
, &img
->mask
,
6583 if (rc
== XpmSuccess
)
6585 #ifdef ALLOC_XPM_COLORS
6586 img
->colors
= colors_in_color_table (&img
->ncolors
);
6587 #else /* not ALLOC_XPM_COLORS */
6590 img
->ncolors
= attrs
.nalloc_pixels
;
6591 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
6592 * sizeof *img
->colors
);
6593 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
6595 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
6596 #ifdef DEBUG_X_COLORS
6597 register_color (img
->colors
[i
]);
6600 #endif /* not ALLOC_XPM_COLORS */
6602 img
->width
= attrs
.width
;
6603 img
->height
= attrs
.height
;
6604 xassert (img
->width
> 0 && img
->height
> 0);
6606 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
6607 XpmFreeAttributes (&attrs
);
6614 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
6617 case XpmFileInvalid
:
6618 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
6622 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
6625 case XpmColorFailed
:
6626 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
6630 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
6635 #ifdef ALLOC_XPM_COLORS
6636 xpm_free_color_cache ();
6638 return rc
== XpmSuccess
;
6641 #endif /* HAVE_XPM != 0 */
6644 /***********************************************************************
6646 ***********************************************************************/
6648 /* An entry in the color table mapping an RGB color to a pixel color. */
6653 unsigned long pixel
;
6655 /* Next in color table collision list. */
6656 struct ct_color
*next
;
6659 /* The bucket vector size to use. Must be prime. */
6663 /* Value is a hash of the RGB color given by R, G, and B. */
6665 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
6667 /* The color hash table. */
6669 struct ct_color
**ct_table
;
6671 /* Number of entries in the color table. */
6673 int ct_colors_allocated
;
6675 /* Initialize the color table. */
6680 int size
= CT_SIZE
* sizeof (*ct_table
);
6681 ct_table
= (struct ct_color
**) xmalloc (size
);
6682 bzero (ct_table
, size
);
6683 ct_colors_allocated
= 0;
6687 /* Free memory associated with the color table. */
6693 struct ct_color
*p
, *next
;
6695 for (i
= 0; i
< CT_SIZE
; ++i
)
6696 for (p
= ct_table
[i
]; p
; p
= next
)
6707 /* Value is a pixel color for RGB color R, G, B on frame F. If an
6708 entry for that color already is in the color table, return the
6709 pixel color of that entry. Otherwise, allocate a new color for R,
6710 G, B, and make an entry in the color table. */
6712 static unsigned long
6713 lookup_rgb_color (f
, r
, g
, b
)
6717 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
6718 int i
= hash
% CT_SIZE
;
6721 for (p
= ct_table
[i
]; p
; p
= p
->next
)
6722 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
6735 cmap
= FRAME_X_COLORMAP (f
);
6736 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
6740 ++ct_colors_allocated
;
6742 p
= (struct ct_color
*) xmalloc (sizeof *p
);
6746 p
->pixel
= color
.pixel
;
6747 p
->next
= ct_table
[i
];
6751 return FRAME_FOREGROUND_PIXEL (f
);
6758 /* Look up pixel color PIXEL which is used on frame F in the color
6759 table. If not already present, allocate it. Value is PIXEL. */
6761 static unsigned long
6762 lookup_pixel_color (f
, pixel
)
6764 unsigned long pixel
;
6766 int i
= pixel
% CT_SIZE
;
6769 for (p
= ct_table
[i
]; p
; p
= p
->next
)
6770 if (p
->pixel
== pixel
)
6779 cmap
= FRAME_X_COLORMAP (f
);
6780 color
.pixel
= pixel
;
6781 x_query_color (f
, &color
);
6782 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
6786 ++ct_colors_allocated
;
6788 p
= (struct ct_color
*) xmalloc (sizeof *p
);
6793 p
->next
= ct_table
[i
];
6797 return FRAME_FOREGROUND_PIXEL (f
);
6804 /* Value is a vector of all pixel colors contained in the color table,
6805 allocated via xmalloc. Set *N to the number of colors. */
6807 static unsigned long *
6808 colors_in_color_table (n
)
6813 unsigned long *colors
;
6815 if (ct_colors_allocated
== 0)
6822 colors
= (unsigned long *) xmalloc (ct_colors_allocated
6824 *n
= ct_colors_allocated
;
6826 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
6827 for (p
= ct_table
[i
]; p
; p
= p
->next
)
6828 colors
[j
++] = p
->pixel
;
6836 /***********************************************************************
6838 ***********************************************************************/
6840 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
6841 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
6842 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
6844 /* Non-zero means draw a cross on images having `:conversion
6847 int cross_disabled_images
;
6849 /* Edge detection matrices for different edge-detection
6852 static int emboss_matrix
[9] = {
6854 2, -1, 0, /* y - 1 */
6856 0, 1, -2 /* y + 1 */
6859 static int laplace_matrix
[9] = {
6861 1, 0, 0, /* y - 1 */
6863 0, 0, -1 /* y + 1 */
6866 /* Value is the intensity of the color whose red/green/blue values
6869 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
6872 /* On frame F, return an array of XColor structures describing image
6873 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
6874 non-zero means also fill the red/green/blue members of the XColor
6875 structures. Value is a pointer to the array of XColors structures,
6876 allocated with xmalloc; it must be freed by the caller. */
6879 x_to_xcolors (f
, img
, rgb_p
)
6888 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
6890 /* Get the X image IMG->pixmap. */
6891 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
6892 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
6894 /* Fill the `pixel' members of the XColor array. I wished there
6895 were an easy and portable way to circumvent XGetPixel. */
6897 for (y
= 0; y
< img
->height
; ++y
)
6901 for (x
= 0; x
< img
->width
; ++x
, ++p
)
6902 p
->pixel
= XGetPixel (ximg
, x
, y
);
6905 x_query_colors (f
, row
, img
->width
);
6908 XDestroyImage (ximg
);
6913 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
6914 RGB members are set. F is the frame on which this all happens.
6915 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
6918 x_from_xcolors (f
, img
, colors
)
6928 init_color_table ();
6930 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
6933 for (y
= 0; y
< img
->height
; ++y
)
6934 for (x
= 0; x
< img
->width
; ++x
, ++p
)
6936 unsigned long pixel
;
6937 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
6938 XPutPixel (oimg
, x
, y
, pixel
);
6942 x_clear_image_1 (f
, img
, 1, 0, 1);
6944 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
6945 x_destroy_x_image (oimg
);
6946 img
->pixmap
= pixmap
;
6947 img
->colors
= colors_in_color_table (&img
->ncolors
);
6948 free_color_table ();
6952 /* On frame F, perform edge-detection on image IMG.
6954 MATRIX is a nine-element array specifying the transformation
6955 matrix. See emboss_matrix for an example.
6957 COLOR_ADJUST is a color adjustment added to each pixel of the
6961 x_detect_edges (f
, img
, matrix
, color_adjust
)
6964 int matrix
[9], color_adjust
;
6966 XColor
*colors
= x_to_xcolors (f
, img
, 1);
6970 for (i
= sum
= 0; i
< 9; ++i
)
6971 sum
+= abs (matrix
[i
]);
6973 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
6975 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
6977 for (y
= 0; y
< img
->height
; ++y
)
6979 p
= COLOR (new, 0, y
);
6980 p
->red
= p
->green
= p
->blue
= 0xffff/2;
6981 p
= COLOR (new, img
->width
- 1, y
);
6982 p
->red
= p
->green
= p
->blue
= 0xffff/2;
6985 for (x
= 1; x
< img
->width
- 1; ++x
)
6987 p
= COLOR (new, x
, 0);
6988 p
->red
= p
->green
= p
->blue
= 0xffff/2;
6989 p
= COLOR (new, x
, img
->height
- 1);
6990 p
->red
= p
->green
= p
->blue
= 0xffff/2;
6993 for (y
= 1; y
< img
->height
- 1; ++y
)
6995 p
= COLOR (new, 1, y
);
6997 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
6999 int r
, g
, b
, y1
, x1
;
7002 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
7003 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
7006 XColor
*t
= COLOR (colors
, x1
, y1
);
7007 r
+= matrix
[i
] * t
->red
;
7008 g
+= matrix
[i
] * t
->green
;
7009 b
+= matrix
[i
] * t
->blue
;
7012 r
= (r
/ sum
+ color_adjust
) & 0xffff;
7013 g
= (g
/ sum
+ color_adjust
) & 0xffff;
7014 b
= (b
/ sum
+ color_adjust
) & 0xffff;
7015 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
7020 x_from_xcolors (f
, img
, new);
7026 /* Perform the pre-defined `emboss' edge-detection on image IMG
7034 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
7038 /* Perform the pre-defined `laplace' edge-detection on image IMG
7046 x_detect_edges (f
, img
, laplace_matrix
, 45000);
7050 /* Perform edge-detection on image IMG on frame F, with specified
7051 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
7053 MATRIX must be either
7055 - a list of at least 9 numbers in row-major form
7056 - a vector of at least 9 numbers
7058 COLOR_ADJUST nil means use a default; otherwise it must be a
7062 x_edge_detection (f
, img
, matrix
, color_adjust
)
7065 Lisp_Object matrix
, color_adjust
;
7073 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
7074 ++i
, matrix
= XCDR (matrix
))
7075 trans
[i
] = XFLOATINT (XCAR (matrix
));
7077 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
7079 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
7080 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
7083 if (NILP (color_adjust
))
7084 color_adjust
= make_number (0xffff / 2);
7086 if (i
== 9 && NUMBERP (color_adjust
))
7087 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
7091 /* Transform image IMG on frame F so that it looks disabled. */
7094 x_disable_image (f
, img
)
7098 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7100 if (dpyinfo
->n_planes
>= 2)
7102 /* Color (or grayscale). Convert to gray, and equalize. Just
7103 drawing such images with a stipple can look very odd, so
7104 we're using this method instead. */
7105 XColor
*colors
= x_to_xcolors (f
, img
, 1);
7107 const int h
= 15000;
7108 const int l
= 30000;
7110 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
7114 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
7115 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
7116 p
->red
= p
->green
= p
->blue
= i2
;
7119 x_from_xcolors (f
, img
, colors
);
7122 /* Draw a cross over the disabled image, if we must or if we
7124 if (dpyinfo
->n_planes
< 2 || cross_disabled_images
)
7126 Display
*dpy
= FRAME_X_DISPLAY (f
);
7129 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
7130 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
7131 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
7132 img
->width
- 1, img
->height
- 1);
7133 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
7139 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
7140 XSetForeground (dpy
, gc
, WHITE_PIX_DEFAULT (f
));
7141 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
7142 img
->width
- 1, img
->height
- 1);
7143 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
7151 /* Build a mask for image IMG which is used on frame F. FILE is the
7152 name of an image file, for error messages. HOW determines how to
7153 determine the background color of IMG. If it is a list '(R G B)',
7154 with R, G, and B being integers >= 0, take that as the color of the
7155 background. Otherwise, determine the background color of IMG
7156 heuristically. Value is non-zero if successful. */
7159 x_build_heuristic_mask (f
, img
, how
)
7164 Display
*dpy
= FRAME_X_DISPLAY (f
);
7165 XImage
*ximg
, *mask_img
;
7166 int x
, y
, rc
, use_img_background
;
7167 unsigned long bg
= 0;
7171 XFreePixmap (FRAME_X_DISPLAY (f
), img
->mask
);
7173 img
->background_transparent_valid
= 0;
7176 /* Create an image and pixmap serving as mask. */
7177 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
7178 &mask_img
, &img
->mask
);
7182 /* Get the X image of IMG->pixmap. */
7183 ximg
= XGetImage (dpy
, img
->pixmap
, 0, 0, img
->width
, img
->height
,
7186 /* Determine the background color of ximg. If HOW is `(R G B)'
7187 take that as color. Otherwise, use the image's background color. */
7188 use_img_background
= 1;
7194 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
7196 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
7200 if (i
== 3 && NILP (how
))
7202 char color_name
[30];
7203 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
7204 bg
= x_alloc_image_color (f
, img
, build_string (color_name
), 0);
7205 use_img_background
= 0;
7209 if (use_img_background
)
7210 bg
= four_corners_best (ximg
, img
->width
, img
->height
);
7212 /* Set all bits in mask_img to 1 whose color in ximg is different
7213 from the background color bg. */
7214 for (y
= 0; y
< img
->height
; ++y
)
7215 for (x
= 0; x
< img
->width
; ++x
)
7216 XPutPixel (mask_img
, x
, y
, XGetPixel (ximg
, x
, y
) != bg
);
7218 /* Fill in the background_transparent field while we have the mask handy. */
7219 image_background_transparent (img
, f
, mask_img
);
7221 /* Put mask_img into img->mask. */
7222 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
7223 x_destroy_x_image (mask_img
);
7224 XDestroyImage (ximg
);
7231 /***********************************************************************
7232 PBM (mono, gray, color)
7233 ***********************************************************************/
7235 static int pbm_image_p
P_ ((Lisp_Object object
));
7236 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
7237 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
7239 /* The symbol `pbm' identifying images of this type. */
7243 /* Indices of image specification fields in gs_format, below. */
7245 enum pbm_keyword_index
7261 /* Vector of image_keyword structures describing the format
7262 of valid user-defined image specifications. */
7264 static struct image_keyword pbm_format
[PBM_LAST
] =
7266 {":type", IMAGE_SYMBOL_VALUE
, 1},
7267 {":file", IMAGE_STRING_VALUE
, 0},
7268 {":data", IMAGE_STRING_VALUE
, 0},
7269 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7270 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7271 {":relief", IMAGE_INTEGER_VALUE
, 0},
7272 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7273 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7274 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7275 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
7276 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7279 /* Structure describing the image type `pbm'. */
7281 static struct image_type pbm_type
=
7291 /* Return non-zero if OBJECT is a valid PBM image specification. */
7294 pbm_image_p (object
)
7297 struct image_keyword fmt
[PBM_LAST
];
7299 bcopy (pbm_format
, fmt
, sizeof fmt
);
7301 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
7304 /* Must specify either :data or :file. */
7305 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
7309 /* Scan a decimal number from *S and return it. Advance *S while
7310 reading the number. END is the end of the string. Value is -1 at
7314 pbm_scan_number (s
, end
)
7315 unsigned char **s
, *end
;
7317 int c
= 0, val
= -1;
7321 /* Skip white-space. */
7322 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
7327 /* Skip comment to end of line. */
7328 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
7331 else if (isdigit (c
))
7333 /* Read decimal number. */
7335 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
7336 val
= 10 * val
+ c
- '0';
7347 /* Load PBM image IMG for use on frame F. */
7355 int width
, height
, max_color_idx
= 0;
7357 Lisp_Object file
, specified_file
;
7358 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
7359 struct gcpro gcpro1
;
7360 unsigned char *contents
= NULL
;
7361 unsigned char *end
, *p
;
7364 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7368 if (STRINGP (specified_file
))
7370 file
= x_find_image_file (specified_file
);
7371 if (!STRINGP (file
))
7373 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7378 contents
= slurp_file (SDATA (file
), &size
);
7379 if (contents
== NULL
)
7381 image_error ("Error reading `%s'", file
, Qnil
);
7387 end
= contents
+ size
;
7392 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7394 end
= p
+ SBYTES (data
);
7397 /* Check magic number. */
7398 if (end
- p
< 2 || *p
++ != 'P')
7400 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
7410 raw_p
= 0, type
= PBM_MONO
;
7414 raw_p
= 0, type
= PBM_GRAY
;
7418 raw_p
= 0, type
= PBM_COLOR
;
7422 raw_p
= 1, type
= PBM_MONO
;
7426 raw_p
= 1, type
= PBM_GRAY
;
7430 raw_p
= 1, type
= PBM_COLOR
;
7434 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
7438 /* Read width, height, maximum color-component. Characters
7439 starting with `#' up to the end of a line are ignored. */
7440 width
= pbm_scan_number (&p
, end
);
7441 height
= pbm_scan_number (&p
, end
);
7443 if (type
!= PBM_MONO
)
7445 max_color_idx
= pbm_scan_number (&p
, end
);
7446 if (raw_p
&& max_color_idx
> 255)
7447 max_color_idx
= 255;
7452 || (type
!= PBM_MONO
&& max_color_idx
< 0))
7455 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
7456 &ximg
, &img
->pixmap
))
7459 /* Initialize the color hash table. */
7460 init_color_table ();
7462 if (type
== PBM_MONO
)
7465 struct image_keyword fmt
[PBM_LAST
];
7466 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
7467 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
7469 /* Parse the image specification. */
7470 bcopy (pbm_format
, fmt
, sizeof fmt
);
7471 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
7473 /* Get foreground and background colors, maybe allocate colors. */
7474 if (fmt
[PBM_FOREGROUND
].count
7475 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
7476 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
7477 if (fmt
[PBM_BACKGROUND
].count
7478 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
7480 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
7481 img
->background
= bg
;
7482 img
->background_valid
= 1;
7485 for (y
= 0; y
< height
; ++y
)
7486 for (x
= 0; x
< width
; ++x
)
7496 g
= pbm_scan_number (&p
, end
);
7498 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
7503 for (y
= 0; y
< height
; ++y
)
7504 for (x
= 0; x
< width
; ++x
)
7508 if (type
== PBM_GRAY
)
7509 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
7518 r
= pbm_scan_number (&p
, end
);
7519 g
= pbm_scan_number (&p
, end
);
7520 b
= pbm_scan_number (&p
, end
);
7523 if (r
< 0 || g
< 0 || b
< 0)
7527 XDestroyImage (ximg
);
7528 image_error ("Invalid pixel value in image `%s'",
7533 /* RGB values are now in the range 0..max_color_idx.
7534 Scale this to the range 0..0xffff supported by X. */
7535 r
= (double) r
* 65535 / max_color_idx
;
7536 g
= (double) g
* 65535 / max_color_idx
;
7537 b
= (double) b
* 65535 / max_color_idx
;
7538 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
7542 /* Store in IMG->colors the colors allocated for the image, and
7543 free the color table. */
7544 img
->colors
= colors_in_color_table (&img
->ncolors
);
7545 free_color_table ();
7547 /* Maybe fill in the background field while we have ximg handy. */
7548 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7549 IMAGE_BACKGROUND (img
, f
, ximg
);
7551 /* Put the image into a pixmap. */
7552 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7553 x_destroy_x_image (ximg
);
7556 img
->height
= height
;
7565 /***********************************************************************
7567 ***********************************************************************/
7571 #if defined HAVE_LIBPNG_PNG_H
7572 # include <libpng/png.h>
7577 /* Function prototypes. */
7579 static int png_image_p
P_ ((Lisp_Object object
));
7580 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
7582 /* The symbol `png' identifying images of this type. */
7586 /* Indices of image specification fields in png_format, below. */
7588 enum png_keyword_index
7603 /* Vector of image_keyword structures describing the format
7604 of valid user-defined image specifications. */
7606 static struct image_keyword png_format
[PNG_LAST
] =
7608 {":type", IMAGE_SYMBOL_VALUE
, 1},
7609 {":data", IMAGE_STRING_VALUE
, 0},
7610 {":file", IMAGE_STRING_VALUE
, 0},
7611 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7612 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7613 {":relief", IMAGE_INTEGER_VALUE
, 0},
7614 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7615 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7616 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7617 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7620 /* Structure describing the image type `png'. */
7622 static struct image_type png_type
=
7632 /* Return non-zero if OBJECT is a valid PNG image specification. */
7635 png_image_p (object
)
7638 struct image_keyword fmt
[PNG_LAST
];
7639 bcopy (png_format
, fmt
, sizeof fmt
);
7641 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
7644 /* Must specify either the :data or :file keyword. */
7645 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
7649 /* Error and warning handlers installed when the PNG library
7653 my_png_error (png_ptr
, msg
)
7654 png_struct
*png_ptr
;
7657 xassert (png_ptr
!= NULL
);
7658 image_error ("PNG error: %s", build_string (msg
), Qnil
);
7659 longjmp (png_ptr
->jmpbuf
, 1);
7664 my_png_warning (png_ptr
, msg
)
7665 png_struct
*png_ptr
;
7668 xassert (png_ptr
!= NULL
);
7669 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
7672 /* Memory source for PNG decoding. */
7674 struct png_memory_storage
7676 unsigned char *bytes
; /* The data */
7677 size_t len
; /* How big is it? */
7678 int index
; /* Where are we? */
7682 /* Function set as reader function when reading PNG image from memory.
7683 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
7684 bytes from the input to DATA. */
7687 png_read_from_memory (png_ptr
, data
, length
)
7688 png_structp png_ptr
;
7692 struct png_memory_storage
*tbr
7693 = (struct png_memory_storage
*) png_get_io_ptr (png_ptr
);
7695 if (length
> tbr
->len
- tbr
->index
)
7696 png_error (png_ptr
, "Read error");
7698 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
7699 tbr
->index
= tbr
->index
+ length
;
7702 /* Load PNG image IMG for use on frame F. Value is non-zero if
7710 Lisp_Object file
, specified_file
;
7711 Lisp_Object specified_data
;
7713 XImage
*ximg
, *mask_img
= NULL
;
7714 struct gcpro gcpro1
;
7715 png_struct
*png_ptr
= NULL
;
7716 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
7717 FILE *volatile fp
= NULL
;
7719 png_byte
* volatile pixels
= NULL
;
7720 png_byte
** volatile rows
= NULL
;
7721 png_uint_32 width
, height
;
7722 int bit_depth
, color_type
, interlace_type
;
7724 png_uint_32 row_bytes
;
7726 double screen_gamma
;
7727 struct png_memory_storage tbr
; /* Data to be read */
7729 /* Find out what file to load. */
7730 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7731 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7735 if (NILP (specified_data
))
7737 file
= x_find_image_file (specified_file
);
7738 if (!STRINGP (file
))
7740 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7745 /* Open the image file. */
7746 fp
= fopen (SDATA (file
), "rb");
7749 image_error ("Cannot open image file `%s'", file
, Qnil
);
7755 /* Check PNG signature. */
7756 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
7757 || !png_check_sig (sig
, sizeof sig
))
7759 image_error ("Not a PNG file: `%s'", file
, Qnil
);
7767 /* Read from memory. */
7768 tbr
.bytes
= SDATA (specified_data
);
7769 tbr
.len
= SBYTES (specified_data
);
7772 /* Check PNG signature. */
7773 if (tbr
.len
< sizeof sig
7774 || !png_check_sig (tbr
.bytes
, sizeof sig
))
7776 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
7781 /* Need to skip past the signature. */
7782 tbr
.bytes
+= sizeof (sig
);
7785 /* Initialize read and info structs for PNG lib. */
7786 png_ptr
= png_create_read_struct (PNG_LIBPNG_VER_STRING
, NULL
,
7787 my_png_error
, my_png_warning
);
7790 if (fp
) fclose (fp
);
7795 info_ptr
= png_create_info_struct (png_ptr
);
7798 png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
7799 if (fp
) fclose (fp
);
7804 end_info
= png_create_info_struct (png_ptr
);
7807 png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
7808 if (fp
) fclose (fp
);
7813 /* Set error jump-back. We come back here when the PNG library
7814 detects an error. */
7815 if (setjmp (png_ptr
->jmpbuf
))
7819 png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
7822 if (fp
) fclose (fp
);
7827 /* Read image info. */
7828 if (!NILP (specified_data
))
7829 png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
7831 png_init_io (png_ptr
, fp
);
7833 png_set_sig_bytes (png_ptr
, sizeof sig
);
7834 png_read_info (png_ptr
, info_ptr
);
7835 png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
7836 &interlace_type
, NULL
, NULL
);
7838 /* If image contains simply transparency data, we prefer to
7839 construct a clipping mask. */
7840 if (png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
7845 /* This function is easier to write if we only have to handle
7846 one data format: RGB or RGBA with 8 bits per channel. Let's
7847 transform other formats into that format. */
7849 /* Strip more than 8 bits per channel. */
7850 if (bit_depth
== 16)
7851 png_set_strip_16 (png_ptr
);
7853 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
7855 png_set_expand (png_ptr
);
7857 /* Convert grayscale images to RGB. */
7858 if (color_type
== PNG_COLOR_TYPE_GRAY
7859 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
7860 png_set_gray_to_rgb (png_ptr
);
7862 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
7864 #if 0 /* Avoid double gamma correction for PNG images. */
7865 { /* Tell the PNG lib to handle gamma correction for us. */
7868 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
7869 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
7870 /* The libpng documentation says this is right in this case. */
7871 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
7874 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
7875 /* Image contains gamma information. */
7876 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
7878 /* Use the standard default for the image gamma. */
7879 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
7883 /* Handle alpha channel by combining the image with a background
7884 color. Do this only if a real alpha channel is supplied. For
7885 simple transparency, we prefer a clipping mask. */
7888 png_color_16
*image_bg
;
7889 Lisp_Object specified_bg
7890 = image_spec_value (img
->spec
, QCbackground
, NULL
);
7892 if (STRINGP (specified_bg
))
7893 /* The user specified `:background', use that. */
7896 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
7898 png_color_16 user_bg
;
7900 bzero (&user_bg
, sizeof user_bg
);
7901 user_bg
.red
= color
.red
;
7902 user_bg
.green
= color
.green
;
7903 user_bg
.blue
= color
.blue
;
7905 png_set_background (png_ptr
, &user_bg
,
7906 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
7909 else if (png_get_bKGD (png_ptr
, info_ptr
, &image_bg
))
7910 /* Image contains a background color with which to
7911 combine the image. */
7912 png_set_background (png_ptr
, image_bg
,
7913 PNG_BACKGROUND_GAMMA_FILE
, 1, 1.0);
7916 /* Image does not contain a background color with which
7917 to combine the image data via an alpha channel. Use
7918 the frame's background instead. */
7921 png_color_16 frame_background
;
7923 cmap
= FRAME_X_COLORMAP (f
);
7924 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
7925 x_query_color (f
, &color
);
7927 bzero (&frame_background
, sizeof frame_background
);
7928 frame_background
.red
= color
.red
;
7929 frame_background
.green
= color
.green
;
7930 frame_background
.blue
= color
.blue
;
7932 png_set_background (png_ptr
, &frame_background
,
7933 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
7937 /* Update info structure. */
7938 png_read_update_info (png_ptr
, info_ptr
);
7940 /* Get number of channels. Valid values are 1 for grayscale images
7941 and images with a palette, 2 for grayscale images with transparency
7942 information (alpha channel), 3 for RGB images, and 4 for RGB
7943 images with alpha channel, i.e. RGBA. If conversions above were
7944 sufficient we should only have 3 or 4 channels here. */
7945 channels
= png_get_channels (png_ptr
, info_ptr
);
7946 xassert (channels
== 3 || channels
== 4);
7948 /* Number of bytes needed for one row of the image. */
7949 row_bytes
= png_get_rowbytes (png_ptr
, info_ptr
);
7951 /* Allocate memory for the image. */
7952 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
7953 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
7954 for (i
= 0; i
< height
; ++i
)
7955 rows
[i
] = pixels
+ i
* row_bytes
;
7957 /* Read the entire image. */
7958 png_read_image (png_ptr
, rows
);
7959 png_read_end (png_ptr
, info_ptr
);
7966 /* Create the X image and pixmap. */
7967 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
7971 /* Create an image and pixmap serving as mask if the PNG image
7972 contains an alpha channel. */
7975 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
7976 &mask_img
, &img
->mask
))
7978 x_destroy_x_image (ximg
);
7979 XFreePixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
7984 /* Fill the X image and mask from PNG data. */
7985 init_color_table ();
7987 for (y
= 0; y
< height
; ++y
)
7989 png_byte
*p
= rows
[y
];
7991 for (x
= 0; x
< width
; ++x
)
7998 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
8000 /* An alpha channel, aka mask channel, associates variable
8001 transparency with an image. Where other image formats
8002 support binary transparency---fully transparent or fully
8003 opaque---PNG allows up to 254 levels of partial transparency.
8004 The PNG library implements partial transparency by combining
8005 the image with a specified background color.
8007 I'm not sure how to handle this here nicely: because the
8008 background on which the image is displayed may change, for
8009 real alpha channel support, it would be necessary to create
8010 a new image for each possible background.
8012 What I'm doing now is that a mask is created if we have
8013 boolean transparency information. Otherwise I'm using
8014 the frame's background color to combine the image with. */
8019 XPutPixel (mask_img
, x
, y
, *p
> 0);
8025 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8026 /* Set IMG's background color from the PNG image, unless the user
8030 if (png_get_bKGD (png_ptr
, info_ptr
, &bg
))
8032 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
8033 img
->background_valid
= 1;
8037 /* Remember colors allocated for this image. */
8038 img
->colors
= colors_in_color_table (&img
->ncolors
);
8039 free_color_table ();
8042 png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
8047 img
->height
= height
;
8049 /* Maybe fill in the background field while we have ximg handy. */
8050 IMAGE_BACKGROUND (img
, f
, ximg
);
8052 /* Put the image into the pixmap, then free the X image and its buffer. */
8053 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8054 x_destroy_x_image (ximg
);
8056 /* Same for the mask. */
8059 /* Fill in the background_transparent field while we have the mask
8061 image_background_transparent (img
, f
, mask_img
);
8063 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
8064 x_destroy_x_image (mask_img
);
8071 #endif /* HAVE_PNG != 0 */
8075 /***********************************************************************
8077 ***********************************************************************/
8081 /* Work around a warning about HAVE_STDLIB_H being redefined in
8083 #ifdef HAVE_STDLIB_H
8084 #define HAVE_STDLIB_H_1
8085 #undef HAVE_STDLIB_H
8086 #endif /* HAVE_STLIB_H */
8088 #include <jpeglib.h>
8092 #ifdef HAVE_STLIB_H_1
8093 #define HAVE_STDLIB_H 1
8096 static int jpeg_image_p
P_ ((Lisp_Object object
));
8097 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
8099 /* The symbol `jpeg' identifying images of this type. */
8103 /* Indices of image specification fields in gs_format, below. */
8105 enum jpeg_keyword_index
8114 JPEG_HEURISTIC_MASK
,
8120 /* Vector of image_keyword structures describing the format
8121 of valid user-defined image specifications. */
8123 static struct image_keyword jpeg_format
[JPEG_LAST
] =
8125 {":type", IMAGE_SYMBOL_VALUE
, 1},
8126 {":data", IMAGE_STRING_VALUE
, 0},
8127 {":file", IMAGE_STRING_VALUE
, 0},
8128 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8129 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8130 {":relief", IMAGE_INTEGER_VALUE
, 0},
8131 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8132 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8133 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8134 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8137 /* Structure describing the image type `jpeg'. */
8139 static struct image_type jpeg_type
=
8149 /* Return non-zero if OBJECT is a valid JPEG image specification. */
8152 jpeg_image_p (object
)
8155 struct image_keyword fmt
[JPEG_LAST
];
8157 bcopy (jpeg_format
, fmt
, sizeof fmt
);
8159 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
8162 /* Must specify either the :data or :file keyword. */
8163 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
8167 struct my_jpeg_error_mgr
8169 struct jpeg_error_mgr pub
;
8170 jmp_buf setjmp_buffer
;
8175 my_error_exit (cinfo
)
8178 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
8179 longjmp (mgr
->setjmp_buffer
, 1);
8183 /* Init source method for JPEG data source manager. Called by
8184 jpeg_read_header() before any data is actually read. See
8185 libjpeg.doc from the JPEG lib distribution. */
8188 our_init_source (cinfo
)
8189 j_decompress_ptr cinfo
;
8194 /* Fill input buffer method for JPEG data source manager. Called
8195 whenever more data is needed. We read the whole image in one step,
8196 so this only adds a fake end of input marker at the end. */
8199 our_fill_input_buffer (cinfo
)
8200 j_decompress_ptr cinfo
;
8202 /* Insert a fake EOI marker. */
8203 struct jpeg_source_mgr
*src
= cinfo
->src
;
8204 static JOCTET buffer
[2];
8206 buffer
[0] = (JOCTET
) 0xFF;
8207 buffer
[1] = (JOCTET
) JPEG_EOI
;
8209 src
->next_input_byte
= buffer
;
8210 src
->bytes_in_buffer
= 2;
8215 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
8216 is the JPEG data source manager. */
8219 our_skip_input_data (cinfo
, num_bytes
)
8220 j_decompress_ptr cinfo
;
8223 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
8227 if (num_bytes
> src
->bytes_in_buffer
)
8228 ERREXIT (cinfo
, JERR_INPUT_EOF
);
8230 src
->bytes_in_buffer
-= num_bytes
;
8231 src
->next_input_byte
+= num_bytes
;
8236 /* Method to terminate data source. Called by
8237 jpeg_finish_decompress() after all data has been processed. */
8240 our_term_source (cinfo
)
8241 j_decompress_ptr cinfo
;
8246 /* Set up the JPEG lib for reading an image from DATA which contains
8247 LEN bytes. CINFO is the decompression info structure created for
8248 reading the image. */
8251 jpeg_memory_src (cinfo
, data
, len
)
8252 j_decompress_ptr cinfo
;
8256 struct jpeg_source_mgr
*src
;
8258 if (cinfo
->src
== NULL
)
8260 /* First time for this JPEG object? */
8261 cinfo
->src
= (struct jpeg_source_mgr
*)
8262 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
8263 sizeof (struct jpeg_source_mgr
));
8264 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
8265 src
->next_input_byte
= data
;
8268 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
8269 src
->init_source
= our_init_source
;
8270 src
->fill_input_buffer
= our_fill_input_buffer
;
8271 src
->skip_input_data
= our_skip_input_data
;
8272 src
->resync_to_restart
= jpeg_resync_to_restart
; /* Use default method. */
8273 src
->term_source
= our_term_source
;
8274 src
->bytes_in_buffer
= len
;
8275 src
->next_input_byte
= data
;
8279 /* Load image IMG for use on frame F. Patterned after example.c
8280 from the JPEG lib. */
8287 struct jpeg_decompress_struct cinfo
;
8288 struct my_jpeg_error_mgr mgr
;
8289 Lisp_Object file
, specified_file
;
8290 Lisp_Object specified_data
;
8291 FILE * volatile fp
= NULL
;
8293 int row_stride
, x
, y
;
8294 XImage
*ximg
= NULL
;
8296 unsigned long *colors
;
8298 struct gcpro gcpro1
;
8300 /* Open the JPEG file. */
8301 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
8302 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8306 if (NILP (specified_data
))
8308 file
= x_find_image_file (specified_file
);
8309 if (!STRINGP (file
))
8311 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
8316 fp
= fopen (SDATA (file
), "r");
8319 image_error ("Cannot open `%s'", file
, Qnil
);
8325 /* Customize libjpeg's error handling to call my_error_exit when an
8326 error is detected. This function will perform a longjmp. */
8327 cinfo
.err
= jpeg_std_error (&mgr
.pub
);
8328 mgr
.pub
.error_exit
= my_error_exit
;
8330 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
8334 /* Called from my_error_exit. Display a JPEG error. */
8335 char buffer
[JMSG_LENGTH_MAX
];
8336 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
8337 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
8338 build_string (buffer
));
8341 /* Close the input file and destroy the JPEG object. */
8343 fclose ((FILE *) fp
);
8344 jpeg_destroy_decompress (&cinfo
);
8346 /* If we already have an XImage, free that. */
8347 x_destroy_x_image (ximg
);
8349 /* Free pixmap and colors. */
8350 x_clear_image (f
, img
);
8356 /* Create the JPEG decompression object. Let it read from fp.
8357 Read the JPEG image header. */
8358 jpeg_create_decompress (&cinfo
);
8360 if (NILP (specified_data
))
8361 jpeg_stdio_src (&cinfo
, (FILE *) fp
);
8363 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
8364 SBYTES (specified_data
));
8366 jpeg_read_header (&cinfo
, TRUE
);
8368 /* Customize decompression so that color quantization will be used.
8369 Start decompression. */
8370 cinfo
.quantize_colors
= TRUE
;
8371 jpeg_start_decompress (&cinfo
);
8372 width
= img
->width
= cinfo
.output_width
;
8373 height
= img
->height
= cinfo
.output_height
;
8375 /* Create X image and pixmap. */
8376 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8377 longjmp (mgr
.setjmp_buffer
, 2);
8379 /* Allocate colors. When color quantization is used,
8380 cinfo.actual_number_of_colors has been set with the number of
8381 colors generated, and cinfo.colormap is a two-dimensional array
8382 of color indices in the range 0..cinfo.actual_number_of_colors.
8383 No more than 255 colors will be generated. */
8387 if (cinfo
.out_color_components
> 2)
8388 ir
= 0, ig
= 1, ib
= 2;
8389 else if (cinfo
.out_color_components
> 1)
8390 ir
= 0, ig
= 1, ib
= 0;
8392 ir
= 0, ig
= 0, ib
= 0;
8394 /* Use the color table mechanism because it handles colors that
8395 cannot be allocated nicely. Such colors will be replaced with
8396 a default color, and we don't have to care about which colors
8397 can be freed safely, and which can't. */
8398 init_color_table ();
8399 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
8402 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
8404 /* Multiply RGB values with 255 because X expects RGB values
8405 in the range 0..0xffff. */
8406 int r
= cinfo
.colormap
[ir
][i
] << 8;
8407 int g
= cinfo
.colormap
[ig
][i
] << 8;
8408 int b
= cinfo
.colormap
[ib
][i
] << 8;
8409 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
8412 /* Remember those colors actually allocated. */
8413 img
->colors
= colors_in_color_table (&img
->ncolors
);
8414 free_color_table ();
8418 row_stride
= width
* cinfo
.output_components
;
8419 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
8421 for (y
= 0; y
< height
; ++y
)
8423 jpeg_read_scanlines (&cinfo
, buffer
, 1);
8424 for (x
= 0; x
< cinfo
.output_width
; ++x
)
8425 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
8429 jpeg_finish_decompress (&cinfo
);
8430 jpeg_destroy_decompress (&cinfo
);
8432 fclose ((FILE *) fp
);
8434 /* Maybe fill in the background field while we have ximg handy. */
8435 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8436 IMAGE_BACKGROUND (img
, f
, ximg
);
8438 /* Put the image into the pixmap. */
8439 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8440 x_destroy_x_image (ximg
);
8445 #endif /* HAVE_JPEG */
8449 /***********************************************************************
8451 ***********************************************************************/
8457 static int tiff_image_p
P_ ((Lisp_Object object
));
8458 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
8460 /* The symbol `tiff' identifying images of this type. */
8464 /* Indices of image specification fields in tiff_format, below. */
8466 enum tiff_keyword_index
8475 TIFF_HEURISTIC_MASK
,
8481 /* Vector of image_keyword structures describing the format
8482 of valid user-defined image specifications. */
8484 static struct image_keyword tiff_format
[TIFF_LAST
] =
8486 {":type", IMAGE_SYMBOL_VALUE
, 1},
8487 {":data", IMAGE_STRING_VALUE
, 0},
8488 {":file", IMAGE_STRING_VALUE
, 0},
8489 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8490 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8491 {":relief", IMAGE_INTEGER_VALUE
, 0},
8492 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8493 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8494 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8495 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8498 /* Structure describing the image type `tiff'. */
8500 static struct image_type tiff_type
=
8510 /* Return non-zero if OBJECT is a valid TIFF image specification. */
8513 tiff_image_p (object
)
8516 struct image_keyword fmt
[TIFF_LAST
];
8517 bcopy (tiff_format
, fmt
, sizeof fmt
);
8519 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
8522 /* Must specify either the :data or :file keyword. */
8523 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
8527 /* Reading from a memory buffer for TIFF images Based on the PNG
8528 memory source, but we have to provide a lot of extra functions.
8531 We really only need to implement read and seek, but I am not
8532 convinced that the TIFF library is smart enough not to destroy
8533 itself if we only hand it the function pointers we need to
8538 unsigned char *bytes
;
8546 tiff_read_from_memory (data
, buf
, size
)
8551 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
8553 if (size
> src
->len
- src
->index
)
8555 bcopy (src
->bytes
+ src
->index
, buf
, size
);
8562 tiff_write_from_memory (data
, buf
, size
)
8572 tiff_seek_in_memory (data
, off
, whence
)
8577 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
8582 case SEEK_SET
: /* Go from beginning of source. */
8586 case SEEK_END
: /* Go from end of source. */
8587 idx
= src
->len
+ off
;
8590 case SEEK_CUR
: /* Go from current position. */
8591 idx
= src
->index
+ off
;
8594 default: /* Invalid `whence'. */
8598 if (idx
> src
->len
|| idx
< 0)
8607 tiff_close_memory (data
)
8616 tiff_mmap_memory (data
, pbase
, psize
)
8621 /* It is already _IN_ memory. */
8627 tiff_unmap_memory (data
, base
, size
)
8632 /* We don't need to do this. */
8637 tiff_size_of_memory (data
)
8640 return ((tiff_memory_source
*) data
)->len
;
8645 tiff_error_handler (title
, format
, ap
)
8646 const char *title
, *format
;
8652 len
= sprintf (buf
, "TIFF error: %s ", title
);
8653 vsprintf (buf
+ len
, format
, ap
);
8654 add_to_log (buf
, Qnil
, Qnil
);
8659 tiff_warning_handler (title
, format
, ap
)
8660 const char *title
, *format
;
8666 len
= sprintf (buf
, "TIFF warning: %s ", title
);
8667 vsprintf (buf
+ len
, format
, ap
);
8668 add_to_log (buf
, Qnil
, Qnil
);
8672 /* Load TIFF image IMG for use on frame F. Value is non-zero if
8680 Lisp_Object file
, specified_file
;
8681 Lisp_Object specified_data
;
8683 int width
, height
, x
, y
;
8687 struct gcpro gcpro1
;
8688 tiff_memory_source memsrc
;
8690 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
8691 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8695 TIFFSetErrorHandler (tiff_error_handler
);
8696 TIFFSetWarningHandler (tiff_warning_handler
);
8698 if (NILP (specified_data
))
8700 /* Read from a file */
8701 file
= x_find_image_file (specified_file
);
8702 if (!STRINGP (file
))
8704 image_error ("Cannot find image file `%s'", file
, Qnil
);
8709 /* Try to open the image file. */
8710 tiff
= TIFFOpen (SDATA (file
), "r");
8713 image_error ("Cannot open `%s'", file
, Qnil
);
8720 /* Memory source! */
8721 memsrc
.bytes
= SDATA (specified_data
);
8722 memsrc
.len
= SBYTES (specified_data
);
8725 tiff
= TIFFClientOpen ("memory_source", "r", &memsrc
,
8726 (TIFFReadWriteProc
) tiff_read_from_memory
,
8727 (TIFFReadWriteProc
) tiff_write_from_memory
,
8728 tiff_seek_in_memory
,
8730 tiff_size_of_memory
,
8736 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
8742 /* Get width and height of the image, and allocate a raster buffer
8743 of width x height 32-bit values. */
8744 TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
8745 TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
8746 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
8748 rc
= TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
8752 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
8758 /* Create the X image and pixmap. */
8759 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8766 /* Initialize the color table. */
8767 init_color_table ();
8769 /* Process the pixel raster. Origin is in the lower-left corner. */
8770 for (y
= 0; y
< height
; ++y
)
8772 uint32
*row
= buf
+ y
* width
;
8774 for (x
= 0; x
< width
; ++x
)
8776 uint32 abgr
= row
[x
];
8777 int r
= TIFFGetR (abgr
) << 8;
8778 int g
= TIFFGetG (abgr
) << 8;
8779 int b
= TIFFGetB (abgr
) << 8;
8780 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
8784 /* Remember the colors allocated for the image. Free the color table. */
8785 img
->colors
= colors_in_color_table (&img
->ncolors
);
8786 free_color_table ();
8789 img
->height
= height
;
8791 /* Maybe fill in the background field while we have ximg handy. */
8792 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8793 IMAGE_BACKGROUND (img
, f
, ximg
);
8795 /* Put the image into the pixmap, then free the X image and its buffer. */
8796 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8797 x_destroy_x_image (ximg
);
8804 #endif /* HAVE_TIFF != 0 */
8808 /***********************************************************************
8810 ***********************************************************************/
8814 #include <gif_lib.h>
8816 static int gif_image_p
P_ ((Lisp_Object object
));
8817 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
8819 /* The symbol `gif' identifying images of this type. */
8823 /* Indices of image specification fields in gif_format, below. */
8825 enum gif_keyword_index
8841 /* Vector of image_keyword structures describing the format
8842 of valid user-defined image specifications. */
8844 static struct image_keyword gif_format
[GIF_LAST
] =
8846 {":type", IMAGE_SYMBOL_VALUE
, 1},
8847 {":data", IMAGE_STRING_VALUE
, 0},
8848 {":file", IMAGE_STRING_VALUE
, 0},
8849 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8850 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8851 {":relief", IMAGE_INTEGER_VALUE
, 0},
8852 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8853 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8854 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8855 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
8856 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8859 /* Structure describing the image type `gif'. */
8861 static struct image_type gif_type
=
8871 /* Return non-zero if OBJECT is a valid GIF image specification. */
8874 gif_image_p (object
)
8877 struct image_keyword fmt
[GIF_LAST
];
8878 bcopy (gif_format
, fmt
, sizeof fmt
);
8880 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
8883 /* Must specify either the :data or :file keyword. */
8884 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
8888 /* Reading a GIF image from memory
8889 Based on the PNG memory stuff to a certain extent. */
8893 unsigned char *bytes
;
8900 /* Make the current memory source available to gif_read_from_memory.
8901 It's done this way because not all versions of libungif support
8902 a UserData field in the GifFileType structure. */
8903 static gif_memory_source
*current_gif_memory_src
;
8906 gif_read_from_memory (file
, buf
, len
)
8911 gif_memory_source
*src
= current_gif_memory_src
;
8913 if (len
> src
->len
- src
->index
)
8916 bcopy (src
->bytes
+ src
->index
, buf
, len
);
8922 /* Load GIF image IMG for use on frame F. Value is non-zero if
8930 Lisp_Object file
, specified_file
;
8931 Lisp_Object specified_data
;
8932 int rc
, width
, height
, x
, y
, i
;
8934 ColorMapObject
*gif_color_map
;
8935 unsigned long pixel_colors
[256];
8937 struct gcpro gcpro1
;
8939 int ino
, image_left
, image_top
, image_width
, image_height
;
8940 gif_memory_source memsrc
;
8941 unsigned char *raster
;
8943 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
8944 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8948 if (NILP (specified_data
))
8950 file
= x_find_image_file (specified_file
);
8951 if (!STRINGP (file
))
8953 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
8958 /* Open the GIF file. */
8959 gif
= DGifOpenFileName (SDATA (file
));
8962 image_error ("Cannot open `%s'", file
, Qnil
);
8969 /* Read from memory! */
8970 current_gif_memory_src
= &memsrc
;
8971 memsrc
.bytes
= SDATA (specified_data
);
8972 memsrc
.len
= SBYTES (specified_data
);
8975 gif
= DGifOpen(&memsrc
, gif_read_from_memory
);
8978 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
8984 /* Read entire contents. */
8985 rc
= DGifSlurp (gif
);
8986 if (rc
== GIF_ERROR
)
8988 image_error ("Error reading `%s'", img
->spec
, Qnil
);
8989 DGifCloseFile (gif
);
8994 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
8995 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
8996 if (ino
>= gif
->ImageCount
)
8998 image_error ("Invalid image number `%s' in image `%s'",
9000 DGifCloseFile (gif
);
9005 width
= img
->width
= max (gif
->SWidth
, gif
->Image
.Left
+ gif
->Image
.Width
);
9006 height
= img
->height
= max (gif
->SHeight
, gif
->Image
.Top
+ gif
->Image
.Height
);
9008 /* Create the X image and pixmap. */
9009 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
9011 DGifCloseFile (gif
);
9016 /* Allocate colors. */
9017 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
9019 gif_color_map
= gif
->SColorMap
;
9020 init_color_table ();
9021 bzero (pixel_colors
, sizeof pixel_colors
);
9023 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
9025 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
9026 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
9027 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
9028 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
9031 img
->colors
= colors_in_color_table (&img
->ncolors
);
9032 free_color_table ();
9034 /* Clear the part of the screen image that are not covered by
9035 the image from the GIF file. Full animated GIF support
9036 requires more than can be done here (see the gif89 spec,
9037 disposal methods). Let's simply assume that the part
9038 not covered by a sub-image is in the frame's background color. */
9039 image_top
= gif
->SavedImages
[ino
].ImageDesc
.Top
;
9040 image_left
= gif
->SavedImages
[ino
].ImageDesc
.Left
;
9041 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
9042 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
9044 for (y
= 0; y
< image_top
; ++y
)
9045 for (x
= 0; x
< width
; ++x
)
9046 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
9048 for (y
= image_top
+ image_height
; y
< height
; ++y
)
9049 for (x
= 0; x
< width
; ++x
)
9050 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
9052 for (y
= image_top
; y
< image_top
+ image_height
; ++y
)
9054 for (x
= 0; x
< image_left
; ++x
)
9055 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
9056 for (x
= image_left
+ image_width
; x
< width
; ++x
)
9057 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
9060 /* Read the GIF image into the X image. We use a local variable
9061 `raster' here because RasterBits below is a char *, and invites
9062 problems with bytes >= 0x80. */
9063 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
9065 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
9067 static int interlace_start
[] = {0, 4, 2, 1};
9068 static int interlace_increment
[] = {8, 8, 4, 2};
9070 int row
= interlace_start
[0];
9074 for (y
= 0; y
< image_height
; y
++)
9076 if (row
>= image_height
)
9078 row
= interlace_start
[++pass
];
9079 while (row
>= image_height
)
9080 row
= interlace_start
[++pass
];
9083 for (x
= 0; x
< image_width
; x
++)
9085 int i
= raster
[(y
* image_width
) + x
];
9086 XPutPixel (ximg
, x
+ image_left
, row
+ image_top
,
9090 row
+= interlace_increment
[pass
];
9095 for (y
= 0; y
< image_height
; ++y
)
9096 for (x
= 0; x
< image_width
; ++x
)
9098 int i
= raster
[y
* image_width
+ x
];
9099 XPutPixel (ximg
, x
+ image_left
, y
+ image_top
, pixel_colors
[i
]);
9103 DGifCloseFile (gif
);
9105 /* Maybe fill in the background field while we have ximg handy. */
9106 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
9107 IMAGE_BACKGROUND (img
, f
, ximg
);
9109 /* Put the image into the pixmap, then free the X image and its buffer. */
9110 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
9111 x_destroy_x_image (ximg
);
9117 #endif /* HAVE_GIF != 0 */
9121 /***********************************************************************
9123 ***********************************************************************/
9125 static int gs_image_p
P_ ((Lisp_Object object
));
9126 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
9127 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
9129 /* The symbol `postscript' identifying images of this type. */
9131 Lisp_Object Qpostscript
;
9133 /* Keyword symbols. */
9135 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
9137 /* Indices of image specification fields in gs_format, below. */
9139 enum gs_keyword_index
9157 /* Vector of image_keyword structures describing the format
9158 of valid user-defined image specifications. */
9160 static struct image_keyword gs_format
[GS_LAST
] =
9162 {":type", IMAGE_SYMBOL_VALUE
, 1},
9163 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
9164 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
9165 {":file", IMAGE_STRING_VALUE
, 1},
9166 {":loader", IMAGE_FUNCTION_VALUE
, 0},
9167 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
9168 {":ascent", IMAGE_ASCENT_VALUE
, 0},
9169 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
9170 {":relief", IMAGE_INTEGER_VALUE
, 0},
9171 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9172 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9173 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9174 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
9177 /* Structure describing the image type `ghostscript'. */
9179 static struct image_type gs_type
=
9189 /* Free X resources of Ghostscript image IMG which is used on frame F. */
9192 gs_clear_image (f
, img
)
9196 /* IMG->data.ptr_val may contain a recorded colormap. */
9197 xfree (img
->data
.ptr_val
);
9198 x_clear_image (f
, img
);
9202 /* Return non-zero if OBJECT is a valid Ghostscript image
9209 struct image_keyword fmt
[GS_LAST
];
9213 bcopy (gs_format
, fmt
, sizeof fmt
);
9215 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
9218 /* Bounding box must be a list or vector containing 4 integers. */
9219 tem
= fmt
[GS_BOUNDING_BOX
].value
;
9222 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
9223 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
9228 else if (VECTORP (tem
))
9230 if (XVECTOR (tem
)->size
!= 4)
9232 for (i
= 0; i
< 4; ++i
)
9233 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
9243 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
9252 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
9253 struct gcpro gcpro1
, gcpro2
;
9255 double in_width
, in_height
;
9256 Lisp_Object pixel_colors
= Qnil
;
9258 /* Compute pixel size of pixmap needed from the given size in the
9259 image specification. Sizes in the specification are in pt. 1 pt
9260 = 1/72 in, xdpi and ydpi are stored in the frame's X display
9262 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
9263 in_width
= XFASTINT (pt_width
) / 72.0;
9264 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
9265 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
9266 in_height
= XFASTINT (pt_height
) / 72.0;
9267 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
9269 /* Create the pixmap. */
9270 xassert (img
->pixmap
== None
);
9271 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9272 img
->width
, img
->height
,
9273 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
9277 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
9281 /* Call the loader to fill the pixmap. It returns a process object
9282 if successful. We do not record_unwind_protect here because
9283 other places in redisplay like calling window scroll functions
9284 don't either. Let the Lisp loader use `unwind-protect' instead. */
9285 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
9287 sprintf (buffer
, "%lu %lu",
9288 (unsigned long) FRAME_X_WINDOW (f
),
9289 (unsigned long) img
->pixmap
);
9290 window_and_pixmap_id
= build_string (buffer
);
9292 sprintf (buffer
, "%lu %lu",
9293 FRAME_FOREGROUND_PIXEL (f
),
9294 FRAME_BACKGROUND_PIXEL (f
));
9295 pixel_colors
= build_string (buffer
);
9297 XSETFRAME (frame
, f
);
9298 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
9300 loader
= intern ("gs-load-image");
9302 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
9303 make_number (img
->width
),
9304 make_number (img
->height
),
9305 window_and_pixmap_id
,
9308 return PROCESSP (img
->data
.lisp_val
);
9312 /* Kill the Ghostscript process that was started to fill PIXMAP on
9313 frame F. Called from XTread_socket when receiving an event
9314 telling Emacs that Ghostscript has finished drawing. */
9317 x_kill_gs_process (pixmap
, f
)
9321 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
9325 /* Find the image containing PIXMAP. */
9326 for (i
= 0; i
< c
->used
; ++i
)
9327 if (c
->images
[i
]->pixmap
== pixmap
)
9330 /* Should someone in between have cleared the image cache, for
9331 instance, give up. */
9335 /* Kill the GS process. We should have found PIXMAP in the image
9336 cache and its image should contain a process object. */
9338 xassert (PROCESSP (img
->data
.lisp_val
));
9339 Fkill_process (img
->data
.lisp_val
, Qnil
);
9340 img
->data
.lisp_val
= Qnil
;
9342 /* On displays with a mutable colormap, figure out the colors
9343 allocated for the image by looking at the pixels of an XImage for
9345 class = FRAME_X_VISUAL (f
)->class;
9346 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
9352 /* Try to get an XImage for img->pixmep. */
9353 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
9354 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
9359 /* Initialize the color table. */
9360 init_color_table ();
9362 /* For each pixel of the image, look its color up in the
9363 color table. After having done so, the color table will
9364 contain an entry for each color used by the image. */
9365 for (y
= 0; y
< img
->height
; ++y
)
9366 for (x
= 0; x
< img
->width
; ++x
)
9368 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
9369 lookup_pixel_color (f
, pixel
);
9372 /* Record colors in the image. Free color table and XImage. */
9373 img
->colors
= colors_in_color_table (&img
->ncolors
);
9374 free_color_table ();
9375 XDestroyImage (ximg
);
9377 #if 0 /* This doesn't seem to be the case. If we free the colors
9378 here, we get a BadAccess later in x_clear_image when
9379 freeing the colors. */
9380 /* We have allocated colors once, but Ghostscript has also
9381 allocated colors on behalf of us. So, to get the
9382 reference counts right, free them once. */
9384 x_free_colors (f
, img
->colors
, img
->ncolors
);
9388 image_error ("Cannot get X image of `%s'; colors will not be freed",
9394 /* Now that we have the pixmap, compute mask and transform the
9395 image if requested. */
9397 postprocess_image (f
, img
);
9403 /***********************************************************************
9405 ***********************************************************************/
9407 DEFUN ("x-change-window-property", Fx_change_window_property
,
9408 Sx_change_window_property
, 2, 3, 0,
9409 doc
: /* Change window property PROP to VALUE on the X window of FRAME.
9410 PROP and VALUE must be strings. FRAME nil or omitted means use the
9411 selected frame. Value is VALUE. */)
9412 (prop
, value
, frame
)
9413 Lisp_Object frame
, prop
, value
;
9415 struct frame
*f
= check_x_frame (frame
);
9418 CHECK_STRING (prop
);
9419 CHECK_STRING (value
);
9422 prop_atom
= XInternAtom (FRAME_X_DISPLAY (f
), SDATA (prop
), False
);
9423 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9424 prop_atom
, XA_STRING
, 8, PropModeReplace
,
9425 SDATA (value
), SCHARS (value
));
9427 /* Make sure the property is set when we return. */
9428 XFlush (FRAME_X_DISPLAY (f
));
9435 DEFUN ("x-delete-window-property", Fx_delete_window_property
,
9436 Sx_delete_window_property
, 1, 2, 0,
9437 doc
: /* Remove window property PROP from X window of FRAME.
9438 FRAME nil or omitted means use the selected frame. Value is PROP. */)
9440 Lisp_Object prop
, frame
;
9442 struct frame
*f
= check_x_frame (frame
);
9445 CHECK_STRING (prop
);
9447 prop_atom
= XInternAtom (FRAME_X_DISPLAY (f
), SDATA (prop
), False
);
9448 XDeleteProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), prop_atom
);
9450 /* Make sure the property is removed when we return. */
9451 XFlush (FRAME_X_DISPLAY (f
));
9458 DEFUN ("x-window-property", Fx_window_property
, Sx_window_property
,
9460 doc
: /* Value is the value of window property PROP on FRAME.
9461 If FRAME is nil or omitted, use the selected frame. Value is nil
9462 if FRAME hasn't a property with name PROP or if PROP has no string
9465 Lisp_Object prop
, frame
;
9467 struct frame
*f
= check_x_frame (frame
);
9470 Lisp_Object prop_value
= Qnil
;
9471 char *tmp_data
= NULL
;
9474 unsigned long actual_size
, bytes_remaining
;
9476 CHECK_STRING (prop
);
9478 prop_atom
= XInternAtom (FRAME_X_DISPLAY (f
), SDATA (prop
), False
);
9479 rc
= XGetWindowProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9480 prop_atom
, 0, 0, False
, XA_STRING
,
9481 &actual_type
, &actual_format
, &actual_size
,
9482 &bytes_remaining
, (unsigned char **) &tmp_data
);
9485 int size
= bytes_remaining
;
9490 rc
= XGetWindowProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9491 prop_atom
, 0, bytes_remaining
,
9493 &actual_type
, &actual_format
,
9494 &actual_size
, &bytes_remaining
,
9495 (unsigned char **) &tmp_data
);
9496 if (rc
== Success
&& tmp_data
)
9497 prop_value
= make_string (tmp_data
, size
);
9508 /***********************************************************************
9510 ***********************************************************************/
9512 /* If non-null, an asynchronous timer that, when it expires, displays
9513 an hourglass cursor on all frames. */
9515 static struct atimer
*hourglass_atimer
;
9517 /* Non-zero means an hourglass cursor is currently shown. */
9519 static int hourglass_shown_p
;
9521 /* Number of seconds to wait before displaying an hourglass cursor. */
9523 static Lisp_Object Vhourglass_delay
;
9525 /* Default number of seconds to wait before displaying an hourglass
9528 #define DEFAULT_HOURGLASS_DELAY 1
9530 /* Function prototypes. */
9532 static void show_hourglass
P_ ((struct atimer
*));
9533 static void hide_hourglass
P_ ((void));
9536 /* Cancel a currently active hourglass timer, and start a new one. */
9542 int secs
, usecs
= 0;
9544 cancel_hourglass ();
9546 if (INTEGERP (Vhourglass_delay
)
9547 && XINT (Vhourglass_delay
) > 0)
9548 secs
= XFASTINT (Vhourglass_delay
);
9549 else if (FLOATP (Vhourglass_delay
)
9550 && XFLOAT_DATA (Vhourglass_delay
) > 0)
9553 tem
= Ftruncate (Vhourglass_delay
, Qnil
);
9554 secs
= XFASTINT (tem
);
9555 usecs
= (XFLOAT_DATA (Vhourglass_delay
) - secs
) * 1000000;
9558 secs
= DEFAULT_HOURGLASS_DELAY
;
9560 EMACS_SET_SECS_USECS (delay
, secs
, usecs
);
9561 hourglass_atimer
= start_atimer (ATIMER_RELATIVE
, delay
,
9562 show_hourglass
, NULL
);
9566 /* Cancel the hourglass cursor timer if active, hide a busy cursor if
9572 if (hourglass_atimer
)
9574 cancel_atimer (hourglass_atimer
);
9575 hourglass_atimer
= NULL
;
9578 if (hourglass_shown_p
)
9583 /* Timer function of hourglass_atimer. TIMER is equal to
9586 Display an hourglass pointer on all frames by mapping the frames'
9587 hourglass_window. Set the hourglass_p flag in the frames'
9588 output_data.x structure to indicate that an hourglass cursor is
9589 shown on the frames. */
9592 show_hourglass (timer
)
9593 struct atimer
*timer
;
9595 /* The timer implementation will cancel this timer automatically
9596 after this function has run. Set hourglass_atimer to null
9597 so that we know the timer doesn't have to be canceled. */
9598 hourglass_atimer
= NULL
;
9600 if (!hourglass_shown_p
)
9602 Lisp_Object rest
, frame
;
9606 FOR_EACH_FRAME (rest
, frame
)
9608 struct frame
*f
= XFRAME (frame
);
9610 if (FRAME_LIVE_P (f
) && FRAME_X_P (f
) && FRAME_X_DISPLAY (f
))
9612 Display
*dpy
= FRAME_X_DISPLAY (f
);
9614 #ifdef USE_X_TOOLKIT
9615 if (f
->output_data
.x
->widget
)
9617 if (FRAME_OUTER_WINDOW (f
))
9620 f
->output_data
.x
->hourglass_p
= 1;
9622 if (!f
->output_data
.x
->hourglass_window
)
9624 unsigned long mask
= CWCursor
;
9625 XSetWindowAttributes attrs
;
9627 attrs
.cursor
= f
->output_data
.x
->hourglass_cursor
;
9629 f
->output_data
.x
->hourglass_window
9630 = XCreateWindow (dpy
, FRAME_OUTER_WINDOW (f
),
9631 0, 0, 32000, 32000, 0, 0,
9637 XMapRaised (dpy
, f
->output_data
.x
->hourglass_window
);
9643 hourglass_shown_p
= 1;
9649 /* Hide the hourglass pointer on all frames, if it is currently
9655 if (hourglass_shown_p
)
9657 Lisp_Object rest
, frame
;
9660 FOR_EACH_FRAME (rest
, frame
)
9662 struct frame
*f
= XFRAME (frame
);
9665 /* Watch out for newly created frames. */
9666 && f
->output_data
.x
->hourglass_window
)
9668 XUnmapWindow (FRAME_X_DISPLAY (f
),
9669 f
->output_data
.x
->hourglass_window
);
9670 /* Sync here because XTread_socket looks at the
9671 hourglass_p flag that is reset to zero below. */
9672 XSync (FRAME_X_DISPLAY (f
), False
);
9673 f
->output_data
.x
->hourglass_p
= 0;
9677 hourglass_shown_p
= 0;
9684 /***********************************************************************
9686 ***********************************************************************/
9688 static Lisp_Object x_create_tip_frame
P_ ((struct x_display_info
*,
9689 Lisp_Object
, Lisp_Object
));
9690 static void compute_tip_xy
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
,
9691 Lisp_Object
, int, int, int *, int *));
9693 /* The frame of a currently visible tooltip. */
9695 Lisp_Object tip_frame
;
9697 /* If non-nil, a timer started that hides the last tooltip when it
9700 Lisp_Object tip_timer
;
9703 /* If non-nil, a vector of 3 elements containing the last args
9704 with which x-show-tip was called. See there. */
9706 Lisp_Object last_show_tip_args
;
9708 /* Maximum size for tooltips; a cons (COLUMNS . ROWS). */
9710 Lisp_Object Vx_max_tooltip_size
;
9714 unwind_create_tip_frame (frame
)
9717 Lisp_Object deleted
;
9719 deleted
= unwind_create_frame (frame
);
9720 if (EQ (deleted
, Qt
))
9730 /* Create a frame for a tooltip on the display described by DPYINFO.
9731 PARMS is a list of frame parameters. TEXT is the string to
9732 display in the tip frame. Value is the frame.
9734 Note that functions called here, esp. x_default_parameter can
9735 signal errors, for instance when a specified color name is
9736 undefined. We have to make sure that we're in a consistent state
9737 when this happens. */
9740 x_create_tip_frame (dpyinfo
, parms
, text
)
9741 struct x_display_info
*dpyinfo
;
9742 Lisp_Object parms
, text
;
9745 Lisp_Object frame
, tem
;
9747 long window_prompting
= 0;
9749 int count
= SPECPDL_INDEX ();
9750 struct gcpro gcpro1
, gcpro2
, gcpro3
;
9752 int face_change_count_before
= face_change_count
;
9754 struct buffer
*old_buffer
;
9758 /* Use this general default value to start with until we know if
9759 this frame has a specified name. */
9760 Vx_resource_name
= Vinvocation_name
;
9763 kb
= dpyinfo
->kboard
;
9765 kb
= &the_only_kboard
;
9768 /* Get the name of the frame to use for resource lookup. */
9769 name
= x_get_arg (dpyinfo
, parms
, Qname
, "name", "Name", RES_TYPE_STRING
);
9771 && !EQ (name
, Qunbound
)
9773 error ("Invalid frame name--not a string or nil");
9774 Vx_resource_name
= name
;
9777 GCPRO3 (parms
, name
, frame
);
9779 XSETFRAME (frame
, f
);
9781 buffer
= Fget_buffer_create (build_string (" *tip*"));
9782 Fset_window_buffer (FRAME_ROOT_WINDOW (f
), buffer
, Qnil
);
9783 old_buffer
= current_buffer
;
9784 set_buffer_internal_1 (XBUFFER (buffer
));
9785 current_buffer
->truncate_lines
= Qnil
;
9788 set_buffer_internal_1 (old_buffer
);
9790 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 0;
9791 record_unwind_protect (unwind_create_tip_frame
, frame
);
9793 /* By setting the output method, we're essentially saying that
9794 the frame is live, as per FRAME_LIVE_P. If we get a signal
9795 from this point on, x_destroy_window might screw up reference
9797 f
->output_method
= output_x_window
;
9798 f
->output_data
.x
= (struct x_output
*) xmalloc (sizeof (struct x_output
));
9799 bzero (f
->output_data
.x
, sizeof (struct x_output
));
9800 f
->output_data
.x
->icon_bitmap
= -1;
9801 FRAME_FONTSET (f
) = -1;
9802 f
->output_data
.x
->scroll_bar_foreground_pixel
= -1;
9803 f
->output_data
.x
->scroll_bar_background_pixel
= -1;
9804 #ifdef USE_TOOLKIT_SCROLL_BARS
9805 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= -1;
9806 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= -1;
9807 #endif /* USE_TOOLKIT_SCROLL_BARS */
9808 f
->icon_name
= Qnil
;
9809 FRAME_X_DISPLAY_INFO (f
) = dpyinfo
;
9811 image_cache_refcount
= FRAME_X_IMAGE_CACHE (f
)->refcount
;
9812 dpyinfo_refcount
= dpyinfo
->reference_count
;
9813 #endif /* GLYPH_DEBUG */
9815 FRAME_KBOARD (f
) = kb
;
9817 f
->output_data
.x
->parent_desc
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
9818 f
->output_data
.x
->explicit_parent
= 0;
9820 /* These colors will be set anyway later, but it's important
9821 to get the color reference counts right, so initialize them! */
9824 struct gcpro gcpro1
;
9826 black
= build_string ("black");
9828 f
->output_data
.x
->foreground_pixel
9829 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
9830 f
->output_data
.x
->background_pixel
9831 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
9832 f
->output_data
.x
->cursor_pixel
9833 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
9834 f
->output_data
.x
->cursor_foreground_pixel
9835 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
9836 f
->output_data
.x
->border_pixel
9837 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
9838 f
->output_data
.x
->mouse_pixel
9839 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
9843 /* Set the name; the functions to which we pass f expect the name to
9845 if (EQ (name
, Qunbound
) || NILP (name
))
9847 f
->name
= build_string (dpyinfo
->x_id_name
);
9848 f
->explicit_name
= 0;
9853 f
->explicit_name
= 1;
9854 /* use the frame's title when getting resources for this frame. */
9855 specbind (Qx_resource_name
, name
);
9858 /* Extract the window parameters from the supplied values that are
9859 needed to determine window geometry. */
9863 font
= x_get_arg (dpyinfo
, parms
, Qfont
, "font", "Font", RES_TYPE_STRING
);
9866 /* First, try whatever font the caller has specified. */
9869 tem
= Fquery_fontset (font
, Qnil
);
9871 font
= x_new_fontset (f
, tem
);
9873 font
= x_new_font (f
, SDATA (font
));
9876 /* Try out a font which we hope has bold and italic variations. */
9877 if (!STRINGP (font
))
9878 font
= x_new_font (f
, "-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1");
9879 if (!STRINGP (font
))
9880 font
= x_new_font (f
, "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
9881 if (! STRINGP (font
))
9882 font
= x_new_font (f
, "-*-*-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
9883 if (! STRINGP (font
))
9884 /* This was formerly the first thing tried, but it finds too many fonts
9885 and takes too long. */
9886 font
= x_new_font (f
, "-*-*-medium-r-*-*-*-*-*-*-c-*-iso8859-1");
9887 /* If those didn't work, look for something which will at least work. */
9888 if (! STRINGP (font
))
9889 font
= x_new_font (f
, "-*-fixed-*-*-*-*-*-140-*-*-c-*-iso8859-1");
9891 if (! STRINGP (font
))
9892 font
= build_string ("fixed");
9894 x_default_parameter (f
, parms
, Qfont
, font
,
9895 "font", "Font", RES_TYPE_STRING
);
9898 x_default_parameter (f
, parms
, Qborder_width
, make_number (2),
9899 "borderWidth", "BorderWidth", RES_TYPE_NUMBER
);
9901 /* This defaults to 2 in order to match xterm. We recognize either
9902 internalBorderWidth or internalBorder (which is what xterm calls
9904 if (NILP (Fassq (Qinternal_border_width
, parms
)))
9908 value
= x_get_arg (dpyinfo
, parms
, Qinternal_border_width
,
9909 "internalBorder", "internalBorder", RES_TYPE_NUMBER
);
9910 if (! EQ (value
, Qunbound
))
9911 parms
= Fcons (Fcons (Qinternal_border_width
, value
),
9915 x_default_parameter (f
, parms
, Qinternal_border_width
, make_number (1),
9916 "internalBorderWidth", "internalBorderWidth",
9919 /* Also do the stuff which must be set before the window exists. */
9920 x_default_parameter (f
, parms
, Qforeground_color
, build_string ("black"),
9921 "foreground", "Foreground", RES_TYPE_STRING
);
9922 x_default_parameter (f
, parms
, Qbackground_color
, build_string ("white"),
9923 "background", "Background", RES_TYPE_STRING
);
9924 x_default_parameter (f
, parms
, Qmouse_color
, build_string ("black"),
9925 "pointerColor", "Foreground", RES_TYPE_STRING
);
9926 x_default_parameter (f
, parms
, Qcursor_color
, build_string ("black"),
9927 "cursorColor", "Foreground", RES_TYPE_STRING
);
9928 x_default_parameter (f
, parms
, Qborder_color
, build_string ("black"),
9929 "borderColor", "BorderColor", RES_TYPE_STRING
);
9931 /* Init faces before x_default_parameter is called for scroll-bar
9932 parameters because that function calls x_set_scroll_bar_width,
9933 which calls change_frame_size, which calls Fset_window_buffer,
9934 which runs hooks, which call Fvertical_motion. At the end, we
9935 end up in init_iterator with a null face cache, which should not
9937 init_frame_faces (f
);
9939 f
->output_data
.x
->parent_desc
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
9941 window_prompting
= x_figure_window_size (f
, parms
, 0);
9944 XSetWindowAttributes attrs
;
9948 mask
= CWBackPixel
| CWOverrideRedirect
| CWEventMask
;
9949 if (DoesSaveUnders (dpyinfo
->screen
))
9950 mask
|= CWSaveUnder
;
9952 /* Window managers look at the override-redirect flag to determine
9953 whether or net to give windows a decoration (Xlib spec, chapter
9955 attrs
.override_redirect
= True
;
9956 attrs
.save_under
= True
;
9957 attrs
.background_pixel
= FRAME_BACKGROUND_PIXEL (f
);
9958 /* Arrange for getting MapNotify and UnmapNotify events. */
9959 attrs
.event_mask
= StructureNotifyMask
;
9961 = FRAME_X_WINDOW (f
)
9962 = XCreateWindow (FRAME_X_DISPLAY (f
),
9963 FRAME_X_DISPLAY_INFO (f
)->root_window
,
9964 /* x, y, width, height */
9968 CopyFromParent
, InputOutput
, CopyFromParent
,
9975 x_default_parameter (f
, parms
, Qauto_raise
, Qnil
,
9976 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
9977 x_default_parameter (f
, parms
, Qauto_lower
, Qnil
,
9978 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
9979 x_default_parameter (f
, parms
, Qcursor_type
, Qbox
,
9980 "cursorType", "CursorType", RES_TYPE_SYMBOL
);
9982 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
9983 Change will not be effected unless different from the current
9985 width
= FRAME_COLS (f
);
9986 height
= FRAME_LINES (f
);
9987 SET_FRAME_COLS (f
, 0);
9988 FRAME_LINES (f
) = 0;
9989 change_frame_size (f
, height
, width
, 1, 0, 0);
9991 /* Add `tooltip' frame parameter's default value. */
9992 if (NILP (Fframe_parameter (frame
, intern ("tooltip"))))
9993 Fmodify_frame_parameters (frame
, Fcons (Fcons (intern ("tooltip"), Qt
),
9996 /* Set up faces after all frame parameters are known. This call
9997 also merges in face attributes specified for new frames.
9999 Frame parameters may be changed if .Xdefaults contains
10000 specifications for the default font. For example, if there is an
10001 `Emacs.default.attributeBackground: pink', the `background-color'
10002 attribute of the frame get's set, which let's the internal border
10003 of the tooltip frame appear in pink. Prevent this. */
10005 Lisp_Object bg
= Fframe_parameter (frame
, Qbackground_color
);
10007 /* Set tip_frame here, so that */
10009 call1 (Qface_set_after_frame_default
, frame
);
10011 if (!EQ (bg
, Fframe_parameter (frame
, Qbackground_color
)))
10012 Fmodify_frame_parameters (frame
, Fcons (Fcons (Qbackground_color
, bg
),
10020 /* It is now ok to make the frame official even if we get an error
10021 below. And the frame needs to be on Vframe_list or making it
10022 visible won't work. */
10023 Vframe_list
= Fcons (frame
, Vframe_list
);
10025 /* Now that the frame is official, it counts as a reference to
10027 FRAME_X_DISPLAY_INFO (f
)->reference_count
++;
10029 /* Setting attributes of faces of the tooltip frame from resources
10030 and similar will increment face_change_count, which leads to the
10031 clearing of all current matrices. Since this isn't necessary
10032 here, avoid it by resetting face_change_count to the value it
10033 had before we created the tip frame. */
10034 face_change_count
= face_change_count_before
;
10036 /* Discard the unwind_protect. */
10037 return unbind_to (count
, frame
);
10041 /* Compute where to display tip frame F. PARMS is the list of frame
10042 parameters for F. DX and DY are specified offsets from the current
10043 location of the mouse. WIDTH and HEIGHT are the width and height
10044 of the tooltip. Return coordinates relative to the root window of
10045 the display in *ROOT_X, and *ROOT_Y. */
10048 compute_tip_xy (f
, parms
, dx
, dy
, width
, height
, root_x
, root_y
)
10050 Lisp_Object parms
, dx
, dy
;
10052 int *root_x
, *root_y
;
10054 Lisp_Object left
, top
;
10056 Window root
, child
;
10059 /* User-specified position? */
10060 left
= Fcdr (Fassq (Qleft
, parms
));
10061 top
= Fcdr (Fassq (Qtop
, parms
));
10063 /* Move the tooltip window where the mouse pointer is. Resize and
10065 if (!INTEGERP (left
) || !INTEGERP (top
))
10068 XQueryPointer (FRAME_X_DISPLAY (f
), FRAME_X_DISPLAY_INFO (f
)->root_window
,
10069 &root
, &child
, root_x
, root_y
, &win_x
, &win_y
, &pmask
);
10073 if (INTEGERP (top
))
10074 *root_y
= XINT (top
);
10075 else if (*root_y
+ XINT (dy
) - height
< 0)
10076 *root_y
-= XINT (dy
);
10080 *root_y
+= XINT (dy
);
10083 if (INTEGERP (left
))
10084 *root_x
= XINT (left
);
10085 else if (*root_x
+ XINT (dx
) + width
<= FRAME_X_DISPLAY_INFO (f
)->width
)
10086 /* It fits to the right of the pointer. */
10087 *root_x
+= XINT (dx
);
10088 else if (width
+ XINT (dx
) <= *root_x
)
10089 /* It fits to the left of the pointer. */
10090 *root_x
-= width
+ XINT (dx
);
10092 /* Put it left-justified on the screen--it ought to fit that way. */
10097 DEFUN ("x-show-tip", Fx_show_tip
, Sx_show_tip
, 1, 6, 0,
10098 doc
: /* Show STRING in a "tooltip" window on frame FRAME.
10099 A tooltip window is a small X window displaying a string.
10101 FRAME nil or omitted means use the selected frame.
10103 PARMS is an optional list of frame parameters which can be used to
10104 change the tooltip's appearance.
10106 Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
10107 means use the default timeout of 5 seconds.
10109 If the list of frame parameters PARAMS contains a `left' parameters,
10110 the tooltip is displayed at that x-position. Otherwise it is
10111 displayed at the mouse position, with offset DX added (default is 5 if
10112 DX isn't specified). Likewise for the y-position; if a `top' frame
10113 parameter is specified, it determines the y-position of the tooltip
10114 window, otherwise it is displayed at the mouse position, with offset
10115 DY added (default is -10).
10117 A tooltip's maximum size is specified by `x-max-tooltip-size'.
10118 Text larger than the specified size is clipped. */)
10119 (string
, frame
, parms
, timeout
, dx
, dy
)
10120 Lisp_Object string
, frame
, parms
, timeout
, dx
, dy
;
10124 int root_x
, root_y
;
10125 struct buffer
*old_buffer
;
10126 struct text_pos pos
;
10127 int i
, width
, height
;
10128 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
10129 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
10130 int count
= SPECPDL_INDEX ();
10132 specbind (Qinhibit_redisplay
, Qt
);
10134 GCPRO4 (string
, parms
, frame
, timeout
);
10136 CHECK_STRING (string
);
10137 f
= check_x_frame (frame
);
10138 if (NILP (timeout
))
10139 timeout
= make_number (5);
10141 CHECK_NATNUM (timeout
);
10144 dx
= make_number (5);
10149 dy
= make_number (-10);
10153 if (NILP (last_show_tip_args
))
10154 last_show_tip_args
= Fmake_vector (make_number (3), Qnil
);
10156 if (!NILP (tip_frame
))
10158 Lisp_Object last_string
= AREF (last_show_tip_args
, 0);
10159 Lisp_Object last_frame
= AREF (last_show_tip_args
, 1);
10160 Lisp_Object last_parms
= AREF (last_show_tip_args
, 2);
10162 if (EQ (frame
, last_frame
)
10163 && !NILP (Fequal (last_string
, string
))
10164 && !NILP (Fequal (last_parms
, parms
)))
10166 struct frame
*f
= XFRAME (tip_frame
);
10168 /* Only DX and DY have changed. */
10169 if (!NILP (tip_timer
))
10171 Lisp_Object timer
= tip_timer
;
10173 call1 (Qcancel_timer
, timer
);
10177 compute_tip_xy (f
, parms
, dx
, dy
, FRAME_PIXEL_WIDTH (f
),
10178 FRAME_PIXEL_HEIGHT (f
), &root_x
, &root_y
);
10179 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
10186 /* Hide a previous tip, if any. */
10189 ASET (last_show_tip_args
, 0, string
);
10190 ASET (last_show_tip_args
, 1, frame
);
10191 ASET (last_show_tip_args
, 2, parms
);
10193 /* Add default values to frame parameters. */
10194 if (NILP (Fassq (Qname
, parms
)))
10195 parms
= Fcons (Fcons (Qname
, build_string ("tooltip")), parms
);
10196 if (NILP (Fassq (Qinternal_border_width
, parms
)))
10197 parms
= Fcons (Fcons (Qinternal_border_width
, make_number (3)), parms
);
10198 if (NILP (Fassq (Qborder_width
, parms
)))
10199 parms
= Fcons (Fcons (Qborder_width
, make_number (1)), parms
);
10200 if (NILP (Fassq (Qborder_color
, parms
)))
10201 parms
= Fcons (Fcons (Qborder_color
, build_string ("lightyellow")), parms
);
10202 if (NILP (Fassq (Qbackground_color
, parms
)))
10203 parms
= Fcons (Fcons (Qbackground_color
, build_string ("lightyellow")),
10206 /* Create a frame for the tooltip, and record it in the global
10207 variable tip_frame. */
10208 frame
= x_create_tip_frame (FRAME_X_DISPLAY_INFO (f
), parms
, string
);
10209 f
= XFRAME (frame
);
10211 /* Set up the frame's root window. */
10212 w
= XWINDOW (FRAME_ROOT_WINDOW (f
));
10213 w
->left_col
= w
->top_line
= make_number (0);
10215 if (CONSP (Vx_max_tooltip_size
)
10216 && INTEGERP (XCAR (Vx_max_tooltip_size
))
10217 && XINT (XCAR (Vx_max_tooltip_size
)) > 0
10218 && INTEGERP (XCDR (Vx_max_tooltip_size
))
10219 && XINT (XCDR (Vx_max_tooltip_size
)) > 0)
10221 w
->total_cols
= XCAR (Vx_max_tooltip_size
);
10222 w
->total_lines
= XCDR (Vx_max_tooltip_size
);
10226 w
->total_cols
= make_number (80);
10227 w
->total_lines
= make_number (40);
10230 FRAME_TOTAL_COLS (f
) = XINT (w
->total_cols
);
10232 w
->pseudo_window_p
= 1;
10234 /* Display the tooltip text in a temporary buffer. */
10235 old_buffer
= current_buffer
;
10236 set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f
))->buffer
));
10237 current_buffer
->truncate_lines
= Qnil
;
10238 clear_glyph_matrix (w
->desired_matrix
);
10239 clear_glyph_matrix (w
->current_matrix
);
10240 SET_TEXT_POS (pos
, BEGV
, BEGV_BYTE
);
10241 try_window (FRAME_ROOT_WINDOW (f
), pos
);
10243 /* Compute width and height of the tooltip. */
10244 width
= height
= 0;
10245 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
10247 struct glyph_row
*row
= &w
->desired_matrix
->rows
[i
];
10248 struct glyph
*last
;
10251 /* Stop at the first empty row at the end. */
10252 if (!row
->enabled_p
|| !row
->displays_text_p
)
10255 /* Let the row go over the full width of the frame. */
10256 row
->full_width_p
= 1;
10258 /* There's a glyph at the end of rows that is used to place
10259 the cursor there. Don't include the width of this glyph. */
10260 if (row
->used
[TEXT_AREA
])
10262 last
= &row
->glyphs
[TEXT_AREA
][row
->used
[TEXT_AREA
] - 1];
10263 row_width
= row
->pixel_width
- last
->pixel_width
;
10266 row_width
= row
->pixel_width
;
10268 height
+= row
->height
;
10269 width
= max (width
, row_width
);
10272 /* Add the frame's internal border to the width and height the X
10273 window should have. */
10274 height
+= 2 * FRAME_INTERNAL_BORDER_WIDTH (f
);
10275 width
+= 2 * FRAME_INTERNAL_BORDER_WIDTH (f
);
10277 /* Move the tooltip window where the mouse pointer is. Resize and
10279 compute_tip_xy (f
, parms
, dx
, dy
, width
, height
, &root_x
, &root_y
);
10282 XMoveResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
10283 root_x
, root_y
, width
, height
);
10284 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10287 /* Draw into the window. */
10288 w
->must_be_updated_p
= 1;
10289 update_single_window (w
, 1);
10291 /* Restore original current buffer. */
10292 set_buffer_internal_1 (old_buffer
);
10293 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
10296 /* Let the tip disappear after timeout seconds. */
10297 tip_timer
= call3 (intern ("run-at-time"), timeout
, Qnil
,
10298 intern ("x-hide-tip"));
10301 return unbind_to (count
, Qnil
);
10305 DEFUN ("x-hide-tip", Fx_hide_tip
, Sx_hide_tip
, 0, 0, 0,
10306 doc
: /* Hide the current tooltip window, if there is any.
10307 Value is t if tooltip was open, nil otherwise. */)
10311 Lisp_Object deleted
, frame
, timer
;
10312 struct gcpro gcpro1
, gcpro2
;
10314 /* Return quickly if nothing to do. */
10315 if (NILP (tip_timer
) && NILP (tip_frame
))
10320 GCPRO2 (frame
, timer
);
10321 tip_frame
= tip_timer
= deleted
= Qnil
;
10323 count
= SPECPDL_INDEX ();
10324 specbind (Qinhibit_redisplay
, Qt
);
10325 specbind (Qinhibit_quit
, Qt
);
10328 call1 (Qcancel_timer
, timer
);
10330 if (FRAMEP (frame
))
10332 Fdelete_frame (frame
, Qnil
);
10336 /* Bloodcurdling hack alert: The Lucid menu bar widget's
10337 redisplay procedure is not called when a tip frame over menu
10338 items is unmapped. Redisplay the menu manually... */
10340 struct frame
*f
= SELECTED_FRAME ();
10341 Widget w
= f
->output_data
.x
->menubar_widget
;
10342 extern void xlwmenu_redisplay
P_ ((Widget
));
10344 if (!DoesSaveUnders (FRAME_X_DISPLAY_INFO (f
)->screen
)
10348 xlwmenu_redisplay (w
);
10352 #endif /* USE_LUCID */
10356 return unbind_to (count
, deleted
);
10361 /***********************************************************************
10362 File selection dialog
10363 ***********************************************************************/
10367 /* Callback for "OK" and "Cancel" on file selection dialog. */
10370 file_dialog_cb (widget
, client_data
, call_data
)
10372 XtPointer call_data
, client_data
;
10374 int *result
= (int *) client_data
;
10375 XmAnyCallbackStruct
*cb
= (XmAnyCallbackStruct
*) call_data
;
10376 *result
= cb
->reason
;
10380 /* Callback for unmapping a file selection dialog. This is used to
10381 capture the case where a dialog is closed via a window manager's
10382 closer button, for example. Using a XmNdestroyCallback didn't work
10386 file_dialog_unmap_cb (widget
, client_data
, call_data
)
10388 XtPointer call_data
, client_data
;
10390 int *result
= (int *) client_data
;
10391 *result
= XmCR_CANCEL
;
10395 DEFUN ("x-file-dialog", Fx_file_dialog
, Sx_file_dialog
, 2, 4, 0,
10396 doc
: /* Read file name, prompting with PROMPT in directory DIR.
10397 Use a file selection dialog.
10398 Select DEFAULT-FILENAME in the dialog's file selection box, if
10399 specified. Don't let the user enter a file name in the file
10400 selection dialog's entry field, if MUSTMATCH is non-nil. */)
10401 (prompt
, dir
, default_filename
, mustmatch
)
10402 Lisp_Object prompt
, dir
, default_filename
, mustmatch
;
10405 struct frame
*f
= SELECTED_FRAME ();
10406 Lisp_Object file
= Qnil
;
10407 Widget dialog
, text
, list
, help
;
10410 extern XtAppContext Xt_app_con
;
10411 XmString dir_xmstring
, pattern_xmstring
;
10412 int count
= SPECPDL_INDEX ();
10413 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
10415 GCPRO5 (prompt
, dir
, default_filename
, mustmatch
, file
);
10416 CHECK_STRING (prompt
);
10417 CHECK_STRING (dir
);
10419 /* Prevent redisplay. */
10420 specbind (Qinhibit_redisplay
, Qt
);
10424 /* Create the dialog with PROMPT as title, using DIR as initial
10425 directory and using "*" as pattern. */
10426 dir
= Fexpand_file_name (dir
, Qnil
);
10427 dir_xmstring
= XmStringCreateLocalized (SDATA (dir
));
10428 pattern_xmstring
= XmStringCreateLocalized ("*");
10430 XtSetArg (al
[ac
], XmNtitle
, SDATA (prompt
)); ++ac
;
10431 XtSetArg (al
[ac
], XmNdirectory
, dir_xmstring
); ++ac
;
10432 XtSetArg (al
[ac
], XmNpattern
, pattern_xmstring
); ++ac
;
10433 XtSetArg (al
[ac
], XmNresizePolicy
, XmRESIZE_GROW
); ++ac
;
10434 XtSetArg (al
[ac
], XmNdialogStyle
, XmDIALOG_APPLICATION_MODAL
); ++ac
;
10435 dialog
= XmCreateFileSelectionDialog (f
->output_data
.x
->widget
,
10437 XmStringFree (dir_xmstring
);
10438 XmStringFree (pattern_xmstring
);
10440 /* Add callbacks for OK and Cancel. */
10441 XtAddCallback (dialog
, XmNokCallback
, file_dialog_cb
,
10442 (XtPointer
) &result
);
10443 XtAddCallback (dialog
, XmNcancelCallback
, file_dialog_cb
,
10444 (XtPointer
) &result
);
10445 XtAddCallback (dialog
, XmNunmapCallback
, file_dialog_unmap_cb
,
10446 (XtPointer
) &result
);
10448 /* Disable the help button since we can't display help. */
10449 help
= XmFileSelectionBoxGetChild (dialog
, XmDIALOG_HELP_BUTTON
);
10450 XtSetSensitive (help
, False
);
10452 /* Mark OK button as default. */
10453 XtVaSetValues (XmFileSelectionBoxGetChild (dialog
, XmDIALOG_OK_BUTTON
),
10454 XmNshowAsDefault
, True
, NULL
);
10456 /* If MUSTMATCH is non-nil, disable the file entry field of the
10457 dialog, so that the user must select a file from the files list
10458 box. We can't remove it because we wouldn't have a way to get at
10459 the result file name, then. */
10460 text
= XmFileSelectionBoxGetChild (dialog
, XmDIALOG_TEXT
);
10461 if (!NILP (mustmatch
))
10464 label
= XmFileSelectionBoxGetChild (dialog
, XmDIALOG_SELECTION_LABEL
);
10465 XtSetSensitive (text
, False
);
10466 XtSetSensitive (label
, False
);
10469 /* Manage the dialog, so that list boxes get filled. */
10470 XtManageChild (dialog
);
10472 /* Select DEFAULT_FILENAME in the files list box. DEFAULT_FILENAME
10473 must include the path for this to work. */
10474 list
= XmFileSelectionBoxGetChild (dialog
, XmDIALOG_LIST
);
10475 if (STRINGP (default_filename
))
10477 XmString default_xmstring
;
10481 = XmStringCreateLocalized (SDATA (default_filename
));
10483 if (!XmListItemExists (list
, default_xmstring
))
10485 /* Add a new item if DEFAULT_FILENAME is not in the list. */
10486 XmListAddItem (list
, default_xmstring
, 0);
10490 item_pos
= XmListItemPos (list
, default_xmstring
);
10491 XmStringFree (default_xmstring
);
10493 /* Select the item and scroll it into view. */
10494 XmListSelectPos (list
, item_pos
, True
);
10495 XmListSetPos (list
, item_pos
);
10498 /* Process events until the user presses Cancel or OK. */
10500 while (result
== 0)
10503 XtAppNextEvent (Xt_app_con
, &event
);
10504 (void) x_dispatch_event (&event
, FRAME_X_DISPLAY (f
) );
10507 /* Get the result. */
10508 if (result
== XmCR_OK
)
10513 XtVaGetValues (dialog
, XmNtextString
, &text
, NULL
);
10514 XmStringGetLtoR (text
, XmFONTLIST_DEFAULT_TAG
, &data
);
10515 XmStringFree (text
);
10516 file
= build_string (data
);
10523 XtUnmanageChild (dialog
);
10524 XtDestroyWidget (dialog
);
10528 /* Make "Cancel" equivalent to C-g. */
10530 Fsignal (Qquit
, Qnil
);
10532 return unbind_to (count
, file
);
10535 #endif /* USE_MOTIF */
10539 DEFUN ("x-file-dialog", Fx_file_dialog
, Sx_file_dialog
, 2, 4, 0,
10540 "Read file name, prompting with PROMPT in directory DIR.\n\
10541 Use a file selection dialog.\n\
10542 Select DEFAULT-FILENAME in the dialog's file selection box, if\n\
10543 specified. Don't let the user enter a file name in the file\n\
10544 selection dialog's entry field, if MUSTMATCH is non-nil.")
10545 (prompt
, dir
, default_filename
, mustmatch
)
10546 Lisp_Object prompt
, dir
, default_filename
, mustmatch
;
10548 FRAME_PTR f
= SELECTED_FRAME ();
10550 Lisp_Object file
= Qnil
;
10551 int count
= specpdl_ptr
- specpdl
;
10552 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
10556 GCPRO5 (prompt
, dir
, default_filename
, mustmatch
, file
);
10557 CHECK_STRING (prompt
);
10558 CHECK_STRING (dir
);
10560 /* Prevent redisplay. */
10561 specbind (Qinhibit_redisplay
, Qt
);
10565 if (STRINGP (default_filename
))
10566 cdef_file
= SDATA (default_filename
);
10568 cdef_file
= SDATA (dir
);
10570 fn
= xg_get_file_name (f
, SDATA (prompt
), cdef_file
, ! NILP (mustmatch
));
10574 file
= build_string (fn
);
10581 /* Make "Cancel" equivalent to C-g. */
10583 Fsignal (Qquit
, Qnil
);
10585 return unbind_to (count
, file
);
10588 #endif /* USE_GTK */
10591 /***********************************************************************
10593 ***********************************************************************/
10595 #ifdef HAVE_XKBGETKEYBOARD
10596 #include <X11/XKBlib.h>
10597 #include <X11/keysym.h>
10600 DEFUN ("x-backspace-delete-keys-p", Fx_backspace_delete_keys_p
,
10601 Sx_backspace_delete_keys_p
, 0, 1, 0,
10602 doc
: /* Check if both Backspace and Delete keys are on the keyboard of FRAME.
10603 FRAME nil means use the selected frame.
10604 Value is t if we know that both keys are present, and are mapped to the
10605 usual X keysyms. */)
10609 #ifdef HAVE_XKBGETKEYBOARD
10611 struct frame
*f
= check_x_frame (frame
);
10612 Display
*dpy
= FRAME_X_DISPLAY (f
);
10613 Lisp_Object have_keys
;
10614 int major
, minor
, op
, event
, error
;
10618 /* Check library version in case we're dynamically linked. */
10619 major
= XkbMajorVersion
;
10620 minor
= XkbMinorVersion
;
10621 if (!XkbLibraryVersion (&major
, &minor
))
10627 /* Check that the server supports XKB. */
10628 major
= XkbMajorVersion
;
10629 minor
= XkbMinorVersion
;
10630 if (!XkbQueryExtension (dpy
, &op
, &event
, &error
, &major
, &minor
))
10637 kb
= XkbGetMap (dpy
, XkbAllMapComponentsMask
, XkbUseCoreKbd
);
10640 int delete_keycode
= 0, backspace_keycode
= 0, i
;
10642 if (XkbGetNames (dpy
, XkbAllNamesMask
, kb
) == Success
)
10644 for (i
= kb
->min_key_code
;
10645 (i
< kb
->max_key_code
10646 && (delete_keycode
== 0 || backspace_keycode
== 0));
10649 /* The XKB symbolic key names can be seen most easily in
10650 the PS file generated by `xkbprint -label name
10652 if (bcmp ("DELE", kb
->names
->keys
[i
].name
, 4) == 0)
10653 delete_keycode
= i
;
10654 else if (bcmp ("BKSP", kb
->names
->keys
[i
].name
, 4) == 0)
10655 backspace_keycode
= i
;
10658 XkbFreeNames (kb
, 0, True
);
10661 XkbFreeClientMap (kb
, 0, True
);
10664 && backspace_keycode
10665 && XKeysymToKeycode (dpy
, XK_Delete
) == delete_keycode
10666 && XKeysymToKeycode (dpy
, XK_BackSpace
) == backspace_keycode
)
10671 #else /* not HAVE_XKBGETKEYBOARD */
10673 #endif /* not HAVE_XKBGETKEYBOARD */
10678 /***********************************************************************
10680 ***********************************************************************/
10682 /* Keep this list in the same order as frame_parms in frame.c.
10683 Use 0 for unsupported frame parameters. */
10685 frame_parm_handler x_frame_parm_handlers
[] =
10689 x_set_background_color
,
10690 x_set_border_color
,
10691 x_set_border_width
,
10692 x_set_cursor_color
,
10695 x_set_foreground_color
,
10698 x_set_internal_border_width
,
10699 x_set_menu_bar_lines
,
10701 x_explicitly_set_name
,
10702 x_set_scroll_bar_width
,
10704 x_set_unsplittable
,
10705 x_set_vertical_scroll_bars
,
10707 x_set_tool_bar_lines
,
10708 x_set_scroll_bar_foreground
,
10709 x_set_scroll_bar_background
,
10710 x_set_screen_gamma
,
10711 x_set_line_spacing
,
10712 x_set_fringe_width
,
10713 x_set_fringe_width
,
10721 /* This is zero if not using X windows. */
10724 /* The section below is built by the lisp expression at the top of the file,
10725 just above where these variables are declared. */
10726 /*&&& init symbols here &&&*/
10727 Qnone
= intern ("none");
10728 staticpro (&Qnone
);
10729 Qsuppress_icon
= intern ("suppress-icon");
10730 staticpro (&Qsuppress_icon
);
10731 Qundefined_color
= intern ("undefined-color");
10732 staticpro (&Qundefined_color
);
10733 Qcenter
= intern ("center");
10734 staticpro (&Qcenter
);
10735 Qcompound_text
= intern ("compound-text");
10736 staticpro (&Qcompound_text
);
10737 Qcancel_timer
= intern ("cancel-timer");
10738 staticpro (&Qcancel_timer
);
10739 /* This is the end of symbol initialization. */
10741 /* Text property `display' should be nonsticky by default. */
10742 Vtext_property_default_nonsticky
10743 = Fcons (Fcons (Qdisplay
, Qt
), Vtext_property_default_nonsticky
);
10746 Qlaplace
= intern ("laplace");
10747 staticpro (&Qlaplace
);
10748 Qemboss
= intern ("emboss");
10749 staticpro (&Qemboss
);
10750 Qedge_detection
= intern ("edge-detection");
10751 staticpro (&Qedge_detection
);
10752 Qheuristic
= intern ("heuristic");
10753 staticpro (&Qheuristic
);
10754 QCmatrix
= intern (":matrix");
10755 staticpro (&QCmatrix
);
10756 QCcolor_adjustment
= intern (":color-adjustment");
10757 staticpro (&QCcolor_adjustment
);
10758 QCmask
= intern (":mask");
10759 staticpro (&QCmask
);
10761 Fput (Qundefined_color
, Qerror_conditions
,
10762 Fcons (Qundefined_color
, Fcons (Qerror
, Qnil
)));
10763 Fput (Qundefined_color
, Qerror_message
,
10764 build_string ("Undefined color"));
10766 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
10767 doc
: /* Non-nil means always draw a cross over disabled images.
10768 Disabled images are those having an `:conversion disabled' property.
10769 A cross is always drawn on black & white displays. */);
10770 cross_disabled_images
= 0;
10772 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
10773 doc
: /* List of directories to search for window system bitmap files. */);
10774 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
10776 DEFVAR_LISP ("x-pointer-shape", &Vx_pointer_shape
,
10777 doc
: /* The shape of the pointer when over text.
10778 Changing the value does not affect existing frames
10779 unless you set the mouse color. */);
10780 Vx_pointer_shape
= Qnil
;
10782 #if 0 /* This doesn't really do anything. */
10783 DEFVAR_LISP ("x-nontext-pointer-shape", &Vx_nontext_pointer_shape
,
10784 doc
: /* The shape of the pointer when not over text.
10785 This variable takes effect when you create a new frame
10786 or when you set the mouse color. */);
10788 Vx_nontext_pointer_shape
= Qnil
;
10790 DEFVAR_LISP ("x-hourglass-pointer-shape", &Vx_hourglass_pointer_shape
,
10791 doc
: /* The shape of the pointer when Emacs is busy.
10792 This variable takes effect when you create a new frame
10793 or when you set the mouse color. */);
10794 Vx_hourglass_pointer_shape
= Qnil
;
10796 DEFVAR_BOOL ("display-hourglass", &display_hourglass_p
,
10797 doc
: /* Non-zero means Emacs displays an hourglass pointer on window systems. */);
10798 display_hourglass_p
= 1;
10800 DEFVAR_LISP ("hourglass-delay", &Vhourglass_delay
,
10801 doc
: /* *Seconds to wait before displaying an hourglass pointer.
10802 Value must be an integer or float. */);
10803 Vhourglass_delay
= make_number (DEFAULT_HOURGLASS_DELAY
);
10805 #if 0 /* This doesn't really do anything. */
10806 DEFVAR_LISP ("x-mode-pointer-shape", &Vx_mode_pointer_shape
,
10807 doc
: /* The shape of the pointer when over the mode line.
10808 This variable takes effect when you create a new frame
10809 or when you set the mouse color. */);
10811 Vx_mode_pointer_shape
= Qnil
;
10813 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
10814 &Vx_sensitive_text_pointer_shape
,
10815 doc
: /* The shape of the pointer when over mouse-sensitive text.
10816 This variable takes effect when you create a new frame
10817 or when you set the mouse color. */);
10818 Vx_sensitive_text_pointer_shape
= Qnil
;
10820 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
10821 &Vx_window_horizontal_drag_shape
,
10822 doc
: /* Pointer shape to use for indicating a window can be dragged horizontally.
10823 This variable takes effect when you create a new frame
10824 or when you set the mouse color. */);
10825 Vx_window_horizontal_drag_shape
= Qnil
;
10827 DEFVAR_LISP ("x-cursor-fore-pixel", &Vx_cursor_fore_pixel
,
10828 doc
: /* A string indicating the foreground color of the cursor box. */);
10829 Vx_cursor_fore_pixel
= Qnil
;
10831 DEFVAR_LISP ("x-max-tooltip-size", &Vx_max_tooltip_size
,
10832 doc
: /* Maximum size for tooltips. Value is a pair (COLUMNS . ROWS).
10833 Text larger than this is clipped. */);
10834 Vx_max_tooltip_size
= Fcons (make_number (80), make_number (40));
10836 DEFVAR_LISP ("x-no-window-manager", &Vx_no_window_manager
,
10837 doc
: /* Non-nil if no X window manager is in use.
10838 Emacs doesn't try to figure this out; this is always nil
10839 unless you set it to something else. */);
10840 /* We don't have any way to find this out, so set it to nil
10841 and maybe the user would like to set it to t. */
10842 Vx_no_window_manager
= Qnil
;
10844 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
10845 &Vx_pixel_size_width_font_regexp
,
10846 doc
: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
10848 Since Emacs gets width of a font matching with this regexp from
10849 PIXEL_SIZE field of the name, font finding mechanism gets faster for
10850 such a font. This is especially effective for such large fonts as
10851 Chinese, Japanese, and Korean. */);
10852 Vx_pixel_size_width_font_regexp
= Qnil
;
10854 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
10855 doc
: /* Time after which cached images are removed from the cache.
10856 When an image has not been displayed this many seconds, remove it
10857 from the image cache. Value must be an integer or nil with nil
10858 meaning don't clear the cache. */);
10859 Vimage_cache_eviction_delay
= make_number (30 * 60);
10861 #ifdef USE_X_TOOLKIT
10862 Fprovide (intern ("x-toolkit"), Qnil
);
10864 Fprovide (intern ("motif"), Qnil
);
10866 DEFVAR_LISP ("motif-version-string", &Vmotif_version_string
,
10867 doc
: /* Version info for LessTif/Motif. */);
10868 Vmotif_version_string
= build_string (XmVERSION_STRING
);
10869 #endif /* USE_MOTIF */
10870 #endif /* USE_X_TOOLKIT */
10872 /* X window properties. */
10873 defsubr (&Sx_change_window_property
);
10874 defsubr (&Sx_delete_window_property
);
10875 defsubr (&Sx_window_property
);
10877 defsubr (&Sxw_display_color_p
);
10878 defsubr (&Sx_display_grayscale_p
);
10879 defsubr (&Sxw_color_defined_p
);
10880 defsubr (&Sxw_color_values
);
10881 defsubr (&Sx_server_max_request_size
);
10882 defsubr (&Sx_server_vendor
);
10883 defsubr (&Sx_server_version
);
10884 defsubr (&Sx_display_pixel_width
);
10885 defsubr (&Sx_display_pixel_height
);
10886 defsubr (&Sx_display_mm_width
);
10887 defsubr (&Sx_display_mm_height
);
10888 defsubr (&Sx_display_screens
);
10889 defsubr (&Sx_display_planes
);
10890 defsubr (&Sx_display_color_cells
);
10891 defsubr (&Sx_display_visual_class
);
10892 defsubr (&Sx_display_backing_store
);
10893 defsubr (&Sx_display_save_under
);
10894 defsubr (&Sx_create_frame
);
10895 defsubr (&Sx_open_connection
);
10896 defsubr (&Sx_close_connection
);
10897 defsubr (&Sx_display_list
);
10898 defsubr (&Sx_synchronize
);
10899 defsubr (&Sx_focus_frame
);
10900 defsubr (&Sx_backspace_delete_keys_p
);
10902 /* Setting callback functions for fontset handler. */
10903 get_font_info_func
= x_get_font_info
;
10905 #if 0 /* This function pointer doesn't seem to be used anywhere.
10906 And the pointer assigned has the wrong type, anyway. */
10907 list_fonts_func
= x_list_fonts
;
10910 load_font_func
= x_load_font
;
10911 find_ccl_program_func
= x_find_ccl_program
;
10912 query_font_func
= x_query_font
;
10913 set_frame_fontset_func
= x_set_font
;
10914 get_font_repertory_func
= x_get_font_repertory
;
10915 check_window_system_func
= check_x
;
10918 Qxbm
= intern ("xbm");
10920 QCconversion
= intern (":conversion");
10921 staticpro (&QCconversion
);
10922 QCheuristic_mask
= intern (":heuristic-mask");
10923 staticpro (&QCheuristic_mask
);
10924 QCcolor_symbols
= intern (":color-symbols");
10925 staticpro (&QCcolor_symbols
);
10926 QCascent
= intern (":ascent");
10927 staticpro (&QCascent
);
10928 QCmargin
= intern (":margin");
10929 staticpro (&QCmargin
);
10930 QCrelief
= intern (":relief");
10931 staticpro (&QCrelief
);
10932 Qpostscript
= intern ("postscript");
10933 staticpro (&Qpostscript
);
10934 QCloader
= intern (":loader");
10935 staticpro (&QCloader
);
10936 QCbounding_box
= intern (":bounding-box");
10937 staticpro (&QCbounding_box
);
10938 QCpt_width
= intern (":pt-width");
10939 staticpro (&QCpt_width
);
10940 QCpt_height
= intern (":pt-height");
10941 staticpro (&QCpt_height
);
10942 QCindex
= intern (":index");
10943 staticpro (&QCindex
);
10944 Qpbm
= intern ("pbm");
10948 Qxpm
= intern ("xpm");
10953 Qjpeg
= intern ("jpeg");
10954 staticpro (&Qjpeg
);
10958 Qtiff
= intern ("tiff");
10959 staticpro (&Qtiff
);
10963 Qgif
= intern ("gif");
10968 Qpng
= intern ("png");
10972 defsubr (&Sclear_image_cache
);
10973 defsubr (&Simage_size
);
10974 defsubr (&Simage_mask_p
);
10976 hourglass_atimer
= NULL
;
10977 hourglass_shown_p
= 0;
10979 defsubr (&Sx_show_tip
);
10980 defsubr (&Sx_hide_tip
);
10982 staticpro (&tip_timer
);
10984 staticpro (&tip_frame
);
10986 last_show_tip_args
= Qnil
;
10987 staticpro (&last_show_tip_args
);
10990 defsubr (&Sx_file_dialog
);
10998 image_types
= NULL
;
10999 Vimage_types
= Qnil
;
11001 define_image_type (&xbm_type
);
11002 define_image_type (&gs_type
);
11003 define_image_type (&pbm_type
);
11006 define_image_type (&xpm_type
);
11010 define_image_type (&jpeg_type
);
11014 define_image_type (&tiff_type
);
11018 define_image_type (&gif_type
);
11022 define_image_type (&png_type
);
11026 #endif /* HAVE_X_WINDOWS */