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"
55 #include <sys/types.h>
59 #if 1 /* Used to be #ifdef EMACS_BITMAP_FILES, but this should always work. */
60 #include "bitmaps/gray.xbm"
62 #include <X11/bitmaps/gray>
65 #include "[.bitmaps]gray.xbm"
73 #include <X11/Shell.h>
76 #include <X11/Xaw/Paned.h>
77 #include <X11/Xaw/Label.h>
78 #endif /* USE_MOTIF */
81 #undef USG /* ####KLUDGE for Solaris 2.2 and up */
90 #include "../lwlib/lwlib.h"
94 #include <Xm/DialogS.h>
95 #include <Xm/FileSB.h>
98 /* Do the EDITRES protocol if running X11R5
99 Exception: HP-UX (at least version A.09.05) has X11R5 without EditRes */
101 #if (XtSpecificationRelease >= 5) && !defined(NO_EDITRES)
103 extern void _XEditResCheckMessages ();
104 #endif /* R5 + Athena */
106 /* Unique id counter for widgets created by the Lucid Widget Library. */
108 extern LWLIB_ID widget_id_tick
;
111 /* This is part of a kludge--see lwlib/xlwmenu.c. */
112 extern XFontStruct
*xlwmenu_default_font
;
115 extern void free_frame_menubar ();
116 extern double atof ();
120 /* LessTif/Motif version info. */
122 static Lisp_Object Vmotif_version_string
;
124 #endif /* USE_MOTIF */
126 #endif /* USE_X_TOOLKIT */
130 /* GTK+ version info */
132 static Lisp_Object Vgtk_version_string
;
137 #define MAXREQUEST(dpy) (XMaxRequestSize (dpy))
139 #define MAXREQUEST(dpy) ((dpy)->max_request_size)
142 /* The gray bitmap `bitmaps/gray'. This is done because xterm.c uses
143 it, and including `bitmaps/gray' more than once is a problem when
144 config.h defines `static' as an empty replacement string. */
146 int gray_bitmap_width
= gray_width
;
147 int gray_bitmap_height
= gray_height
;
148 char *gray_bitmap_bits
= gray_bits
;
150 /* Non-zero means we're allowed to display an hourglass cursor. */
152 int display_hourglass_p
;
154 /* The background and shape of the mouse pointer, and shape when not
155 over text or in the modeline. */
157 Lisp_Object Vx_pointer_shape
, Vx_nontext_pointer_shape
, Vx_mode_pointer_shape
;
158 Lisp_Object Vx_hourglass_pointer_shape
;
160 /* The shape when over mouse-sensitive text. */
162 Lisp_Object Vx_sensitive_text_pointer_shape
;
164 /* If non-nil, the pointer shape to indicate that windows can be
165 dragged horizontally. */
167 Lisp_Object Vx_window_horizontal_drag_shape
;
169 /* Color of chars displayed in cursor box. */
171 Lisp_Object Vx_cursor_fore_pixel
;
173 /* Nonzero if using X. */
177 /* Non nil if no window manager is in use. */
179 Lisp_Object Vx_no_window_manager
;
181 /* Search path for bitmap files. */
183 Lisp_Object Vx_bitmap_file_path
;
185 /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'. */
187 Lisp_Object Vx_pixel_size_width_font_regexp
;
190 Lisp_Object Qsuppress_icon
;
191 Lisp_Object Qundefined_color
;
193 Lisp_Object Qcompound_text
, Qcancel_timer
;
197 extern Lisp_Object Vwindow_system_version
;
199 /* The below are defined in frame.c. */
202 int image_cache_refcount
, dpyinfo_refcount
;
207 /* Error if we are not connected to X. */
213 error ("X windows are not in use or not initialized");
216 /* Nonzero if we can use mouse menus.
217 You should not call this unless HAVE_MENUS is defined. */
225 /* Extract a frame as a FRAME_PTR, defaulting to the selected frame
226 and checking validity for X. */
229 check_x_frame (frame
)
235 frame
= selected_frame
;
236 CHECK_LIVE_FRAME (frame
);
239 error ("Non-X frame used");
243 /* Let the user specify an X display with a frame.
244 nil stands for the selected frame--or, if that is not an X frame,
245 the first X display on the list. */
247 struct x_display_info
*
248 check_x_display_info (frame
)
251 struct x_display_info
*dpyinfo
= NULL
;
255 struct frame
*sf
= XFRAME (selected_frame
);
257 if (FRAME_X_P (sf
) && FRAME_LIVE_P (sf
))
258 dpyinfo
= FRAME_X_DISPLAY_INFO (sf
);
259 else if (x_display_list
!= 0)
260 dpyinfo
= x_display_list
;
262 error ("X windows are not in use or not initialized");
264 else if (STRINGP (frame
))
265 dpyinfo
= x_display_info_for_name (frame
);
268 FRAME_PTR f
= check_x_frame (frame
);
269 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
276 /* Return the Emacs frame-object corresponding to an X window.
277 It could be the frame's main window or an icon window. */
279 /* This function can be called during GC, so use GC_xxx type test macros. */
282 x_window_to_frame (dpyinfo
, wdesc
)
283 struct x_display_info
*dpyinfo
;
286 Lisp_Object tail
, frame
;
289 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
292 if (!GC_FRAMEP (frame
))
295 if (!FRAME_X_P (f
) || FRAME_X_DISPLAY_INFO (f
) != dpyinfo
)
297 if (f
->output_data
.x
->hourglass_window
== wdesc
)
300 if ((f
->output_data
.x
->edit_widget
301 && XtWindow (f
->output_data
.x
->edit_widget
) == wdesc
)
302 /* A tooltip frame? */
303 || (!f
->output_data
.x
->edit_widget
304 && FRAME_X_WINDOW (f
) == wdesc
)
305 || f
->output_data
.x
->icon_desc
== wdesc
)
307 #else /* not USE_X_TOOLKIT */
309 if (f
->output_data
.x
->edit_widget
)
311 GtkWidget
*gwdesc
= xg_win_to_widget (wdesc
);
312 struct x_output
*x
= f
->output_data
.x
;
313 if (gwdesc
!= 0 && gwdesc
== x
->edit_widget
)
317 if (FRAME_X_WINDOW (f
) == wdesc
318 || f
->output_data
.x
->icon_desc
== wdesc
)
320 #endif /* not USE_X_TOOLKIT */
325 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
326 /* Like x_window_to_frame but also compares the window with the widget's
330 x_any_window_to_frame (dpyinfo
, wdesc
)
331 struct x_display_info
*dpyinfo
;
334 Lisp_Object tail
, frame
;
335 struct frame
*f
, *found
;
339 for (tail
= Vframe_list
; GC_CONSP (tail
) && !found
; tail
= XCDR (tail
))
342 if (!GC_FRAMEP (frame
))
346 if (FRAME_X_P (f
) && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
348 /* This frame matches if the window is any of its widgets. */
349 x
= f
->output_data
.x
;
350 if (x
->hourglass_window
== wdesc
)
355 GtkWidget
*gwdesc
= xg_win_to_widget (wdesc
);
357 && (gwdesc
== x
->widget
358 || gwdesc
== x
->edit_widget
359 || gwdesc
== x
->vbox_widget
360 || gwdesc
== x
->menubar_widget
))
363 if (wdesc
== XtWindow (x
->widget
)
364 || wdesc
== XtWindow (x
->column_widget
)
365 || wdesc
== XtWindow (x
->edit_widget
))
367 /* Match if the window is this frame's menubar. */
368 else if (lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
372 else if (FRAME_X_WINDOW (f
) == wdesc
)
373 /* A tooltip frame. */
381 /* Likewise, but exclude the menu bar widget. */
384 x_non_menubar_window_to_frame (dpyinfo
, wdesc
)
385 struct x_display_info
*dpyinfo
;
388 Lisp_Object tail
, frame
;
392 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
395 if (!GC_FRAMEP (frame
))
398 if (!FRAME_X_P (f
) || FRAME_X_DISPLAY_INFO (f
) != dpyinfo
)
400 x
= f
->output_data
.x
;
401 /* This frame matches if the window is any of its widgets. */
402 if (x
->hourglass_window
== wdesc
)
407 GtkWidget
*gwdesc
= xg_win_to_widget (wdesc
);
409 && (gwdesc
== x
->widget
410 || gwdesc
== x
->edit_widget
411 || gwdesc
== x
->vbox_widget
))
414 if (wdesc
== XtWindow (x
->widget
)
415 || wdesc
== XtWindow (x
->column_widget
)
416 || wdesc
== XtWindow (x
->edit_widget
))
420 else if (FRAME_X_WINDOW (f
) == wdesc
)
421 /* A tooltip frame. */
427 /* Likewise, but consider only the menu bar widget. */
430 x_menubar_window_to_frame (dpyinfo
, wdesc
)
431 struct x_display_info
*dpyinfo
;
434 Lisp_Object tail
, frame
;
438 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
441 if (!GC_FRAMEP (frame
))
444 if (!FRAME_X_P (f
) || FRAME_X_DISPLAY_INFO (f
) != dpyinfo
)
446 x
= f
->output_data
.x
;
447 /* Match if the window is this frame's menubar. */
449 if (x
->menubar_widget
)
451 GtkWidget
*gwdesc
= xg_win_to_widget (wdesc
);
456 && (gwdesc
== x
->menubar_widget
457 || gtk_widget_get_parent (gwdesc
) == x
->menubar_widget
))
463 if (x
->menubar_widget
464 && lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
471 /* Return the frame whose principal (outermost) window is WDESC.
472 If WDESC is some other (smaller) window, we return 0. */
475 x_top_window_to_frame (dpyinfo
, wdesc
)
476 struct x_display_info
*dpyinfo
;
479 Lisp_Object tail
, frame
;
483 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
486 if (!GC_FRAMEP (frame
))
489 if (!FRAME_X_P (f
) || FRAME_X_DISPLAY_INFO (f
) != dpyinfo
)
491 x
= f
->output_data
.x
;
495 /* This frame matches if the window is its topmost widget. */
497 GtkWidget
*gwdesc
= xg_win_to_widget (wdesc
);
498 if (gwdesc
== x
->widget
)
501 if (wdesc
== XtWindow (x
->widget
))
503 #if 0 /* I don't know why it did this,
504 but it seems logically wrong,
505 and it causes trouble for MapNotify events. */
506 /* Match if the window is this frame's menubar. */
507 if (x
->menubar_widget
508 && wdesc
== XtWindow (x
->menubar_widget
))
513 else if (FRAME_X_WINDOW (f
) == wdesc
)
519 #endif /* USE_X_TOOLKIT || USE_GTK */
523 /* Code to deal with bitmaps. Bitmaps are referenced by their bitmap
524 id, which is just an int that this section returns. Bitmaps are
525 reference counted so they can be shared among frames.
527 Bitmap indices are guaranteed to be > 0, so a negative number can
528 be used to indicate no bitmap.
530 If you use x_create_bitmap_from_data, then you must keep track of
531 the bitmaps yourself. That is, creating a bitmap from the same
532 data more than once will not be caught. */
535 /* Functions to access the contents of a bitmap, given an id. */
538 x_bitmap_height (f
, id
)
542 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].height
;
546 x_bitmap_width (f
, id
)
550 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].width
;
554 x_bitmap_pixmap (f
, id
)
558 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].pixmap
;
562 x_bitmap_mask (f
, id
)
566 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].mask
;
570 /* Allocate a new bitmap record. Returns index of new record. */
573 x_allocate_bitmap_record (f
)
576 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
579 if (dpyinfo
->bitmaps
== NULL
)
581 dpyinfo
->bitmaps_size
= 10;
583 = (struct x_bitmap_record
*) xmalloc (dpyinfo
->bitmaps_size
* sizeof (struct x_bitmap_record
));
584 dpyinfo
->bitmaps_last
= 1;
588 if (dpyinfo
->bitmaps_last
< dpyinfo
->bitmaps_size
)
589 return ++dpyinfo
->bitmaps_last
;
591 for (i
= 0; i
< dpyinfo
->bitmaps_size
; ++i
)
592 if (dpyinfo
->bitmaps
[i
].refcount
== 0)
595 dpyinfo
->bitmaps_size
*= 2;
597 = (struct x_bitmap_record
*) xrealloc (dpyinfo
->bitmaps
,
598 dpyinfo
->bitmaps_size
* sizeof (struct x_bitmap_record
));
599 return ++dpyinfo
->bitmaps_last
;
602 /* Add one reference to the reference count of the bitmap with id ID. */
605 x_reference_bitmap (f
, id
)
609 ++FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].refcount
;
612 /* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS. */
615 x_create_bitmap_from_data (f
, bits
, width
, height
)
618 unsigned int width
, height
;
620 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
624 bitmap
= XCreateBitmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
625 bits
, width
, height
);
632 id
= x_allocate_bitmap_record (f
);
633 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
634 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
635 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
636 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
637 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
638 dpyinfo
->bitmaps
[id
- 1].height
= height
;
639 dpyinfo
->bitmaps
[id
- 1].width
= width
;
644 /* Create bitmap from file FILE for frame F. */
647 x_create_bitmap_from_file (f
, file
)
651 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
652 unsigned int width
, height
;
654 int xhot
, yhot
, result
, id
;
659 /* Look for an existing bitmap with the same name. */
660 for (id
= 0; id
< dpyinfo
->bitmaps_last
; ++id
)
662 if (dpyinfo
->bitmaps
[id
].refcount
663 && dpyinfo
->bitmaps
[id
].file
664 && !strcmp (dpyinfo
->bitmaps
[id
].file
, (char *) SDATA (file
)))
666 ++dpyinfo
->bitmaps
[id
].refcount
;
671 /* Search bitmap-file-path for the file, if appropriate. */
672 fd
= openp (Vx_bitmap_file_path
, file
, Qnil
, &found
, Qnil
);
677 filename
= (char *) SDATA (found
);
679 result
= XReadBitmapFile (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
680 filename
, &width
, &height
, &bitmap
, &xhot
, &yhot
);
681 if (result
!= BitmapSuccess
)
684 id
= x_allocate_bitmap_record (f
);
685 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
686 dpyinfo
->bitmaps
[id
- 1].have_mask
= 0;
687 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
688 dpyinfo
->bitmaps
[id
- 1].file
689 = (char *) xmalloc (SBYTES (file
) + 1);
690 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
691 dpyinfo
->bitmaps
[id
- 1].height
= height
;
692 dpyinfo
->bitmaps
[id
- 1].width
= width
;
693 strcpy (dpyinfo
->bitmaps
[id
- 1].file
, SDATA (file
));
698 /* Remove reference to bitmap with id number ID. */
701 x_destroy_bitmap (f
, id
)
705 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
709 --dpyinfo
->bitmaps
[id
- 1].refcount
;
710 if (dpyinfo
->bitmaps
[id
- 1].refcount
== 0)
713 XFreePixmap (FRAME_X_DISPLAY (f
), dpyinfo
->bitmaps
[id
- 1].pixmap
);
714 if (dpyinfo
->bitmaps
[id
- 1].have_mask
)
715 XFreePixmap (FRAME_X_DISPLAY (f
), dpyinfo
->bitmaps
[id
- 1].mask
);
716 if (dpyinfo
->bitmaps
[id
- 1].file
)
718 xfree (dpyinfo
->bitmaps
[id
- 1].file
);
719 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
726 /* Free all the bitmaps for the display specified by DPYINFO. */
729 x_destroy_all_bitmaps (dpyinfo
)
730 struct x_display_info
*dpyinfo
;
733 for (i
= 0; i
< dpyinfo
->bitmaps_last
; i
++)
734 if (dpyinfo
->bitmaps
[i
].refcount
> 0)
736 XFreePixmap (dpyinfo
->display
, dpyinfo
->bitmaps
[i
].pixmap
);
737 if (dpyinfo
->bitmaps
[i
].have_mask
)
738 XFreePixmap (dpyinfo
->display
, dpyinfo
->bitmaps
[i
].mask
);
739 if (dpyinfo
->bitmaps
[i
].file
)
740 xfree (dpyinfo
->bitmaps
[i
].file
);
742 dpyinfo
->bitmaps_last
= 0;
748 /* Useful functions defined in the section
749 `Image type independent image structures' below. */
751 static unsigned long four_corners_best
P_ ((XImage
*ximg
, unsigned long width
,
752 unsigned long height
));
754 static int x_create_x_image_and_pixmap
P_ ((struct frame
*f
, int width
, int height
,
755 int depth
, XImage
**ximg
,
758 static void x_destroy_x_image
P_ ((XImage
*ximg
));
761 /* Create a mask of a bitmap. Note is this not a perfect mask.
762 It's nicer with some borders in this context */
765 x_create_bitmap_mask(f
, id
)
770 XImage
*ximg
, *mask_img
;
771 unsigned long width
, height
;
774 unsigned long x
, y
, xp
, xm
, yp
, ym
;
777 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
778 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
783 pixmap
= x_bitmap_pixmap(f
, id
);
784 width
= x_bitmap_width(f
, id
);
785 height
= x_bitmap_height(f
, id
);
788 ximg
= XGetImage (FRAME_X_DISPLAY (f
), pixmap
, 0, 0, width
, height
,
797 result
= x_create_x_image_and_pixmap (f
, width
, height
, 1, &mask_img
, &mask
);
806 bg
= four_corners_best (ximg
, width
, height
);
808 for (y
= 0; y
< ximg
->height
; ++y
)
810 for (x
= 0; x
< ximg
->width
; ++x
)
812 xp
= x
!= ximg
->width
- 1 ? x
+ 1 : 0;
813 xm
= x
!= 0 ? x
- 1 : ximg
->width
- 1;
814 yp
= y
!= ximg
->height
- 1 ? y
+ 1 : 0;
815 ym
= y
!= 0 ? y
- 1 : ximg
->height
- 1;
816 if (XGetPixel (ximg
, x
, y
) == bg
817 && XGetPixel (ximg
, x
, yp
) == bg
818 && XGetPixel (ximg
, x
, ym
) == bg
819 && XGetPixel (ximg
, xp
, y
) == bg
820 && XGetPixel (ximg
, xp
, yp
) == bg
821 && XGetPixel (ximg
, xp
, ym
) == bg
822 && XGetPixel (ximg
, xm
, y
) == bg
823 && XGetPixel (ximg
, xm
, yp
) == bg
824 && XGetPixel (ximg
, xm
, ym
) == bg
)
825 XPutPixel (mask_img
, x
, y
, 0);
827 XPutPixel (mask_img
, x
, y
, 1);
831 xassert (interrupt_input_blocked
);
832 gc
= XCreateGC (FRAME_X_DISPLAY (f
), mask
, 0, NULL
);
833 XPutImage (FRAME_X_DISPLAY (f
), mask
, gc
, mask_img
, 0, 0, 0, 0,
835 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
837 dpyinfo
->bitmaps
[id
- 1].have_mask
= 1;
838 dpyinfo
->bitmaps
[id
- 1].mask
= mask
;
840 XDestroyImage (ximg
);
841 x_destroy_x_image(mask_img
);
846 static Lisp_Object unwind_create_frame
P_ ((Lisp_Object
));
847 static Lisp_Object unwind_create_tip_frame
P_ ((Lisp_Object
));
848 static void x_disable_image
P_ ((struct frame
*, struct image
*));
850 void x_set_foreground_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
851 static void x_set_wait_for_wm
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
852 void x_set_background_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
853 void x_set_mouse_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
854 void x_set_cursor_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
855 void x_set_border_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
856 void x_set_cursor_type
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
857 void x_set_icon_type
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
858 void x_set_icon_name
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
859 void x_explicitly_set_name
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
860 void x_set_menu_bar_lines
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
861 void x_set_title
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
862 void x_set_tool_bar_lines
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
863 void x_set_scroll_bar_foreground
P_ ((struct frame
*, Lisp_Object
,
865 void x_set_scroll_bar_background
P_ ((struct frame
*, Lisp_Object
,
867 static Lisp_Object x_default_scroll_bar_color_parameter
P_ ((struct frame
*,
872 static void x_edge_detection
P_ ((struct frame
*, struct image
*, Lisp_Object
,
874 static void init_color_table
P_ ((void));
875 static void free_color_table
P_ ((void));
876 static unsigned long *colors_in_color_table
P_ ((int *n
));
877 static unsigned long lookup_rgb_color
P_ ((struct frame
*f
, int r
, int g
, int b
));
878 static unsigned long lookup_pixel_color
P_ ((struct frame
*f
, unsigned long p
));
884 /* Store the screen positions of frame F into XPTR and YPTR.
885 These are the positions of the containing window manager window,
886 not Emacs's own window. */
889 x_real_positions (f
, xptr
, yptr
)
893 int win_x
, win_y
, outer_x
, outer_y
;
894 int real_x
= 0, real_y
= 0;
896 Window win
= f
->output_data
.x
->parent_desc
;
902 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
904 if (win
== FRAME_X_DISPLAY_INFO (f
)->root_window
)
905 win
= FRAME_OUTER_WINDOW (f
);
907 /* This loop traverses up the containment tree until we hit the root
908 window. Window managers may intersect many windows between our window
909 and the root window. The window we find just before the root window
910 should be the outer WM window. */
913 Window wm_window
, rootw
;
914 Window
*tmp_children
;
915 unsigned int tmp_nchildren
;
918 success
= XQueryTree (FRAME_X_DISPLAY (f
), win
, &rootw
,
919 &wm_window
, &tmp_children
, &tmp_nchildren
);
921 had_errors
= x_had_errors_p (FRAME_X_DISPLAY (f
));
923 /* Don't free tmp_children if XQueryTree failed. */
927 XFree ((char *) tmp_children
);
929 if (wm_window
== rootw
|| had_errors
)
940 /* Get the real coordinates for the WM window upper left corner */
941 XGetGeometry (FRAME_X_DISPLAY (f
), win
,
942 &rootw
, &real_x
, &real_y
, &ign
, &ign
, &ign
, &ign
);
944 /* Translate real coordinates to coordinates relative to our
945 window. For our window, the upper left corner is 0, 0.
946 Since the upper left corner of the WM window is outside
947 our window, win_x and win_y will be negative:
949 ------------------ ---> x
951 | ----------------- v y
954 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
956 /* From-window, to-window. */
957 FRAME_X_DISPLAY_INFO (f
)->root_window
,
960 /* From-position, to-position. */
961 real_x
, real_y
, &win_x
, &win_y
,
966 if (FRAME_X_WINDOW (f
) == FRAME_OUTER_WINDOW (f
))
973 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
975 /* From-window, to-window. */
976 FRAME_X_DISPLAY_INFO (f
)->root_window
,
977 FRAME_OUTER_WINDOW (f
),
979 /* From-position, to-position. */
980 real_x
, real_y
, &outer_x
, &outer_y
,
986 had_errors
= x_had_errors_p (FRAME_X_DISPLAY (f
));
989 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
993 if (had_errors
) return;
995 f
->x_pixels_diff
= -win_x
;
996 f
->y_pixels_diff
= -win_y
;
998 FRAME_X_OUTPUT (f
)->x_pixels_outer_diff
= -outer_x
;
999 FRAME_X_OUTPUT (f
)->y_pixels_outer_diff
= -outer_y
;
1008 /* Gamma-correct COLOR on frame F. */
1011 gamma_correct (f
, color
)
1017 color
->red
= pow (color
->red
/ 65535.0, f
->gamma
) * 65535.0 + 0.5;
1018 color
->green
= pow (color
->green
/ 65535.0, f
->gamma
) * 65535.0 + 0.5;
1019 color
->blue
= pow (color
->blue
/ 65535.0, f
->gamma
) * 65535.0 + 0.5;
1024 /* Decide if color named COLOR_NAME is valid for use on frame F. If
1025 so, return the RGB values in COLOR. If ALLOC_P is non-zero,
1026 allocate the color. Value is zero if COLOR_NAME is invalid, or
1027 no color could be allocated. */
1030 x_defined_color (f
, color_name
, color
, alloc_p
)
1037 Display
*dpy
= FRAME_X_DISPLAY (f
);
1038 Colormap cmap
= FRAME_X_COLORMAP (f
);
1041 success_p
= XParseColor (dpy
, cmap
, color_name
, color
);
1042 if (success_p
&& alloc_p
)
1043 success_p
= x_alloc_nearest_color (f
, cmap
, color
);
1050 /* Return the pixel color value for color COLOR_NAME on frame F. If F
1051 is a monochrome frame, return MONO_COLOR regardless of what ARG says.
1052 Signal an error if color can't be allocated. */
1055 x_decode_color (f
, color_name
, mono_color
)
1057 Lisp_Object color_name
;
1062 CHECK_STRING (color_name
);
1064 #if 0 /* Don't do this. It's wrong when we're not using the default
1065 colormap, it makes freeing difficult, and it's probably not
1066 an important optimization. */
1067 if (strcmp (SDATA (color_name
), "black") == 0)
1068 return BLACK_PIX_DEFAULT (f
);
1069 else if (strcmp (SDATA (color_name
), "white") == 0)
1070 return WHITE_PIX_DEFAULT (f
);
1073 /* Return MONO_COLOR for monochrome frames. */
1074 if (FRAME_X_DISPLAY_INFO (f
)->n_planes
== 1)
1077 /* x_defined_color is responsible for coping with failures
1078 by looking for a near-miss. */
1079 if (x_defined_color (f
, SDATA (color_name
), &cdef
, 1))
1082 Fsignal (Qerror
, Fcons (build_string ("Undefined color"),
1083 Fcons (color_name
, Qnil
)));
1089 /* Change the `wait-for-wm' frame parameter of frame F. OLD_VALUE is
1090 the previous value of that parameter, NEW_VALUE is the new value.
1091 See also the comment of wait_for_wm in struct x_output. */
1094 x_set_wait_for_wm (f
, new_value
, old_value
)
1096 Lisp_Object new_value
, old_value
;
1098 f
->output_data
.x
->wait_for_wm
= !NILP (new_value
);
1103 static Lisp_Object x_find_image_file
P_ ((Lisp_Object file
));
1105 /* Set icon from FILE for frame F. By using GTK functions the icon
1106 may be any format that GdkPixbuf knows about, i.e. not just bitmaps. */
1109 xg_set_icon(f
, file
)
1113 struct gcpro gcpro1
;
1119 found
= x_find_image_file (file
);
1127 filename
= SDATA (found
);
1130 pixbuf
= gdk_pixbuf_new_from_file (filename
, &err
);
1134 gtk_window_set_icon (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1136 g_object_unref (pixbuf
);
1149 #endif /* USE_GTK */
1152 /* Functions called only from `x_set_frame_param'
1153 to set individual parameters.
1155 If FRAME_X_WINDOW (f) is 0,
1156 the frame is being created and its X-window does not exist yet.
1157 In that case, just record the parameter's new value
1158 in the standard place; do not attempt to change the window. */
1161 x_set_foreground_color (f
, arg
, oldval
)
1163 Lisp_Object arg
, oldval
;
1165 struct x_output
*x
= f
->output_data
.x
;
1166 unsigned long fg
, old_fg
;
1168 fg
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1169 old_fg
= x
->foreground_pixel
;
1170 x
->foreground_pixel
= fg
;
1172 if (FRAME_X_WINDOW (f
) != 0)
1174 Display
*dpy
= FRAME_X_DISPLAY (f
);
1177 XSetForeground (dpy
, x
->normal_gc
, fg
);
1178 XSetBackground (dpy
, x
->reverse_gc
, fg
);
1180 if (x
->cursor_pixel
== old_fg
)
1182 unload_color (f
, x
->cursor_pixel
);
1183 x
->cursor_pixel
= x_copy_color (f
, fg
);
1184 XSetBackground (dpy
, x
->cursor_gc
, x
->cursor_pixel
);
1189 update_face_from_frame_parameter (f
, Qforeground_color
, arg
);
1191 if (FRAME_VISIBLE_P (f
))
1195 unload_color (f
, old_fg
);
1199 x_set_background_color (f
, arg
, oldval
)
1201 Lisp_Object arg
, oldval
;
1203 struct x_output
*x
= f
->output_data
.x
;
1206 bg
= x_decode_color (f
, arg
, WHITE_PIX_DEFAULT (f
));
1207 unload_color (f
, x
->background_pixel
);
1208 x
->background_pixel
= bg
;
1210 if (FRAME_X_WINDOW (f
) != 0)
1212 Display
*dpy
= FRAME_X_DISPLAY (f
);
1215 XSetBackground (dpy
, x
->normal_gc
, bg
);
1216 XSetForeground (dpy
, x
->reverse_gc
, bg
);
1217 XSetWindowBackground (dpy
, FRAME_X_WINDOW (f
), bg
);
1218 XSetForeground (dpy
, x
->cursor_gc
, bg
);
1221 xg_set_background_color (f
, bg
);
1224 #ifndef USE_TOOLKIT_SCROLL_BARS /* Turns out to be annoying with
1225 toolkit scroll bars. */
1228 for (bar
= FRAME_SCROLL_BARS (f
);
1230 bar
= XSCROLL_BAR (bar
)->next
)
1232 Window window
= SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
));
1233 XSetWindowBackground (dpy
, window
, bg
);
1236 #endif /* USE_TOOLKIT_SCROLL_BARS */
1239 update_face_from_frame_parameter (f
, Qbackground_color
, arg
);
1241 if (FRAME_VISIBLE_P (f
))
1247 x_set_mouse_color (f
, arg
, oldval
)
1249 Lisp_Object arg
, oldval
;
1251 struct x_output
*x
= f
->output_data
.x
;
1252 Display
*dpy
= FRAME_X_DISPLAY (f
);
1253 Cursor cursor
, nontext_cursor
, mode_cursor
, hand_cursor
;
1254 Cursor hourglass_cursor
, horizontal_drag_cursor
;
1256 unsigned long pixel
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1257 unsigned long mask_color
= x
->background_pixel
;
1259 /* Don't let pointers be invisible. */
1260 if (mask_color
== pixel
)
1262 x_free_colors (f
, &pixel
, 1);
1263 pixel
= x_copy_color (f
, x
->foreground_pixel
);
1266 unload_color (f
, x
->mouse_pixel
);
1267 x
->mouse_pixel
= pixel
;
1271 /* It's not okay to crash if the user selects a screwy cursor. */
1272 count
= x_catch_errors (dpy
);
1274 if (!NILP (Vx_pointer_shape
))
1276 CHECK_NUMBER (Vx_pointer_shape
);
1277 cursor
= XCreateFontCursor (dpy
, XINT (Vx_pointer_shape
));
1280 cursor
= XCreateFontCursor (dpy
, XC_xterm
);
1281 x_check_errors (dpy
, "bad text pointer cursor: %s");
1283 if (!NILP (Vx_nontext_pointer_shape
))
1285 CHECK_NUMBER (Vx_nontext_pointer_shape
);
1287 = XCreateFontCursor (dpy
, XINT (Vx_nontext_pointer_shape
));
1290 nontext_cursor
= XCreateFontCursor (dpy
, XC_left_ptr
);
1291 x_check_errors (dpy
, "bad nontext pointer cursor: %s");
1293 if (!NILP (Vx_hourglass_pointer_shape
))
1295 CHECK_NUMBER (Vx_hourglass_pointer_shape
);
1297 = XCreateFontCursor (dpy
, XINT (Vx_hourglass_pointer_shape
));
1300 hourglass_cursor
= XCreateFontCursor (dpy
, XC_watch
);
1301 x_check_errors (dpy
, "bad hourglass pointer cursor: %s");
1303 x_check_errors (dpy
, "bad nontext pointer cursor: %s");
1304 if (!NILP (Vx_mode_pointer_shape
))
1306 CHECK_NUMBER (Vx_mode_pointer_shape
);
1307 mode_cursor
= XCreateFontCursor (dpy
, XINT (Vx_mode_pointer_shape
));
1310 mode_cursor
= XCreateFontCursor (dpy
, XC_xterm
);
1311 x_check_errors (dpy
, "bad modeline pointer cursor: %s");
1313 if (!NILP (Vx_sensitive_text_pointer_shape
))
1315 CHECK_NUMBER (Vx_sensitive_text_pointer_shape
);
1317 = XCreateFontCursor (dpy
, XINT (Vx_sensitive_text_pointer_shape
));
1320 hand_cursor
= XCreateFontCursor (dpy
, XC_hand2
);
1322 if (!NILP (Vx_window_horizontal_drag_shape
))
1324 CHECK_NUMBER (Vx_window_horizontal_drag_shape
);
1325 horizontal_drag_cursor
1326 = XCreateFontCursor (dpy
, XINT (Vx_window_horizontal_drag_shape
));
1329 horizontal_drag_cursor
1330 = XCreateFontCursor (dpy
, XC_sb_h_double_arrow
);
1332 /* Check and report errors with the above calls. */
1333 x_check_errors (dpy
, "can't set cursor shape: %s");
1334 x_uncatch_errors (dpy
, count
);
1337 XColor fore_color
, back_color
;
1339 fore_color
.pixel
= x
->mouse_pixel
;
1340 x_query_color (f
, &fore_color
);
1341 back_color
.pixel
= mask_color
;
1342 x_query_color (f
, &back_color
);
1344 XRecolorCursor (dpy
, cursor
, &fore_color
, &back_color
);
1345 XRecolorCursor (dpy
, nontext_cursor
, &fore_color
, &back_color
);
1346 XRecolorCursor (dpy
, mode_cursor
, &fore_color
, &back_color
);
1347 XRecolorCursor (dpy
, hand_cursor
, &fore_color
, &back_color
);
1348 XRecolorCursor (dpy
, hourglass_cursor
, &fore_color
, &back_color
);
1349 XRecolorCursor (dpy
, horizontal_drag_cursor
, &fore_color
, &back_color
);
1352 if (FRAME_X_WINDOW (f
) != 0)
1353 XDefineCursor (dpy
, FRAME_X_WINDOW (f
), cursor
);
1355 if (cursor
!= x
->text_cursor
1356 && x
->text_cursor
!= 0)
1357 XFreeCursor (dpy
, x
->text_cursor
);
1358 x
->text_cursor
= cursor
;
1360 if (nontext_cursor
!= x
->nontext_cursor
1361 && x
->nontext_cursor
!= 0)
1362 XFreeCursor (dpy
, x
->nontext_cursor
);
1363 x
->nontext_cursor
= nontext_cursor
;
1365 if (hourglass_cursor
!= x
->hourglass_cursor
1366 && x
->hourglass_cursor
!= 0)
1367 XFreeCursor (dpy
, x
->hourglass_cursor
);
1368 x
->hourglass_cursor
= hourglass_cursor
;
1370 if (mode_cursor
!= x
->modeline_cursor
1371 && x
->modeline_cursor
!= 0)
1372 XFreeCursor (dpy
, f
->output_data
.x
->modeline_cursor
);
1373 x
->modeline_cursor
= mode_cursor
;
1375 if (hand_cursor
!= x
->hand_cursor
1376 && x
->hand_cursor
!= 0)
1377 XFreeCursor (dpy
, x
->hand_cursor
);
1378 x
->hand_cursor
= hand_cursor
;
1380 if (horizontal_drag_cursor
!= x
->horizontal_drag_cursor
1381 && x
->horizontal_drag_cursor
!= 0)
1382 XFreeCursor (dpy
, x
->horizontal_drag_cursor
);
1383 x
->horizontal_drag_cursor
= horizontal_drag_cursor
;
1388 update_face_from_frame_parameter (f
, Qmouse_color
, arg
);
1392 x_set_cursor_color (f
, arg
, oldval
)
1394 Lisp_Object arg
, oldval
;
1396 unsigned long fore_pixel
, pixel
;
1397 int fore_pixel_allocated_p
= 0, pixel_allocated_p
= 0;
1398 struct x_output
*x
= f
->output_data
.x
;
1400 if (!NILP (Vx_cursor_fore_pixel
))
1402 fore_pixel
= x_decode_color (f
, Vx_cursor_fore_pixel
,
1403 WHITE_PIX_DEFAULT (f
));
1404 fore_pixel_allocated_p
= 1;
1407 fore_pixel
= x
->background_pixel
;
1409 pixel
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1410 pixel_allocated_p
= 1;
1412 /* Make sure that the cursor color differs from the background color. */
1413 if (pixel
== x
->background_pixel
)
1415 if (pixel_allocated_p
)
1417 x_free_colors (f
, &pixel
, 1);
1418 pixel_allocated_p
= 0;
1421 pixel
= x
->mouse_pixel
;
1422 if (pixel
== fore_pixel
)
1424 if (fore_pixel_allocated_p
)
1426 x_free_colors (f
, &fore_pixel
, 1);
1427 fore_pixel_allocated_p
= 0;
1429 fore_pixel
= x
->background_pixel
;
1433 unload_color (f
, x
->cursor_foreground_pixel
);
1434 if (!fore_pixel_allocated_p
)
1435 fore_pixel
= x_copy_color (f
, fore_pixel
);
1436 x
->cursor_foreground_pixel
= fore_pixel
;
1438 unload_color (f
, x
->cursor_pixel
);
1439 if (!pixel_allocated_p
)
1440 pixel
= x_copy_color (f
, pixel
);
1441 x
->cursor_pixel
= pixel
;
1443 if (FRAME_X_WINDOW (f
) != 0)
1446 XSetBackground (FRAME_X_DISPLAY (f
), x
->cursor_gc
, x
->cursor_pixel
);
1447 XSetForeground (FRAME_X_DISPLAY (f
), x
->cursor_gc
, fore_pixel
);
1450 if (FRAME_VISIBLE_P (f
))
1452 x_update_cursor (f
, 0);
1453 x_update_cursor (f
, 1);
1457 update_face_from_frame_parameter (f
, Qcursor_color
, arg
);
1460 /* Set the border-color of frame F to pixel value PIX.
1461 Note that this does not fully take effect if done before
1462 F has an x-window. */
1465 x_set_border_pixel (f
, pix
)
1469 unload_color (f
, f
->output_data
.x
->border_pixel
);
1470 f
->output_data
.x
->border_pixel
= pix
;
1472 if (FRAME_X_WINDOW (f
) != 0 && f
->border_width
> 0)
1475 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1476 (unsigned long)pix
);
1479 if (FRAME_VISIBLE_P (f
))
1484 /* Set the border-color of frame F to value described by ARG.
1485 ARG can be a string naming a color.
1486 The border-color is used for the border that is drawn by the X server.
1487 Note that this does not fully take effect if done before
1488 F has an x-window; it must be redone when the window is created.
1490 Note: this is done in two routines because of the way X10 works.
1492 Note: under X11, this is normally the province of the window manager,
1493 and so emacs' border colors may be overridden. */
1496 x_set_border_color (f
, arg
, oldval
)
1498 Lisp_Object arg
, oldval
;
1503 pix
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1504 x_set_border_pixel (f
, pix
);
1505 update_face_from_frame_parameter (f
, Qborder_color
, arg
);
1510 x_set_cursor_type (f
, arg
, oldval
)
1512 Lisp_Object arg
, oldval
;
1514 set_frame_cursor_types (f
, arg
);
1516 /* Make sure the cursor gets redrawn. */
1517 cursor_type_changed
= 1;
1521 x_set_icon_type (f
, arg
, oldval
)
1523 Lisp_Object arg
, oldval
;
1529 if (STRINGP (oldval
) && EQ (Fstring_equal (oldval
, arg
), Qt
))
1532 else if (!STRINGP (oldval
) && EQ (oldval
, Qnil
) == EQ (arg
, Qnil
))
1537 result
= x_text_icon (f
,
1538 (char *) SDATA ((!NILP (f
->icon_name
)
1542 result
= x_bitmap_icon (f
, arg
);
1547 error ("No icon window available");
1550 XFlush (FRAME_X_DISPLAY (f
));
1555 x_set_icon_name (f
, arg
, oldval
)
1557 Lisp_Object arg
, oldval
;
1563 if (STRINGP (oldval
) && EQ (Fstring_equal (oldval
, arg
), Qt
))
1566 else if (!STRINGP (oldval
) && EQ (oldval
, Qnil
) == EQ (arg
, Qnil
))
1571 if (f
->output_data
.x
->icon_bitmap
!= 0)
1576 result
= x_text_icon (f
,
1577 (char *) SDATA ((!NILP (f
->icon_name
)
1586 error ("No icon window available");
1589 XFlush (FRAME_X_DISPLAY (f
));
1595 x_set_menu_bar_lines (f
, value
, oldval
)
1597 Lisp_Object value
, oldval
;
1600 #ifndef USE_X_TOOLKIT
1601 int olines
= FRAME_MENU_BAR_LINES (f
);
1604 /* Right now, menu bars don't work properly in minibuf-only frames;
1605 most of the commands try to apply themselves to the minibuffer
1606 frame itself, and get an error because you can't switch buffers
1607 in or split the minibuffer window. */
1608 if (FRAME_MINIBUF_ONLY_P (f
))
1611 if (INTEGERP (value
))
1612 nlines
= XINT (value
);
1616 /* Make sure we redisplay all windows in this frame. */
1617 windows_or_buffers_changed
++;
1619 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1620 FRAME_MENU_BAR_LINES (f
) = 0;
1623 FRAME_EXTERNAL_MENU_BAR (f
) = 1;
1624 if (FRAME_X_P (f
) && f
->output_data
.x
->menubar_widget
== 0)
1625 /* Make sure next redisplay shows the menu bar. */
1626 XWINDOW (FRAME_SELECTED_WINDOW (f
))->update_mode_line
= Qt
;
1630 if (FRAME_EXTERNAL_MENU_BAR (f
) == 1)
1631 free_frame_menubar (f
);
1632 FRAME_EXTERNAL_MENU_BAR (f
) = 0;
1634 f
->output_data
.x
->menubar_widget
= 0;
1636 #else /* not USE_X_TOOLKIT && not USE_GTK */
1637 FRAME_MENU_BAR_LINES (f
) = nlines
;
1638 change_window_heights (f
->root_window
, nlines
- olines
);
1639 #endif /* not USE_X_TOOLKIT */
1644 /* Set the number of lines used for the tool bar of frame F to VALUE.
1645 VALUE not an integer, or < 0 means set the lines to zero. OLDVAL
1646 is the old number of tool bar lines. This function changes the
1647 height of all windows on frame F to match the new tool bar height.
1648 The frame's height doesn't change. */
1651 x_set_tool_bar_lines (f
, value
, oldval
)
1653 Lisp_Object value
, oldval
;
1655 int delta
, nlines
, root_height
;
1656 Lisp_Object root_window
;
1658 /* Treat tool bars like menu bars. */
1659 if (FRAME_MINIBUF_ONLY_P (f
))
1662 /* Use VALUE only if an integer >= 0. */
1663 if (INTEGERP (value
) && XINT (value
) >= 0)
1664 nlines
= XFASTINT (value
);
1669 FRAME_TOOL_BAR_LINES (f
) = 0;
1672 FRAME_EXTERNAL_TOOL_BAR (f
) = 1;
1673 if (FRAME_X_P (f
) && f
->output_data
.x
->toolbar_widget
== 0)
1674 /* Make sure next redisplay shows the tool bar. */
1675 XWINDOW (FRAME_SELECTED_WINDOW (f
))->update_mode_line
= Qt
;
1676 update_frame_tool_bar (f
);
1680 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1681 free_frame_tool_bar (f
);
1682 FRAME_EXTERNAL_TOOL_BAR (f
) = 0;
1688 /* Make sure we redisplay all windows in this frame. */
1689 ++windows_or_buffers_changed
;
1691 delta
= nlines
- FRAME_TOOL_BAR_LINES (f
);
1693 /* Don't resize the tool-bar to more than we have room for. */
1694 root_window
= FRAME_ROOT_WINDOW (f
);
1695 root_height
= WINDOW_TOTAL_LINES (XWINDOW (root_window
));
1696 if (root_height
- delta
< 1)
1698 delta
= root_height
- 1;
1699 nlines
= FRAME_TOOL_BAR_LINES (f
) + delta
;
1702 FRAME_TOOL_BAR_LINES (f
) = nlines
;
1703 change_window_heights (root_window
, delta
);
1706 /* We also have to make sure that the internal border at the top of
1707 the frame, below the menu bar or tool bar, is redrawn when the
1708 tool bar disappears. This is so because the internal border is
1709 below the tool bar if one is displayed, but is below the menu bar
1710 if there isn't a tool bar. The tool bar draws into the area
1711 below the menu bar. */
1712 if (FRAME_X_WINDOW (f
) && FRAME_TOOL_BAR_LINES (f
) == 0)
1716 clear_current_matrices (f
);
1717 updating_frame
= NULL
;
1720 /* If the tool bar gets smaller, the internal border below it
1721 has to be cleared. It was formerly part of the display
1722 of the larger tool bar, and updating windows won't clear it. */
1725 int height
= FRAME_INTERNAL_BORDER_WIDTH (f
);
1726 int width
= FRAME_PIXEL_WIDTH (f
);
1727 int y
= nlines
* FRAME_LINE_HEIGHT (f
);
1730 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1731 0, y
, width
, height
, False
);
1734 if (WINDOWP (f
->tool_bar_window
))
1735 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
1740 /* Set the foreground color for scroll bars on frame F to VALUE.
1741 VALUE should be a string, a color name. If it isn't a string or
1742 isn't a valid color name, do nothing. OLDVAL is the old value of
1743 the frame parameter. */
1746 x_set_scroll_bar_foreground (f
, value
, oldval
)
1748 Lisp_Object value
, oldval
;
1750 unsigned long pixel
;
1752 if (STRINGP (value
))
1753 pixel
= x_decode_color (f
, value
, BLACK_PIX_DEFAULT (f
));
1757 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
1758 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
1760 f
->output_data
.x
->scroll_bar_foreground_pixel
= pixel
;
1761 if (FRAME_X_WINDOW (f
) && FRAME_VISIBLE_P (f
))
1763 /* Remove all scroll bars because they have wrong colors. */
1764 if (condemn_scroll_bars_hook
)
1765 (*condemn_scroll_bars_hook
) (f
);
1766 if (judge_scroll_bars_hook
)
1767 (*judge_scroll_bars_hook
) (f
);
1769 update_face_from_frame_parameter (f
, Qscroll_bar_foreground
, value
);
1775 /* Set the background color for scroll bars on frame F to VALUE VALUE
1776 should be a string, a color name. If it isn't a string or isn't a
1777 valid color name, do nothing. OLDVAL is the old value of the frame
1781 x_set_scroll_bar_background (f
, value
, oldval
)
1783 Lisp_Object value
, oldval
;
1785 unsigned long pixel
;
1787 if (STRINGP (value
))
1788 pixel
= x_decode_color (f
, value
, WHITE_PIX_DEFAULT (f
));
1792 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
1793 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
1795 #ifdef USE_TOOLKIT_SCROLL_BARS
1796 /* Scrollbar shadow colors. */
1797 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
1799 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
1800 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= -1;
1802 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
1804 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
1805 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= -1;
1807 #endif /* USE_TOOLKIT_SCROLL_BARS */
1809 f
->output_data
.x
->scroll_bar_background_pixel
= pixel
;
1810 if (FRAME_X_WINDOW (f
) && FRAME_VISIBLE_P (f
))
1812 /* Remove all scroll bars because they have wrong colors. */
1813 if (condemn_scroll_bars_hook
)
1814 (*condemn_scroll_bars_hook
) (f
);
1815 if (judge_scroll_bars_hook
)
1816 (*judge_scroll_bars_hook
) (f
);
1818 update_face_from_frame_parameter (f
, Qscroll_bar_background
, value
);
1824 /* Encode Lisp string STRING as a text in a format appropriate for
1825 XICCC (X Inter Client Communication Conventions).
1827 If STRING contains only ASCII characters, do no conversion and
1828 return the string data of STRING. Otherwise, encode the text by
1829 CODING_SYSTEM, and return a newly allocated memory area which
1830 should be freed by `xfree' by a caller.
1832 SELECTIONP non-zero means the string is being encoded for an X
1833 selection, so it is safe to run pre-write conversions (which
1836 Store the byte length of resulting text in *TEXT_BYTES.
1838 If the text contains only ASCII and Latin-1, store 1 in *STRING_P,
1839 which means that the `encoding' of the result can be `STRING'.
1840 Otherwise store 0 in *STRINGP, which means that the `encoding' of
1841 the result should be `COMPOUND_TEXT'. */
1844 x_encode_text (string
, coding_system
, selectionp
, text_bytes
, stringp
)
1845 Lisp_Object string
, coding_system
;
1846 int *text_bytes
, *stringp
;
1849 unsigned char *str
= SDATA (string
);
1850 int chars
= SCHARS (string
);
1851 int bytes
= SBYTES (string
);
1855 struct coding_system coding
;
1856 extern Lisp_Object Qcompound_text_with_extensions
;
1858 charset_info
= find_charset_in_text (str
, chars
, bytes
, NULL
, Qnil
);
1859 if (charset_info
== 0)
1861 /* No multibyte character in OBJ. We need not encode it. */
1862 *text_bytes
= bytes
;
1867 setup_coding_system (coding_system
, &coding
);
1869 && SYMBOLP (coding
.pre_write_conversion
)
1870 && !NILP (Ffboundp (coding
.pre_write_conversion
)))
1872 string
= run_pre_post_conversion_on_str (string
, &coding
, 1);
1873 str
= SDATA (string
);
1874 chars
= SCHARS (string
);
1875 bytes
= SBYTES (string
);
1877 coding
.src_multibyte
= 1;
1878 coding
.dst_multibyte
= 0;
1879 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
1880 if (coding
.type
== coding_type_iso2022
)
1881 coding
.flags
|= CODING_FLAG_ISO_SAFE
;
1882 /* We suppress producing escape sequences for composition. */
1883 coding
.composing
= COMPOSITION_DISABLED
;
1884 bufsize
= encoding_buffer_size (&coding
, bytes
);
1885 buf
= (unsigned char *) xmalloc (bufsize
);
1886 encode_coding (&coding
, str
, buf
, bytes
, bufsize
);
1887 *text_bytes
= coding
.produced
;
1888 *stringp
= (charset_info
== 1
1889 || (!EQ (coding_system
, Qcompound_text
)
1890 && !EQ (coding_system
, Qcompound_text_with_extensions
)));
1895 /* Change the name of frame F to NAME. If NAME is nil, set F's name to
1898 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1899 name; if NAME is a string, set F's name to NAME and set
1900 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1902 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1903 suggesting a new name, which lisp code should override; if
1904 F->explicit_name is set, ignore the new name; otherwise, set it. */
1907 x_set_name (f
, name
, explicit)
1912 /* Make sure that requests from lisp code override requests from
1913 Emacs redisplay code. */
1916 /* If we're switching from explicit to implicit, we had better
1917 update the mode lines and thereby update the title. */
1918 if (f
->explicit_name
&& NILP (name
))
1919 update_mode_lines
= 1;
1921 f
->explicit_name
= ! NILP (name
);
1923 else if (f
->explicit_name
)
1926 /* If NAME is nil, set the name to the x_id_name. */
1929 /* Check for no change needed in this very common case
1930 before we do any consing. */
1931 if (!strcmp (FRAME_X_DISPLAY_INFO (f
)->x_id_name
,
1934 name
= build_string (FRAME_X_DISPLAY_INFO (f
)->x_id_name
);
1937 CHECK_STRING (name
);
1939 /* Don't change the name if it's already NAME. */
1940 if (! NILP (Fstring_equal (name
, f
->name
)))
1945 /* For setting the frame title, the title parameter should override
1946 the name parameter. */
1947 if (! NILP (f
->title
))
1950 if (FRAME_X_WINDOW (f
))
1955 XTextProperty text
, icon
;
1957 Lisp_Object coding_system
;
1959 /* Note: Encoding strategy
1961 We encode NAME by compound-text and use "COMPOUND-TEXT" in
1962 text.encoding. But, there are non-internationalized window
1963 managers which don't support that encoding. So, if NAME
1964 contains only ASCII and 8859-1 characters, encode it by
1965 iso-latin-1, and use "STRING" in text.encoding hoping that
1966 such window managers at least analyze this format correctly,
1967 i.e. treat 8-bit bytes as 8859-1 characters.
1969 We may also be able to use "UTF8_STRING" in text.encoding
1970 in the future which can encode all Unicode characters.
1971 But, for the moment, there's no way to know that the
1972 current window manager supports it or not. */
1973 coding_system
= Qcompound_text
;
1974 text
.value
= x_encode_text (name
, coding_system
, 0, &bytes
, &stringp
);
1975 text
.encoding
= (stringp
? XA_STRING
1976 : FRAME_X_DISPLAY_INFO (f
)->Xatom_COMPOUND_TEXT
);
1978 text
.nitems
= bytes
;
1980 if (NILP (f
->icon_name
))
1986 /* See the above comment "Note: Encoding strategy". */
1987 icon
.value
= x_encode_text (f
->icon_name
, coding_system
, 0,
1989 icon
.encoding
= (stringp
? XA_STRING
1990 : FRAME_X_DISPLAY_INFO (f
)->Xatom_COMPOUND_TEXT
);
1992 icon
.nitems
= bytes
;
1995 gtk_window_set_title (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1997 #else /* not USE_GTK */
1998 XSetWMName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
1999 #endif /* not USE_GTK */
2001 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &icon
);
2003 if (!NILP (f
->icon_name
)
2004 && icon
.value
!= (unsigned char *) SDATA (f
->icon_name
))
2006 if (text
.value
!= (unsigned char *) SDATA (name
))
2009 #else /* not HAVE_X11R4 */
2010 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2012 XStoreName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2014 #endif /* not HAVE_X11R4 */
2019 /* This function should be called when the user's lisp code has
2020 specified a name for the frame; the name will override any set by the
2023 x_explicitly_set_name (f
, arg
, oldval
)
2025 Lisp_Object arg
, oldval
;
2027 x_set_name (f
, arg
, 1);
2030 /* This function should be called by Emacs redisplay code to set the
2031 name; names set this way will never override names set by the user's
2034 x_implicitly_set_name (f
, arg
, oldval
)
2036 Lisp_Object arg
, oldval
;
2038 x_set_name (f
, arg
, 0);
2041 /* Change the title of frame F to NAME.
2042 If NAME is nil, use the frame name as the title.
2044 If EXPLICIT is non-zero, that indicates that lisp code is setting the
2045 name; if NAME is a string, set F's name to NAME and set
2046 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
2048 If EXPLICIT is zero, that indicates that Emacs redisplay code is
2049 suggesting a new name, which lisp code should override; if
2050 F->explicit_name is set, ignore the new name; otherwise, set it. */
2053 x_set_title (f
, name
, old_name
)
2055 Lisp_Object name
, old_name
;
2057 /* Don't change the title if it's already NAME. */
2058 if (EQ (name
, f
->title
))
2061 update_mode_lines
= 1;
2068 CHECK_STRING (name
);
2070 if (FRAME_X_WINDOW (f
))
2075 XTextProperty text
, icon
;
2077 Lisp_Object coding_system
;
2079 coding_system
= Qcompound_text
;
2080 /* See the comment "Note: Encoding strategy" in x_set_name. */
2081 text
.value
= x_encode_text (name
, coding_system
, 0, &bytes
, &stringp
);
2082 text
.encoding
= (stringp
? XA_STRING
2083 : FRAME_X_DISPLAY_INFO (f
)->Xatom_COMPOUND_TEXT
);
2085 text
.nitems
= bytes
;
2087 if (NILP (f
->icon_name
))
2093 /* See the comment "Note: Encoding strategy" in x_set_name. */
2094 icon
.value
= x_encode_text (f
->icon_name
, coding_system
, 0,
2096 icon
.encoding
= (stringp
? XA_STRING
2097 : FRAME_X_DISPLAY_INFO (f
)->Xatom_COMPOUND_TEXT
);
2099 icon
.nitems
= bytes
;
2103 gtk_window_set_title (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
2105 #else /* not USE_GTK */
2106 XSetWMName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
2107 #endif /* not USE_GTK */
2109 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
2112 if (!NILP (f
->icon_name
)
2113 && icon
.value
!= (unsigned char *) SDATA (f
->icon_name
))
2115 if (text
.value
!= (unsigned char *) SDATA (name
))
2118 #else /* not HAVE_X11R4 */
2119 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2121 XStoreName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2123 #endif /* not HAVE_X11R4 */
2129 x_set_scroll_bar_default_width (f
)
2132 int wid
= FRAME_COLUMN_WIDTH (f
);
2134 #ifdef USE_TOOLKIT_SCROLL_BARS
2135 /* A minimum width of 14 doesn't look good for toolkit scroll bars. */
2136 int width
= 16 + 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
2137 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (width
+ wid
- 1) / wid
;
2138 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) = width
;
2140 /* Make the actual width at least 14 pixels and a multiple of a
2142 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
2144 /* Use all of that space (aside from required margins) for the
2146 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) = 0;
2151 /* Record in frame F the specified or default value according to ALIST
2152 of the parameter named PROP (a Lisp symbol). If no value is
2153 specified for PROP, look for an X default for XPROP on the frame
2154 named NAME. If that is not found either, use the value DEFLT. */
2157 x_default_scroll_bar_color_parameter (f
, alist
, prop
, xprop
, xclass
,
2166 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2169 tem
= x_get_arg (dpyinfo
, alist
, prop
, xprop
, xclass
, RES_TYPE_STRING
);
2170 if (EQ (tem
, Qunbound
))
2172 #ifdef USE_TOOLKIT_SCROLL_BARS
2174 /* See if an X resource for the scroll bar color has been
2176 tem
= display_x_get_resource (dpyinfo
,
2177 build_string (foreground_p
2181 build_string ("verticalScrollBar"),
2185 /* If nothing has been specified, scroll bars will use a
2186 toolkit-dependent default. Because these defaults are
2187 difficult to get at without actually creating a scroll
2188 bar, use nil to indicate that no color has been
2193 #else /* not USE_TOOLKIT_SCROLL_BARS */
2197 #endif /* not USE_TOOLKIT_SCROLL_BARS */
2200 x_set_frame_parameters (f
, Fcons (Fcons (prop
, tem
), Qnil
));
2206 #if !defined (HAVE_X11R4) && !defined (HAVE_XSETWMPROTOCOLS)
2209 XSetWMProtocols (dpy
, w
, protocols
, count
)
2216 prop
= XInternAtom (dpy
, "WM_PROTOCOLS", False
);
2217 if (prop
== None
) return False
;
2218 XChangeProperty (dpy
, w
, prop
, XA_ATOM
, 32, PropModeReplace
,
2219 (unsigned char *) protocols
, count
);
2222 #endif /* not HAVE_X11R4 && not HAVE_XSETWMPROTOCOLS */
2224 #ifdef USE_X_TOOLKIT
2226 /* If the WM_PROTOCOLS property does not already contain WM_TAKE_FOCUS,
2227 WM_DELETE_WINDOW, and WM_SAVE_YOURSELF, then add them. (They may
2228 already be present because of the toolkit (Motif adds some of them,
2229 for example, but Xt doesn't). */
2232 hack_wm_protocols (f
, widget
)
2236 Display
*dpy
= XtDisplay (widget
);
2237 Window w
= XtWindow (widget
);
2238 int need_delete
= 1;
2244 Atom type
, *atoms
= 0;
2246 unsigned long nitems
= 0;
2247 unsigned long bytes_after
;
2249 if ((XGetWindowProperty (dpy
, w
,
2250 FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_protocols
,
2251 (long)0, (long)100, False
, XA_ATOM
,
2252 &type
, &format
, &nitems
, &bytes_after
,
2253 (unsigned char **) &atoms
)
2255 && format
== 32 && type
== XA_ATOM
)
2259 if (atoms
[nitems
] == FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_delete_window
)
2261 else if (atoms
[nitems
] == FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_take_focus
)
2263 else if (atoms
[nitems
] == FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_save_yourself
)
2266 if (atoms
) XFree ((char *) atoms
);
2272 props
[count
++] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_delete_window
;
2274 props
[count
++] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_take_focus
;
2276 props
[count
++] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_save_yourself
;
2278 XChangeProperty (dpy
, w
, FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_protocols
,
2279 XA_ATOM
, 32, PropModeAppend
,
2280 (unsigned char *) props
, count
);
2288 /* Support routines for XIC (X Input Context). */
2292 static XFontSet xic_create_xfontset
P_ ((struct frame
*, char *));
2293 static XIMStyle best_xim_style
P_ ((XIMStyles
*, XIMStyles
*));
2296 /* Supported XIM styles, ordered by preference. */
2298 static XIMStyle supported_xim_styles
[] =
2300 XIMPreeditPosition
| XIMStatusArea
,
2301 XIMPreeditPosition
| XIMStatusNothing
,
2302 XIMPreeditPosition
| XIMStatusNone
,
2303 XIMPreeditNothing
| XIMStatusArea
,
2304 XIMPreeditNothing
| XIMStatusNothing
,
2305 XIMPreeditNothing
| XIMStatusNone
,
2306 XIMPreeditNone
| XIMStatusArea
,
2307 XIMPreeditNone
| XIMStatusNothing
,
2308 XIMPreeditNone
| XIMStatusNone
,
2313 /* Create an X fontset on frame F with base font name
2317 xic_create_xfontset (f
, base_fontname
)
2319 char *base_fontname
;
2322 char **missing_list
;
2326 xfs
= XCreateFontSet (FRAME_X_DISPLAY (f
),
2327 base_fontname
, &missing_list
,
2328 &missing_count
, &def_string
);
2330 XFreeStringList (missing_list
);
2332 /* No need to free def_string. */
2337 /* Value is the best input style, given user preferences USER (already
2338 checked to be supported by Emacs), and styles supported by the
2339 input method XIM. */
2342 best_xim_style (user
, xim
)
2348 for (i
= 0; i
< user
->count_styles
; ++i
)
2349 for (j
= 0; j
< xim
->count_styles
; ++j
)
2350 if (user
->supported_styles
[i
] == xim
->supported_styles
[j
])
2351 return user
->supported_styles
[i
];
2353 /* Return the default style. */
2354 return XIMPreeditNothing
| XIMStatusNothing
;
2357 /* Create XIC for frame F. */
2359 static XIMStyle xic_style
;
2362 create_frame_xic (f
)
2367 XFontSet xfs
= NULL
;
2372 xim
= FRAME_X_XIM (f
);
2377 XVaNestedList preedit_attr
;
2378 XVaNestedList status_attr
;
2379 char *base_fontname
;
2382 s_area
.x
= 0; s_area
.y
= 0; s_area
.width
= 1; s_area
.height
= 1;
2383 spot
.x
= 0; spot
.y
= 1;
2384 /* Create X fontset. */
2385 fontset
= FRAME_FONTSET (f
);
2387 base_fontname
= "-*-*-*-r-normal--14-*-*-*-*-*-*-*";
2390 /* Determine the base fontname from the ASCII font name of
2392 char *ascii_font
= (char *) SDATA (fontset_ascii (fontset
));
2393 char *p
= ascii_font
;
2396 for (i
= 0; *p
; p
++)
2399 /* As the font name doesn't conform to XLFD, we can't
2400 modify it to get a suitable base fontname for the
2402 base_fontname
= "-*-*-*-r-normal--14-*-*-*-*-*-*-*";
2405 int len
= strlen (ascii_font
) + 1;
2408 for (i
= 0, p
= ascii_font
; i
< 8; p
++)
2417 base_fontname
= (char *) alloca (len
);
2418 bzero (base_fontname
, len
);
2419 strcpy (base_fontname
, "-*-*-");
2420 bcopy (p1
, base_fontname
+ 5, p
- p1
);
2421 strcat (base_fontname
, "*-*-*-*-*-*-*");
2424 xfs
= xic_create_xfontset (f
, base_fontname
);
2426 /* Determine XIC style. */
2429 XIMStyles supported_list
;
2430 supported_list
.count_styles
= (sizeof supported_xim_styles
2431 / sizeof supported_xim_styles
[0]);
2432 supported_list
.supported_styles
= supported_xim_styles
;
2433 xic_style
= best_xim_style (&supported_list
,
2434 FRAME_X_XIM_STYLES (f
));
2437 preedit_attr
= XVaCreateNestedList (0,
2440 FRAME_FOREGROUND_PIXEL (f
),
2442 FRAME_BACKGROUND_PIXEL (f
),
2443 (xic_style
& XIMPreeditPosition
2448 status_attr
= XVaCreateNestedList (0,
2454 FRAME_FOREGROUND_PIXEL (f
),
2456 FRAME_BACKGROUND_PIXEL (f
),
2459 xic
= XCreateIC (xim
,
2460 XNInputStyle
, xic_style
,
2461 XNClientWindow
, FRAME_X_WINDOW(f
),
2462 XNFocusWindow
, FRAME_X_WINDOW(f
),
2463 XNStatusAttributes
, status_attr
,
2464 XNPreeditAttributes
, preedit_attr
,
2466 XFree (preedit_attr
);
2467 XFree (status_attr
);
2470 FRAME_XIC (f
) = xic
;
2471 FRAME_XIC_STYLE (f
) = xic_style
;
2472 FRAME_XIC_FONTSET (f
) = xfs
;
2476 /* Destroy XIC and free XIC fontset of frame F, if any. */
2482 if (FRAME_XIC (f
) == NULL
)
2485 XDestroyIC (FRAME_XIC (f
));
2486 if (FRAME_XIC_FONTSET (f
))
2487 XFreeFontSet (FRAME_X_DISPLAY (f
), FRAME_XIC_FONTSET (f
));
2489 FRAME_XIC (f
) = NULL
;
2490 FRAME_XIC_FONTSET (f
) = NULL
;
2494 /* Place preedit area for XIC of window W's frame to specified
2495 pixel position X/Y. X and Y are relative to window W. */
2498 xic_set_preeditarea (w
, x
, y
)
2502 struct frame
*f
= XFRAME (w
->frame
);
2506 spot
.x
= WINDOW_TO_FRAME_PIXEL_X (w
, x
) + WINDOW_LEFT_FRINGE_WIDTH (w
);
2507 spot
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, y
) + FONT_BASE (FRAME_FONT (f
));
2508 attr
= XVaCreateNestedList (0, XNSpotLocation
, &spot
, NULL
);
2509 XSetICValues (FRAME_XIC (f
), XNPreeditAttributes
, attr
, NULL
);
2514 /* Place status area for XIC in bottom right corner of frame F.. */
2517 xic_set_statusarea (f
)
2520 XIC xic
= FRAME_XIC (f
);
2525 /* Negotiate geometry of status area. If input method has existing
2526 status area, use its current size. */
2527 area
.x
= area
.y
= area
.width
= area
.height
= 0;
2528 attr
= XVaCreateNestedList (0, XNAreaNeeded
, &area
, NULL
);
2529 XSetICValues (xic
, XNStatusAttributes
, attr
, NULL
);
2532 attr
= XVaCreateNestedList (0, XNAreaNeeded
, &needed
, NULL
);
2533 XGetICValues (xic
, XNStatusAttributes
, attr
, NULL
);
2536 if (needed
->width
== 0) /* Use XNArea instead of XNAreaNeeded */
2538 attr
= XVaCreateNestedList (0, XNArea
, &needed
, NULL
);
2539 XGetICValues (xic
, XNStatusAttributes
, attr
, NULL
);
2543 area
.width
= needed
->width
;
2544 area
.height
= needed
->height
;
2545 area
.x
= FRAME_PIXEL_WIDTH (f
) - area
.width
- FRAME_INTERNAL_BORDER_WIDTH (f
);
2546 area
.y
= (FRAME_PIXEL_HEIGHT (f
) - area
.height
2547 - FRAME_MENUBAR_HEIGHT (f
)
2548 - FRAME_TOOLBAR_HEIGHT (f
)
2549 - FRAME_INTERNAL_BORDER_WIDTH (f
));
2552 attr
= XVaCreateNestedList (0, XNArea
, &area
, NULL
);
2553 XSetICValues(xic
, XNStatusAttributes
, attr
, NULL
);
2558 /* Set X fontset for XIC of frame F, using base font name
2559 BASE_FONTNAME. Called when a new Emacs fontset is chosen. */
2562 xic_set_xfontset (f
, base_fontname
)
2564 char *base_fontname
;
2569 xfs
= xic_create_xfontset (f
, base_fontname
);
2571 attr
= XVaCreateNestedList (0, XNFontSet
, xfs
, NULL
);
2572 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
2573 XSetICValues (FRAME_XIC (f
), XNPreeditAttributes
, attr
, NULL
);
2574 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
2575 XSetICValues (FRAME_XIC (f
), XNStatusAttributes
, attr
, NULL
);
2578 if (FRAME_XIC_FONTSET (f
))
2579 XFreeFontSet (FRAME_X_DISPLAY (f
), FRAME_XIC_FONTSET (f
));
2580 FRAME_XIC_FONTSET (f
) = xfs
;
2583 #endif /* HAVE_X_I18N */
2587 #ifdef USE_X_TOOLKIT
2589 /* Create and set up the X widget for frame F. */
2592 x_window (f
, window_prompting
, minibuffer_only
)
2594 long window_prompting
;
2595 int minibuffer_only
;
2597 XClassHint class_hints
;
2598 XSetWindowAttributes attributes
;
2599 unsigned long attribute_mask
;
2600 Widget shell_widget
;
2602 Widget frame_widget
;
2608 /* Use the resource name as the top-level widget name
2609 for looking up resources. Make a non-Lisp copy
2610 for the window manager, so GC relocation won't bother it.
2612 Elsewhere we specify the window name for the window manager. */
2615 char *str
= (char *) SDATA (Vx_resource_name
);
2616 f
->namebuf
= (char *) xmalloc (strlen (str
) + 1);
2617 strcpy (f
->namebuf
, str
);
2621 XtSetArg (al
[ac
], XtNallowShellResize
, 1); ac
++;
2622 XtSetArg (al
[ac
], XtNinput
, 1); ac
++;
2623 XtSetArg (al
[ac
], XtNmappedWhenManaged
, 0); ac
++;
2624 XtSetArg (al
[ac
], XtNborderWidth
, f
->border_width
); ac
++;
2625 XtSetArg (al
[ac
], XtNvisual
, FRAME_X_VISUAL (f
)); ac
++;
2626 XtSetArg (al
[ac
], XtNdepth
, FRAME_X_DISPLAY_INFO (f
)->n_planes
); ac
++;
2627 XtSetArg (al
[ac
], XtNcolormap
, FRAME_X_COLORMAP (f
)); ac
++;
2628 shell_widget
= XtAppCreateShell (f
->namebuf
, EMACS_CLASS
,
2629 applicationShellWidgetClass
,
2630 FRAME_X_DISPLAY (f
), al
, ac
);
2632 f
->output_data
.x
->widget
= shell_widget
;
2633 /* maybe_set_screen_title_format (shell_widget); */
2635 pane_widget
= lw_create_widget ("main", "pane", widget_id_tick
++,
2636 (widget_value
*) NULL
,
2637 shell_widget
, False
,
2641 (lw_callback
) NULL
);
2644 XtSetArg (al
[ac
], XtNvisual
, FRAME_X_VISUAL (f
)); ac
++;
2645 XtSetArg (al
[ac
], XtNdepth
, FRAME_X_DISPLAY_INFO (f
)->n_planes
); ac
++;
2646 XtSetArg (al
[ac
], XtNcolormap
, FRAME_X_COLORMAP (f
)); ac
++;
2647 XtSetValues (pane_widget
, al
, ac
);
2648 f
->output_data
.x
->column_widget
= pane_widget
;
2650 /* mappedWhenManaged to false tells to the paned window to not map/unmap
2651 the emacs screen when changing menubar. This reduces flickering. */
2654 XtSetArg (al
[ac
], XtNmappedWhenManaged
, 0); ac
++;
2655 XtSetArg (al
[ac
], XtNshowGrip
, 0); ac
++;
2656 XtSetArg (al
[ac
], XtNallowResize
, 1); ac
++;
2657 XtSetArg (al
[ac
], XtNresizeToPreferred
, 1); ac
++;
2658 XtSetArg (al
[ac
], XtNemacsFrame
, f
); ac
++;
2659 XtSetArg (al
[ac
], XtNvisual
, FRAME_X_VISUAL (f
)); ac
++;
2660 XtSetArg (al
[ac
], XtNdepth
, FRAME_X_DISPLAY_INFO (f
)->n_planes
); ac
++;
2661 XtSetArg (al
[ac
], XtNcolormap
, FRAME_X_COLORMAP (f
)); ac
++;
2662 frame_widget
= XtCreateWidget (f
->namebuf
, emacsFrameClass
, pane_widget
,
2665 f
->output_data
.x
->edit_widget
= frame_widget
;
2667 XtManageChild (frame_widget
);
2669 /* Do some needed geometry management. */
2672 char *tem
, shell_position
[32];
2675 int extra_borders
= 0;
2677 = (f
->output_data
.x
->menubar_widget
2678 ? (f
->output_data
.x
->menubar_widget
->core
.height
2679 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
2682 #if 0 /* Experimentally, we now get the right results
2683 for -geometry -0-0 without this. 24 Aug 96, rms. */
2684 if (FRAME_EXTERNAL_MENU_BAR (f
))
2687 XtVaGetValues (pane_widget
, XtNinternalBorderWidth
, &ibw
, NULL
);
2688 menubar_size
+= ibw
;
2692 f
->output_data
.x
->menubar_height
= menubar_size
;
2695 /* Motif seems to need this amount added to the sizes
2696 specified for the shell widget. The Athena/Lucid widgets don't.
2697 Both conclusions reached experimentally. -- rms. */
2698 XtVaGetValues (f
->output_data
.x
->edit_widget
, XtNinternalBorderWidth
,
2699 &extra_borders
, NULL
);
2703 /* Convert our geometry parameters into a geometry string
2705 Note that we do not specify here whether the position
2706 is a user-specified or program-specified one.
2707 We pass that information later, in x_wm_set_size_hints. */
2709 int left
= f
->left_pos
;
2710 int xneg
= window_prompting
& XNegative
;
2711 int top
= f
->top_pos
;
2712 int yneg
= window_prompting
& YNegative
;
2718 if (window_prompting
& USPosition
)
2719 sprintf (shell_position
, "=%dx%d%c%d%c%d",
2720 FRAME_PIXEL_WIDTH (f
) + extra_borders
,
2721 FRAME_PIXEL_HEIGHT (f
) + menubar_size
+ extra_borders
,
2722 (xneg
? '-' : '+'), left
,
2723 (yneg
? '-' : '+'), top
);
2725 sprintf (shell_position
, "=%dx%d",
2726 FRAME_PIXEL_WIDTH (f
) + extra_borders
,
2727 FRAME_PIXEL_HEIGHT (f
) + menubar_size
+ extra_borders
);
2730 len
= strlen (shell_position
) + 1;
2731 /* We don't free this because we don't know whether
2732 it is safe to free it while the frame exists.
2733 It isn't worth the trouble of arranging to free it
2734 when the frame is deleted. */
2735 tem
= (char *) xmalloc (len
);
2736 strncpy (tem
, shell_position
, len
);
2737 XtSetArg (al
[ac
], XtNgeometry
, tem
); ac
++;
2738 XtSetValues (shell_widget
, al
, ac
);
2741 XtManageChild (pane_widget
);
2742 XtRealizeWidget (shell_widget
);
2744 FRAME_X_WINDOW (f
) = XtWindow (frame_widget
);
2746 validate_x_resource_name ();
2748 class_hints
.res_name
= (char *) SDATA (Vx_resource_name
);
2749 class_hints
.res_class
= (char *) SDATA (Vx_resource_class
);
2750 XSetClassHint (FRAME_X_DISPLAY (f
), XtWindow (shell_widget
), &class_hints
);
2753 FRAME_XIC (f
) = NULL
;
2755 create_frame_xic (f
);
2758 f
->output_data
.x
->wm_hints
.input
= True
;
2759 f
->output_data
.x
->wm_hints
.flags
|= InputHint
;
2760 XSetWMHints (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2761 &f
->output_data
.x
->wm_hints
);
2763 hack_wm_protocols (f
, shell_widget
);
2766 XtAddEventHandler (shell_widget
, 0, True
, _XEditResCheckMessages
, 0);
2769 /* Do a stupid property change to force the server to generate a
2770 PropertyNotify event so that the event_stream server timestamp will
2771 be initialized to something relevant to the time we created the window.
2773 XChangeProperty (XtDisplay (frame_widget
), XtWindow (frame_widget
),
2774 FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_protocols
,
2775 XA_ATOM
, 32, PropModeAppend
,
2776 (unsigned char*) NULL
, 0);
2778 /* Make all the standard events reach the Emacs frame. */
2779 attributes
.event_mask
= STANDARD_EVENT_SET
;
2784 /* XIM server might require some X events. */
2785 unsigned long fevent
= NoEventMask
;
2786 XGetICValues(FRAME_XIC (f
), XNFilterEvents
, &fevent
, NULL
);
2787 attributes
.event_mask
|= fevent
;
2789 #endif /* HAVE_X_I18N */
2791 attribute_mask
= CWEventMask
;
2792 XChangeWindowAttributes (XtDisplay (shell_widget
), XtWindow (shell_widget
),
2793 attribute_mask
, &attributes
);
2795 XtMapWidget (frame_widget
);
2797 /* x_set_name normally ignores requests to set the name if the
2798 requested name is the same as the current name. This is the one
2799 place where that assumption isn't correct; f->name is set, but
2800 the X server hasn't been told. */
2803 int explicit = f
->explicit_name
;
2805 f
->explicit_name
= 0;
2808 x_set_name (f
, name
, explicit);
2811 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2812 f
->output_data
.x
->text_cursor
);
2816 /* This is a no-op, except under Motif. Make sure main areas are
2817 set to something reasonable, in case we get an error later. */
2818 lw_set_main_areas (pane_widget
, 0, frame_widget
);
2821 #else /* not USE_X_TOOLKIT */
2827 if (! xg_create_frame_widgets (f
))
2828 error ("Unable to create window");
2831 FRAME_XIC (f
) = NULL
;
2835 create_frame_xic (f
);
2838 /* XIM server might require some X events. */
2839 unsigned long fevent
= NoEventMask
;
2840 XGetICValues(FRAME_XIC (f
), XNFilterEvents
, &fevent
, NULL
);
2842 if (fevent
!= NoEventMask
)
2844 XSetWindowAttributes attributes
;
2845 XWindowAttributes wattr
;
2846 unsigned long attribute_mask
;
2848 XGetWindowAttributes (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2850 attributes
.event_mask
= wattr
.your_event_mask
| fevent
;
2851 attribute_mask
= CWEventMask
;
2852 XChangeWindowAttributes (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2853 attribute_mask
, &attributes
);
2861 #else /*! USE_GTK */
2862 /* Create and set up the X window for frame F. */
2869 XClassHint class_hints
;
2870 XSetWindowAttributes attributes
;
2871 unsigned long attribute_mask
;
2873 attributes
.background_pixel
= f
->output_data
.x
->background_pixel
;
2874 attributes
.border_pixel
= f
->output_data
.x
->border_pixel
;
2875 attributes
.bit_gravity
= StaticGravity
;
2876 attributes
.backing_store
= NotUseful
;
2877 attributes
.save_under
= True
;
2878 attributes
.event_mask
= STANDARD_EVENT_SET
;
2879 attributes
.colormap
= FRAME_X_COLORMAP (f
);
2880 attribute_mask
= (CWBackPixel
| CWBorderPixel
| CWBitGravity
| CWEventMask
2885 = XCreateWindow (FRAME_X_DISPLAY (f
),
2886 f
->output_data
.x
->parent_desc
,
2889 FRAME_PIXEL_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
),
2891 CopyFromParent
, /* depth */
2892 InputOutput
, /* class */
2894 attribute_mask
, &attributes
);
2899 create_frame_xic (f
);
2902 /* XIM server might require some X events. */
2903 unsigned long fevent
= NoEventMask
;
2904 XGetICValues(FRAME_XIC (f
), XNFilterEvents
, &fevent
, NULL
);
2905 attributes
.event_mask
|= fevent
;
2906 attribute_mask
= CWEventMask
;
2907 XChangeWindowAttributes (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2908 attribute_mask
, &attributes
);
2911 #endif /* HAVE_X_I18N */
2913 validate_x_resource_name ();
2915 class_hints
.res_name
= (char *) SDATA (Vx_resource_name
);
2916 class_hints
.res_class
= (char *) SDATA (Vx_resource_class
);
2917 XSetClassHint (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &class_hints
);
2919 /* The menubar is part of the ordinary display;
2920 it does not count in addition to the height of the window. */
2921 f
->output_data
.x
->menubar_height
= 0;
2923 /* This indicates that we use the "Passive Input" input model.
2924 Unless we do this, we don't get the Focus{In,Out} events that we
2925 need to draw the cursor correctly. Accursed bureaucrats.
2926 XWhipsAndChains (FRAME_X_DISPLAY (f), IronMaiden, &TheRack); */
2928 f
->output_data
.x
->wm_hints
.input
= True
;
2929 f
->output_data
.x
->wm_hints
.flags
|= InputHint
;
2930 XSetWMHints (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2931 &f
->output_data
.x
->wm_hints
);
2932 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
2934 /* Request "save yourself" and "delete window" commands from wm. */
2937 protocols
[0] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_delete_window
;
2938 protocols
[1] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_save_yourself
;
2939 XSetWMProtocols (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), protocols
, 2);
2942 /* x_set_name normally ignores requests to set the name if the
2943 requested name is the same as the current name. This is the one
2944 place where that assumption isn't correct; f->name is set, but
2945 the X server hasn't been told. */
2948 int explicit = f
->explicit_name
;
2950 f
->explicit_name
= 0;
2953 x_set_name (f
, name
, explicit);
2956 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2957 f
->output_data
.x
->text_cursor
);
2961 if (FRAME_X_WINDOW (f
) == 0)
2962 error ("Unable to create window");
2965 #endif /* not USE_GTK */
2966 #endif /* not USE_X_TOOLKIT */
2968 /* Handle the icon stuff for this window. Perhaps later we might
2969 want an x_set_icon_position which can be called interactively as
2977 Lisp_Object icon_x
, icon_y
;
2978 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2980 /* Set the position of the icon. Note that twm groups all
2981 icons in an icon window. */
2982 icon_x
= x_frame_get_and_record_arg (f
, parms
, Qicon_left
, 0, 0, RES_TYPE_NUMBER
);
2983 icon_y
= x_frame_get_and_record_arg (f
, parms
, Qicon_top
, 0, 0, RES_TYPE_NUMBER
);
2984 if (!EQ (icon_x
, Qunbound
) && !EQ (icon_y
, Qunbound
))
2986 CHECK_NUMBER (icon_x
);
2987 CHECK_NUMBER (icon_y
);
2989 else if (!EQ (icon_x
, Qunbound
) || !EQ (icon_y
, Qunbound
))
2990 error ("Both left and top icon corners of icon must be specified");
2994 if (! EQ (icon_x
, Qunbound
))
2995 x_wm_set_icon_position (f
, XINT (icon_x
), XINT (icon_y
));
2997 /* Start up iconic or window? */
2998 x_wm_set_window_state
2999 (f
, (EQ (x_get_arg (dpyinfo
, parms
, Qvisibility
, 0, 0, RES_TYPE_SYMBOL
),
3004 x_text_icon (f
, (char *) SDATA ((!NILP (f
->icon_name
)
3011 /* Make the GCs needed for this window, setting the
3012 background, border and mouse colors; also create the
3013 mouse cursor and the gray border tile. */
3015 static char cursor_bits
[] =
3017 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3018 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3019 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3020 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
3027 XGCValues gc_values
;
3031 /* Create the GCs of this frame.
3032 Note that many default values are used. */
3035 gc_values
.font
= FRAME_FONT (f
)->fid
;
3036 gc_values
.foreground
= f
->output_data
.x
->foreground_pixel
;
3037 gc_values
.background
= f
->output_data
.x
->background_pixel
;
3038 gc_values
.line_width
= 0; /* Means 1 using fast algorithm. */
3039 f
->output_data
.x
->normal_gc
3040 = XCreateGC (FRAME_X_DISPLAY (f
),
3042 GCLineWidth
| GCFont
| GCForeground
| GCBackground
,
3045 /* Reverse video style. */
3046 gc_values
.foreground
= f
->output_data
.x
->background_pixel
;
3047 gc_values
.background
= f
->output_data
.x
->foreground_pixel
;
3048 f
->output_data
.x
->reverse_gc
3049 = XCreateGC (FRAME_X_DISPLAY (f
),
3051 GCFont
| GCForeground
| GCBackground
| GCLineWidth
,
3054 /* Cursor has cursor-color background, background-color foreground. */
3055 gc_values
.foreground
= f
->output_data
.x
->background_pixel
;
3056 gc_values
.background
= f
->output_data
.x
->cursor_pixel
;
3057 gc_values
.fill_style
= FillOpaqueStippled
;
3059 = XCreateBitmapFromData (FRAME_X_DISPLAY (f
),
3060 FRAME_X_DISPLAY_INFO (f
)->root_window
,
3061 cursor_bits
, 16, 16);
3062 f
->output_data
.x
->cursor_gc
3063 = XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3064 (GCFont
| GCForeground
| GCBackground
3065 | GCFillStyle
/* | GCStipple */ | GCLineWidth
),
3069 f
->output_data
.x
->white_relief
.gc
= 0;
3070 f
->output_data
.x
->black_relief
.gc
= 0;
3072 /* Create the gray border tile used when the pointer is not in
3073 the frame. Since this depends on the frame's pixel values,
3074 this must be done on a per-frame basis. */
3075 f
->output_data
.x
->border_tile
3076 = (XCreatePixmapFromBitmapData
3077 (FRAME_X_DISPLAY (f
), FRAME_X_DISPLAY_INFO (f
)->root_window
,
3078 gray_bits
, gray_width
, gray_height
,
3079 f
->output_data
.x
->foreground_pixel
,
3080 f
->output_data
.x
->background_pixel
,
3081 DefaultDepth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
))));
3087 /* Free what was was allocated in x_make_gc. */
3093 Display
*dpy
= FRAME_X_DISPLAY (f
);
3097 if (f
->output_data
.x
->normal_gc
)
3099 XFreeGC (dpy
, f
->output_data
.x
->normal_gc
);
3100 f
->output_data
.x
->normal_gc
= 0;
3103 if (f
->output_data
.x
->reverse_gc
)
3105 XFreeGC (dpy
, f
->output_data
.x
->reverse_gc
);
3106 f
->output_data
.x
->reverse_gc
= 0;
3109 if (f
->output_data
.x
->cursor_gc
)
3111 XFreeGC (dpy
, f
->output_data
.x
->cursor_gc
);
3112 f
->output_data
.x
->cursor_gc
= 0;
3115 if (f
->output_data
.x
->border_tile
)
3117 XFreePixmap (dpy
, f
->output_data
.x
->border_tile
);
3118 f
->output_data
.x
->border_tile
= 0;
3125 /* Handler for signals raised during x_create_frame and
3126 x_create_top_frame. FRAME is the frame which is partially
3130 unwind_create_frame (frame
)
3133 struct frame
*f
= XFRAME (frame
);
3135 /* If frame is ``official'', nothing to do. */
3136 if (!CONSP (Vframe_list
) || !EQ (XCAR (Vframe_list
), frame
))
3139 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
3142 x_free_frame_resources (f
);
3144 /* Check that reference counts are indeed correct. */
3145 xassert (dpyinfo
->reference_count
== dpyinfo_refcount
);
3146 xassert (dpyinfo
->image_cache
->refcount
== image_cache_refcount
);
3154 DEFUN ("x-create-frame", Fx_create_frame
, Sx_create_frame
,
3156 doc
: /* Make a new X window, which is called a "frame" in Emacs terms.
3157 Returns an Emacs frame object.
3158 ALIST is an alist of frame parameters.
3159 If the parameters specify that the frame should not have a minibuffer,
3160 and do not specify a specific minibuffer window to use,
3161 then `default-minibuffer-frame' must be a frame whose minibuffer can
3162 be shared by the new frame.
3164 This function is an internal primitive--use `make-frame' instead. */)
3169 Lisp_Object frame
, tem
;
3171 int minibuffer_only
= 0;
3172 long window_prompting
= 0;
3174 int count
= SPECPDL_INDEX ();
3175 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
3176 Lisp_Object display
;
3177 struct x_display_info
*dpyinfo
= NULL
;
3183 /* Use this general default value to start with
3184 until we know if this frame has a specified name. */
3185 Vx_resource_name
= Vinvocation_name
;
3187 display
= x_get_arg (dpyinfo
, parms
, Qdisplay
, 0, 0, RES_TYPE_STRING
);
3188 if (EQ (display
, Qunbound
))
3190 dpyinfo
= check_x_display_info (display
);
3192 kb
= dpyinfo
->kboard
;
3194 kb
= &the_only_kboard
;
3197 name
= x_get_arg (dpyinfo
, parms
, Qname
, "name", "Name", RES_TYPE_STRING
);
3199 && ! EQ (name
, Qunbound
)
3201 error ("Invalid frame name--not a string or nil");
3204 Vx_resource_name
= name
;
3206 /* See if parent window is specified. */
3207 parent
= x_get_arg (dpyinfo
, parms
, Qparent_id
, NULL
, NULL
, RES_TYPE_NUMBER
);
3208 if (EQ (parent
, Qunbound
))
3210 if (! NILP (parent
))
3211 CHECK_NUMBER (parent
);
3213 /* make_frame_without_minibuffer can run Lisp code and garbage collect. */
3214 /* No need to protect DISPLAY because that's not used after passing
3215 it to make_frame_without_minibuffer. */
3217 GCPRO4 (parms
, parent
, name
, frame
);
3218 tem
= x_get_arg (dpyinfo
, parms
, Qminibuffer
, "minibuffer", "Minibuffer",
3220 if (EQ (tem
, Qnone
) || NILP (tem
))
3221 f
= make_frame_without_minibuffer (Qnil
, kb
, display
);
3222 else if (EQ (tem
, Qonly
))
3224 f
= make_minibuffer_frame ();
3225 minibuffer_only
= 1;
3227 else if (WINDOWP (tem
))
3228 f
= make_frame_without_minibuffer (tem
, kb
, display
);
3232 XSETFRAME (frame
, f
);
3234 /* Note that X Windows does support scroll bars. */
3235 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 1;
3237 f
->output_method
= output_x_window
;
3238 f
->output_data
.x
= (struct x_output
*) xmalloc (sizeof (struct x_output
));
3239 bzero (f
->output_data
.x
, sizeof (struct x_output
));
3240 f
->output_data
.x
->icon_bitmap
= -1;
3241 FRAME_FONTSET (f
) = -1;
3242 f
->output_data
.x
->scroll_bar_foreground_pixel
= -1;
3243 f
->output_data
.x
->scroll_bar_background_pixel
= -1;
3244 #ifdef USE_TOOLKIT_SCROLL_BARS
3245 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= -1;
3246 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= -1;
3247 #endif /* USE_TOOLKIT_SCROLL_BARS */
3248 record_unwind_protect (unwind_create_frame
, frame
);
3251 = x_get_arg (dpyinfo
, parms
, Qicon_name
, "iconName", "Title",
3253 if (! STRINGP (f
->icon_name
))
3254 f
->icon_name
= Qnil
;
3256 FRAME_X_DISPLAY_INFO (f
) = dpyinfo
;
3258 image_cache_refcount
= FRAME_X_IMAGE_CACHE (f
)->refcount
;
3259 dpyinfo_refcount
= dpyinfo
->reference_count
;
3260 #endif /* GLYPH_DEBUG */
3262 FRAME_KBOARD (f
) = kb
;
3265 /* These colors will be set anyway later, but it's important
3266 to get the color reference counts right, so initialize them! */
3269 struct gcpro gcpro1
;
3271 /* Function x_decode_color can signal an error. Make
3272 sure to initialize color slots so that we won't try
3273 to free colors we haven't allocated. */
3274 f
->output_data
.x
->foreground_pixel
= -1;
3275 f
->output_data
.x
->background_pixel
= -1;
3276 f
->output_data
.x
->cursor_pixel
= -1;
3277 f
->output_data
.x
->cursor_foreground_pixel
= -1;
3278 f
->output_data
.x
->border_pixel
= -1;
3279 f
->output_data
.x
->mouse_pixel
= -1;
3281 black
= build_string ("black");
3283 f
->output_data
.x
->foreground_pixel
3284 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3285 f
->output_data
.x
->background_pixel
3286 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3287 f
->output_data
.x
->cursor_pixel
3288 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3289 f
->output_data
.x
->cursor_foreground_pixel
3290 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3291 f
->output_data
.x
->border_pixel
3292 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3293 f
->output_data
.x
->mouse_pixel
3294 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3298 /* Specify the parent under which to make this X window. */
3302 f
->output_data
.x
->parent_desc
= (Window
) XFASTINT (parent
);
3303 f
->output_data
.x
->explicit_parent
= 1;
3307 f
->output_data
.x
->parent_desc
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
3308 f
->output_data
.x
->explicit_parent
= 0;
3311 /* Set the name; the functions to which we pass f expect the name to
3313 if (EQ (name
, Qunbound
) || NILP (name
))
3315 f
->name
= build_string (dpyinfo
->x_id_name
);
3316 f
->explicit_name
= 0;
3321 f
->explicit_name
= 1;
3322 /* use the frame's title when getting resources for this frame. */
3323 specbind (Qx_resource_name
, name
);
3326 /* Extract the window parameters from the supplied values
3327 that are needed to determine window geometry. */
3331 font
= x_get_arg (dpyinfo
, parms
, Qfont
, "font", "Font", RES_TYPE_STRING
);
3334 /* First, try whatever font the caller has specified. */
3337 tem
= Fquery_fontset (font
, Qnil
);
3339 font
= x_new_fontset (f
, SDATA (tem
));
3341 font
= x_new_font (f
, SDATA (font
));
3344 /* Try out a font which we hope has bold and italic variations. */
3345 if (!STRINGP (font
))
3346 font
= x_new_font (f
, "-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1");
3347 if (!STRINGP (font
))
3348 font
= x_new_font (f
, "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
3349 if (! STRINGP (font
))
3350 font
= x_new_font (f
, "-*-*-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
3351 if (! STRINGP (font
))
3352 /* This was formerly the first thing tried, but it finds too many fonts
3353 and takes too long. */
3354 font
= x_new_font (f
, "-*-*-medium-r-*-*-*-*-*-*-c-*-iso8859-1");
3355 /* If those didn't work, look for something which will at least work. */
3356 if (! STRINGP (font
))
3357 font
= x_new_font (f
, "-*-fixed-*-*-*-*-*-140-*-*-c-*-iso8859-1");
3359 if (! STRINGP (font
))
3360 font
= build_string ("fixed");
3362 x_default_parameter (f
, parms
, Qfont
, font
,
3363 "font", "Font", RES_TYPE_STRING
);
3367 /* Prevent lwlib/xlwmenu.c from crashing because of a bug
3368 whereby it fails to get any font. */
3369 xlwmenu_default_font
= FRAME_FONT (f
);
3372 x_default_parameter (f
, parms
, Qborder_width
, make_number (2),
3373 "borderWidth", "BorderWidth", RES_TYPE_NUMBER
);
3375 /* This defaults to 1 in order to match xterm. We recognize either
3376 internalBorderWidth or internalBorder (which is what xterm calls
3378 if (NILP (Fassq (Qinternal_border_width
, parms
)))
3382 value
= x_get_arg (dpyinfo
, parms
, Qinternal_border_width
,
3383 "internalBorder", "internalBorder", RES_TYPE_NUMBER
);
3384 if (! EQ (value
, Qunbound
))
3385 parms
= Fcons (Fcons (Qinternal_border_width
, value
),
3388 x_default_parameter (f
, parms
, Qinternal_border_width
, make_number (1),
3389 "internalBorderWidth", "internalBorderWidth",
3391 x_default_parameter (f
, parms
, Qvertical_scroll_bars
, Qleft
,
3392 "verticalScrollBars", "ScrollBars",
3395 /* Also do the stuff which must be set before the window exists. */
3396 x_default_parameter (f
, parms
, Qforeground_color
, build_string ("black"),
3397 "foreground", "Foreground", RES_TYPE_STRING
);
3398 x_default_parameter (f
, parms
, Qbackground_color
, build_string ("white"),
3399 "background", "Background", RES_TYPE_STRING
);
3400 x_default_parameter (f
, parms
, Qmouse_color
, build_string ("black"),
3401 "pointerColor", "Foreground", RES_TYPE_STRING
);
3402 x_default_parameter (f
, parms
, Qcursor_color
, build_string ("black"),
3403 "cursorColor", "Foreground", RES_TYPE_STRING
);
3404 x_default_parameter (f
, parms
, Qborder_color
, build_string ("black"),
3405 "borderColor", "BorderColor", RES_TYPE_STRING
);
3406 x_default_parameter (f
, parms
, Qscreen_gamma
, Qnil
,
3407 "screenGamma", "ScreenGamma", RES_TYPE_FLOAT
);
3408 x_default_parameter (f
, parms
, Qline_spacing
, Qnil
,
3409 "lineSpacing", "LineSpacing", RES_TYPE_NUMBER
);
3410 x_default_parameter (f
, parms
, Qleft_fringe
, Qnil
,
3411 "leftFringe", "LeftFringe", RES_TYPE_NUMBER
);
3412 x_default_parameter (f
, parms
, Qright_fringe
, Qnil
,
3413 "rightFringe", "RightFringe", RES_TYPE_NUMBER
);
3415 x_default_scroll_bar_color_parameter (f
, parms
, Qscroll_bar_foreground
,
3416 "scrollBarForeground",
3417 "ScrollBarForeground", 1);
3418 x_default_scroll_bar_color_parameter (f
, parms
, Qscroll_bar_background
,
3419 "scrollBarBackground",
3420 "ScrollBarBackground", 0);
3422 /* Init faces before x_default_parameter is called for scroll-bar
3423 parameters because that function calls x_set_scroll_bar_width,
3424 which calls change_frame_size, which calls Fset_window_buffer,
3425 which runs hooks, which call Fvertical_motion. At the end, we
3426 end up in init_iterator with a null face cache, which should not
3428 init_frame_faces (f
);
3430 x_default_parameter (f
, parms
, Qmenu_bar_lines
, make_number (1),
3431 "menuBar", "MenuBar", RES_TYPE_NUMBER
);
3432 x_default_parameter (f
, parms
, Qtool_bar_lines
, make_number (1),
3433 "toolBar", "ToolBar", RES_TYPE_NUMBER
);
3434 x_default_parameter (f
, parms
, Qbuffer_predicate
, Qnil
,
3435 "bufferPredicate", "BufferPredicate",
3437 x_default_parameter (f
, parms
, Qtitle
, Qnil
,
3438 "title", "Title", RES_TYPE_STRING
);
3439 x_default_parameter (f
, parms
, Qwait_for_wm
, Qt
,
3440 "waitForWM", "WaitForWM", RES_TYPE_BOOLEAN
);
3441 x_default_parameter (f
, parms
, Qfullscreen
, Qnil
,
3442 "fullscreen", "Fullscreen", RES_TYPE_SYMBOL
);
3444 f
->output_data
.x
->parent_desc
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
3446 /* Compute the size of the X window. */
3447 window_prompting
= x_figure_window_size (f
, parms
, 1);
3449 tem
= x_get_arg (dpyinfo
, parms
, Qunsplittable
, 0, 0, RES_TYPE_BOOLEAN
);
3450 f
->no_split
= minibuffer_only
|| EQ (tem
, Qt
);
3452 /* Create the X widget or window. */
3453 #ifdef USE_X_TOOLKIT
3454 x_window (f
, window_prompting
, minibuffer_only
);
3462 /* Now consider the frame official. */
3463 FRAME_X_DISPLAY_INFO (f
)->reference_count
++;
3464 Vframe_list
= Fcons (frame
, Vframe_list
);
3466 /* We need to do this after creating the X window, so that the
3467 icon-creation functions can say whose icon they're describing. */
3468 x_default_parameter (f
, parms
, Qicon_type
, Qnil
,
3469 "bitmapIcon", "BitmapIcon", RES_TYPE_SYMBOL
);
3471 x_default_parameter (f
, parms
, Qauto_raise
, Qnil
,
3472 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
3473 x_default_parameter (f
, parms
, Qauto_lower
, Qnil
,
3474 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
3475 x_default_parameter (f
, parms
, Qcursor_type
, Qbox
,
3476 "cursorType", "CursorType", RES_TYPE_SYMBOL
);
3477 x_default_parameter (f
, parms
, Qscroll_bar_width
, Qnil
,
3478 "scrollBarWidth", "ScrollBarWidth",
3481 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
3482 Change will not be effected unless different from the current
3484 width
= FRAME_COLS (f
);
3485 height
= FRAME_LINES (f
);
3487 SET_FRAME_COLS (f
, 0);
3488 FRAME_LINES (f
) = 0;
3489 change_frame_size (f
, height
, width
, 1, 0, 0);
3491 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
3492 /* Create the menu bar. */
3493 if (!minibuffer_only
&& FRAME_EXTERNAL_MENU_BAR (f
))
3495 /* If this signals an error, we haven't set size hints for the
3496 frame and we didn't make it visible. */
3497 initialize_frame_menubar (f
);
3500 /* This is a no-op, except under Motif where it arranges the
3501 main window for the widgets on it. */
3502 lw_set_main_areas (f
->output_data
.x
->column_widget
,
3503 f
->output_data
.x
->menubar_widget
,
3504 f
->output_data
.x
->edit_widget
);
3505 #endif /* not USE_GTK */
3507 #endif /* USE_X_TOOLKIT || USE_GTK */
3509 /* Tell the server what size and position, etc, we want, and how
3510 badly we want them. This should be done after we have the menu
3511 bar so that its size can be taken into account. */
3513 x_wm_set_size_hint (f
, window_prompting
, 0);
3516 /* Make the window appear on the frame and enable display, unless
3517 the caller says not to. However, with explicit parent, Emacs
3518 cannot control visibility, so don't try. */
3519 if (! f
->output_data
.x
->explicit_parent
)
3521 Lisp_Object visibility
;
3523 visibility
= x_get_arg (dpyinfo
, parms
, Qvisibility
, 0, 0,
3525 if (EQ (visibility
, Qunbound
))
3528 if (EQ (visibility
, Qicon
))
3529 x_iconify_frame (f
);
3530 else if (! NILP (visibility
))
3531 x_make_frame_visible (f
);
3533 /* Must have been Qnil. */
3537 /* Set the WM leader property. GTK does this itself, so this is not
3538 needed when using GTK. */
3539 if (dpyinfo
->client_leader_window
!= 0)
3542 XChangeProperty (FRAME_X_DISPLAY (f
),
3543 FRAME_OUTER_WINDOW (f
),
3544 dpyinfo
->Xatom_wm_client_leader
,
3545 XA_WINDOW
, 32, PropModeReplace
,
3546 (char *) &dpyinfo
->client_leader_window
, 1);
3552 /* Make sure windows on this frame appear in calls to next-window
3553 and similar functions. */
3554 Vwindow_list
= Qnil
;
3556 return unbind_to (count
, frame
);
3560 /* FRAME is used only to get a handle on the X display. We don't pass the
3561 display info directly because we're called from frame.c, which doesn't
3562 know about that structure. */
3565 x_get_focus_frame (frame
)
3566 struct frame
*frame
;
3568 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (frame
);
3570 if (! dpyinfo
->x_focus_frame
)
3573 XSETFRAME (xfocus
, dpyinfo
->x_focus_frame
);
3578 /* In certain situations, when the window manager follows a
3579 click-to-focus policy, there seems to be no way around calling
3580 XSetInputFocus to give another frame the input focus .
3582 In an ideal world, XSetInputFocus should generally be avoided so
3583 that applications don't interfere with the window manager's focus
3584 policy. But I think it's okay to use when it's clearly done
3585 following a user-command. */
3587 DEFUN ("x-focus-frame", Fx_focus_frame
, Sx_focus_frame
, 1, 1, 0,
3588 doc
: /* Set the input focus to FRAME.
3589 FRAME nil means use the selected frame. */)
3593 struct frame
*f
= check_x_frame (frame
);
3594 Display
*dpy
= FRAME_X_DISPLAY (f
);
3598 count
= x_catch_errors (dpy
);
3599 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3600 RevertToParent
, CurrentTime
);
3601 x_uncatch_errors (dpy
, count
);
3608 DEFUN ("xw-color-defined-p", Fxw_color_defined_p
, Sxw_color_defined_p
, 1, 2, 0,
3609 doc
: /* Internal function called by `color-defined-p', which see. */)
3611 Lisp_Object color
, frame
;
3614 FRAME_PTR f
= check_x_frame (frame
);
3616 CHECK_STRING (color
);
3618 if (x_defined_color (f
, SDATA (color
), &foo
, 0))
3624 DEFUN ("xw-color-values", Fxw_color_values
, Sxw_color_values
, 1, 2, 0,
3625 doc
: /* Internal function called by `color-values', which see. */)
3627 Lisp_Object color
, frame
;
3630 FRAME_PTR f
= check_x_frame (frame
);
3632 CHECK_STRING (color
);
3634 if (x_defined_color (f
, SDATA (color
), &foo
, 0))
3638 rgb
[0] = make_number (foo
.red
);
3639 rgb
[1] = make_number (foo
.green
);
3640 rgb
[2] = make_number (foo
.blue
);
3641 return Flist (3, rgb
);
3647 DEFUN ("xw-display-color-p", Fxw_display_color_p
, Sxw_display_color_p
, 0, 1, 0,
3648 doc
: /* Internal function called by `display-color-p', which see. */)
3650 Lisp_Object display
;
3652 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3654 if (dpyinfo
->n_planes
<= 2)
3657 switch (dpyinfo
->visual
->class)
3670 DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p
, Sx_display_grayscale_p
,
3672 doc
: /* Return t if the X display supports shades of gray.
3673 Note that color displays do support shades of gray.
3674 The optional argument DISPLAY specifies which display to ask about.
3675 DISPLAY should be either a frame or a display name (a string).
3676 If omitted or nil, that stands for the selected frame's display. */)
3678 Lisp_Object display
;
3680 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3682 if (dpyinfo
->n_planes
<= 1)
3685 switch (dpyinfo
->visual
->class)
3700 DEFUN ("x-display-pixel-width", Fx_display_pixel_width
, Sx_display_pixel_width
,
3702 doc
: /* Returns the width in pixels of the X display DISPLAY.
3703 The optional argument DISPLAY specifies which display to ask about.
3704 DISPLAY should be either a frame or a display name (a string).
3705 If omitted or nil, that stands for the selected frame's display. */)
3707 Lisp_Object display
;
3709 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3711 return make_number (dpyinfo
->width
);
3714 DEFUN ("x-display-pixel-height", Fx_display_pixel_height
,
3715 Sx_display_pixel_height
, 0, 1, 0,
3716 doc
: /* Returns the height in pixels of the X display DISPLAY.
3717 The optional argument DISPLAY specifies which display to ask about.
3718 DISPLAY should be either a frame or a display name (a string).
3719 If omitted or nil, that stands for the selected frame's display. */)
3721 Lisp_Object display
;
3723 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3725 return make_number (dpyinfo
->height
);
3728 DEFUN ("x-display-planes", Fx_display_planes
, Sx_display_planes
,
3730 doc
: /* Returns the number of bitplanes of the X display DISPLAY.
3731 The optional argument DISPLAY specifies which display to ask about.
3732 DISPLAY should be either a frame or a display name (a string).
3733 If omitted or nil, that stands for the selected frame's display. */)
3735 Lisp_Object display
;
3737 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3739 return make_number (dpyinfo
->n_planes
);
3742 DEFUN ("x-display-color-cells", Fx_display_color_cells
, Sx_display_color_cells
,
3744 doc
: /* Returns the number of color cells of the X display DISPLAY.
3745 The optional argument DISPLAY specifies which display to ask about.
3746 DISPLAY should be either a frame or a display name (a string).
3747 If omitted or nil, that stands for the selected frame's display. */)
3749 Lisp_Object display
;
3751 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3753 return make_number (DisplayCells (dpyinfo
->display
,
3754 XScreenNumberOfScreen (dpyinfo
->screen
)));
3757 DEFUN ("x-server-max-request-size", Fx_server_max_request_size
,
3758 Sx_server_max_request_size
,
3760 doc
: /* Returns the maximum request size of the X server of display DISPLAY.
3761 The optional argument DISPLAY specifies which display to ask about.
3762 DISPLAY should be either a frame or a display name (a string).
3763 If omitted or nil, that stands for the selected frame's display. */)
3765 Lisp_Object display
;
3767 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3769 return make_number (MAXREQUEST (dpyinfo
->display
));
3772 DEFUN ("x-server-vendor", Fx_server_vendor
, Sx_server_vendor
, 0, 1, 0,
3773 doc
: /* Returns the vendor ID string of the X server of display DISPLAY.
3774 The optional argument DISPLAY specifies which display to ask about.
3775 DISPLAY should be either a frame or a display name (a string).
3776 If omitted or nil, that stands for the selected frame's display. */)
3778 Lisp_Object display
;
3780 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3781 char *vendor
= ServerVendor (dpyinfo
->display
);
3783 if (! vendor
) vendor
= "";
3784 return build_string (vendor
);
3787 DEFUN ("x-server-version", Fx_server_version
, Sx_server_version
, 0, 1, 0,
3788 doc
: /* Returns the version numbers of the X server of display DISPLAY.
3789 The value is a list of three integers: the major and minor
3790 version numbers of the X Protocol in use, and the vendor-specific release
3791 number. See also the function `x-server-vendor'.
3793 The optional argument DISPLAY specifies which display to ask about.
3794 DISPLAY should be either a frame or a display name (a string).
3795 If omitted or nil, that stands for the selected frame's display. */)
3797 Lisp_Object display
;
3799 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3800 Display
*dpy
= dpyinfo
->display
;
3802 return Fcons (make_number (ProtocolVersion (dpy
)),
3803 Fcons (make_number (ProtocolRevision (dpy
)),
3804 Fcons (make_number (VendorRelease (dpy
)), Qnil
)));
3807 DEFUN ("x-display-screens", Fx_display_screens
, Sx_display_screens
, 0, 1, 0,
3808 doc
: /* Return the number of screens on the X server of display DISPLAY.
3809 The optional argument DISPLAY specifies which display to ask about.
3810 DISPLAY should be either a frame or a display name (a string).
3811 If omitted or nil, that stands for the selected frame's display. */)
3813 Lisp_Object display
;
3815 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3817 return make_number (ScreenCount (dpyinfo
->display
));
3820 DEFUN ("x-display-mm-height", Fx_display_mm_height
, Sx_display_mm_height
, 0, 1, 0,
3821 doc
: /* Return the height in millimeters of the X display DISPLAY.
3822 The optional argument DISPLAY specifies which display to ask about.
3823 DISPLAY should be either a frame or a display name (a string).
3824 If omitted or nil, that stands for the selected frame's display. */)
3826 Lisp_Object display
;
3828 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3830 return make_number (HeightMMOfScreen (dpyinfo
->screen
));
3833 DEFUN ("x-display-mm-width", Fx_display_mm_width
, Sx_display_mm_width
, 0, 1, 0,
3834 doc
: /* Return the width in millimeters of the X display DISPLAY.
3835 The optional argument DISPLAY specifies which display to ask about.
3836 DISPLAY should be either a frame or a display name (a string).
3837 If omitted or nil, that stands for the selected frame's display. */)
3839 Lisp_Object display
;
3841 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3843 return make_number (WidthMMOfScreen (dpyinfo
->screen
));
3846 DEFUN ("x-display-backing-store", Fx_display_backing_store
,
3847 Sx_display_backing_store
, 0, 1, 0,
3848 doc
: /* Returns an indication of whether X display DISPLAY does backing store.
3849 The value may be `always', `when-mapped', or `not-useful'.
3850 The optional argument DISPLAY specifies which display to ask about.
3851 DISPLAY should be either a frame or a display name (a string).
3852 If omitted or nil, that stands for the selected frame's display. */)
3854 Lisp_Object display
;
3856 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3859 switch (DoesBackingStore (dpyinfo
->screen
))
3862 result
= intern ("always");
3866 result
= intern ("when-mapped");
3870 result
= intern ("not-useful");
3874 error ("Strange value for BackingStore parameter of screen");
3881 DEFUN ("x-display-visual-class", Fx_display_visual_class
,
3882 Sx_display_visual_class
, 0, 1, 0,
3883 doc
: /* Return the visual class of the X display DISPLAY.
3884 The value is one of the symbols `static-gray', `gray-scale',
3885 `static-color', `pseudo-color', `true-color', or `direct-color'.
3887 The optional argument DISPLAY specifies which display to ask about.
3888 DISPLAY should be either a frame or a display name (a string).
3889 If omitted or nil, that stands for the selected frame's display. */)
3891 Lisp_Object display
;
3893 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3896 switch (dpyinfo
->visual
->class)
3899 result
= intern ("static-gray");
3902 result
= intern ("gray-scale");
3905 result
= intern ("static-color");
3908 result
= intern ("pseudo-color");
3911 result
= intern ("true-color");
3914 result
= intern ("direct-color");
3917 error ("Display has an unknown visual class");
3924 DEFUN ("x-display-save-under", Fx_display_save_under
,
3925 Sx_display_save_under
, 0, 1, 0,
3926 doc
: /* Returns t if the X display DISPLAY supports the save-under feature.
3927 The optional argument DISPLAY specifies which display to ask about.
3928 DISPLAY should be either a frame or a display name (a string).
3929 If omitted or nil, that stands for the selected frame's display. */)
3931 Lisp_Object display
;
3933 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3935 if (DoesSaveUnders (dpyinfo
->screen
) == True
)
3943 register struct frame
*f
;
3945 return FRAME_PIXEL_WIDTH (f
);
3950 register struct frame
*f
;
3952 return FRAME_PIXEL_HEIGHT (f
);
3957 register struct frame
*f
;
3959 return FRAME_COLUMN_WIDTH (f
);
3964 register struct frame
*f
;
3966 return FRAME_LINE_HEIGHT (f
);
3971 register struct frame
*f
;
3973 return FRAME_X_DISPLAY_INFO (f
)->n_planes
;
3978 /************************************************************************
3980 ************************************************************************/
3983 /* Mapping visual names to visuals. */
3985 static struct visual_class
3992 {"StaticGray", StaticGray
},
3993 {"GrayScale", GrayScale
},
3994 {"StaticColor", StaticColor
},
3995 {"PseudoColor", PseudoColor
},
3996 {"TrueColor", TrueColor
},
3997 {"DirectColor", DirectColor
},
4002 #ifndef HAVE_XSCREENNUMBEROFSCREEN
4004 /* Value is the screen number of screen SCR. This is a substitute for
4005 the X function with the same name when that doesn't exist. */
4008 XScreenNumberOfScreen (scr
)
4009 register Screen
*scr
;
4011 Display
*dpy
= scr
->display
;
4014 for (i
= 0; i
< dpy
->nscreens
; ++i
)
4015 if (scr
== dpy
->screens
+ i
)
4021 #endif /* not HAVE_XSCREENNUMBEROFSCREEN */
4024 /* Select the visual that should be used on display DPYINFO. Set
4025 members of DPYINFO appropriately. Called from x_term_init. */
4028 select_visual (dpyinfo
)
4029 struct x_display_info
*dpyinfo
;
4031 Display
*dpy
= dpyinfo
->display
;
4032 Screen
*screen
= dpyinfo
->screen
;
4035 /* See if a visual is specified. */
4036 value
= display_x_get_resource (dpyinfo
,
4037 build_string ("visualClass"),
4038 build_string ("VisualClass"),
4040 if (STRINGP (value
))
4042 /* VALUE should be of the form CLASS-DEPTH, where CLASS is one
4043 of `PseudoColor', `TrueColor' etc. and DEPTH is the color
4044 depth, a decimal number. NAME is compared with case ignored. */
4045 char *s
= (char *) alloca (SBYTES (value
) + 1);
4050 strcpy (s
, SDATA (value
));
4051 dash
= index (s
, '-');
4054 dpyinfo
->n_planes
= atoi (dash
+ 1);
4058 /* We won't find a matching visual with depth 0, so that
4059 an error will be printed below. */
4060 dpyinfo
->n_planes
= 0;
4062 /* Determine the visual class. */
4063 for (i
= 0; visual_classes
[i
].name
; ++i
)
4064 if (xstricmp (s
, visual_classes
[i
].name
) == 0)
4066 class = visual_classes
[i
].class;
4070 /* Look up a matching visual for the specified class. */
4072 || !XMatchVisualInfo (dpy
, XScreenNumberOfScreen (screen
),
4073 dpyinfo
->n_planes
, class, &vinfo
))
4074 fatal ("Invalid visual specification `%s'", SDATA (value
));
4076 dpyinfo
->visual
= vinfo
.visual
;
4081 XVisualInfo
*vinfo
, vinfo_template
;
4083 dpyinfo
->visual
= DefaultVisualOfScreen (screen
);
4086 vinfo_template
.visualid
= XVisualIDFromVisual (dpyinfo
->visual
);
4088 vinfo_template
.visualid
= dpyinfo
->visual
->visualid
;
4090 vinfo_template
.screen
= XScreenNumberOfScreen (screen
);
4091 vinfo
= XGetVisualInfo (dpy
, VisualIDMask
| VisualScreenMask
,
4092 &vinfo_template
, &n_visuals
);
4094 fatal ("Can't get proper X visual info");
4096 dpyinfo
->n_planes
= vinfo
->depth
;
4097 XFree ((char *) vinfo
);
4102 /* Return the X display structure for the display named NAME.
4103 Open a new connection if necessary. */
4105 struct x_display_info
*
4106 x_display_info_for_name (name
)
4110 struct x_display_info
*dpyinfo
;
4112 CHECK_STRING (name
);
4114 if (! EQ (Vwindow_system
, intern ("x")))
4115 error ("Not using X Windows");
4117 for (dpyinfo
= x_display_list
, names
= x_display_name_list
;
4119 dpyinfo
= dpyinfo
->next
, names
= XCDR (names
))
4122 tem
= Fstring_equal (XCAR (XCAR (names
)), name
);
4127 /* Use this general default value to start with. */
4128 Vx_resource_name
= Vinvocation_name
;
4130 validate_x_resource_name ();
4132 dpyinfo
= x_term_init (name
, (char *)0,
4133 (char *) SDATA (Vx_resource_name
));
4136 error ("Cannot connect to X server %s", SDATA (name
));
4139 XSETFASTINT (Vwindow_system_version
, 11);
4145 DEFUN ("x-open-connection", Fx_open_connection
, Sx_open_connection
,
4147 doc
: /* Open a connection to an X server.
4148 DISPLAY is the name of the display to connect to.
4149 Optional second arg XRM-STRING is a string of resources in xrdb format.
4150 If the optional third arg MUST-SUCCEED is non-nil,
4151 terminate Emacs if we can't open the connection. */)
4152 (display
, xrm_string
, must_succeed
)
4153 Lisp_Object display
, xrm_string
, must_succeed
;
4155 unsigned char *xrm_option
;
4156 struct x_display_info
*dpyinfo
;
4158 CHECK_STRING (display
);
4159 if (! NILP (xrm_string
))
4160 CHECK_STRING (xrm_string
);
4162 if (! EQ (Vwindow_system
, intern ("x")))
4163 error ("Not using X Windows");
4165 if (! NILP (xrm_string
))
4166 xrm_option
= (unsigned char *) SDATA (xrm_string
);
4168 xrm_option
= (unsigned char *) 0;
4170 validate_x_resource_name ();
4172 /* This is what opens the connection and sets x_current_display.
4173 This also initializes many symbols, such as those used for input. */
4174 dpyinfo
= x_term_init (display
, xrm_option
,
4175 (char *) SDATA (Vx_resource_name
));
4179 if (!NILP (must_succeed
))
4180 fatal ("Cannot connect to X server %s.\n\
4181 Check the DISPLAY environment variable or use `-d'.\n\
4182 Also use the `xauth' program to verify that you have the proper\n\
4183 authorization information needed to connect the X server.\n\
4184 An insecure way to solve the problem may be to use `xhost'.\n",
4187 error ("Cannot connect to X server %s", SDATA (display
));
4192 XSETFASTINT (Vwindow_system_version
, 11);
4196 DEFUN ("x-close-connection", Fx_close_connection
,
4197 Sx_close_connection
, 1, 1, 0,
4198 doc
: /* Close the connection to DISPLAY's X server.
4199 For DISPLAY, specify either a frame or a display name (a string).
4200 If DISPLAY is nil, that stands for the selected frame's display. */)
4202 Lisp_Object display
;
4204 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
4207 if (dpyinfo
->reference_count
> 0)
4208 error ("Display still has frames on it");
4211 /* Free the fonts in the font table. */
4212 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
4213 if (dpyinfo
->font_table
[i
].name
)
4215 XFreeFont (dpyinfo
->display
, dpyinfo
->font_table
[i
].font
);
4218 x_destroy_all_bitmaps (dpyinfo
);
4219 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
4221 #ifdef USE_X_TOOLKIT
4222 XtCloseDisplay (dpyinfo
->display
);
4224 XCloseDisplay (dpyinfo
->display
);
4227 x_delete_display (dpyinfo
);
4233 DEFUN ("x-display-list", Fx_display_list
, Sx_display_list
, 0, 0, 0,
4234 doc
: /* Return the list of display names that Emacs has connections to. */)
4237 Lisp_Object tail
, result
;
4240 for (tail
= x_display_name_list
; ! NILP (tail
); tail
= XCDR (tail
))
4241 result
= Fcons (XCAR (XCAR (tail
)), result
);
4246 DEFUN ("x-synchronize", Fx_synchronize
, Sx_synchronize
, 1, 2, 0,
4247 doc
: /* If ON is non-nil, report X errors as soon as the erring request is made.
4248 If ON is nil, allow buffering of requests.
4249 Turning on synchronization prohibits the Xlib routines from buffering
4250 requests and seriously degrades performance, but makes debugging much
4252 The optional second argument DISPLAY specifies which display to act on.
4253 DISPLAY should be either a frame or a display name (a string).
4254 If DISPLAY is omitted or nil, that stands for the selected frame's display. */)
4256 Lisp_Object display
, on
;
4258 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
4260 XSynchronize (dpyinfo
->display
, !EQ (on
, Qnil
));
4265 /* Wait for responses to all X commands issued so far for frame F. */
4272 XSync (FRAME_X_DISPLAY (f
), False
);
4277 /***********************************************************************
4278 General X functions exposed to Elisp.
4279 ***********************************************************************/
4281 DEFUN ("x-send-client-message", Fx_send_client_event
,
4282 Sx_send_client_message
, 6, 6, 0,
4283 doc
: /* Send a client message of MESSAGE-TYPE to window DEST on DISPLAY.
4285 For DISPLAY, specify either a frame or a display name (a string).
4286 If DISPLAY is nil, that stands for the selected frame's display.
4287 DEST may be an integer, in which case it is a Window id. The value 0 may
4288 be used to send to the root window of the DISPLAY.
4289 If DEST is a frame the event is sent to the outer window of that frame.
4290 Nil means the currently selected frame.
4291 If DEST is the string "PointerWindow" the event is sent to the window that
4292 contains the pointer. If DEST is the string "InputFocus" the event is
4293 sent to the window that has the input focus.
4294 FROM is the frame sending the event. Use nil for currently selected frame.
4295 MESSAGE-TYPE is the name of an Atom as a string.
4296 FORMAT must be one of 8, 16 or 32 and determines the size of the values in
4297 bits. VALUES is a list of integer and/or strings containing the values to
4298 send. If a value is a string, it is converted to an Atom and the value of
4299 the Atom is sent. If more values than fits into the event is given,
4300 the excessive values are ignored. */)
4301 (display
, dest
, from
, message_type
, format
, values
)
4302 Lisp_Object display
, dest
, from
, message_type
, format
, values
;
4304 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
4309 int max_nr_values
= (int) sizeof (event
.xclient
.data
.b
);
4310 struct frame
*f
= check_x_frame (from
);
4312 CHECK_STRING (message_type
);
4313 CHECK_NUMBER (format
);
4314 CHECK_CONS (values
);
4316 for (cons
= values
; CONSP (cons
); cons
= XCDR (cons
))
4318 Lisp_Object o
= XCAR (cons
);
4320 if (! INTEGERP (o
) && ! STRINGP (o
))
4321 error ("Bad data in VALUES, must be integer or string");
4324 event
.xclient
.type
= ClientMessage
;
4325 event
.xclient
.format
= XFASTINT (format
);
4327 if (event
.xclient
.format
!= 8 && event
.xclient
.format
!= 16
4328 && event
.xclient
.format
!= 32)
4329 error ("FORMAT must be one of 8, 16 or 32");
4330 if (event
.xclient
.format
== 16) max_nr_values
/= 2;
4331 if (event
.xclient
.format
== 32) max_nr_values
/= 4;
4333 if (FRAMEP (dest
) || NILP (dest
))
4335 struct frame
*fdest
= check_x_frame (dest
);
4336 wdest
= FRAME_OUTER_WINDOW (fdest
);
4338 else if (STRINGP (dest
))
4340 if (strcmp (SDATA (dest
), "PointerWindow") == 0)
4341 wdest
= PointerWindow
;
4342 else if (strcmp (SDATA (dest
), "InputFocus") == 0)
4345 error ("DEST as a string must be one of PointerWindow or InputFocus");
4349 CHECK_NUMBER (dest
);
4350 wdest
= (Window
) XFASTINT (dest
);
4351 if (wdest
== 0) wdest
= dpyinfo
->root_window
;
4355 for (cons
= values
, i
= 0;
4356 CONSP (cons
) && i
< max_nr_values
;
4357 cons
= XCDR (cons
), ++i
)
4359 Lisp_Object o
= XCAR (cons
);
4365 else if (STRINGP (o
))
4366 val
= XInternAtom (dpyinfo
->display
, s
= SDATA (o
), False
);
4368 if (event
.xclient
.format
== 8)
4369 event
.xclient
.data
.b
[i
] = (char) val
;
4370 else if (event
.xclient
.format
== 16)
4371 event
.xclient
.data
.s
[i
] = (short) val
;
4373 event
.xclient
.data
.l
[i
] = val
;
4376 for ( ; i
< max_nr_values
; ++i
)
4377 if (event
.xclient
.format
== 8)
4378 event
.xclient
.data
.b
[i
] = 0;
4379 else if (event
.xclient
.format
== 16)
4380 event
.xclient
.data
.s
[i
] = 0;
4382 event
.xclient
.data
.l
[i
] = 0;
4384 event
.xclient
.message_type
4385 = XInternAtom (dpyinfo
->display
, SDATA (message_type
), False
);
4386 event
.xclient
.display
= dpyinfo
->display
;
4387 event
.xclient
.window
= FRAME_OUTER_WINDOW (f
);
4389 XSendEvent (dpyinfo
->display
, wdest
, False
, 0xffff, &event
);
4391 XFlush (dpyinfo
->display
);
4397 /***********************************************************************
4399 ***********************************************************************/
4401 /* Value is the number of elements of vector VECTOR. */
4403 #define DIM(VECTOR) (sizeof (VECTOR) / sizeof *(VECTOR))
4405 /* List of supported image types. Use define_image_type to add new
4406 types. Use lookup_image_type to find a type for a given symbol. */
4408 static struct image_type
*image_types
;
4410 /* The symbol `image' which is the car of the lists used to represent
4413 extern Lisp_Object Qimage
;
4415 /* The symbol `xbm' which is used as the type symbol for XBM images. */
4421 extern Lisp_Object QCwidth
, QCheight
, QCforeground
, QCbackground
, QCfile
;
4422 extern Lisp_Object QCdata
, QCtype
;
4423 Lisp_Object QCascent
, QCmargin
, QCrelief
;
4424 Lisp_Object QCconversion
, QCcolor_symbols
, QCheuristic_mask
;
4425 Lisp_Object QCindex
, QCmatrix
, QCcolor_adjustment
, QCmask
;
4427 /* Other symbols. */
4429 Lisp_Object Qlaplace
, Qemboss
, Qedge_detection
, Qheuristic
;
4431 /* Time in seconds after which images should be removed from the cache
4432 if not displayed. */
4434 Lisp_Object Vimage_cache_eviction_delay
;
4436 /* Function prototypes. */
4438 static void define_image_type
P_ ((struct image_type
*type
));
4439 static struct image_type
*lookup_image_type
P_ ((Lisp_Object symbol
));
4440 static void image_error
P_ ((char *format
, Lisp_Object
, Lisp_Object
));
4441 static void x_laplace
P_ ((struct frame
*, struct image
*));
4442 static void x_emboss
P_ ((struct frame
*, struct image
*));
4443 static int x_build_heuristic_mask
P_ ((struct frame
*, struct image
*,
4447 /* Define a new image type from TYPE. This adds a copy of TYPE to
4448 image_types and adds the symbol *TYPE->type to Vimage_types. */
4451 define_image_type (type
)
4452 struct image_type
*type
;
4454 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
4455 The initialized data segment is read-only. */
4456 struct image_type
*p
= (struct image_type
*) xmalloc (sizeof *p
);
4457 bcopy (type
, p
, sizeof *p
);
4458 p
->next
= image_types
;
4460 Vimage_types
= Fcons (*p
->type
, Vimage_types
);
4464 /* Look up image type SYMBOL, and return a pointer to its image_type
4465 structure. Value is null if SYMBOL is not a known image type. */
4467 static INLINE
struct image_type
*
4468 lookup_image_type (symbol
)
4471 struct image_type
*type
;
4473 for (type
= image_types
; type
; type
= type
->next
)
4474 if (EQ (symbol
, *type
->type
))
4481 /* Value is non-zero if OBJECT is a valid Lisp image specification. A
4482 valid image specification is a list whose car is the symbol
4483 `image', and whose rest is a property list. The property list must
4484 contain a value for key `:type'. That value must be the name of a
4485 supported image type. The rest of the property list depends on the
4489 valid_image_p (object
)
4494 if (CONSP (object
) && EQ (XCAR (object
), Qimage
))
4498 for (tem
= XCDR (object
); CONSP (tem
); tem
= XCDR (tem
))
4499 if (EQ (XCAR (tem
), QCtype
))
4502 if (CONSP (tem
) && SYMBOLP (XCAR (tem
)))
4504 struct image_type
*type
;
4505 type
= lookup_image_type (XCAR (tem
));
4507 valid_p
= type
->valid_p (object
);
4518 /* Log error message with format string FORMAT and argument ARG.
4519 Signaling an error, e.g. when an image cannot be loaded, is not a
4520 good idea because this would interrupt redisplay, and the error
4521 message display would lead to another redisplay. This function
4522 therefore simply displays a message. */
4525 image_error (format
, arg1
, arg2
)
4527 Lisp_Object arg1
, arg2
;
4529 add_to_log (format
, arg1
, arg2
);
4534 /***********************************************************************
4535 Image specifications
4536 ***********************************************************************/
4538 enum image_value_type
4540 IMAGE_DONT_CHECK_VALUE_TYPE
,
4542 IMAGE_STRING_OR_NIL_VALUE
,
4544 IMAGE_POSITIVE_INTEGER_VALUE
,
4545 IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
,
4546 IMAGE_NON_NEGATIVE_INTEGER_VALUE
,
4548 IMAGE_INTEGER_VALUE
,
4549 IMAGE_FUNCTION_VALUE
,
4554 /* Structure used when parsing image specifications. */
4556 struct image_keyword
4558 /* Name of keyword. */
4561 /* The type of value allowed. */
4562 enum image_value_type type
;
4564 /* Non-zero means key must be present. */
4567 /* Used to recognize duplicate keywords in a property list. */
4570 /* The value that was found. */
4575 static int parse_image_spec
P_ ((Lisp_Object
, struct image_keyword
*,
4577 static Lisp_Object image_spec_value
P_ ((Lisp_Object
, Lisp_Object
, int *));
4580 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
4581 has the format (image KEYWORD VALUE ...). One of the keyword/
4582 value pairs must be `:type TYPE'. KEYWORDS is a vector of
4583 image_keywords structures of size NKEYWORDS describing other
4584 allowed keyword/value pairs. Value is non-zero if SPEC is valid. */
4587 parse_image_spec (spec
, keywords
, nkeywords
, type
)
4589 struct image_keyword
*keywords
;
4596 if (!CONSP (spec
) || !EQ (XCAR (spec
), Qimage
))
4599 plist
= XCDR (spec
);
4600 while (CONSP (plist
))
4602 Lisp_Object key
, value
;
4604 /* First element of a pair must be a symbol. */
4606 plist
= XCDR (plist
);
4610 /* There must follow a value. */
4613 value
= XCAR (plist
);
4614 plist
= XCDR (plist
);
4616 /* Find key in KEYWORDS. Error if not found. */
4617 for (i
= 0; i
< nkeywords
; ++i
)
4618 if (strcmp (keywords
[i
].name
, SDATA (SYMBOL_NAME (key
))) == 0)
4624 /* Record that we recognized the keyword. If a keywords
4625 was found more than once, it's an error. */
4626 keywords
[i
].value
= value
;
4627 ++keywords
[i
].count
;
4629 if (keywords
[i
].count
> 1)
4632 /* Check type of value against allowed type. */
4633 switch (keywords
[i
].type
)
4635 case IMAGE_STRING_VALUE
:
4636 if (!STRINGP (value
))
4640 case IMAGE_STRING_OR_NIL_VALUE
:
4641 if (!STRINGP (value
) && !NILP (value
))
4645 case IMAGE_SYMBOL_VALUE
:
4646 if (!SYMBOLP (value
))
4650 case IMAGE_POSITIVE_INTEGER_VALUE
:
4651 if (!INTEGERP (value
) || XINT (value
) <= 0)
4655 case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
:
4656 if (INTEGERP (value
) && XINT (value
) >= 0)
4659 && INTEGERP (XCAR (value
)) && INTEGERP (XCDR (value
))
4660 && XINT (XCAR (value
)) >= 0 && XINT (XCDR (value
)) >= 0)
4664 case IMAGE_ASCENT_VALUE
:
4665 if (SYMBOLP (value
) && EQ (value
, Qcenter
))
4667 else if (INTEGERP (value
)
4668 && XINT (value
) >= 0
4669 && XINT (value
) <= 100)
4673 case IMAGE_NON_NEGATIVE_INTEGER_VALUE
:
4674 if (!INTEGERP (value
) || XINT (value
) < 0)
4678 case IMAGE_DONT_CHECK_VALUE_TYPE
:
4681 case IMAGE_FUNCTION_VALUE
:
4682 value
= indirect_function (value
);
4684 || COMPILEDP (value
)
4685 || (CONSP (value
) && EQ (XCAR (value
), Qlambda
)))
4689 case IMAGE_NUMBER_VALUE
:
4690 if (!INTEGERP (value
) && !FLOATP (value
))
4694 case IMAGE_INTEGER_VALUE
:
4695 if (!INTEGERP (value
))
4699 case IMAGE_BOOL_VALUE
:
4700 if (!NILP (value
) && !EQ (value
, Qt
))
4709 if (EQ (key
, QCtype
) && !EQ (type
, value
))
4713 /* Check that all mandatory fields are present. */
4714 for (i
= 0; i
< nkeywords
; ++i
)
4715 if (keywords
[i
].mandatory_p
&& keywords
[i
].count
== 0)
4718 return NILP (plist
);
4722 /* Return the value of KEY in image specification SPEC. Value is nil
4723 if KEY is not present in SPEC. if FOUND is not null, set *FOUND
4724 to 1 if KEY was found in SPEC, set it to 0 otherwise. */
4727 image_spec_value (spec
, key
, found
)
4728 Lisp_Object spec
, key
;
4733 xassert (valid_image_p (spec
));
4735 for (tail
= XCDR (spec
);
4736 CONSP (tail
) && CONSP (XCDR (tail
));
4737 tail
= XCDR (XCDR (tail
)))
4739 if (EQ (XCAR (tail
), key
))
4743 return XCAR (XCDR (tail
));
4753 DEFUN ("image-size", Fimage_size
, Simage_size
, 1, 3, 0,
4754 doc
: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
4755 PIXELS non-nil means return the size in pixels, otherwise return the
4756 size in canonical character units.
4757 FRAME is the frame on which the image will be displayed. FRAME nil
4758 or omitted means use the selected frame. */)
4759 (spec
, pixels
, frame
)
4760 Lisp_Object spec
, pixels
, frame
;
4765 if (valid_image_p (spec
))
4767 struct frame
*f
= check_x_frame (frame
);
4768 int id
= lookup_image (f
, spec
);
4769 struct image
*img
= IMAGE_FROM_ID (f
, id
);
4770 int width
= img
->width
+ 2 * img
->hmargin
;
4771 int height
= img
->height
+ 2 * img
->vmargin
;
4774 size
= Fcons (make_float ((double) width
/ FRAME_COLUMN_WIDTH (f
)),
4775 make_float ((double) height
/ FRAME_LINE_HEIGHT (f
)));
4777 size
= Fcons (make_number (width
), make_number (height
));
4780 error ("Invalid image specification");
4786 DEFUN ("image-mask-p", Fimage_mask_p
, Simage_mask_p
, 1, 2, 0,
4787 doc
: /* Return t if image SPEC has a mask bitmap.
4788 FRAME is the frame on which the image will be displayed. FRAME nil
4789 or omitted means use the selected frame. */)
4791 Lisp_Object spec
, frame
;
4796 if (valid_image_p (spec
))
4798 struct frame
*f
= check_x_frame (frame
);
4799 int id
= lookup_image (f
, spec
);
4800 struct image
*img
= IMAGE_FROM_ID (f
, id
);
4805 error ("Invalid image specification");
4812 /***********************************************************************
4813 Image type independent image structures
4814 ***********************************************************************/
4816 static struct image
*make_image
P_ ((Lisp_Object spec
, unsigned hash
));
4817 static void free_image
P_ ((struct frame
*f
, struct image
*img
));
4820 /* Allocate and return a new image structure for image specification
4821 SPEC. SPEC has a hash value of HASH. */
4823 static struct image
*
4824 make_image (spec
, hash
)
4828 struct image
*img
= (struct image
*) xmalloc (sizeof *img
);
4830 xassert (valid_image_p (spec
));
4831 bzero (img
, sizeof *img
);
4832 img
->type
= lookup_image_type (image_spec_value (spec
, QCtype
, NULL
));
4833 xassert (img
->type
!= NULL
);
4835 img
->data
.lisp_val
= Qnil
;
4836 img
->ascent
= DEFAULT_IMAGE_ASCENT
;
4842 /* Free image IMG which was used on frame F, including its resources. */
4851 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
4853 /* Remove IMG from the hash table of its cache. */
4855 img
->prev
->next
= img
->next
;
4857 c
->buckets
[img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
] = img
->next
;
4860 img
->next
->prev
= img
->prev
;
4862 c
->images
[img
->id
] = NULL
;
4864 /* Free resources, then free IMG. */
4865 img
->type
->free (f
, img
);
4871 /* Prepare image IMG for display on frame F. Must be called before
4872 drawing an image. */
4875 prepare_image_for_display (f
, img
)
4881 /* We're about to display IMG, so set its timestamp to `now'. */
4883 img
->timestamp
= EMACS_SECS (t
);
4885 /* If IMG doesn't have a pixmap yet, load it now, using the image
4886 type dependent loader function. */
4887 if (img
->pixmap
== None
&& !img
->load_failed_p
)
4888 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
4892 /* Value is the number of pixels for the ascent of image IMG when
4893 drawn in face FACE. */
4896 image_ascent (img
, face
)
4900 int height
= img
->height
+ img
->vmargin
;
4903 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
4906 /* This expression is arranged so that if the image can't be
4907 exactly centered, it will be moved slightly up. This is
4908 because a typical font is `top-heavy' (due to the presence
4909 uppercase letters), so the image placement should err towards
4910 being top-heavy too. It also just generally looks better. */
4911 ascent
= (height
+ face
->font
->ascent
- face
->font
->descent
+ 1) / 2;
4913 ascent
= height
/ 2;
4916 ascent
= height
* img
->ascent
/ 100.0;
4922 /* Image background colors. */
4924 static unsigned long
4925 four_corners_best (ximg
, width
, height
)
4927 unsigned long width
, height
;
4929 unsigned long corners
[4], best
;
4932 /* Get the colors at the corners of ximg. */
4933 corners
[0] = XGetPixel (ximg
, 0, 0);
4934 corners
[1] = XGetPixel (ximg
, width
- 1, 0);
4935 corners
[2] = XGetPixel (ximg
, width
- 1, height
- 1);
4936 corners
[3] = XGetPixel (ximg
, 0, height
- 1);
4938 /* Choose the most frequently found color as background. */
4939 for (i
= best_count
= 0; i
< 4; ++i
)
4943 for (j
= n
= 0; j
< 4; ++j
)
4944 if (corners
[i
] == corners
[j
])
4948 best
= corners
[i
], best_count
= n
;
4954 /* Return the `background' field of IMG. If IMG doesn't have one yet,
4955 it is guessed heuristically. If non-zero, XIMG is an existing XImage
4956 object to use for the heuristic. */
4959 image_background (img
, f
, ximg
)
4964 if (! img
->background_valid
)
4965 /* IMG doesn't have a background yet, try to guess a reasonable value. */
4967 int free_ximg
= !ximg
;
4970 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4971 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4973 img
->background
= four_corners_best (ximg
, img
->width
, img
->height
);
4976 XDestroyImage (ximg
);
4978 img
->background_valid
= 1;
4981 return img
->background
;
4984 /* Return the `background_transparent' field of IMG. If IMG doesn't
4985 have one yet, it is guessed heuristically. If non-zero, MASK is an
4986 existing XImage object to use for the heuristic. */
4989 image_background_transparent (img
, f
, mask
)
4994 if (! img
->background_transparent_valid
)
4995 /* IMG doesn't have a background yet, try to guess a reasonable value. */
4999 int free_mask
= !mask
;
5002 mask
= XGetImage (FRAME_X_DISPLAY (f
), img
->mask
,
5003 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
5005 img
->background_transparent
5006 = !four_corners_best (mask
, img
->width
, img
->height
);
5009 XDestroyImage (mask
);
5012 img
->background_transparent
= 0;
5014 img
->background_transparent_valid
= 1;
5017 return img
->background_transparent
;
5021 /***********************************************************************
5022 Helper functions for X image types
5023 ***********************************************************************/
5025 static void x_clear_image_1
P_ ((struct frame
*, struct image
*, int,
5027 static void x_clear_image
P_ ((struct frame
*f
, struct image
*img
));
5028 static unsigned long x_alloc_image_color
P_ ((struct frame
*f
,
5030 Lisp_Object color_name
,
5031 unsigned long dflt
));
5034 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
5035 free the pixmap if any. MASK_P non-zero means clear the mask
5036 pixmap if any. COLORS_P non-zero means free colors allocated for
5037 the image, if any. */
5040 x_clear_image_1 (f
, img
, pixmap_p
, mask_p
, colors_p
)
5043 int pixmap_p
, mask_p
, colors_p
;
5045 if (pixmap_p
&& img
->pixmap
)
5047 XFreePixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
5049 img
->background_valid
= 0;
5052 if (mask_p
&& img
->mask
)
5054 XFreePixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5056 img
->background_transparent_valid
= 0;
5059 if (colors_p
&& img
->ncolors
)
5061 x_free_colors (f
, img
->colors
, img
->ncolors
);
5062 xfree (img
->colors
);
5068 /* Free X resources of image IMG which is used on frame F. */
5071 x_clear_image (f
, img
)
5076 x_clear_image_1 (f
, img
, 1, 1, 1);
5081 /* Allocate color COLOR_NAME for image IMG on frame F. If color
5082 cannot be allocated, use DFLT. Add a newly allocated color to
5083 IMG->colors, so that it can be freed again. Value is the pixel
5086 static unsigned long
5087 x_alloc_image_color (f
, img
, color_name
, dflt
)
5090 Lisp_Object color_name
;
5094 unsigned long result
;
5096 xassert (STRINGP (color_name
));
5098 if (x_defined_color (f
, SDATA (color_name
), &color
, 1))
5100 /* This isn't called frequently so we get away with simply
5101 reallocating the color vector to the needed size, here. */
5104 (unsigned long *) xrealloc (img
->colors
,
5105 img
->ncolors
* sizeof *img
->colors
);
5106 img
->colors
[img
->ncolors
- 1] = color
.pixel
;
5107 result
= color
.pixel
;
5117 /***********************************************************************
5119 ***********************************************************************/
5121 static void cache_image
P_ ((struct frame
*f
, struct image
*img
));
5122 static void postprocess_image
P_ ((struct frame
*, struct image
*));
5125 /* Return a new, initialized image cache that is allocated from the
5126 heap. Call free_image_cache to free an image cache. */
5128 struct image_cache
*
5131 struct image_cache
*c
= (struct image_cache
*) xmalloc (sizeof *c
);
5134 bzero (c
, sizeof *c
);
5136 c
->images
= (struct image
**) xmalloc (c
->size
* sizeof *c
->images
);
5137 size
= IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
;
5138 c
->buckets
= (struct image
**) xmalloc (size
);
5139 bzero (c
->buckets
, size
);
5144 /* Free image cache of frame F. Be aware that X frames share images
5148 free_image_cache (f
)
5151 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5156 /* Cache should not be referenced by any frame when freed. */
5157 xassert (c
->refcount
== 0);
5159 for (i
= 0; i
< c
->used
; ++i
)
5160 free_image (f
, c
->images
[i
]);
5164 FRAME_X_IMAGE_CACHE (f
) = NULL
;
5169 /* Clear image cache of frame F. FORCE_P non-zero means free all
5170 images. FORCE_P zero means clear only images that haven't been
5171 displayed for some time. Should be called from time to time to
5172 reduce the number of loaded images. If image-eviction-seconds is
5173 non-nil, this frees images in the cache which weren't displayed for
5174 at least that many seconds. */
5177 clear_image_cache (f
, force_p
)
5181 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5183 if (c
&& INTEGERP (Vimage_cache_eviction_delay
))
5190 old
= EMACS_SECS (t
) - XFASTINT (Vimage_cache_eviction_delay
);
5192 /* Block input so that we won't be interrupted by a SIGIO
5193 while being in an inconsistent state. */
5196 for (i
= nfreed
= 0; i
< c
->used
; ++i
)
5198 struct image
*img
= c
->images
[i
];
5200 && (force_p
|| img
->timestamp
< old
))
5202 free_image (f
, img
);
5207 /* We may be clearing the image cache because, for example,
5208 Emacs was iconified for a longer period of time. In that
5209 case, current matrices may still contain references to
5210 images freed above. So, clear these matrices. */
5213 Lisp_Object tail
, frame
;
5215 FOR_EACH_FRAME (tail
, frame
)
5217 struct frame
*f
= XFRAME (frame
);
5219 && FRAME_X_IMAGE_CACHE (f
) == c
)
5220 clear_current_matrices (f
);
5223 ++windows_or_buffers_changed
;
5231 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
5233 doc
: /* Clear the image cache of FRAME.
5234 FRAME nil or omitted means use the selected frame.
5235 FRAME t means clear the image caches of all frames. */)
5243 FOR_EACH_FRAME (tail
, frame
)
5244 if (FRAME_X_P (XFRAME (frame
)))
5245 clear_image_cache (XFRAME (frame
), 1);
5248 clear_image_cache (check_x_frame (frame
), 1);
5254 /* Compute masks and transform image IMG on frame F, as specified
5255 by the image's specification, */
5258 postprocess_image (f
, img
)
5262 /* Manipulation of the image's mask. */
5265 Lisp_Object conversion
, spec
;
5270 /* `:heuristic-mask t'
5272 means build a mask heuristically.
5273 `:heuristic-mask (R G B)'
5274 `:mask (heuristic (R G B))'
5275 means build a mask from color (R G B) in the
5278 means remove a mask, if any. */
5280 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
5282 x_build_heuristic_mask (f
, img
, mask
);
5287 mask
= image_spec_value (spec
, QCmask
, &found_p
);
5289 if (EQ (mask
, Qheuristic
))
5290 x_build_heuristic_mask (f
, img
, Qt
);
5291 else if (CONSP (mask
)
5292 && EQ (XCAR (mask
), Qheuristic
))
5294 if (CONSP (XCDR (mask
)))
5295 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
5297 x_build_heuristic_mask (f
, img
, XCDR (mask
));
5299 else if (NILP (mask
) && found_p
&& img
->mask
)
5301 XFreePixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5307 /* Should we apply an image transformation algorithm? */
5308 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
5309 if (EQ (conversion
, Qdisabled
))
5310 x_disable_image (f
, img
);
5311 else if (EQ (conversion
, Qlaplace
))
5313 else if (EQ (conversion
, Qemboss
))
5315 else if (CONSP (conversion
)
5316 && EQ (XCAR (conversion
), Qedge_detection
))
5319 tem
= XCDR (conversion
);
5321 x_edge_detection (f
, img
,
5322 Fplist_get (tem
, QCmatrix
),
5323 Fplist_get (tem
, QCcolor_adjustment
));
5329 /* Return the id of image with Lisp specification SPEC on frame F.
5330 SPEC must be a valid Lisp image specification (see valid_image_p). */
5333 lookup_image (f
, spec
)
5337 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5341 struct gcpro gcpro1
;
5344 /* F must be a window-system frame, and SPEC must be a valid image
5346 xassert (FRAME_WINDOW_P (f
));
5347 xassert (valid_image_p (spec
));
5351 /* Look up SPEC in the hash table of the image cache. */
5352 hash
= sxhash (spec
, 0);
5353 i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
5355 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
5356 if (img
->hash
== hash
&& !NILP (Fequal (img
->spec
, spec
)))
5359 /* If not found, create a new image and cache it. */
5362 extern Lisp_Object Qpostscript
;
5365 img
= make_image (spec
, hash
);
5366 cache_image (f
, img
);
5367 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
5369 /* If we can't load the image, and we don't have a width and
5370 height, use some arbitrary width and height so that we can
5371 draw a rectangle for it. */
5372 if (img
->load_failed_p
)
5376 value
= image_spec_value (spec
, QCwidth
, NULL
);
5377 img
->width
= (INTEGERP (value
)
5378 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
5379 value
= image_spec_value (spec
, QCheight
, NULL
);
5380 img
->height
= (INTEGERP (value
)
5381 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
5385 /* Handle image type independent image attributes
5386 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
5387 `:background COLOR'. */
5388 Lisp_Object ascent
, margin
, relief
, bg
;
5390 ascent
= image_spec_value (spec
, QCascent
, NULL
);
5391 if (INTEGERP (ascent
))
5392 img
->ascent
= XFASTINT (ascent
);
5393 else if (EQ (ascent
, Qcenter
))
5394 img
->ascent
= CENTERED_IMAGE_ASCENT
;
5396 margin
= image_spec_value (spec
, QCmargin
, NULL
);
5397 if (INTEGERP (margin
) && XINT (margin
) >= 0)
5398 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
5399 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
5400 && INTEGERP (XCDR (margin
)))
5402 if (XINT (XCAR (margin
)) > 0)
5403 img
->hmargin
= XFASTINT (XCAR (margin
));
5404 if (XINT (XCDR (margin
)) > 0)
5405 img
->vmargin
= XFASTINT (XCDR (margin
));
5408 relief
= image_spec_value (spec
, QCrelief
, NULL
);
5409 if (INTEGERP (relief
))
5411 img
->relief
= XINT (relief
);
5412 img
->hmargin
+= abs (img
->relief
);
5413 img
->vmargin
+= abs (img
->relief
);
5416 if (! img
->background_valid
)
5418 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
5422 = x_alloc_image_color (f
, img
, bg
,
5423 FRAME_BACKGROUND_PIXEL (f
));
5424 img
->background_valid
= 1;
5428 /* Do image transformations and compute masks, unless we
5429 don't have the image yet. */
5430 if (!EQ (*img
->type
->type
, Qpostscript
))
5431 postprocess_image (f
, img
);
5435 xassert (!interrupt_input_blocked
);
5438 /* We're using IMG, so set its timestamp to `now'. */
5439 EMACS_GET_TIME (now
);
5440 img
->timestamp
= EMACS_SECS (now
);
5444 /* Value is the image id. */
5449 /* Cache image IMG in the image cache of frame F. */
5452 cache_image (f
, img
)
5456 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5459 /* Find a free slot in c->images. */
5460 for (i
= 0; i
< c
->used
; ++i
)
5461 if (c
->images
[i
] == NULL
)
5464 /* If no free slot found, maybe enlarge c->images. */
5465 if (i
== c
->used
&& c
->used
== c
->size
)
5468 c
->images
= (struct image
**) xrealloc (c
->images
,
5469 c
->size
* sizeof *c
->images
);
5472 /* Add IMG to c->images, and assign IMG an id. */
5478 /* Add IMG to the cache's hash table. */
5479 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
5480 img
->next
= c
->buckets
[i
];
5482 img
->next
->prev
= img
;
5484 c
->buckets
[i
] = img
;
5488 /* Call FN on every image in the image cache of frame F. Used to mark
5489 Lisp Objects in the image cache. */
5492 forall_images_in_image_cache (f
, fn
)
5494 void (*fn
) P_ ((struct image
*img
));
5496 if (FRAME_LIVE_P (f
) && FRAME_X_P (f
))
5498 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5502 for (i
= 0; i
< c
->used
; ++i
)
5511 /***********************************************************************
5513 ***********************************************************************/
5515 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
5516 XImage
**, Pixmap
*));
5517 static void x_destroy_x_image
P_ ((XImage
*));
5518 static void x_put_x_image
P_ ((struct frame
*, XImage
*, Pixmap
, int, int));
5521 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
5522 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
5523 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
5524 via xmalloc. Print error messages via image_error if an error
5525 occurs. Value is non-zero if successful. */
5528 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
5530 int width
, height
, depth
;
5534 Display
*display
= FRAME_X_DISPLAY (f
);
5535 Screen
*screen
= FRAME_X_SCREEN (f
);
5536 Window window
= FRAME_X_WINDOW (f
);
5538 xassert (interrupt_input_blocked
);
5541 depth
= DefaultDepthOfScreen (screen
);
5542 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
5543 depth
, ZPixmap
, 0, NULL
, width
, height
,
5544 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
5547 image_error ("Unable to allocate X image", Qnil
, Qnil
);
5551 /* Allocate image raster. */
5552 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
5554 /* Allocate a pixmap of the same size. */
5555 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
5556 if (*pixmap
== None
)
5558 x_destroy_x_image (*ximg
);
5560 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
5568 /* Destroy XImage XIMG. Free XIMG->data. */
5571 x_destroy_x_image (ximg
)
5574 xassert (interrupt_input_blocked
);
5579 XDestroyImage (ximg
);
5584 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
5585 are width and height of both the image and pixmap. */
5588 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
5596 xassert (interrupt_input_blocked
);
5597 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
5598 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
5599 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
5604 /***********************************************************************
5606 ***********************************************************************/
5608 static Lisp_Object x_find_image_file
P_ ((Lisp_Object
));
5609 static char *slurp_file
P_ ((char *, int *));
5612 /* Find image file FILE. Look in data-directory, then
5613 x-bitmap-file-path. Value is the full name of the file found, or
5614 nil if not found. */
5617 x_find_image_file (file
)
5620 Lisp_Object file_found
, search_path
;
5621 struct gcpro gcpro1
, gcpro2
;
5625 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
5626 GCPRO2 (file_found
, search_path
);
5628 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
5629 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
5641 /* Read FILE into memory. Value is a pointer to a buffer allocated
5642 with xmalloc holding FILE's contents. Value is null if an error
5643 occurred. *SIZE is set to the size of the file. */
5646 slurp_file (file
, size
)
5654 if (stat (file
, &st
) == 0
5655 && (fp
= fopen (file
, "r")) != NULL
5656 && (buf
= (char *) xmalloc (st
.st_size
),
5657 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5678 /***********************************************************************
5680 ***********************************************************************/
5682 static int xbm_scan
P_ ((char **, char *, char *, int *));
5683 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
5684 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
5686 static int xbm_image_p
P_ ((Lisp_Object object
));
5687 static int xbm_read_bitmap_data
P_ ((char *, char *, int *, int *,
5689 static int xbm_file_p
P_ ((Lisp_Object
));
5692 /* Indices of image specification fields in xbm_format, below. */
5694 enum xbm_keyword_index
5712 /* Vector of image_keyword structures describing the format
5713 of valid XBM image specifications. */
5715 static struct image_keyword xbm_format
[XBM_LAST
] =
5717 {":type", IMAGE_SYMBOL_VALUE
, 1},
5718 {":file", IMAGE_STRING_VALUE
, 0},
5719 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
5720 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
5721 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5722 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5723 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
5724 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5725 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5726 {":relief", IMAGE_INTEGER_VALUE
, 0},
5727 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5728 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5729 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
5732 /* Structure describing the image type XBM. */
5734 static struct image_type xbm_type
=
5743 /* Tokens returned from xbm_scan. */
5752 /* Return non-zero if OBJECT is a valid XBM-type image specification.
5753 A valid specification is a list starting with the symbol `image'
5754 The rest of the list is a property list which must contain an
5757 If the specification specifies a file to load, it must contain
5758 an entry `:file FILENAME' where FILENAME is a string.
5760 If the specification is for a bitmap loaded from memory it must
5761 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
5762 WIDTH and HEIGHT are integers > 0. DATA may be:
5764 1. a string large enough to hold the bitmap data, i.e. it must
5765 have a size >= (WIDTH + 7) / 8 * HEIGHT
5767 2. a bool-vector of size >= WIDTH * HEIGHT
5769 3. a vector of strings or bool-vectors, one for each line of the
5772 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
5773 may not be specified in this case because they are defined in the
5776 Both the file and data forms may contain the additional entries
5777 `:background COLOR' and `:foreground COLOR'. If not present,
5778 foreground and background of the frame on which the image is
5779 displayed is used. */
5782 xbm_image_p (object
)
5785 struct image_keyword kw
[XBM_LAST
];
5787 bcopy (xbm_format
, kw
, sizeof kw
);
5788 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
5791 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
5793 if (kw
[XBM_FILE
].count
)
5795 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
5798 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
5800 /* In-memory XBM file. */
5801 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
5809 /* Entries for `:width', `:height' and `:data' must be present. */
5810 if (!kw
[XBM_WIDTH
].count
5811 || !kw
[XBM_HEIGHT
].count
5812 || !kw
[XBM_DATA
].count
)
5815 data
= kw
[XBM_DATA
].value
;
5816 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
5817 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
5819 /* Check type of data, and width and height against contents of
5825 /* Number of elements of the vector must be >= height. */
5826 if (XVECTOR (data
)->size
< height
)
5829 /* Each string or bool-vector in data must be large enough
5830 for one line of the image. */
5831 for (i
= 0; i
< height
; ++i
)
5833 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
5838 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
5841 else if (BOOL_VECTOR_P (elt
))
5843 if (XBOOL_VECTOR (elt
)->size
< width
)
5850 else if (STRINGP (data
))
5853 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
5856 else if (BOOL_VECTOR_P (data
))
5858 if (XBOOL_VECTOR (data
)->size
< width
* height
)
5869 /* Scan a bitmap file. FP is the stream to read from. Value is
5870 either an enumerator from enum xbm_token, or a character for a
5871 single-character token, or 0 at end of file. If scanning an
5872 identifier, store the lexeme of the identifier in SVAL. If
5873 scanning a number, store its value in *IVAL. */
5876 xbm_scan (s
, end
, sval
, ival
)
5885 /* Skip white space. */
5886 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5891 else if (isdigit (c
))
5893 int value
= 0, digit
;
5895 if (c
== '0' && *s
< end
)
5898 if (c
== 'x' || c
== 'X')
5905 else if (c
>= 'a' && c
<= 'f')
5906 digit
= c
- 'a' + 10;
5907 else if (c
>= 'A' && c
<= 'F')
5908 digit
= c
- 'A' + 10;
5911 value
= 16 * value
+ digit
;
5914 else if (isdigit (c
))
5918 && (c
= *(*s
)++, isdigit (c
)))
5919 value
= 8 * value
+ c
- '0';
5926 && (c
= *(*s
)++, isdigit (c
)))
5927 value
= 10 * value
+ c
- '0';
5935 else if (isalpha (c
) || c
== '_')
5939 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
5946 else if (c
== '/' && **s
== '*')
5948 /* C-style comment. */
5950 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
5963 /* Replacement for XReadBitmapFileData which isn't available under old
5964 X versions. CONTENTS is a pointer to a buffer to parse; END is the
5965 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
5966 the image. Return in *DATA the bitmap data allocated with xmalloc.
5967 Value is non-zero if successful. DATA null means just test if
5968 CONTENTS looks like an in-memory XBM file. */
5971 xbm_read_bitmap_data (contents
, end
, width
, height
, data
)
5972 char *contents
, *end
;
5973 int *width
, *height
;
5974 unsigned char **data
;
5977 char buffer
[BUFSIZ
];
5980 int bytes_per_line
, i
, nbytes
;
5986 LA1 = xbm_scan (&s, end, buffer, &value)
5988 #define expect(TOKEN) \
5989 if (LA1 != (TOKEN)) \
5994 #define expect_ident(IDENT) \
5995 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
6000 *width
= *height
= -1;
6003 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
6005 /* Parse defines for width, height and hot-spots. */
6009 expect_ident ("define");
6010 expect (XBM_TK_IDENT
);
6012 if (LA1
== XBM_TK_NUMBER
);
6014 char *p
= strrchr (buffer
, '_');
6015 p
= p
? p
+ 1 : buffer
;
6016 if (strcmp (p
, "width") == 0)
6018 else if (strcmp (p
, "height") == 0)
6021 expect (XBM_TK_NUMBER
);
6024 if (*width
< 0 || *height
< 0)
6026 else if (data
== NULL
)
6029 /* Parse bits. Must start with `static'. */
6030 expect_ident ("static");
6031 if (LA1
== XBM_TK_IDENT
)
6033 if (strcmp (buffer
, "unsigned") == 0)
6036 expect_ident ("char");
6038 else if (strcmp (buffer
, "short") == 0)
6042 if (*width
% 16 && *width
% 16 < 9)
6045 else if (strcmp (buffer
, "char") == 0)
6053 expect (XBM_TK_IDENT
);
6059 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
6060 nbytes
= bytes_per_line
* *height
;
6061 p
= *data
= (char *) xmalloc (nbytes
);
6065 for (i
= 0; i
< nbytes
; i
+= 2)
6068 expect (XBM_TK_NUMBER
);
6071 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
6074 if (LA1
== ',' || LA1
== '}')
6082 for (i
= 0; i
< nbytes
; ++i
)
6085 expect (XBM_TK_NUMBER
);
6089 if (LA1
== ',' || LA1
== '}')
6114 /* Load XBM image IMG which will be displayed on frame F from buffer
6115 CONTENTS. END is the end of the buffer. Value is non-zero if
6119 xbm_load_image (f
, img
, contents
, end
)
6122 char *contents
, *end
;
6125 unsigned char *data
;
6128 rc
= xbm_read_bitmap_data (contents
, end
, &img
->width
, &img
->height
, &data
);
6131 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
6132 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
6133 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
6136 xassert (img
->width
> 0 && img
->height
> 0);
6138 /* Get foreground and background colors, maybe allocate colors. */
6139 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
6141 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
6142 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
6145 background
= x_alloc_image_color (f
, img
, value
, background
);
6146 img
->background
= background
;
6147 img
->background_valid
= 1;
6151 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
6154 img
->width
, img
->height
,
6155 foreground
, background
,
6159 if (img
->pixmap
== None
)
6161 x_clear_image (f
, img
);
6162 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
6168 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
6174 /* Value is non-zero if DATA looks like an in-memory XBM file. */
6181 return (STRINGP (data
)
6182 && xbm_read_bitmap_data (SDATA (data
),
6189 /* Fill image IMG which is used on frame F with pixmap data. Value is
6190 non-zero if successful. */
6198 Lisp_Object file_name
;
6200 xassert (xbm_image_p (img
->spec
));
6202 /* If IMG->spec specifies a file name, create a non-file spec from it. */
6203 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
6204 if (STRINGP (file_name
))
6209 struct gcpro gcpro1
;
6211 file
= x_find_image_file (file_name
);
6213 if (!STRINGP (file
))
6215 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
6220 contents
= slurp_file (SDATA (file
), &size
);
6221 if (contents
== NULL
)
6223 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
6228 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
6233 struct image_keyword fmt
[XBM_LAST
];
6236 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
6237 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
6240 int in_memory_file_p
= 0;
6242 /* See if data looks like an in-memory XBM file. */
6243 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
6244 in_memory_file_p
= xbm_file_p (data
);
6246 /* Parse the image specification. */
6247 bcopy (xbm_format
, fmt
, sizeof fmt
);
6248 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
6251 /* Get specified width, and height. */
6252 if (!in_memory_file_p
)
6254 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
6255 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
6256 xassert (img
->width
> 0 && img
->height
> 0);
6259 /* Get foreground and background colors, maybe allocate colors. */
6260 if (fmt
[XBM_FOREGROUND
].count
6261 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
6262 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
6264 if (fmt
[XBM_BACKGROUND
].count
6265 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
6266 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
6269 if (in_memory_file_p
)
6270 success_p
= xbm_load_image (f
, img
, SDATA (data
),
6279 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
6281 p
= bits
= (char *) alloca (nbytes
* img
->height
);
6282 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
6284 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
6286 bcopy (SDATA (line
), p
, nbytes
);
6288 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
6291 else if (STRINGP (data
))
6292 bits
= SDATA (data
);
6294 bits
= XBOOL_VECTOR (data
)->data
;
6296 /* Create the pixmap. */
6297 depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
6299 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
6302 img
->width
, img
->height
,
6303 foreground
, background
,
6309 image_error ("Unable to create pixmap for XBM image `%s'",
6311 x_clear_image (f
, img
);
6321 /***********************************************************************
6323 ***********************************************************************/
6327 static int xpm_image_p
P_ ((Lisp_Object object
));
6328 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
6329 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
6331 #include "X11/xpm.h"
6333 /* The symbol `xpm' identifying XPM-format images. */
6337 /* Indices of image specification fields in xpm_format, below. */
6339 enum xpm_keyword_index
6355 /* Vector of image_keyword structures describing the format
6356 of valid XPM image specifications. */
6358 static struct image_keyword xpm_format
[XPM_LAST
] =
6360 {":type", IMAGE_SYMBOL_VALUE
, 1},
6361 {":file", IMAGE_STRING_VALUE
, 0},
6362 {":data", IMAGE_STRING_VALUE
, 0},
6363 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6364 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6365 {":relief", IMAGE_INTEGER_VALUE
, 0},
6366 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6367 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6368 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6369 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6370 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6373 /* Structure describing the image type XBM. */
6375 static struct image_type xpm_type
=
6385 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
6386 functions for allocating image colors. Our own functions handle
6387 color allocation failures more gracefully than the ones on the XPM
6390 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
6391 #define ALLOC_XPM_COLORS
6394 #ifdef ALLOC_XPM_COLORS
6396 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
6397 static void xpm_free_color_cache
P_ ((void));
6398 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
6399 static int xpm_color_bucket
P_ ((char *));
6400 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
6403 /* An entry in a hash table used to cache color definitions of named
6404 colors. This cache is necessary to speed up XPM image loading in
6405 case we do color allocations ourselves. Without it, we would need
6406 a call to XParseColor per pixel in the image. */
6408 struct xpm_cached_color
6410 /* Next in collision chain. */
6411 struct xpm_cached_color
*next
;
6413 /* Color definition (RGB and pixel color). */
6420 /* The hash table used for the color cache, and its bucket vector
6423 #define XPM_COLOR_CACHE_BUCKETS 1001
6424 struct xpm_cached_color
**xpm_color_cache
;
6426 /* Initialize the color cache. */
6429 xpm_init_color_cache (f
, attrs
)
6431 XpmAttributes
*attrs
;
6433 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
6434 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
6435 memset (xpm_color_cache
, 0, nbytes
);
6436 init_color_table ();
6438 if (attrs
->valuemask
& XpmColorSymbols
)
6443 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
6444 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
6445 attrs
->colorsymbols
[i
].value
, &color
))
6447 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
6449 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
6455 /* Free the color cache. */
6458 xpm_free_color_cache ()
6460 struct xpm_cached_color
*p
, *next
;
6463 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
6464 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
6470 xfree (xpm_color_cache
);
6471 xpm_color_cache
= NULL
;
6472 free_color_table ();
6476 /* Return the bucket index for color named COLOR_NAME in the color
6480 xpm_color_bucket (color_name
)
6486 for (s
= color_name
; *s
; ++s
)
6488 return h
%= XPM_COLOR_CACHE_BUCKETS
;
6492 /* On frame F, cache values COLOR for color with name COLOR_NAME.
6493 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
6496 static struct xpm_cached_color
*
6497 xpm_cache_color (f
, color_name
, color
, bucket
)
6504 struct xpm_cached_color
*p
;
6507 bucket
= xpm_color_bucket (color_name
);
6509 nbytes
= sizeof *p
+ strlen (color_name
);
6510 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
6511 strcpy (p
->name
, color_name
);
6513 p
->next
= xpm_color_cache
[bucket
];
6514 xpm_color_cache
[bucket
] = p
;
6519 /* Look up color COLOR_NAME for frame F in the color cache. If found,
6520 return the cached definition in *COLOR. Otherwise, make a new
6521 entry in the cache and allocate the color. Value is zero if color
6522 allocation failed. */
6525 xpm_lookup_color (f
, color_name
, color
)
6530 struct xpm_cached_color
*p
;
6531 int h
= xpm_color_bucket (color_name
);
6533 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
6534 if (strcmp (p
->name
, color_name
) == 0)
6539 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
6542 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
6544 p
= xpm_cache_color (f
, color_name
, color
, h
);
6546 /* You get `opaque' at least from ImageMagick converting pbm to xpm
6547 with transparency, and it's useful. */
6548 else if (strcmp ("opaque", color_name
) == 0)
6550 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
6551 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
6552 p
= xpm_cache_color (f
, color_name
, color
, h
);
6559 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
6560 CLOSURE is a pointer to the frame on which we allocate the
6561 color. Return in *COLOR the allocated color. Value is non-zero
6565 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
6572 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
6576 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
6577 is a pointer to the frame on which we allocate the color. Value is
6578 non-zero if successful. */
6581 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
6591 #endif /* ALLOC_XPM_COLORS */
6594 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
6595 for XPM images. Such a list must consist of conses whose car and
6599 xpm_valid_color_symbols_p (color_symbols
)
6600 Lisp_Object color_symbols
;
6602 while (CONSP (color_symbols
))
6604 Lisp_Object sym
= XCAR (color_symbols
);
6606 || !STRINGP (XCAR (sym
))
6607 || !STRINGP (XCDR (sym
)))
6609 color_symbols
= XCDR (color_symbols
);
6612 return NILP (color_symbols
);
6616 /* Value is non-zero if OBJECT is a valid XPM image specification. */
6619 xpm_image_p (object
)
6622 struct image_keyword fmt
[XPM_LAST
];
6623 bcopy (xpm_format
, fmt
, sizeof fmt
);
6624 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
6625 /* Either `:file' or `:data' must be present. */
6626 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
6627 /* Either no `:color-symbols' or it's a list of conses
6628 whose car and cdr are strings. */
6629 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
6630 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
6634 /* Load image IMG which will be displayed on frame F. Value is
6635 non-zero if successful. */
6643 XpmAttributes attrs
;
6644 Lisp_Object specified_file
, color_symbols
;
6646 /* Configure the XPM lib. Use the visual of frame F. Allocate
6647 close colors. Return colors allocated. */
6648 bzero (&attrs
, sizeof attrs
);
6649 attrs
.visual
= FRAME_X_VISUAL (f
);
6650 attrs
.colormap
= FRAME_X_COLORMAP (f
);
6651 attrs
.valuemask
|= XpmVisual
;
6652 attrs
.valuemask
|= XpmColormap
;
6654 #ifdef ALLOC_XPM_COLORS
6655 /* Allocate colors with our own functions which handle
6656 failing color allocation more gracefully. */
6657 attrs
.color_closure
= f
;
6658 attrs
.alloc_color
= xpm_alloc_color
;
6659 attrs
.free_colors
= xpm_free_colors
;
6660 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
6661 #else /* not ALLOC_XPM_COLORS */
6662 /* Let the XPM lib allocate colors. */
6663 attrs
.valuemask
|= XpmReturnAllocPixels
;
6664 #ifdef XpmAllocCloseColors
6665 attrs
.alloc_close_colors
= 1;
6666 attrs
.valuemask
|= XpmAllocCloseColors
;
6667 #else /* not XpmAllocCloseColors */
6668 attrs
.closeness
= 600;
6669 attrs
.valuemask
|= XpmCloseness
;
6670 #endif /* not XpmAllocCloseColors */
6671 #endif /* ALLOC_XPM_COLORS */
6673 /* If image specification contains symbolic color definitions, add
6674 these to `attrs'. */
6675 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
6676 if (CONSP (color_symbols
))
6679 XpmColorSymbol
*xpm_syms
;
6682 attrs
.valuemask
|= XpmColorSymbols
;
6684 /* Count number of symbols. */
6685 attrs
.numsymbols
= 0;
6686 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
6689 /* Allocate an XpmColorSymbol array. */
6690 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
6691 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
6692 bzero (xpm_syms
, size
);
6693 attrs
.colorsymbols
= xpm_syms
;
6695 /* Fill the color symbol array. */
6696 for (tail
= color_symbols
, i
= 0;
6698 ++i
, tail
= XCDR (tail
))
6700 Lisp_Object name
= XCAR (XCAR (tail
));
6701 Lisp_Object color
= XCDR (XCAR (tail
));
6702 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
6703 strcpy (xpm_syms
[i
].name
, SDATA (name
));
6704 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
6705 strcpy (xpm_syms
[i
].value
, SDATA (color
));
6709 /* Create a pixmap for the image, either from a file, or from a
6710 string buffer containing data in the same format as an XPM file. */
6711 #ifdef ALLOC_XPM_COLORS
6712 xpm_init_color_cache (f
, &attrs
);
6715 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6716 if (STRINGP (specified_file
))
6718 Lisp_Object file
= x_find_image_file (specified_file
);
6719 if (!STRINGP (file
))
6721 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6725 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6726 SDATA (file
), &img
->pixmap
, &img
->mask
,
6731 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
6732 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6734 &img
->pixmap
, &img
->mask
,
6738 if (rc
== XpmSuccess
)
6740 #ifdef ALLOC_XPM_COLORS
6741 img
->colors
= colors_in_color_table (&img
->ncolors
);
6742 #else /* not ALLOC_XPM_COLORS */
6745 img
->ncolors
= attrs
.nalloc_pixels
;
6746 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
6747 * sizeof *img
->colors
);
6748 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
6750 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
6751 #ifdef DEBUG_X_COLORS
6752 register_color (img
->colors
[i
]);
6755 #endif /* not ALLOC_XPM_COLORS */
6757 img
->width
= attrs
.width
;
6758 img
->height
= attrs
.height
;
6759 xassert (img
->width
> 0 && img
->height
> 0);
6761 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
6762 XpmFreeAttributes (&attrs
);
6769 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
6772 case XpmFileInvalid
:
6773 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
6777 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
6780 case XpmColorFailed
:
6781 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
6785 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
6790 #ifdef ALLOC_XPM_COLORS
6791 xpm_free_color_cache ();
6793 return rc
== XpmSuccess
;
6796 #endif /* HAVE_XPM != 0 */
6799 /***********************************************************************
6801 ***********************************************************************/
6803 /* An entry in the color table mapping an RGB color to a pixel color. */
6808 unsigned long pixel
;
6810 /* Next in color table collision list. */
6811 struct ct_color
*next
;
6814 /* The bucket vector size to use. Must be prime. */
6818 /* Value is a hash of the RGB color given by R, G, and B. */
6820 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
6822 /* The color hash table. */
6824 struct ct_color
**ct_table
;
6826 /* Number of entries in the color table. */
6828 int ct_colors_allocated
;
6830 /* Initialize the color table. */
6835 int size
= CT_SIZE
* sizeof (*ct_table
);
6836 ct_table
= (struct ct_color
**) xmalloc (size
);
6837 bzero (ct_table
, size
);
6838 ct_colors_allocated
= 0;
6842 /* Free memory associated with the color table. */
6848 struct ct_color
*p
, *next
;
6850 for (i
= 0; i
< CT_SIZE
; ++i
)
6851 for (p
= ct_table
[i
]; p
; p
= next
)
6862 /* Value is a pixel color for RGB color R, G, B on frame F. If an
6863 entry for that color already is in the color table, return the
6864 pixel color of that entry. Otherwise, allocate a new color for R,
6865 G, B, and make an entry in the color table. */
6867 static unsigned long
6868 lookup_rgb_color (f
, r
, g
, b
)
6872 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
6873 int i
= hash
% CT_SIZE
;
6875 struct x_display_info
*dpyinfo
;
6877 /* Handle TrueColor visuals specially, which improves performance by
6878 two orders of magnitude. Freeing colors on TrueColor visuals is
6879 a nop, and pixel colors specify RGB values directly. See also
6880 the Xlib spec, chapter 3.1. */
6881 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6882 if (dpyinfo
->red_bits
> 0)
6884 unsigned long pr
, pg
, pb
;
6886 /* Apply gamma-correction like normal color allocation does. */
6890 color
.red
= r
, color
.green
= g
, color
.blue
= b
;
6891 gamma_correct (f
, &color
);
6892 r
= color
.red
, g
= color
.green
, b
= color
.blue
;
6895 /* Scale down RGB values to the visual's bits per RGB, and shift
6896 them to the right position in the pixel color. Note that the
6897 original RGB values are 16-bit values, as usual in X. */
6898 pr
= (r
>> (16 - dpyinfo
->red_bits
)) << dpyinfo
->red_offset
;
6899 pg
= (g
>> (16 - dpyinfo
->green_bits
)) << dpyinfo
->green_offset
;
6900 pb
= (b
>> (16 - dpyinfo
->blue_bits
)) << dpyinfo
->blue_offset
;
6902 /* Assemble the pixel color. */
6903 return pr
| pg
| pb
;
6906 for (p
= ct_table
[i
]; p
; p
= p
->next
)
6907 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
6920 cmap
= FRAME_X_COLORMAP (f
);
6921 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
6925 ++ct_colors_allocated
;
6927 p
= (struct ct_color
*) xmalloc (sizeof *p
);
6931 p
->pixel
= color
.pixel
;
6932 p
->next
= ct_table
[i
];
6936 return FRAME_FOREGROUND_PIXEL (f
);
6943 /* Look up pixel color PIXEL which is used on frame F in the color
6944 table. If not already present, allocate it. Value is PIXEL. */
6946 static unsigned long
6947 lookup_pixel_color (f
, pixel
)
6949 unsigned long pixel
;
6951 int i
= pixel
% CT_SIZE
;
6954 for (p
= ct_table
[i
]; p
; p
= p
->next
)
6955 if (p
->pixel
== pixel
)
6964 cmap
= FRAME_X_COLORMAP (f
);
6965 color
.pixel
= pixel
;
6966 x_query_color (f
, &color
);
6967 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
6971 ++ct_colors_allocated
;
6973 p
= (struct ct_color
*) xmalloc (sizeof *p
);
6978 p
->next
= ct_table
[i
];
6982 return FRAME_FOREGROUND_PIXEL (f
);
6989 /* Value is a vector of all pixel colors contained in the color table,
6990 allocated via xmalloc. Set *N to the number of colors. */
6992 static unsigned long *
6993 colors_in_color_table (n
)
6998 unsigned long *colors
;
7000 if (ct_colors_allocated
== 0)
7007 colors
= (unsigned long *) xmalloc (ct_colors_allocated
7009 *n
= ct_colors_allocated
;
7011 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
7012 for (p
= ct_table
[i
]; p
; p
= p
->next
)
7013 colors
[j
++] = p
->pixel
;
7021 /***********************************************************************
7023 ***********************************************************************/
7025 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
7026 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
7027 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
7029 /* Non-zero means draw a cross on images having `:conversion
7032 int cross_disabled_images
;
7034 /* Edge detection matrices for different edge-detection
7037 static int emboss_matrix
[9] = {
7039 2, -1, 0, /* y - 1 */
7041 0, 1, -2 /* y + 1 */
7044 static int laplace_matrix
[9] = {
7046 1, 0, 0, /* y - 1 */
7048 0, 0, -1 /* y + 1 */
7051 /* Value is the intensity of the color whose red/green/blue values
7054 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
7057 /* On frame F, return an array of XColor structures describing image
7058 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
7059 non-zero means also fill the red/green/blue members of the XColor
7060 structures. Value is a pointer to the array of XColors structures,
7061 allocated with xmalloc; it must be freed by the caller. */
7064 x_to_xcolors (f
, img
, rgb_p
)
7073 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
7075 /* Get the X image IMG->pixmap. */
7076 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
7077 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
7079 /* Fill the `pixel' members of the XColor array. I wished there
7080 were an easy and portable way to circumvent XGetPixel. */
7082 for (y
= 0; y
< img
->height
; ++y
)
7086 for (x
= 0; x
< img
->width
; ++x
, ++p
)
7087 p
->pixel
= XGetPixel (ximg
, x
, y
);
7090 x_query_colors (f
, row
, img
->width
);
7093 XDestroyImage (ximg
);
7098 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
7099 RGB members are set. F is the frame on which this all happens.
7100 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
7103 x_from_xcolors (f
, img
, colors
)
7113 init_color_table ();
7115 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
7118 for (y
= 0; y
< img
->height
; ++y
)
7119 for (x
= 0; x
< img
->width
; ++x
, ++p
)
7121 unsigned long pixel
;
7122 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
7123 XPutPixel (oimg
, x
, y
, pixel
);
7127 x_clear_image_1 (f
, img
, 1, 0, 1);
7129 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
7130 x_destroy_x_image (oimg
);
7131 img
->pixmap
= pixmap
;
7132 img
->colors
= colors_in_color_table (&img
->ncolors
);
7133 free_color_table ();
7137 /* On frame F, perform edge-detection on image IMG.
7139 MATRIX is a nine-element array specifying the transformation
7140 matrix. See emboss_matrix for an example.
7142 COLOR_ADJUST is a color adjustment added to each pixel of the
7146 x_detect_edges (f
, img
, matrix
, color_adjust
)
7149 int matrix
[9], color_adjust
;
7151 XColor
*colors
= x_to_xcolors (f
, img
, 1);
7155 for (i
= sum
= 0; i
< 9; ++i
)
7156 sum
+= abs (matrix
[i
]);
7158 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
7160 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
7162 for (y
= 0; y
< img
->height
; ++y
)
7164 p
= COLOR (new, 0, y
);
7165 p
->red
= p
->green
= p
->blue
= 0xffff/2;
7166 p
= COLOR (new, img
->width
- 1, y
);
7167 p
->red
= p
->green
= p
->blue
= 0xffff/2;
7170 for (x
= 1; x
< img
->width
- 1; ++x
)
7172 p
= COLOR (new, x
, 0);
7173 p
->red
= p
->green
= p
->blue
= 0xffff/2;
7174 p
= COLOR (new, x
, img
->height
- 1);
7175 p
->red
= p
->green
= p
->blue
= 0xffff/2;
7178 for (y
= 1; y
< img
->height
- 1; ++y
)
7180 p
= COLOR (new, 1, y
);
7182 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
7184 int r
, g
, b
, y1
, x1
;
7187 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
7188 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
7191 XColor
*t
= COLOR (colors
, x1
, y1
);
7192 r
+= matrix
[i
] * t
->red
;
7193 g
+= matrix
[i
] * t
->green
;
7194 b
+= matrix
[i
] * t
->blue
;
7197 r
= (r
/ sum
+ color_adjust
) & 0xffff;
7198 g
= (g
/ sum
+ color_adjust
) & 0xffff;
7199 b
= (b
/ sum
+ color_adjust
) & 0xffff;
7200 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
7205 x_from_xcolors (f
, img
, new);
7211 /* Perform the pre-defined `emboss' edge-detection on image IMG
7219 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
7223 /* Perform the pre-defined `laplace' edge-detection on image IMG
7231 x_detect_edges (f
, img
, laplace_matrix
, 45000);
7235 /* Perform edge-detection on image IMG on frame F, with specified
7236 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
7238 MATRIX must be either
7240 - a list of at least 9 numbers in row-major form
7241 - a vector of at least 9 numbers
7243 COLOR_ADJUST nil means use a default; otherwise it must be a
7247 x_edge_detection (f
, img
, matrix
, color_adjust
)
7250 Lisp_Object matrix
, color_adjust
;
7258 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
7259 ++i
, matrix
= XCDR (matrix
))
7260 trans
[i
] = XFLOATINT (XCAR (matrix
));
7262 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
7264 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
7265 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
7268 if (NILP (color_adjust
))
7269 color_adjust
= make_number (0xffff / 2);
7271 if (i
== 9 && NUMBERP (color_adjust
))
7272 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
7276 /* Transform image IMG on frame F so that it looks disabled. */
7279 x_disable_image (f
, img
)
7283 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
7285 if (dpyinfo
->n_planes
>= 2)
7287 /* Color (or grayscale). Convert to gray, and equalize. Just
7288 drawing such images with a stipple can look very odd, so
7289 we're using this method instead. */
7290 XColor
*colors
= x_to_xcolors (f
, img
, 1);
7292 const int h
= 15000;
7293 const int l
= 30000;
7295 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
7299 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
7300 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
7301 p
->red
= p
->green
= p
->blue
= i2
;
7304 x_from_xcolors (f
, img
, colors
);
7307 /* Draw a cross over the disabled image, if we must or if we
7309 if (dpyinfo
->n_planes
< 2 || cross_disabled_images
)
7311 Display
*dpy
= FRAME_X_DISPLAY (f
);
7314 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
7315 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
7316 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
7317 img
->width
- 1, img
->height
- 1);
7318 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
7324 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
7325 XSetForeground (dpy
, gc
, WHITE_PIX_DEFAULT (f
));
7326 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
7327 img
->width
- 1, img
->height
- 1);
7328 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
7336 /* Build a mask for image IMG which is used on frame F. FILE is the
7337 name of an image file, for error messages. HOW determines how to
7338 determine the background color of IMG. If it is a list '(R G B)',
7339 with R, G, and B being integers >= 0, take that as the color of the
7340 background. Otherwise, determine the background color of IMG
7341 heuristically. Value is non-zero if successful. */
7344 x_build_heuristic_mask (f
, img
, how
)
7349 Display
*dpy
= FRAME_X_DISPLAY (f
);
7350 XImage
*ximg
, *mask_img
;
7351 int x
, y
, rc
, use_img_background
;
7352 unsigned long bg
= 0;
7356 XFreePixmap (FRAME_X_DISPLAY (f
), img
->mask
);
7358 img
->background_transparent_valid
= 0;
7361 /* Create an image and pixmap serving as mask. */
7362 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
7363 &mask_img
, &img
->mask
);
7367 /* Get the X image of IMG->pixmap. */
7368 ximg
= XGetImage (dpy
, img
->pixmap
, 0, 0, img
->width
, img
->height
,
7371 /* Determine the background color of ximg. If HOW is `(R G B)'
7372 take that as color. Otherwise, use the image's background color. */
7373 use_img_background
= 1;
7379 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
7381 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
7385 if (i
== 3 && NILP (how
))
7387 char color_name
[30];
7388 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
7389 bg
= x_alloc_image_color (f
, img
, build_string (color_name
), 0);
7390 use_img_background
= 0;
7394 if (use_img_background
)
7395 bg
= four_corners_best (ximg
, img
->width
, img
->height
);
7397 /* Set all bits in mask_img to 1 whose color in ximg is different
7398 from the background color bg. */
7399 for (y
= 0; y
< img
->height
; ++y
)
7400 for (x
= 0; x
< img
->width
; ++x
)
7401 XPutPixel (mask_img
, x
, y
, XGetPixel (ximg
, x
, y
) != bg
);
7403 /* Fill in the background_transparent field while we have the mask handy. */
7404 image_background_transparent (img
, f
, mask_img
);
7406 /* Put mask_img into img->mask. */
7407 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
7408 x_destroy_x_image (mask_img
);
7409 XDestroyImage (ximg
);
7416 /***********************************************************************
7417 PBM (mono, gray, color)
7418 ***********************************************************************/
7420 static int pbm_image_p
P_ ((Lisp_Object object
));
7421 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
7422 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
7424 /* The symbol `pbm' identifying images of this type. */
7428 /* Indices of image specification fields in gs_format, below. */
7430 enum pbm_keyword_index
7446 /* Vector of image_keyword structures describing the format
7447 of valid user-defined image specifications. */
7449 static struct image_keyword pbm_format
[PBM_LAST
] =
7451 {":type", IMAGE_SYMBOL_VALUE
, 1},
7452 {":file", IMAGE_STRING_VALUE
, 0},
7453 {":data", IMAGE_STRING_VALUE
, 0},
7454 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7455 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7456 {":relief", IMAGE_INTEGER_VALUE
, 0},
7457 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7458 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7459 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7460 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
7461 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7464 /* Structure describing the image type `pbm'. */
7466 static struct image_type pbm_type
=
7476 /* Return non-zero if OBJECT is a valid PBM image specification. */
7479 pbm_image_p (object
)
7482 struct image_keyword fmt
[PBM_LAST
];
7484 bcopy (pbm_format
, fmt
, sizeof fmt
);
7486 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
7489 /* Must specify either :data or :file. */
7490 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
7494 /* Scan a decimal number from *S and return it. Advance *S while
7495 reading the number. END is the end of the string. Value is -1 at
7499 pbm_scan_number (s
, end
)
7500 unsigned char **s
, *end
;
7502 int c
= 0, val
= -1;
7506 /* Skip white-space. */
7507 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
7512 /* Skip comment to end of line. */
7513 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
7516 else if (isdigit (c
))
7518 /* Read decimal number. */
7520 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
7521 val
= 10 * val
+ c
- '0';
7532 /* Load PBM image IMG for use on frame F. */
7540 int width
, height
, max_color_idx
= 0;
7542 Lisp_Object file
, specified_file
;
7543 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
7544 struct gcpro gcpro1
;
7545 unsigned char *contents
= NULL
;
7546 unsigned char *end
, *p
;
7549 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7553 if (STRINGP (specified_file
))
7555 file
= x_find_image_file (specified_file
);
7556 if (!STRINGP (file
))
7558 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7563 contents
= slurp_file (SDATA (file
), &size
);
7564 if (contents
== NULL
)
7566 image_error ("Error reading `%s'", file
, Qnil
);
7572 end
= contents
+ size
;
7577 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7579 end
= p
+ SBYTES (data
);
7582 /* Check magic number. */
7583 if (end
- p
< 2 || *p
++ != 'P')
7585 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
7595 raw_p
= 0, type
= PBM_MONO
;
7599 raw_p
= 0, type
= PBM_GRAY
;
7603 raw_p
= 0, type
= PBM_COLOR
;
7607 raw_p
= 1, type
= PBM_MONO
;
7611 raw_p
= 1, type
= PBM_GRAY
;
7615 raw_p
= 1, type
= PBM_COLOR
;
7619 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
7623 /* Read width, height, maximum color-component. Characters
7624 starting with `#' up to the end of a line are ignored. */
7625 width
= pbm_scan_number (&p
, end
);
7626 height
= pbm_scan_number (&p
, end
);
7628 if (type
!= PBM_MONO
)
7630 max_color_idx
= pbm_scan_number (&p
, end
);
7631 if (raw_p
&& max_color_idx
> 255)
7632 max_color_idx
= 255;
7637 || (type
!= PBM_MONO
&& max_color_idx
< 0))
7640 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
7641 &ximg
, &img
->pixmap
))
7644 /* Initialize the color hash table. */
7645 init_color_table ();
7647 if (type
== PBM_MONO
)
7650 struct image_keyword fmt
[PBM_LAST
];
7651 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
7652 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
7654 /* Parse the image specification. */
7655 bcopy (pbm_format
, fmt
, sizeof fmt
);
7656 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
7658 /* Get foreground and background colors, maybe allocate colors. */
7659 if (fmt
[PBM_FOREGROUND
].count
7660 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
7661 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
7662 if (fmt
[PBM_BACKGROUND
].count
7663 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
7665 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
7666 img
->background
= bg
;
7667 img
->background_valid
= 1;
7670 for (y
= 0; y
< height
; ++y
)
7671 for (x
= 0; x
< width
; ++x
)
7681 g
= pbm_scan_number (&p
, end
);
7683 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
7688 for (y
= 0; y
< height
; ++y
)
7689 for (x
= 0; x
< width
; ++x
)
7693 if (type
== PBM_GRAY
)
7694 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
7703 r
= pbm_scan_number (&p
, end
);
7704 g
= pbm_scan_number (&p
, end
);
7705 b
= pbm_scan_number (&p
, end
);
7708 if (r
< 0 || g
< 0 || b
< 0)
7712 XDestroyImage (ximg
);
7713 image_error ("Invalid pixel value in image `%s'",
7718 /* RGB values are now in the range 0..max_color_idx.
7719 Scale this to the range 0..0xffff supported by X. */
7720 r
= (double) r
* 65535 / max_color_idx
;
7721 g
= (double) g
* 65535 / max_color_idx
;
7722 b
= (double) b
* 65535 / max_color_idx
;
7723 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
7727 /* Store in IMG->colors the colors allocated for the image, and
7728 free the color table. */
7729 img
->colors
= colors_in_color_table (&img
->ncolors
);
7730 free_color_table ();
7732 /* Maybe fill in the background field while we have ximg handy. */
7733 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7734 IMAGE_BACKGROUND (img
, f
, ximg
);
7736 /* Put the image into a pixmap. */
7737 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7738 x_destroy_x_image (ximg
);
7741 img
->height
= height
;
7750 /***********************************************************************
7752 ***********************************************************************/
7756 #if defined HAVE_LIBPNG_PNG_H
7757 # include <libpng/png.h>
7762 /* Function prototypes. */
7764 static int png_image_p
P_ ((Lisp_Object object
));
7765 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
7767 /* The symbol `png' identifying images of this type. */
7771 /* Indices of image specification fields in png_format, below. */
7773 enum png_keyword_index
7788 /* Vector of image_keyword structures describing the format
7789 of valid user-defined image specifications. */
7791 static struct image_keyword png_format
[PNG_LAST
] =
7793 {":type", IMAGE_SYMBOL_VALUE
, 1},
7794 {":data", IMAGE_STRING_VALUE
, 0},
7795 {":file", IMAGE_STRING_VALUE
, 0},
7796 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7797 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7798 {":relief", IMAGE_INTEGER_VALUE
, 0},
7799 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7800 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7801 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7802 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7805 /* Structure describing the image type `png'. */
7807 static struct image_type png_type
=
7817 /* Return non-zero if OBJECT is a valid PNG image specification. */
7820 png_image_p (object
)
7823 struct image_keyword fmt
[PNG_LAST
];
7824 bcopy (png_format
, fmt
, sizeof fmt
);
7826 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
7829 /* Must specify either the :data or :file keyword. */
7830 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
7834 /* Error and warning handlers installed when the PNG library
7838 my_png_error (png_ptr
, msg
)
7839 png_struct
*png_ptr
;
7842 xassert (png_ptr
!= NULL
);
7843 image_error ("PNG error: %s", build_string (msg
), Qnil
);
7844 longjmp (png_ptr
->jmpbuf
, 1);
7849 my_png_warning (png_ptr
, msg
)
7850 png_struct
*png_ptr
;
7853 xassert (png_ptr
!= NULL
);
7854 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
7857 /* Memory source for PNG decoding. */
7859 struct png_memory_storage
7861 unsigned char *bytes
; /* The data */
7862 size_t len
; /* How big is it? */
7863 int index
; /* Where are we? */
7867 /* Function set as reader function when reading PNG image from memory.
7868 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
7869 bytes from the input to DATA. */
7872 png_read_from_memory (png_ptr
, data
, length
)
7873 png_structp png_ptr
;
7877 struct png_memory_storage
*tbr
7878 = (struct png_memory_storage
*) png_get_io_ptr (png_ptr
);
7880 if (length
> tbr
->len
- tbr
->index
)
7881 png_error (png_ptr
, "Read error");
7883 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
7884 tbr
->index
= tbr
->index
+ length
;
7887 /* Load PNG image IMG for use on frame F. Value is non-zero if
7895 Lisp_Object file
, specified_file
;
7896 Lisp_Object specified_data
;
7898 XImage
*ximg
, *mask_img
= NULL
;
7899 struct gcpro gcpro1
;
7900 png_struct
*png_ptr
= NULL
;
7901 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
7902 FILE *volatile fp
= NULL
;
7904 png_byte
* volatile pixels
= NULL
;
7905 png_byte
** volatile rows
= NULL
;
7906 png_uint_32 width
, height
;
7907 int bit_depth
, color_type
, interlace_type
;
7909 png_uint_32 row_bytes
;
7911 double screen_gamma
;
7912 struct png_memory_storage tbr
; /* Data to be read */
7914 /* Find out what file to load. */
7915 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7916 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7920 if (NILP (specified_data
))
7922 file
= x_find_image_file (specified_file
);
7923 if (!STRINGP (file
))
7925 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7930 /* Open the image file. */
7931 fp
= fopen (SDATA (file
), "rb");
7934 image_error ("Cannot open image file `%s'", file
, Qnil
);
7940 /* Check PNG signature. */
7941 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
7942 || !png_check_sig (sig
, sizeof sig
))
7944 image_error ("Not a PNG file: `%s'", file
, Qnil
);
7952 /* Read from memory. */
7953 tbr
.bytes
= SDATA (specified_data
);
7954 tbr
.len
= SBYTES (specified_data
);
7957 /* Check PNG signature. */
7958 if (tbr
.len
< sizeof sig
7959 || !png_check_sig (tbr
.bytes
, sizeof sig
))
7961 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
7966 /* Need to skip past the signature. */
7967 tbr
.bytes
+= sizeof (sig
);
7970 /* Initialize read and info structs for PNG lib. */
7971 png_ptr
= png_create_read_struct (PNG_LIBPNG_VER_STRING
, NULL
,
7972 my_png_error
, my_png_warning
);
7975 if (fp
) fclose (fp
);
7980 info_ptr
= png_create_info_struct (png_ptr
);
7983 png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
7984 if (fp
) fclose (fp
);
7989 end_info
= png_create_info_struct (png_ptr
);
7992 png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
7993 if (fp
) fclose (fp
);
7998 /* Set error jump-back. We come back here when the PNG library
7999 detects an error. */
8000 if (setjmp (png_ptr
->jmpbuf
))
8004 png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
8007 if (fp
) fclose (fp
);
8012 /* Read image info. */
8013 if (!NILP (specified_data
))
8014 png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
8016 png_init_io (png_ptr
, fp
);
8018 png_set_sig_bytes (png_ptr
, sizeof sig
);
8019 png_read_info (png_ptr
, info_ptr
);
8020 png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
8021 &interlace_type
, NULL
, NULL
);
8023 /* If image contains simply transparency data, we prefer to
8024 construct a clipping mask. */
8025 if (png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
8030 /* This function is easier to write if we only have to handle
8031 one data format: RGB or RGBA with 8 bits per channel. Let's
8032 transform other formats into that format. */
8034 /* Strip more than 8 bits per channel. */
8035 if (bit_depth
== 16)
8036 png_set_strip_16 (png_ptr
);
8038 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
8040 png_set_expand (png_ptr
);
8042 /* Convert grayscale images to RGB. */
8043 if (color_type
== PNG_COLOR_TYPE_GRAY
8044 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
8045 png_set_gray_to_rgb (png_ptr
);
8047 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
8049 #if 0 /* Avoid double gamma correction for PNG images. */
8050 { /* Tell the PNG lib to handle gamma correction for us. */
8053 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
8054 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
8055 /* The libpng documentation says this is right in this case. */
8056 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
8059 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
8060 /* Image contains gamma information. */
8061 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
8063 /* Use the standard default for the image gamma. */
8064 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
8068 /* Handle alpha channel by combining the image with a background
8069 color. Do this only if a real alpha channel is supplied. For
8070 simple transparency, we prefer a clipping mask. */
8073 png_color_16
*image_bg
;
8074 Lisp_Object specified_bg
8075 = image_spec_value (img
->spec
, QCbackground
, NULL
);
8077 if (STRINGP (specified_bg
))
8078 /* The user specified `:background', use that. */
8081 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
8083 png_color_16 user_bg
;
8085 bzero (&user_bg
, sizeof user_bg
);
8086 user_bg
.red
= color
.red
;
8087 user_bg
.green
= color
.green
;
8088 user_bg
.blue
= color
.blue
;
8090 png_set_background (png_ptr
, &user_bg
,
8091 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
8094 else if (png_get_bKGD (png_ptr
, info_ptr
, &image_bg
))
8095 /* Image contains a background color with which to
8096 combine the image. */
8097 png_set_background (png_ptr
, image_bg
,
8098 PNG_BACKGROUND_GAMMA_FILE
, 1, 1.0);
8101 /* Image does not contain a background color with which
8102 to combine the image data via an alpha channel. Use
8103 the frame's background instead. */
8106 png_color_16 frame_background
;
8108 cmap
= FRAME_X_COLORMAP (f
);
8109 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
8110 x_query_color (f
, &color
);
8112 bzero (&frame_background
, sizeof frame_background
);
8113 frame_background
.red
= color
.red
;
8114 frame_background
.green
= color
.green
;
8115 frame_background
.blue
= color
.blue
;
8117 png_set_background (png_ptr
, &frame_background
,
8118 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
8122 /* Update info structure. */
8123 png_read_update_info (png_ptr
, info_ptr
);
8125 /* Get number of channels. Valid values are 1 for grayscale images
8126 and images with a palette, 2 for grayscale images with transparency
8127 information (alpha channel), 3 for RGB images, and 4 for RGB
8128 images with alpha channel, i.e. RGBA. If conversions above were
8129 sufficient we should only have 3 or 4 channels here. */
8130 channels
= png_get_channels (png_ptr
, info_ptr
);
8131 xassert (channels
== 3 || channels
== 4);
8133 /* Number of bytes needed for one row of the image. */
8134 row_bytes
= png_get_rowbytes (png_ptr
, info_ptr
);
8136 /* Allocate memory for the image. */
8137 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
8138 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
8139 for (i
= 0; i
< height
; ++i
)
8140 rows
[i
] = pixels
+ i
* row_bytes
;
8142 /* Read the entire image. */
8143 png_read_image (png_ptr
, rows
);
8144 png_read_end (png_ptr
, info_ptr
);
8151 /* Create the X image and pixmap. */
8152 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
8156 /* Create an image and pixmap serving as mask if the PNG image
8157 contains an alpha channel. */
8160 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
8161 &mask_img
, &img
->mask
))
8163 x_destroy_x_image (ximg
);
8164 XFreePixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
8169 /* Fill the X image and mask from PNG data. */
8170 init_color_table ();
8172 for (y
= 0; y
< height
; ++y
)
8174 png_byte
*p
= rows
[y
];
8176 for (x
= 0; x
< width
; ++x
)
8183 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
8185 /* An alpha channel, aka mask channel, associates variable
8186 transparency with an image. Where other image formats
8187 support binary transparency---fully transparent or fully
8188 opaque---PNG allows up to 254 levels of partial transparency.
8189 The PNG library implements partial transparency by combining
8190 the image with a specified background color.
8192 I'm not sure how to handle this here nicely: because the
8193 background on which the image is displayed may change, for
8194 real alpha channel support, it would be necessary to create
8195 a new image for each possible background.
8197 What I'm doing now is that a mask is created if we have
8198 boolean transparency information. Otherwise I'm using
8199 the frame's background color to combine the image with. */
8204 XPutPixel (mask_img
, x
, y
, *p
> 0);
8210 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8211 /* Set IMG's background color from the PNG image, unless the user
8215 if (png_get_bKGD (png_ptr
, info_ptr
, &bg
))
8217 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
8218 img
->background_valid
= 1;
8222 /* Remember colors allocated for this image. */
8223 img
->colors
= colors_in_color_table (&img
->ncolors
);
8224 free_color_table ();
8227 png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
8232 img
->height
= height
;
8234 /* Maybe fill in the background field while we have ximg handy. */
8235 IMAGE_BACKGROUND (img
, f
, ximg
);
8237 /* Put the image into the pixmap, then free the X image and its buffer. */
8238 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8239 x_destroy_x_image (ximg
);
8241 /* Same for the mask. */
8244 /* Fill in the background_transparent field while we have the mask
8246 image_background_transparent (img
, f
, mask_img
);
8248 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
8249 x_destroy_x_image (mask_img
);
8256 #endif /* HAVE_PNG != 0 */
8260 /***********************************************************************
8262 ***********************************************************************/
8266 /* Work around a warning about HAVE_STDLIB_H being redefined in
8268 #ifdef HAVE_STDLIB_H
8269 #define HAVE_STDLIB_H_1
8270 #undef HAVE_STDLIB_H
8271 #endif /* HAVE_STLIB_H */
8273 #include <jpeglib.h>
8277 #ifdef HAVE_STLIB_H_1
8278 #define HAVE_STDLIB_H 1
8281 static int jpeg_image_p
P_ ((Lisp_Object object
));
8282 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
8284 /* The symbol `jpeg' identifying images of this type. */
8288 /* Indices of image specification fields in gs_format, below. */
8290 enum jpeg_keyword_index
8299 JPEG_HEURISTIC_MASK
,
8305 /* Vector of image_keyword structures describing the format
8306 of valid user-defined image specifications. */
8308 static struct image_keyword jpeg_format
[JPEG_LAST
] =
8310 {":type", IMAGE_SYMBOL_VALUE
, 1},
8311 {":data", IMAGE_STRING_VALUE
, 0},
8312 {":file", IMAGE_STRING_VALUE
, 0},
8313 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8314 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8315 {":relief", IMAGE_INTEGER_VALUE
, 0},
8316 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8317 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8318 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8319 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8322 /* Structure describing the image type `jpeg'. */
8324 static struct image_type jpeg_type
=
8334 /* Return non-zero if OBJECT is a valid JPEG image specification. */
8337 jpeg_image_p (object
)
8340 struct image_keyword fmt
[JPEG_LAST
];
8342 bcopy (jpeg_format
, fmt
, sizeof fmt
);
8344 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
8347 /* Must specify either the :data or :file keyword. */
8348 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
8352 struct my_jpeg_error_mgr
8354 struct jpeg_error_mgr pub
;
8355 jmp_buf setjmp_buffer
;
8360 my_error_exit (cinfo
)
8363 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
8364 longjmp (mgr
->setjmp_buffer
, 1);
8368 /* Init source method for JPEG data source manager. Called by
8369 jpeg_read_header() before any data is actually read. See
8370 libjpeg.doc from the JPEG lib distribution. */
8373 our_init_source (cinfo
)
8374 j_decompress_ptr cinfo
;
8379 /* Fill input buffer method for JPEG data source manager. Called
8380 whenever more data is needed. We read the whole image in one step,
8381 so this only adds a fake end of input marker at the end. */
8384 our_fill_input_buffer (cinfo
)
8385 j_decompress_ptr cinfo
;
8387 /* Insert a fake EOI marker. */
8388 struct jpeg_source_mgr
*src
= cinfo
->src
;
8389 static JOCTET buffer
[2];
8391 buffer
[0] = (JOCTET
) 0xFF;
8392 buffer
[1] = (JOCTET
) JPEG_EOI
;
8394 src
->next_input_byte
= buffer
;
8395 src
->bytes_in_buffer
= 2;
8400 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
8401 is the JPEG data source manager. */
8404 our_skip_input_data (cinfo
, num_bytes
)
8405 j_decompress_ptr cinfo
;
8408 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
8412 if (num_bytes
> src
->bytes_in_buffer
)
8413 ERREXIT (cinfo
, JERR_INPUT_EOF
);
8415 src
->bytes_in_buffer
-= num_bytes
;
8416 src
->next_input_byte
+= num_bytes
;
8421 /* Method to terminate data source. Called by
8422 jpeg_finish_decompress() after all data has been processed. */
8425 our_term_source (cinfo
)
8426 j_decompress_ptr cinfo
;
8431 /* Set up the JPEG lib for reading an image from DATA which contains
8432 LEN bytes. CINFO is the decompression info structure created for
8433 reading the image. */
8436 jpeg_memory_src (cinfo
, data
, len
)
8437 j_decompress_ptr cinfo
;
8441 struct jpeg_source_mgr
*src
;
8443 if (cinfo
->src
== NULL
)
8445 /* First time for this JPEG object? */
8446 cinfo
->src
= (struct jpeg_source_mgr
*)
8447 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
8448 sizeof (struct jpeg_source_mgr
));
8449 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
8450 src
->next_input_byte
= data
;
8453 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
8454 src
->init_source
= our_init_source
;
8455 src
->fill_input_buffer
= our_fill_input_buffer
;
8456 src
->skip_input_data
= our_skip_input_data
;
8457 src
->resync_to_restart
= jpeg_resync_to_restart
; /* Use default method. */
8458 src
->term_source
= our_term_source
;
8459 src
->bytes_in_buffer
= len
;
8460 src
->next_input_byte
= data
;
8464 /* Load image IMG for use on frame F. Patterned after example.c
8465 from the JPEG lib. */
8472 struct jpeg_decompress_struct cinfo
;
8473 struct my_jpeg_error_mgr mgr
;
8474 Lisp_Object file
, specified_file
;
8475 Lisp_Object specified_data
;
8476 FILE * volatile fp
= NULL
;
8478 int row_stride
, x
, y
;
8479 XImage
*ximg
= NULL
;
8481 unsigned long *colors
;
8483 struct gcpro gcpro1
;
8485 /* Open the JPEG file. */
8486 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
8487 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8491 if (NILP (specified_data
))
8493 file
= x_find_image_file (specified_file
);
8494 if (!STRINGP (file
))
8496 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
8501 fp
= fopen (SDATA (file
), "r");
8504 image_error ("Cannot open `%s'", file
, Qnil
);
8510 /* Customize libjpeg's error handling to call my_error_exit when an
8511 error is detected. This function will perform a longjmp. */
8512 cinfo
.err
= jpeg_std_error (&mgr
.pub
);
8513 mgr
.pub
.error_exit
= my_error_exit
;
8515 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
8519 /* Called from my_error_exit. Display a JPEG error. */
8520 char buffer
[JMSG_LENGTH_MAX
];
8521 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
8522 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
8523 build_string (buffer
));
8526 /* Close the input file and destroy the JPEG object. */
8528 fclose ((FILE *) fp
);
8529 jpeg_destroy_decompress (&cinfo
);
8531 /* If we already have an XImage, free that. */
8532 x_destroy_x_image (ximg
);
8534 /* Free pixmap and colors. */
8535 x_clear_image (f
, img
);
8541 /* Create the JPEG decompression object. Let it read from fp.
8542 Read the JPEG image header. */
8543 jpeg_create_decompress (&cinfo
);
8545 if (NILP (specified_data
))
8546 jpeg_stdio_src (&cinfo
, (FILE *) fp
);
8548 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
8549 SBYTES (specified_data
));
8551 jpeg_read_header (&cinfo
, TRUE
);
8553 /* Customize decompression so that color quantization will be used.
8554 Start decompression. */
8555 cinfo
.quantize_colors
= TRUE
;
8556 jpeg_start_decompress (&cinfo
);
8557 width
= img
->width
= cinfo
.output_width
;
8558 height
= img
->height
= cinfo
.output_height
;
8560 /* Create X image and pixmap. */
8561 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8562 longjmp (mgr
.setjmp_buffer
, 2);
8564 /* Allocate colors. When color quantization is used,
8565 cinfo.actual_number_of_colors has been set with the number of
8566 colors generated, and cinfo.colormap is a two-dimensional array
8567 of color indices in the range 0..cinfo.actual_number_of_colors.
8568 No more than 255 colors will be generated. */
8572 if (cinfo
.out_color_components
> 2)
8573 ir
= 0, ig
= 1, ib
= 2;
8574 else if (cinfo
.out_color_components
> 1)
8575 ir
= 0, ig
= 1, ib
= 0;
8577 ir
= 0, ig
= 0, ib
= 0;
8579 /* Use the color table mechanism because it handles colors that
8580 cannot be allocated nicely. Such colors will be replaced with
8581 a default color, and we don't have to care about which colors
8582 can be freed safely, and which can't. */
8583 init_color_table ();
8584 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
8587 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
8589 /* Multiply RGB values with 255 because X expects RGB values
8590 in the range 0..0xffff. */
8591 int r
= cinfo
.colormap
[ir
][i
] << 8;
8592 int g
= cinfo
.colormap
[ig
][i
] << 8;
8593 int b
= cinfo
.colormap
[ib
][i
] << 8;
8594 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
8597 /* Remember those colors actually allocated. */
8598 img
->colors
= colors_in_color_table (&img
->ncolors
);
8599 free_color_table ();
8603 row_stride
= width
* cinfo
.output_components
;
8604 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
8606 for (y
= 0; y
< height
; ++y
)
8608 jpeg_read_scanlines (&cinfo
, buffer
, 1);
8609 for (x
= 0; x
< cinfo
.output_width
; ++x
)
8610 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
8614 jpeg_finish_decompress (&cinfo
);
8615 jpeg_destroy_decompress (&cinfo
);
8617 fclose ((FILE *) fp
);
8619 /* Maybe fill in the background field while we have ximg handy. */
8620 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8621 IMAGE_BACKGROUND (img
, f
, ximg
);
8623 /* Put the image into the pixmap. */
8624 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8625 x_destroy_x_image (ximg
);
8630 #endif /* HAVE_JPEG */
8634 /***********************************************************************
8636 ***********************************************************************/
8642 static int tiff_image_p
P_ ((Lisp_Object object
));
8643 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
8645 /* The symbol `tiff' identifying images of this type. */
8649 /* Indices of image specification fields in tiff_format, below. */
8651 enum tiff_keyword_index
8660 TIFF_HEURISTIC_MASK
,
8666 /* Vector of image_keyword structures describing the format
8667 of valid user-defined image specifications. */
8669 static struct image_keyword tiff_format
[TIFF_LAST
] =
8671 {":type", IMAGE_SYMBOL_VALUE
, 1},
8672 {":data", IMAGE_STRING_VALUE
, 0},
8673 {":file", IMAGE_STRING_VALUE
, 0},
8674 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8675 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8676 {":relief", IMAGE_INTEGER_VALUE
, 0},
8677 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8678 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8679 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8680 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8683 /* Structure describing the image type `tiff'. */
8685 static struct image_type tiff_type
=
8695 /* Return non-zero if OBJECT is a valid TIFF image specification. */
8698 tiff_image_p (object
)
8701 struct image_keyword fmt
[TIFF_LAST
];
8702 bcopy (tiff_format
, fmt
, sizeof fmt
);
8704 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
8707 /* Must specify either the :data or :file keyword. */
8708 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
8712 /* Reading from a memory buffer for TIFF images Based on the PNG
8713 memory source, but we have to provide a lot of extra functions.
8716 We really only need to implement read and seek, but I am not
8717 convinced that the TIFF library is smart enough not to destroy
8718 itself if we only hand it the function pointers we need to
8723 unsigned char *bytes
;
8731 tiff_read_from_memory (data
, buf
, size
)
8736 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
8738 if (size
> src
->len
- src
->index
)
8740 bcopy (src
->bytes
+ src
->index
, buf
, size
);
8747 tiff_write_from_memory (data
, buf
, size
)
8757 tiff_seek_in_memory (data
, off
, whence
)
8762 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
8767 case SEEK_SET
: /* Go from beginning of source. */
8771 case SEEK_END
: /* Go from end of source. */
8772 idx
= src
->len
+ off
;
8775 case SEEK_CUR
: /* Go from current position. */
8776 idx
= src
->index
+ off
;
8779 default: /* Invalid `whence'. */
8783 if (idx
> src
->len
|| idx
< 0)
8792 tiff_close_memory (data
)
8801 tiff_mmap_memory (data
, pbase
, psize
)
8806 /* It is already _IN_ memory. */
8812 tiff_unmap_memory (data
, base
, size
)
8817 /* We don't need to do this. */
8822 tiff_size_of_memory (data
)
8825 return ((tiff_memory_source
*) data
)->len
;
8830 tiff_error_handler (title
, format
, ap
)
8831 const char *title
, *format
;
8837 len
= sprintf (buf
, "TIFF error: %s ", title
);
8838 vsprintf (buf
+ len
, format
, ap
);
8839 add_to_log (buf
, Qnil
, Qnil
);
8844 tiff_warning_handler (title
, format
, ap
)
8845 const char *title
, *format
;
8851 len
= sprintf (buf
, "TIFF warning: %s ", title
);
8852 vsprintf (buf
+ len
, format
, ap
);
8853 add_to_log (buf
, Qnil
, Qnil
);
8857 /* Load TIFF image IMG for use on frame F. Value is non-zero if
8865 Lisp_Object file
, specified_file
;
8866 Lisp_Object specified_data
;
8868 int width
, height
, x
, y
;
8872 struct gcpro gcpro1
;
8873 tiff_memory_source memsrc
;
8875 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
8876 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8880 TIFFSetErrorHandler (tiff_error_handler
);
8881 TIFFSetWarningHandler (tiff_warning_handler
);
8883 if (NILP (specified_data
))
8885 /* Read from a file */
8886 file
= x_find_image_file (specified_file
);
8887 if (!STRINGP (file
))
8889 image_error ("Cannot find image file `%s'", file
, Qnil
);
8894 /* Try to open the image file. */
8895 tiff
= TIFFOpen (SDATA (file
), "r");
8898 image_error ("Cannot open `%s'", file
, Qnil
);
8905 /* Memory source! */
8906 memsrc
.bytes
= SDATA (specified_data
);
8907 memsrc
.len
= SBYTES (specified_data
);
8910 tiff
= TIFFClientOpen ("memory_source", "r", &memsrc
,
8911 (TIFFReadWriteProc
) tiff_read_from_memory
,
8912 (TIFFReadWriteProc
) tiff_write_from_memory
,
8913 tiff_seek_in_memory
,
8915 tiff_size_of_memory
,
8921 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
8927 /* Get width and height of the image, and allocate a raster buffer
8928 of width x height 32-bit values. */
8929 TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
8930 TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
8931 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
8933 rc
= TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
8937 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
8943 /* Create the X image and pixmap. */
8944 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8951 /* Initialize the color table. */
8952 init_color_table ();
8954 /* Process the pixel raster. Origin is in the lower-left corner. */
8955 for (y
= 0; y
< height
; ++y
)
8957 uint32
*row
= buf
+ y
* width
;
8959 for (x
= 0; x
< width
; ++x
)
8961 uint32 abgr
= row
[x
];
8962 int r
= TIFFGetR (abgr
) << 8;
8963 int g
= TIFFGetG (abgr
) << 8;
8964 int b
= TIFFGetB (abgr
) << 8;
8965 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
8969 /* Remember the colors allocated for the image. Free the color table. */
8970 img
->colors
= colors_in_color_table (&img
->ncolors
);
8971 free_color_table ();
8974 img
->height
= height
;
8976 /* Maybe fill in the background field while we have ximg handy. */
8977 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8978 IMAGE_BACKGROUND (img
, f
, ximg
);
8980 /* Put the image into the pixmap, then free the X image and its buffer. */
8981 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8982 x_destroy_x_image (ximg
);
8989 #endif /* HAVE_TIFF != 0 */
8993 /***********************************************************************
8995 ***********************************************************************/
8999 #include <gif_lib.h>
9001 static int gif_image_p
P_ ((Lisp_Object object
));
9002 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
9004 /* The symbol `gif' identifying images of this type. */
9008 /* Indices of image specification fields in gif_format, below. */
9010 enum gif_keyword_index
9026 /* Vector of image_keyword structures describing the format
9027 of valid user-defined image specifications. */
9029 static struct image_keyword gif_format
[GIF_LAST
] =
9031 {":type", IMAGE_SYMBOL_VALUE
, 1},
9032 {":data", IMAGE_STRING_VALUE
, 0},
9033 {":file", IMAGE_STRING_VALUE
, 0},
9034 {":ascent", IMAGE_ASCENT_VALUE
, 0},
9035 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
9036 {":relief", IMAGE_INTEGER_VALUE
, 0},
9037 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9038 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9039 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9040 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
9041 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
9044 /* Structure describing the image type `gif'. */
9046 static struct image_type gif_type
=
9056 /* Return non-zero if OBJECT is a valid GIF image specification. */
9059 gif_image_p (object
)
9062 struct image_keyword fmt
[GIF_LAST
];
9063 bcopy (gif_format
, fmt
, sizeof fmt
);
9065 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
9068 /* Must specify either the :data or :file keyword. */
9069 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
9073 /* Reading a GIF image from memory
9074 Based on the PNG memory stuff to a certain extent. */
9078 unsigned char *bytes
;
9085 /* Make the current memory source available to gif_read_from_memory.
9086 It's done this way because not all versions of libungif support
9087 a UserData field in the GifFileType structure. */
9088 static gif_memory_source
*current_gif_memory_src
;
9091 gif_read_from_memory (file
, buf
, len
)
9096 gif_memory_source
*src
= current_gif_memory_src
;
9098 if (len
> src
->len
- src
->index
)
9101 bcopy (src
->bytes
+ src
->index
, buf
, len
);
9107 /* Load GIF image IMG for use on frame F. Value is non-zero if
9115 Lisp_Object file
, specified_file
;
9116 Lisp_Object specified_data
;
9117 int rc
, width
, height
, x
, y
, i
;
9119 ColorMapObject
*gif_color_map
;
9120 unsigned long pixel_colors
[256];
9122 struct gcpro gcpro1
;
9124 int ino
, image_left
, image_top
, image_width
, image_height
;
9125 gif_memory_source memsrc
;
9126 unsigned char *raster
;
9128 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
9129 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
9133 if (NILP (specified_data
))
9135 file
= x_find_image_file (specified_file
);
9136 if (!STRINGP (file
))
9138 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
9143 /* Open the GIF file. */
9144 gif
= DGifOpenFileName (SDATA (file
));
9147 image_error ("Cannot open `%s'", file
, Qnil
);
9154 /* Read from memory! */
9155 current_gif_memory_src
= &memsrc
;
9156 memsrc
.bytes
= SDATA (specified_data
);
9157 memsrc
.len
= SBYTES (specified_data
);
9160 gif
= DGifOpen(&memsrc
, gif_read_from_memory
);
9163 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
9169 /* Read entire contents. */
9170 rc
= DGifSlurp (gif
);
9171 if (rc
== GIF_ERROR
)
9173 image_error ("Error reading `%s'", img
->spec
, Qnil
);
9174 DGifCloseFile (gif
);
9179 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
9180 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
9181 if (ino
>= gif
->ImageCount
)
9183 image_error ("Invalid image number `%s' in image `%s'",
9185 DGifCloseFile (gif
);
9190 width
= img
->width
= max (gif
->SWidth
, gif
->Image
.Left
+ gif
->Image
.Width
);
9191 height
= img
->height
= max (gif
->SHeight
, gif
->Image
.Top
+ gif
->Image
.Height
);
9193 /* Create the X image and pixmap. */
9194 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
9196 DGifCloseFile (gif
);
9201 /* Allocate colors. */
9202 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
9204 gif_color_map
= gif
->SColorMap
;
9205 init_color_table ();
9206 bzero (pixel_colors
, sizeof pixel_colors
);
9208 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
9210 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
9211 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
9212 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
9213 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
9216 img
->colors
= colors_in_color_table (&img
->ncolors
);
9217 free_color_table ();
9219 /* Clear the part of the screen image that are not covered by
9220 the image from the GIF file. Full animated GIF support
9221 requires more than can be done here (see the gif89 spec,
9222 disposal methods). Let's simply assume that the part
9223 not covered by a sub-image is in the frame's background color. */
9224 image_top
= gif
->SavedImages
[ino
].ImageDesc
.Top
;
9225 image_left
= gif
->SavedImages
[ino
].ImageDesc
.Left
;
9226 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
9227 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
9229 for (y
= 0; y
< image_top
; ++y
)
9230 for (x
= 0; x
< width
; ++x
)
9231 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
9233 for (y
= image_top
+ image_height
; y
< height
; ++y
)
9234 for (x
= 0; x
< width
; ++x
)
9235 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
9237 for (y
= image_top
; y
< image_top
+ image_height
; ++y
)
9239 for (x
= 0; x
< image_left
; ++x
)
9240 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
9241 for (x
= image_left
+ image_width
; x
< width
; ++x
)
9242 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
9245 /* Read the GIF image into the X image. We use a local variable
9246 `raster' here because RasterBits below is a char *, and invites
9247 problems with bytes >= 0x80. */
9248 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
9250 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
9252 static int interlace_start
[] = {0, 4, 2, 1};
9253 static int interlace_increment
[] = {8, 8, 4, 2};
9255 int row
= interlace_start
[0];
9259 for (y
= 0; y
< image_height
; y
++)
9261 if (row
>= image_height
)
9263 row
= interlace_start
[++pass
];
9264 while (row
>= image_height
)
9265 row
= interlace_start
[++pass
];
9268 for (x
= 0; x
< image_width
; x
++)
9270 int i
= raster
[(y
* image_width
) + x
];
9271 XPutPixel (ximg
, x
+ image_left
, row
+ image_top
,
9275 row
+= interlace_increment
[pass
];
9280 for (y
= 0; y
< image_height
; ++y
)
9281 for (x
= 0; x
< image_width
; ++x
)
9283 int i
= raster
[y
* image_width
+ x
];
9284 XPutPixel (ximg
, x
+ image_left
, y
+ image_top
, pixel_colors
[i
]);
9288 DGifCloseFile (gif
);
9290 /* Maybe fill in the background field while we have ximg handy. */
9291 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
9292 IMAGE_BACKGROUND (img
, f
, ximg
);
9294 /* Put the image into the pixmap, then free the X image and its buffer. */
9295 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
9296 x_destroy_x_image (ximg
);
9302 #endif /* HAVE_GIF != 0 */
9306 /***********************************************************************
9308 ***********************************************************************/
9310 static int gs_image_p
P_ ((Lisp_Object object
));
9311 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
9312 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
9314 /* The symbol `postscript' identifying images of this type. */
9316 Lisp_Object Qpostscript
;
9318 /* Keyword symbols. */
9320 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
9322 /* Indices of image specification fields in gs_format, below. */
9324 enum gs_keyword_index
9342 /* Vector of image_keyword structures describing the format
9343 of valid user-defined image specifications. */
9345 static struct image_keyword gs_format
[GS_LAST
] =
9347 {":type", IMAGE_SYMBOL_VALUE
, 1},
9348 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
9349 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
9350 {":file", IMAGE_STRING_VALUE
, 1},
9351 {":loader", IMAGE_FUNCTION_VALUE
, 0},
9352 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
9353 {":ascent", IMAGE_ASCENT_VALUE
, 0},
9354 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
9355 {":relief", IMAGE_INTEGER_VALUE
, 0},
9356 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9357 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9358 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9359 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
9362 /* Structure describing the image type `ghostscript'. */
9364 static struct image_type gs_type
=
9374 /* Free X resources of Ghostscript image IMG which is used on frame F. */
9377 gs_clear_image (f
, img
)
9381 /* IMG->data.ptr_val may contain a recorded colormap. */
9382 xfree (img
->data
.ptr_val
);
9383 x_clear_image (f
, img
);
9387 /* Return non-zero if OBJECT is a valid Ghostscript image
9394 struct image_keyword fmt
[GS_LAST
];
9398 bcopy (gs_format
, fmt
, sizeof fmt
);
9400 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
9403 /* Bounding box must be a list or vector containing 4 integers. */
9404 tem
= fmt
[GS_BOUNDING_BOX
].value
;
9407 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
9408 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
9413 else if (VECTORP (tem
))
9415 if (XVECTOR (tem
)->size
!= 4)
9417 for (i
= 0; i
< 4; ++i
)
9418 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
9428 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
9437 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
9438 struct gcpro gcpro1
, gcpro2
;
9440 double in_width
, in_height
;
9441 Lisp_Object pixel_colors
= Qnil
;
9443 /* Compute pixel size of pixmap needed from the given size in the
9444 image specification. Sizes in the specification are in pt. 1 pt
9445 = 1/72 in, xdpi and ydpi are stored in the frame's X display
9447 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
9448 in_width
= XFASTINT (pt_width
) / 72.0;
9449 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
9450 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
9451 in_height
= XFASTINT (pt_height
) / 72.0;
9452 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
9454 /* Create the pixmap. */
9455 xassert (img
->pixmap
== None
);
9456 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9457 img
->width
, img
->height
,
9458 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
9462 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
9466 /* Call the loader to fill the pixmap. It returns a process object
9467 if successful. We do not record_unwind_protect here because
9468 other places in redisplay like calling window scroll functions
9469 don't either. Let the Lisp loader use `unwind-protect' instead. */
9470 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
9472 sprintf (buffer
, "%lu %lu",
9473 (unsigned long) FRAME_X_WINDOW (f
),
9474 (unsigned long) img
->pixmap
);
9475 window_and_pixmap_id
= build_string (buffer
);
9477 sprintf (buffer
, "%lu %lu",
9478 FRAME_FOREGROUND_PIXEL (f
),
9479 FRAME_BACKGROUND_PIXEL (f
));
9480 pixel_colors
= build_string (buffer
);
9482 XSETFRAME (frame
, f
);
9483 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
9485 loader
= intern ("gs-load-image");
9487 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
9488 make_number (img
->width
),
9489 make_number (img
->height
),
9490 window_and_pixmap_id
,
9493 return PROCESSP (img
->data
.lisp_val
);
9497 /* Kill the Ghostscript process that was started to fill PIXMAP on
9498 frame F. Called from XTread_socket when receiving an event
9499 telling Emacs that Ghostscript has finished drawing. */
9502 x_kill_gs_process (pixmap
, f
)
9506 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
9510 /* Find the image containing PIXMAP. */
9511 for (i
= 0; i
< c
->used
; ++i
)
9512 if (c
->images
[i
]->pixmap
== pixmap
)
9515 /* Should someone in between have cleared the image cache, for
9516 instance, give up. */
9520 /* Kill the GS process. We should have found PIXMAP in the image
9521 cache and its image should contain a process object. */
9523 xassert (PROCESSP (img
->data
.lisp_val
));
9524 Fkill_process (img
->data
.lisp_val
, Qnil
);
9525 img
->data
.lisp_val
= Qnil
;
9527 /* On displays with a mutable colormap, figure out the colors
9528 allocated for the image by looking at the pixels of an XImage for
9530 class = FRAME_X_VISUAL (f
)->class;
9531 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
9537 /* Try to get an XImage for img->pixmep. */
9538 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
9539 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
9544 /* Initialize the color table. */
9545 init_color_table ();
9547 /* For each pixel of the image, look its color up in the
9548 color table. After having done so, the color table will
9549 contain an entry for each color used by the image. */
9550 for (y
= 0; y
< img
->height
; ++y
)
9551 for (x
= 0; x
< img
->width
; ++x
)
9553 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
9554 lookup_pixel_color (f
, pixel
);
9557 /* Record colors in the image. Free color table and XImage. */
9558 img
->colors
= colors_in_color_table (&img
->ncolors
);
9559 free_color_table ();
9560 XDestroyImage (ximg
);
9562 #if 0 /* This doesn't seem to be the case. If we free the colors
9563 here, we get a BadAccess later in x_clear_image when
9564 freeing the colors. */
9565 /* We have allocated colors once, but Ghostscript has also
9566 allocated colors on behalf of us. So, to get the
9567 reference counts right, free them once. */
9569 x_free_colors (f
, img
->colors
, img
->ncolors
);
9573 image_error ("Cannot get X image of `%s'; colors will not be freed",
9579 /* Now that we have the pixmap, compute mask and transform the
9580 image if requested. */
9582 postprocess_image (f
, img
);
9588 /***********************************************************************
9590 ***********************************************************************/
9592 DEFUN ("x-change-window-property", Fx_change_window_property
,
9593 Sx_change_window_property
, 2, 3, 0,
9594 doc
: /* Change window property PROP to VALUE on the X window of FRAME.
9595 PROP and VALUE must be strings. FRAME nil or omitted means use the
9596 selected frame. Value is VALUE. */)
9597 (prop
, value
, frame
)
9598 Lisp_Object frame
, prop
, value
;
9600 struct frame
*f
= check_x_frame (frame
);
9603 CHECK_STRING (prop
);
9604 CHECK_STRING (value
);
9607 prop_atom
= XInternAtom (FRAME_X_DISPLAY (f
), SDATA (prop
), False
);
9608 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9609 prop_atom
, XA_STRING
, 8, PropModeReplace
,
9610 SDATA (value
), SCHARS (value
));
9612 /* Make sure the property is set when we return. */
9613 XFlush (FRAME_X_DISPLAY (f
));
9620 DEFUN ("x-delete-window-property", Fx_delete_window_property
,
9621 Sx_delete_window_property
, 1, 2, 0,
9622 doc
: /* Remove window property PROP from X window of FRAME.
9623 FRAME nil or omitted means use the selected frame. Value is PROP. */)
9625 Lisp_Object prop
, frame
;
9627 struct frame
*f
= check_x_frame (frame
);
9630 CHECK_STRING (prop
);
9632 prop_atom
= XInternAtom (FRAME_X_DISPLAY (f
), SDATA (prop
), False
);
9633 XDeleteProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), prop_atom
);
9635 /* Make sure the property is removed when we return. */
9636 XFlush (FRAME_X_DISPLAY (f
));
9643 DEFUN ("x-window-property", Fx_window_property
, Sx_window_property
,
9645 doc
: /* Value is the value of window property PROP on FRAME.
9646 If FRAME is nil or omitted, use the selected frame. Value is nil
9647 if FRAME hasn't a property with name PROP or if PROP has no string
9650 Lisp_Object prop
, frame
;
9652 struct frame
*f
= check_x_frame (frame
);
9655 Lisp_Object prop_value
= Qnil
;
9656 char *tmp_data
= NULL
;
9659 unsigned long actual_size
, bytes_remaining
;
9661 CHECK_STRING (prop
);
9663 prop_atom
= XInternAtom (FRAME_X_DISPLAY (f
), SDATA (prop
), False
);
9664 rc
= XGetWindowProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9665 prop_atom
, 0, 0, False
, XA_STRING
,
9666 &actual_type
, &actual_format
, &actual_size
,
9667 &bytes_remaining
, (unsigned char **) &tmp_data
);
9670 int size
= bytes_remaining
;
9675 rc
= XGetWindowProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9676 prop_atom
, 0, bytes_remaining
,
9678 &actual_type
, &actual_format
,
9679 &actual_size
, &bytes_remaining
,
9680 (unsigned char **) &tmp_data
);
9681 if (rc
== Success
&& tmp_data
)
9682 prop_value
= make_string (tmp_data
, size
);
9693 /***********************************************************************
9695 ***********************************************************************/
9697 /* If non-null, an asynchronous timer that, when it expires, displays
9698 an hourglass cursor on all frames. */
9700 static struct atimer
*hourglass_atimer
;
9702 /* Non-zero means an hourglass cursor is currently shown. */
9704 static int hourglass_shown_p
;
9706 /* Number of seconds to wait before displaying an hourglass cursor. */
9708 static Lisp_Object Vhourglass_delay
;
9710 /* Default number of seconds to wait before displaying an hourglass
9713 #define DEFAULT_HOURGLASS_DELAY 1
9715 /* Function prototypes. */
9717 static void show_hourglass
P_ ((struct atimer
*));
9718 static void hide_hourglass
P_ ((void));
9721 /* Cancel a currently active hourglass timer, and start a new one. */
9727 int secs
, usecs
= 0;
9729 cancel_hourglass ();
9731 if (INTEGERP (Vhourglass_delay
)
9732 && XINT (Vhourglass_delay
) > 0)
9733 secs
= XFASTINT (Vhourglass_delay
);
9734 else if (FLOATP (Vhourglass_delay
)
9735 && XFLOAT_DATA (Vhourglass_delay
) > 0)
9738 tem
= Ftruncate (Vhourglass_delay
, Qnil
);
9739 secs
= XFASTINT (tem
);
9740 usecs
= (XFLOAT_DATA (Vhourglass_delay
) - secs
) * 1000000;
9743 secs
= DEFAULT_HOURGLASS_DELAY
;
9745 EMACS_SET_SECS_USECS (delay
, secs
, usecs
);
9746 hourglass_atimer
= start_atimer (ATIMER_RELATIVE
, delay
,
9747 show_hourglass
, NULL
);
9751 /* Cancel the hourglass cursor timer if active, hide a busy cursor if
9757 if (hourglass_atimer
)
9759 cancel_atimer (hourglass_atimer
);
9760 hourglass_atimer
= NULL
;
9763 if (hourglass_shown_p
)
9768 /* Timer function of hourglass_atimer. TIMER is equal to
9771 Display an hourglass pointer on all frames by mapping the frames'
9772 hourglass_window. Set the hourglass_p flag in the frames'
9773 output_data.x structure to indicate that an hourglass cursor is
9774 shown on the frames. */
9777 show_hourglass (timer
)
9778 struct atimer
*timer
;
9780 /* The timer implementation will cancel this timer automatically
9781 after this function has run. Set hourglass_atimer to null
9782 so that we know the timer doesn't have to be canceled. */
9783 hourglass_atimer
= NULL
;
9785 if (!hourglass_shown_p
)
9787 Lisp_Object rest
, frame
;
9791 FOR_EACH_FRAME (rest
, frame
)
9793 struct frame
*f
= XFRAME (frame
);
9795 if (FRAME_LIVE_P (f
) && FRAME_X_P (f
) && FRAME_X_DISPLAY (f
))
9797 Display
*dpy
= FRAME_X_DISPLAY (f
);
9799 #ifdef USE_X_TOOLKIT
9800 if (f
->output_data
.x
->widget
)
9802 if (FRAME_OUTER_WINDOW (f
))
9805 f
->output_data
.x
->hourglass_p
= 1;
9807 if (!f
->output_data
.x
->hourglass_window
)
9809 unsigned long mask
= CWCursor
;
9810 XSetWindowAttributes attrs
;
9812 attrs
.cursor
= f
->output_data
.x
->hourglass_cursor
;
9814 f
->output_data
.x
->hourglass_window
9815 = XCreateWindow (dpy
, FRAME_OUTER_WINDOW (f
),
9816 0, 0, 32000, 32000, 0, 0,
9822 XMapRaised (dpy
, f
->output_data
.x
->hourglass_window
);
9828 hourglass_shown_p
= 1;
9834 /* Hide the hourglass pointer on all frames, if it is currently
9840 if (hourglass_shown_p
)
9842 Lisp_Object rest
, frame
;
9845 FOR_EACH_FRAME (rest
, frame
)
9847 struct frame
*f
= XFRAME (frame
);
9850 /* Watch out for newly created frames. */
9851 && f
->output_data
.x
->hourglass_window
)
9853 XUnmapWindow (FRAME_X_DISPLAY (f
),
9854 f
->output_data
.x
->hourglass_window
);
9855 /* Sync here because XTread_socket looks at the
9856 hourglass_p flag that is reset to zero below. */
9857 XSync (FRAME_X_DISPLAY (f
), False
);
9858 f
->output_data
.x
->hourglass_p
= 0;
9862 hourglass_shown_p
= 0;
9869 /***********************************************************************
9871 ***********************************************************************/
9873 static Lisp_Object x_create_tip_frame
P_ ((struct x_display_info
*,
9874 Lisp_Object
, Lisp_Object
));
9875 static void compute_tip_xy
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
,
9876 Lisp_Object
, int, int, int *, int *));
9878 /* The frame of a currently visible tooltip. */
9880 Lisp_Object tip_frame
;
9882 /* If non-nil, a timer started that hides the last tooltip when it
9885 Lisp_Object tip_timer
;
9888 /* If non-nil, a vector of 3 elements containing the last args
9889 with which x-show-tip was called. See there. */
9891 Lisp_Object last_show_tip_args
;
9893 /* Maximum size for tooltips; a cons (COLUMNS . ROWS). */
9895 Lisp_Object Vx_max_tooltip_size
;
9899 unwind_create_tip_frame (frame
)
9902 Lisp_Object deleted
;
9904 deleted
= unwind_create_frame (frame
);
9905 if (EQ (deleted
, Qt
))
9915 /* Create a frame for a tooltip on the display described by DPYINFO.
9916 PARMS is a list of frame parameters. TEXT is the string to
9917 display in the tip frame. Value is the frame.
9919 Note that functions called here, esp. x_default_parameter can
9920 signal errors, for instance when a specified color name is
9921 undefined. We have to make sure that we're in a consistent state
9922 when this happens. */
9925 x_create_tip_frame (dpyinfo
, parms
, text
)
9926 struct x_display_info
*dpyinfo
;
9927 Lisp_Object parms
, text
;
9930 Lisp_Object frame
, tem
;
9932 long window_prompting
= 0;
9934 int count
= SPECPDL_INDEX ();
9935 struct gcpro gcpro1
, gcpro2
, gcpro3
;
9937 int face_change_count_before
= face_change_count
;
9939 struct buffer
*old_buffer
;
9943 /* Use this general default value to start with until we know if
9944 this frame has a specified name. */
9945 Vx_resource_name
= Vinvocation_name
;
9948 kb
= dpyinfo
->kboard
;
9950 kb
= &the_only_kboard
;
9953 /* Get the name of the frame to use for resource lookup. */
9954 name
= x_get_arg (dpyinfo
, parms
, Qname
, "name", "Name", RES_TYPE_STRING
);
9956 && !EQ (name
, Qunbound
)
9958 error ("Invalid frame name--not a string or nil");
9959 Vx_resource_name
= name
;
9962 GCPRO3 (parms
, name
, frame
);
9964 XSETFRAME (frame
, f
);
9966 buffer
= Fget_buffer_create (build_string (" *tip*"));
9967 Fset_window_buffer (FRAME_ROOT_WINDOW (f
), buffer
, Qnil
);
9968 old_buffer
= current_buffer
;
9969 set_buffer_internal_1 (XBUFFER (buffer
));
9970 current_buffer
->truncate_lines
= Qnil
;
9973 set_buffer_internal_1 (old_buffer
);
9975 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 0;
9976 record_unwind_protect (unwind_create_tip_frame
, frame
);
9978 /* By setting the output method, we're essentially saying that
9979 the frame is live, as per FRAME_LIVE_P. If we get a signal
9980 from this point on, x_destroy_window might screw up reference
9982 f
->output_method
= output_x_window
;
9983 f
->output_data
.x
= (struct x_output
*) xmalloc (sizeof (struct x_output
));
9984 bzero (f
->output_data
.x
, sizeof (struct x_output
));
9985 f
->output_data
.x
->icon_bitmap
= -1;
9986 FRAME_FONTSET (f
) = -1;
9987 f
->output_data
.x
->scroll_bar_foreground_pixel
= -1;
9988 f
->output_data
.x
->scroll_bar_background_pixel
= -1;
9989 #ifdef USE_TOOLKIT_SCROLL_BARS
9990 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= -1;
9991 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= -1;
9992 #endif /* USE_TOOLKIT_SCROLL_BARS */
9993 f
->icon_name
= Qnil
;
9994 FRAME_X_DISPLAY_INFO (f
) = dpyinfo
;
9996 image_cache_refcount
= FRAME_X_IMAGE_CACHE (f
)->refcount
;
9997 dpyinfo_refcount
= dpyinfo
->reference_count
;
9998 #endif /* GLYPH_DEBUG */
10000 FRAME_KBOARD (f
) = kb
;
10002 f
->output_data
.x
->parent_desc
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
10003 f
->output_data
.x
->explicit_parent
= 0;
10005 /* These colors will be set anyway later, but it's important
10006 to get the color reference counts right, so initialize them! */
10009 struct gcpro gcpro1
;
10011 black
= build_string ("black");
10013 f
->output_data
.x
->foreground_pixel
10014 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
10015 f
->output_data
.x
->background_pixel
10016 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
10017 f
->output_data
.x
->cursor_pixel
10018 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
10019 f
->output_data
.x
->cursor_foreground_pixel
10020 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
10021 f
->output_data
.x
->border_pixel
10022 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
10023 f
->output_data
.x
->mouse_pixel
10024 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
10028 /* Set the name; the functions to which we pass f expect the name to
10030 if (EQ (name
, Qunbound
) || NILP (name
))
10032 f
->name
= build_string (dpyinfo
->x_id_name
);
10033 f
->explicit_name
= 0;
10038 f
->explicit_name
= 1;
10039 /* use the frame's title when getting resources for this frame. */
10040 specbind (Qx_resource_name
, name
);
10043 /* Extract the window parameters from the supplied values that are
10044 needed to determine window geometry. */
10048 font
= x_get_arg (dpyinfo
, parms
, Qfont
, "font", "Font", RES_TYPE_STRING
);
10051 /* First, try whatever font the caller has specified. */
10052 if (STRINGP (font
))
10054 tem
= Fquery_fontset (font
, Qnil
);
10056 font
= x_new_fontset (f
, SDATA (tem
));
10058 font
= x_new_font (f
, SDATA (font
));
10061 /* Try out a font which we hope has bold and italic variations. */
10062 if (!STRINGP (font
))
10063 font
= x_new_font (f
, "-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1");
10064 if (!STRINGP (font
))
10065 font
= x_new_font (f
, "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
10066 if (! STRINGP (font
))
10067 font
= x_new_font (f
, "-*-*-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
10068 if (! STRINGP (font
))
10069 /* This was formerly the first thing tried, but it finds too many fonts
10070 and takes too long. */
10071 font
= x_new_font (f
, "-*-*-medium-r-*-*-*-*-*-*-c-*-iso8859-1");
10072 /* If those didn't work, look for something which will at least work. */
10073 if (! STRINGP (font
))
10074 font
= x_new_font (f
, "-*-fixed-*-*-*-*-*-140-*-*-c-*-iso8859-1");
10076 if (! STRINGP (font
))
10077 font
= build_string ("fixed");
10079 x_default_parameter (f
, parms
, Qfont
, font
,
10080 "font", "Font", RES_TYPE_STRING
);
10083 x_default_parameter (f
, parms
, Qborder_width
, make_number (2),
10084 "borderWidth", "BorderWidth", RES_TYPE_NUMBER
);
10086 /* This defaults to 2 in order to match xterm. We recognize either
10087 internalBorderWidth or internalBorder (which is what xterm calls
10089 if (NILP (Fassq (Qinternal_border_width
, parms
)))
10093 value
= x_get_arg (dpyinfo
, parms
, Qinternal_border_width
,
10094 "internalBorder", "internalBorder", RES_TYPE_NUMBER
);
10095 if (! EQ (value
, Qunbound
))
10096 parms
= Fcons (Fcons (Qinternal_border_width
, value
),
10100 x_default_parameter (f
, parms
, Qinternal_border_width
, make_number (1),
10101 "internalBorderWidth", "internalBorderWidth",
10104 /* Also do the stuff which must be set before the window exists. */
10105 x_default_parameter (f
, parms
, Qforeground_color
, build_string ("black"),
10106 "foreground", "Foreground", RES_TYPE_STRING
);
10107 x_default_parameter (f
, parms
, Qbackground_color
, build_string ("white"),
10108 "background", "Background", RES_TYPE_STRING
);
10109 x_default_parameter (f
, parms
, Qmouse_color
, build_string ("black"),
10110 "pointerColor", "Foreground", RES_TYPE_STRING
);
10111 x_default_parameter (f
, parms
, Qcursor_color
, build_string ("black"),
10112 "cursorColor", "Foreground", RES_TYPE_STRING
);
10113 x_default_parameter (f
, parms
, Qborder_color
, build_string ("black"),
10114 "borderColor", "BorderColor", RES_TYPE_STRING
);
10116 /* Init faces before x_default_parameter is called for scroll-bar
10117 parameters because that function calls x_set_scroll_bar_width,
10118 which calls change_frame_size, which calls Fset_window_buffer,
10119 which runs hooks, which call Fvertical_motion. At the end, we
10120 end up in init_iterator with a null face cache, which should not
10122 init_frame_faces (f
);
10124 f
->output_data
.x
->parent_desc
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
10126 window_prompting
= x_figure_window_size (f
, parms
, 0);
10129 XSetWindowAttributes attrs
;
10130 unsigned long mask
;
10133 mask
= CWBackPixel
| CWOverrideRedirect
| CWEventMask
;
10134 if (DoesSaveUnders (dpyinfo
->screen
))
10135 mask
|= CWSaveUnder
;
10137 /* Window managers look at the override-redirect flag to determine
10138 whether or net to give windows a decoration (Xlib spec, chapter
10140 attrs
.override_redirect
= True
;
10141 attrs
.save_under
= True
;
10142 attrs
.background_pixel
= FRAME_BACKGROUND_PIXEL (f
);
10143 /* Arrange for getting MapNotify and UnmapNotify events. */
10144 attrs
.event_mask
= StructureNotifyMask
;
10146 = FRAME_X_WINDOW (f
)
10147 = XCreateWindow (FRAME_X_DISPLAY (f
),
10148 FRAME_X_DISPLAY_INFO (f
)->root_window
,
10149 /* x, y, width, height */
10153 CopyFromParent
, InputOutput
, CopyFromParent
,
10160 x_default_parameter (f
, parms
, Qauto_raise
, Qnil
,
10161 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
10162 x_default_parameter (f
, parms
, Qauto_lower
, Qnil
,
10163 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
10164 x_default_parameter (f
, parms
, Qcursor_type
, Qbox
,
10165 "cursorType", "CursorType", RES_TYPE_SYMBOL
);
10167 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
10168 Change will not be effected unless different from the current
10169 FRAME_LINES (f). */
10170 width
= FRAME_COLS (f
);
10171 height
= FRAME_LINES (f
);
10172 SET_FRAME_COLS (f
, 0);
10173 FRAME_LINES (f
) = 0;
10174 change_frame_size (f
, height
, width
, 1, 0, 0);
10176 /* Add `tooltip' frame parameter's default value. */
10177 if (NILP (Fframe_parameter (frame
, intern ("tooltip"))))
10178 Fmodify_frame_parameters (frame
, Fcons (Fcons (intern ("tooltip"), Qt
),
10181 /* Set up faces after all frame parameters are known. This call
10182 also merges in face attributes specified for new frames.
10184 Frame parameters may be changed if .Xdefaults contains
10185 specifications for the default font. For example, if there is an
10186 `Emacs.default.attributeBackground: pink', the `background-color'
10187 attribute of the frame get's set, which let's the internal border
10188 of the tooltip frame appear in pink. Prevent this. */
10190 Lisp_Object bg
= Fframe_parameter (frame
, Qbackground_color
);
10192 /* Set tip_frame here, so that */
10194 call1 (Qface_set_after_frame_default
, frame
);
10196 if (!EQ (bg
, Fframe_parameter (frame
, Qbackground_color
)))
10197 Fmodify_frame_parameters (frame
, Fcons (Fcons (Qbackground_color
, bg
),
10205 /* It is now ok to make the frame official even if we get an error
10206 below. And the frame needs to be on Vframe_list or making it
10207 visible won't work. */
10208 Vframe_list
= Fcons (frame
, Vframe_list
);
10210 /* Now that the frame is official, it counts as a reference to
10212 FRAME_X_DISPLAY_INFO (f
)->reference_count
++;
10214 /* Setting attributes of faces of the tooltip frame from resources
10215 and similar will increment face_change_count, which leads to the
10216 clearing of all current matrices. Since this isn't necessary
10217 here, avoid it by resetting face_change_count to the value it
10218 had before we created the tip frame. */
10219 face_change_count
= face_change_count_before
;
10221 /* Discard the unwind_protect. */
10222 return unbind_to (count
, frame
);
10226 /* Compute where to display tip frame F. PARMS is the list of frame
10227 parameters for F. DX and DY are specified offsets from the current
10228 location of the mouse. WIDTH and HEIGHT are the width and height
10229 of the tooltip. Return coordinates relative to the root window of
10230 the display in *ROOT_X, and *ROOT_Y. */
10233 compute_tip_xy (f
, parms
, dx
, dy
, width
, height
, root_x
, root_y
)
10235 Lisp_Object parms
, dx
, dy
;
10237 int *root_x
, *root_y
;
10239 Lisp_Object left
, top
;
10241 Window root
, child
;
10244 /* User-specified position? */
10245 left
= Fcdr (Fassq (Qleft
, parms
));
10246 top
= Fcdr (Fassq (Qtop
, parms
));
10248 /* Move the tooltip window where the mouse pointer is. Resize and
10250 if (!INTEGERP (left
) || !INTEGERP (top
))
10253 XQueryPointer (FRAME_X_DISPLAY (f
), FRAME_X_DISPLAY_INFO (f
)->root_window
,
10254 &root
, &child
, root_x
, root_y
, &win_x
, &win_y
, &pmask
);
10258 if (INTEGERP (top
))
10259 *root_y
= XINT (top
);
10260 else if (*root_y
+ XINT (dy
) - height
< 0)
10261 *root_y
-= XINT (dy
);
10265 *root_y
+= XINT (dy
);
10268 if (INTEGERP (left
))
10269 *root_x
= XINT (left
);
10270 else if (*root_x
+ XINT (dx
) + width
<= FRAME_X_DISPLAY_INFO (f
)->width
)
10271 /* It fits to the right of the pointer. */
10272 *root_x
+= XINT (dx
);
10273 else if (width
+ XINT (dx
) <= *root_x
)
10274 /* It fits to the left of the pointer. */
10275 *root_x
-= width
+ XINT (dx
);
10277 /* Put it left-justified on the screen--it ought to fit that way. */
10282 DEFUN ("x-show-tip", Fx_show_tip
, Sx_show_tip
, 1, 6, 0,
10283 doc
: /* Show STRING in a "tooltip" window on frame FRAME.
10284 A tooltip window is a small X window displaying a string.
10286 FRAME nil or omitted means use the selected frame.
10288 PARMS is an optional list of frame parameters which can be used to
10289 change the tooltip's appearance.
10291 Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
10292 means use the default timeout of 5 seconds.
10294 If the list of frame parameters PARAMS contains a `left' parameters,
10295 the tooltip is displayed at that x-position. Otherwise it is
10296 displayed at the mouse position, with offset DX added (default is 5 if
10297 DX isn't specified). Likewise for the y-position; if a `top' frame
10298 parameter is specified, it determines the y-position of the tooltip
10299 window, otherwise it is displayed at the mouse position, with offset
10300 DY added (default is -10).
10302 A tooltip's maximum size is specified by `x-max-tooltip-size'.
10303 Text larger than the specified size is clipped. */)
10304 (string
, frame
, parms
, timeout
, dx
, dy
)
10305 Lisp_Object string
, frame
, parms
, timeout
, dx
, dy
;
10309 int root_x
, root_y
;
10310 struct buffer
*old_buffer
;
10311 struct text_pos pos
;
10312 int i
, width
, height
;
10313 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
10314 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
10315 int count
= SPECPDL_INDEX ();
10317 specbind (Qinhibit_redisplay
, Qt
);
10319 GCPRO4 (string
, parms
, frame
, timeout
);
10321 CHECK_STRING (string
);
10322 f
= check_x_frame (frame
);
10323 if (NILP (timeout
))
10324 timeout
= make_number (5);
10326 CHECK_NATNUM (timeout
);
10329 dx
= make_number (5);
10334 dy
= make_number (-10);
10338 if (NILP (last_show_tip_args
))
10339 last_show_tip_args
= Fmake_vector (make_number (3), Qnil
);
10341 if (!NILP (tip_frame
))
10343 Lisp_Object last_string
= AREF (last_show_tip_args
, 0);
10344 Lisp_Object last_frame
= AREF (last_show_tip_args
, 1);
10345 Lisp_Object last_parms
= AREF (last_show_tip_args
, 2);
10347 if (EQ (frame
, last_frame
)
10348 && !NILP (Fequal (last_string
, string
))
10349 && !NILP (Fequal (last_parms
, parms
)))
10351 struct frame
*f
= XFRAME (tip_frame
);
10353 /* Only DX and DY have changed. */
10354 if (!NILP (tip_timer
))
10356 Lisp_Object timer
= tip_timer
;
10358 call1 (Qcancel_timer
, timer
);
10362 compute_tip_xy (f
, parms
, dx
, dy
, FRAME_PIXEL_WIDTH (f
),
10363 FRAME_PIXEL_HEIGHT (f
), &root_x
, &root_y
);
10364 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
10371 /* Hide a previous tip, if any. */
10374 ASET (last_show_tip_args
, 0, string
);
10375 ASET (last_show_tip_args
, 1, frame
);
10376 ASET (last_show_tip_args
, 2, parms
);
10378 /* Add default values to frame parameters. */
10379 if (NILP (Fassq (Qname
, parms
)))
10380 parms
= Fcons (Fcons (Qname
, build_string ("tooltip")), parms
);
10381 if (NILP (Fassq (Qinternal_border_width
, parms
)))
10382 parms
= Fcons (Fcons (Qinternal_border_width
, make_number (3)), parms
);
10383 if (NILP (Fassq (Qborder_width
, parms
)))
10384 parms
= Fcons (Fcons (Qborder_width
, make_number (1)), parms
);
10385 if (NILP (Fassq (Qborder_color
, parms
)))
10386 parms
= Fcons (Fcons (Qborder_color
, build_string ("lightyellow")), parms
);
10387 if (NILP (Fassq (Qbackground_color
, parms
)))
10388 parms
= Fcons (Fcons (Qbackground_color
, build_string ("lightyellow")),
10391 /* Create a frame for the tooltip, and record it in the global
10392 variable tip_frame. */
10393 frame
= x_create_tip_frame (FRAME_X_DISPLAY_INFO (f
), parms
, string
);
10394 f
= XFRAME (frame
);
10396 /* Set up the frame's root window. */
10397 w
= XWINDOW (FRAME_ROOT_WINDOW (f
));
10398 w
->left_col
= w
->top_line
= make_number (0);
10400 if (CONSP (Vx_max_tooltip_size
)
10401 && INTEGERP (XCAR (Vx_max_tooltip_size
))
10402 && XINT (XCAR (Vx_max_tooltip_size
)) > 0
10403 && INTEGERP (XCDR (Vx_max_tooltip_size
))
10404 && XINT (XCDR (Vx_max_tooltip_size
)) > 0)
10406 w
->total_cols
= XCAR (Vx_max_tooltip_size
);
10407 w
->total_lines
= XCDR (Vx_max_tooltip_size
);
10411 w
->total_cols
= make_number (80);
10412 w
->total_lines
= make_number (40);
10415 FRAME_TOTAL_COLS (f
) = XINT (w
->total_cols
);
10417 w
->pseudo_window_p
= 1;
10419 /* Display the tooltip text in a temporary buffer. */
10420 old_buffer
= current_buffer
;
10421 set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f
))->buffer
));
10422 current_buffer
->truncate_lines
= Qnil
;
10423 clear_glyph_matrix (w
->desired_matrix
);
10424 clear_glyph_matrix (w
->current_matrix
);
10425 SET_TEXT_POS (pos
, BEGV
, BEGV_BYTE
);
10426 try_window (FRAME_ROOT_WINDOW (f
), pos
);
10428 /* Compute width and height of the tooltip. */
10429 width
= height
= 0;
10430 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
10432 struct glyph_row
*row
= &w
->desired_matrix
->rows
[i
];
10433 struct glyph
*last
;
10436 /* Stop at the first empty row at the end. */
10437 if (!row
->enabled_p
|| !row
->displays_text_p
)
10440 /* Let the row go over the full width of the frame. */
10441 row
->full_width_p
= 1;
10443 /* There's a glyph at the end of rows that is used to place
10444 the cursor there. Don't include the width of this glyph. */
10445 if (row
->used
[TEXT_AREA
])
10447 last
= &row
->glyphs
[TEXT_AREA
][row
->used
[TEXT_AREA
] - 1];
10448 row_width
= row
->pixel_width
- last
->pixel_width
;
10451 row_width
= row
->pixel_width
;
10453 height
+= row
->height
;
10454 width
= max (width
, row_width
);
10457 /* Add the frame's internal border to the width and height the X
10458 window should have. */
10459 height
+= 2 * FRAME_INTERNAL_BORDER_WIDTH (f
);
10460 width
+= 2 * FRAME_INTERNAL_BORDER_WIDTH (f
);
10462 /* Move the tooltip window where the mouse pointer is. Resize and
10464 compute_tip_xy (f
, parms
, dx
, dy
, width
, height
, &root_x
, &root_y
);
10467 XMoveResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
10468 root_x
, root_y
, width
, height
);
10469 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10472 /* Draw into the window. */
10473 w
->must_be_updated_p
= 1;
10474 update_single_window (w
, 1);
10476 /* Restore original current buffer. */
10477 set_buffer_internal_1 (old_buffer
);
10478 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
10481 /* Let the tip disappear after timeout seconds. */
10482 tip_timer
= call3 (intern ("run-at-time"), timeout
, Qnil
,
10483 intern ("x-hide-tip"));
10486 return unbind_to (count
, Qnil
);
10490 DEFUN ("x-hide-tip", Fx_hide_tip
, Sx_hide_tip
, 0, 0, 0,
10491 doc
: /* Hide the current tooltip window, if there is any.
10492 Value is t if tooltip was open, nil otherwise. */)
10496 Lisp_Object deleted
, frame
, timer
;
10497 struct gcpro gcpro1
, gcpro2
;
10499 /* Return quickly if nothing to do. */
10500 if (NILP (tip_timer
) && NILP (tip_frame
))
10505 GCPRO2 (frame
, timer
);
10506 tip_frame
= tip_timer
= deleted
= Qnil
;
10508 count
= SPECPDL_INDEX ();
10509 specbind (Qinhibit_redisplay
, Qt
);
10510 specbind (Qinhibit_quit
, Qt
);
10513 call1 (Qcancel_timer
, timer
);
10515 if (FRAMEP (frame
))
10517 Fdelete_frame (frame
, Qnil
);
10521 /* Bloodcurdling hack alert: The Lucid menu bar widget's
10522 redisplay procedure is not called when a tip frame over menu
10523 items is unmapped. Redisplay the menu manually... */
10525 struct frame
*f
= SELECTED_FRAME ();
10526 Widget w
= f
->output_data
.x
->menubar_widget
;
10527 extern void xlwmenu_redisplay
P_ ((Widget
));
10529 if (!DoesSaveUnders (FRAME_X_DISPLAY_INFO (f
)->screen
)
10533 xlwmenu_redisplay (w
);
10537 #endif /* USE_LUCID */
10541 return unbind_to (count
, deleted
);
10546 /***********************************************************************
10547 File selection dialog
10548 ***********************************************************************/
10552 /* Callback for "OK" and "Cancel" on file selection dialog. */
10555 file_dialog_cb (widget
, client_data
, call_data
)
10557 XtPointer call_data
, client_data
;
10559 int *result
= (int *) client_data
;
10560 XmAnyCallbackStruct
*cb
= (XmAnyCallbackStruct
*) call_data
;
10561 *result
= cb
->reason
;
10565 /* Callback for unmapping a file selection dialog. This is used to
10566 capture the case where a dialog is closed via a window manager's
10567 closer button, for example. Using a XmNdestroyCallback didn't work
10571 file_dialog_unmap_cb (widget
, client_data
, call_data
)
10573 XtPointer call_data
, client_data
;
10575 int *result
= (int *) client_data
;
10576 *result
= XmCR_CANCEL
;
10580 DEFUN ("x-file-dialog", Fx_file_dialog
, Sx_file_dialog
, 2, 4, 0,
10581 doc
: /* Read file name, prompting with PROMPT in directory DIR.
10582 Use a file selection dialog.
10583 Select DEFAULT-FILENAME in the dialog's file selection box, if
10584 specified. Don't let the user enter a file name in the file
10585 selection dialog's entry field, if MUSTMATCH is non-nil. */)
10586 (prompt
, dir
, default_filename
, mustmatch
)
10587 Lisp_Object prompt
, dir
, default_filename
, mustmatch
;
10590 struct frame
*f
= SELECTED_FRAME ();
10591 Lisp_Object file
= Qnil
;
10592 Widget dialog
, text
, list
, help
;
10595 extern XtAppContext Xt_app_con
;
10596 XmString dir_xmstring
, pattern_xmstring
;
10597 int count
= SPECPDL_INDEX ();
10598 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
10600 GCPRO5 (prompt
, dir
, default_filename
, mustmatch
, file
);
10601 CHECK_STRING (prompt
);
10602 CHECK_STRING (dir
);
10604 /* Prevent redisplay. */
10605 specbind (Qinhibit_redisplay
, Qt
);
10609 /* Create the dialog with PROMPT as title, using DIR as initial
10610 directory and using "*" as pattern. */
10611 dir
= Fexpand_file_name (dir
, Qnil
);
10612 dir_xmstring
= XmStringCreateLocalized (SDATA (dir
));
10613 pattern_xmstring
= XmStringCreateLocalized ("*");
10615 XtSetArg (al
[ac
], XmNtitle
, SDATA (prompt
)); ++ac
;
10616 XtSetArg (al
[ac
], XmNdirectory
, dir_xmstring
); ++ac
;
10617 XtSetArg (al
[ac
], XmNpattern
, pattern_xmstring
); ++ac
;
10618 XtSetArg (al
[ac
], XmNresizePolicy
, XmRESIZE_GROW
); ++ac
;
10619 XtSetArg (al
[ac
], XmNdialogStyle
, XmDIALOG_APPLICATION_MODAL
); ++ac
;
10620 dialog
= XmCreateFileSelectionDialog (f
->output_data
.x
->widget
,
10622 XmStringFree (dir_xmstring
);
10623 XmStringFree (pattern_xmstring
);
10625 /* Add callbacks for OK and Cancel. */
10626 XtAddCallback (dialog
, XmNokCallback
, file_dialog_cb
,
10627 (XtPointer
) &result
);
10628 XtAddCallback (dialog
, XmNcancelCallback
, file_dialog_cb
,
10629 (XtPointer
) &result
);
10630 XtAddCallback (dialog
, XmNunmapCallback
, file_dialog_unmap_cb
,
10631 (XtPointer
) &result
);
10633 /* Disable the help button since we can't display help. */
10634 help
= XmFileSelectionBoxGetChild (dialog
, XmDIALOG_HELP_BUTTON
);
10635 XtSetSensitive (help
, False
);
10637 /* Mark OK button as default. */
10638 XtVaSetValues (XmFileSelectionBoxGetChild (dialog
, XmDIALOG_OK_BUTTON
),
10639 XmNshowAsDefault
, True
, NULL
);
10641 /* If MUSTMATCH is non-nil, disable the file entry field of the
10642 dialog, so that the user must select a file from the files list
10643 box. We can't remove it because we wouldn't have a way to get at
10644 the result file name, then. */
10645 text
= XmFileSelectionBoxGetChild (dialog
, XmDIALOG_TEXT
);
10646 if (!NILP (mustmatch
))
10649 label
= XmFileSelectionBoxGetChild (dialog
, XmDIALOG_SELECTION_LABEL
);
10650 XtSetSensitive (text
, False
);
10651 XtSetSensitive (label
, False
);
10654 /* Manage the dialog, so that list boxes get filled. */
10655 XtManageChild (dialog
);
10657 /* Select DEFAULT_FILENAME in the files list box. DEFAULT_FILENAME
10658 must include the path for this to work. */
10659 list
= XmFileSelectionBoxGetChild (dialog
, XmDIALOG_LIST
);
10660 if (STRINGP (default_filename
))
10662 XmString default_xmstring
;
10666 = XmStringCreateLocalized (SDATA (default_filename
));
10668 if (!XmListItemExists (list
, default_xmstring
))
10670 /* Add a new item if DEFAULT_FILENAME is not in the list. */
10671 XmListAddItem (list
, default_xmstring
, 0);
10675 item_pos
= XmListItemPos (list
, default_xmstring
);
10676 XmStringFree (default_xmstring
);
10678 /* Select the item and scroll it into view. */
10679 XmListSelectPos (list
, item_pos
, True
);
10680 XmListSetPos (list
, item_pos
);
10683 /* Process events until the user presses Cancel or OK. */
10685 while (result
== 0)
10688 XtAppNextEvent (Xt_app_con
, &event
);
10689 (void) x_dispatch_event (&event
, FRAME_X_DISPLAY (f
) );
10692 /* Get the result. */
10693 if (result
== XmCR_OK
)
10698 XtVaGetValues (dialog
, XmNtextString
, &text
, NULL
);
10699 XmStringGetLtoR (text
, XmFONTLIST_DEFAULT_TAG
, &data
);
10700 XmStringFree (text
);
10701 file
= build_string (data
);
10708 XtUnmanageChild (dialog
);
10709 XtDestroyWidget (dialog
);
10713 /* Make "Cancel" equivalent to C-g. */
10715 Fsignal (Qquit
, Qnil
);
10717 return unbind_to (count
, file
);
10720 #endif /* USE_MOTIF */
10724 DEFUN ("x-file-dialog", Fx_file_dialog
, Sx_file_dialog
, 2, 4, 0,
10725 "Read file name, prompting with PROMPT in directory DIR.\n\
10726 Use a file selection dialog.\n\
10727 Select DEFAULT-FILENAME in the dialog's file selection box, if\n\
10728 specified. Don't let the user enter a file name in the file\n\
10729 selection dialog's entry field, if MUSTMATCH is non-nil.")
10730 (prompt
, dir
, default_filename
, mustmatch
)
10731 Lisp_Object prompt
, dir
, default_filename
, mustmatch
;
10733 FRAME_PTR f
= SELECTED_FRAME ();
10735 Lisp_Object file
= Qnil
;
10736 int count
= specpdl_ptr
- specpdl
;
10737 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
10741 GCPRO5 (prompt
, dir
, default_filename
, mustmatch
, file
);
10742 CHECK_STRING (prompt
);
10743 CHECK_STRING (dir
);
10745 /* Prevent redisplay. */
10746 specbind (Qinhibit_redisplay
, Qt
);
10750 if (STRINGP (default_filename
))
10751 cdef_file
= SDATA (default_filename
);
10753 cdef_file
= SDATA (dir
);
10755 fn
= xg_get_file_name (f
, SDATA (prompt
), cdef_file
, ! NILP (mustmatch
));
10759 file
= build_string (fn
);
10766 /* Make "Cancel" equivalent to C-g. */
10768 Fsignal (Qquit
, Qnil
);
10770 return unbind_to (count
, file
);
10773 #endif /* USE_GTK */
10776 /***********************************************************************
10778 ***********************************************************************/
10780 #ifdef HAVE_XKBGETKEYBOARD
10781 #include <X11/XKBlib.h>
10782 #include <X11/keysym.h>
10785 DEFUN ("x-backspace-delete-keys-p", Fx_backspace_delete_keys_p
,
10786 Sx_backspace_delete_keys_p
, 0, 1, 0,
10787 doc
: /* Check if both Backspace and Delete keys are on the keyboard of FRAME.
10788 FRAME nil means use the selected frame.
10789 Value is t if we know that both keys are present, and are mapped to the
10790 usual X keysyms. */)
10794 #ifdef HAVE_XKBGETKEYBOARD
10796 struct frame
*f
= check_x_frame (frame
);
10797 Display
*dpy
= FRAME_X_DISPLAY (f
);
10798 Lisp_Object have_keys
;
10799 int major
, minor
, op
, event
, error
;
10803 /* Check library version in case we're dynamically linked. */
10804 major
= XkbMajorVersion
;
10805 minor
= XkbMinorVersion
;
10806 if (!XkbLibraryVersion (&major
, &minor
))
10812 /* Check that the server supports XKB. */
10813 major
= XkbMajorVersion
;
10814 minor
= XkbMinorVersion
;
10815 if (!XkbQueryExtension (dpy
, &op
, &event
, &error
, &major
, &minor
))
10822 kb
= XkbGetMap (dpy
, XkbAllMapComponentsMask
, XkbUseCoreKbd
);
10825 int delete_keycode
= 0, backspace_keycode
= 0, i
;
10827 if (XkbGetNames (dpy
, XkbAllNamesMask
, kb
) == Success
)
10829 for (i
= kb
->min_key_code
;
10830 (i
< kb
->max_key_code
10831 && (delete_keycode
== 0 || backspace_keycode
== 0));
10834 /* The XKB symbolic key names can be seen most easily in
10835 the PS file generated by `xkbprint -label name
10837 if (bcmp ("DELE", kb
->names
->keys
[i
].name
, 4) == 0)
10838 delete_keycode
= i
;
10839 else if (bcmp ("BKSP", kb
->names
->keys
[i
].name
, 4) == 0)
10840 backspace_keycode
= i
;
10843 XkbFreeNames (kb
, 0, True
);
10846 XkbFreeClientMap (kb
, 0, True
);
10849 && backspace_keycode
10850 && XKeysymToKeycode (dpy
, XK_Delete
) == delete_keycode
10851 && XKeysymToKeycode (dpy
, XK_BackSpace
) == backspace_keycode
)
10856 #else /* not HAVE_XKBGETKEYBOARD */
10858 #endif /* not HAVE_XKBGETKEYBOARD */
10863 /***********************************************************************
10865 ***********************************************************************/
10867 /* Keep this list in the same order as frame_parms in frame.c.
10868 Use 0 for unsupported frame parameters. */
10870 frame_parm_handler x_frame_parm_handlers
[] =
10874 x_set_background_color
,
10875 x_set_border_color
,
10876 x_set_border_width
,
10877 x_set_cursor_color
,
10880 x_set_foreground_color
,
10883 x_set_internal_border_width
,
10884 x_set_menu_bar_lines
,
10886 x_explicitly_set_name
,
10887 x_set_scroll_bar_width
,
10889 x_set_unsplittable
,
10890 x_set_vertical_scroll_bars
,
10892 x_set_tool_bar_lines
,
10893 x_set_scroll_bar_foreground
,
10894 x_set_scroll_bar_background
,
10895 x_set_screen_gamma
,
10896 x_set_line_spacing
,
10897 x_set_fringe_width
,
10898 x_set_fringe_width
,
10906 /* This is zero if not using X windows. */
10909 /* The section below is built by the lisp expression at the top of the file,
10910 just above where these variables are declared. */
10911 /*&&& init symbols here &&&*/
10912 Qnone
= intern ("none");
10913 staticpro (&Qnone
);
10914 Qsuppress_icon
= intern ("suppress-icon");
10915 staticpro (&Qsuppress_icon
);
10916 Qundefined_color
= intern ("undefined-color");
10917 staticpro (&Qundefined_color
);
10918 Qcenter
= intern ("center");
10919 staticpro (&Qcenter
);
10920 Qcompound_text
= intern ("compound-text");
10921 staticpro (&Qcompound_text
);
10922 Qcancel_timer
= intern ("cancel-timer");
10923 staticpro (&Qcancel_timer
);
10924 /* This is the end of symbol initialization. */
10926 /* Text property `display' should be nonsticky by default. */
10927 Vtext_property_default_nonsticky
10928 = Fcons (Fcons (Qdisplay
, Qt
), Vtext_property_default_nonsticky
);
10931 Qlaplace
= intern ("laplace");
10932 staticpro (&Qlaplace
);
10933 Qemboss
= intern ("emboss");
10934 staticpro (&Qemboss
);
10935 Qedge_detection
= intern ("edge-detection");
10936 staticpro (&Qedge_detection
);
10937 Qheuristic
= intern ("heuristic");
10938 staticpro (&Qheuristic
);
10939 QCmatrix
= intern (":matrix");
10940 staticpro (&QCmatrix
);
10941 QCcolor_adjustment
= intern (":color-adjustment");
10942 staticpro (&QCcolor_adjustment
);
10943 QCmask
= intern (":mask");
10944 staticpro (&QCmask
);
10946 Fput (Qundefined_color
, Qerror_conditions
,
10947 Fcons (Qundefined_color
, Fcons (Qerror
, Qnil
)));
10948 Fput (Qundefined_color
, Qerror_message
,
10949 build_string ("Undefined color"));
10951 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
10952 doc
: /* Non-nil means always draw a cross over disabled images.
10953 Disabled images are those having an `:conversion disabled' property.
10954 A cross is always drawn on black & white displays. */);
10955 cross_disabled_images
= 0;
10957 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
10958 doc
: /* List of directories to search for window system bitmap files. */);
10959 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
10961 DEFVAR_LISP ("x-pointer-shape", &Vx_pointer_shape
,
10962 doc
: /* The shape of the pointer when over text.
10963 Changing the value does not affect existing frames
10964 unless you set the mouse color. */);
10965 Vx_pointer_shape
= Qnil
;
10967 #if 0 /* This doesn't really do anything. */
10968 DEFVAR_LISP ("x-nontext-pointer-shape", &Vx_nontext_pointer_shape
,
10969 doc
: /* The shape of the pointer when not over text.
10970 This variable takes effect when you create a new frame
10971 or when you set the mouse color. */);
10973 Vx_nontext_pointer_shape
= Qnil
;
10975 DEFVAR_LISP ("x-hourglass-pointer-shape", &Vx_hourglass_pointer_shape
,
10976 doc
: /* The shape of the pointer when Emacs is busy.
10977 This variable takes effect when you create a new frame
10978 or when you set the mouse color. */);
10979 Vx_hourglass_pointer_shape
= Qnil
;
10981 DEFVAR_BOOL ("display-hourglass", &display_hourglass_p
,
10982 doc
: /* Non-zero means Emacs displays an hourglass pointer on window systems. */);
10983 display_hourglass_p
= 1;
10985 DEFVAR_LISP ("hourglass-delay", &Vhourglass_delay
,
10986 doc
: /* *Seconds to wait before displaying an hourglass pointer.
10987 Value must be an integer or float. */);
10988 Vhourglass_delay
= make_number (DEFAULT_HOURGLASS_DELAY
);
10990 #if 0 /* This doesn't really do anything. */
10991 DEFVAR_LISP ("x-mode-pointer-shape", &Vx_mode_pointer_shape
,
10992 doc
: /* The shape of the pointer when over the mode line.
10993 This variable takes effect when you create a new frame
10994 or when you set the mouse color. */);
10996 Vx_mode_pointer_shape
= Qnil
;
10998 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
10999 &Vx_sensitive_text_pointer_shape
,
11000 doc
: /* The shape of the pointer when over mouse-sensitive text.
11001 This variable takes effect when you create a new frame
11002 or when you set the mouse color. */);
11003 Vx_sensitive_text_pointer_shape
= Qnil
;
11005 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
11006 &Vx_window_horizontal_drag_shape
,
11007 doc
: /* Pointer shape to use for indicating a window can be dragged horizontally.
11008 This variable takes effect when you create a new frame
11009 or when you set the mouse color. */);
11010 Vx_window_horizontal_drag_shape
= Qnil
;
11012 DEFVAR_LISP ("x-cursor-fore-pixel", &Vx_cursor_fore_pixel
,
11013 doc
: /* A string indicating the foreground color of the cursor box. */);
11014 Vx_cursor_fore_pixel
= Qnil
;
11016 DEFVAR_LISP ("x-max-tooltip-size", &Vx_max_tooltip_size
,
11017 doc
: /* Maximum size for tooltips. Value is a pair (COLUMNS . ROWS).
11018 Text larger than this is clipped. */);
11019 Vx_max_tooltip_size
= Fcons (make_number (80), make_number (40));
11021 DEFVAR_LISP ("x-no-window-manager", &Vx_no_window_manager
,
11022 doc
: /* Non-nil if no X window manager is in use.
11023 Emacs doesn't try to figure this out; this is always nil
11024 unless you set it to something else. */);
11025 /* We don't have any way to find this out, so set it to nil
11026 and maybe the user would like to set it to t. */
11027 Vx_no_window_manager
= Qnil
;
11029 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
11030 &Vx_pixel_size_width_font_regexp
,
11031 doc
: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
11033 Since Emacs gets width of a font matching with this regexp from
11034 PIXEL_SIZE field of the name, font finding mechanism gets faster for
11035 such a font. This is especially effective for such large fonts as
11036 Chinese, Japanese, and Korean. */);
11037 Vx_pixel_size_width_font_regexp
= Qnil
;
11039 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
11040 doc
: /* Time after which cached images are removed from the cache.
11041 When an image has not been displayed this many seconds, remove it
11042 from the image cache. Value must be an integer or nil with nil
11043 meaning don't clear the cache. */);
11044 Vimage_cache_eviction_delay
= make_number (30 * 60);
11046 #ifdef USE_X_TOOLKIT
11047 Fprovide (intern ("x-toolkit"), Qnil
);
11049 Fprovide (intern ("motif"), Qnil
);
11051 DEFVAR_LISP ("motif-version-string", &Vmotif_version_string
,
11052 doc
: /* Version info for LessTif/Motif. */);
11053 Vmotif_version_string
= build_string (XmVERSION_STRING
);
11054 #endif /* USE_MOTIF */
11055 #endif /* USE_X_TOOLKIT */
11058 Fprovide (intern ("gtk"), Qnil
);
11060 DEFVAR_LISP ("gtk-version-string", &Vgtk_version_string
,
11061 doc
: /* Version info for GTK+. */);
11063 char gtk_version
[40];
11064 g_snprintf (gtk_version
, sizeof (gtk_version
), "%u.%u.%u",
11065 GTK_MAJOR_VERSION
, GTK_MINOR_VERSION
, GTK_MICRO_VERSION
);
11066 Vgtk_version_string
= build_string (gtk_version
);
11068 #endif /* USE_GTK */
11070 /* X window properties. */
11071 defsubr (&Sx_change_window_property
);
11072 defsubr (&Sx_delete_window_property
);
11073 defsubr (&Sx_window_property
);
11075 defsubr (&Sxw_display_color_p
);
11076 defsubr (&Sx_display_grayscale_p
);
11077 defsubr (&Sxw_color_defined_p
);
11078 defsubr (&Sxw_color_values
);
11079 defsubr (&Sx_server_max_request_size
);
11080 defsubr (&Sx_server_vendor
);
11081 defsubr (&Sx_server_version
);
11082 defsubr (&Sx_display_pixel_width
);
11083 defsubr (&Sx_display_pixel_height
);
11084 defsubr (&Sx_display_mm_width
);
11085 defsubr (&Sx_display_mm_height
);
11086 defsubr (&Sx_display_screens
);
11087 defsubr (&Sx_display_planes
);
11088 defsubr (&Sx_display_color_cells
);
11089 defsubr (&Sx_display_visual_class
);
11090 defsubr (&Sx_display_backing_store
);
11091 defsubr (&Sx_display_save_under
);
11092 defsubr (&Sx_create_frame
);
11093 defsubr (&Sx_open_connection
);
11094 defsubr (&Sx_close_connection
);
11095 defsubr (&Sx_display_list
);
11096 defsubr (&Sx_synchronize
);
11097 defsubr (&Sx_send_client_message
);
11098 defsubr (&Sx_focus_frame
);
11099 defsubr (&Sx_backspace_delete_keys_p
);
11101 /* Setting callback functions for fontset handler. */
11102 get_font_info_func
= x_get_font_info
;
11104 #if 0 /* This function pointer doesn't seem to be used anywhere.
11105 And the pointer assigned has the wrong type, anyway. */
11106 list_fonts_func
= x_list_fonts
;
11109 load_font_func
= x_load_font
;
11110 find_ccl_program_func
= x_find_ccl_program
;
11111 query_font_func
= x_query_font
;
11112 set_frame_fontset_func
= x_set_font
;
11113 check_window_system_func
= check_x
;
11116 Qxbm
= intern ("xbm");
11118 QCconversion
= intern (":conversion");
11119 staticpro (&QCconversion
);
11120 QCheuristic_mask
= intern (":heuristic-mask");
11121 staticpro (&QCheuristic_mask
);
11122 QCcolor_symbols
= intern (":color-symbols");
11123 staticpro (&QCcolor_symbols
);
11124 QCascent
= intern (":ascent");
11125 staticpro (&QCascent
);
11126 QCmargin
= intern (":margin");
11127 staticpro (&QCmargin
);
11128 QCrelief
= intern (":relief");
11129 staticpro (&QCrelief
);
11130 Qpostscript
= intern ("postscript");
11131 staticpro (&Qpostscript
);
11132 QCloader
= intern (":loader");
11133 staticpro (&QCloader
);
11134 QCbounding_box
= intern (":bounding-box");
11135 staticpro (&QCbounding_box
);
11136 QCpt_width
= intern (":pt-width");
11137 staticpro (&QCpt_width
);
11138 QCpt_height
= intern (":pt-height");
11139 staticpro (&QCpt_height
);
11140 QCindex
= intern (":index");
11141 staticpro (&QCindex
);
11142 Qpbm
= intern ("pbm");
11146 Qxpm
= intern ("xpm");
11151 Qjpeg
= intern ("jpeg");
11152 staticpro (&Qjpeg
);
11156 Qtiff
= intern ("tiff");
11157 staticpro (&Qtiff
);
11161 Qgif
= intern ("gif");
11166 Qpng
= intern ("png");
11170 defsubr (&Sclear_image_cache
);
11171 defsubr (&Simage_size
);
11172 defsubr (&Simage_mask_p
);
11174 hourglass_atimer
= NULL
;
11175 hourglass_shown_p
= 0;
11177 defsubr (&Sx_show_tip
);
11178 defsubr (&Sx_hide_tip
);
11180 staticpro (&tip_timer
);
11182 staticpro (&tip_frame
);
11184 last_show_tip_args
= Qnil
;
11185 staticpro (&last_show_tip_args
);
11188 defsubr (&Sx_file_dialog
);
11196 image_types
= NULL
;
11197 Vimage_types
= Qnil
;
11199 define_image_type (&xbm_type
);
11200 define_image_type (&gs_type
);
11201 define_image_type (&pbm_type
);
11204 define_image_type (&xpm_type
);
11208 define_image_type (&jpeg_type
);
11212 define_image_type (&tiff_type
);
11216 define_image_type (&gif_type
);
11220 define_image_type (&png_type
);
11224 #endif /* HAVE_X_WINDOWS */
11226 /* arch-tag: 55040d02-5485-4d58-8b22-95a7a05f3288
11227 (do not change this comment) */