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"
49 #include "termhooks.h"
57 #include <sys/types.h>
61 #if 1 /* Used to be #ifdef EMACS_BITMAP_FILES, but this should always work. */
62 #include "bitmaps/gray.xbm"
64 #include <X11/bitmaps/gray>
67 #include "[.bitmaps]gray.xbm"
75 #include <X11/Shell.h>
78 #include <X11/Xaw/Paned.h>
79 #include <X11/Xaw/Label.h>
80 #endif /* USE_MOTIF */
83 #undef USG /* ####KLUDGE for Solaris 2.2 and up */
92 #include "../lwlib/lwlib.h"
96 #include <Xm/DialogS.h>
97 #include <Xm/FileSB.h>
100 /* Do the EDITRES protocol if running X11R5
101 Exception: HP-UX (at least version A.09.05) has X11R5 without EditRes */
103 #if (XtSpecificationRelease >= 5) && !defined(NO_EDITRES)
105 extern void _XEditResCheckMessages ();
106 #endif /* R5 + Athena */
108 /* Unique id counter for widgets created by the Lucid Widget Library. */
110 extern LWLIB_ID widget_id_tick
;
113 /* This is part of a kludge--see lwlib/xlwmenu.c. */
114 extern XFontStruct
*xlwmenu_default_font
;
117 extern void free_frame_menubar ();
118 extern double atof ();
122 /* LessTif/Motif version info. */
124 static Lisp_Object Vmotif_version_string
;
126 #endif /* USE_MOTIF */
128 #endif /* USE_X_TOOLKIT */
132 /* GTK+ version info */
134 static Lisp_Object Vgtk_version_string
;
139 #define MAXREQUEST(dpy) (XMaxRequestSize (dpy))
141 #define MAXREQUEST(dpy) ((dpy)->max_request_size)
144 /* The gray bitmap `bitmaps/gray'. This is done because xterm.c uses
145 it, and including `bitmaps/gray' more than once is a problem when
146 config.h defines `static' as an empty replacement string. */
148 int gray_bitmap_width
= gray_width
;
149 int gray_bitmap_height
= gray_height
;
150 char *gray_bitmap_bits
= gray_bits
;
152 /* Non-zero means we're allowed to display an hourglass cursor. */
154 int display_hourglass_p
;
156 /* The background and shape of the mouse pointer, and shape when not
157 over text or in the modeline. */
159 Lisp_Object Vx_pointer_shape
, Vx_nontext_pointer_shape
, Vx_mode_pointer_shape
;
160 Lisp_Object Vx_hourglass_pointer_shape
;
162 /* The shape when over mouse-sensitive text. */
164 Lisp_Object Vx_sensitive_text_pointer_shape
;
166 /* If non-nil, the pointer shape to indicate that windows can be
167 dragged horizontally. */
169 Lisp_Object Vx_window_horizontal_drag_shape
;
171 /* Color of chars displayed in cursor box. */
173 Lisp_Object Vx_cursor_fore_pixel
;
175 /* Nonzero if using X. */
179 /* Non nil if no window manager is in use. */
181 Lisp_Object Vx_no_window_manager
;
183 /* Search path for bitmap files. */
185 Lisp_Object Vx_bitmap_file_path
;
187 /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'. */
189 Lisp_Object Vx_pixel_size_width_font_regexp
;
192 Lisp_Object Qsuppress_icon
;
193 Lisp_Object Qundefined_color
;
195 Lisp_Object Qcompound_text
, Qcancel_timer
;
199 extern Lisp_Object Vwindow_system_version
;
201 /* The below are defined in frame.c. */
204 int image_cache_refcount
, dpyinfo_refcount
;
209 /* Error if we are not connected to X. */
215 error ("X windows are not in use or not initialized");
218 /* Nonzero if we can use mouse menus.
219 You should not call this unless HAVE_MENUS is defined. */
227 /* Extract a frame as a FRAME_PTR, defaulting to the selected frame
228 and checking validity for X. */
231 check_x_frame (frame
)
237 frame
= selected_frame
;
238 CHECK_LIVE_FRAME (frame
);
241 error ("Non-X frame used");
245 /* Let the user specify an X display with a frame.
246 nil stands for the selected frame--or, if that is not an X frame,
247 the first X display on the list. */
249 struct x_display_info
*
250 check_x_display_info (frame
)
253 struct x_display_info
*dpyinfo
= NULL
;
257 struct frame
*sf
= XFRAME (selected_frame
);
259 if (FRAME_X_P (sf
) && FRAME_LIVE_P (sf
))
260 dpyinfo
= FRAME_X_DISPLAY_INFO (sf
);
261 else if (x_display_list
!= 0)
262 dpyinfo
= x_display_list
;
264 error ("X windows are not in use or not initialized");
266 else if (STRINGP (frame
))
267 dpyinfo
= x_display_info_for_name (frame
);
270 FRAME_PTR f
= check_x_frame (frame
);
271 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
278 /* Return the Emacs frame-object corresponding to an X window.
279 It could be the frame's main window or an icon window. */
281 /* This function can be called during GC, so use GC_xxx type test macros. */
284 x_window_to_frame (dpyinfo
, wdesc
)
285 struct x_display_info
*dpyinfo
;
288 Lisp_Object tail
, frame
;
291 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
294 if (!GC_FRAMEP (frame
))
297 if (!FRAME_X_P (f
) || FRAME_X_DISPLAY_INFO (f
) != dpyinfo
)
299 if (f
->output_data
.x
->hourglass_window
== wdesc
)
302 if ((f
->output_data
.x
->edit_widget
303 && XtWindow (f
->output_data
.x
->edit_widget
) == wdesc
)
304 /* A tooltip frame? */
305 || (!f
->output_data
.x
->edit_widget
306 && FRAME_X_WINDOW (f
) == wdesc
)
307 || f
->output_data
.x
->icon_desc
== wdesc
)
309 #else /* not USE_X_TOOLKIT */
311 if (f
->output_data
.x
->edit_widget
)
313 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
314 struct x_output
*x
= f
->output_data
.x
;
315 if (gwdesc
!= 0 && gwdesc
== x
->edit_widget
)
319 if (FRAME_X_WINDOW (f
) == wdesc
320 || f
->output_data
.x
->icon_desc
== wdesc
)
322 #endif /* not USE_X_TOOLKIT */
327 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
328 /* Like x_window_to_frame but also compares the window with the widget's
332 x_any_window_to_frame (dpyinfo
, wdesc
)
333 struct x_display_info
*dpyinfo
;
336 Lisp_Object tail
, frame
;
337 struct frame
*f
, *found
;
341 for (tail
= Vframe_list
; GC_CONSP (tail
) && !found
; tail
= XCDR (tail
))
344 if (!GC_FRAMEP (frame
))
348 if (FRAME_X_P (f
) && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
350 /* This frame matches if the window is any of its widgets. */
351 x
= f
->output_data
.x
;
352 if (x
->hourglass_window
== wdesc
)
357 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
359 && (gwdesc
== x
->widget
360 || gwdesc
== x
->edit_widget
361 || gwdesc
== x
->vbox_widget
362 || gwdesc
== x
->menubar_widget
))
365 if (wdesc
== XtWindow (x
->widget
)
366 || wdesc
== XtWindow (x
->column_widget
)
367 || wdesc
== XtWindow (x
->edit_widget
))
369 /* Match if the window is this frame's menubar. */
370 else if (lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
374 else if (FRAME_X_WINDOW (f
) == wdesc
)
375 /* A tooltip frame. */
383 /* Likewise, but exclude the menu bar widget. */
386 x_non_menubar_window_to_frame (dpyinfo
, wdesc
)
387 struct x_display_info
*dpyinfo
;
390 Lisp_Object tail
, frame
;
394 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
397 if (!GC_FRAMEP (frame
))
400 if (!FRAME_X_P (f
) || FRAME_X_DISPLAY_INFO (f
) != dpyinfo
)
402 x
= f
->output_data
.x
;
403 /* This frame matches if the window is any of its widgets. */
404 if (x
->hourglass_window
== wdesc
)
409 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
411 && (gwdesc
== x
->widget
412 || gwdesc
== x
->edit_widget
413 || gwdesc
== x
->vbox_widget
))
416 if (wdesc
== XtWindow (x
->widget
)
417 || wdesc
== XtWindow (x
->column_widget
)
418 || wdesc
== XtWindow (x
->edit_widget
))
422 else if (FRAME_X_WINDOW (f
) == wdesc
)
423 /* A tooltip frame. */
429 /* Likewise, but consider only the menu bar widget. */
432 x_menubar_window_to_frame (dpyinfo
, wdesc
)
433 struct x_display_info
*dpyinfo
;
436 Lisp_Object tail
, frame
;
440 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
443 if (!GC_FRAMEP (frame
))
446 if (!FRAME_X_P (f
) || FRAME_X_DISPLAY_INFO (f
) != dpyinfo
)
448 x
= f
->output_data
.x
;
449 /* Match if the window is this frame's menubar. */
451 if (x
->menubar_widget
)
453 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
458 && (gwdesc
== x
->menubar_widget
459 || gtk_widget_get_parent (gwdesc
) == x
->menubar_widget
))
465 if (x
->menubar_widget
466 && lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
473 /* Return the frame whose principal (outermost) window is WDESC.
474 If WDESC is some other (smaller) window, we return 0. */
477 x_top_window_to_frame (dpyinfo
, wdesc
)
478 struct x_display_info
*dpyinfo
;
481 Lisp_Object tail
, frame
;
485 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
488 if (!GC_FRAMEP (frame
))
491 if (!FRAME_X_P (f
) || FRAME_X_DISPLAY_INFO (f
) != dpyinfo
)
493 x
= f
->output_data
.x
;
497 /* This frame matches if the window is its topmost widget. */
499 GtkWidget
*gwdesc
= xg_win_to_widget (dpyinfo
->display
, wdesc
);
500 if (gwdesc
== x
->widget
)
503 if (wdesc
== XtWindow (x
->widget
))
505 #if 0 /* I don't know why it did this,
506 but it seems logically wrong,
507 and it causes trouble for MapNotify events. */
508 /* Match if the window is this frame's menubar. */
509 if (x
->menubar_widget
510 && wdesc
== XtWindow (x
->menubar_widget
))
515 else if (FRAME_X_WINDOW (f
) == wdesc
)
521 #endif /* USE_X_TOOLKIT || USE_GTK */
525 /* Code to deal with bitmaps. Bitmaps are referenced by their bitmap
526 id, which is just an int that this section returns. Bitmaps are
527 reference counted so they can be shared among frames.
529 Bitmap indices are guaranteed to be > 0, so a negative number can
530 be used to indicate no bitmap.
532 If you use x_create_bitmap_from_data, then you must keep track of
533 the bitmaps yourself. That is, creating a bitmap from the same
534 data more than once will not be caught. */
537 /* Functions to access the contents of a bitmap, given an id. */
540 x_bitmap_height (f
, id
)
544 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].height
;
548 x_bitmap_width (f
, id
)
552 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].width
;
556 x_bitmap_pixmap (f
, id
)
560 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].pixmap
;
564 x_bitmap_mask (f
, id
)
568 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].mask
;
572 /* Allocate a new bitmap record. Returns index of new record. */
575 x_allocate_bitmap_record (f
)
578 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
581 if (dpyinfo
->bitmaps
== NULL
)
583 dpyinfo
->bitmaps_size
= 10;
585 = (struct x_bitmap_record
*) xmalloc (dpyinfo
->bitmaps_size
* sizeof (struct x_bitmap_record
));
586 dpyinfo
->bitmaps_last
= 1;
590 if (dpyinfo
->bitmaps_last
< dpyinfo
->bitmaps_size
)
591 return ++dpyinfo
->bitmaps_last
;
593 for (i
= 0; i
< dpyinfo
->bitmaps_size
; ++i
)
594 if (dpyinfo
->bitmaps
[i
].refcount
== 0)
597 dpyinfo
->bitmaps_size
*= 2;
599 = (struct x_bitmap_record
*) xrealloc (dpyinfo
->bitmaps
,
600 dpyinfo
->bitmaps_size
* sizeof (struct x_bitmap_record
));
601 return ++dpyinfo
->bitmaps_last
;
604 /* Add one reference to the reference count of the bitmap with id ID. */
607 x_reference_bitmap (f
, id
)
611 ++FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].refcount
;
614 /* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS. */
617 x_create_bitmap_from_data (f
, bits
, width
, height
)
620 unsigned int width
, height
;
622 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
626 bitmap
= XCreateBitmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
627 bits
, width
, height
);
634 id
= x_allocate_bitmap_record (f
);
635 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
636 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
637 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
638 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
639 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
640 dpyinfo
->bitmaps
[id
- 1].height
= height
;
641 dpyinfo
->bitmaps
[id
- 1].width
= width
;
646 /* Create bitmap from file FILE for frame F. */
649 x_create_bitmap_from_file (f
, file
)
653 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
654 unsigned int width
, height
;
656 int xhot
, yhot
, result
, id
;
661 /* Look for an existing bitmap with the same name. */
662 for (id
= 0; id
< dpyinfo
->bitmaps_last
; ++id
)
664 if (dpyinfo
->bitmaps
[id
].refcount
665 && dpyinfo
->bitmaps
[id
].file
666 && !strcmp (dpyinfo
->bitmaps
[id
].file
, (char *) SDATA (file
)))
668 ++dpyinfo
->bitmaps
[id
].refcount
;
673 /* Search bitmap-file-path for the file, if appropriate. */
674 fd
= openp (Vx_bitmap_file_path
, file
, Qnil
, &found
, Qnil
);
679 filename
= (char *) SDATA (found
);
681 result
= XReadBitmapFile (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
682 filename
, &width
, &height
, &bitmap
, &xhot
, &yhot
);
683 if (result
!= BitmapSuccess
)
686 id
= x_allocate_bitmap_record (f
);
687 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
688 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
689 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
690 dpyinfo
->bitmaps
[id
- 1].file
691 = (char *) xmalloc (SBYTES (file
) + 1);
692 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
693 dpyinfo
->bitmaps
[id
- 1].height
= height
;
694 dpyinfo
->bitmaps
[id
- 1].width
= width
;
695 strcpy (dpyinfo
->bitmaps
[id
- 1].file
, SDATA (file
));
700 /* Remove reference to bitmap with id number ID. */
703 x_destroy_bitmap (f
, id
)
707 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
711 --dpyinfo
->bitmaps
[id
- 1].refcount
;
712 if (dpyinfo
->bitmaps
[id
- 1].refcount
== 0)
715 XFreePixmap (FRAME_X_DISPLAY (f
), dpyinfo
->bitmaps
[id
- 1].pixmap
);
716 if (dpyinfo
->bitmaps
[id
- 1].have_mask
)
717 XFreePixmap (FRAME_X_DISPLAY (f
), dpyinfo
->bitmaps
[id
- 1].mask
);
718 if (dpyinfo
->bitmaps
[id
- 1].file
)
720 xfree (dpyinfo
->bitmaps
[id
- 1].file
);
721 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
728 /* Free all the bitmaps for the display specified by DPYINFO. */
731 x_destroy_all_bitmaps (dpyinfo
)
732 struct x_display_info
*dpyinfo
;
735 for (i
= 0; i
< dpyinfo
->bitmaps_last
; i
++)
736 if (dpyinfo
->bitmaps
[i
].refcount
> 0)
738 XFreePixmap (dpyinfo
->display
, dpyinfo
->bitmaps
[i
].pixmap
);
739 if (dpyinfo
->bitmaps
[i
].have_mask
)
740 XFreePixmap (dpyinfo
->display
, dpyinfo
->bitmaps
[i
].mask
);
741 if (dpyinfo
->bitmaps
[i
].file
)
742 xfree (dpyinfo
->bitmaps
[i
].file
);
744 dpyinfo
->bitmaps_last
= 0;
750 /* Useful functions defined in the section
751 `Image type independent image structures' below. */
753 static unsigned long four_corners_best
P_ ((XImage
*ximg
, unsigned long width
,
754 unsigned long height
));
756 static int x_create_x_image_and_pixmap
P_ ((struct frame
*f
, int width
, int height
,
757 int depth
, XImage
**ximg
,
760 static void x_destroy_x_image
P_ ((XImage
*ximg
));
763 /* Create a mask of a bitmap. Note is this not a perfect mask.
764 It's nicer with some borders in this context */
767 x_create_bitmap_mask (f
, id
)
772 XImage
*ximg
, *mask_img
;
773 unsigned long width
, height
;
776 unsigned long x
, y
, xp
, xm
, yp
, ym
;
779 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
780 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
785 pixmap
= x_bitmap_pixmap (f
, id
);
786 width
= x_bitmap_width (f
, id
);
787 height
= x_bitmap_height (f
, id
);
790 ximg
= XGetImage (FRAME_X_DISPLAY (f
), pixmap
, 0, 0, width
, height
,
799 result
= x_create_x_image_and_pixmap (f
, width
, height
, 1, &mask_img
, &mask
);
804 XDestroyImage (ximg
);
808 bg
= four_corners_best (ximg
, width
, height
);
810 for (y
= 0; y
< ximg
->height
; ++y
)
812 for (x
= 0; x
< ximg
->width
; ++x
)
814 xp
= x
!= ximg
->width
- 1 ? x
+ 1 : 0;
815 xm
= x
!= 0 ? x
- 1 : ximg
->width
- 1;
816 yp
= y
!= ximg
->height
- 1 ? y
+ 1 : 0;
817 ym
= y
!= 0 ? y
- 1 : ximg
->height
- 1;
818 if (XGetPixel (ximg
, x
, y
) == bg
819 && XGetPixel (ximg
, x
, yp
) == bg
820 && XGetPixel (ximg
, x
, ym
) == bg
821 && XGetPixel (ximg
, xp
, y
) == bg
822 && XGetPixel (ximg
, xp
, yp
) == bg
823 && XGetPixel (ximg
, xp
, ym
) == bg
824 && XGetPixel (ximg
, xm
, y
) == bg
825 && XGetPixel (ximg
, xm
, yp
) == bg
826 && XGetPixel (ximg
, xm
, ym
) == bg
)
827 XPutPixel (mask_img
, x
, y
, 0);
829 XPutPixel (mask_img
, x
, y
, 1);
833 xassert (interrupt_input_blocked
);
834 gc
= XCreateGC (FRAME_X_DISPLAY (f
), mask
, 0, NULL
);
835 XPutImage (FRAME_X_DISPLAY (f
), mask
, gc
, mask_img
, 0, 0, 0, 0,
837 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
839 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
840 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
842 XDestroyImage (ximg
);
843 x_destroy_x_image (mask_img
);
848 static Lisp_Object unwind_create_frame
P_ ((Lisp_Object
));
849 static Lisp_Object unwind_create_tip_frame
P_ ((Lisp_Object
));
850 static void x_disable_image
P_ ((struct frame
*, struct image
*));
852 void x_set_foreground_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
853 static void x_set_wait_for_wm
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
854 void x_set_background_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
855 void x_set_mouse_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
856 void x_set_cursor_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
857 void x_set_border_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
858 void x_set_cursor_type
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
859 void x_set_icon_type
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
860 void x_set_icon_name
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
861 void x_explicitly_set_name
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
862 void x_set_menu_bar_lines
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
863 void x_set_title
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
864 void x_set_tool_bar_lines
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
865 void x_set_scroll_bar_foreground
P_ ((struct frame
*, Lisp_Object
,
867 void x_set_scroll_bar_background
P_ ((struct frame
*, Lisp_Object
,
869 static Lisp_Object x_default_scroll_bar_color_parameter
P_ ((struct frame
*,
874 static void x_edge_detection
P_ ((struct frame
*, struct image
*, Lisp_Object
,
876 static void init_color_table
P_ ((void));
877 static void free_color_table
P_ ((void));
878 static unsigned long *colors_in_color_table
P_ ((int *n
));
879 static unsigned long lookup_rgb_color
P_ ((struct frame
*f
, int r
, int g
, int b
));
880 static unsigned long lookup_pixel_color
P_ ((struct frame
*f
, unsigned long p
));
886 /* Store the screen positions of frame F into XPTR and YPTR.
887 These are the positions of the containing window manager window,
888 not Emacs's own window. */
891 x_real_positions (f
, xptr
, yptr
)
895 int win_x
, win_y
, outer_x
, outer_y
;
896 int real_x
= 0, real_y
= 0;
898 Window win
= f
->output_data
.x
->parent_desc
;
904 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
906 if (win
== FRAME_X_DISPLAY_INFO (f
)->root_window
)
907 win
= FRAME_OUTER_WINDOW (f
);
909 /* This loop traverses up the containment tree until we hit the root
910 window. Window managers may intersect many windows between our window
911 and the root window. The window we find just before the root window
912 should be the outer WM window. */
915 Window wm_window
, rootw
;
916 Window
*tmp_children
;
917 unsigned int tmp_nchildren
;
920 success
= XQueryTree (FRAME_X_DISPLAY (f
), win
, &rootw
,
921 &wm_window
, &tmp_children
, &tmp_nchildren
);
923 had_errors
= x_had_errors_p (FRAME_X_DISPLAY (f
));
925 /* Don't free tmp_children if XQueryTree failed. */
929 XFree ((char *) tmp_children
);
931 if (wm_window
== rootw
|| had_errors
)
942 /* Get the real coordinates for the WM window upper left corner */
943 XGetGeometry (FRAME_X_DISPLAY (f
), win
,
944 &rootw
, &real_x
, &real_y
, &ign
, &ign
, &ign
, &ign
);
946 /* Translate real coordinates to coordinates relative to our
947 window. For our window, the upper left corner is 0, 0.
948 Since the upper left corner of the WM window is outside
949 our window, win_x and win_y will be negative:
951 ------------------ ---> x
953 | ----------------- v y
956 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
958 /* From-window, to-window. */
959 FRAME_X_DISPLAY_INFO (f
)->root_window
,
962 /* From-position, to-position. */
963 real_x
, real_y
, &win_x
, &win_y
,
968 if (FRAME_X_WINDOW (f
) == FRAME_OUTER_WINDOW (f
))
975 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
977 /* From-window, to-window. */
978 FRAME_X_DISPLAY_INFO (f
)->root_window
,
979 FRAME_OUTER_WINDOW (f
),
981 /* From-position, to-position. */
982 real_x
, real_y
, &outer_x
, &outer_y
,
988 had_errors
= x_had_errors_p (FRAME_X_DISPLAY (f
));
991 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
995 if (had_errors
) return;
997 f
->x_pixels_diff
= -win_x
;
998 f
->y_pixels_diff
= -win_y
;
1000 FRAME_X_OUTPUT (f
)->x_pixels_outer_diff
= -outer_x
;
1001 FRAME_X_OUTPUT (f
)->y_pixels_outer_diff
= -outer_y
;
1010 /* Gamma-correct COLOR on frame F. */
1013 gamma_correct (f
, color
)
1019 color
->red
= pow (color
->red
/ 65535.0, f
->gamma
) * 65535.0 + 0.5;
1020 color
->green
= pow (color
->green
/ 65535.0, f
->gamma
) * 65535.0 + 0.5;
1021 color
->blue
= pow (color
->blue
/ 65535.0, f
->gamma
) * 65535.0 + 0.5;
1026 /* Decide if color named COLOR_NAME is valid for use on frame F. If
1027 so, return the RGB values in COLOR. If ALLOC_P is non-zero,
1028 allocate the color. Value is zero if COLOR_NAME is invalid, or
1029 no color could be allocated. */
1032 x_defined_color (f
, color_name
, color
, alloc_p
)
1039 Display
*dpy
= FRAME_X_DISPLAY (f
);
1040 Colormap cmap
= FRAME_X_COLORMAP (f
);
1043 success_p
= XParseColor (dpy
, cmap
, color_name
, color
);
1044 if (success_p
&& alloc_p
)
1045 success_p
= x_alloc_nearest_color (f
, cmap
, color
);
1052 /* Return the pixel color value for color COLOR_NAME on frame F. If F
1053 is a monochrome frame, return MONO_COLOR regardless of what ARG says.
1054 Signal an error if color can't be allocated. */
1057 x_decode_color (f
, color_name
, mono_color
)
1059 Lisp_Object color_name
;
1064 CHECK_STRING (color_name
);
1066 #if 0 /* Don't do this. It's wrong when we're not using the default
1067 colormap, it makes freeing difficult, and it's probably not
1068 an important optimization. */
1069 if (strcmp (SDATA (color_name
), "black") == 0)
1070 return BLACK_PIX_DEFAULT (f
);
1071 else if (strcmp (SDATA (color_name
), "white") == 0)
1072 return WHITE_PIX_DEFAULT (f
);
1075 /* Return MONO_COLOR for monochrome frames. */
1076 if (FRAME_X_DISPLAY_INFO (f
)->n_planes
== 1)
1079 /* x_defined_color is responsible for coping with failures
1080 by looking for a near-miss. */
1081 if (x_defined_color (f
, SDATA (color_name
), &cdef
, 1))
1084 Fsignal (Qerror
, Fcons (build_string ("Undefined color"),
1085 Fcons (color_name
, Qnil
)));
1091 /* Change the `wait-for-wm' frame parameter of frame F. OLD_VALUE is
1092 the previous value of that parameter, NEW_VALUE is the new value.
1093 See also the comment of wait_for_wm in struct x_output. */
1096 x_set_wait_for_wm (f
, new_value
, old_value
)
1098 Lisp_Object new_value
, old_value
;
1100 f
->output_data
.x
->wait_for_wm
= !NILP (new_value
);
1105 static Lisp_Object x_find_image_file
P_ ((Lisp_Object file
));
1107 /* Set icon from FILE for frame F. By using GTK functions the icon
1108 may be any format that GdkPixbuf knows about, i.e. not just bitmaps. */
1111 xg_set_icon (f
, file
)
1115 struct gcpro gcpro1
;
1121 found
= x_find_image_file (file
);
1129 filename
= SDATA (found
);
1132 pixbuf
= gdk_pixbuf_new_from_file (filename
, &err
);
1136 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1138 g_object_unref (pixbuf
);
1151 #endif /* USE_GTK */
1154 /* Functions called only from `x_set_frame_param'
1155 to set individual parameters.
1157 If FRAME_X_WINDOW (f) is 0,
1158 the frame is being created and its X-window does not exist yet.
1159 In that case, just record the parameter's new value
1160 in the standard place; do not attempt to change the window. */
1163 x_set_foreground_color (f
, arg
, oldval
)
1165 Lisp_Object arg
, oldval
;
1167 struct x_output
*x
= f
->output_data
.x
;
1168 unsigned long fg
, old_fg
;
1170 fg
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1171 old_fg
= x
->foreground_pixel
;
1172 x
->foreground_pixel
= fg
;
1174 if (FRAME_X_WINDOW (f
) != 0)
1176 Display
*dpy
= FRAME_X_DISPLAY (f
);
1179 XSetForeground (dpy
, x
->normal_gc
, fg
);
1180 XSetBackground (dpy
, x
->reverse_gc
, fg
);
1182 if (x
->cursor_pixel
== old_fg
)
1184 unload_color (f
, x
->cursor_pixel
);
1185 x
->cursor_pixel
= x_copy_color (f
, fg
);
1186 XSetBackground (dpy
, x
->cursor_gc
, x
->cursor_pixel
);
1191 update_face_from_frame_parameter (f
, Qforeground_color
, arg
);
1193 if (FRAME_VISIBLE_P (f
))
1197 unload_color (f
, old_fg
);
1201 x_set_background_color (f
, arg
, oldval
)
1203 Lisp_Object arg
, oldval
;
1205 struct x_output
*x
= f
->output_data
.x
;
1208 bg
= x_decode_color (f
, arg
, WHITE_PIX_DEFAULT (f
));
1209 unload_color (f
, x
->background_pixel
);
1210 x
->background_pixel
= bg
;
1212 if (FRAME_X_WINDOW (f
) != 0)
1214 Display
*dpy
= FRAME_X_DISPLAY (f
);
1217 XSetBackground (dpy
, x
->normal_gc
, bg
);
1218 XSetForeground (dpy
, x
->reverse_gc
, bg
);
1219 XSetWindowBackground (dpy
, FRAME_X_WINDOW (f
), bg
);
1220 XSetForeground (dpy
, x
->cursor_gc
, bg
);
1223 xg_set_background_color (f
, bg
);
1226 #ifndef USE_TOOLKIT_SCROLL_BARS /* Turns out to be annoying with
1227 toolkit scroll bars. */
1230 for (bar
= FRAME_SCROLL_BARS (f
);
1232 bar
= XSCROLL_BAR (bar
)->next
)
1234 Window window
= SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
));
1235 XSetWindowBackground (dpy
, window
, bg
);
1238 #endif /* USE_TOOLKIT_SCROLL_BARS */
1241 update_face_from_frame_parameter (f
, Qbackground_color
, arg
);
1243 if (FRAME_VISIBLE_P (f
))
1249 x_set_mouse_color (f
, arg
, oldval
)
1251 Lisp_Object arg
, oldval
;
1253 struct x_output
*x
= f
->output_data
.x
;
1254 Display
*dpy
= FRAME_X_DISPLAY (f
);
1255 Cursor cursor
, nontext_cursor
, mode_cursor
, hand_cursor
;
1256 Cursor hourglass_cursor
, horizontal_drag_cursor
;
1258 unsigned long pixel
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1259 unsigned long mask_color
= x
->background_pixel
;
1261 /* Don't let pointers be invisible. */
1262 if (mask_color
== pixel
)
1264 x_free_colors (f
, &pixel
, 1);
1265 pixel
= x_copy_color (f
, x
->foreground_pixel
);
1268 unload_color (f
, x
->mouse_pixel
);
1269 x
->mouse_pixel
= pixel
;
1273 /* It's not okay to crash if the user selects a screwy cursor. */
1274 count
= x_catch_errors (dpy
);
1276 if (!NILP (Vx_pointer_shape
))
1278 CHECK_NUMBER (Vx_pointer_shape
);
1279 cursor
= XCreateFontCursor (dpy
, XINT (Vx_pointer_shape
));
1282 cursor
= XCreateFontCursor (dpy
, XC_xterm
);
1283 x_check_errors (dpy
, "bad text pointer cursor: %s");
1285 if (!NILP (Vx_nontext_pointer_shape
))
1287 CHECK_NUMBER (Vx_nontext_pointer_shape
);
1289 = XCreateFontCursor (dpy
, XINT (Vx_nontext_pointer_shape
));
1292 nontext_cursor
= XCreateFontCursor (dpy
, XC_left_ptr
);
1293 x_check_errors (dpy
, "bad nontext pointer cursor: %s");
1295 if (!NILP (Vx_hourglass_pointer_shape
))
1297 CHECK_NUMBER (Vx_hourglass_pointer_shape
);
1299 = XCreateFontCursor (dpy
, XINT (Vx_hourglass_pointer_shape
));
1302 hourglass_cursor
= XCreateFontCursor (dpy
, XC_watch
);
1303 x_check_errors (dpy
, "bad hourglass pointer cursor: %s");
1305 x_check_errors (dpy
, "bad nontext pointer cursor: %s");
1306 if (!NILP (Vx_mode_pointer_shape
))
1308 CHECK_NUMBER (Vx_mode_pointer_shape
);
1309 mode_cursor
= XCreateFontCursor (dpy
, XINT (Vx_mode_pointer_shape
));
1312 mode_cursor
= XCreateFontCursor (dpy
, XC_xterm
);
1313 x_check_errors (dpy
, "bad modeline pointer cursor: %s");
1315 if (!NILP (Vx_sensitive_text_pointer_shape
))
1317 CHECK_NUMBER (Vx_sensitive_text_pointer_shape
);
1319 = XCreateFontCursor (dpy
, XINT (Vx_sensitive_text_pointer_shape
));
1322 hand_cursor
= XCreateFontCursor (dpy
, XC_hand2
);
1324 if (!NILP (Vx_window_horizontal_drag_shape
))
1326 CHECK_NUMBER (Vx_window_horizontal_drag_shape
);
1327 horizontal_drag_cursor
1328 = XCreateFontCursor (dpy
, XINT (Vx_window_horizontal_drag_shape
));
1331 horizontal_drag_cursor
1332 = XCreateFontCursor (dpy
, XC_sb_h_double_arrow
);
1334 /* Check and report errors with the above calls. */
1335 x_check_errors (dpy
, "can't set cursor shape: %s");
1336 x_uncatch_errors (dpy
, count
);
1339 XColor fore_color
, back_color
;
1341 fore_color
.pixel
= x
->mouse_pixel
;
1342 x_query_color (f
, &fore_color
);
1343 back_color
.pixel
= mask_color
;
1344 x_query_color (f
, &back_color
);
1346 XRecolorCursor (dpy
, cursor
, &fore_color
, &back_color
);
1347 XRecolorCursor (dpy
, nontext_cursor
, &fore_color
, &back_color
);
1348 XRecolorCursor (dpy
, mode_cursor
, &fore_color
, &back_color
);
1349 XRecolorCursor (dpy
, hand_cursor
, &fore_color
, &back_color
);
1350 XRecolorCursor (dpy
, hourglass_cursor
, &fore_color
, &back_color
);
1351 XRecolorCursor (dpy
, horizontal_drag_cursor
, &fore_color
, &back_color
);
1354 if (FRAME_X_WINDOW (f
) != 0)
1355 XDefineCursor (dpy
, FRAME_X_WINDOW (f
), cursor
);
1357 if (cursor
!= x
->text_cursor
1358 && x
->text_cursor
!= 0)
1359 XFreeCursor (dpy
, x
->text_cursor
);
1360 x
->text_cursor
= cursor
;
1362 if (nontext_cursor
!= x
->nontext_cursor
1363 && x
->nontext_cursor
!= 0)
1364 XFreeCursor (dpy
, x
->nontext_cursor
);
1365 x
->nontext_cursor
= nontext_cursor
;
1367 if (hourglass_cursor
!= x
->hourglass_cursor
1368 && x
->hourglass_cursor
!= 0)
1369 XFreeCursor (dpy
, x
->hourglass_cursor
);
1370 x
->hourglass_cursor
= hourglass_cursor
;
1372 if (mode_cursor
!= x
->modeline_cursor
1373 && x
->modeline_cursor
!= 0)
1374 XFreeCursor (dpy
, f
->output_data
.x
->modeline_cursor
);
1375 x
->modeline_cursor
= mode_cursor
;
1377 if (hand_cursor
!= x
->hand_cursor
1378 && x
->hand_cursor
!= 0)
1379 XFreeCursor (dpy
, x
->hand_cursor
);
1380 x
->hand_cursor
= hand_cursor
;
1382 if (horizontal_drag_cursor
!= x
->horizontal_drag_cursor
1383 && x
->horizontal_drag_cursor
!= 0)
1384 XFreeCursor (dpy
, x
->horizontal_drag_cursor
);
1385 x
->horizontal_drag_cursor
= horizontal_drag_cursor
;
1390 update_face_from_frame_parameter (f
, Qmouse_color
, arg
);
1394 x_set_cursor_color (f
, arg
, oldval
)
1396 Lisp_Object arg
, oldval
;
1398 unsigned long fore_pixel
, pixel
;
1399 int fore_pixel_allocated_p
= 0, pixel_allocated_p
= 0;
1400 struct x_output
*x
= f
->output_data
.x
;
1402 if (!NILP (Vx_cursor_fore_pixel
))
1404 fore_pixel
= x_decode_color (f
, Vx_cursor_fore_pixel
,
1405 WHITE_PIX_DEFAULT (f
));
1406 fore_pixel_allocated_p
= 1;
1409 fore_pixel
= x
->background_pixel
;
1411 pixel
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1412 pixel_allocated_p
= 1;
1414 /* Make sure that the cursor color differs from the background color. */
1415 if (pixel
== x
->background_pixel
)
1417 if (pixel_allocated_p
)
1419 x_free_colors (f
, &pixel
, 1);
1420 pixel_allocated_p
= 0;
1423 pixel
= x
->mouse_pixel
;
1424 if (pixel
== fore_pixel
)
1426 if (fore_pixel_allocated_p
)
1428 x_free_colors (f
, &fore_pixel
, 1);
1429 fore_pixel_allocated_p
= 0;
1431 fore_pixel
= x
->background_pixel
;
1435 unload_color (f
, x
->cursor_foreground_pixel
);
1436 if (!fore_pixel_allocated_p
)
1437 fore_pixel
= x_copy_color (f
, fore_pixel
);
1438 x
->cursor_foreground_pixel
= fore_pixel
;
1440 unload_color (f
, x
->cursor_pixel
);
1441 if (!pixel_allocated_p
)
1442 pixel
= x_copy_color (f
, pixel
);
1443 x
->cursor_pixel
= pixel
;
1445 if (FRAME_X_WINDOW (f
) != 0)
1448 XSetBackground (FRAME_X_DISPLAY (f
), x
->cursor_gc
, x
->cursor_pixel
);
1449 XSetForeground (FRAME_X_DISPLAY (f
), x
->cursor_gc
, fore_pixel
);
1452 if (FRAME_VISIBLE_P (f
))
1454 x_update_cursor (f
, 0);
1455 x_update_cursor (f
, 1);
1459 update_face_from_frame_parameter (f
, Qcursor_color
, arg
);
1462 /* Set the border-color of frame F to pixel value PIX.
1463 Note that this does not fully take effect if done before
1464 F has an x-window. */
1467 x_set_border_pixel (f
, pix
)
1471 unload_color (f
, f
->output_data
.x
->border_pixel
);
1472 f
->output_data
.x
->border_pixel
= pix
;
1474 if (FRAME_X_WINDOW (f
) != 0 && f
->border_width
> 0)
1477 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1478 (unsigned long)pix
);
1481 if (FRAME_VISIBLE_P (f
))
1486 /* Set the border-color of frame F to value described by ARG.
1487 ARG can be a string naming a color.
1488 The border-color is used for the border that is drawn by the X server.
1489 Note that this does not fully take effect if done before
1490 F has an x-window; it must be redone when the window is created.
1492 Note: this is done in two routines because of the way X10 works.
1494 Note: under X11, this is normally the province of the window manager,
1495 and so emacs' border colors may be overridden. */
1498 x_set_border_color (f
, arg
, oldval
)
1500 Lisp_Object arg
, oldval
;
1505 pix
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1506 x_set_border_pixel (f
, pix
);
1507 update_face_from_frame_parameter (f
, Qborder_color
, arg
);
1512 x_set_cursor_type (f
, arg
, oldval
)
1514 Lisp_Object arg
, oldval
;
1516 set_frame_cursor_types (f
, arg
);
1518 /* Make sure the cursor gets redrawn. */
1519 cursor_type_changed
= 1;
1523 x_set_icon_type (f
, arg
, oldval
)
1525 Lisp_Object arg
, oldval
;
1531 if (STRINGP (oldval
) && EQ (Fstring_equal (oldval
, arg
), Qt
))
1534 else if (!STRINGP (oldval
) && EQ (oldval
, Qnil
) == EQ (arg
, Qnil
))
1539 result
= x_text_icon (f
,
1540 (char *) SDATA ((!NILP (f
->icon_name
)
1544 result
= x_bitmap_icon (f
, arg
);
1549 error ("No icon window available");
1552 XFlush (FRAME_X_DISPLAY (f
));
1557 x_set_icon_name (f
, arg
, oldval
)
1559 Lisp_Object arg
, oldval
;
1565 if (STRINGP (oldval
) && EQ (Fstring_equal (oldval
, arg
), Qt
))
1568 else if (!STRINGP (oldval
) && EQ (oldval
, Qnil
) == EQ (arg
, Qnil
))
1573 if (f
->output_data
.x
->icon_bitmap
!= 0)
1578 result
= x_text_icon (f
,
1579 (char *) SDATA ((!NILP (f
->icon_name
)
1588 error ("No icon window available");
1591 XFlush (FRAME_X_DISPLAY (f
));
1597 x_set_menu_bar_lines (f
, value
, oldval
)
1599 Lisp_Object value
, oldval
;
1602 #ifndef USE_X_TOOLKIT
1603 int olines
= FRAME_MENU_BAR_LINES (f
);
1606 /* Right now, menu bars don't work properly in minibuf-only frames;
1607 most of the commands try to apply themselves to the minibuffer
1608 frame itself, and get an error because you can't switch buffers
1609 in or split the minibuffer window. */
1610 if (FRAME_MINIBUF_ONLY_P (f
))
1613 if (INTEGERP (value
))
1614 nlines
= XINT (value
);
1618 /* Make sure we redisplay all windows in this frame. */
1619 windows_or_buffers_changed
++;
1621 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1622 FRAME_MENU_BAR_LINES (f
) = 0;
1625 FRAME_EXTERNAL_MENU_BAR (f
) = 1;
1626 if (FRAME_X_P (f
) && f
->output_data
.x
->menubar_widget
== 0)
1627 /* Make sure next redisplay shows the menu bar. */
1628 XWINDOW (FRAME_SELECTED_WINDOW (f
))->update_mode_line
= Qt
;
1632 if (FRAME_EXTERNAL_MENU_BAR (f
) == 1)
1633 free_frame_menubar (f
);
1634 FRAME_EXTERNAL_MENU_BAR (f
) = 0;
1636 f
->output_data
.x
->menubar_widget
= 0;
1638 #else /* not USE_X_TOOLKIT && not USE_GTK */
1639 FRAME_MENU_BAR_LINES (f
) = nlines
;
1640 change_window_heights (f
->root_window
, nlines
- olines
);
1641 #endif /* not USE_X_TOOLKIT */
1646 /* Set the number of lines used for the tool bar of frame F to VALUE.
1647 VALUE not an integer, or < 0 means set the lines to zero. OLDVAL
1648 is the old number of tool bar lines. This function changes the
1649 height of all windows on frame F to match the new tool bar height.
1650 The frame's height doesn't change. */
1653 x_set_tool_bar_lines (f
, value
, oldval
)
1655 Lisp_Object value
, oldval
;
1657 int delta
, nlines
, root_height
;
1658 Lisp_Object root_window
;
1660 /* Treat tool bars like menu bars. */
1661 if (FRAME_MINIBUF_ONLY_P (f
))
1664 /* Use VALUE only if an integer >= 0. */
1665 if (INTEGERP (value
) && XINT (value
) >= 0)
1666 nlines
= XFASTINT (value
);
1671 FRAME_TOOL_BAR_LINES (f
) = 0;
1674 FRAME_EXTERNAL_TOOL_BAR (f
) = 1;
1675 if (FRAME_X_P (f
) && f
->output_data
.x
->toolbar_widget
== 0)
1676 /* Make sure next redisplay shows the tool bar. */
1677 XWINDOW (FRAME_SELECTED_WINDOW (f
))->update_mode_line
= Qt
;
1678 update_frame_tool_bar (f
);
1682 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1683 free_frame_tool_bar (f
);
1684 FRAME_EXTERNAL_TOOL_BAR (f
) = 0;
1690 /* Make sure we redisplay all windows in this frame. */
1691 ++windows_or_buffers_changed
;
1693 delta
= nlines
- FRAME_TOOL_BAR_LINES (f
);
1695 /* Don't resize the tool-bar to more than we have room for. */
1696 root_window
= FRAME_ROOT_WINDOW (f
);
1697 root_height
= WINDOW_TOTAL_LINES (XWINDOW (root_window
));
1698 if (root_height
- delta
< 1)
1700 delta
= root_height
- 1;
1701 nlines
= FRAME_TOOL_BAR_LINES (f
) + delta
;
1704 FRAME_TOOL_BAR_LINES (f
) = nlines
;
1705 change_window_heights (root_window
, delta
);
1708 /* We also have to make sure that the internal border at the top of
1709 the frame, below the menu bar or tool bar, is redrawn when the
1710 tool bar disappears. This is so because the internal border is
1711 below the tool bar if one is displayed, but is below the menu bar
1712 if there isn't a tool bar. The tool bar draws into the area
1713 below the menu bar. */
1714 if (FRAME_X_WINDOW (f
) && FRAME_TOOL_BAR_LINES (f
) == 0)
1718 clear_current_matrices (f
);
1719 updating_frame
= NULL
;
1722 /* If the tool bar gets smaller, the internal border below it
1723 has to be cleared. It was formerly part of the display
1724 of the larger tool bar, and updating windows won't clear it. */
1727 int height
= FRAME_INTERNAL_BORDER_WIDTH (f
);
1728 int width
= FRAME_PIXEL_WIDTH (f
);
1729 int y
= nlines
* FRAME_LINE_HEIGHT (f
);
1732 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1733 0, y
, width
, height
, False
);
1736 if (WINDOWP (f
->tool_bar_window
))
1737 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
1742 /* Set the foreground color for scroll bars on frame F to VALUE.
1743 VALUE should be a string, a color name. If it isn't a string or
1744 isn't a valid color name, do nothing. OLDVAL is the old value of
1745 the frame parameter. */
1748 x_set_scroll_bar_foreground (f
, value
, oldval
)
1750 Lisp_Object value
, oldval
;
1752 unsigned long pixel
;
1754 if (STRINGP (value
))
1755 pixel
= x_decode_color (f
, value
, BLACK_PIX_DEFAULT (f
));
1759 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
1760 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
1762 f
->output_data
.x
->scroll_bar_foreground_pixel
= pixel
;
1763 if (FRAME_X_WINDOW (f
) && FRAME_VISIBLE_P (f
))
1765 /* Remove all scroll bars because they have wrong colors. */
1766 if (condemn_scroll_bars_hook
)
1767 (*condemn_scroll_bars_hook
) (f
);
1768 if (judge_scroll_bars_hook
)
1769 (*judge_scroll_bars_hook
) (f
);
1771 update_face_from_frame_parameter (f
, Qscroll_bar_foreground
, value
);
1777 /* Set the background color for scroll bars on frame F to VALUE VALUE
1778 should be a string, a color name. If it isn't a string or isn't a
1779 valid color name, do nothing. OLDVAL is the old value of the frame
1783 x_set_scroll_bar_background (f
, value
, oldval
)
1785 Lisp_Object value
, oldval
;
1787 unsigned long pixel
;
1789 if (STRINGP (value
))
1790 pixel
= x_decode_color (f
, value
, WHITE_PIX_DEFAULT (f
));
1794 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
1795 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
1797 #ifdef USE_TOOLKIT_SCROLL_BARS
1798 /* Scrollbar shadow colors. */
1799 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
1801 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
1802 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= -1;
1804 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
1806 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
1807 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= -1;
1809 #endif /* USE_TOOLKIT_SCROLL_BARS */
1811 f
->output_data
.x
->scroll_bar_background_pixel
= pixel
;
1812 if (FRAME_X_WINDOW (f
) && FRAME_VISIBLE_P (f
))
1814 /* Remove all scroll bars because they have wrong colors. */
1815 if (condemn_scroll_bars_hook
)
1816 (*condemn_scroll_bars_hook
) (f
);
1817 if (judge_scroll_bars_hook
)
1818 (*judge_scroll_bars_hook
) (f
);
1820 update_face_from_frame_parameter (f
, Qscroll_bar_background
, value
);
1826 /* Encode Lisp string STRING as a text in a format appropriate for
1827 XICCC (X Inter Client Communication Conventions).
1829 If STRING contains only ASCII characters, do no conversion and
1830 return the string data of STRING. Otherwise, encode the text by
1831 CODING_SYSTEM, and return a newly allocated memory area which
1832 should be freed by `xfree' by a caller.
1834 SELECTIONP non-zero means the string is being encoded for an X
1835 selection, so it is safe to run pre-write conversions (which
1838 Store the byte length of resulting text in *TEXT_BYTES.
1840 If the text contains only ASCII and Latin-1, store 1 in *STRING_P,
1841 which means that the `encoding' of the result can be `STRING'.
1842 Otherwise store 0 in *STRINGP, which means that the `encoding' of
1843 the result should be `COMPOUND_TEXT'. */
1846 x_encode_text (string
, coding_system
, selectionp
, text_bytes
, stringp
)
1847 Lisp_Object string
, coding_system
;
1848 int *text_bytes
, *stringp
;
1851 unsigned char *str
= SDATA (string
);
1852 int chars
= SCHARS (string
);
1853 int bytes
= SBYTES (string
);
1857 struct coding_system coding
;
1858 extern Lisp_Object Qcompound_text_with_extensions
;
1860 charset_info
= find_charset_in_text (str
, chars
, bytes
, NULL
, Qnil
);
1861 if (charset_info
== 0)
1863 /* No multibyte character in OBJ. We need not encode it. */
1864 *text_bytes
= bytes
;
1869 setup_coding_system (coding_system
, &coding
);
1871 && SYMBOLP (coding
.pre_write_conversion
)
1872 && !NILP (Ffboundp (coding
.pre_write_conversion
)))
1874 string
= run_pre_post_conversion_on_str (string
, &coding
, 1);
1875 str
= SDATA (string
);
1876 chars
= SCHARS (string
);
1877 bytes
= SBYTES (string
);
1879 coding
.src_multibyte
= 1;
1880 coding
.dst_multibyte
= 0;
1881 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
1882 if (coding
.type
== coding_type_iso2022
)
1883 coding
.flags
|= CODING_FLAG_ISO_SAFE
;
1884 /* We suppress producing escape sequences for composition. */
1885 coding
.composing
= COMPOSITION_DISABLED
;
1886 bufsize
= encoding_buffer_size (&coding
, bytes
);
1887 buf
= (unsigned char *) xmalloc (bufsize
);
1888 encode_coding (&coding
, str
, buf
, bytes
, bufsize
);
1889 *text_bytes
= coding
.produced
;
1890 *stringp
= (charset_info
== 1
1891 || (!EQ (coding_system
, Qcompound_text
)
1892 && !EQ (coding_system
, Qcompound_text_with_extensions
)));
1897 /* Change the name of frame F to NAME. If NAME is nil, set F's name to
1900 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1901 name; if NAME is a string, set F's name to NAME and set
1902 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1904 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1905 suggesting a new name, which lisp code should override; if
1906 F->explicit_name is set, ignore the new name; otherwise, set it. */
1909 x_set_name (f
, name
, explicit)
1914 /* Make sure that requests from lisp code override requests from
1915 Emacs redisplay code. */
1918 /* If we're switching from explicit to implicit, we had better
1919 update the mode lines and thereby update the title. */
1920 if (f
->explicit_name
&& NILP (name
))
1921 update_mode_lines
= 1;
1923 f
->explicit_name
= ! NILP (name
);
1925 else if (f
->explicit_name
)
1928 /* If NAME is nil, set the name to the x_id_name. */
1931 /* Check for no change needed in this very common case
1932 before we do any consing. */
1933 if (!strcmp (FRAME_X_DISPLAY_INFO (f
)->x_id_name
,
1936 name
= build_string (FRAME_X_DISPLAY_INFO (f
)->x_id_name
);
1939 CHECK_STRING (name
);
1941 /* Don't change the name if it's already NAME. */
1942 if (! NILP (Fstring_equal (name
, f
->name
)))
1947 /* For setting the frame title, the title parameter should override
1948 the name parameter. */
1949 if (! NILP (f
->title
))
1952 if (FRAME_X_WINDOW (f
))
1957 XTextProperty text
, icon
;
1959 Lisp_Object coding_system
;
1961 /* Note: Encoding strategy
1963 We encode NAME by compound-text and use "COMPOUND-TEXT" in
1964 text.encoding. But, there are non-internationalized window
1965 managers which don't support that encoding. So, if NAME
1966 contains only ASCII and 8859-1 characters, encode it by
1967 iso-latin-1, and use "STRING" in text.encoding hoping that
1968 such window managers at least analyze this format correctly,
1969 i.e. treat 8-bit bytes as 8859-1 characters.
1971 We may also be able to use "UTF8_STRING" in text.encoding
1972 in the future which can encode all Unicode characters.
1973 But, for the moment, there's no way to know that the
1974 current window manager supports it or not. */
1975 coding_system
= Qcompound_text
;
1976 text
.value
= x_encode_text (name
, coding_system
, 0, &bytes
, &stringp
);
1977 text
.encoding
= (stringp
? XA_STRING
1978 : FRAME_X_DISPLAY_INFO (f
)->Xatom_COMPOUND_TEXT
);
1980 text
.nitems
= bytes
;
1982 if (NILP (f
->icon_name
))
1988 /* See the above comment "Note: Encoding strategy". */
1989 icon
.value
= x_encode_text (f
->icon_name
, coding_system
, 0,
1991 icon
.encoding
= (stringp
? XA_STRING
1992 : FRAME_X_DISPLAY_INFO (f
)->Xatom_COMPOUND_TEXT
);
1994 icon
.nitems
= bytes
;
1997 gtk_window_set_title (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1999 #else /* not USE_GTK */
2000 XSetWMName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
2001 #endif /* not USE_GTK */
2003 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &icon
);
2005 if (!NILP (f
->icon_name
)
2006 && icon
.value
!= (unsigned char *) SDATA (f
->icon_name
))
2008 if (text
.value
!= (unsigned char *) SDATA (name
))
2011 #else /* not HAVE_X11R4 */
2012 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2014 XStoreName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2016 #endif /* not HAVE_X11R4 */
2021 /* This function should be called when the user's lisp code has
2022 specified a name for the frame; the name will override any set by the
2025 x_explicitly_set_name (f
, arg
, oldval
)
2027 Lisp_Object arg
, oldval
;
2029 x_set_name (f
, arg
, 1);
2032 /* This function should be called by Emacs redisplay code to set the
2033 name; names set this way will never override names set by the user's
2036 x_implicitly_set_name (f
, arg
, oldval
)
2038 Lisp_Object arg
, oldval
;
2040 x_set_name (f
, arg
, 0);
2043 /* Change the title of frame F to NAME.
2044 If NAME is nil, use the frame name as the title.
2046 If EXPLICIT is non-zero, that indicates that lisp code is setting the
2047 name; if NAME is a string, set F's name to NAME and set
2048 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
2050 If EXPLICIT is zero, that indicates that Emacs redisplay code is
2051 suggesting a new name, which lisp code should override; if
2052 F->explicit_name is set, ignore the new name; otherwise, set it. */
2055 x_set_title (f
, name
, old_name
)
2057 Lisp_Object name
, old_name
;
2059 /* Don't change the title if it's already NAME. */
2060 if (EQ (name
, f
->title
))
2063 update_mode_lines
= 1;
2070 CHECK_STRING (name
);
2072 if (FRAME_X_WINDOW (f
))
2077 XTextProperty text
, icon
;
2079 Lisp_Object coding_system
;
2081 coding_system
= Qcompound_text
;
2082 /* See the comment "Note: Encoding strategy" in x_set_name. */
2083 text
.value
= x_encode_text (name
, coding_system
, 0, &bytes
, &stringp
);
2084 text
.encoding
= (stringp
? XA_STRING
2085 : FRAME_X_DISPLAY_INFO (f
)->Xatom_COMPOUND_TEXT
);
2087 text
.nitems
= bytes
;
2089 if (NILP (f
->icon_name
))
2095 /* See the comment "Note: Encoding strategy" in x_set_name. */
2096 icon
.value
= x_encode_text (f
->icon_name
, coding_system
, 0,
2098 icon
.encoding
= (stringp
? XA_STRING
2099 : FRAME_X_DISPLAY_INFO (f
)->Xatom_COMPOUND_TEXT
);
2101 icon
.nitems
= bytes
;
2105 gtk_window_set_title (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
2107 #else /* not USE_GTK */
2108 XSetWMName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
2109 #endif /* not USE_GTK */
2111 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
2114 if (!NILP (f
->icon_name
)
2115 && icon
.value
!= (unsigned char *) SDATA (f
->icon_name
))
2117 if (text
.value
!= (unsigned char *) SDATA (name
))
2120 #else /* not HAVE_X11R4 */
2121 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2123 XStoreName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2125 #endif /* not HAVE_X11R4 */
2131 x_set_scroll_bar_default_width (f
)
2134 int wid
= FRAME_COLUMN_WIDTH (f
);
2136 #ifdef USE_TOOLKIT_SCROLL_BARS
2137 /* A minimum width of 14 doesn't look good for toolkit scroll bars. */
2138 int width
= 16 + 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
2139 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (width
+ wid
- 1) / wid
;
2140 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) = width
;
2142 /* Make the actual width at least 14 pixels and a multiple of a
2144 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
2146 /* Use all of that space (aside from required margins) for the
2148 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) = 0;
2153 /* Record in frame F the specified or default value according to ALIST
2154 of the parameter named PROP (a Lisp symbol). If no value is
2155 specified for PROP, look for an X default for XPROP on the frame
2156 named NAME. If that is not found either, use the value DEFLT. */
2159 x_default_scroll_bar_color_parameter (f
, alist
, prop
, xprop
, xclass
,
2168 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2171 tem
= x_get_arg (dpyinfo
, alist
, prop
, xprop
, xclass
, RES_TYPE_STRING
);
2172 if (EQ (tem
, Qunbound
))
2174 #ifdef USE_TOOLKIT_SCROLL_BARS
2176 /* See if an X resource for the scroll bar color has been
2178 tem
= display_x_get_resource (dpyinfo
,
2179 build_string (foreground_p
2183 build_string ("verticalScrollBar"),
2187 /* If nothing has been specified, scroll bars will use a
2188 toolkit-dependent default. Because these defaults are
2189 difficult to get at without actually creating a scroll
2190 bar, use nil to indicate that no color has been
2195 #else /* not USE_TOOLKIT_SCROLL_BARS */
2199 #endif /* not USE_TOOLKIT_SCROLL_BARS */
2202 x_set_frame_parameters (f
, Fcons (Fcons (prop
, tem
), Qnil
));
2208 #if !defined (HAVE_X11R4) && !defined (HAVE_XSETWMPROTOCOLS)
2211 XSetWMProtocols (dpy
, w
, protocols
, count
)
2218 prop
= XInternAtom (dpy
, "WM_PROTOCOLS", False
);
2219 if (prop
== None
) return False
;
2220 XChangeProperty (dpy
, w
, prop
, XA_ATOM
, 32, PropModeReplace
,
2221 (unsigned char *) protocols
, count
);
2224 #endif /* not HAVE_X11R4 && not HAVE_XSETWMPROTOCOLS */
2226 #ifdef USE_X_TOOLKIT
2228 /* If the WM_PROTOCOLS property does not already contain WM_TAKE_FOCUS,
2229 WM_DELETE_WINDOW, and WM_SAVE_YOURSELF, then add them. (They may
2230 already be present because of the toolkit (Motif adds some of them,
2231 for example, but Xt doesn't). */
2234 hack_wm_protocols (f
, widget
)
2238 Display
*dpy
= XtDisplay (widget
);
2239 Window w
= XtWindow (widget
);
2240 int need_delete
= 1;
2246 Atom type
, *atoms
= 0;
2248 unsigned long nitems
= 0;
2249 unsigned long bytes_after
;
2251 if ((XGetWindowProperty (dpy
, w
,
2252 FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_protocols
,
2253 (long)0, (long)100, False
, XA_ATOM
,
2254 &type
, &format
, &nitems
, &bytes_after
,
2255 (unsigned char **) &atoms
)
2257 && format
== 32 && type
== XA_ATOM
)
2261 if (atoms
[nitems
] == FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_delete_window
)
2263 else if (atoms
[nitems
] == FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_take_focus
)
2265 else if (atoms
[nitems
] == FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_save_yourself
)
2268 if (atoms
) XFree ((char *) atoms
);
2274 props
[count
++] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_delete_window
;
2276 props
[count
++] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_take_focus
;
2278 props
[count
++] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_save_yourself
;
2280 XChangeProperty (dpy
, w
, FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_protocols
,
2281 XA_ATOM
, 32, PropModeAppend
,
2282 (unsigned char *) props
, count
);
2290 /* Support routines for XIC (X Input Context). */
2294 static XFontSet xic_create_xfontset
P_ ((struct frame
*, char *));
2295 static XIMStyle best_xim_style
P_ ((XIMStyles
*, XIMStyles
*));
2298 /* Supported XIM styles, ordered by preference. */
2300 static XIMStyle supported_xim_styles
[] =
2302 XIMPreeditPosition
| XIMStatusArea
,
2303 XIMPreeditPosition
| XIMStatusNothing
,
2304 XIMPreeditPosition
| XIMStatusNone
,
2305 XIMPreeditNothing
| XIMStatusArea
,
2306 XIMPreeditNothing
| XIMStatusNothing
,
2307 XIMPreeditNothing
| XIMStatusNone
,
2308 XIMPreeditNone
| XIMStatusArea
,
2309 XIMPreeditNone
| XIMStatusNothing
,
2310 XIMPreeditNone
| XIMStatusNone
,
2315 /* Create an X fontset on frame F with base font name
2319 xic_create_xfontset (f
, base_fontname
)
2321 char *base_fontname
;
2324 char **missing_list
;
2328 xfs
= XCreateFontSet (FRAME_X_DISPLAY (f
),
2329 base_fontname
, &missing_list
,
2330 &missing_count
, &def_string
);
2332 XFreeStringList (missing_list
);
2334 /* No need to free def_string. */
2339 /* Value is the best input style, given user preferences USER (already
2340 checked to be supported by Emacs), and styles supported by the
2341 input method XIM. */
2344 best_xim_style (user
, xim
)
2350 for (i
= 0; i
< user
->count_styles
; ++i
)
2351 for (j
= 0; j
< xim
->count_styles
; ++j
)
2352 if (user
->supported_styles
[i
] == xim
->supported_styles
[j
])
2353 return user
->supported_styles
[i
];
2355 /* Return the default style. */
2356 return XIMPreeditNothing
| XIMStatusNothing
;
2359 /* Create XIC for frame F. */
2361 static XIMStyle xic_style
;
2364 create_frame_xic (f
)
2369 XFontSet xfs
= NULL
;
2374 xim
= FRAME_X_XIM (f
);
2379 XVaNestedList preedit_attr
;
2380 XVaNestedList status_attr
;
2381 char *base_fontname
;
2384 s_area
.x
= 0; s_area
.y
= 0; s_area
.width
= 1; s_area
.height
= 1;
2385 spot
.x
= 0; spot
.y
= 1;
2386 /* Create X fontset. */
2387 fontset
= FRAME_FONTSET (f
);
2389 base_fontname
= "-*-*-*-r-normal--14-*-*-*-*-*-*-*";
2392 /* Determine the base fontname from the ASCII font name of
2394 char *ascii_font
= (char *) SDATA (fontset_ascii (fontset
));
2395 char *p
= ascii_font
;
2398 for (i
= 0; *p
; p
++)
2401 /* As the font name doesn't conform to XLFD, we can't
2402 modify it to get a suitable base fontname for the
2404 base_fontname
= "-*-*-*-r-normal--14-*-*-*-*-*-*-*";
2407 int len
= strlen (ascii_font
) + 1;
2410 for (i
= 0, p
= ascii_font
; i
< 8; p
++)
2419 base_fontname
= (char *) alloca (len
);
2420 bzero (base_fontname
, len
);
2421 strcpy (base_fontname
, "-*-*-");
2422 bcopy (p1
, base_fontname
+ 5, p
- p1
);
2423 strcat (base_fontname
, "*-*-*-*-*-*-*");
2426 xfs
= xic_create_xfontset (f
, base_fontname
);
2428 /* Determine XIC style. */
2431 XIMStyles supported_list
;
2432 supported_list
.count_styles
= (sizeof supported_xim_styles
2433 / sizeof supported_xim_styles
[0]);
2434 supported_list
.supported_styles
= supported_xim_styles
;
2435 xic_style
= best_xim_style (&supported_list
,
2436 FRAME_X_XIM_STYLES (f
));
2439 preedit_attr
= XVaCreateNestedList (0,
2442 FRAME_FOREGROUND_PIXEL (f
),
2444 FRAME_BACKGROUND_PIXEL (f
),
2445 (xic_style
& XIMPreeditPosition
2450 status_attr
= XVaCreateNestedList (0,
2456 FRAME_FOREGROUND_PIXEL (f
),
2458 FRAME_BACKGROUND_PIXEL (f
),
2461 xic
= XCreateIC (xim
,
2462 XNInputStyle
, xic_style
,
2463 XNClientWindow
, FRAME_X_WINDOW (f
),
2464 XNFocusWindow
, FRAME_X_WINDOW (f
),
2465 XNStatusAttributes
, status_attr
,
2466 XNPreeditAttributes
, preedit_attr
,
2468 XFree (preedit_attr
);
2469 XFree (status_attr
);
2472 FRAME_XIC (f
) = xic
;
2473 FRAME_XIC_STYLE (f
) = xic_style
;
2474 FRAME_XIC_FONTSET (f
) = xfs
;
2478 /* Destroy XIC and free XIC fontset of frame F, if any. */
2484 if (FRAME_XIC (f
) == NULL
)
2487 XDestroyIC (FRAME_XIC (f
));
2488 if (FRAME_XIC_FONTSET (f
))
2489 XFreeFontSet (FRAME_X_DISPLAY (f
), FRAME_XIC_FONTSET (f
));
2491 FRAME_XIC (f
) = NULL
;
2492 FRAME_XIC_FONTSET (f
) = NULL
;
2496 /* Place preedit area for XIC of window W's frame to specified
2497 pixel position X/Y. X and Y are relative to window W. */
2500 xic_set_preeditarea (w
, x
, y
)
2504 struct frame
*f
= XFRAME (w
->frame
);
2508 spot
.x
= WINDOW_TO_FRAME_PIXEL_X (w
, x
) + WINDOW_LEFT_FRINGE_WIDTH (w
);
2509 spot
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, y
) + FONT_BASE (FRAME_FONT (f
));
2510 attr
= XVaCreateNestedList (0, XNSpotLocation
, &spot
, NULL
);
2511 XSetICValues (FRAME_XIC (f
), XNPreeditAttributes
, attr
, NULL
);
2516 /* Place status area for XIC in bottom right corner of frame F.. */
2519 xic_set_statusarea (f
)
2522 XIC xic
= FRAME_XIC (f
);
2527 /* Negotiate geometry of status area. If input method has existing
2528 status area, use its current size. */
2529 area
.x
= area
.y
= area
.width
= area
.height
= 0;
2530 attr
= XVaCreateNestedList (0, XNAreaNeeded
, &area
, NULL
);
2531 XSetICValues (xic
, XNStatusAttributes
, attr
, NULL
);
2534 attr
= XVaCreateNestedList (0, XNAreaNeeded
, &needed
, NULL
);
2535 XGetICValues (xic
, XNStatusAttributes
, attr
, NULL
);
2538 if (needed
->width
== 0) /* Use XNArea instead of XNAreaNeeded */
2540 attr
= XVaCreateNestedList (0, XNArea
, &needed
, NULL
);
2541 XGetICValues (xic
, XNStatusAttributes
, attr
, NULL
);
2545 area
.width
= needed
->width
;
2546 area
.height
= needed
->height
;
2547 area
.x
= FRAME_PIXEL_WIDTH (f
) - area
.width
- FRAME_INTERNAL_BORDER_WIDTH (f
);
2548 area
.y
= (FRAME_PIXEL_HEIGHT (f
) - area
.height
2549 - FRAME_MENUBAR_HEIGHT (f
)
2550 - FRAME_TOOLBAR_HEIGHT (f
)
2551 - FRAME_INTERNAL_BORDER_WIDTH (f
));
2554 attr
= XVaCreateNestedList (0, XNArea
, &area
, NULL
);
2555 XSetICValues (xic
, XNStatusAttributes
, attr
, NULL
);
2560 /* Set X fontset for XIC of frame F, using base font name
2561 BASE_FONTNAME. Called when a new Emacs fontset is chosen. */
2564 xic_set_xfontset (f
, base_fontname
)
2566 char *base_fontname
;
2571 xfs
= xic_create_xfontset (f
, base_fontname
);
2573 attr
= XVaCreateNestedList (0, XNFontSet
, xfs
, NULL
);
2574 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
2575 XSetICValues (FRAME_XIC (f
), XNPreeditAttributes
, attr
, NULL
);
2576 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
2577 XSetICValues (FRAME_XIC (f
), XNStatusAttributes
, attr
, NULL
);
2580 if (FRAME_XIC_FONTSET (f
))
2581 XFreeFontSet (FRAME_X_DISPLAY (f
), FRAME_XIC_FONTSET (f
));
2582 FRAME_XIC_FONTSET (f
) = xfs
;
2585 #endif /* HAVE_X_I18N */
2589 #ifdef USE_X_TOOLKIT
2591 /* Create and set up the X widget for frame F. */
2594 x_window (f
, window_prompting
, minibuffer_only
)
2596 long window_prompting
;
2597 int minibuffer_only
;
2599 XClassHint class_hints
;
2600 XSetWindowAttributes attributes
;
2601 unsigned long attribute_mask
;
2602 Widget shell_widget
;
2604 Widget frame_widget
;
2610 /* Use the resource name as the top-level widget name
2611 for looking up resources. Make a non-Lisp copy
2612 for the window manager, so GC relocation won't bother it.
2614 Elsewhere we specify the window name for the window manager. */
2617 char *str
= (char *) SDATA (Vx_resource_name
);
2618 f
->namebuf
= (char *) xmalloc (strlen (str
) + 1);
2619 strcpy (f
->namebuf
, str
);
2623 XtSetArg (al
[ac
], XtNallowShellResize
, 1); ac
++;
2624 XtSetArg (al
[ac
], XtNinput
, 1); ac
++;
2625 XtSetArg (al
[ac
], XtNmappedWhenManaged
, 0); ac
++;
2626 XtSetArg (al
[ac
], XtNborderWidth
, f
->border_width
); ac
++;
2627 XtSetArg (al
[ac
], XtNvisual
, FRAME_X_VISUAL (f
)); ac
++;
2628 XtSetArg (al
[ac
], XtNdepth
, FRAME_X_DISPLAY_INFO (f
)->n_planes
); ac
++;
2629 XtSetArg (al
[ac
], XtNcolormap
, FRAME_X_COLORMAP (f
)); ac
++;
2630 shell_widget
= XtAppCreateShell (f
->namebuf
, EMACS_CLASS
,
2631 applicationShellWidgetClass
,
2632 FRAME_X_DISPLAY (f
), al
, ac
);
2634 f
->output_data
.x
->widget
= shell_widget
;
2635 /* maybe_set_screen_title_format (shell_widget); */
2637 pane_widget
= lw_create_widget ("main", "pane", widget_id_tick
++,
2638 (widget_value
*) NULL
,
2639 shell_widget
, False
,
2643 (lw_callback
) NULL
);
2646 XtSetArg (al
[ac
], XtNvisual
, FRAME_X_VISUAL (f
)); ac
++;
2647 XtSetArg (al
[ac
], XtNdepth
, FRAME_X_DISPLAY_INFO (f
)->n_planes
); ac
++;
2648 XtSetArg (al
[ac
], XtNcolormap
, FRAME_X_COLORMAP (f
)); ac
++;
2649 XtSetValues (pane_widget
, al
, ac
);
2650 f
->output_data
.x
->column_widget
= pane_widget
;
2652 /* mappedWhenManaged to false tells to the paned window to not map/unmap
2653 the emacs screen when changing menubar. This reduces flickering. */
2656 XtSetArg (al
[ac
], XtNmappedWhenManaged
, 0); ac
++;
2657 XtSetArg (al
[ac
], XtNshowGrip
, 0); ac
++;
2658 XtSetArg (al
[ac
], XtNallowResize
, 1); ac
++;
2659 XtSetArg (al
[ac
], XtNresizeToPreferred
, 1); ac
++;
2660 XtSetArg (al
[ac
], XtNemacsFrame
, f
); ac
++;
2661 XtSetArg (al
[ac
], XtNvisual
, FRAME_X_VISUAL (f
)); ac
++;
2662 XtSetArg (al
[ac
], XtNdepth
, FRAME_X_DISPLAY_INFO (f
)->n_planes
); ac
++;
2663 XtSetArg (al
[ac
], XtNcolormap
, FRAME_X_COLORMAP (f
)); ac
++;
2664 frame_widget
= XtCreateWidget (f
->namebuf
, emacsFrameClass
, pane_widget
,
2667 f
->output_data
.x
->edit_widget
= frame_widget
;
2669 XtManageChild (frame_widget
);
2671 /* Do some needed geometry management. */
2674 char *tem
, shell_position
[32];
2677 int extra_borders
= 0;
2679 = (f
->output_data
.x
->menubar_widget
2680 ? (f
->output_data
.x
->menubar_widget
->core
.height
2681 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
2684 #if 0 /* Experimentally, we now get the right results
2685 for -geometry -0-0 without this. 24 Aug 96, rms. */
2686 if (FRAME_EXTERNAL_MENU_BAR (f
))
2689 XtVaGetValues (pane_widget
, XtNinternalBorderWidth
, &ibw
, NULL
);
2690 menubar_size
+= ibw
;
2694 f
->output_data
.x
->menubar_height
= menubar_size
;
2697 /* Motif seems to need this amount added to the sizes
2698 specified for the shell widget. The Athena/Lucid widgets don't.
2699 Both conclusions reached experimentally. -- rms. */
2700 XtVaGetValues (f
->output_data
.x
->edit_widget
, XtNinternalBorderWidth
,
2701 &extra_borders
, NULL
);
2705 /* Convert our geometry parameters into a geometry string
2707 Note that we do not specify here whether the position
2708 is a user-specified or program-specified one.
2709 We pass that information later, in x_wm_set_size_hints. */
2711 int left
= f
->left_pos
;
2712 int xneg
= window_prompting
& XNegative
;
2713 int top
= f
->top_pos
;
2714 int yneg
= window_prompting
& YNegative
;
2720 if (window_prompting
& USPosition
)
2721 sprintf (shell_position
, "=%dx%d%c%d%c%d",
2722 FRAME_PIXEL_WIDTH (f
) + extra_borders
,
2723 FRAME_PIXEL_HEIGHT (f
) + menubar_size
+ extra_borders
,
2724 (xneg
? '-' : '+'), left
,
2725 (yneg
? '-' : '+'), top
);
2728 sprintf (shell_position
, "=%dx%d",
2729 FRAME_PIXEL_WIDTH (f
) + extra_borders
,
2730 FRAME_PIXEL_HEIGHT (f
) + menubar_size
+ extra_borders
);
2732 /* Setting x and y when the position is not specified in
2733 the geometry string will set program position in the WM hints.
2734 If Emacs had just one program position, we could set it in
2735 fallback resources, but since each make-frame call can specify
2736 different program positions, this is easier. */
2737 XtSetArg (al
[ac
], XtNx
, left
); ac
++;
2738 XtSetArg (al
[ac
], XtNy
, top
); ac
++;
2742 len
= strlen (shell_position
) + 1;
2743 /* We don't free this because we don't know whether
2744 it is safe to free it while the frame exists.
2745 It isn't worth the trouble of arranging to free it
2746 when the frame is deleted. */
2747 tem
= (char *) xmalloc (len
);
2748 strncpy (tem
, shell_position
, len
);
2749 XtSetArg (al
[ac
], XtNgeometry
, tem
); ac
++;
2750 XtSetValues (shell_widget
, al
, ac
);
2753 XtManageChild (pane_widget
);
2754 XtRealizeWidget (shell_widget
);
2756 FRAME_X_WINDOW (f
) = XtWindow (frame_widget
);
2758 validate_x_resource_name ();
2760 class_hints
.res_name
= (char *) SDATA (Vx_resource_name
);
2761 class_hints
.res_class
= (char *) SDATA (Vx_resource_class
);
2762 XSetClassHint (FRAME_X_DISPLAY (f
), XtWindow (shell_widget
), &class_hints
);
2765 FRAME_XIC (f
) = NULL
;
2767 create_frame_xic (f
);
2770 f
->output_data
.x
->wm_hints
.input
= True
;
2771 f
->output_data
.x
->wm_hints
.flags
|= InputHint
;
2772 XSetWMHints (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2773 &f
->output_data
.x
->wm_hints
);
2775 hack_wm_protocols (f
, shell_widget
);
2778 XtAddEventHandler (shell_widget
, 0, True
, _XEditResCheckMessages
, 0);
2781 /* Do a stupid property change to force the server to generate a
2782 PropertyNotify event so that the event_stream server timestamp will
2783 be initialized to something relevant to the time we created the window.
2785 XChangeProperty (XtDisplay (frame_widget
), XtWindow (frame_widget
),
2786 FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_protocols
,
2787 XA_ATOM
, 32, PropModeAppend
,
2788 (unsigned char*) NULL
, 0);
2790 /* Make all the standard events reach the Emacs frame. */
2791 attributes
.event_mask
= STANDARD_EVENT_SET
;
2796 /* XIM server might require some X events. */
2797 unsigned long fevent
= NoEventMask
;
2798 XGetICValues (FRAME_XIC (f
), XNFilterEvents
, &fevent
, NULL
);
2799 attributes
.event_mask
|= fevent
;
2801 #endif /* HAVE_X_I18N */
2803 attribute_mask
= CWEventMask
;
2804 XChangeWindowAttributes (XtDisplay (shell_widget
), XtWindow (shell_widget
),
2805 attribute_mask
, &attributes
);
2807 XtMapWidget (frame_widget
);
2809 /* x_set_name normally ignores requests to set the name if the
2810 requested name is the same as the current name. This is the one
2811 place where that assumption isn't correct; f->name is set, but
2812 the X server hasn't been told. */
2815 int explicit = f
->explicit_name
;
2817 f
->explicit_name
= 0;
2820 x_set_name (f
, name
, explicit);
2823 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2824 f
->output_data
.x
->text_cursor
);
2828 /* This is a no-op, except under Motif. Make sure main areas are
2829 set to something reasonable, in case we get an error later. */
2830 lw_set_main_areas (pane_widget
, 0, frame_widget
);
2833 #else /* not USE_X_TOOLKIT */
2839 if (! xg_create_frame_widgets (f
))
2840 error ("Unable to create window");
2843 FRAME_XIC (f
) = NULL
;
2847 create_frame_xic (f
);
2850 /* XIM server might require some X events. */
2851 unsigned long fevent
= NoEventMask
;
2852 XGetICValues (FRAME_XIC (f
), XNFilterEvents
, &fevent
, NULL
);
2854 if (fevent
!= NoEventMask
)
2856 XSetWindowAttributes attributes
;
2857 XWindowAttributes wattr
;
2858 unsigned long attribute_mask
;
2860 XGetWindowAttributes (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2862 attributes
.event_mask
= wattr
.your_event_mask
| fevent
;
2863 attribute_mask
= CWEventMask
;
2864 XChangeWindowAttributes (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2865 attribute_mask
, &attributes
);
2873 #else /*! USE_GTK */
2874 /* Create and set up the X window for frame F. */
2881 XClassHint class_hints
;
2882 XSetWindowAttributes attributes
;
2883 unsigned long attribute_mask
;
2885 attributes
.background_pixel
= f
->output_data
.x
->background_pixel
;
2886 attributes
.border_pixel
= f
->output_data
.x
->border_pixel
;
2887 attributes
.bit_gravity
= StaticGravity
;
2888 attributes
.backing_store
= NotUseful
;
2889 attributes
.save_under
= True
;
2890 attributes
.event_mask
= STANDARD_EVENT_SET
;
2891 attributes
.colormap
= FRAME_X_COLORMAP (f
);
2892 attribute_mask
= (CWBackPixel
| CWBorderPixel
| CWBitGravity
| CWEventMask
2897 = XCreateWindow (FRAME_X_DISPLAY (f
),
2898 f
->output_data
.x
->parent_desc
,
2901 FRAME_PIXEL_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
),
2903 CopyFromParent
, /* depth */
2904 InputOutput
, /* class */
2906 attribute_mask
, &attributes
);
2911 create_frame_xic (f
);
2914 /* XIM server might require some X events. */
2915 unsigned long fevent
= NoEventMask
;
2916 XGetICValues (FRAME_XIC (f
), XNFilterEvents
, &fevent
, NULL
);
2917 attributes
.event_mask
|= fevent
;
2918 attribute_mask
= CWEventMask
;
2919 XChangeWindowAttributes (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2920 attribute_mask
, &attributes
);
2923 #endif /* HAVE_X_I18N */
2925 validate_x_resource_name ();
2927 class_hints
.res_name
= (char *) SDATA (Vx_resource_name
);
2928 class_hints
.res_class
= (char *) SDATA (Vx_resource_class
);
2929 XSetClassHint (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &class_hints
);
2931 /* The menubar is part of the ordinary display;
2932 it does not count in addition to the height of the window. */
2933 f
->output_data
.x
->menubar_height
= 0;
2935 /* This indicates that we use the "Passive Input" input model.
2936 Unless we do this, we don't get the Focus{In,Out} events that we
2937 need to draw the cursor correctly. Accursed bureaucrats.
2938 XWhipsAndChains (FRAME_X_DISPLAY (f), IronMaiden, &TheRack); */
2940 f
->output_data
.x
->wm_hints
.input
= True
;
2941 f
->output_data
.x
->wm_hints
.flags
|= InputHint
;
2942 XSetWMHints (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2943 &f
->output_data
.x
->wm_hints
);
2944 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
2946 /* Request "save yourself" and "delete window" commands from wm. */
2949 protocols
[0] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_delete_window
;
2950 protocols
[1] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_save_yourself
;
2951 XSetWMProtocols (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), protocols
, 2);
2954 /* x_set_name normally ignores requests to set the name if the
2955 requested name is the same as the current name. This is the one
2956 place where that assumption isn't correct; f->name is set, but
2957 the X server hasn't been told. */
2960 int explicit = f
->explicit_name
;
2962 f
->explicit_name
= 0;
2965 x_set_name (f
, name
, explicit);
2968 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2969 f
->output_data
.x
->text_cursor
);
2973 if (FRAME_X_WINDOW (f
) == 0)
2974 error ("Unable to create window");
2977 #endif /* not USE_GTK */
2978 #endif /* not USE_X_TOOLKIT */
2980 /* Handle the icon stuff for this window. Perhaps later we might
2981 want an x_set_icon_position which can be called interactively as
2989 Lisp_Object icon_x
, icon_y
;
2990 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2992 /* Set the position of the icon. Note that twm groups all
2993 icons in an icon window. */
2994 icon_x
= x_frame_get_and_record_arg (f
, parms
, Qicon_left
, 0, 0, RES_TYPE_NUMBER
);
2995 icon_y
= x_frame_get_and_record_arg (f
, parms
, Qicon_top
, 0, 0, RES_TYPE_NUMBER
);
2996 if (!EQ (icon_x
, Qunbound
) && !EQ (icon_y
, Qunbound
))
2998 CHECK_NUMBER (icon_x
);
2999 CHECK_NUMBER (icon_y
);
3001 else if (!EQ (icon_x
, Qunbound
) || !EQ (icon_y
, Qunbound
))
3002 error ("Both left and top icon corners of icon must be specified");
3006 if (! EQ (icon_x
, Qunbound
))
3007 x_wm_set_icon_position (f
, XINT (icon_x
), XINT (icon_y
));
3009 /* Start up iconic or window? */
3010 x_wm_set_window_state
3011 (f
, (EQ (x_get_arg (dpyinfo
, parms
, Qvisibility
, 0, 0, RES_TYPE_SYMBOL
),
3016 x_text_icon (f
, (char *) SDATA ((!NILP (f
->icon_name
)
3023 /* Make the GCs needed for this window, setting the
3024 background, border and mouse colors; also create the
3025 mouse cursor and the gray border tile. */
3027 static char cursor_bits
[] =
3029 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3030 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3031 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3032 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
3039 XGCValues gc_values
;
3043 /* Create the GCs of this frame.
3044 Note that many default values are used. */
3047 gc_values
.font
= FRAME_FONT (f
)->fid
;
3048 gc_values
.foreground
= f
->output_data
.x
->foreground_pixel
;
3049 gc_values
.background
= f
->output_data
.x
->background_pixel
;
3050 gc_values
.line_width
= 0; /* Means 1 using fast algorithm. */
3051 f
->output_data
.x
->normal_gc
3052 = XCreateGC (FRAME_X_DISPLAY (f
),
3054 GCLineWidth
| GCFont
| GCForeground
| GCBackground
,
3057 /* Reverse video style. */
3058 gc_values
.foreground
= f
->output_data
.x
->background_pixel
;
3059 gc_values
.background
= f
->output_data
.x
->foreground_pixel
;
3060 f
->output_data
.x
->reverse_gc
3061 = XCreateGC (FRAME_X_DISPLAY (f
),
3063 GCFont
| GCForeground
| GCBackground
| GCLineWidth
,
3066 /* Cursor has cursor-color background, background-color foreground. */
3067 gc_values
.foreground
= f
->output_data
.x
->background_pixel
;
3068 gc_values
.background
= f
->output_data
.x
->cursor_pixel
;
3069 gc_values
.fill_style
= FillOpaqueStippled
;
3071 = XCreateBitmapFromData (FRAME_X_DISPLAY (f
),
3072 FRAME_X_DISPLAY_INFO (f
)->root_window
,
3073 cursor_bits
, 16, 16);
3074 f
->output_data
.x
->cursor_gc
3075 = XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3076 (GCFont
| GCForeground
| GCBackground
3077 | GCFillStyle
/* | GCStipple */ | GCLineWidth
),
3081 f
->output_data
.x
->white_relief
.gc
= 0;
3082 f
->output_data
.x
->black_relief
.gc
= 0;
3084 /* Create the gray border tile used when the pointer is not in
3085 the frame. Since this depends on the frame's pixel values,
3086 this must be done on a per-frame basis. */
3087 f
->output_data
.x
->border_tile
3088 = (XCreatePixmapFromBitmapData
3089 (FRAME_X_DISPLAY (f
), FRAME_X_DISPLAY_INFO (f
)->root_window
,
3090 gray_bits
, gray_width
, gray_height
,
3091 f
->output_data
.x
->foreground_pixel
,
3092 f
->output_data
.x
->background_pixel
,
3093 DefaultDepth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
))));
3099 /* Free what was was allocated in x_make_gc. */
3105 Display
*dpy
= FRAME_X_DISPLAY (f
);
3109 if (f
->output_data
.x
->normal_gc
)
3111 XFreeGC (dpy
, f
->output_data
.x
->normal_gc
);
3112 f
->output_data
.x
->normal_gc
= 0;
3115 if (f
->output_data
.x
->reverse_gc
)
3117 XFreeGC (dpy
, f
->output_data
.x
->reverse_gc
);
3118 f
->output_data
.x
->reverse_gc
= 0;
3121 if (f
->output_data
.x
->cursor_gc
)
3123 XFreeGC (dpy
, f
->output_data
.x
->cursor_gc
);
3124 f
->output_data
.x
->cursor_gc
= 0;
3127 if (f
->output_data
.x
->border_tile
)
3129 XFreePixmap (dpy
, f
->output_data
.x
->border_tile
);
3130 f
->output_data
.x
->border_tile
= 0;
3137 /* Handler for signals raised during x_create_frame and
3138 x_create_top_frame. FRAME is the frame which is partially
3142 unwind_create_frame (frame
)
3145 struct frame
*f
= XFRAME (frame
);
3147 /* If frame is ``official'', nothing to do. */
3148 if (!CONSP (Vframe_list
) || !EQ (XCAR (Vframe_list
), frame
))
3151 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3154 x_free_frame_resources (f
);
3156 /* Check that reference counts are indeed correct. */
3157 xassert (dpyinfo
->reference_count
== dpyinfo_refcount
);
3158 xassert (dpyinfo
->image_cache
->refcount
== image_cache_refcount
);
3166 DEFUN ("x-create-frame", Fx_create_frame
, Sx_create_frame
,
3168 doc
: /* Make a new X window, which is called a "frame" in Emacs terms.
3169 Returns an Emacs frame object.
3170 ALIST is an alist of frame parameters.
3171 If the parameters specify that the frame should not have a minibuffer,
3172 and do not specify a specific minibuffer window to use,
3173 then `default-minibuffer-frame' must be a frame whose minibuffer can
3174 be shared by the new frame.
3176 This function is an internal primitive--use `make-frame' instead. */)
3181 Lisp_Object frame
, tem
;
3183 int minibuffer_only
= 0;
3184 long window_prompting
= 0;
3186 int count
= SPECPDL_INDEX ();
3187 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
3188 Lisp_Object display
;
3189 struct x_display_info
*dpyinfo
= NULL
;
3195 /* Use this general default value to start with
3196 until we know if this frame has a specified name. */
3197 Vx_resource_name
= Vinvocation_name
;
3199 display
= x_get_arg (dpyinfo
, parms
, Qdisplay
, 0, 0, RES_TYPE_STRING
);
3200 if (EQ (display
, Qunbound
))
3202 dpyinfo
= check_x_display_info (display
);
3204 kb
= dpyinfo
->kboard
;
3206 kb
= &the_only_kboard
;
3209 name
= x_get_arg (dpyinfo
, parms
, Qname
, "name", "Name", RES_TYPE_STRING
);
3211 && ! EQ (name
, Qunbound
)
3213 error ("Invalid frame name--not a string or nil");
3216 Vx_resource_name
= name
;
3218 /* See if parent window is specified. */
3219 parent
= x_get_arg (dpyinfo
, parms
, Qparent_id
, NULL
, NULL
, RES_TYPE_NUMBER
);
3220 if (EQ (parent
, Qunbound
))
3222 if (! NILP (parent
))
3223 CHECK_NUMBER (parent
);
3225 /* make_frame_without_minibuffer can run Lisp code and garbage collect. */
3226 /* No need to protect DISPLAY because that's not used after passing
3227 it to make_frame_without_minibuffer. */
3229 GCPRO4 (parms
, parent
, name
, frame
);
3230 tem
= x_get_arg (dpyinfo
, parms
, Qminibuffer
, "minibuffer", "Minibuffer",
3232 if (EQ (tem
, Qnone
) || NILP (tem
))
3233 f
= make_frame_without_minibuffer (Qnil
, kb
, display
);
3234 else if (EQ (tem
, Qonly
))
3236 f
= make_minibuffer_frame ();
3237 minibuffer_only
= 1;
3239 else if (WINDOWP (tem
))
3240 f
= make_frame_without_minibuffer (tem
, kb
, display
);
3244 XSETFRAME (frame
, f
);
3246 /* Note that X Windows does support scroll bars. */
3247 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 1;
3249 f
->output_method
= output_x_window
;
3250 f
->output_data
.x
= (struct x_output
*) xmalloc (sizeof (struct x_output
));
3251 bzero (f
->output_data
.x
, sizeof (struct x_output
));
3252 f
->output_data
.x
->icon_bitmap
= -1;
3253 FRAME_FONTSET (f
) = -1;
3254 f
->output_data
.x
->scroll_bar_foreground_pixel
= -1;
3255 f
->output_data
.x
->scroll_bar_background_pixel
= -1;
3256 #ifdef USE_TOOLKIT_SCROLL_BARS
3257 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= -1;
3258 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= -1;
3259 #endif /* USE_TOOLKIT_SCROLL_BARS */
3260 record_unwind_protect (unwind_create_frame
, frame
);
3263 = x_get_arg (dpyinfo
, parms
, Qicon_name
, "iconName", "Title",
3265 if (! STRINGP (f
->icon_name
))
3266 f
->icon_name
= Qnil
;
3268 FRAME_X_DISPLAY_INFO (f
) = dpyinfo
;
3270 image_cache_refcount
= FRAME_X_IMAGE_CACHE (f
)->refcount
;
3271 dpyinfo_refcount
= dpyinfo
->reference_count
;
3272 #endif /* GLYPH_DEBUG */
3274 FRAME_KBOARD (f
) = kb
;
3277 /* These colors will be set anyway later, but it's important
3278 to get the color reference counts right, so initialize them! */
3281 struct gcpro gcpro1
;
3283 /* Function x_decode_color can signal an error. Make
3284 sure to initialize color slots so that we won't try
3285 to free colors we haven't allocated. */
3286 f
->output_data
.x
->foreground_pixel
= -1;
3287 f
->output_data
.x
->background_pixel
= -1;
3288 f
->output_data
.x
->cursor_pixel
= -1;
3289 f
->output_data
.x
->cursor_foreground_pixel
= -1;
3290 f
->output_data
.x
->border_pixel
= -1;
3291 f
->output_data
.x
->mouse_pixel
= -1;
3293 black
= build_string ("black");
3295 f
->output_data
.x
->foreground_pixel
3296 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3297 f
->output_data
.x
->background_pixel
3298 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3299 f
->output_data
.x
->cursor_pixel
3300 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3301 f
->output_data
.x
->cursor_foreground_pixel
3302 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3303 f
->output_data
.x
->border_pixel
3304 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3305 f
->output_data
.x
->mouse_pixel
3306 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3310 /* Specify the parent under which to make this X window. */
3314 f
->output_data
.x
->parent_desc
= (Window
) XFASTINT (parent
);
3315 f
->output_data
.x
->explicit_parent
= 1;
3319 f
->output_data
.x
->parent_desc
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
3320 f
->output_data
.x
->explicit_parent
= 0;
3323 /* Set the name; the functions to which we pass f expect the name to
3325 if (EQ (name
, Qunbound
) || NILP (name
))
3327 f
->name
= build_string (dpyinfo
->x_id_name
);
3328 f
->explicit_name
= 0;
3333 f
->explicit_name
= 1;
3334 /* use the frame's title when getting resources for this frame. */
3335 specbind (Qx_resource_name
, name
);
3338 /* Extract the window parameters from the supplied values
3339 that are needed to determine window geometry. */
3343 font
= x_get_arg (dpyinfo
, parms
, Qfont
, "font", "Font", RES_TYPE_STRING
);
3346 /* First, try whatever font the caller has specified. */
3349 tem
= Fquery_fontset (font
, Qnil
);
3351 font
= x_new_fontset (f
, SDATA (tem
));
3353 font
= x_new_font (f
, SDATA (font
));
3356 /* Try out a font which we hope has bold and italic variations. */
3357 if (!STRINGP (font
))
3358 font
= x_new_font (f
, "-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1");
3359 if (!STRINGP (font
))
3360 font
= x_new_font (f
, "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
3361 if (! STRINGP (font
))
3362 font
= x_new_font (f
, "-*-*-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
3363 if (! STRINGP (font
))
3364 /* This was formerly the first thing tried, but it finds too many fonts
3365 and takes too long. */
3366 font
= x_new_font (f
, "-*-*-medium-r-*-*-*-*-*-*-c-*-iso8859-1");
3367 /* If those didn't work, look for something which will at least work. */
3368 if (! STRINGP (font
))
3369 font
= x_new_font (f
, "-*-fixed-*-*-*-*-*-140-*-*-c-*-iso8859-1");
3371 if (! STRINGP (font
))
3372 font
= build_string ("fixed");
3374 x_default_parameter (f
, parms
, Qfont
, font
,
3375 "font", "Font", RES_TYPE_STRING
);
3379 /* Prevent lwlib/xlwmenu.c from crashing because of a bug
3380 whereby it fails to get any font. */
3381 xlwmenu_default_font
= FRAME_FONT (f
);
3384 x_default_parameter (f
, parms
, Qborder_width
, make_number (2),
3385 "borderWidth", "BorderWidth", RES_TYPE_NUMBER
);
3387 /* This defaults to 1 in order to match xterm. We recognize either
3388 internalBorderWidth or internalBorder (which is what xterm calls
3390 if (NILP (Fassq (Qinternal_border_width
, parms
)))
3394 value
= x_get_arg (dpyinfo
, parms
, Qinternal_border_width
,
3395 "internalBorder", "internalBorder", RES_TYPE_NUMBER
);
3396 if (! EQ (value
, Qunbound
))
3397 parms
= Fcons (Fcons (Qinternal_border_width
, value
),
3400 x_default_parameter (f
, parms
, Qinternal_border_width
, make_number (1),
3401 "internalBorderWidth", "internalBorderWidth",
3403 x_default_parameter (f
, parms
, Qvertical_scroll_bars
, Qleft
,
3404 "verticalScrollBars", "ScrollBars",
3407 /* Also do the stuff which must be set before the window exists. */
3408 x_default_parameter (f
, parms
, Qforeground_color
, build_string ("black"),
3409 "foreground", "Foreground", RES_TYPE_STRING
);
3410 x_default_parameter (f
, parms
, Qbackground_color
, build_string ("white"),
3411 "background", "Background", RES_TYPE_STRING
);
3412 x_default_parameter (f
, parms
, Qmouse_color
, build_string ("black"),
3413 "pointerColor", "Foreground", RES_TYPE_STRING
);
3414 x_default_parameter (f
, parms
, Qcursor_color
, build_string ("black"),
3415 "cursorColor", "Foreground", RES_TYPE_STRING
);
3416 x_default_parameter (f
, parms
, Qborder_color
, build_string ("black"),
3417 "borderColor", "BorderColor", RES_TYPE_STRING
);
3418 x_default_parameter (f
, parms
, Qscreen_gamma
, Qnil
,
3419 "screenGamma", "ScreenGamma", RES_TYPE_FLOAT
);
3420 x_default_parameter (f
, parms
, Qline_spacing
, Qnil
,
3421 "lineSpacing", "LineSpacing", RES_TYPE_NUMBER
);
3422 x_default_parameter (f
, parms
, Qleft_fringe
, Qnil
,
3423 "leftFringe", "LeftFringe", RES_TYPE_NUMBER
);
3424 x_default_parameter (f
, parms
, Qright_fringe
, Qnil
,
3425 "rightFringe", "RightFringe", RES_TYPE_NUMBER
);
3427 x_default_scroll_bar_color_parameter (f
, parms
, Qscroll_bar_foreground
,
3428 "scrollBarForeground",
3429 "ScrollBarForeground", 1);
3430 x_default_scroll_bar_color_parameter (f
, parms
, Qscroll_bar_background
,
3431 "scrollBarBackground",
3432 "ScrollBarBackground", 0);
3434 /* Init faces before x_default_parameter is called for scroll-bar
3435 parameters because that function calls x_set_scroll_bar_width,
3436 which calls change_frame_size, which calls Fset_window_buffer,
3437 which runs hooks, which call Fvertical_motion. At the end, we
3438 end up in init_iterator with a null face cache, which should not
3440 init_frame_faces (f
);
3442 x_default_parameter (f
, parms
, Qmenu_bar_lines
, make_number (1),
3443 "menuBar", "MenuBar", RES_TYPE_NUMBER
);
3444 x_default_parameter (f
, parms
, Qtool_bar_lines
, make_number (1),
3445 "toolBar", "ToolBar", RES_TYPE_NUMBER
);
3446 x_default_parameter (f
, parms
, Qbuffer_predicate
, Qnil
,
3447 "bufferPredicate", "BufferPredicate",
3449 x_default_parameter (f
, parms
, Qtitle
, Qnil
,
3450 "title", "Title", RES_TYPE_STRING
);
3451 x_default_parameter (f
, parms
, Qwait_for_wm
, Qt
,
3452 "waitForWM", "WaitForWM", RES_TYPE_BOOLEAN
);
3453 x_default_parameter (f
, parms
, Qfullscreen
, Qnil
,
3454 "fullscreen", "Fullscreen", RES_TYPE_SYMBOL
);
3456 f
->output_data
.x
->parent_desc
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
3458 /* Compute the size of the X window. */
3459 window_prompting
= x_figure_window_size (f
, parms
, 1);
3461 tem
= x_get_arg (dpyinfo
, parms
, Qunsplittable
, 0, 0, RES_TYPE_BOOLEAN
);
3462 f
->no_split
= minibuffer_only
|| EQ (tem
, Qt
);
3464 /* Create the X widget or window. */
3465 #ifdef USE_X_TOOLKIT
3466 x_window (f
, window_prompting
, minibuffer_only
);
3474 /* Now consider the frame official. */
3475 FRAME_X_DISPLAY_INFO (f
)->reference_count
++;
3476 Vframe_list
= Fcons (frame
, Vframe_list
);
3478 /* We need to do this after creating the X window, so that the
3479 icon-creation functions can say whose icon they're describing. */
3480 x_default_parameter (f
, parms
, Qicon_type
, Qnil
,
3481 "bitmapIcon", "BitmapIcon", RES_TYPE_SYMBOL
);
3483 x_default_parameter (f
, parms
, Qauto_raise
, Qnil
,
3484 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
3485 x_default_parameter (f
, parms
, Qauto_lower
, Qnil
,
3486 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
3487 x_default_parameter (f
, parms
, Qcursor_type
, Qbox
,
3488 "cursorType", "CursorType", RES_TYPE_SYMBOL
);
3489 x_default_parameter (f
, parms
, Qscroll_bar_width
, Qnil
,
3490 "scrollBarWidth", "ScrollBarWidth",
3493 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
3494 Change will not be effected unless different from the current
3496 width
= FRAME_COLS (f
);
3497 height
= FRAME_LINES (f
);
3499 SET_FRAME_COLS (f
, 0);
3500 FRAME_LINES (f
) = 0;
3501 change_frame_size (f
, height
, width
, 1, 0, 0);
3503 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
3504 /* Create the menu bar. */
3505 if (!minibuffer_only
&& FRAME_EXTERNAL_MENU_BAR (f
))
3507 /* If this signals an error, we haven't set size hints for the
3508 frame and we didn't make it visible. */
3509 initialize_frame_menubar (f
);
3512 /* This is a no-op, except under Motif where it arranges the
3513 main window for the widgets on it. */
3514 lw_set_main_areas (f
->output_data
.x
->column_widget
,
3515 f
->output_data
.x
->menubar_widget
,
3516 f
->output_data
.x
->edit_widget
);
3517 #endif /* not USE_GTK */
3519 #endif /* USE_X_TOOLKIT || USE_GTK */
3521 /* Tell the server what size and position, etc, we want, and how
3522 badly we want them. This should be done after we have the menu
3523 bar so that its size can be taken into account. */
3525 x_wm_set_size_hint (f
, window_prompting
, 0);
3528 /* Make the window appear on the frame and enable display, unless
3529 the caller says not to. However, with explicit parent, Emacs
3530 cannot control visibility, so don't try. */
3531 if (! f
->output_data
.x
->explicit_parent
)
3533 Lisp_Object visibility
;
3535 visibility
= x_get_arg (dpyinfo
, parms
, Qvisibility
, 0, 0,
3537 if (EQ (visibility
, Qunbound
))
3540 if (EQ (visibility
, Qicon
))
3541 x_iconify_frame (f
);
3542 else if (! NILP (visibility
))
3543 x_make_frame_visible (f
);
3545 /* Must have been Qnil. */
3549 /* Set the WM leader property. GTK does this itself, so this is not
3550 needed when using GTK. */
3551 if (dpyinfo
->client_leader_window
!= 0)
3554 XChangeProperty (FRAME_X_DISPLAY (f
),
3555 FRAME_OUTER_WINDOW (f
),
3556 dpyinfo
->Xatom_wm_client_leader
,
3557 XA_WINDOW
, 32, PropModeReplace
,
3558 (char *) &dpyinfo
->client_leader_window
, 1);
3564 /* Make sure windows on this frame appear in calls to next-window
3565 and similar functions. */
3566 Vwindow_list
= Qnil
;
3568 return unbind_to (count
, frame
);
3572 /* FRAME is used only to get a handle on the X display. We don't pass the
3573 display info directly because we're called from frame.c, which doesn't
3574 know about that structure. */
3577 x_get_focus_frame (frame
)
3578 struct frame
*frame
;
3580 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (frame
);
3582 if (! dpyinfo
->x_focus_frame
)
3585 XSETFRAME (xfocus
, dpyinfo
->x_focus_frame
);
3590 /* In certain situations, when the window manager follows a
3591 click-to-focus policy, there seems to be no way around calling
3592 XSetInputFocus to give another frame the input focus .
3594 In an ideal world, XSetInputFocus should generally be avoided so
3595 that applications don't interfere with the window manager's focus
3596 policy. But I think it's okay to use when it's clearly done
3597 following a user-command. */
3599 DEFUN ("x-focus-frame", Fx_focus_frame
, Sx_focus_frame
, 1, 1, 0,
3600 doc
: /* Set the input focus to FRAME.
3601 FRAME nil means use the selected frame. */)
3605 struct frame
*f
= check_x_frame (frame
);
3606 Display
*dpy
= FRAME_X_DISPLAY (f
);
3610 count
= x_catch_errors (dpy
);
3611 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3612 RevertToParent
, CurrentTime
);
3613 x_uncatch_errors (dpy
, count
);
3620 DEFUN ("xw-color-defined-p", Fxw_color_defined_p
, Sxw_color_defined_p
, 1, 2, 0,
3621 doc
: /* Internal function called by `color-defined-p', which see. */)
3623 Lisp_Object color
, frame
;
3626 FRAME_PTR f
= check_x_frame (frame
);
3628 CHECK_STRING (color
);
3630 if (x_defined_color (f
, SDATA (color
), &foo
, 0))
3636 DEFUN ("xw-color-values", Fxw_color_values
, Sxw_color_values
, 1, 2, 0,
3637 doc
: /* Internal function called by `color-values', which see. */)
3639 Lisp_Object color
, frame
;
3642 FRAME_PTR f
= check_x_frame (frame
);
3644 CHECK_STRING (color
);
3646 if (x_defined_color (f
, SDATA (color
), &foo
, 0))
3650 rgb
[0] = make_number (foo
.red
);
3651 rgb
[1] = make_number (foo
.green
);
3652 rgb
[2] = make_number (foo
.blue
);
3653 return Flist (3, rgb
);
3659 DEFUN ("xw-display-color-p", Fxw_display_color_p
, Sxw_display_color_p
, 0, 1, 0,
3660 doc
: /* Internal function called by `display-color-p', which see. */)
3662 Lisp_Object display
;
3664 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3666 if (dpyinfo
->n_planes
<= 2)
3669 switch (dpyinfo
->visual
->class)
3682 DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p
, Sx_display_grayscale_p
,
3684 doc
: /* Return t if the X display supports shades of gray.
3685 Note that color displays do support shades of gray.
3686 The optional argument DISPLAY specifies which display to ask about.
3687 DISPLAY should be either a frame or a display name (a string).
3688 If omitted or nil, that stands for the selected frame's display. */)
3690 Lisp_Object display
;
3692 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3694 if (dpyinfo
->n_planes
<= 1)
3697 switch (dpyinfo
->visual
->class)
3712 DEFUN ("x-display-pixel-width", Fx_display_pixel_width
, Sx_display_pixel_width
,
3714 doc
: /* Returns the width in pixels of the X display DISPLAY.
3715 The optional argument DISPLAY specifies which display to ask about.
3716 DISPLAY should be either a frame or a display name (a string).
3717 If omitted or nil, that stands for the selected frame's display. */)
3719 Lisp_Object display
;
3721 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3723 return make_number (dpyinfo
->width
);
3726 DEFUN ("x-display-pixel-height", Fx_display_pixel_height
,
3727 Sx_display_pixel_height
, 0, 1, 0,
3728 doc
: /* Returns the height in pixels of the X display DISPLAY.
3729 The optional argument DISPLAY specifies which display to ask about.
3730 DISPLAY should be either a frame or a display name (a string).
3731 If omitted or nil, that stands for the selected frame's display. */)
3733 Lisp_Object display
;
3735 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3737 return make_number (dpyinfo
->height
);
3740 DEFUN ("x-display-planes", Fx_display_planes
, Sx_display_planes
,
3742 doc
: /* Returns the number of bitplanes of the X display DISPLAY.
3743 The optional argument DISPLAY specifies which display to ask about.
3744 DISPLAY should be either a frame or a display name (a string).
3745 If omitted or nil, that stands for the selected frame's display. */)
3747 Lisp_Object display
;
3749 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3751 return make_number (dpyinfo
->n_planes
);
3754 DEFUN ("x-display-color-cells", Fx_display_color_cells
, Sx_display_color_cells
,
3756 doc
: /* Returns the number of color cells of the X display DISPLAY.
3757 The optional argument DISPLAY specifies which display to ask about.
3758 DISPLAY should be either a frame or a display name (a string).
3759 If omitted or nil, that stands for the selected frame's display. */)
3761 Lisp_Object display
;
3763 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3765 return make_number (DisplayCells (dpyinfo
->display
,
3766 XScreenNumberOfScreen (dpyinfo
->screen
)));
3769 DEFUN ("x-server-max-request-size", Fx_server_max_request_size
,
3770 Sx_server_max_request_size
,
3772 doc
: /* Returns the maximum request size of the X server of display DISPLAY.
3773 The optional argument DISPLAY specifies which display to ask about.
3774 DISPLAY should be either a frame or a display name (a string).
3775 If omitted or nil, that stands for the selected frame's display. */)
3777 Lisp_Object display
;
3779 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3781 return make_number (MAXREQUEST (dpyinfo
->display
));
3784 DEFUN ("x-server-vendor", Fx_server_vendor
, Sx_server_vendor
, 0, 1, 0,
3785 doc
: /* Returns the vendor ID string of the X server of display DISPLAY.
3786 The optional argument DISPLAY specifies which display to ask about.
3787 DISPLAY should be either a frame or a display name (a string).
3788 If omitted or nil, that stands for the selected frame's display. */)
3790 Lisp_Object display
;
3792 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3793 char *vendor
= ServerVendor (dpyinfo
->display
);
3795 if (! vendor
) vendor
= "";
3796 return build_string (vendor
);
3799 DEFUN ("x-server-version", Fx_server_version
, Sx_server_version
, 0, 1, 0,
3800 doc
: /* Returns the version numbers of the X server of display DISPLAY.
3801 The value is a list of three integers: the major and minor
3802 version numbers of the X Protocol in use, and the vendor-specific release
3803 number. See also the function `x-server-vendor'.
3805 The optional argument DISPLAY specifies which display to ask about.
3806 DISPLAY should be either a frame or a display name (a string).
3807 If omitted or nil, that stands for the selected frame's display. */)
3809 Lisp_Object display
;
3811 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3812 Display
*dpy
= dpyinfo
->display
;
3814 return Fcons (make_number (ProtocolVersion (dpy
)),
3815 Fcons (make_number (ProtocolRevision (dpy
)),
3816 Fcons (make_number (VendorRelease (dpy
)), Qnil
)));
3819 DEFUN ("x-display-screens", Fx_display_screens
, Sx_display_screens
, 0, 1, 0,
3820 doc
: /* Return the number of screens on the X server of display DISPLAY.
3821 The optional argument DISPLAY specifies which display to ask about.
3822 DISPLAY should be either a frame or a display name (a string).
3823 If omitted or nil, that stands for the selected frame's display. */)
3825 Lisp_Object display
;
3827 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3829 return make_number (ScreenCount (dpyinfo
->display
));
3832 DEFUN ("x-display-mm-height", Fx_display_mm_height
, Sx_display_mm_height
, 0, 1, 0,
3833 doc
: /* Return the height in millimeters of the X display DISPLAY.
3834 The optional argument DISPLAY specifies which display to ask about.
3835 DISPLAY should be either a frame or a display name (a string).
3836 If omitted or nil, that stands for the selected frame's display. */)
3838 Lisp_Object display
;
3840 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3842 return make_number (HeightMMOfScreen (dpyinfo
->screen
));
3845 DEFUN ("x-display-mm-width", Fx_display_mm_width
, Sx_display_mm_width
, 0, 1, 0,
3846 doc
: /* Return the width in millimeters of the X display DISPLAY.
3847 The optional argument DISPLAY specifies which display to ask about.
3848 DISPLAY should be either a frame or a display name (a string).
3849 If omitted or nil, that stands for the selected frame's display. */)
3851 Lisp_Object display
;
3853 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3855 return make_number (WidthMMOfScreen (dpyinfo
->screen
));
3858 DEFUN ("x-display-backing-store", Fx_display_backing_store
,
3859 Sx_display_backing_store
, 0, 1, 0,
3860 doc
: /* Returns an indication of whether X display DISPLAY does backing store.
3861 The value may be `always', `when-mapped', or `not-useful'.
3862 The optional argument DISPLAY specifies which display to ask about.
3863 DISPLAY should be either a frame or a display name (a string).
3864 If omitted or nil, that stands for the selected frame's display. */)
3866 Lisp_Object display
;
3868 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3871 switch (DoesBackingStore (dpyinfo
->screen
))
3874 result
= intern ("always");
3878 result
= intern ("when-mapped");
3882 result
= intern ("not-useful");
3886 error ("Strange value for BackingStore parameter of screen");
3893 DEFUN ("x-display-visual-class", Fx_display_visual_class
,
3894 Sx_display_visual_class
, 0, 1, 0,
3895 doc
: /* Return the visual class of the X display DISPLAY.
3896 The value is one of the symbols `static-gray', `gray-scale',
3897 `static-color', `pseudo-color', `true-color', or `direct-color'.
3899 The optional argument DISPLAY specifies which display to ask about.
3900 DISPLAY should be either a frame or a display name (a string).
3901 If omitted or nil, that stands for the selected frame's display. */)
3903 Lisp_Object display
;
3905 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3908 switch (dpyinfo
->visual
->class)
3911 result
= intern ("static-gray");
3914 result
= intern ("gray-scale");
3917 result
= intern ("static-color");
3920 result
= intern ("pseudo-color");
3923 result
= intern ("true-color");
3926 result
= intern ("direct-color");
3929 error ("Display has an unknown visual class");
3936 DEFUN ("x-display-save-under", Fx_display_save_under
,
3937 Sx_display_save_under
, 0, 1, 0,
3938 doc
: /* Returns t if the X display DISPLAY supports the save-under feature.
3939 The optional argument DISPLAY specifies which display to ask about.
3940 DISPLAY should be either a frame or a display name (a string).
3941 If omitted or nil, that stands for the selected frame's display. */)
3943 Lisp_Object display
;
3945 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3947 if (DoesSaveUnders (dpyinfo
->screen
) == True
)
3955 register struct frame
*f
;
3957 return FRAME_PIXEL_WIDTH (f
);
3962 register struct frame
*f
;
3964 return FRAME_PIXEL_HEIGHT (f
);
3969 register struct frame
*f
;
3971 return FRAME_COLUMN_WIDTH (f
);
3976 register struct frame
*f
;
3978 return FRAME_LINE_HEIGHT (f
);
3983 register struct frame
*f
;
3985 return FRAME_X_DISPLAY_INFO (f
)->n_planes
;
3990 /************************************************************************
3992 ************************************************************************/
3995 /* Mapping visual names to visuals. */
3997 static struct visual_class
4004 {"StaticGray", StaticGray
},
4005 {"GrayScale", GrayScale
},
4006 {"StaticColor", StaticColor
},
4007 {"PseudoColor", PseudoColor
},
4008 {"TrueColor", TrueColor
},
4009 {"DirectColor", DirectColor
},
4014 #ifndef HAVE_XSCREENNUMBEROFSCREEN
4016 /* Value is the screen number of screen SCR. This is a substitute for
4017 the X function with the same name when that doesn't exist. */
4020 XScreenNumberOfScreen (scr
)
4021 register Screen
*scr
;
4023 Display
*dpy
= scr
->display
;
4026 for (i
= 0; i
< dpy
->nscreens
; ++i
)
4027 if (scr
== dpy
->screens
+ i
)
4033 #endif /* not HAVE_XSCREENNUMBEROFSCREEN */
4036 /* Select the visual that should be used on display DPYINFO. Set
4037 members of DPYINFO appropriately. Called from x_term_init. */
4040 select_visual (dpyinfo
)
4041 struct x_display_info
*dpyinfo
;
4043 Display
*dpy
= dpyinfo
->display
;
4044 Screen
*screen
= dpyinfo
->screen
;
4047 /* See if a visual is specified. */
4048 value
= display_x_get_resource (dpyinfo
,
4049 build_string ("visualClass"),
4050 build_string ("VisualClass"),
4052 if (STRINGP (value
))
4054 /* VALUE should be of the form CLASS-DEPTH, where CLASS is one
4055 of `PseudoColor', `TrueColor' etc. and DEPTH is the color
4056 depth, a decimal number. NAME is compared with case ignored. */
4057 char *s
= (char *) alloca (SBYTES (value
) + 1);
4062 strcpy (s
, SDATA (value
));
4063 dash
= index (s
, '-');
4066 dpyinfo
->n_planes
= atoi (dash
+ 1);
4070 /* We won't find a matching visual with depth 0, so that
4071 an error will be printed below. */
4072 dpyinfo
->n_planes
= 0;
4074 /* Determine the visual class. */
4075 for (i
= 0; visual_classes
[i
].name
; ++i
)
4076 if (xstricmp (s
, visual_classes
[i
].name
) == 0)
4078 class = visual_classes
[i
].class;
4082 /* Look up a matching visual for the specified class. */
4084 || !XMatchVisualInfo (dpy
, XScreenNumberOfScreen (screen
),
4085 dpyinfo
->n_planes
, class, &vinfo
))
4086 fatal ("Invalid visual specification `%s'", SDATA (value
));
4088 dpyinfo
->visual
= vinfo
.visual
;
4093 XVisualInfo
*vinfo
, vinfo_template
;
4095 dpyinfo
->visual
= DefaultVisualOfScreen (screen
);
4098 vinfo_template
.visualid
= XVisualIDFromVisual (dpyinfo
->visual
);
4100 vinfo_template
.visualid
= dpyinfo
->visual
->visualid
;
4102 vinfo_template
.screen
= XScreenNumberOfScreen (screen
);
4103 vinfo
= XGetVisualInfo (dpy
, VisualIDMask
| VisualScreenMask
,
4104 &vinfo_template
, &n_visuals
);
4106 fatal ("Can't get proper X visual info");
4108 dpyinfo
->n_planes
= vinfo
->depth
;
4109 XFree ((char *) vinfo
);
4114 /* Return the X display structure for the display named NAME.
4115 Open a new connection if necessary. */
4117 struct x_display_info
*
4118 x_display_info_for_name (name
)
4122 struct x_display_info
*dpyinfo
;
4124 CHECK_STRING (name
);
4126 if (! EQ (Vwindow_system
, intern ("x")))
4127 error ("Not using X Windows");
4129 for (dpyinfo
= x_display_list
, names
= x_display_name_list
;
4131 dpyinfo
= dpyinfo
->next
, names
= XCDR (names
))
4134 tem
= Fstring_equal (XCAR (XCAR (names
)), name
);
4139 /* Use this general default value to start with. */
4140 Vx_resource_name
= Vinvocation_name
;
4142 validate_x_resource_name ();
4144 dpyinfo
= x_term_init (name
, (char *)0,
4145 (char *) SDATA (Vx_resource_name
));
4148 error ("Cannot connect to X server %s", SDATA (name
));
4151 XSETFASTINT (Vwindow_system_version
, 11);
4157 DEFUN ("x-open-connection", Fx_open_connection
, Sx_open_connection
,
4159 doc
: /* Open a connection to an X server.
4160 DISPLAY is the name of the display to connect to.
4161 Optional second arg XRM-STRING is a string of resources in xrdb format.
4162 If the optional third arg MUST-SUCCEED is non-nil,
4163 terminate Emacs if we can't open the connection. */)
4164 (display
, xrm_string
, must_succeed
)
4165 Lisp_Object display
, xrm_string
, must_succeed
;
4167 unsigned char *xrm_option
;
4168 struct x_display_info
*dpyinfo
;
4170 CHECK_STRING (display
);
4171 if (! NILP (xrm_string
))
4172 CHECK_STRING (xrm_string
);
4174 if (! EQ (Vwindow_system
, intern ("x")))
4175 error ("Not using X Windows");
4177 if (! NILP (xrm_string
))
4178 xrm_option
= (unsigned char *) SDATA (xrm_string
);
4180 xrm_option
= (unsigned char *) 0;
4182 validate_x_resource_name ();
4184 /* This is what opens the connection and sets x_current_display.
4185 This also initializes many symbols, such as those used for input. */
4186 dpyinfo
= x_term_init (display
, xrm_option
,
4187 (char *) SDATA (Vx_resource_name
));
4191 if (!NILP (must_succeed
))
4192 fatal ("Cannot connect to X server %s.\n\
4193 Check the DISPLAY environment variable or use `-d'.\n\
4194 Also use the `xauth' program to verify that you have the proper\n\
4195 authorization information needed to connect the X server.\n\
4196 An insecure way to solve the problem may be to use `xhost'.\n",
4199 error ("Cannot connect to X server %s", SDATA (display
));
4204 XSETFASTINT (Vwindow_system_version
, 11);
4208 DEFUN ("x-close-connection", Fx_close_connection
,
4209 Sx_close_connection
, 1, 1, 0,
4210 doc
: /* Close the connection to DISPLAY's X server.
4211 For DISPLAY, specify either a frame or a display name (a string).
4212 If DISPLAY is nil, that stands for the selected frame's display. */)
4214 Lisp_Object display
;
4216 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
4219 if (dpyinfo
->reference_count
> 0)
4220 error ("Display still has frames on it");
4223 /* Free the fonts in the font table. */
4224 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
4225 if (dpyinfo
->font_table
[i
].name
)
4227 XFreeFont (dpyinfo
->display
, dpyinfo
->font_table
[i
].font
);
4230 x_destroy_all_bitmaps (dpyinfo
);
4231 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
4233 #ifdef USE_X_TOOLKIT
4234 XtCloseDisplay (dpyinfo
->display
);
4236 XCloseDisplay (dpyinfo
->display
);
4239 x_delete_display (dpyinfo
);
4245 DEFUN ("x-display-list", Fx_display_list
, Sx_display_list
, 0, 0, 0,
4246 doc
: /* Return the list of display names that Emacs has connections to. */)
4249 Lisp_Object tail
, result
;
4252 for (tail
= x_display_name_list
; ! NILP (tail
); tail
= XCDR (tail
))
4253 result
= Fcons (XCAR (XCAR (tail
)), result
);
4258 DEFUN ("x-synchronize", Fx_synchronize
, Sx_synchronize
, 1, 2, 0,
4259 doc
: /* If ON is non-nil, report X errors as soon as the erring request is made.
4260 If ON is nil, allow buffering of requests.
4261 Turning on synchronization prohibits the Xlib routines from buffering
4262 requests and seriously degrades performance, but makes debugging much
4264 The optional second argument DISPLAY specifies which display to act on.
4265 DISPLAY should be either a frame or a display name (a string).
4266 If DISPLAY is omitted or nil, that stands for the selected frame's display. */)
4268 Lisp_Object display
, on
;
4270 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
4272 XSynchronize (dpyinfo
->display
, !EQ (on
, Qnil
));
4277 /* Wait for responses to all X commands issued so far for frame F. */
4284 XSync (FRAME_X_DISPLAY (f
), False
);
4289 /***********************************************************************
4290 General X functions exposed to Elisp.
4291 ***********************************************************************/
4293 DEFUN ("x-send-client-message", Fx_send_client_event
,
4294 Sx_send_client_message
, 6, 6, 0,
4295 doc
: /* Send a client message of MESSAGE-TYPE to window DEST on DISPLAY.
4297 For DISPLAY, specify either a frame or a display name (a string).
4298 If DISPLAY is nil, that stands for the selected frame's display.
4299 DEST may be an integer, in which case it is a Window id. The value 0 may
4300 be used to send to the root window of the DISPLAY.
4301 If DEST is a frame the event is sent to the outer window of that frame.
4302 Nil means the currently selected frame.
4303 If DEST is the string "PointerWindow" the event is sent to the window that
4304 contains the pointer. If DEST is the string "InputFocus" the event is
4305 sent to the window that has the input focus.
4306 FROM is the frame sending the event. Use nil for currently selected frame.
4307 MESSAGE-TYPE is the name of an Atom as a string.
4308 FORMAT must be one of 8, 16 or 32 and determines the size of the values in
4309 bits. VALUES is a list of integer and/or strings containing the values to
4310 send. If a value is a string, it is converted to an Atom and the value of
4311 the Atom is sent. If more values than fits into the event is given,
4312 the excessive values are ignored. */)
4313 (display
, dest
, from
, message_type
, format
, values
)
4314 Lisp_Object display
, dest
, from
, message_type
, format
, values
;
4316 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
4321 int max_nr_values
= (int) sizeof (event
.xclient
.data
.b
);
4322 struct frame
*f
= check_x_frame (from
);
4324 CHECK_STRING (message_type
);
4325 CHECK_NUMBER (format
);
4326 CHECK_CONS (values
);
4328 for (cons
= values
; CONSP (cons
); cons
= XCDR (cons
))
4330 Lisp_Object o
= XCAR (cons
);
4332 if (! INTEGERP (o
) && ! STRINGP (o
))
4333 error ("Bad data in VALUES, must be integer or string");
4336 event
.xclient
.type
= ClientMessage
;
4337 event
.xclient
.format
= XFASTINT (format
);
4339 if (event
.xclient
.format
!= 8 && event
.xclient
.format
!= 16
4340 && event
.xclient
.format
!= 32)
4341 error ("FORMAT must be one of 8, 16 or 32");
4342 if (event
.xclient
.format
== 16) max_nr_values
/= 2;
4343 if (event
.xclient
.format
== 32) max_nr_values
/= 4;
4345 if (FRAMEP (dest
) || NILP (dest
))
4347 struct frame
*fdest
= check_x_frame (dest
);
4348 wdest
= FRAME_OUTER_WINDOW (fdest
);
4350 else if (STRINGP (dest
))
4352 if (strcmp (SDATA (dest
), "PointerWindow") == 0)
4353 wdest
= PointerWindow
;
4354 else if (strcmp (SDATA (dest
), "InputFocus") == 0)
4357 error ("DEST as a string must be one of PointerWindow or InputFocus");
4361 CHECK_NUMBER (dest
);
4362 wdest
= (Window
) XFASTINT (dest
);
4363 if (wdest
== 0) wdest
= dpyinfo
->root_window
;
4367 for (cons
= values
, i
= 0;
4368 CONSP (cons
) && i
< max_nr_values
;
4369 cons
= XCDR (cons
), ++i
)
4371 Lisp_Object o
= XCAR (cons
);
4376 else if (STRINGP (o
))
4377 val
= XInternAtom (dpyinfo
->display
, SDATA (o
), False
);
4379 if (event
.xclient
.format
== 8)
4380 event
.xclient
.data
.b
[i
] = (char) val
;
4381 else if (event
.xclient
.format
== 16)
4382 event
.xclient
.data
.s
[i
] = (short) val
;
4384 event
.xclient
.data
.l
[i
] = val
;
4387 for ( ; i
< max_nr_values
; ++i
)
4388 if (event
.xclient
.format
== 8)
4389 event
.xclient
.data
.b
[i
] = 0;
4390 else if (event
.xclient
.format
== 16)
4391 event
.xclient
.data
.s
[i
] = 0;
4393 event
.xclient
.data
.l
[i
] = 0;
4395 event
.xclient
.message_type
4396 = XInternAtom (dpyinfo
->display
, SDATA (message_type
), False
);
4397 event
.xclient
.display
= dpyinfo
->display
;
4398 event
.xclient
.window
= FRAME_OUTER_WINDOW (f
);
4400 XSendEvent (dpyinfo
->display
, wdest
, False
, 0xffff, &event
);
4402 XFlush (dpyinfo
->display
);
4408 /***********************************************************************
4410 ***********************************************************************/
4412 /* Value is the number of elements of vector VECTOR. */
4414 #define DIM(VECTOR) (sizeof (VECTOR) / sizeof *(VECTOR))
4416 /* List of supported image types. Use define_image_type to add new
4417 types. Use lookup_image_type to find a type for a given symbol. */
4419 static struct image_type
*image_types
;
4421 /* The symbol `image' which is the car of the lists used to represent
4424 extern Lisp_Object Qimage
;
4426 /* The symbol `xbm' which is used as the type symbol for XBM images. */
4432 extern Lisp_Object QCwidth
, QCheight
, QCforeground
, QCbackground
, QCfile
;
4433 extern Lisp_Object QCdata
, QCtype
;
4434 Lisp_Object QCascent
, QCmargin
, QCrelief
;
4435 Lisp_Object QCconversion
, QCcolor_symbols
, QCheuristic_mask
;
4436 Lisp_Object QCindex
, QCmatrix
, QCcolor_adjustment
, QCmask
;
4438 /* Other symbols. */
4440 Lisp_Object Qlaplace
, Qemboss
, Qedge_detection
, Qheuristic
;
4442 /* Time in seconds after which images should be removed from the cache
4443 if not displayed. */
4445 Lisp_Object Vimage_cache_eviction_delay
;
4447 /* Function prototypes. */
4449 static void define_image_type
P_ ((struct image_type
*type
));
4450 static struct image_type
*lookup_image_type
P_ ((Lisp_Object symbol
));
4451 static void image_error
P_ ((char *format
, Lisp_Object
, Lisp_Object
));
4452 static void x_laplace
P_ ((struct frame
*, struct image
*));
4453 static void x_emboss
P_ ((struct frame
*, struct image
*));
4454 static int x_build_heuristic_mask
P_ ((struct frame
*, struct image
*,
4458 /* Define a new image type from TYPE. This adds a copy of TYPE to
4459 image_types and adds the symbol *TYPE->type to Vimage_types. */
4462 define_image_type (type
)
4463 struct image_type
*type
;
4465 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
4466 The initialized data segment is read-only. */
4467 struct image_type
*p
= (struct image_type
*) xmalloc (sizeof *p
);
4468 bcopy (type
, p
, sizeof *p
);
4469 p
->next
= image_types
;
4471 Vimage_types
= Fcons (*p
->type
, Vimage_types
);
4475 /* Look up image type SYMBOL, and return a pointer to its image_type
4476 structure. Value is null if SYMBOL is not a known image type. */
4478 static INLINE
struct image_type
*
4479 lookup_image_type (symbol
)
4482 struct image_type
*type
;
4484 for (type
= image_types
; type
; type
= type
->next
)
4485 if (EQ (symbol
, *type
->type
))
4492 /* Value is non-zero if OBJECT is a valid Lisp image specification. A
4493 valid image specification is a list whose car is the symbol
4494 `image', and whose rest is a property list. The property list must
4495 contain a value for key `:type'. That value must be the name of a
4496 supported image type. The rest of the property list depends on the
4500 valid_image_p (object
)
4505 if (CONSP (object
) && EQ (XCAR (object
), Qimage
))
4509 for (tem
= XCDR (object
); CONSP (tem
); tem
= XCDR (tem
))
4510 if (EQ (XCAR (tem
), QCtype
))
4513 if (CONSP (tem
) && SYMBOLP (XCAR (tem
)))
4515 struct image_type
*type
;
4516 type
= lookup_image_type (XCAR (tem
));
4518 valid_p
= type
->valid_p (object
);
4529 /* Log error message with format string FORMAT and argument ARG.
4530 Signaling an error, e.g. when an image cannot be loaded, is not a
4531 good idea because this would interrupt redisplay, and the error
4532 message display would lead to another redisplay. This function
4533 therefore simply displays a message. */
4536 image_error (format
, arg1
, arg2
)
4538 Lisp_Object arg1
, arg2
;
4540 add_to_log (format
, arg1
, arg2
);
4545 /***********************************************************************
4546 Image specifications
4547 ***********************************************************************/
4549 enum image_value_type
4551 IMAGE_DONT_CHECK_VALUE_TYPE
,
4553 IMAGE_STRING_OR_NIL_VALUE
,
4555 IMAGE_POSITIVE_INTEGER_VALUE
,
4556 IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
,
4557 IMAGE_NON_NEGATIVE_INTEGER_VALUE
,
4559 IMAGE_INTEGER_VALUE
,
4560 IMAGE_FUNCTION_VALUE
,
4565 /* Structure used when parsing image specifications. */
4567 struct image_keyword
4569 /* Name of keyword. */
4572 /* The type of value allowed. */
4573 enum image_value_type type
;
4575 /* Non-zero means key must be present. */
4578 /* Used to recognize duplicate keywords in a property list. */
4581 /* The value that was found. */
4586 static int parse_image_spec
P_ ((Lisp_Object
, struct image_keyword
*,
4588 static Lisp_Object image_spec_value
P_ ((Lisp_Object
, Lisp_Object
, int *));
4591 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
4592 has the format (image KEYWORD VALUE ...). One of the keyword/
4593 value pairs must be `:type TYPE'. KEYWORDS is a vector of
4594 image_keywords structures of size NKEYWORDS describing other
4595 allowed keyword/value pairs. Value is non-zero if SPEC is valid. */
4598 parse_image_spec (spec
, keywords
, nkeywords
, type
)
4600 struct image_keyword
*keywords
;
4607 if (!CONSP (spec
) || !EQ (XCAR (spec
), Qimage
))
4610 plist
= XCDR (spec
);
4611 while (CONSP (plist
))
4613 Lisp_Object key
, value
;
4615 /* First element of a pair must be a symbol. */
4617 plist
= XCDR (plist
);
4621 /* There must follow a value. */
4624 value
= XCAR (plist
);
4625 plist
= XCDR (plist
);
4627 /* Find key in KEYWORDS. Error if not found. */
4628 for (i
= 0; i
< nkeywords
; ++i
)
4629 if (strcmp (keywords
[i
].name
, SDATA (SYMBOL_NAME (key
))) == 0)
4635 /* Record that we recognized the keyword. If a keywords
4636 was found more than once, it's an error. */
4637 keywords
[i
].value
= value
;
4638 ++keywords
[i
].count
;
4640 if (keywords
[i
].count
> 1)
4643 /* Check type of value against allowed type. */
4644 switch (keywords
[i
].type
)
4646 case IMAGE_STRING_VALUE
:
4647 if (!STRINGP (value
))
4651 case IMAGE_STRING_OR_NIL_VALUE
:
4652 if (!STRINGP (value
) && !NILP (value
))
4656 case IMAGE_SYMBOL_VALUE
:
4657 if (!SYMBOLP (value
))
4661 case IMAGE_POSITIVE_INTEGER_VALUE
:
4662 if (!INTEGERP (value
) || XINT (value
) <= 0)
4666 case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
:
4667 if (INTEGERP (value
) && XINT (value
) >= 0)
4670 && INTEGERP (XCAR (value
)) && INTEGERP (XCDR (value
))
4671 && XINT (XCAR (value
)) >= 0 && XINT (XCDR (value
)) >= 0)
4675 case IMAGE_ASCENT_VALUE
:
4676 if (SYMBOLP (value
) && EQ (value
, Qcenter
))
4678 else if (INTEGERP (value
)
4679 && XINT (value
) >= 0
4680 && XINT (value
) <= 100)
4684 case IMAGE_NON_NEGATIVE_INTEGER_VALUE
:
4685 if (!INTEGERP (value
) || XINT (value
) < 0)
4689 case IMAGE_DONT_CHECK_VALUE_TYPE
:
4692 case IMAGE_FUNCTION_VALUE
:
4693 value
= indirect_function (value
);
4695 || COMPILEDP (value
)
4696 || (CONSP (value
) && EQ (XCAR (value
), Qlambda
)))
4700 case IMAGE_NUMBER_VALUE
:
4701 if (!INTEGERP (value
) && !FLOATP (value
))
4705 case IMAGE_INTEGER_VALUE
:
4706 if (!INTEGERP (value
))
4710 case IMAGE_BOOL_VALUE
:
4711 if (!NILP (value
) && !EQ (value
, Qt
))
4720 if (EQ (key
, QCtype
) && !EQ (type
, value
))
4724 /* Check that all mandatory fields are present. */
4725 for (i
= 0; i
< nkeywords
; ++i
)
4726 if (keywords
[i
].mandatory_p
&& keywords
[i
].count
== 0)
4729 return NILP (plist
);
4733 /* Return the value of KEY in image specification SPEC. Value is nil
4734 if KEY is not present in SPEC. if FOUND is not null, set *FOUND
4735 to 1 if KEY was found in SPEC, set it to 0 otherwise. */
4738 image_spec_value (spec
, key
, found
)
4739 Lisp_Object spec
, key
;
4744 xassert (valid_image_p (spec
));
4746 for (tail
= XCDR (spec
);
4747 CONSP (tail
) && CONSP (XCDR (tail
));
4748 tail
= XCDR (XCDR (tail
)))
4750 if (EQ (XCAR (tail
), key
))
4754 return XCAR (XCDR (tail
));
4764 DEFUN ("image-size", Fimage_size
, Simage_size
, 1, 3, 0,
4765 doc
: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
4766 PIXELS non-nil means return the size in pixels, otherwise return the
4767 size in canonical character units.
4768 FRAME is the frame on which the image will be displayed. FRAME nil
4769 or omitted means use the selected frame. */)
4770 (spec
, pixels
, frame
)
4771 Lisp_Object spec
, pixels
, frame
;
4776 if (valid_image_p (spec
))
4778 struct frame
*f
= check_x_frame (frame
);
4779 int id
= lookup_image (f
, spec
);
4780 struct image
*img
= IMAGE_FROM_ID (f
, id
);
4781 int width
= img
->width
+ 2 * img
->hmargin
;
4782 int height
= img
->height
+ 2 * img
->vmargin
;
4785 size
= Fcons (make_float ((double) width
/ FRAME_COLUMN_WIDTH (f
)),
4786 make_float ((double) height
/ FRAME_LINE_HEIGHT (f
)));
4788 size
= Fcons (make_number (width
), make_number (height
));
4791 error ("Invalid image specification");
4797 DEFUN ("image-mask-p", Fimage_mask_p
, Simage_mask_p
, 1, 2, 0,
4798 doc
: /* Return t if image SPEC has a mask bitmap.
4799 FRAME is the frame on which the image will be displayed. FRAME nil
4800 or omitted means use the selected frame. */)
4802 Lisp_Object spec
, frame
;
4807 if (valid_image_p (spec
))
4809 struct frame
*f
= check_x_frame (frame
);
4810 int id
= lookup_image (f
, spec
);
4811 struct image
*img
= IMAGE_FROM_ID (f
, id
);
4816 error ("Invalid image specification");
4823 /***********************************************************************
4824 Image type independent image structures
4825 ***********************************************************************/
4827 static struct image
*make_image
P_ ((Lisp_Object spec
, unsigned hash
));
4828 static void free_image
P_ ((struct frame
*f
, struct image
*img
));
4831 /* Allocate and return a new image structure for image specification
4832 SPEC. SPEC has a hash value of HASH. */
4834 static struct image
*
4835 make_image (spec
, hash
)
4839 struct image
*img
= (struct image
*) xmalloc (sizeof *img
);
4841 xassert (valid_image_p (spec
));
4842 bzero (img
, sizeof *img
);
4843 img
->type
= lookup_image_type (image_spec_value (spec
, QCtype
, NULL
));
4844 xassert (img
->type
!= NULL
);
4846 img
->data
.lisp_val
= Qnil
;
4847 img
->ascent
= DEFAULT_IMAGE_ASCENT
;
4853 /* Free image IMG which was used on frame F, including its resources. */
4862 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
4864 /* Remove IMG from the hash table of its cache. */
4866 img
->prev
->next
= img
->next
;
4868 c
->buckets
[img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
] = img
->next
;
4871 img
->next
->prev
= img
->prev
;
4873 c
->images
[img
->id
] = NULL
;
4875 /* Free resources, then free IMG. */
4876 img
->type
->free (f
, img
);
4882 /* Prepare image IMG for display on frame F. Must be called before
4883 drawing an image. */
4886 prepare_image_for_display (f
, img
)
4892 /* We're about to display IMG, so set its timestamp to `now'. */
4894 img
->timestamp
= EMACS_SECS (t
);
4896 /* If IMG doesn't have a pixmap yet, load it now, using the image
4897 type dependent loader function. */
4898 if (img
->pixmap
== None
&& !img
->load_failed_p
)
4899 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
4903 /* Value is the number of pixels for the ascent of image IMG when
4904 drawn in face FACE. */
4907 image_ascent (img
, face
)
4911 int height
= img
->height
+ img
->vmargin
;
4914 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
4917 /* This expression is arranged so that if the image can't be
4918 exactly centered, it will be moved slightly up. This is
4919 because a typical font is `top-heavy' (due to the presence
4920 uppercase letters), so the image placement should err towards
4921 being top-heavy too. It also just generally looks better. */
4922 ascent
= (height
+ face
->font
->ascent
- face
->font
->descent
+ 1) / 2;
4924 ascent
= height
/ 2;
4927 ascent
= height
* img
->ascent
/ 100.0;
4933 /* Image background colors. */
4935 static unsigned long
4936 four_corners_best (ximg
, width
, height
)
4938 unsigned long width
, height
;
4940 unsigned long corners
[4], best
;
4943 /* Get the colors at the corners of ximg. */
4944 corners
[0] = XGetPixel (ximg
, 0, 0);
4945 corners
[1] = XGetPixel (ximg
, width
- 1, 0);
4946 corners
[2] = XGetPixel (ximg
, width
- 1, height
- 1);
4947 corners
[3] = XGetPixel (ximg
, 0, height
- 1);
4949 /* Choose the most frequently found color as background. */
4950 for (i
= best_count
= 0; i
< 4; ++i
)
4954 for (j
= n
= 0; j
< 4; ++j
)
4955 if (corners
[i
] == corners
[j
])
4959 best
= corners
[i
], best_count
= n
;
4965 /* Return the `background' field of IMG. If IMG doesn't have one yet,
4966 it is guessed heuristically. If non-zero, XIMG is an existing XImage
4967 object to use for the heuristic. */
4970 image_background (img
, f
, ximg
)
4975 if (! img
->background_valid
)
4976 /* IMG doesn't have a background yet, try to guess a reasonable value. */
4978 int free_ximg
= !ximg
;
4981 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4982 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4984 img
->background
= four_corners_best (ximg
, img
->width
, img
->height
);
4987 XDestroyImage (ximg
);
4989 img
->background_valid
= 1;
4992 return img
->background
;
4995 /* Return the `background_transparent' field of IMG. If IMG doesn't
4996 have one yet, it is guessed heuristically. If non-zero, MASK is an
4997 existing XImage object to use for the heuristic. */
5000 image_background_transparent (img
, f
, mask
)
5005 if (! img
->background_transparent_valid
)
5006 /* IMG doesn't have a background yet, try to guess a reasonable value. */
5010 int free_mask
= !mask
;
5013 mask
= XGetImage (FRAME_X_DISPLAY (f
), img
->mask
,
5014 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
5016 img
->background_transparent
5017 = !four_corners_best (mask
, img
->width
, img
->height
);
5020 XDestroyImage (mask
);
5023 img
->background_transparent
= 0;
5025 img
->background_transparent_valid
= 1;
5028 return img
->background_transparent
;
5032 /***********************************************************************
5033 Helper functions for X image types
5034 ***********************************************************************/
5036 static void x_clear_image_1
P_ ((struct frame
*, struct image
*, int,
5038 static void x_clear_image
P_ ((struct frame
*f
, struct image
*img
));
5039 static unsigned long x_alloc_image_color
P_ ((struct frame
*f
,
5041 Lisp_Object color_name
,
5042 unsigned long dflt
));
5045 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
5046 free the pixmap if any. MASK_P non-zero means clear the mask
5047 pixmap if any. COLORS_P non-zero means free colors allocated for
5048 the image, if any. */
5051 x_clear_image_1 (f
, img
, pixmap_p
, mask_p
, colors_p
)
5054 int pixmap_p
, mask_p
, colors_p
;
5056 if (pixmap_p
&& img
->pixmap
)
5058 XFreePixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
5060 img
->background_valid
= 0;
5063 if (mask_p
&& img
->mask
)
5065 XFreePixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5067 img
->background_transparent_valid
= 0;
5070 if (colors_p
&& img
->ncolors
)
5072 x_free_colors (f
, img
->colors
, img
->ncolors
);
5073 xfree (img
->colors
);
5079 /* Free X resources of image IMG which is used on frame F. */
5082 x_clear_image (f
, img
)
5087 x_clear_image_1 (f
, img
, 1, 1, 1);
5092 /* Allocate color COLOR_NAME for image IMG on frame F. If color
5093 cannot be allocated, use DFLT. Add a newly allocated color to
5094 IMG->colors, so that it can be freed again. Value is the pixel
5097 static unsigned long
5098 x_alloc_image_color (f
, img
, color_name
, dflt
)
5101 Lisp_Object color_name
;
5105 unsigned long result
;
5107 xassert (STRINGP (color_name
));
5109 if (x_defined_color (f
, SDATA (color_name
), &color
, 1))
5111 /* This isn't called frequently so we get away with simply
5112 reallocating the color vector to the needed size, here. */
5115 (unsigned long *) xrealloc (img
->colors
,
5116 img
->ncolors
* sizeof *img
->colors
);
5117 img
->colors
[img
->ncolors
- 1] = color
.pixel
;
5118 result
= color
.pixel
;
5128 /***********************************************************************
5130 ***********************************************************************/
5132 static void cache_image
P_ ((struct frame
*f
, struct image
*img
));
5133 static void postprocess_image
P_ ((struct frame
*, struct image
*));
5136 /* Return a new, initialized image cache that is allocated from the
5137 heap. Call free_image_cache to free an image cache. */
5139 struct image_cache
*
5142 struct image_cache
*c
= (struct image_cache
*) xmalloc (sizeof *c
);
5145 bzero (c
, sizeof *c
);
5147 c
->images
= (struct image
**) xmalloc (c
->size
* sizeof *c
->images
);
5148 size
= IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
;
5149 c
->buckets
= (struct image
**) xmalloc (size
);
5150 bzero (c
->buckets
, size
);
5155 /* Free image cache of frame F. Be aware that X frames share images
5159 free_image_cache (f
)
5162 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5167 /* Cache should not be referenced by any frame when freed. */
5168 xassert (c
->refcount
== 0);
5170 for (i
= 0; i
< c
->used
; ++i
)
5171 free_image (f
, c
->images
[i
]);
5175 FRAME_X_IMAGE_CACHE (f
) = NULL
;
5180 /* Clear image cache of frame F. FORCE_P non-zero means free all
5181 images. FORCE_P zero means clear only images that haven't been
5182 displayed for some time. Should be called from time to time to
5183 reduce the number of loaded images. If image-eviction-seconds is
5184 non-nil, this frees images in the cache which weren't displayed for
5185 at least that many seconds. */
5188 clear_image_cache (f
, force_p
)
5192 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5194 if (c
&& INTEGERP (Vimage_cache_eviction_delay
))
5201 old
= EMACS_SECS (t
) - XFASTINT (Vimage_cache_eviction_delay
);
5203 /* Block input so that we won't be interrupted by a SIGIO
5204 while being in an inconsistent state. */
5207 for (i
= nfreed
= 0; i
< c
->used
; ++i
)
5209 struct image
*img
= c
->images
[i
];
5211 && (force_p
|| img
->timestamp
< old
))
5213 free_image (f
, img
);
5218 /* We may be clearing the image cache because, for example,
5219 Emacs was iconified for a longer period of time. In that
5220 case, current matrices may still contain references to
5221 images freed above. So, clear these matrices. */
5224 Lisp_Object tail
, frame
;
5226 FOR_EACH_FRAME (tail
, frame
)
5228 struct frame
*f
= XFRAME (frame
);
5230 && FRAME_X_IMAGE_CACHE (f
) == c
)
5231 clear_current_matrices (f
);
5234 ++windows_or_buffers_changed
;
5242 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
5244 doc
: /* Clear the image cache of FRAME.
5245 FRAME nil or omitted means use the selected frame.
5246 FRAME t means clear the image caches of all frames. */)
5254 FOR_EACH_FRAME (tail
, frame
)
5255 if (FRAME_X_P (XFRAME (frame
)))
5256 clear_image_cache (XFRAME (frame
), 1);
5259 clear_image_cache (check_x_frame (frame
), 1);
5265 /* Compute masks and transform image IMG on frame F, as specified
5266 by the image's specification, */
5269 postprocess_image (f
, img
)
5273 /* Manipulation of the image's mask. */
5276 Lisp_Object conversion
, spec
;
5281 /* `:heuristic-mask t'
5283 means build a mask heuristically.
5284 `:heuristic-mask (R G B)'
5285 `:mask (heuristic (R G B))'
5286 means build a mask from color (R G B) in the
5289 means remove a mask, if any. */
5291 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
5293 x_build_heuristic_mask (f
, img
, mask
);
5298 mask
= image_spec_value (spec
, QCmask
, &found_p
);
5300 if (EQ (mask
, Qheuristic
))
5301 x_build_heuristic_mask (f
, img
, Qt
);
5302 else if (CONSP (mask
)
5303 && EQ (XCAR (mask
), Qheuristic
))
5305 if (CONSP (XCDR (mask
)))
5306 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
5308 x_build_heuristic_mask (f
, img
, XCDR (mask
));
5310 else if (NILP (mask
) && found_p
&& img
->mask
)
5312 XFreePixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5318 /* Should we apply an image transformation algorithm? */
5319 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
5320 if (EQ (conversion
, Qdisabled
))
5321 x_disable_image (f
, img
);
5322 else if (EQ (conversion
, Qlaplace
))
5324 else if (EQ (conversion
, Qemboss
))
5326 else if (CONSP (conversion
)
5327 && EQ (XCAR (conversion
), Qedge_detection
))
5330 tem
= XCDR (conversion
);
5332 x_edge_detection (f
, img
,
5333 Fplist_get (tem
, QCmatrix
),
5334 Fplist_get (tem
, QCcolor_adjustment
));
5340 /* Return the id of image with Lisp specification SPEC on frame F.
5341 SPEC must be a valid Lisp image specification (see valid_image_p). */
5344 lookup_image (f
, spec
)
5348 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5352 struct gcpro gcpro1
;
5355 /* F must be a window-system frame, and SPEC must be a valid image
5357 xassert (FRAME_WINDOW_P (f
));
5358 xassert (valid_image_p (spec
));
5362 /* Look up SPEC in the hash table of the image cache. */
5363 hash
= sxhash (spec
, 0);
5364 i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
5366 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
5367 if (img
->hash
== hash
&& !NILP (Fequal (img
->spec
, spec
)))
5370 /* If not found, create a new image and cache it. */
5373 extern Lisp_Object Qpostscript
;
5376 img
= make_image (spec
, hash
);
5377 cache_image (f
, img
);
5378 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
5380 /* If we can't load the image, and we don't have a width and
5381 height, use some arbitrary width and height so that we can
5382 draw a rectangle for it. */
5383 if (img
->load_failed_p
)
5387 value
= image_spec_value (spec
, QCwidth
, NULL
);
5388 img
->width
= (INTEGERP (value
)
5389 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
5390 value
= image_spec_value (spec
, QCheight
, NULL
);
5391 img
->height
= (INTEGERP (value
)
5392 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
5396 /* Handle image type independent image attributes
5397 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
5398 `:background COLOR'. */
5399 Lisp_Object ascent
, margin
, relief
, bg
;
5401 ascent
= image_spec_value (spec
, QCascent
, NULL
);
5402 if (INTEGERP (ascent
))
5403 img
->ascent
= XFASTINT (ascent
);
5404 else if (EQ (ascent
, Qcenter
))
5405 img
->ascent
= CENTERED_IMAGE_ASCENT
;
5407 margin
= image_spec_value (spec
, QCmargin
, NULL
);
5408 if (INTEGERP (margin
) && XINT (margin
) >= 0)
5409 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
5410 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
5411 && INTEGERP (XCDR (margin
)))
5413 if (XINT (XCAR (margin
)) > 0)
5414 img
->hmargin
= XFASTINT (XCAR (margin
));
5415 if (XINT (XCDR (margin
)) > 0)
5416 img
->vmargin
= XFASTINT (XCDR (margin
));
5419 relief
= image_spec_value (spec
, QCrelief
, NULL
);
5420 if (INTEGERP (relief
))
5422 img
->relief
= XINT (relief
);
5423 img
->hmargin
+= abs (img
->relief
);
5424 img
->vmargin
+= abs (img
->relief
);
5427 if (! img
->background_valid
)
5429 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
5433 = x_alloc_image_color (f
, img
, bg
,
5434 FRAME_BACKGROUND_PIXEL (f
));
5435 img
->background_valid
= 1;
5439 /* Do image transformations and compute masks, unless we
5440 don't have the image yet. */
5441 if (!EQ (*img
->type
->type
, Qpostscript
))
5442 postprocess_image (f
, img
);
5446 xassert (!interrupt_input_blocked
);
5449 /* We're using IMG, so set its timestamp to `now'. */
5450 EMACS_GET_TIME (now
);
5451 img
->timestamp
= EMACS_SECS (now
);
5455 /* Value is the image id. */
5460 /* Cache image IMG in the image cache of frame F. */
5463 cache_image (f
, img
)
5467 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5470 /* Find a free slot in c->images. */
5471 for (i
= 0; i
< c
->used
; ++i
)
5472 if (c
->images
[i
] == NULL
)
5475 /* If no free slot found, maybe enlarge c->images. */
5476 if (i
== c
->used
&& c
->used
== c
->size
)
5479 c
->images
= (struct image
**) xrealloc (c
->images
,
5480 c
->size
* sizeof *c
->images
);
5483 /* Add IMG to c->images, and assign IMG an id. */
5489 /* Add IMG to the cache's hash table. */
5490 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
5491 img
->next
= c
->buckets
[i
];
5493 img
->next
->prev
= img
;
5495 c
->buckets
[i
] = img
;
5499 /* Call FN on every image in the image cache of frame F. Used to mark
5500 Lisp Objects in the image cache. */
5503 forall_images_in_image_cache (f
, fn
)
5505 void (*fn
) P_ ((struct image
*img
));
5507 if (FRAME_LIVE_P (f
) && FRAME_X_P (f
))
5509 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5513 for (i
= 0; i
< c
->used
; ++i
)
5522 /***********************************************************************
5524 ***********************************************************************/
5526 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
5527 XImage
**, Pixmap
*));
5528 static void x_destroy_x_image
P_ ((XImage
*));
5529 static void x_put_x_image
P_ ((struct frame
*, XImage
*, Pixmap
, int, int));
5532 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
5533 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
5534 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
5535 via xmalloc. Print error messages via image_error if an error
5536 occurs. Value is non-zero if successful. */
5539 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
5541 int width
, height
, depth
;
5545 Display
*display
= FRAME_X_DISPLAY (f
);
5546 Screen
*screen
= FRAME_X_SCREEN (f
);
5547 Window window
= FRAME_X_WINDOW (f
);
5549 xassert (interrupt_input_blocked
);
5552 depth
= DefaultDepthOfScreen (screen
);
5553 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
5554 depth
, ZPixmap
, 0, NULL
, width
, height
,
5555 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
5558 image_error ("Unable to allocate X image", Qnil
, Qnil
);
5562 /* Allocate image raster. */
5563 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
5565 /* Allocate a pixmap of the same size. */
5566 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
5567 if (*pixmap
== None
)
5569 x_destroy_x_image (*ximg
);
5571 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
5579 /* Destroy XImage XIMG. Free XIMG->data. */
5582 x_destroy_x_image (ximg
)
5585 xassert (interrupt_input_blocked
);
5590 XDestroyImage (ximg
);
5595 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
5596 are width and height of both the image and pixmap. */
5599 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
5607 xassert (interrupt_input_blocked
);
5608 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
5609 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
5610 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
5615 /***********************************************************************
5617 ***********************************************************************/
5619 static Lisp_Object x_find_image_file
P_ ((Lisp_Object
));
5620 static char *slurp_file
P_ ((char *, int *));
5623 /* Find image file FILE. Look in data-directory, then
5624 x-bitmap-file-path. Value is the full name of the file found, or
5625 nil if not found. */
5628 x_find_image_file (file
)
5631 Lisp_Object file_found
, search_path
;
5632 struct gcpro gcpro1
, gcpro2
;
5636 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
5637 GCPRO2 (file_found
, search_path
);
5639 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
5640 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
5652 /* Read FILE into memory. Value is a pointer to a buffer allocated
5653 with xmalloc holding FILE's contents. Value is null if an error
5654 occurred. *SIZE is set to the size of the file. */
5657 slurp_file (file
, size
)
5665 if (stat (file
, &st
) == 0
5666 && (fp
= fopen (file
, "r")) != NULL
5667 && (buf
= (char *) xmalloc (st
.st_size
),
5668 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5689 /***********************************************************************
5691 ***********************************************************************/
5693 static int xbm_scan
P_ ((char **, char *, char *, int *));
5694 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
5695 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
5697 static int xbm_image_p
P_ ((Lisp_Object object
));
5698 static int xbm_read_bitmap_data
P_ ((char *, char *, int *, int *,
5700 static int xbm_file_p
P_ ((Lisp_Object
));
5703 /* Indices of image specification fields in xbm_format, below. */
5705 enum xbm_keyword_index
5723 /* Vector of image_keyword structures describing the format
5724 of valid XBM image specifications. */
5726 static struct image_keyword xbm_format
[XBM_LAST
] =
5728 {":type", IMAGE_SYMBOL_VALUE
, 1},
5729 {":file", IMAGE_STRING_VALUE
, 0},
5730 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
5731 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
5732 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5733 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5734 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
5735 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5736 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5737 {":relief", IMAGE_INTEGER_VALUE
, 0},
5738 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5739 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5740 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
5743 /* Structure describing the image type XBM. */
5745 static struct image_type xbm_type
=
5754 /* Tokens returned from xbm_scan. */
5763 /* Return non-zero if OBJECT is a valid XBM-type image specification.
5764 A valid specification is a list starting with the symbol `image'
5765 The rest of the list is a property list which must contain an
5768 If the specification specifies a file to load, it must contain
5769 an entry `:file FILENAME' where FILENAME is a string.
5771 If the specification is for a bitmap loaded from memory it must
5772 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
5773 WIDTH and HEIGHT are integers > 0. DATA may be:
5775 1. a string large enough to hold the bitmap data, i.e. it must
5776 have a size >= (WIDTH + 7) / 8 * HEIGHT
5778 2. a bool-vector of size >= WIDTH * HEIGHT
5780 3. a vector of strings or bool-vectors, one for each line of the
5783 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
5784 may not be specified in this case because they are defined in the
5787 Both the file and data forms may contain the additional entries
5788 `:background COLOR' and `:foreground COLOR'. If not present,
5789 foreground and background of the frame on which the image is
5790 displayed is used. */
5793 xbm_image_p (object
)
5796 struct image_keyword kw
[XBM_LAST
];
5798 bcopy (xbm_format
, kw
, sizeof kw
);
5799 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
5802 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
5804 if (kw
[XBM_FILE
].count
)
5806 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
5809 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
5811 /* In-memory XBM file. */
5812 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
5820 /* Entries for `:width', `:height' and `:data' must be present. */
5821 if (!kw
[XBM_WIDTH
].count
5822 || !kw
[XBM_HEIGHT
].count
5823 || !kw
[XBM_DATA
].count
)
5826 data
= kw
[XBM_DATA
].value
;
5827 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
5828 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
5830 /* Check type of data, and width and height against contents of
5836 /* Number of elements of the vector must be >= height. */
5837 if (XVECTOR (data
)->size
< height
)
5840 /* Each string or bool-vector in data must be large enough
5841 for one line of the image. */
5842 for (i
= 0; i
< height
; ++i
)
5844 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
5849 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
5852 else if (BOOL_VECTOR_P (elt
))
5854 if (XBOOL_VECTOR (elt
)->size
< width
)
5861 else if (STRINGP (data
))
5864 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
5867 else if (BOOL_VECTOR_P (data
))
5869 if (XBOOL_VECTOR (data
)->size
< width
* height
)
5880 /* Scan a bitmap file. FP is the stream to read from. Value is
5881 either an enumerator from enum xbm_token, or a character for a
5882 single-character token, or 0 at end of file. If scanning an
5883 identifier, store the lexeme of the identifier in SVAL. If
5884 scanning a number, store its value in *IVAL. */
5887 xbm_scan (s
, end
, sval
, ival
)
5896 /* Skip white space. */
5897 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5902 else if (isdigit (c
))
5904 int value
= 0, digit
;
5906 if (c
== '0' && *s
< end
)
5909 if (c
== 'x' || c
== 'X')
5916 else if (c
>= 'a' && c
<= 'f')
5917 digit
= c
- 'a' + 10;
5918 else if (c
>= 'A' && c
<= 'F')
5919 digit
= c
- 'A' + 10;
5922 value
= 16 * value
+ digit
;
5925 else if (isdigit (c
))
5929 && (c
= *(*s
)++, isdigit (c
)))
5930 value
= 8 * value
+ c
- '0';
5937 && (c
= *(*s
)++, isdigit (c
)))
5938 value
= 10 * value
+ c
- '0';
5946 else if (isalpha (c
) || c
== '_')
5950 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
5957 else if (c
== '/' && **s
== '*')
5959 /* C-style comment. */
5961 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
5974 /* Replacement for XReadBitmapFileData which isn't available under old
5975 X versions. CONTENTS is a pointer to a buffer to parse; END is the
5976 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
5977 the image. Return in *DATA the bitmap data allocated with xmalloc.
5978 Value is non-zero if successful. DATA null means just test if
5979 CONTENTS looks like an in-memory XBM file. */
5982 xbm_read_bitmap_data (contents
, end
, width
, height
, data
)
5983 char *contents
, *end
;
5984 int *width
, *height
;
5985 unsigned char **data
;
5988 char buffer
[BUFSIZ
];
5991 int bytes_per_line
, i
, nbytes
;
5997 LA1 = xbm_scan (&s, end, buffer, &value)
5999 #define expect(TOKEN) \
6000 if (LA1 != (TOKEN)) \
6005 #define expect_ident(IDENT) \
6006 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
6011 *width
= *height
= -1;
6014 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
6016 /* Parse defines for width, height and hot-spots. */
6020 expect_ident ("define");
6021 expect (XBM_TK_IDENT
);
6023 if (LA1
== XBM_TK_NUMBER
);
6025 char *p
= strrchr (buffer
, '_');
6026 p
= p
? p
+ 1 : buffer
;
6027 if (strcmp (p
, "width") == 0)
6029 else if (strcmp (p
, "height") == 0)
6032 expect (XBM_TK_NUMBER
);
6035 if (*width
< 0 || *height
< 0)
6037 else if (data
== NULL
)
6040 /* Parse bits. Must start with `static'. */
6041 expect_ident ("static");
6042 if (LA1
== XBM_TK_IDENT
)
6044 if (strcmp (buffer
, "unsigned") == 0)
6047 expect_ident ("char");
6049 else if (strcmp (buffer
, "short") == 0)
6053 if (*width
% 16 && *width
% 16 < 9)
6056 else if (strcmp (buffer
, "char") == 0)
6064 expect (XBM_TK_IDENT
);
6070 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
6071 nbytes
= bytes_per_line
* *height
;
6072 p
= *data
= (char *) xmalloc (nbytes
);
6076 for (i
= 0; i
< nbytes
; i
+= 2)
6079 expect (XBM_TK_NUMBER
);
6082 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
6085 if (LA1
== ',' || LA1
== '}')
6093 for (i
= 0; i
< nbytes
; ++i
)
6096 expect (XBM_TK_NUMBER
);
6100 if (LA1
== ',' || LA1
== '}')
6125 /* Load XBM image IMG which will be displayed on frame F from buffer
6126 CONTENTS. END is the end of the buffer. Value is non-zero if
6130 xbm_load_image (f
, img
, contents
, end
)
6133 char *contents
, *end
;
6136 unsigned char *data
;
6139 rc
= xbm_read_bitmap_data (contents
, end
, &img
->width
, &img
->height
, &data
);
6142 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
6143 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
6144 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
6147 xassert (img
->width
> 0 && img
->height
> 0);
6149 /* Get foreground and background colors, maybe allocate colors. */
6150 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
6152 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
6153 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
6156 background
= x_alloc_image_color (f
, img
, value
, background
);
6157 img
->background
= background
;
6158 img
->background_valid
= 1;
6162 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
6165 img
->width
, img
->height
,
6166 foreground
, background
,
6170 if (img
->pixmap
== None
)
6172 x_clear_image (f
, img
);
6173 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
6179 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
6185 /* Value is non-zero if DATA looks like an in-memory XBM file. */
6192 return (STRINGP (data
)
6193 && xbm_read_bitmap_data (SDATA (data
),
6200 /* Fill image IMG which is used on frame F with pixmap data. Value is
6201 non-zero if successful. */
6209 Lisp_Object file_name
;
6211 xassert (xbm_image_p (img
->spec
));
6213 /* If IMG->spec specifies a file name, create a non-file spec from it. */
6214 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
6215 if (STRINGP (file_name
))
6220 struct gcpro gcpro1
;
6222 file
= x_find_image_file (file_name
);
6224 if (!STRINGP (file
))
6226 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
6231 contents
= slurp_file (SDATA (file
), &size
);
6232 if (contents
== NULL
)
6234 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
6239 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
6244 struct image_keyword fmt
[XBM_LAST
];
6247 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
6248 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
6251 int in_memory_file_p
= 0;
6253 /* See if data looks like an in-memory XBM file. */
6254 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6255 in_memory_file_p
= xbm_file_p (data
);
6257 /* Parse the image specification. */
6258 bcopy (xbm_format
, fmt
, sizeof fmt
);
6259 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
6262 /* Get specified width, and height. */
6263 if (!in_memory_file_p
)
6265 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
6266 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
6267 xassert (img
->width
> 0 && img
->height
> 0);
6270 /* Get foreground and background colors, maybe allocate colors. */
6271 if (fmt
[XBM_FOREGROUND
].count
6272 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
6273 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
6275 if (fmt
[XBM_BACKGROUND
].count
6276 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
6277 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
6280 if (in_memory_file_p
)
6281 success_p
= xbm_load_image (f
, img
, SDATA (data
),
6290 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
6292 p
= bits
= (char *) alloca (nbytes
* img
->height
);
6293 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
6295 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
6297 bcopy (SDATA (line
), p
, nbytes
);
6299 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
6302 else if (STRINGP (data
))
6303 bits
= SDATA (data
);
6305 bits
= XBOOL_VECTOR (data
)->data
;
6307 /* Create the pixmap. */
6308 depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
6310 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
6313 img
->width
, img
->height
,
6314 foreground
, background
,
6320 image_error ("Unable to create pixmap for XBM image `%s'",
6322 x_clear_image (f
, img
);
6332 /***********************************************************************
6334 ***********************************************************************/
6338 static int xpm_image_p
P_ ((Lisp_Object object
));
6339 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
6340 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
6342 #include "X11/xpm.h"
6344 /* The symbol `xpm' identifying XPM-format images. */
6348 /* Indices of image specification fields in xpm_format, below. */
6350 enum xpm_keyword_index
6366 /* Vector of image_keyword structures describing the format
6367 of valid XPM image specifications. */
6369 static struct image_keyword xpm_format
[XPM_LAST
] =
6371 {":type", IMAGE_SYMBOL_VALUE
, 1},
6372 {":file", IMAGE_STRING_VALUE
, 0},
6373 {":data", IMAGE_STRING_VALUE
, 0},
6374 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6375 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6376 {":relief", IMAGE_INTEGER_VALUE
, 0},
6377 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6378 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6379 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6380 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6381 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6384 /* Structure describing the image type XBM. */
6386 static struct image_type xpm_type
=
6396 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
6397 functions for allocating image colors. Our own functions handle
6398 color allocation failures more gracefully than the ones on the XPM
6401 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
6402 #define ALLOC_XPM_COLORS
6405 #ifdef ALLOC_XPM_COLORS
6407 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
6408 static void xpm_free_color_cache
P_ ((void));
6409 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
6410 static int xpm_color_bucket
P_ ((char *));
6411 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
6414 /* An entry in a hash table used to cache color definitions of named
6415 colors. This cache is necessary to speed up XPM image loading in
6416 case we do color allocations ourselves. Without it, we would need
6417 a call to XParseColor per pixel in the image. */
6419 struct xpm_cached_color
6421 /* Next in collision chain. */
6422 struct xpm_cached_color
*next
;
6424 /* Color definition (RGB and pixel color). */
6431 /* The hash table used for the color cache, and its bucket vector
6434 #define XPM_COLOR_CACHE_BUCKETS 1001
6435 struct xpm_cached_color
**xpm_color_cache
;
6437 /* Initialize the color cache. */
6440 xpm_init_color_cache (f
, attrs
)
6442 XpmAttributes
*attrs
;
6444 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
6445 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
6446 memset (xpm_color_cache
, 0, nbytes
);
6447 init_color_table ();
6449 if (attrs
->valuemask
& XpmColorSymbols
)
6454 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
6455 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
6456 attrs
->colorsymbols
[i
].value
, &color
))
6458 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
6460 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
6466 /* Free the color cache. */
6469 xpm_free_color_cache ()
6471 struct xpm_cached_color
*p
, *next
;
6474 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
6475 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
6481 xfree (xpm_color_cache
);
6482 xpm_color_cache
= NULL
;
6483 free_color_table ();
6487 /* Return the bucket index for color named COLOR_NAME in the color
6491 xpm_color_bucket (color_name
)
6497 for (s
= color_name
; *s
; ++s
)
6499 return h
%= XPM_COLOR_CACHE_BUCKETS
;
6503 /* On frame F, cache values COLOR for color with name COLOR_NAME.
6504 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
6507 static struct xpm_cached_color
*
6508 xpm_cache_color (f
, color_name
, color
, bucket
)
6515 struct xpm_cached_color
*p
;
6518 bucket
= xpm_color_bucket (color_name
);
6520 nbytes
= sizeof *p
+ strlen (color_name
);
6521 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
6522 strcpy (p
->name
, color_name
);
6524 p
->next
= xpm_color_cache
[bucket
];
6525 xpm_color_cache
[bucket
] = p
;
6530 /* Look up color COLOR_NAME for frame F in the color cache. If found,
6531 return the cached definition in *COLOR. Otherwise, make a new
6532 entry in the cache and allocate the color. Value is zero if color
6533 allocation failed. */
6536 xpm_lookup_color (f
, color_name
, color
)
6541 struct xpm_cached_color
*p
;
6542 int h
= xpm_color_bucket (color_name
);
6544 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
6545 if (strcmp (p
->name
, color_name
) == 0)
6550 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
6553 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
6555 p
= xpm_cache_color (f
, color_name
, color
, h
);
6557 /* You get `opaque' at least from ImageMagick converting pbm to xpm
6558 with transparency, and it's useful. */
6559 else if (strcmp ("opaque", color_name
) == 0)
6561 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
6562 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
6563 p
= xpm_cache_color (f
, color_name
, color
, h
);
6570 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
6571 CLOSURE is a pointer to the frame on which we allocate the
6572 color. Return in *COLOR the allocated color. Value is non-zero
6576 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
6583 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
6587 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
6588 is a pointer to the frame on which we allocate the color. Value is
6589 non-zero if successful. */
6592 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
6602 #endif /* ALLOC_XPM_COLORS */
6605 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
6606 for XPM images. Such a list must consist of conses whose car and
6610 xpm_valid_color_symbols_p (color_symbols
)
6611 Lisp_Object color_symbols
;
6613 while (CONSP (color_symbols
))
6615 Lisp_Object sym
= XCAR (color_symbols
);
6617 || !STRINGP (XCAR (sym
))
6618 || !STRINGP (XCDR (sym
)))
6620 color_symbols
= XCDR (color_symbols
);
6623 return NILP (color_symbols
);
6627 /* Value is non-zero if OBJECT is a valid XPM image specification. */
6630 xpm_image_p (object
)
6633 struct image_keyword fmt
[XPM_LAST
];
6634 bcopy (xpm_format
, fmt
, sizeof fmt
);
6635 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
6636 /* Either `:file' or `:data' must be present. */
6637 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
6638 /* Either no `:color-symbols' or it's a list of conses
6639 whose car and cdr are strings. */
6640 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
6641 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
6645 /* Load image IMG which will be displayed on frame F. Value is
6646 non-zero if successful. */
6654 XpmAttributes attrs
;
6655 Lisp_Object specified_file
, color_symbols
;
6657 /* Configure the XPM lib. Use the visual of frame F. Allocate
6658 close colors. Return colors allocated. */
6659 bzero (&attrs
, sizeof attrs
);
6660 attrs
.visual
= FRAME_X_VISUAL (f
);
6661 attrs
.colormap
= FRAME_X_COLORMAP (f
);
6662 attrs
.valuemask
|= XpmVisual
;
6663 attrs
.valuemask
|= XpmColormap
;
6665 #ifdef ALLOC_XPM_COLORS
6666 /* Allocate colors with our own functions which handle
6667 failing color allocation more gracefully. */
6668 attrs
.color_closure
= f
;
6669 attrs
.alloc_color
= xpm_alloc_color
;
6670 attrs
.free_colors
= xpm_free_colors
;
6671 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
6672 #else /* not ALLOC_XPM_COLORS */
6673 /* Let the XPM lib allocate colors. */
6674 attrs
.valuemask
|= XpmReturnAllocPixels
;
6675 #ifdef XpmAllocCloseColors
6676 attrs
.alloc_close_colors
= 1;
6677 attrs
.valuemask
|= XpmAllocCloseColors
;
6678 #else /* not XpmAllocCloseColors */
6679 attrs
.closeness
= 600;
6680 attrs
.valuemask
|= XpmCloseness
;
6681 #endif /* not XpmAllocCloseColors */
6682 #endif /* ALLOC_XPM_COLORS */
6684 /* If image specification contains symbolic color definitions, add
6685 these to `attrs'. */
6686 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
6687 if (CONSP (color_symbols
))
6690 XpmColorSymbol
*xpm_syms
;
6693 attrs
.valuemask
|= XpmColorSymbols
;
6695 /* Count number of symbols. */
6696 attrs
.numsymbols
= 0;
6697 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
6700 /* Allocate an XpmColorSymbol array. */
6701 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
6702 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
6703 bzero (xpm_syms
, size
);
6704 attrs
.colorsymbols
= xpm_syms
;
6706 /* Fill the color symbol array. */
6707 for (tail
= color_symbols
, i
= 0;
6709 ++i
, tail
= XCDR (tail
))
6711 Lisp_Object name
= XCAR (XCAR (tail
));
6712 Lisp_Object color
= XCDR (XCAR (tail
));
6713 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
6714 strcpy (xpm_syms
[i
].name
, SDATA (name
));
6715 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
6716 strcpy (xpm_syms
[i
].value
, SDATA (color
));
6720 /* Create a pixmap for the image, either from a file, or from a
6721 string buffer containing data in the same format as an XPM file. */
6722 #ifdef ALLOC_XPM_COLORS
6723 xpm_init_color_cache (f
, &attrs
);
6726 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6727 if (STRINGP (specified_file
))
6729 Lisp_Object file
= x_find_image_file (specified_file
);
6730 if (!STRINGP (file
))
6732 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6736 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6737 SDATA (file
), &img
->pixmap
, &img
->mask
,
6742 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
6743 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6745 &img
->pixmap
, &img
->mask
,
6749 if (rc
== XpmSuccess
)
6751 #ifdef ALLOC_XPM_COLORS
6752 img
->colors
= colors_in_color_table (&img
->ncolors
);
6753 #else /* not ALLOC_XPM_COLORS */
6756 img
->ncolors
= attrs
.nalloc_pixels
;
6757 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
6758 * sizeof *img
->colors
);
6759 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
6761 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
6762 #ifdef DEBUG_X_COLORS
6763 register_color (img
->colors
[i
]);
6766 #endif /* not ALLOC_XPM_COLORS */
6768 img
->width
= attrs
.width
;
6769 img
->height
= attrs
.height
;
6770 xassert (img
->width
> 0 && img
->height
> 0);
6772 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
6773 XpmFreeAttributes (&attrs
);
6780 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
6783 case XpmFileInvalid
:
6784 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
6788 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
6791 case XpmColorFailed
:
6792 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
6796 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
6801 #ifdef ALLOC_XPM_COLORS
6802 xpm_free_color_cache ();
6804 return rc
== XpmSuccess
;
6807 #endif /* HAVE_XPM != 0 */
6810 /***********************************************************************
6812 ***********************************************************************/
6814 /* An entry in the color table mapping an RGB color to a pixel color. */
6819 unsigned long pixel
;
6821 /* Next in color table collision list. */
6822 struct ct_color
*next
;
6825 /* The bucket vector size to use. Must be prime. */
6829 /* Value is a hash of the RGB color given by R, G, and B. */
6831 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
6833 /* The color hash table. */
6835 struct ct_color
**ct_table
;
6837 /* Number of entries in the color table. */
6839 int ct_colors_allocated
;
6841 /* Initialize the color table. */
6846 int size
= CT_SIZE
* sizeof (*ct_table
);
6847 ct_table
= (struct ct_color
**) xmalloc (size
);
6848 bzero (ct_table
, size
);
6849 ct_colors_allocated
= 0;
6853 /* Free memory associated with the color table. */
6859 struct ct_color
*p
, *next
;
6861 for (i
= 0; i
< CT_SIZE
; ++i
)
6862 for (p
= ct_table
[i
]; p
; p
= next
)
6873 /* Value is a pixel color for RGB color R, G, B on frame F. If an
6874 entry for that color already is in the color table, return the
6875 pixel color of that entry. Otherwise, allocate a new color for R,
6876 G, B, and make an entry in the color table. */
6878 static unsigned long
6879 lookup_rgb_color (f
, r
, g
, b
)
6883 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
6884 int i
= hash
% CT_SIZE
;
6886 struct x_display_info
*dpyinfo
;
6888 /* Handle TrueColor visuals specially, which improves performance by
6889 two orders of magnitude. Freeing colors on TrueColor visuals is
6890 a nop, and pixel colors specify RGB values directly. See also
6891 the Xlib spec, chapter 3.1. */
6892 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6893 if (dpyinfo
->red_bits
> 0)
6895 unsigned long pr
, pg
, pb
;
6897 /* Apply gamma-correction like normal color allocation does. */
6901 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
6902 gamma_correct (f
, &color
);
6903 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
6906 /* Scale down RGB values to the visual's bits per RGB, and shift
6907 them to the right position in the pixel color. Note that the
6908 original RGB values are 16-bit values, as usual in X. */
6909 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
6910 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
6911 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
6913 /* Assemble the pixel color. */
6914 return pr
| pg
| pb
;
6917 for (p
= ct_table
[i
]; p
; p
= p
->next
)
6918 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
6931 cmap
= FRAME_X_COLORMAP (f
);
6932 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
6936 ++ct_colors_allocated
;
6938 p
= (struct ct_color
*) xmalloc (sizeof *p
);
6942 p
->pixel
= color
.pixel
;
6943 p
->next
= ct_table
[i
];
6947 return FRAME_FOREGROUND_PIXEL (f
);
6954 /* Look up pixel color PIXEL which is used on frame F in the color
6955 table. If not already present, allocate it. Value is PIXEL. */
6957 static unsigned long
6958 lookup_pixel_color (f
, pixel
)
6960 unsigned long pixel
;
6962 int i
= pixel
% CT_SIZE
;
6965 for (p
= ct_table
[i
]; p
; p
= p
->next
)
6966 if (p
->pixel
== pixel
)
6975 cmap
= FRAME_X_COLORMAP (f
);
6976 color
.pixel
= pixel
;
6977 x_query_color (f
, &color
);
6978 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
6982 ++ct_colors_allocated
;
6984 p
= (struct ct_color
*) xmalloc (sizeof *p
);
6989 p
->next
= ct_table
[i
];
6993 return FRAME_FOREGROUND_PIXEL (f
);
7000 /* Value is a vector of all pixel colors contained in the color table,
7001 allocated via xmalloc. Set *N to the number of colors. */
7003 static unsigned long *
7004 colors_in_color_table (n
)
7009 unsigned long *colors
;
7011 if (ct_colors_allocated
== 0)
7018 colors
= (unsigned long *) xmalloc (ct_colors_allocated
7020 *n
= ct_colors_allocated
;
7022 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
7023 for (p
= ct_table
[i
]; p
; p
= p
->next
)
7024 colors
[j
++] = p
->pixel
;
7032 /***********************************************************************
7034 ***********************************************************************/
7036 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
7037 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
7038 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
7040 /* Non-zero means draw a cross on images having `:conversion
7043 int cross_disabled_images
;
7045 /* Edge detection matrices for different edge-detection
7048 static int emboss_matrix
[9] = {
7050 2, -1, 0, /* y - 1 */
7052 0, 1, -2 /* y + 1 */
7055 static int laplace_matrix
[9] = {
7057 1, 0, 0, /* y - 1 */
7059 0, 0, -1 /* y + 1 */
7062 /* Value is the intensity of the color whose red/green/blue values
7065 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
7068 /* On frame F, return an array of XColor structures describing image
7069 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
7070 non-zero means also fill the red/green/blue members of the XColor
7071 structures. Value is a pointer to the array of XColors structures,
7072 allocated with xmalloc; it must be freed by the caller. */
7075 x_to_xcolors (f
, img
, rgb_p
)
7084 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
7086 /* Get the X image IMG->pixmap. */
7087 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
7088 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
7090 /* Fill the `pixel' members of the XColor array. I wished there
7091 were an easy and portable way to circumvent XGetPixel. */
7093 for (y
= 0; y
< img
->height
; ++y
)
7097 for (x
= 0; x
< img
->width
; ++x
, ++p
)
7098 p
->pixel
= XGetPixel (ximg
, x
, y
);
7101 x_query_colors (f
, row
, img
->width
);
7104 XDestroyImage (ximg
);
7109 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
7110 RGB members are set. F is the frame on which this all happens.
7111 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
7114 x_from_xcolors (f
, img
, colors
)
7124 init_color_table ();
7126 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
7129 for (y
= 0; y
< img
->height
; ++y
)
7130 for (x
= 0; x
< img
->width
; ++x
, ++p
)
7132 unsigned long pixel
;
7133 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
7134 XPutPixel (oimg
, x
, y
, pixel
);
7138 x_clear_image_1 (f
, img
, 1, 0, 1);
7140 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
7141 x_destroy_x_image (oimg
);
7142 img
->pixmap
= pixmap
;
7143 img
->colors
= colors_in_color_table (&img
->ncolors
);
7144 free_color_table ();
7148 /* On frame F, perform edge-detection on image IMG.
7150 MATRIX is a nine-element array specifying the transformation
7151 matrix. See emboss_matrix for an example.
7153 COLOR_ADJUST is a color adjustment added to each pixel of the
7157 x_detect_edges (f
, img
, matrix
, color_adjust
)
7160 int matrix
[9], color_adjust
;
7162 XColor
*colors
= x_to_xcolors (f
, img
, 1);
7166 for (i
= sum
= 0; i
< 9; ++i
)
7167 sum
+= abs (matrix
[i
]);
7169 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
7171 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
7173 for (y
= 0; y
< img
->height
; ++y
)
7175 p
= COLOR (new, 0, y
);
7176 p
->red
= p
->green
= p
->blue
= 0xffff/2;
7177 p
= COLOR (new, img
->width
- 1, y
);
7178 p
->red
= p
->green
= p
->blue
= 0xffff/2;
7181 for (x
= 1; x
< img
->width
- 1; ++x
)
7183 p
= COLOR (new, x
, 0);
7184 p
->red
= p
->green
= p
->blue
= 0xffff/2;
7185 p
= COLOR (new, x
, img
->height
- 1);
7186 p
->red
= p
->green
= p
->blue
= 0xffff/2;
7189 for (y
= 1; y
< img
->height
- 1; ++y
)
7191 p
= COLOR (new, 1, y
);
7193 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
7195 int r
, g
, b
, y1
, x1
;
7198 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
7199 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
7202 XColor
*t
= COLOR (colors
, x1
, y1
);
7203 r
+= matrix
[i
] * t
->red
;
7204 g
+= matrix
[i
] * t
->green
;
7205 b
+= matrix
[i
] * t
->blue
;
7208 r
= (r
/ sum
+ color_adjust
) & 0xffff;
7209 g
= (g
/ sum
+ color_adjust
) & 0xffff;
7210 b
= (b
/ sum
+ color_adjust
) & 0xffff;
7211 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
7216 x_from_xcolors (f
, img
, new);
7222 /* Perform the pre-defined `emboss' edge-detection on image IMG
7230 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
7234 /* Perform the pre-defined `laplace' edge-detection on image IMG
7242 x_detect_edges (f
, img
, laplace_matrix
, 45000);
7246 /* Perform edge-detection on image IMG on frame F, with specified
7247 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
7249 MATRIX must be either
7251 - a list of at least 9 numbers in row-major form
7252 - a vector of at least 9 numbers
7254 COLOR_ADJUST nil means use a default; otherwise it must be a
7258 x_edge_detection (f
, img
, matrix
, color_adjust
)
7261 Lisp_Object matrix
, color_adjust
;
7269 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
7270 ++i
, matrix
= XCDR (matrix
))
7271 trans
[i
] = XFLOATINT (XCAR (matrix
));
7273 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
7275 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
7276 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
7279 if (NILP (color_adjust
))
7280 color_adjust
= make_number (0xffff / 2);
7282 if (i
== 9 && NUMBERP (color_adjust
))
7283 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
7287 /* Transform image IMG on frame F so that it looks disabled. */
7290 x_disable_image (f
, img
)
7294 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7296 if (dpyinfo
->n_planes
>= 2)
7298 /* Color (or grayscale). Convert to gray, and equalize. Just
7299 drawing such images with a stipple can look very odd, so
7300 we're using this method instead. */
7301 XColor
*colors
= x_to_xcolors (f
, img
, 1);
7303 const int h
= 15000;
7304 const int l
= 30000;
7306 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
7310 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
7311 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
7312 p
->red
= p
->green
= p
->blue
= i2
;
7315 x_from_xcolors (f
, img
, colors
);
7318 /* Draw a cross over the disabled image, if we must or if we
7320 if (dpyinfo
->n_planes
< 2 || cross_disabled_images
)
7322 Display
*dpy
= FRAME_X_DISPLAY (f
);
7325 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
7326 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
7327 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
7328 img
->width
- 1, img
->height
- 1);
7329 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
7335 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
7336 XSetForeground (dpy
, gc
, WHITE_PIX_DEFAULT (f
));
7337 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
7338 img
->width
- 1, img
->height
- 1);
7339 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
7347 /* Build a mask for image IMG which is used on frame F. FILE is the
7348 name of an image file, for error messages. HOW determines how to
7349 determine the background color of IMG. If it is a list '(R G B)',
7350 with R, G, and B being integers >= 0, take that as the color of the
7351 background. Otherwise, determine the background color of IMG
7352 heuristically. Value is non-zero if successful. */
7355 x_build_heuristic_mask (f
, img
, how
)
7360 Display
*dpy
= FRAME_X_DISPLAY (f
);
7361 XImage
*ximg
, *mask_img
;
7362 int x
, y
, rc
, use_img_background
;
7363 unsigned long bg
= 0;
7367 XFreePixmap (FRAME_X_DISPLAY (f
), img
->mask
);
7369 img
->background_transparent_valid
= 0;
7372 /* Create an image and pixmap serving as mask. */
7373 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
7374 &mask_img
, &img
->mask
);
7378 /* Get the X image of IMG->pixmap. */
7379 ximg
= XGetImage (dpy
, img
->pixmap
, 0, 0, img
->width
, img
->height
,
7382 /* Determine the background color of ximg. If HOW is `(R G B)'
7383 take that as color. Otherwise, use the image's background color. */
7384 use_img_background
= 1;
7390 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
7392 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
7396 if (i
== 3 && NILP (how
))
7398 char color_name
[30];
7399 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
7400 bg
= x_alloc_image_color (f
, img
, build_string (color_name
), 0);
7401 use_img_background
= 0;
7405 if (use_img_background
)
7406 bg
= four_corners_best (ximg
, img
->width
, img
->height
);
7408 /* Set all bits in mask_img to 1 whose color in ximg is different
7409 from the background color bg. */
7410 for (y
= 0; y
< img
->height
; ++y
)
7411 for (x
= 0; x
< img
->width
; ++x
)
7412 XPutPixel (mask_img
, x
, y
, XGetPixel (ximg
, x
, y
) != bg
);
7414 /* Fill in the background_transparent field while we have the mask handy. */
7415 image_background_transparent (img
, f
, mask_img
);
7417 /* Put mask_img into img->mask. */
7418 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
7419 x_destroy_x_image (mask_img
);
7420 XDestroyImage (ximg
);
7427 /***********************************************************************
7428 PBM (mono, gray, color)
7429 ***********************************************************************/
7431 static int pbm_image_p
P_ ((Lisp_Object object
));
7432 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
7433 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
7435 /* The symbol `pbm' identifying images of this type. */
7439 /* Indices of image specification fields in gs_format, below. */
7441 enum pbm_keyword_index
7457 /* Vector of image_keyword structures describing the format
7458 of valid user-defined image specifications. */
7460 static struct image_keyword pbm_format
[PBM_LAST
] =
7462 {":type", IMAGE_SYMBOL_VALUE
, 1},
7463 {":file", IMAGE_STRING_VALUE
, 0},
7464 {":data", IMAGE_STRING_VALUE
, 0},
7465 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7466 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7467 {":relief", IMAGE_INTEGER_VALUE
, 0},
7468 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7469 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7470 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7471 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
7472 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7475 /* Structure describing the image type `pbm'. */
7477 static struct image_type pbm_type
=
7487 /* Return non-zero if OBJECT is a valid PBM image specification. */
7490 pbm_image_p (object
)
7493 struct image_keyword fmt
[PBM_LAST
];
7495 bcopy (pbm_format
, fmt
, sizeof fmt
);
7497 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
7500 /* Must specify either :data or :file. */
7501 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
7505 /* Scan a decimal number from *S and return it. Advance *S while
7506 reading the number. END is the end of the string. Value is -1 at
7510 pbm_scan_number (s
, end
)
7511 unsigned char **s
, *end
;
7513 int c
= 0, val
= -1;
7517 /* Skip white-space. */
7518 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
7523 /* Skip comment to end of line. */
7524 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
7527 else if (isdigit (c
))
7529 /* Read decimal number. */
7531 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
7532 val
= 10 * val
+ c
- '0';
7543 /* Load PBM image IMG for use on frame F. */
7551 int width
, height
, max_color_idx
= 0;
7553 Lisp_Object file
, specified_file
;
7554 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
7555 struct gcpro gcpro1
;
7556 unsigned char *contents
= NULL
;
7557 unsigned char *end
, *p
;
7560 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7564 if (STRINGP (specified_file
))
7566 file
= x_find_image_file (specified_file
);
7567 if (!STRINGP (file
))
7569 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7574 contents
= slurp_file (SDATA (file
), &size
);
7575 if (contents
== NULL
)
7577 image_error ("Error reading `%s'", file
, Qnil
);
7583 end
= contents
+ size
;
7588 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7590 end
= p
+ SBYTES (data
);
7593 /* Check magic number. */
7594 if (end
- p
< 2 || *p
++ != 'P')
7596 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
7606 raw_p
= 0, type
= PBM_MONO
;
7610 raw_p
= 0, type
= PBM_GRAY
;
7614 raw_p
= 0, type
= PBM_COLOR
;
7618 raw_p
= 1, type
= PBM_MONO
;
7622 raw_p
= 1, type
= PBM_GRAY
;
7626 raw_p
= 1, type
= PBM_COLOR
;
7630 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
7634 /* Read width, height, maximum color-component. Characters
7635 starting with `#' up to the end of a line are ignored. */
7636 width
= pbm_scan_number (&p
, end
);
7637 height
= pbm_scan_number (&p
, end
);
7639 if (type
!= PBM_MONO
)
7641 max_color_idx
= pbm_scan_number (&p
, end
);
7642 if (raw_p
&& max_color_idx
> 255)
7643 max_color_idx
= 255;
7648 || (type
!= PBM_MONO
&& max_color_idx
< 0))
7651 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
7652 &ximg
, &img
->pixmap
))
7655 /* Initialize the color hash table. */
7656 init_color_table ();
7658 if (type
== PBM_MONO
)
7661 struct image_keyword fmt
[PBM_LAST
];
7662 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
7663 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
7665 /* Parse the image specification. */
7666 bcopy (pbm_format
, fmt
, sizeof fmt
);
7667 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
7669 /* Get foreground and background colors, maybe allocate colors. */
7670 if (fmt
[PBM_FOREGROUND
].count
7671 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
7672 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
7673 if (fmt
[PBM_BACKGROUND
].count
7674 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
7676 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
7677 img
->background
= bg
;
7678 img
->background_valid
= 1;
7681 for (y
= 0; y
< height
; ++y
)
7682 for (x
= 0; x
< width
; ++x
)
7692 g
= pbm_scan_number (&p
, end
);
7694 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
7699 for (y
= 0; y
< height
; ++y
)
7700 for (x
= 0; x
< width
; ++x
)
7704 if (type
== PBM_GRAY
)
7705 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
7714 r
= pbm_scan_number (&p
, end
);
7715 g
= pbm_scan_number (&p
, end
);
7716 b
= pbm_scan_number (&p
, end
);
7719 if (r
< 0 || g
< 0 || b
< 0)
7723 XDestroyImage (ximg
);
7724 image_error ("Invalid pixel value in image `%s'",
7729 /* RGB values are now in the range 0..max_color_idx.
7730 Scale this to the range 0..0xffff supported by X. */
7731 r
= (double) r
* 65535 / max_color_idx
;
7732 g
= (double) g
* 65535 / max_color_idx
;
7733 b
= (double) b
* 65535 / max_color_idx
;
7734 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
7738 /* Store in IMG->colors the colors allocated for the image, and
7739 free the color table. */
7740 img
->colors
= colors_in_color_table (&img
->ncolors
);
7741 free_color_table ();
7743 /* Maybe fill in the background field while we have ximg handy. */
7744 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7745 IMAGE_BACKGROUND (img
, f
, ximg
);
7747 /* Put the image into a pixmap. */
7748 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7749 x_destroy_x_image (ximg
);
7752 img
->height
= height
;
7761 /***********************************************************************
7763 ***********************************************************************/
7767 #if defined HAVE_LIBPNG_PNG_H
7768 # include <libpng/png.h>
7773 /* Function prototypes. */
7775 static int png_image_p
P_ ((Lisp_Object object
));
7776 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
7778 /* The symbol `png' identifying images of this type. */
7782 /* Indices of image specification fields in png_format, below. */
7784 enum png_keyword_index
7799 /* Vector of image_keyword structures describing the format
7800 of valid user-defined image specifications. */
7802 static struct image_keyword png_format
[PNG_LAST
] =
7804 {":type", IMAGE_SYMBOL_VALUE
, 1},
7805 {":data", IMAGE_STRING_VALUE
, 0},
7806 {":file", IMAGE_STRING_VALUE
, 0},
7807 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7808 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7809 {":relief", IMAGE_INTEGER_VALUE
, 0},
7810 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7811 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7812 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7813 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7816 /* Structure describing the image type `png'. */
7818 static struct image_type png_type
=
7828 /* Return non-zero if OBJECT is a valid PNG image specification. */
7831 png_image_p (object
)
7834 struct image_keyword fmt
[PNG_LAST
];
7835 bcopy (png_format
, fmt
, sizeof fmt
);
7837 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
7840 /* Must specify either the :data or :file keyword. */
7841 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
7845 /* Error and warning handlers installed when the PNG library
7849 my_png_error (png_ptr
, msg
)
7850 png_struct
*png_ptr
;
7853 xassert (png_ptr
!= NULL
);
7854 image_error ("PNG error: %s", build_string (msg
), Qnil
);
7855 longjmp (png_ptr
->jmpbuf
, 1);
7860 my_png_warning (png_ptr
, msg
)
7861 png_struct
*png_ptr
;
7864 xassert (png_ptr
!= NULL
);
7865 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
7868 /* Memory source for PNG decoding. */
7870 struct png_memory_storage
7872 unsigned char *bytes
; /* The data */
7873 size_t len
; /* How big is it? */
7874 int index
; /* Where are we? */
7878 /* Function set as reader function when reading PNG image from memory.
7879 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
7880 bytes from the input to DATA. */
7883 png_read_from_memory (png_ptr
, data
, length
)
7884 png_structp png_ptr
;
7888 struct png_memory_storage
*tbr
7889 = (struct png_memory_storage
*) png_get_io_ptr (png_ptr
);
7891 if (length
> tbr
->len
- tbr
->index
)
7892 png_error (png_ptr
, "Read error");
7894 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
7895 tbr
->index
= tbr
->index
+ length
;
7898 /* Load PNG image IMG for use on frame F. Value is non-zero if
7906 Lisp_Object file
, specified_file
;
7907 Lisp_Object specified_data
;
7909 XImage
*ximg
, *mask_img
= NULL
;
7910 struct gcpro gcpro1
;
7911 png_struct
*png_ptr
= NULL
;
7912 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
7913 FILE *volatile fp
= NULL
;
7915 png_byte
* volatile pixels
= NULL
;
7916 png_byte
** volatile rows
= NULL
;
7917 png_uint_32 width
, height
;
7918 int bit_depth
, color_type
, interlace_type
;
7920 png_uint_32 row_bytes
;
7922 double screen_gamma
;
7923 struct png_memory_storage tbr
; /* Data to be read */
7925 /* Find out what file to load. */
7926 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7927 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7931 if (NILP (specified_data
))
7933 file
= x_find_image_file (specified_file
);
7934 if (!STRINGP (file
))
7936 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7941 /* Open the image file. */
7942 fp
= fopen (SDATA (file
), "rb");
7945 image_error ("Cannot open image file `%s'", file
, Qnil
);
7951 /* Check PNG signature. */
7952 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
7953 || !png_check_sig (sig
, sizeof sig
))
7955 image_error ("Not a PNG file: `%s'", file
, Qnil
);
7963 /* Read from memory. */
7964 tbr
.bytes
= SDATA (specified_data
);
7965 tbr
.len
= SBYTES (specified_data
);
7968 /* Check PNG signature. */
7969 if (tbr
.len
< sizeof sig
7970 || !png_check_sig (tbr
.bytes
, sizeof sig
))
7972 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
7977 /* Need to skip past the signature. */
7978 tbr
.bytes
+= sizeof (sig
);
7981 /* Initialize read and info structs for PNG lib. */
7982 png_ptr
= png_create_read_struct (PNG_LIBPNG_VER_STRING
, NULL
,
7983 my_png_error
, my_png_warning
);
7986 if (fp
) fclose (fp
);
7991 info_ptr
= png_create_info_struct (png_ptr
);
7994 png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
7995 if (fp
) fclose (fp
);
8000 end_info
= png_create_info_struct (png_ptr
);
8003 png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
8004 if (fp
) fclose (fp
);
8009 /* Set error jump-back. We come back here when the PNG library
8010 detects an error. */
8011 if (setjmp (png_ptr
->jmpbuf
))
8015 png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
8018 if (fp
) fclose (fp
);
8023 /* Read image info. */
8024 if (!NILP (specified_data
))
8025 png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
8027 png_init_io (png_ptr
, fp
);
8029 png_set_sig_bytes (png_ptr
, sizeof sig
);
8030 png_read_info (png_ptr
, info_ptr
);
8031 png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
8032 &interlace_type
, NULL
, NULL
);
8034 /* If image contains simply transparency data, we prefer to
8035 construct a clipping mask. */
8036 if (png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
8041 /* This function is easier to write if we only have to handle
8042 one data format: RGB or RGBA with 8 bits per channel. Let's
8043 transform other formats into that format. */
8045 /* Strip more than 8 bits per channel. */
8046 if (bit_depth
== 16)
8047 png_set_strip_16 (png_ptr
);
8049 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
8051 png_set_expand (png_ptr
);
8053 /* Convert grayscale images to RGB. */
8054 if (color_type
== PNG_COLOR_TYPE_GRAY
8055 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
8056 png_set_gray_to_rgb (png_ptr
);
8058 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
8060 #if 0 /* Avoid double gamma correction for PNG images. */
8061 { /* Tell the PNG lib to handle gamma correction for us. */
8064 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
8065 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
8066 /* The libpng documentation says this is right in this case. */
8067 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
8070 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
8071 /* Image contains gamma information. */
8072 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
8074 /* Use the standard default for the image gamma. */
8075 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
8079 /* Handle alpha channel by combining the image with a background
8080 color. Do this only if a real alpha channel is supplied. For
8081 simple transparency, we prefer a clipping mask. */
8084 png_color_16
*image_bg
;
8085 Lisp_Object specified_bg
8086 = image_spec_value (img
->spec
, QCbackground
, NULL
);
8088 if (STRINGP (specified_bg
))
8089 /* The user specified `:background', use that. */
8092 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
8094 png_color_16 user_bg
;
8096 bzero (&user_bg
, sizeof user_bg
);
8097 user_bg
.red
= color
.red
;
8098 user_bg
.green
= color
.green
;
8099 user_bg
.blue
= color
.blue
;
8101 png_set_background (png_ptr
, &user_bg
,
8102 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
8105 else if (png_get_bKGD (png_ptr
, info_ptr
, &image_bg
))
8106 /* Image contains a background color with which to
8107 combine the image. */
8108 png_set_background (png_ptr
, image_bg
,
8109 PNG_BACKGROUND_GAMMA_FILE
, 1, 1.0);
8112 /* Image does not contain a background color with which
8113 to combine the image data via an alpha channel. Use
8114 the frame's background instead. */
8117 png_color_16 frame_background
;
8119 cmap
= FRAME_X_COLORMAP (f
);
8120 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8121 x_query_color (f
, &color
);
8123 bzero (&frame_background
, sizeof frame_background
);
8124 frame_background
.red
= color
.red
;
8125 frame_background
.green
= color
.green
;
8126 frame_background
.blue
= color
.blue
;
8128 png_set_background (png_ptr
, &frame_background
,
8129 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
8133 /* Update info structure. */
8134 png_read_update_info (png_ptr
, info_ptr
);
8136 /* Get number of channels. Valid values are 1 for grayscale images
8137 and images with a palette, 2 for grayscale images with transparency
8138 information (alpha channel), 3 for RGB images, and 4 for RGB
8139 images with alpha channel, i.e. RGBA. If conversions above were
8140 sufficient we should only have 3 or 4 channels here. */
8141 channels
= png_get_channels (png_ptr
, info_ptr
);
8142 xassert (channels
== 3 || channels
== 4);
8144 /* Number of bytes needed for one row of the image. */
8145 row_bytes
= png_get_rowbytes (png_ptr
, info_ptr
);
8147 /* Allocate memory for the image. */
8148 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
8149 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
8150 for (i
= 0; i
< height
; ++i
)
8151 rows
[i
] = pixels
+ i
* row_bytes
;
8153 /* Read the entire image. */
8154 png_read_image (png_ptr
, rows
);
8155 png_read_end (png_ptr
, info_ptr
);
8162 /* Create the X image and pixmap. */
8163 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
8167 /* Create an image and pixmap serving as mask if the PNG image
8168 contains an alpha channel. */
8171 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
8172 &mask_img
, &img
->mask
))
8174 x_destroy_x_image (ximg
);
8175 XFreePixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
8180 /* Fill the X image and mask from PNG data. */
8181 init_color_table ();
8183 for (y
= 0; y
< height
; ++y
)
8185 png_byte
*p
= rows
[y
];
8187 for (x
= 0; x
< width
; ++x
)
8194 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
8196 /* An alpha channel, aka mask channel, associates variable
8197 transparency with an image. Where other image formats
8198 support binary transparency---fully transparent or fully
8199 opaque---PNG allows up to 254 levels of partial transparency.
8200 The PNG library implements partial transparency by combining
8201 the image with a specified background color.
8203 I'm not sure how to handle this here nicely: because the
8204 background on which the image is displayed may change, for
8205 real alpha channel support, it would be necessary to create
8206 a new image for each possible background.
8208 What I'm doing now is that a mask is created if we have
8209 boolean transparency information. Otherwise I'm using
8210 the frame's background color to combine the image with. */
8215 XPutPixel (mask_img
, x
, y
, *p
> 0);
8221 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8222 /* Set IMG's background color from the PNG image, unless the user
8226 if (png_get_bKGD (png_ptr
, info_ptr
, &bg
))
8228 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
8229 img
->background_valid
= 1;
8233 /* Remember colors allocated for this image. */
8234 img
->colors
= colors_in_color_table (&img
->ncolors
);
8235 free_color_table ();
8238 png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
8243 img
->height
= height
;
8245 /* Maybe fill in the background field while we have ximg handy. */
8246 IMAGE_BACKGROUND (img
, f
, ximg
);
8248 /* Put the image into the pixmap, then free the X image and its buffer. */
8249 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8250 x_destroy_x_image (ximg
);
8252 /* Same for the mask. */
8255 /* Fill in the background_transparent field while we have the mask
8257 image_background_transparent (img
, f
, mask_img
);
8259 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
8260 x_destroy_x_image (mask_img
);
8267 #endif /* HAVE_PNG != 0 */
8271 /***********************************************************************
8273 ***********************************************************************/
8277 /* Work around a warning about HAVE_STDLIB_H being redefined in
8279 #ifdef HAVE_STDLIB_H
8280 #define HAVE_STDLIB_H_1
8281 #undef HAVE_STDLIB_H
8282 #endif /* HAVE_STLIB_H */
8284 #include <jpeglib.h>
8288 #ifdef HAVE_STLIB_H_1
8289 #define HAVE_STDLIB_H 1
8292 static int jpeg_image_p
P_ ((Lisp_Object object
));
8293 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
8295 /* The symbol `jpeg' identifying images of this type. */
8299 /* Indices of image specification fields in gs_format, below. */
8301 enum jpeg_keyword_index
8310 JPEG_HEURISTIC_MASK
,
8316 /* Vector of image_keyword structures describing the format
8317 of valid user-defined image specifications. */
8319 static struct image_keyword jpeg_format
[JPEG_LAST
] =
8321 {":type", IMAGE_SYMBOL_VALUE
, 1},
8322 {":data", IMAGE_STRING_VALUE
, 0},
8323 {":file", IMAGE_STRING_VALUE
, 0},
8324 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8325 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8326 {":relief", IMAGE_INTEGER_VALUE
, 0},
8327 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8328 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8329 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8330 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8333 /* Structure describing the image type `jpeg'. */
8335 static struct image_type jpeg_type
=
8345 /* Return non-zero if OBJECT is a valid JPEG image specification. */
8348 jpeg_image_p (object
)
8351 struct image_keyword fmt
[JPEG_LAST
];
8353 bcopy (jpeg_format
, fmt
, sizeof fmt
);
8355 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
8358 /* Must specify either the :data or :file keyword. */
8359 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
8363 struct my_jpeg_error_mgr
8365 struct jpeg_error_mgr pub
;
8366 jmp_buf setjmp_buffer
;
8371 my_error_exit (cinfo
)
8374 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
8375 longjmp (mgr
->setjmp_buffer
, 1);
8379 /* Init source method for JPEG data source manager. Called by
8380 jpeg_read_header() before any data is actually read. See
8381 libjpeg.doc from the JPEG lib distribution. */
8384 our_init_source (cinfo
)
8385 j_decompress_ptr cinfo
;
8390 /* Fill input buffer method for JPEG data source manager. Called
8391 whenever more data is needed. We read the whole image in one step,
8392 so this only adds a fake end of input marker at the end. */
8395 our_fill_input_buffer (cinfo
)
8396 j_decompress_ptr cinfo
;
8398 /* Insert a fake EOI marker. */
8399 struct jpeg_source_mgr
*src
= cinfo
->src
;
8400 static JOCTET buffer
[2];
8402 buffer
[0] = (JOCTET
) 0xFF;
8403 buffer
[1] = (JOCTET
) JPEG_EOI
;
8405 src
->next_input_byte
= buffer
;
8406 src
->bytes_in_buffer
= 2;
8411 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
8412 is the JPEG data source manager. */
8415 our_skip_input_data (cinfo
, num_bytes
)
8416 j_decompress_ptr cinfo
;
8419 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
8423 if (num_bytes
> src
->bytes_in_buffer
)
8424 ERREXIT (cinfo
, JERR_INPUT_EOF
);
8426 src
->bytes_in_buffer
-= num_bytes
;
8427 src
->next_input_byte
+= num_bytes
;
8432 /* Method to terminate data source. Called by
8433 jpeg_finish_decompress() after all data has been processed. */
8436 our_term_source (cinfo
)
8437 j_decompress_ptr cinfo
;
8442 /* Set up the JPEG lib for reading an image from DATA which contains
8443 LEN bytes. CINFO is the decompression info structure created for
8444 reading the image. */
8447 jpeg_memory_src (cinfo
, data
, len
)
8448 j_decompress_ptr cinfo
;
8452 struct jpeg_source_mgr
*src
;
8454 if (cinfo
->src
== NULL
)
8456 /* First time for this JPEG object? */
8457 cinfo
->src
= (struct jpeg_source_mgr
*)
8458 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
8459 sizeof (struct jpeg_source_mgr
));
8460 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
8461 src
->next_input_byte
= data
;
8464 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
8465 src
->init_source
= our_init_source
;
8466 src
->fill_input_buffer
= our_fill_input_buffer
;
8467 src
->skip_input_data
= our_skip_input_data
;
8468 src
->resync_to_restart
= jpeg_resync_to_restart
; /* Use default method. */
8469 src
->term_source
= our_term_source
;
8470 src
->bytes_in_buffer
= len
;
8471 src
->next_input_byte
= data
;
8475 /* Load image IMG for use on frame F. Patterned after example.c
8476 from the JPEG lib. */
8483 struct jpeg_decompress_struct cinfo
;
8484 struct my_jpeg_error_mgr mgr
;
8485 Lisp_Object file
, specified_file
;
8486 Lisp_Object specified_data
;
8487 FILE * volatile fp
= NULL
;
8489 int row_stride
, x
, y
;
8490 XImage
*ximg
= NULL
;
8492 unsigned long *colors
;
8494 struct gcpro gcpro1
;
8496 /* Open the JPEG file. */
8497 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
8498 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8502 if (NILP (specified_data
))
8504 file
= x_find_image_file (specified_file
);
8505 if (!STRINGP (file
))
8507 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
8512 fp
= fopen (SDATA (file
), "r");
8515 image_error ("Cannot open `%s'", file
, Qnil
);
8521 /* Customize libjpeg's error handling to call my_error_exit when an
8522 error is detected. This function will perform a longjmp. */
8523 cinfo
.err
= jpeg_std_error (&mgr
.pub
);
8524 mgr
.pub
.error_exit
= my_error_exit
;
8526 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
8530 /* Called from my_error_exit. Display a JPEG error. */
8531 char buffer
[JMSG_LENGTH_MAX
];
8532 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
8533 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
8534 build_string (buffer
));
8537 /* Close the input file and destroy the JPEG object. */
8539 fclose ((FILE *) fp
);
8540 jpeg_destroy_decompress (&cinfo
);
8542 /* If we already have an XImage, free that. */
8543 x_destroy_x_image (ximg
);
8545 /* Free pixmap and colors. */
8546 x_clear_image (f
, img
);
8552 /* Create the JPEG decompression object. Let it read from fp.
8553 Read the JPEG image header. */
8554 jpeg_create_decompress (&cinfo
);
8556 if (NILP (specified_data
))
8557 jpeg_stdio_src (&cinfo
, (FILE *) fp
);
8559 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
8560 SBYTES (specified_data
));
8562 jpeg_read_header (&cinfo
, TRUE
);
8564 /* Customize decompression so that color quantization will be used.
8565 Start decompression. */
8566 cinfo
.quantize_colors
= TRUE
;
8567 jpeg_start_decompress (&cinfo
);
8568 width
= img
->width
= cinfo
.output_width
;
8569 height
= img
->height
= cinfo
.output_height
;
8571 /* Create X image and pixmap. */
8572 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8573 longjmp (mgr
.setjmp_buffer
, 2);
8575 /* Allocate colors. When color quantization is used,
8576 cinfo.actual_number_of_colors has been set with the number of
8577 colors generated, and cinfo.colormap is a two-dimensional array
8578 of color indices in the range 0..cinfo.actual_number_of_colors.
8579 No more than 255 colors will be generated. */
8583 if (cinfo
.out_color_components
> 2)
8584 ir
= 0, ig
= 1, ib
= 2;
8585 else if (cinfo
.out_color_components
> 1)
8586 ir
= 0, ig
= 1, ib
= 0;
8588 ir
= 0, ig
= 0, ib
= 0;
8590 /* Use the color table mechanism because it handles colors that
8591 cannot be allocated nicely. Such colors will be replaced with
8592 a default color, and we don't have to care about which colors
8593 can be freed safely, and which can't. */
8594 init_color_table ();
8595 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
8598 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
8600 /* Multiply RGB values with 255 because X expects RGB values
8601 in the range 0..0xffff. */
8602 int r
= cinfo
.colormap
[ir
][i
] << 8;
8603 int g
= cinfo
.colormap
[ig
][i
] << 8;
8604 int b
= cinfo
.colormap
[ib
][i
] << 8;
8605 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
8608 /* Remember those colors actually allocated. */
8609 img
->colors
= colors_in_color_table (&img
->ncolors
);
8610 free_color_table ();
8614 row_stride
= width
* cinfo
.output_components
;
8615 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
8617 for (y
= 0; y
< height
; ++y
)
8619 jpeg_read_scanlines (&cinfo
, buffer
, 1);
8620 for (x
= 0; x
< cinfo
.output_width
; ++x
)
8621 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
8625 jpeg_finish_decompress (&cinfo
);
8626 jpeg_destroy_decompress (&cinfo
);
8628 fclose ((FILE *) fp
);
8630 /* Maybe fill in the background field while we have ximg handy. */
8631 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8632 IMAGE_BACKGROUND (img
, f
, ximg
);
8634 /* Put the image into the pixmap. */
8635 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8636 x_destroy_x_image (ximg
);
8641 #endif /* HAVE_JPEG */
8645 /***********************************************************************
8647 ***********************************************************************/
8653 static int tiff_image_p
P_ ((Lisp_Object object
));
8654 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
8656 /* The symbol `tiff' identifying images of this type. */
8660 /* Indices of image specification fields in tiff_format, below. */
8662 enum tiff_keyword_index
8671 TIFF_HEURISTIC_MASK
,
8677 /* Vector of image_keyword structures describing the format
8678 of valid user-defined image specifications. */
8680 static struct image_keyword tiff_format
[TIFF_LAST
] =
8682 {":type", IMAGE_SYMBOL_VALUE
, 1},
8683 {":data", IMAGE_STRING_VALUE
, 0},
8684 {":file", IMAGE_STRING_VALUE
, 0},
8685 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8686 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8687 {":relief", IMAGE_INTEGER_VALUE
, 0},
8688 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8689 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8690 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8691 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8694 /* Structure describing the image type `tiff'. */
8696 static struct image_type tiff_type
=
8706 /* Return non-zero if OBJECT is a valid TIFF image specification. */
8709 tiff_image_p (object
)
8712 struct image_keyword fmt
[TIFF_LAST
];
8713 bcopy (tiff_format
, fmt
, sizeof fmt
);
8715 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
8718 /* Must specify either the :data or :file keyword. */
8719 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
8723 /* Reading from a memory buffer for TIFF images Based on the PNG
8724 memory source, but we have to provide a lot of extra functions.
8727 We really only need to implement read and seek, but I am not
8728 convinced that the TIFF library is smart enough not to destroy
8729 itself if we only hand it the function pointers we need to
8734 unsigned char *bytes
;
8742 tiff_read_from_memory (data
, buf
, size
)
8747 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
8749 if (size
> src
->len
- src
->index
)
8751 bcopy (src
->bytes
+ src
->index
, buf
, size
);
8758 tiff_write_from_memory (data
, buf
, size
)
8768 tiff_seek_in_memory (data
, off
, whence
)
8773 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
8778 case SEEK_SET
: /* Go from beginning of source. */
8782 case SEEK_END
: /* Go from end of source. */
8783 idx
= src
->len
+ off
;
8786 case SEEK_CUR
: /* Go from current position. */
8787 idx
= src
->index
+ off
;
8790 default: /* Invalid `whence'. */
8794 if (idx
> src
->len
|| idx
< 0)
8803 tiff_close_memory (data
)
8812 tiff_mmap_memory (data
, pbase
, psize
)
8817 /* It is already _IN_ memory. */
8823 tiff_unmap_memory (data
, base
, size
)
8828 /* We don't need to do this. */
8833 tiff_size_of_memory (data
)
8836 return ((tiff_memory_source
*) data
)->len
;
8841 tiff_error_handler (title
, format
, ap
)
8842 const char *title
, *format
;
8848 len
= sprintf (buf
, "TIFF error: %s ", title
);
8849 vsprintf (buf
+ len
, format
, ap
);
8850 add_to_log (buf
, Qnil
, Qnil
);
8855 tiff_warning_handler (title
, format
, ap
)
8856 const char *title
, *format
;
8862 len
= sprintf (buf
, "TIFF warning: %s ", title
);
8863 vsprintf (buf
+ len
, format
, ap
);
8864 add_to_log (buf
, Qnil
, Qnil
);
8868 /* Load TIFF image IMG for use on frame F. Value is non-zero if
8876 Lisp_Object file
, specified_file
;
8877 Lisp_Object specified_data
;
8879 int width
, height
, x
, y
;
8883 struct gcpro gcpro1
;
8884 tiff_memory_source memsrc
;
8886 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
8887 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8891 TIFFSetErrorHandler (tiff_error_handler
);
8892 TIFFSetWarningHandler (tiff_warning_handler
);
8894 if (NILP (specified_data
))
8896 /* Read from a file */
8897 file
= x_find_image_file (specified_file
);
8898 if (!STRINGP (file
))
8900 image_error ("Cannot find image file `%s'", file
, Qnil
);
8905 /* Try to open the image file. */
8906 tiff
= TIFFOpen (SDATA (file
), "r");
8909 image_error ("Cannot open `%s'", file
, Qnil
);
8916 /* Memory source! */
8917 memsrc
.bytes
= SDATA (specified_data
);
8918 memsrc
.len
= SBYTES (specified_data
);
8921 tiff
= TIFFClientOpen ("memory_source", "r", &memsrc
,
8922 (TIFFReadWriteProc
) tiff_read_from_memory
,
8923 (TIFFReadWriteProc
) tiff_write_from_memory
,
8924 tiff_seek_in_memory
,
8926 tiff_size_of_memory
,
8932 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
8938 /* Get width and height of the image, and allocate a raster buffer
8939 of width x height 32-bit values. */
8940 TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
8941 TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
8942 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
8944 rc
= TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
8948 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
8954 /* Create the X image and pixmap. */
8955 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8962 /* Initialize the color table. */
8963 init_color_table ();
8965 /* Process the pixel raster. Origin is in the lower-left corner. */
8966 for (y
= 0; y
< height
; ++y
)
8968 uint32
*row
= buf
+ y
* width
;
8970 for (x
= 0; x
< width
; ++x
)
8972 uint32 abgr
= row
[x
];
8973 int r
= TIFFGetR (abgr
) << 8;
8974 int g
= TIFFGetG (abgr
) << 8;
8975 int b
= TIFFGetB (abgr
) << 8;
8976 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
8980 /* Remember the colors allocated for the image. Free the color table. */
8981 img
->colors
= colors_in_color_table (&img
->ncolors
);
8982 free_color_table ();
8985 img
->height
= height
;
8987 /* Maybe fill in the background field while we have ximg handy. */
8988 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8989 IMAGE_BACKGROUND (img
, f
, ximg
);
8991 /* Put the image into the pixmap, then free the X image and its buffer. */
8992 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8993 x_destroy_x_image (ximg
);
9000 #endif /* HAVE_TIFF != 0 */
9004 /***********************************************************************
9006 ***********************************************************************/
9010 #include <gif_lib.h>
9012 static int gif_image_p
P_ ((Lisp_Object object
));
9013 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
9015 /* The symbol `gif' identifying images of this type. */
9019 /* Indices of image specification fields in gif_format, below. */
9021 enum gif_keyword_index
9037 /* Vector of image_keyword structures describing the format
9038 of valid user-defined image specifications. */
9040 static struct image_keyword gif_format
[GIF_LAST
] =
9042 {":type", IMAGE_SYMBOL_VALUE
, 1},
9043 {":data", IMAGE_STRING_VALUE
, 0},
9044 {":file", IMAGE_STRING_VALUE
, 0},
9045 {":ascent", IMAGE_ASCENT_VALUE
, 0},
9046 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
9047 {":relief", IMAGE_INTEGER_VALUE
, 0},
9048 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9049 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9050 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9051 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
9052 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
9055 /* Structure describing the image type `gif'. */
9057 static struct image_type gif_type
=
9067 /* Return non-zero if OBJECT is a valid GIF image specification. */
9070 gif_image_p (object
)
9073 struct image_keyword fmt
[GIF_LAST
];
9074 bcopy (gif_format
, fmt
, sizeof fmt
);
9076 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
9079 /* Must specify either the :data or :file keyword. */
9080 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
9084 /* Reading a GIF image from memory
9085 Based on the PNG memory stuff to a certain extent. */
9089 unsigned char *bytes
;
9096 /* Make the current memory source available to gif_read_from_memory.
9097 It's done this way because not all versions of libungif support
9098 a UserData field in the GifFileType structure. */
9099 static gif_memory_source
*current_gif_memory_src
;
9102 gif_read_from_memory (file
, buf
, len
)
9107 gif_memory_source
*src
= current_gif_memory_src
;
9109 if (len
> src
->len
- src
->index
)
9112 bcopy (src
->bytes
+ src
->index
, buf
, len
);
9118 /* Load GIF image IMG for use on frame F. Value is non-zero if
9126 Lisp_Object file
, specified_file
;
9127 Lisp_Object specified_data
;
9128 int rc
, width
, height
, x
, y
, i
;
9130 ColorMapObject
*gif_color_map
;
9131 unsigned long pixel_colors
[256];
9133 struct gcpro gcpro1
;
9135 int ino
, image_left
, image_top
, image_width
, image_height
;
9136 gif_memory_source memsrc
;
9137 unsigned char *raster
;
9139 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
9140 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
9144 if (NILP (specified_data
))
9146 file
= x_find_image_file (specified_file
);
9147 if (!STRINGP (file
))
9149 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
9154 /* Open the GIF file. */
9155 gif
= DGifOpenFileName (SDATA (file
));
9158 image_error ("Cannot open `%s'", file
, Qnil
);
9165 /* Read from memory! */
9166 current_gif_memory_src
= &memsrc
;
9167 memsrc
.bytes
= SDATA (specified_data
);
9168 memsrc
.len
= SBYTES (specified_data
);
9171 gif
= DGifOpen (&memsrc
, gif_read_from_memory
);
9174 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
9180 /* Read entire contents. */
9181 rc
= DGifSlurp (gif
);
9182 if (rc
== GIF_ERROR
)
9184 image_error ("Error reading `%s'", img
->spec
, Qnil
);
9185 DGifCloseFile (gif
);
9190 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
9191 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
9192 if (ino
>= gif
->ImageCount
)
9194 image_error ("Invalid image number `%s' in image `%s'",
9196 DGifCloseFile (gif
);
9201 width
= img
->width
= max (gif
->SWidth
, gif
->Image
.Left
+ gif
->Image
.Width
);
9202 height
= img
->height
= max (gif
->SHeight
, gif
->Image
.Top
+ gif
->Image
.Height
);
9204 /* Create the X image and pixmap. */
9205 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
9207 DGifCloseFile (gif
);
9212 /* Allocate colors. */
9213 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
9215 gif_color_map
= gif
->SColorMap
;
9216 init_color_table ();
9217 bzero (pixel_colors
, sizeof pixel_colors
);
9219 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
9221 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
9222 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
9223 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
9224 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
9227 img
->colors
= colors_in_color_table (&img
->ncolors
);
9228 free_color_table ();
9230 /* Clear the part of the screen image that are not covered by
9231 the image from the GIF file. Full animated GIF support
9232 requires more than can be done here (see the gif89 spec,
9233 disposal methods). Let's simply assume that the part
9234 not covered by a sub-image is in the frame's background color. */
9235 image_top
= gif
->SavedImages
[ino
].ImageDesc
.Top
;
9236 image_left
= gif
->SavedImages
[ino
].ImageDesc
.Left
;
9237 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
9238 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
9240 for (y
= 0; y
< image_top
; ++y
)
9241 for (x
= 0; x
< width
; ++x
)
9242 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
9244 for (y
= image_top
+ image_height
; y
< height
; ++y
)
9245 for (x
= 0; x
< width
; ++x
)
9246 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
9248 for (y
= image_top
; y
< image_top
+ image_height
; ++y
)
9250 for (x
= 0; x
< image_left
; ++x
)
9251 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
9252 for (x
= image_left
+ image_width
; x
< width
; ++x
)
9253 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
9256 /* Read the GIF image into the X image. We use a local variable
9257 `raster' here because RasterBits below is a char *, and invites
9258 problems with bytes >= 0x80. */
9259 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
9261 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
9263 static int interlace_start
[] = {0, 4, 2, 1};
9264 static int interlace_increment
[] = {8, 8, 4, 2};
9266 int row
= interlace_start
[0];
9270 for (y
= 0; y
< image_height
; y
++)
9272 if (row
>= image_height
)
9274 row
= interlace_start
[++pass
];
9275 while (row
>= image_height
)
9276 row
= interlace_start
[++pass
];
9279 for (x
= 0; x
< image_width
; x
++)
9281 int i
= raster
[(y
* image_width
) + x
];
9282 XPutPixel (ximg
, x
+ image_left
, row
+ image_top
,
9286 row
+= interlace_increment
[pass
];
9291 for (y
= 0; y
< image_height
; ++y
)
9292 for (x
= 0; x
< image_width
; ++x
)
9294 int i
= raster
[y
* image_width
+ x
];
9295 XPutPixel (ximg
, x
+ image_left
, y
+ image_top
, pixel_colors
[i
]);
9299 DGifCloseFile (gif
);
9301 /* Maybe fill in the background field while we have ximg handy. */
9302 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
9303 IMAGE_BACKGROUND (img
, f
, ximg
);
9305 /* Put the image into the pixmap, then free the X image and its buffer. */
9306 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
9307 x_destroy_x_image (ximg
);
9313 #endif /* HAVE_GIF != 0 */
9317 /***********************************************************************
9319 ***********************************************************************/
9321 static int gs_image_p
P_ ((Lisp_Object object
));
9322 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
9323 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
9325 /* The symbol `postscript' identifying images of this type. */
9327 Lisp_Object Qpostscript
;
9329 /* Keyword symbols. */
9331 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
9333 /* Indices of image specification fields in gs_format, below. */
9335 enum gs_keyword_index
9353 /* Vector of image_keyword structures describing the format
9354 of valid user-defined image specifications. */
9356 static struct image_keyword gs_format
[GS_LAST
] =
9358 {":type", IMAGE_SYMBOL_VALUE
, 1},
9359 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
9360 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
9361 {":file", IMAGE_STRING_VALUE
, 1},
9362 {":loader", IMAGE_FUNCTION_VALUE
, 0},
9363 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
9364 {":ascent", IMAGE_ASCENT_VALUE
, 0},
9365 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
9366 {":relief", IMAGE_INTEGER_VALUE
, 0},
9367 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9368 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9369 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9370 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
9373 /* Structure describing the image type `ghostscript'. */
9375 static struct image_type gs_type
=
9385 /* Free X resources of Ghostscript image IMG which is used on frame F. */
9388 gs_clear_image (f
, img
)
9392 /* IMG->data.ptr_val may contain a recorded colormap. */
9393 xfree (img
->data
.ptr_val
);
9394 x_clear_image (f
, img
);
9398 /* Return non-zero if OBJECT is a valid Ghostscript image
9405 struct image_keyword fmt
[GS_LAST
];
9409 bcopy (gs_format
, fmt
, sizeof fmt
);
9411 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
9414 /* Bounding box must be a list or vector containing 4 integers. */
9415 tem
= fmt
[GS_BOUNDING_BOX
].value
;
9418 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
9419 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
9424 else if (VECTORP (tem
))
9426 if (XVECTOR (tem
)->size
!= 4)
9428 for (i
= 0; i
< 4; ++i
)
9429 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
9439 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
9448 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
9449 struct gcpro gcpro1
, gcpro2
;
9451 double in_width
, in_height
;
9452 Lisp_Object pixel_colors
= Qnil
;
9454 /* Compute pixel size of pixmap needed from the given size in the
9455 image specification. Sizes in the specification are in pt. 1 pt
9456 = 1/72 in, xdpi and ydpi are stored in the frame's X display
9458 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
9459 in_width
= XFASTINT (pt_width
) / 72.0;
9460 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
9461 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
9462 in_height
= XFASTINT (pt_height
) / 72.0;
9463 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
9465 /* Create the pixmap. */
9466 xassert (img
->pixmap
== None
);
9467 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9468 img
->width
, img
->height
,
9469 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
9473 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
9477 /* Call the loader to fill the pixmap. It returns a process object
9478 if successful. We do not record_unwind_protect here because
9479 other places in redisplay like calling window scroll functions
9480 don't either. Let the Lisp loader use `unwind-protect' instead. */
9481 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
9483 sprintf (buffer
, "%lu %lu",
9484 (unsigned long) FRAME_X_WINDOW (f
),
9485 (unsigned long) img
->pixmap
);
9486 window_and_pixmap_id
= build_string (buffer
);
9488 sprintf (buffer
, "%lu %lu",
9489 FRAME_FOREGROUND_PIXEL (f
),
9490 FRAME_BACKGROUND_PIXEL (f
));
9491 pixel_colors
= build_string (buffer
);
9493 XSETFRAME (frame
, f
);
9494 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
9496 loader
= intern ("gs-load-image");
9498 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
9499 make_number (img
->width
),
9500 make_number (img
->height
),
9501 window_and_pixmap_id
,
9504 return PROCESSP (img
->data
.lisp_val
);
9508 /* Kill the Ghostscript process that was started to fill PIXMAP on
9509 frame F. Called from XTread_socket when receiving an event
9510 telling Emacs that Ghostscript has finished drawing. */
9513 x_kill_gs_process (pixmap
, f
)
9517 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
9521 /* Find the image containing PIXMAP. */
9522 for (i
= 0; i
< c
->used
; ++i
)
9523 if (c
->images
[i
]->pixmap
== pixmap
)
9526 /* Should someone in between have cleared the image cache, for
9527 instance, give up. */
9531 /* Kill the GS process. We should have found PIXMAP in the image
9532 cache and its image should contain a process object. */
9534 xassert (PROCESSP (img
->data
.lisp_val
));
9535 Fkill_process (img
->data
.lisp_val
, Qnil
);
9536 img
->data
.lisp_val
= Qnil
;
9538 /* On displays with a mutable colormap, figure out the colors
9539 allocated for the image by looking at the pixels of an XImage for
9541 class = FRAME_X_VISUAL (f
)->class;
9542 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
9548 /* Try to get an XImage for img->pixmep. */
9549 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
9550 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
9555 /* Initialize the color table. */
9556 init_color_table ();
9558 /* For each pixel of the image, look its color up in the
9559 color table. After having done so, the color table will
9560 contain an entry for each color used by the image. */
9561 for (y
= 0; y
< img
->height
; ++y
)
9562 for (x
= 0; x
< img
->width
; ++x
)
9564 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
9565 lookup_pixel_color (f
, pixel
);
9568 /* Record colors in the image. Free color table and XImage. */
9569 img
->colors
= colors_in_color_table (&img
->ncolors
);
9570 free_color_table ();
9571 XDestroyImage (ximg
);
9573 #if 0 /* This doesn't seem to be the case. If we free the colors
9574 here, we get a BadAccess later in x_clear_image when
9575 freeing the colors. */
9576 /* We have allocated colors once, but Ghostscript has also
9577 allocated colors on behalf of us. So, to get the
9578 reference counts right, free them once. */
9580 x_free_colors (f
, img
->colors
, img
->ncolors
);
9584 image_error ("Cannot get X image of `%s'; colors will not be freed",
9590 /* Now that we have the pixmap, compute mask and transform the
9591 image if requested. */
9593 postprocess_image (f
, img
);
9599 /***********************************************************************
9601 ***********************************************************************/
9603 DEFUN ("x-change-window-property", Fx_change_window_property
,
9604 Sx_change_window_property
, 2, 3, 0,
9605 doc
: /* Change window property PROP to VALUE on the X window of FRAME.
9606 PROP and VALUE must be strings. FRAME nil or omitted means use the
9607 selected frame. Value is VALUE. */)
9608 (prop
, value
, frame
)
9609 Lisp_Object frame
, prop
, value
;
9611 struct frame
*f
= check_x_frame (frame
);
9614 CHECK_STRING (prop
);
9615 CHECK_STRING (value
);
9618 prop_atom
= XInternAtom (FRAME_X_DISPLAY (f
), SDATA (prop
), False
);
9619 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9620 prop_atom
, XA_STRING
, 8, PropModeReplace
,
9621 SDATA (value
), SCHARS (value
));
9623 /* Make sure the property is set when we return. */
9624 XFlush (FRAME_X_DISPLAY (f
));
9631 DEFUN ("x-delete-window-property", Fx_delete_window_property
,
9632 Sx_delete_window_property
, 1, 2, 0,
9633 doc
: /* Remove window property PROP from X window of FRAME.
9634 FRAME nil or omitted means use the selected frame. Value is PROP. */)
9636 Lisp_Object prop
, frame
;
9638 struct frame
*f
= check_x_frame (frame
);
9641 CHECK_STRING (prop
);
9643 prop_atom
= XInternAtom (FRAME_X_DISPLAY (f
), SDATA (prop
), False
);
9644 XDeleteProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), prop_atom
);
9646 /* Make sure the property is removed when we return. */
9647 XFlush (FRAME_X_DISPLAY (f
));
9654 DEFUN ("x-window-property", Fx_window_property
, Sx_window_property
,
9656 doc
: /* Value is the value of window property PROP on FRAME.
9657 If FRAME is nil or omitted, use the selected frame. Value is nil
9658 if FRAME hasn't a property with name PROP or if PROP has no string
9661 Lisp_Object prop
, frame
;
9663 struct frame
*f
= check_x_frame (frame
);
9666 Lisp_Object prop_value
= Qnil
;
9667 char *tmp_data
= NULL
;
9670 unsigned long actual_size
, bytes_remaining
;
9672 CHECK_STRING (prop
);
9674 prop_atom
= XInternAtom (FRAME_X_DISPLAY (f
), SDATA (prop
), False
);
9675 rc
= XGetWindowProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9676 prop_atom
, 0, 0, False
, XA_STRING
,
9677 &actual_type
, &actual_format
, &actual_size
,
9678 &bytes_remaining
, (unsigned char **) &tmp_data
);
9681 int size
= bytes_remaining
;
9686 rc
= XGetWindowProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9687 prop_atom
, 0, bytes_remaining
,
9689 &actual_type
, &actual_format
,
9690 &actual_size
, &bytes_remaining
,
9691 (unsigned char **) &tmp_data
);
9692 if (rc
== Success
&& tmp_data
)
9693 prop_value
= make_string (tmp_data
, size
);
9704 /***********************************************************************
9706 ***********************************************************************/
9708 /* If non-null, an asynchronous timer that, when it expires, displays
9709 an hourglass cursor on all frames. */
9711 static struct atimer
*hourglass_atimer
;
9713 /* Non-zero means an hourglass cursor is currently shown. */
9715 static int hourglass_shown_p
;
9717 /* Number of seconds to wait before displaying an hourglass cursor. */
9719 static Lisp_Object Vhourglass_delay
;
9721 /* Default number of seconds to wait before displaying an hourglass
9724 #define DEFAULT_HOURGLASS_DELAY 1
9726 /* Function prototypes. */
9728 static void show_hourglass
P_ ((struct atimer
*));
9729 static void hide_hourglass
P_ ((void));
9732 /* Cancel a currently active hourglass timer, and start a new one. */
9738 int secs
, usecs
= 0;
9740 cancel_hourglass ();
9742 if (INTEGERP (Vhourglass_delay
)
9743 && XINT (Vhourglass_delay
) > 0)
9744 secs
= XFASTINT (Vhourglass_delay
);
9745 else if (FLOATP (Vhourglass_delay
)
9746 && XFLOAT_DATA (Vhourglass_delay
) > 0)
9749 tem
= Ftruncate (Vhourglass_delay
, Qnil
);
9750 secs
= XFASTINT (tem
);
9751 usecs
= (XFLOAT_DATA (Vhourglass_delay
) - secs
) * 1000000;
9754 secs
= DEFAULT_HOURGLASS_DELAY
;
9756 EMACS_SET_SECS_USECS (delay
, secs
, usecs
);
9757 hourglass_atimer
= start_atimer (ATIMER_RELATIVE
, delay
,
9758 show_hourglass
, NULL
);
9762 /* Cancel the hourglass cursor timer if active, hide a busy cursor if
9768 if (hourglass_atimer
)
9770 cancel_atimer (hourglass_atimer
);
9771 hourglass_atimer
= NULL
;
9774 if (hourglass_shown_p
)
9779 /* Timer function of hourglass_atimer. TIMER is equal to
9782 Display an hourglass pointer on all frames by mapping the frames'
9783 hourglass_window. Set the hourglass_p flag in the frames'
9784 output_data.x structure to indicate that an hourglass cursor is
9785 shown on the frames. */
9788 show_hourglass (timer
)
9789 struct atimer
*timer
;
9791 /* The timer implementation will cancel this timer automatically
9792 after this function has run. Set hourglass_atimer to null
9793 so that we know the timer doesn't have to be canceled. */
9794 hourglass_atimer
= NULL
;
9796 if (!hourglass_shown_p
)
9798 Lisp_Object rest
, frame
;
9802 FOR_EACH_FRAME (rest
, frame
)
9804 struct frame
*f
= XFRAME (frame
);
9806 if (FRAME_LIVE_P (f
) && FRAME_X_P (f
) && FRAME_X_DISPLAY (f
))
9808 Display
*dpy
= FRAME_X_DISPLAY (f
);
9810 #ifdef USE_X_TOOLKIT
9811 if (f
->output_data
.x
->widget
)
9813 if (FRAME_OUTER_WINDOW (f
))
9816 f
->output_data
.x
->hourglass_p
= 1;
9818 if (!f
->output_data
.x
->hourglass_window
)
9820 unsigned long mask
= CWCursor
;
9821 XSetWindowAttributes attrs
;
9823 attrs
.cursor
= f
->output_data
.x
->hourglass_cursor
;
9825 f
->output_data
.x
->hourglass_window
9826 = XCreateWindow (dpy
, FRAME_OUTER_WINDOW (f
),
9827 0, 0, 32000, 32000, 0, 0,
9833 XMapRaised (dpy
, f
->output_data
.x
->hourglass_window
);
9839 hourglass_shown_p
= 1;
9845 /* Hide the hourglass pointer on all frames, if it is currently
9851 if (hourglass_shown_p
)
9853 Lisp_Object rest
, frame
;
9856 FOR_EACH_FRAME (rest
, frame
)
9858 struct frame
*f
= XFRAME (frame
);
9861 /* Watch out for newly created frames. */
9862 && f
->output_data
.x
->hourglass_window
)
9864 XUnmapWindow (FRAME_X_DISPLAY (f
),
9865 f
->output_data
.x
->hourglass_window
);
9866 /* Sync here because XTread_socket looks at the
9867 hourglass_p flag that is reset to zero below. */
9868 XSync (FRAME_X_DISPLAY (f
), False
);
9869 f
->output_data
.x
->hourglass_p
= 0;
9873 hourglass_shown_p
= 0;
9880 /***********************************************************************
9882 ***********************************************************************/
9884 static Lisp_Object x_create_tip_frame
P_ ((struct x_display_info
*,
9885 Lisp_Object
, Lisp_Object
));
9886 static void compute_tip_xy
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
,
9887 Lisp_Object
, int, int, int *, int *));
9889 /* The frame of a currently visible tooltip. */
9891 Lisp_Object tip_frame
;
9893 /* If non-nil, a timer started that hides the last tooltip when it
9896 Lisp_Object tip_timer
;
9899 /* If non-nil, a vector of 3 elements containing the last args
9900 with which x-show-tip was called. See there. */
9902 Lisp_Object last_show_tip_args
;
9904 /* Maximum size for tooltips; a cons (COLUMNS . ROWS). */
9906 Lisp_Object Vx_max_tooltip_size
;
9910 unwind_create_tip_frame (frame
)
9913 Lisp_Object deleted
;
9915 deleted
= unwind_create_frame (frame
);
9916 if (EQ (deleted
, Qt
))
9926 /* Create a frame for a tooltip on the display described by DPYINFO.
9927 PARMS is a list of frame parameters. TEXT is the string to
9928 display in the tip frame. Value is the frame.
9930 Note that functions called here, esp. x_default_parameter can
9931 signal errors, for instance when a specified color name is
9932 undefined. We have to make sure that we're in a consistent state
9933 when this happens. */
9936 x_create_tip_frame (dpyinfo
, parms
, text
)
9937 struct x_display_info
*dpyinfo
;
9938 Lisp_Object parms
, text
;
9941 Lisp_Object frame
, tem
;
9943 long window_prompting
= 0;
9945 int count
= SPECPDL_INDEX ();
9946 struct gcpro gcpro1
, gcpro2
, gcpro3
;
9948 int face_change_count_before
= face_change_count
;
9950 struct buffer
*old_buffer
;
9954 /* Use this general default value to start with until we know if
9955 this frame has a specified name. */
9956 Vx_resource_name
= Vinvocation_name
;
9959 kb
= dpyinfo
->kboard
;
9961 kb
= &the_only_kboard
;
9964 /* Get the name of the frame to use for resource lookup. */
9965 name
= x_get_arg (dpyinfo
, parms
, Qname
, "name", "Name", RES_TYPE_STRING
);
9967 && !EQ (name
, Qunbound
)
9969 error ("Invalid frame name--not a string or nil");
9970 Vx_resource_name
= name
;
9973 GCPRO3 (parms
, name
, frame
);
9975 XSETFRAME (frame
, f
);
9977 buffer
= Fget_buffer_create (build_string (" *tip*"));
9978 Fset_window_buffer (FRAME_ROOT_WINDOW (f
), buffer
, Qnil
);
9979 old_buffer
= current_buffer
;
9980 set_buffer_internal_1 (XBUFFER (buffer
));
9981 current_buffer
->truncate_lines
= Qnil
;
9984 set_buffer_internal_1 (old_buffer
);
9986 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 0;
9987 record_unwind_protect (unwind_create_tip_frame
, frame
);
9989 /* By setting the output method, we're essentially saying that
9990 the frame is live, as per FRAME_LIVE_P. If we get a signal
9991 from this point on, x_destroy_window might screw up reference
9993 f
->output_method
= output_x_window
;
9994 f
->output_data
.x
= (struct x_output
*) xmalloc (sizeof (struct x_output
));
9995 bzero (f
->output_data
.x
, sizeof (struct x_output
));
9996 f
->output_data
.x
->icon_bitmap
= -1;
9997 FRAME_FONTSET (f
) = -1;
9998 f
->output_data
.x
->scroll_bar_foreground_pixel
= -1;
9999 f
->output_data
.x
->scroll_bar_background_pixel
= -1;
10000 #ifdef USE_TOOLKIT_SCROLL_BARS
10001 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= -1;
10002 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= -1;
10003 #endif /* USE_TOOLKIT_SCROLL_BARS */
10004 f
->icon_name
= Qnil
;
10005 FRAME_X_DISPLAY_INFO (f
) = dpyinfo
;
10007 image_cache_refcount
= FRAME_X_IMAGE_CACHE (f
)->refcount
;
10008 dpyinfo_refcount
= dpyinfo
->reference_count
;
10009 #endif /* GLYPH_DEBUG */
10010 #ifdef MULTI_KBOARD
10011 FRAME_KBOARD (f
) = kb
;
10013 f
->output_data
.x
->parent_desc
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
10014 f
->output_data
.x
->explicit_parent
= 0;
10016 /* These colors will be set anyway later, but it's important
10017 to get the color reference counts right, so initialize them! */
10020 struct gcpro gcpro1
;
10022 black
= build_string ("black");
10024 f
->output_data
.x
->foreground_pixel
10025 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
10026 f
->output_data
.x
->background_pixel
10027 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
10028 f
->output_data
.x
->cursor_pixel
10029 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
10030 f
->output_data
.x
->cursor_foreground_pixel
10031 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
10032 f
->output_data
.x
->border_pixel
10033 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
10034 f
->output_data
.x
->mouse_pixel
10035 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
10039 /* Set the name; the functions to which we pass f expect the name to
10041 if (EQ (name
, Qunbound
) || NILP (name
))
10043 f
->name
= build_string (dpyinfo
->x_id_name
);
10044 f
->explicit_name
= 0;
10049 f
->explicit_name
= 1;
10050 /* use the frame's title when getting resources for this frame. */
10051 specbind (Qx_resource_name
, name
);
10054 /* Extract the window parameters from the supplied values that are
10055 needed to determine window geometry. */
10059 font
= x_get_arg (dpyinfo
, parms
, Qfont
, "font", "Font", RES_TYPE_STRING
);
10062 /* First, try whatever font the caller has specified. */
10063 if (STRINGP (font
))
10065 tem
= Fquery_fontset (font
, Qnil
);
10067 font
= x_new_fontset (f
, SDATA (tem
));
10069 font
= x_new_font (f
, SDATA (font
));
10072 /* Try out a font which we hope has bold and italic variations. */
10073 if (!STRINGP (font
))
10074 font
= x_new_font (f
, "-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1");
10075 if (!STRINGP (font
))
10076 font
= x_new_font (f
, "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
10077 if (! STRINGP (font
))
10078 font
= x_new_font (f
, "-*-*-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
10079 if (! STRINGP (font
))
10080 /* This was formerly the first thing tried, but it finds too many fonts
10081 and takes too long. */
10082 font
= x_new_font (f
, "-*-*-medium-r-*-*-*-*-*-*-c-*-iso8859-1");
10083 /* If those didn't work, look for something which will at least work. */
10084 if (! STRINGP (font
))
10085 font
= x_new_font (f
, "-*-fixed-*-*-*-*-*-140-*-*-c-*-iso8859-1");
10087 if (! STRINGP (font
))
10088 font
= build_string ("fixed");
10090 x_default_parameter (f
, parms
, Qfont
, font
,
10091 "font", "Font", RES_TYPE_STRING
);
10094 x_default_parameter (f
, parms
, Qborder_width
, make_number (2),
10095 "borderWidth", "BorderWidth", RES_TYPE_NUMBER
);
10097 /* This defaults to 2 in order to match xterm. We recognize either
10098 internalBorderWidth or internalBorder (which is what xterm calls
10100 if (NILP (Fassq (Qinternal_border_width
, parms
)))
10104 value
= x_get_arg (dpyinfo
, parms
, Qinternal_border_width
,
10105 "internalBorder", "internalBorder", RES_TYPE_NUMBER
);
10106 if (! EQ (value
, Qunbound
))
10107 parms
= Fcons (Fcons (Qinternal_border_width
, value
),
10111 x_default_parameter (f
, parms
, Qinternal_border_width
, make_number (1),
10112 "internalBorderWidth", "internalBorderWidth",
10115 /* Also do the stuff which must be set before the window exists. */
10116 x_default_parameter (f
, parms
, Qforeground_color
, build_string ("black"),
10117 "foreground", "Foreground", RES_TYPE_STRING
);
10118 x_default_parameter (f
, parms
, Qbackground_color
, build_string ("white"),
10119 "background", "Background", RES_TYPE_STRING
);
10120 x_default_parameter (f
, parms
, Qmouse_color
, build_string ("black"),
10121 "pointerColor", "Foreground", RES_TYPE_STRING
);
10122 x_default_parameter (f
, parms
, Qcursor_color
, build_string ("black"),
10123 "cursorColor", "Foreground", RES_TYPE_STRING
);
10124 x_default_parameter (f
, parms
, Qborder_color
, build_string ("black"),
10125 "borderColor", "BorderColor", RES_TYPE_STRING
);
10127 /* Init faces before x_default_parameter is called for scroll-bar
10128 parameters because that function calls x_set_scroll_bar_width,
10129 which calls change_frame_size, which calls Fset_window_buffer,
10130 which runs hooks, which call Fvertical_motion. At the end, we
10131 end up in init_iterator with a null face cache, which should not
10133 init_frame_faces (f
);
10135 f
->output_data
.x
->parent_desc
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
10137 window_prompting
= x_figure_window_size (f
, parms
, 0);
10140 XSetWindowAttributes attrs
;
10141 unsigned long mask
;
10144 mask
= CWBackPixel
| CWOverrideRedirect
| CWEventMask
;
10145 if (DoesSaveUnders (dpyinfo
->screen
))
10146 mask
|= CWSaveUnder
;
10148 /* Window managers look at the override-redirect flag to determine
10149 whether or net to give windows a decoration (Xlib spec, chapter
10151 attrs
.override_redirect
= True
;
10152 attrs
.save_under
= True
;
10153 attrs
.background_pixel
= FRAME_BACKGROUND_PIXEL (f
);
10154 /* Arrange for getting MapNotify and UnmapNotify events. */
10155 attrs
.event_mask
= StructureNotifyMask
;
10157 = FRAME_X_WINDOW (f
)
10158 = XCreateWindow (FRAME_X_DISPLAY (f
),
10159 FRAME_X_DISPLAY_INFO (f
)->root_window
,
10160 /* x, y, width, height */
10164 CopyFromParent
, InputOutput
, CopyFromParent
,
10171 x_default_parameter (f
, parms
, Qauto_raise
, Qnil
,
10172 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
10173 x_default_parameter (f
, parms
, Qauto_lower
, Qnil
,
10174 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
10175 x_default_parameter (f
, parms
, Qcursor_type
, Qbox
,
10176 "cursorType", "CursorType", RES_TYPE_SYMBOL
);
10178 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
10179 Change will not be effected unless different from the current
10180 FRAME_LINES (f). */
10181 width
= FRAME_COLS (f
);
10182 height
= FRAME_LINES (f
);
10183 SET_FRAME_COLS (f
, 0);
10184 FRAME_LINES (f
) = 0;
10185 change_frame_size (f
, height
, width
, 1, 0, 0);
10187 /* Add `tooltip' frame parameter's default value. */
10188 if (NILP (Fframe_parameter (frame
, intern ("tooltip"))))
10189 Fmodify_frame_parameters (frame
, Fcons (Fcons (intern ("tooltip"), Qt
),
10192 /* Set up faces after all frame parameters are known. This call
10193 also merges in face attributes specified for new frames.
10195 Frame parameters may be changed if .Xdefaults contains
10196 specifications for the default font. For example, if there is an
10197 `Emacs.default.attributeBackground: pink', the `background-color'
10198 attribute of the frame get's set, which let's the internal border
10199 of the tooltip frame appear in pink. Prevent this. */
10201 Lisp_Object bg
= Fframe_parameter (frame
, Qbackground_color
);
10203 /* Set tip_frame here, so that */
10205 call1 (Qface_set_after_frame_default
, frame
);
10207 if (!EQ (bg
, Fframe_parameter (frame
, Qbackground_color
)))
10208 Fmodify_frame_parameters (frame
, Fcons (Fcons (Qbackground_color
, bg
),
10216 /* It is now ok to make the frame official even if we get an error
10217 below. And the frame needs to be on Vframe_list or making it
10218 visible won't work. */
10219 Vframe_list
= Fcons (frame
, Vframe_list
);
10221 /* Now that the frame is official, it counts as a reference to
10223 FRAME_X_DISPLAY_INFO (f
)->reference_count
++;
10225 /* Setting attributes of faces of the tooltip frame from resources
10226 and similar will increment face_change_count, which leads to the
10227 clearing of all current matrices. Since this isn't necessary
10228 here, avoid it by resetting face_change_count to the value it
10229 had before we created the tip frame. */
10230 face_change_count
= face_change_count_before
;
10232 /* Discard the unwind_protect. */
10233 return unbind_to (count
, frame
);
10237 /* Compute where to display tip frame F. PARMS is the list of frame
10238 parameters for F. DX and DY are specified offsets from the current
10239 location of the mouse. WIDTH and HEIGHT are the width and height
10240 of the tooltip. Return coordinates relative to the root window of
10241 the display in *ROOT_X, and *ROOT_Y. */
10244 compute_tip_xy (f
, parms
, dx
, dy
, width
, height
, root_x
, root_y
)
10246 Lisp_Object parms
, dx
, dy
;
10248 int *root_x
, *root_y
;
10250 Lisp_Object left
, top
;
10252 Window root
, child
;
10255 /* User-specified position? */
10256 left
= Fcdr (Fassq (Qleft
, parms
));
10257 top
= Fcdr (Fassq (Qtop
, parms
));
10259 /* Move the tooltip window where the mouse pointer is. Resize and
10261 if (!INTEGERP (left
) || !INTEGERP (top
))
10264 XQueryPointer (FRAME_X_DISPLAY (f
), FRAME_X_DISPLAY_INFO (f
)->root_window
,
10265 &root
, &child
, root_x
, root_y
, &win_x
, &win_y
, &pmask
);
10269 if (INTEGERP (top
))
10270 *root_y
= XINT (top
);
10271 else if (*root_y
+ XINT (dy
) - height
< 0)
10272 *root_y
-= XINT (dy
);
10276 *root_y
+= XINT (dy
);
10279 if (INTEGERP (left
))
10280 *root_x
= XINT (left
);
10281 else if (*root_x
+ XINT (dx
) + width
<= FRAME_X_DISPLAY_INFO (f
)->width
)
10282 /* It fits to the right of the pointer. */
10283 *root_x
+= XINT (dx
);
10284 else if (width
+ XINT (dx
) <= *root_x
)
10285 /* It fits to the left of the pointer. */
10286 *root_x
-= width
+ XINT (dx
);
10288 /* Put it left-justified on the screen--it ought to fit that way. */
10293 DEFUN ("x-show-tip", Fx_show_tip
, Sx_show_tip
, 1, 6, 0,
10294 doc
: /* Show STRING in a "tooltip" window on frame FRAME.
10295 A tooltip window is a small X window displaying a string.
10297 FRAME nil or omitted means use the selected frame.
10299 PARMS is an optional list of frame parameters which can be used to
10300 change the tooltip's appearance.
10302 Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
10303 means use the default timeout of 5 seconds.
10305 If the list of frame parameters PARAMS contains a `left' parameters,
10306 the tooltip is displayed at that x-position. Otherwise it is
10307 displayed at the mouse position, with offset DX added (default is 5 if
10308 DX isn't specified). Likewise for the y-position; if a `top' frame
10309 parameter is specified, it determines the y-position of the tooltip
10310 window, otherwise it is displayed at the mouse position, with offset
10311 DY added (default is -10).
10313 A tooltip's maximum size is specified by `x-max-tooltip-size'.
10314 Text larger than the specified size is clipped. */)
10315 (string
, frame
, parms
, timeout
, dx
, dy
)
10316 Lisp_Object string
, frame
, parms
, timeout
, dx
, dy
;
10320 int root_x
, root_y
;
10321 struct buffer
*old_buffer
;
10322 struct text_pos pos
;
10323 int i
, width
, height
;
10324 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
10325 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
10326 int count
= SPECPDL_INDEX ();
10328 specbind (Qinhibit_redisplay
, Qt
);
10330 GCPRO4 (string
, parms
, frame
, timeout
);
10332 CHECK_STRING (string
);
10333 f
= check_x_frame (frame
);
10334 if (NILP (timeout
))
10335 timeout
= make_number (5);
10337 CHECK_NATNUM (timeout
);
10340 dx
= make_number (5);
10345 dy
= make_number (-10);
10349 if (NILP (last_show_tip_args
))
10350 last_show_tip_args
= Fmake_vector (make_number (3), Qnil
);
10352 if (!NILP (tip_frame
))
10354 Lisp_Object last_string
= AREF (last_show_tip_args
, 0);
10355 Lisp_Object last_frame
= AREF (last_show_tip_args
, 1);
10356 Lisp_Object last_parms
= AREF (last_show_tip_args
, 2);
10358 if (EQ (frame
, last_frame
)
10359 && !NILP (Fequal (last_string
, string
))
10360 && !NILP (Fequal (last_parms
, parms
)))
10362 struct frame
*f
= XFRAME (tip_frame
);
10364 /* Only DX and DY have changed. */
10365 if (!NILP (tip_timer
))
10367 Lisp_Object timer
= tip_timer
;
10369 call1 (Qcancel_timer
, timer
);
10373 compute_tip_xy (f
, parms
, dx
, dy
, FRAME_PIXEL_WIDTH (f
),
10374 FRAME_PIXEL_HEIGHT (f
), &root_x
, &root_y
);
10375 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
10382 /* Hide a previous tip, if any. */
10385 ASET (last_show_tip_args
, 0, string
);
10386 ASET (last_show_tip_args
, 1, frame
);
10387 ASET (last_show_tip_args
, 2, parms
);
10389 /* Add default values to frame parameters. */
10390 if (NILP (Fassq (Qname
, parms
)))
10391 parms
= Fcons (Fcons (Qname
, build_string ("tooltip")), parms
);
10392 if (NILP (Fassq (Qinternal_border_width
, parms
)))
10393 parms
= Fcons (Fcons (Qinternal_border_width
, make_number (3)), parms
);
10394 if (NILP (Fassq (Qborder_width
, parms
)))
10395 parms
= Fcons (Fcons (Qborder_width
, make_number (1)), parms
);
10396 if (NILP (Fassq (Qborder_color
, parms
)))
10397 parms
= Fcons (Fcons (Qborder_color
, build_string ("lightyellow")), parms
);
10398 if (NILP (Fassq (Qbackground_color
, parms
)))
10399 parms
= Fcons (Fcons (Qbackground_color
, build_string ("lightyellow")),
10402 /* Create a frame for the tooltip, and record it in the global
10403 variable tip_frame. */
10404 frame
= x_create_tip_frame (FRAME_X_DISPLAY_INFO (f
), parms
, string
);
10405 f
= XFRAME (frame
);
10407 /* Set up the frame's root window. */
10408 w
= XWINDOW (FRAME_ROOT_WINDOW (f
));
10409 w
->left_col
= w
->top_line
= make_number (0);
10411 if (CONSP (Vx_max_tooltip_size
)
10412 && INTEGERP (XCAR (Vx_max_tooltip_size
))
10413 && XINT (XCAR (Vx_max_tooltip_size
)) > 0
10414 && INTEGERP (XCDR (Vx_max_tooltip_size
))
10415 && XINT (XCDR (Vx_max_tooltip_size
)) > 0)
10417 w
->total_cols
= XCAR (Vx_max_tooltip_size
);
10418 w
->total_lines
= XCDR (Vx_max_tooltip_size
);
10422 w
->total_cols
= make_number (80);
10423 w
->total_lines
= make_number (40);
10426 FRAME_TOTAL_COLS (f
) = XINT (w
->total_cols
);
10428 w
->pseudo_window_p
= 1;
10430 /* Display the tooltip text in a temporary buffer. */
10431 old_buffer
= current_buffer
;
10432 set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f
))->buffer
));
10433 current_buffer
->truncate_lines
= Qnil
;
10434 clear_glyph_matrix (w
->desired_matrix
);
10435 clear_glyph_matrix (w
->current_matrix
);
10436 SET_TEXT_POS (pos
, BEGV
, BEGV_BYTE
);
10437 try_window (FRAME_ROOT_WINDOW (f
), pos
);
10439 /* Compute width and height of the tooltip. */
10440 width
= height
= 0;
10441 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
10443 struct glyph_row
*row
= &w
->desired_matrix
->rows
[i
];
10444 struct glyph
*last
;
10447 /* Stop at the first empty row at the end. */
10448 if (!row
->enabled_p
|| !row
->displays_text_p
)
10451 /* Let the row go over the full width of the frame. */
10452 row
->full_width_p
= 1;
10454 /* There's a glyph at the end of rows that is used to place
10455 the cursor there. Don't include the width of this glyph. */
10456 if (row
->used
[TEXT_AREA
])
10458 last
= &row
->glyphs
[TEXT_AREA
][row
->used
[TEXT_AREA
] - 1];
10459 row_width
= row
->pixel_width
- last
->pixel_width
;
10462 row_width
= row
->pixel_width
;
10464 height
+= row
->height
;
10465 width
= max (width
, row_width
);
10468 /* Add the frame's internal border to the width and height the X
10469 window should have. */
10470 height
+= 2 * FRAME_INTERNAL_BORDER_WIDTH (f
);
10471 width
+= 2 * FRAME_INTERNAL_BORDER_WIDTH (f
);
10473 /* Move the tooltip window where the mouse pointer is. Resize and
10475 compute_tip_xy (f
, parms
, dx
, dy
, width
, height
, &root_x
, &root_y
);
10478 XMoveResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
10479 root_x
, root_y
, width
, height
);
10480 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10483 /* Draw into the window. */
10484 w
->must_be_updated_p
= 1;
10485 update_single_window (w
, 1);
10487 /* Restore original current buffer. */
10488 set_buffer_internal_1 (old_buffer
);
10489 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
10492 /* Let the tip disappear after timeout seconds. */
10493 tip_timer
= call3 (intern ("run-at-time"), timeout
, Qnil
,
10494 intern ("x-hide-tip"));
10497 return unbind_to (count
, Qnil
);
10501 DEFUN ("x-hide-tip", Fx_hide_tip
, Sx_hide_tip
, 0, 0, 0,
10502 doc
: /* Hide the current tooltip window, if there is any.
10503 Value is t if tooltip was open, nil otherwise. */)
10507 Lisp_Object deleted
, frame
, timer
;
10508 struct gcpro gcpro1
, gcpro2
;
10510 /* Return quickly if nothing to do. */
10511 if (NILP (tip_timer
) && NILP (tip_frame
))
10516 GCPRO2 (frame
, timer
);
10517 tip_frame
= tip_timer
= deleted
= Qnil
;
10519 count
= SPECPDL_INDEX ();
10520 specbind (Qinhibit_redisplay
, Qt
);
10521 specbind (Qinhibit_quit
, Qt
);
10524 call1 (Qcancel_timer
, timer
);
10526 if (FRAMEP (frame
))
10528 Fdelete_frame (frame
, Qnil
);
10532 /* Bloodcurdling hack alert: The Lucid menu bar widget's
10533 redisplay procedure is not called when a tip frame over menu
10534 items is unmapped. Redisplay the menu manually... */
10536 struct frame
*f
= SELECTED_FRAME ();
10537 Widget w
= f
->output_data
.x
->menubar_widget
;
10538 extern void xlwmenu_redisplay
P_ ((Widget
));
10540 if (!DoesSaveUnders (FRAME_X_DISPLAY_INFO (f
)->screen
)
10544 xlwmenu_redisplay (w
);
10548 #endif /* USE_LUCID */
10552 return unbind_to (count
, deleted
);
10557 /***********************************************************************
10558 File selection dialog
10559 ***********************************************************************/
10563 /* Callback for "OK" and "Cancel" on file selection dialog. */
10566 file_dialog_cb (widget
, client_data
, call_data
)
10568 XtPointer call_data
, client_data
;
10570 int *result
= (int *) client_data
;
10571 XmAnyCallbackStruct
*cb
= (XmAnyCallbackStruct
*) call_data
;
10572 *result
= cb
->reason
;
10576 /* Callback for unmapping a file selection dialog. This is used to
10577 capture the case where a dialog is closed via a window manager's
10578 closer button, for example. Using a XmNdestroyCallback didn't work
10582 file_dialog_unmap_cb (widget
, client_data
, call_data
)
10584 XtPointer call_data
, client_data
;
10586 int *result
= (int *) client_data
;
10587 *result
= XmCR_CANCEL
;
10591 DEFUN ("x-file-dialog", Fx_file_dialog
, Sx_file_dialog
, 2, 4, 0,
10592 doc
: /* Read file name, prompting with PROMPT in directory DIR.
10593 Use a file selection dialog.
10594 Select DEFAULT-FILENAME in the dialog's file selection box, if
10595 specified. Don't let the user enter a file name in the file
10596 selection dialog's entry field, if MUSTMATCH is non-nil. */)
10597 (prompt
, dir
, default_filename
, mustmatch
)
10598 Lisp_Object prompt
, dir
, default_filename
, mustmatch
;
10601 struct frame
*f
= SELECTED_FRAME ();
10602 Lisp_Object file
= Qnil
;
10603 Widget dialog
, text
, list
, help
;
10606 extern XtAppContext Xt_app_con
;
10607 XmString dir_xmstring
, pattern_xmstring
;
10608 int count
= SPECPDL_INDEX ();
10609 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
10611 GCPRO5 (prompt
, dir
, default_filename
, mustmatch
, file
);
10612 CHECK_STRING (prompt
);
10613 CHECK_STRING (dir
);
10615 /* Prevent redisplay. */
10616 specbind (Qinhibit_redisplay
, Qt
);
10620 /* Create the dialog with PROMPT as title, using DIR as initial
10621 directory and using "*" as pattern. */
10622 dir
= Fexpand_file_name (dir
, Qnil
);
10623 dir_xmstring
= XmStringCreateLocalized (SDATA (dir
));
10624 pattern_xmstring
= XmStringCreateLocalized ("*");
10626 XtSetArg (al
[ac
], XmNtitle
, SDATA (prompt
)); ++ac
;
10627 XtSetArg (al
[ac
], XmNdirectory
, dir_xmstring
); ++ac
;
10628 XtSetArg (al
[ac
], XmNpattern
, pattern_xmstring
); ++ac
;
10629 XtSetArg (al
[ac
], XmNresizePolicy
, XmRESIZE_GROW
); ++ac
;
10630 XtSetArg (al
[ac
], XmNdialogStyle
, XmDIALOG_APPLICATION_MODAL
); ++ac
;
10631 dialog
= XmCreateFileSelectionDialog (f
->output_data
.x
->widget
,
10633 XmStringFree (dir_xmstring
);
10634 XmStringFree (pattern_xmstring
);
10636 /* Add callbacks for OK and Cancel. */
10637 XtAddCallback (dialog
, XmNokCallback
, file_dialog_cb
,
10638 (XtPointer
) &result
);
10639 XtAddCallback (dialog
, XmNcancelCallback
, file_dialog_cb
,
10640 (XtPointer
) &result
);
10641 XtAddCallback (dialog
, XmNunmapCallback
, file_dialog_unmap_cb
,
10642 (XtPointer
) &result
);
10644 /* Disable the help button since we can't display help. */
10645 help
= XmFileSelectionBoxGetChild (dialog
, XmDIALOG_HELP_BUTTON
);
10646 XtSetSensitive (help
, False
);
10648 /* Mark OK button as default. */
10649 XtVaSetValues (XmFileSelectionBoxGetChild (dialog
, XmDIALOG_OK_BUTTON
),
10650 XmNshowAsDefault
, True
, NULL
);
10652 /* If MUSTMATCH is non-nil, disable the file entry field of the
10653 dialog, so that the user must select a file from the files list
10654 box. We can't remove it because we wouldn't have a way to get at
10655 the result file name, then. */
10656 text
= XmFileSelectionBoxGetChild (dialog
, XmDIALOG_TEXT
);
10657 if (!NILP (mustmatch
))
10660 label
= XmFileSelectionBoxGetChild (dialog
, XmDIALOG_SELECTION_LABEL
);
10661 XtSetSensitive (text
, False
);
10662 XtSetSensitive (label
, False
);
10665 /* Manage the dialog, so that list boxes get filled. */
10666 XtManageChild (dialog
);
10668 /* Select DEFAULT_FILENAME in the files list box. DEFAULT_FILENAME
10669 must include the path for this to work. */
10670 list
= XmFileSelectionBoxGetChild (dialog
, XmDIALOG_LIST
);
10671 if (STRINGP (default_filename
))
10673 XmString default_xmstring
;
10677 = XmStringCreateLocalized (SDATA (default_filename
));
10679 if (!XmListItemExists (list
, default_xmstring
))
10681 /* Add a new item if DEFAULT_FILENAME is not in the list. */
10682 XmListAddItem (list
, default_xmstring
, 0);
10686 item_pos
= XmListItemPos (list
, default_xmstring
);
10687 XmStringFree (default_xmstring
);
10689 /* Select the item and scroll it into view. */
10690 XmListSelectPos (list
, item_pos
, True
);
10691 XmListSetPos (list
, item_pos
);
10694 /* Process events until the user presses Cancel or OK. */
10696 while (result
== 0)
10699 XtAppNextEvent (Xt_app_con
, &event
);
10700 (void) x_dispatch_event (&event
, FRAME_X_DISPLAY (f
) );
10703 /* Get the result. */
10704 if (result
== XmCR_OK
)
10709 XtVaGetValues (dialog
, XmNtextString
, &text
, NULL
);
10710 XmStringGetLtoR (text
, XmFONTLIST_DEFAULT_TAG
, &data
);
10711 XmStringFree (text
);
10712 file
= build_string (data
);
10719 XtUnmanageChild (dialog
);
10720 XtDestroyWidget (dialog
);
10724 /* Make "Cancel" equivalent to C-g. */
10726 Fsignal (Qquit
, Qnil
);
10728 return unbind_to (count
, file
);
10731 #endif /* USE_MOTIF */
10735 DEFUN ("x-file-dialog", Fx_file_dialog
, Sx_file_dialog
, 2, 4, 0,
10736 "Read file name, prompting with PROMPT in directory DIR.\n\
10737 Use a file selection dialog.\n\
10738 Select DEFAULT-FILENAME in the dialog's file selection box, if\n\
10739 specified. Don't let the user enter a file name in the file\n\
10740 selection dialog's entry field, if MUSTMATCH is non-nil.")
10741 (prompt
, dir
, default_filename
, mustmatch
)
10742 Lisp_Object prompt
, dir
, default_filename
, mustmatch
;
10744 FRAME_PTR f
= SELECTED_FRAME ();
10746 Lisp_Object file
= Qnil
;
10747 int count
= specpdl_ptr
- specpdl
;
10748 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
10752 GCPRO5 (prompt
, dir
, default_filename
, mustmatch
, file
);
10753 CHECK_STRING (prompt
);
10754 CHECK_STRING (dir
);
10756 /* Prevent redisplay. */
10757 specbind (Qinhibit_redisplay
, Qt
);
10761 if (STRINGP (default_filename
))
10762 cdef_file
= SDATA (default_filename
);
10764 cdef_file
= SDATA (dir
);
10766 fn
= xg_get_file_name (f
, SDATA (prompt
), cdef_file
, ! NILP (mustmatch
));
10770 file
= build_string (fn
);
10777 /* Make "Cancel" equivalent to C-g. */
10779 Fsignal (Qquit
, Qnil
);
10781 return unbind_to (count
, file
);
10784 #endif /* USE_GTK */
10787 /***********************************************************************
10789 ***********************************************************************/
10791 #ifdef HAVE_XKBGETKEYBOARD
10792 #include <X11/XKBlib.h>
10793 #include <X11/keysym.h>
10796 DEFUN ("x-backspace-delete-keys-p", Fx_backspace_delete_keys_p
,
10797 Sx_backspace_delete_keys_p
, 0, 1, 0,
10798 doc
: /* Check if both Backspace and Delete keys are on the keyboard of FRAME.
10799 FRAME nil means use the selected frame.
10800 Value is t if we know that both keys are present, and are mapped to the
10801 usual X keysyms. */)
10805 #ifdef HAVE_XKBGETKEYBOARD
10807 struct frame
*f
= check_x_frame (frame
);
10808 Display
*dpy
= FRAME_X_DISPLAY (f
);
10809 Lisp_Object have_keys
;
10810 int major
, minor
, op
, event
, error
;
10814 /* Check library version in case we're dynamically linked. */
10815 major
= XkbMajorVersion
;
10816 minor
= XkbMinorVersion
;
10817 if (!XkbLibraryVersion (&major
, &minor
))
10823 /* Check that the server supports XKB. */
10824 major
= XkbMajorVersion
;
10825 minor
= XkbMinorVersion
;
10826 if (!XkbQueryExtension (dpy
, &op
, &event
, &error
, &major
, &minor
))
10833 kb
= XkbGetMap (dpy
, XkbAllMapComponentsMask
, XkbUseCoreKbd
);
10836 int delete_keycode
= 0, backspace_keycode
= 0, i
;
10838 if (XkbGetNames (dpy
, XkbAllNamesMask
, kb
) == Success
)
10840 for (i
= kb
->min_key_code
;
10841 (i
< kb
->max_key_code
10842 && (delete_keycode
== 0 || backspace_keycode
== 0));
10845 /* The XKB symbolic key names can be seen most easily in
10846 the PS file generated by `xkbprint -label name
10848 if (bcmp ("DELE", kb
->names
->keys
[i
].name
, 4) == 0)
10849 delete_keycode
= i
;
10850 else if (bcmp ("BKSP", kb
->names
->keys
[i
].name
, 4) == 0)
10851 backspace_keycode
= i
;
10854 XkbFreeNames (kb
, 0, True
);
10857 XkbFreeClientMap (kb
, 0, True
);
10860 && backspace_keycode
10861 && XKeysymToKeycode (dpy
, XK_Delete
) == delete_keycode
10862 && XKeysymToKeycode (dpy
, XK_BackSpace
) == backspace_keycode
)
10867 #else /* not HAVE_XKBGETKEYBOARD */
10869 #endif /* not HAVE_XKBGETKEYBOARD */
10874 /***********************************************************************
10876 ***********************************************************************/
10878 /* Keep this list in the same order as frame_parms in frame.c.
10879 Use 0 for unsupported frame parameters. */
10881 frame_parm_handler x_frame_parm_handlers
[] =
10885 x_set_background_color
,
10886 x_set_border_color
,
10887 x_set_border_width
,
10888 x_set_cursor_color
,
10891 x_set_foreground_color
,
10894 x_set_internal_border_width
,
10895 x_set_menu_bar_lines
,
10897 x_explicitly_set_name
,
10898 x_set_scroll_bar_width
,
10900 x_set_unsplittable
,
10901 x_set_vertical_scroll_bars
,
10903 x_set_tool_bar_lines
,
10904 x_set_scroll_bar_foreground
,
10905 x_set_scroll_bar_background
,
10906 x_set_screen_gamma
,
10907 x_set_line_spacing
,
10908 x_set_fringe_width
,
10909 x_set_fringe_width
,
10917 /* This is zero if not using X windows. */
10920 /* The section below is built by the lisp expression at the top of the file,
10921 just above where these variables are declared. */
10922 /*&&& init symbols here &&&*/
10923 Qnone
= intern ("none");
10924 staticpro (&Qnone
);
10925 Qsuppress_icon
= intern ("suppress-icon");
10926 staticpro (&Qsuppress_icon
);
10927 Qundefined_color
= intern ("undefined-color");
10928 staticpro (&Qundefined_color
);
10929 Qcenter
= intern ("center");
10930 staticpro (&Qcenter
);
10931 Qcompound_text
= intern ("compound-text");
10932 staticpro (&Qcompound_text
);
10933 Qcancel_timer
= intern ("cancel-timer");
10934 staticpro (&Qcancel_timer
);
10935 /* This is the end of symbol initialization. */
10937 /* Text property `display' should be nonsticky by default. */
10938 Vtext_property_default_nonsticky
10939 = Fcons (Fcons (Qdisplay
, Qt
), Vtext_property_default_nonsticky
);
10942 Qlaplace
= intern ("laplace");
10943 staticpro (&Qlaplace
);
10944 Qemboss
= intern ("emboss");
10945 staticpro (&Qemboss
);
10946 Qedge_detection
= intern ("edge-detection");
10947 staticpro (&Qedge_detection
);
10948 Qheuristic
= intern ("heuristic");
10949 staticpro (&Qheuristic
);
10950 QCmatrix
= intern (":matrix");
10951 staticpro (&QCmatrix
);
10952 QCcolor_adjustment
= intern (":color-adjustment");
10953 staticpro (&QCcolor_adjustment
);
10954 QCmask
= intern (":mask");
10955 staticpro (&QCmask
);
10957 Fput (Qundefined_color
, Qerror_conditions
,
10958 Fcons (Qundefined_color
, Fcons (Qerror
, Qnil
)));
10959 Fput (Qundefined_color
, Qerror_message
,
10960 build_string ("Undefined color"));
10962 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
10963 doc
: /* Non-nil means always draw a cross over disabled images.
10964 Disabled images are those having an `:conversion disabled' property.
10965 A cross is always drawn on black & white displays. */);
10966 cross_disabled_images
= 0;
10968 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
10969 doc
: /* List of directories to search for window system bitmap files. */);
10970 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
10972 DEFVAR_LISP ("x-pointer-shape", &Vx_pointer_shape
,
10973 doc
: /* The shape of the pointer when over text.
10974 Changing the value does not affect existing frames
10975 unless you set the mouse color. */);
10976 Vx_pointer_shape
= Qnil
;
10978 #if 0 /* This doesn't really do anything. */
10979 DEFVAR_LISP ("x-nontext-pointer-shape", &Vx_nontext_pointer_shape
,
10980 doc
: /* The shape of the pointer when not over text.
10981 This variable takes effect when you create a new frame
10982 or when you set the mouse color. */);
10984 Vx_nontext_pointer_shape
= Qnil
;
10986 DEFVAR_LISP ("x-hourglass-pointer-shape", &Vx_hourglass_pointer_shape
,
10987 doc
: /* The shape of the pointer when Emacs is busy.
10988 This variable takes effect when you create a new frame
10989 or when you set the mouse color. */);
10990 Vx_hourglass_pointer_shape
= Qnil
;
10992 DEFVAR_BOOL ("display-hourglass", &display_hourglass_p
,
10993 doc
: /* Non-zero means Emacs displays an hourglass pointer on window systems. */);
10994 display_hourglass_p
= 1;
10996 DEFVAR_LISP ("hourglass-delay", &Vhourglass_delay
,
10997 doc
: /* *Seconds to wait before displaying an hourglass pointer.
10998 Value must be an integer or float. */);
10999 Vhourglass_delay
= make_number (DEFAULT_HOURGLASS_DELAY
);
11001 #if 0 /* This doesn't really do anything. */
11002 DEFVAR_LISP ("x-mode-pointer-shape", &Vx_mode_pointer_shape
,
11003 doc
: /* The shape of the pointer when over the mode line.
11004 This variable takes effect when you create a new frame
11005 or when you set the mouse color. */);
11007 Vx_mode_pointer_shape
= Qnil
;
11009 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
11010 &Vx_sensitive_text_pointer_shape
,
11011 doc
: /* The shape of the pointer when over mouse-sensitive text.
11012 This variable takes effect when you create a new frame
11013 or when you set the mouse color. */);
11014 Vx_sensitive_text_pointer_shape
= Qnil
;
11016 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
11017 &Vx_window_horizontal_drag_shape
,
11018 doc
: /* Pointer shape to use for indicating a window can be dragged horizontally.
11019 This variable takes effect when you create a new frame
11020 or when you set the mouse color. */);
11021 Vx_window_horizontal_drag_shape
= Qnil
;
11023 DEFVAR_LISP ("x-cursor-fore-pixel", &Vx_cursor_fore_pixel
,
11024 doc
: /* A string indicating the foreground color of the cursor box. */);
11025 Vx_cursor_fore_pixel
= Qnil
;
11027 DEFVAR_LISP ("x-max-tooltip-size", &Vx_max_tooltip_size
,
11028 doc
: /* Maximum size for tooltips. Value is a pair (COLUMNS . ROWS).
11029 Text larger than this is clipped. */);
11030 Vx_max_tooltip_size
= Fcons (make_number (80), make_number (40));
11032 DEFVAR_LISP ("x-no-window-manager", &Vx_no_window_manager
,
11033 doc
: /* Non-nil if no X window manager is in use.
11034 Emacs doesn't try to figure this out; this is always nil
11035 unless you set it to something else. */);
11036 /* We don't have any way to find this out, so set it to nil
11037 and maybe the user would like to set it to t. */
11038 Vx_no_window_manager
= Qnil
;
11040 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
11041 &Vx_pixel_size_width_font_regexp
,
11042 doc
: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
11044 Since Emacs gets width of a font matching with this regexp from
11045 PIXEL_SIZE field of the name, font finding mechanism gets faster for
11046 such a font. This is especially effective for such large fonts as
11047 Chinese, Japanese, and Korean. */);
11048 Vx_pixel_size_width_font_regexp
= Qnil
;
11050 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
11051 doc
: /* Time after which cached images are removed from the cache.
11052 When an image has not been displayed this many seconds, remove it
11053 from the image cache. Value must be an integer or nil with nil
11054 meaning don't clear the cache. */);
11055 Vimage_cache_eviction_delay
= make_number (30 * 60);
11057 #ifdef USE_X_TOOLKIT
11058 Fprovide (intern ("x-toolkit"), Qnil
);
11060 Fprovide (intern ("motif"), Qnil
);
11062 DEFVAR_LISP ("motif-version-string", &Vmotif_version_string
,
11063 doc
: /* Version info for LessTif/Motif. */);
11064 Vmotif_version_string
= build_string (XmVERSION_STRING
);
11065 #endif /* USE_MOTIF */
11066 #endif /* USE_X_TOOLKIT */
11069 Fprovide (intern ("gtk"), Qnil
);
11071 DEFVAR_LISP ("gtk-version-string", &Vgtk_version_string
,
11072 doc
: /* Version info for GTK+. */);
11074 char gtk_version
[40];
11075 g_snprintf (gtk_version
, sizeof (gtk_version
), "%u.%u.%u",
11076 GTK_MAJOR_VERSION
, GTK_MINOR_VERSION
, GTK_MICRO_VERSION
);
11077 Vgtk_version_string
= build_string (gtk_version
);
11079 #endif /* USE_GTK */
11081 /* X window properties. */
11082 defsubr (&Sx_change_window_property
);
11083 defsubr (&Sx_delete_window_property
);
11084 defsubr (&Sx_window_property
);
11086 defsubr (&Sxw_display_color_p
);
11087 defsubr (&Sx_display_grayscale_p
);
11088 defsubr (&Sxw_color_defined_p
);
11089 defsubr (&Sxw_color_values
);
11090 defsubr (&Sx_server_max_request_size
);
11091 defsubr (&Sx_server_vendor
);
11092 defsubr (&Sx_server_version
);
11093 defsubr (&Sx_display_pixel_width
);
11094 defsubr (&Sx_display_pixel_height
);
11095 defsubr (&Sx_display_mm_width
);
11096 defsubr (&Sx_display_mm_height
);
11097 defsubr (&Sx_display_screens
);
11098 defsubr (&Sx_display_planes
);
11099 defsubr (&Sx_display_color_cells
);
11100 defsubr (&Sx_display_visual_class
);
11101 defsubr (&Sx_display_backing_store
);
11102 defsubr (&Sx_display_save_under
);
11103 defsubr (&Sx_create_frame
);
11104 defsubr (&Sx_open_connection
);
11105 defsubr (&Sx_close_connection
);
11106 defsubr (&Sx_display_list
);
11107 defsubr (&Sx_synchronize
);
11108 defsubr (&Sx_send_client_message
);
11109 defsubr (&Sx_focus_frame
);
11110 defsubr (&Sx_backspace_delete_keys_p
);
11112 /* Setting callback functions for fontset handler. */
11113 get_font_info_func
= x_get_font_info
;
11115 #if 0 /* This function pointer doesn't seem to be used anywhere.
11116 And the pointer assigned has the wrong type, anyway. */
11117 list_fonts_func
= x_list_fonts
;
11120 load_font_func
= x_load_font
;
11121 find_ccl_program_func
= x_find_ccl_program
;
11122 query_font_func
= x_query_font
;
11123 set_frame_fontset_func
= x_set_font
;
11124 check_window_system_func
= check_x
;
11127 Qxbm
= intern ("xbm");
11129 QCconversion
= intern (":conversion");
11130 staticpro (&QCconversion
);
11131 QCheuristic_mask
= intern (":heuristic-mask");
11132 staticpro (&QCheuristic_mask
);
11133 QCcolor_symbols
= intern (":color-symbols");
11134 staticpro (&QCcolor_symbols
);
11135 QCascent
= intern (":ascent");
11136 staticpro (&QCascent
);
11137 QCmargin
= intern (":margin");
11138 staticpro (&QCmargin
);
11139 QCrelief
= intern (":relief");
11140 staticpro (&QCrelief
);
11141 Qpostscript
= intern ("postscript");
11142 staticpro (&Qpostscript
);
11143 QCloader
= intern (":loader");
11144 staticpro (&QCloader
);
11145 QCbounding_box
= intern (":bounding-box");
11146 staticpro (&QCbounding_box
);
11147 QCpt_width
= intern (":pt-width");
11148 staticpro (&QCpt_width
);
11149 QCpt_height
= intern (":pt-height");
11150 staticpro (&QCpt_height
);
11151 QCindex
= intern (":index");
11152 staticpro (&QCindex
);
11153 Qpbm
= intern ("pbm");
11157 Qxpm
= intern ("xpm");
11162 Qjpeg
= intern ("jpeg");
11163 staticpro (&Qjpeg
);
11167 Qtiff
= intern ("tiff");
11168 staticpro (&Qtiff
);
11172 Qgif
= intern ("gif");
11177 Qpng
= intern ("png");
11181 defsubr (&Sclear_image_cache
);
11182 defsubr (&Simage_size
);
11183 defsubr (&Simage_mask_p
);
11185 hourglass_atimer
= NULL
;
11186 hourglass_shown_p
= 0;
11188 defsubr (&Sx_show_tip
);
11189 defsubr (&Sx_hide_tip
);
11191 staticpro (&tip_timer
);
11193 staticpro (&tip_frame
);
11195 last_show_tip_args
= Qnil
;
11196 staticpro (&last_show_tip_args
);
11199 defsubr (&Sx_file_dialog
);
11207 image_types
= NULL
;
11208 Vimage_types
= Qnil
;
11210 define_image_type (&xbm_type
);
11211 define_image_type (&gs_type
);
11212 define_image_type (&pbm_type
);
11215 define_image_type (&xpm_type
);
11219 define_image_type (&jpeg_type
);
11223 define_image_type (&tiff_type
);
11227 define_image_type (&gif_type
);
11231 define_image_type (&png_type
);
11235 #endif /* HAVE_X_WINDOWS */
11237 /* arch-tag: 55040d02-5485-4d58-8b22-95a7a05f3288
11238 (do not change this comment) */