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 */
129 #define MAXREQUEST(dpy) (XMaxRequestSize (dpy))
131 #define MAXREQUEST(dpy) ((dpy)->max_request_size)
134 /* The gray bitmap `bitmaps/gray'. This is done because xterm.c uses
135 it, and including `bitmaps/gray' more than once is a problem when
136 config.h defines `static' as an empty replacement string. */
138 int gray_bitmap_width
= gray_width
;
139 int gray_bitmap_height
= gray_height
;
140 char *gray_bitmap_bits
= gray_bits
;
142 /* Non-zero means we're allowed to display an hourglass cursor. */
144 int display_hourglass_p
;
146 /* The background and shape of the mouse pointer, and shape when not
147 over text or in the modeline. */
149 Lisp_Object Vx_pointer_shape
, Vx_nontext_pointer_shape
, Vx_mode_pointer_shape
;
150 Lisp_Object Vx_hourglass_pointer_shape
;
152 /* The shape when over mouse-sensitive text. */
154 Lisp_Object Vx_sensitive_text_pointer_shape
;
156 /* If non-nil, the pointer shape to indicate that windows can be
157 dragged horizontally. */
159 Lisp_Object Vx_window_horizontal_drag_shape
;
161 /* Color of chars displayed in cursor box. */
163 Lisp_Object Vx_cursor_fore_pixel
;
165 /* Nonzero if using X. */
169 /* Non nil if no window manager is in use. */
171 Lisp_Object Vx_no_window_manager
;
173 /* Search path for bitmap files. */
175 Lisp_Object Vx_bitmap_file_path
;
177 /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'. */
179 Lisp_Object Vx_pixel_size_width_font_regexp
;
182 Lisp_Object Qsuppress_icon
;
183 Lisp_Object Qundefined_color
;
185 Lisp_Object Qcompound_text
, Qcancel_timer
;
189 extern Lisp_Object Vwindow_system_version
;
191 /* The below are defined in frame.c. */
194 int image_cache_refcount
, dpyinfo_refcount
;
199 /* Error if we are not connected to X. */
205 error ("X windows are not in use or not initialized");
208 /* Nonzero if we can use mouse menus.
209 You should not call this unless HAVE_MENUS is defined. */
217 /* Extract a frame as a FRAME_PTR, defaulting to the selected frame
218 and checking validity for X. */
221 check_x_frame (frame
)
227 frame
= selected_frame
;
228 CHECK_LIVE_FRAME (frame
);
231 error ("Non-X frame used");
235 /* Let the user specify an X display with a frame.
236 nil stands for the selected frame--or, if that is not an X frame,
237 the first X display on the list. */
239 struct x_display_info
*
240 check_x_display_info (frame
)
243 struct x_display_info
*dpyinfo
= NULL
;
247 struct frame
*sf
= XFRAME (selected_frame
);
249 if (FRAME_X_P (sf
) && FRAME_LIVE_P (sf
))
250 dpyinfo
= FRAME_X_DISPLAY_INFO (sf
);
251 else if (x_display_list
!= 0)
252 dpyinfo
= x_display_list
;
254 error ("X windows are not in use or not initialized");
256 else if (STRINGP (frame
))
257 dpyinfo
= x_display_info_for_name (frame
);
260 FRAME_PTR f
= check_x_frame (frame
);
261 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
268 /* Return the Emacs frame-object corresponding to an X window.
269 It could be the frame's main window or an icon window. */
271 /* This function can be called during GC, so use GC_xxx type test macros. */
274 x_window_to_frame (dpyinfo
, wdesc
)
275 struct x_display_info
*dpyinfo
;
278 Lisp_Object tail
, frame
;
281 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
284 if (!GC_FRAMEP (frame
))
287 if (!FRAME_X_P (f
) || FRAME_X_DISPLAY_INFO (f
) != dpyinfo
)
289 if (f
->output_data
.x
->hourglass_window
== wdesc
)
292 if ((f
->output_data
.x
->edit_widget
293 && XtWindow (f
->output_data
.x
->edit_widget
) == wdesc
)
294 /* A tooltip frame? */
295 || (!f
->output_data
.x
->edit_widget
296 && FRAME_X_WINDOW (f
) == wdesc
)
297 || f
->output_data
.x
->icon_desc
== wdesc
)
299 #else /* not USE_X_TOOLKIT */
301 if (f
->output_data
.x
->edit_widget
)
303 GtkWidget
*gwdesc
= xg_win_to_widget (wdesc
);
304 struct x_output
*x
= f
->output_data
.x
;
305 if (gwdesc
!= 0 && gwdesc
== x
->edit_widget
)
309 if (FRAME_X_WINDOW (f
) == wdesc
310 || f
->output_data
.x
->icon_desc
== wdesc
)
312 #endif /* not USE_X_TOOLKIT */
317 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
318 /* Like x_window_to_frame but also compares the window with the widget's
322 x_any_window_to_frame (dpyinfo
, wdesc
)
323 struct x_display_info
*dpyinfo
;
326 Lisp_Object tail
, frame
;
327 struct frame
*f
, *found
;
331 for (tail
= Vframe_list
; GC_CONSP (tail
) && !found
; tail
= XCDR (tail
))
334 if (!GC_FRAMEP (frame
))
338 if (FRAME_X_P (f
) && FRAME_X_DISPLAY_INFO (f
) == dpyinfo
)
340 /* This frame matches if the window is any of its widgets. */
341 x
= f
->output_data
.x
;
342 if (x
->hourglass_window
== wdesc
)
347 GtkWidget
*gwdesc
= xg_win_to_widget (wdesc
);
349 && (gwdesc
== x
->widget
350 || gwdesc
== x
->edit_widget
351 || gwdesc
== x
->vbox_widget
352 || gwdesc
== x
->menubar_widget
))
355 if (wdesc
== XtWindow (x
->widget
)
356 || wdesc
== XtWindow (x
->column_widget
)
357 || wdesc
== XtWindow (x
->edit_widget
))
359 /* Match if the window is this frame's menubar. */
360 else if (lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
364 else if (FRAME_X_WINDOW (f
) == wdesc
)
365 /* A tooltip frame. */
373 /* Likewise, but exclude the menu bar widget. */
376 x_non_menubar_window_to_frame (dpyinfo
, wdesc
)
377 struct x_display_info
*dpyinfo
;
380 Lisp_Object tail
, frame
;
384 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
387 if (!GC_FRAMEP (frame
))
390 if (!FRAME_X_P (f
) || FRAME_X_DISPLAY_INFO (f
) != dpyinfo
)
392 x
= f
->output_data
.x
;
393 /* This frame matches if the window is any of its widgets. */
394 if (x
->hourglass_window
== wdesc
)
399 GtkWidget
*gwdesc
= xg_win_to_widget (wdesc
);
401 && (gwdesc
== x
->widget
402 || gwdesc
== x
->edit_widget
403 || gwdesc
== x
->vbox_widget
))
406 if (wdesc
== XtWindow (x
->widget
)
407 || wdesc
== XtWindow (x
->column_widget
)
408 || wdesc
== XtWindow (x
->edit_widget
))
412 else if (FRAME_X_WINDOW (f
) == wdesc
)
413 /* A tooltip frame. */
419 /* Likewise, but consider only the menu bar widget. */
422 x_menubar_window_to_frame (dpyinfo
, wdesc
)
423 struct x_display_info
*dpyinfo
;
426 Lisp_Object tail
, frame
;
430 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
433 if (!GC_FRAMEP (frame
))
436 if (!FRAME_X_P (f
) || FRAME_X_DISPLAY_INFO (f
) != dpyinfo
)
438 x
= f
->output_data
.x
;
439 /* Match if the window is this frame's menubar. */
441 if (x
->menubar_widget
)
443 GtkWidget
*gwdesc
= xg_win_to_widget (wdesc
);
448 && (gwdesc
== x
->menubar_widget
449 || gtk_widget_get_parent (gwdesc
) == x
->menubar_widget
))
455 if (x
->menubar_widget
456 && lw_window_is_in_menubar (wdesc
, x
->menubar_widget
))
463 /* Return the frame whose principal (outermost) window is WDESC.
464 If WDESC is some other (smaller) window, we return 0. */
467 x_top_window_to_frame (dpyinfo
, wdesc
)
468 struct x_display_info
*dpyinfo
;
471 Lisp_Object tail
, frame
;
475 for (tail
= Vframe_list
; GC_CONSP (tail
); tail
= XCDR (tail
))
478 if (!GC_FRAMEP (frame
))
481 if (!FRAME_X_P (f
) || FRAME_X_DISPLAY_INFO (f
) != dpyinfo
)
483 x
= f
->output_data
.x
;
487 /* This frame matches if the window is its topmost widget. */
489 GtkWidget
*gwdesc
= xg_win_to_widget (wdesc
);
490 if (gwdesc
== x
->widget
)
493 if (wdesc
== XtWindow (x
->widget
))
495 #if 0 /* I don't know why it did this,
496 but it seems logically wrong,
497 and it causes trouble for MapNotify events. */
498 /* Match if the window is this frame's menubar. */
499 if (x
->menubar_widget
500 && wdesc
== XtWindow (x
->menubar_widget
))
505 else if (FRAME_X_WINDOW (f
) == wdesc
)
511 #endif /* USE_X_TOOLKIT || USE_GTK */
515 /* Code to deal with bitmaps. Bitmaps are referenced by their bitmap
516 id, which is just an int that this section returns. Bitmaps are
517 reference counted so they can be shared among frames.
519 Bitmap indices are guaranteed to be > 0, so a negative number can
520 be used to indicate no bitmap.
522 If you use x_create_bitmap_from_data, then you must keep track of
523 the bitmaps yourself. That is, creating a bitmap from the same
524 data more than once will not be caught. */
527 /* Functions to access the contents of a bitmap, given an id. */
530 x_bitmap_height (f
, id
)
534 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].height
;
538 x_bitmap_width (f
, id
)
542 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].width
;
546 x_bitmap_pixmap (f
, id
)
550 return FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].pixmap
;
554 /* Allocate a new bitmap record. Returns index of new record. */
557 x_allocate_bitmap_record (f
)
560 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
563 if (dpyinfo
->bitmaps
== NULL
)
565 dpyinfo
->bitmaps_size
= 10;
567 = (struct x_bitmap_record
*) xmalloc (dpyinfo
->bitmaps_size
* sizeof (struct x_bitmap_record
));
568 dpyinfo
->bitmaps_last
= 1;
572 if (dpyinfo
->bitmaps_last
< dpyinfo
->bitmaps_size
)
573 return ++dpyinfo
->bitmaps_last
;
575 for (i
= 0; i
< dpyinfo
->bitmaps_size
; ++i
)
576 if (dpyinfo
->bitmaps
[i
].refcount
== 0)
579 dpyinfo
->bitmaps_size
*= 2;
581 = (struct x_bitmap_record
*) xrealloc (dpyinfo
->bitmaps
,
582 dpyinfo
->bitmaps_size
* sizeof (struct x_bitmap_record
));
583 return ++dpyinfo
->bitmaps_last
;
586 /* Add one reference to the reference count of the bitmap with id ID. */
589 x_reference_bitmap (f
, id
)
593 ++FRAME_X_DISPLAY_INFO (f
)->bitmaps
[id
- 1].refcount
;
596 /* Create a bitmap for frame F from a HEIGHT x WIDTH array of bits at BITS. */
599 x_create_bitmap_from_data (f
, bits
, width
, height
)
602 unsigned int width
, height
;
604 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
608 bitmap
= XCreateBitmapFromData (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
609 bits
, width
, height
);
616 id
= x_allocate_bitmap_record (f
);
617 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
618 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
619 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
620 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
621 dpyinfo
->bitmaps
[id
- 1].height
= height
;
622 dpyinfo
->bitmaps
[id
- 1].width
= width
;
627 /* Create bitmap from file FILE for frame F. */
630 x_create_bitmap_from_file (f
, file
)
634 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
635 unsigned int width
, height
;
637 int xhot
, yhot
, result
, id
;
642 /* Look for an existing bitmap with the same name. */
643 for (id
= 0; id
< dpyinfo
->bitmaps_last
; ++id
)
645 if (dpyinfo
->bitmaps
[id
].refcount
646 && dpyinfo
->bitmaps
[id
].file
647 && !strcmp (dpyinfo
->bitmaps
[id
].file
, (char *) SDATA (file
)))
649 ++dpyinfo
->bitmaps
[id
].refcount
;
654 /* Search bitmap-file-path for the file, if appropriate. */
655 fd
= openp (Vx_bitmap_file_path
, file
, Qnil
, &found
, Qnil
);
660 filename
= (char *) SDATA (found
);
662 result
= XReadBitmapFile (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
663 filename
, &width
, &height
, &bitmap
, &xhot
, &yhot
);
664 if (result
!= BitmapSuccess
)
667 id
= x_allocate_bitmap_record (f
);
668 dpyinfo
->bitmaps
[id
- 1].pixmap
= bitmap
;
669 dpyinfo
->bitmaps
[id
- 1].refcount
= 1;
670 dpyinfo
->bitmaps
[id
- 1].file
671 = (char *) xmalloc (SBYTES (file
) + 1);
672 dpyinfo
->bitmaps
[id
- 1].depth
= 1;
673 dpyinfo
->bitmaps
[id
- 1].height
= height
;
674 dpyinfo
->bitmaps
[id
- 1].width
= width
;
675 strcpy (dpyinfo
->bitmaps
[id
- 1].file
, SDATA (file
));
680 /* Remove reference to bitmap with id number ID. */
683 x_destroy_bitmap (f
, id
)
687 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
691 --dpyinfo
->bitmaps
[id
- 1].refcount
;
692 if (dpyinfo
->bitmaps
[id
- 1].refcount
== 0)
695 XFreePixmap (FRAME_X_DISPLAY (f
), dpyinfo
->bitmaps
[id
- 1].pixmap
);
696 if (dpyinfo
->bitmaps
[id
- 1].file
)
698 xfree (dpyinfo
->bitmaps
[id
- 1].file
);
699 dpyinfo
->bitmaps
[id
- 1].file
= NULL
;
706 /* Free all the bitmaps for the display specified by DPYINFO. */
709 x_destroy_all_bitmaps (dpyinfo
)
710 struct x_display_info
*dpyinfo
;
713 for (i
= 0; i
< dpyinfo
->bitmaps_last
; i
++)
714 if (dpyinfo
->bitmaps
[i
].refcount
> 0)
716 XFreePixmap (dpyinfo
->display
, dpyinfo
->bitmaps
[i
].pixmap
);
717 if (dpyinfo
->bitmaps
[i
].file
)
718 xfree (dpyinfo
->bitmaps
[i
].file
);
720 dpyinfo
->bitmaps_last
= 0;
724 static Lisp_Object unwind_create_frame
P_ ((Lisp_Object
));
725 static Lisp_Object unwind_create_tip_frame
P_ ((Lisp_Object
));
726 static void x_disable_image
P_ ((struct frame
*, struct image
*));
728 void x_set_foreground_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
729 static void x_set_wait_for_wm
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
730 void x_set_background_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
731 void x_set_mouse_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
732 void x_set_cursor_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
733 void x_set_border_color
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
734 void x_set_cursor_type
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
735 void x_set_icon_type
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
736 void x_set_icon_name
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
737 void x_explicitly_set_name
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
738 void x_set_menu_bar_lines
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
739 void x_set_title
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
740 void x_set_tool_bar_lines
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
));
741 void x_set_scroll_bar_foreground
P_ ((struct frame
*, Lisp_Object
,
743 void x_set_scroll_bar_background
P_ ((struct frame
*, Lisp_Object
,
745 static Lisp_Object x_default_scroll_bar_color_parameter
P_ ((struct frame
*,
750 static void x_edge_detection
P_ ((struct frame
*, struct image
*, Lisp_Object
,
752 static void init_color_table
P_ ((void));
753 static void free_color_table
P_ ((void));
754 static unsigned long *colors_in_color_table
P_ ((int *n
));
755 static unsigned long lookup_rgb_color
P_ ((struct frame
*f
, int r
, int g
, int b
));
756 static unsigned long lookup_pixel_color
P_ ((struct frame
*f
, unsigned long p
));
762 /* Store the screen positions of frame F into XPTR and YPTR.
763 These are the positions of the containing window manager window,
764 not Emacs's own window. */
767 x_real_positions (f
, xptr
, yptr
)
771 int win_x
, win_y
, outer_x
, outer_y
;
772 int real_x
= 0, real_y
= 0;
774 Window win
= f
->output_data
.x
->parent_desc
;
780 count
= x_catch_errors (FRAME_X_DISPLAY (f
));
782 if (win
== FRAME_X_DISPLAY_INFO (f
)->root_window
)
783 win
= FRAME_OUTER_WINDOW (f
);
785 /* This loop traverses up the containment tree until we hit the root
786 window. Window managers may intersect many windows between our window
787 and the root window. The window we find just before the root window
788 should be the outer WM window. */
791 Window wm_window
, rootw
;
792 Window
*tmp_children
;
793 unsigned int tmp_nchildren
;
796 success
= XQueryTree (FRAME_X_DISPLAY (f
), win
, &rootw
,
797 &wm_window
, &tmp_children
, &tmp_nchildren
);
799 had_errors
= x_had_errors_p (FRAME_X_DISPLAY (f
));
801 /* Don't free tmp_children if XQueryTree failed. */
805 XFree ((char *) tmp_children
);
807 if (wm_window
== rootw
|| had_errors
)
818 /* Get the real coordinates for the WM window upper left corner */
819 XGetGeometry (FRAME_X_DISPLAY (f
), win
,
820 &rootw
, &real_x
, &real_y
, &ign
, &ign
, &ign
, &ign
);
822 /* Translate real coordinates to coordinates relative to our
823 window. For our window, the upper left corner is 0, 0.
824 Since the upper left corner of the WM window is outside
825 our window, win_x and win_y will be negative:
827 ------------------ ---> x
829 | ----------------- v y
832 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
834 /* From-window, to-window. */
835 FRAME_X_DISPLAY_INFO (f
)->root_window
,
838 /* From-position, to-position. */
839 real_x
, real_y
, &win_x
, &win_y
,
844 if (FRAME_X_WINDOW (f
) == FRAME_OUTER_WINDOW (f
))
851 XTranslateCoordinates (FRAME_X_DISPLAY (f
),
853 /* From-window, to-window. */
854 FRAME_X_DISPLAY_INFO (f
)->root_window
,
855 FRAME_OUTER_WINDOW (f
),
857 /* From-position, to-position. */
858 real_x
, real_y
, &outer_x
, &outer_y
,
864 had_errors
= x_had_errors_p (FRAME_X_DISPLAY (f
));
867 x_uncatch_errors (FRAME_X_DISPLAY (f
), count
);
871 if (had_errors
) return;
873 f
->output_data
.x
->x_pixels_diff
= -win_x
;
874 f
->output_data
.x
->y_pixels_diff
= -win_y
;
875 f
->output_data
.x
->x_pixels_outer_diff
= -outer_x
;
876 f
->output_data
.x
->y_pixels_outer_diff
= -outer_y
;
885 /* Gamma-correct COLOR on frame F. */
888 gamma_correct (f
, color
)
894 color
->red
= pow (color
->red
/ 65535.0, f
->gamma
) * 65535.0 + 0.5;
895 color
->green
= pow (color
->green
/ 65535.0, f
->gamma
) * 65535.0 + 0.5;
896 color
->blue
= pow (color
->blue
/ 65535.0, f
->gamma
) * 65535.0 + 0.5;
901 /* Decide if color named COLOR_NAME is valid for use on frame F. If
902 so, return the RGB values in COLOR. If ALLOC_P is non-zero,
903 allocate the color. Value is zero if COLOR_NAME is invalid, or
904 no color could be allocated. */
907 x_defined_color (f
, color_name
, color
, alloc_p
)
914 Display
*dpy
= FRAME_X_DISPLAY (f
);
915 Colormap cmap
= FRAME_X_COLORMAP (f
);
918 success_p
= XParseColor (dpy
, cmap
, color_name
, color
);
919 if (success_p
&& alloc_p
)
920 success_p
= x_alloc_nearest_color (f
, cmap
, color
);
927 /* Return the pixel color value for color COLOR_NAME on frame F. If F
928 is a monochrome frame, return MONO_COLOR regardless of what ARG says.
929 Signal an error if color can't be allocated. */
932 x_decode_color (f
, color_name
, mono_color
)
934 Lisp_Object color_name
;
939 CHECK_STRING (color_name
);
941 #if 0 /* Don't do this. It's wrong when we're not using the default
942 colormap, it makes freeing difficult, and it's probably not
943 an important optimization. */
944 if (strcmp (SDATA (color_name
), "black") == 0)
945 return BLACK_PIX_DEFAULT (f
);
946 else if (strcmp (SDATA (color_name
), "white") == 0)
947 return WHITE_PIX_DEFAULT (f
);
950 /* Return MONO_COLOR for monochrome frames. */
951 if (FRAME_X_DISPLAY_INFO (f
)->n_planes
== 1)
954 /* x_defined_color is responsible for coping with failures
955 by looking for a near-miss. */
956 if (x_defined_color (f
, SDATA (color_name
), &cdef
, 1))
959 Fsignal (Qerror
, Fcons (build_string ("Undefined color"),
960 Fcons (color_name
, Qnil
)));
966 /* Change the `wait-for-wm' frame parameter of frame F. OLD_VALUE is
967 the previous value of that parameter, NEW_VALUE is the new value.
968 See also the comment of wait_for_wm in struct x_output. */
971 x_set_wait_for_wm (f
, new_value
, old_value
)
973 Lisp_Object new_value
, old_value
;
975 f
->output_data
.x
->wait_for_wm
= !NILP (new_value
);
979 /* Functions called only from `x_set_frame_param'
980 to set individual parameters.
982 If FRAME_X_WINDOW (f) is 0,
983 the frame is being created and its X-window does not exist yet.
984 In that case, just record the parameter's new value
985 in the standard place; do not attempt to change the window. */
988 x_set_foreground_color (f
, arg
, oldval
)
990 Lisp_Object arg
, oldval
;
992 struct x_output
*x
= f
->output_data
.x
;
993 unsigned long fg
, old_fg
;
995 fg
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
996 old_fg
= x
->foreground_pixel
;
997 x
->foreground_pixel
= fg
;
999 if (FRAME_X_WINDOW (f
) != 0)
1001 Display
*dpy
= FRAME_X_DISPLAY (f
);
1004 XSetForeground (dpy
, x
->normal_gc
, fg
);
1005 XSetBackground (dpy
, x
->reverse_gc
, fg
);
1007 if (x
->cursor_pixel
== old_fg
)
1009 unload_color (f
, x
->cursor_pixel
);
1010 x
->cursor_pixel
= x_copy_color (f
, fg
);
1011 XSetBackground (dpy
, x
->cursor_gc
, x
->cursor_pixel
);
1016 update_face_from_frame_parameter (f
, Qforeground_color
, arg
);
1018 if (FRAME_VISIBLE_P (f
))
1022 unload_color (f
, old_fg
);
1026 x_set_background_color (f
, arg
, oldval
)
1028 Lisp_Object arg
, oldval
;
1030 struct x_output
*x
= f
->output_data
.x
;
1033 bg
= x_decode_color (f
, arg
, WHITE_PIX_DEFAULT (f
));
1034 unload_color (f
, x
->background_pixel
);
1035 x
->background_pixel
= bg
;
1037 if (FRAME_X_WINDOW (f
) != 0)
1039 Display
*dpy
= FRAME_X_DISPLAY (f
);
1042 XSetBackground (dpy
, x
->normal_gc
, bg
);
1043 XSetForeground (dpy
, x
->reverse_gc
, bg
);
1044 XSetWindowBackground (dpy
, FRAME_X_WINDOW (f
), bg
);
1045 XSetForeground (dpy
, x
->cursor_gc
, bg
);
1048 xg_set_background_color (f
, bg
);
1051 #ifndef USE_TOOLKIT_SCROLL_BARS /* Turns out to be annoying with
1052 toolkit scroll bars. */
1055 for (bar
= FRAME_SCROLL_BARS (f
);
1057 bar
= XSCROLL_BAR (bar
)->next
)
1059 Window window
= SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
));
1060 XSetWindowBackground (dpy
, window
, bg
);
1063 #endif /* USE_TOOLKIT_SCROLL_BARS */
1066 update_face_from_frame_parameter (f
, Qbackground_color
, arg
);
1068 if (FRAME_VISIBLE_P (f
))
1074 x_set_mouse_color (f
, arg
, oldval
)
1076 Lisp_Object arg
, oldval
;
1078 struct x_output
*x
= f
->output_data
.x
;
1079 Display
*dpy
= FRAME_X_DISPLAY (f
);
1080 Cursor cursor
, nontext_cursor
, mode_cursor
, hand_cursor
;
1081 Cursor hourglass_cursor
, horizontal_drag_cursor
;
1083 unsigned long pixel
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1084 unsigned long mask_color
= x
->background_pixel
;
1086 /* Don't let pointers be invisible. */
1087 if (mask_color
== pixel
)
1089 x_free_colors (f
, &pixel
, 1);
1090 pixel
= x_copy_color (f
, x
->foreground_pixel
);
1093 unload_color (f
, x
->mouse_pixel
);
1094 x
->mouse_pixel
= pixel
;
1098 /* It's not okay to crash if the user selects a screwy cursor. */
1099 count
= x_catch_errors (dpy
);
1101 if (!NILP (Vx_pointer_shape
))
1103 CHECK_NUMBER (Vx_pointer_shape
);
1104 cursor
= XCreateFontCursor (dpy
, XINT (Vx_pointer_shape
));
1107 cursor
= XCreateFontCursor (dpy
, XC_xterm
);
1108 x_check_errors (dpy
, "bad text pointer cursor: %s");
1110 if (!NILP (Vx_nontext_pointer_shape
))
1112 CHECK_NUMBER (Vx_nontext_pointer_shape
);
1114 = XCreateFontCursor (dpy
, XINT (Vx_nontext_pointer_shape
));
1117 nontext_cursor
= XCreateFontCursor (dpy
, XC_left_ptr
);
1118 x_check_errors (dpy
, "bad nontext pointer cursor: %s");
1120 if (!NILP (Vx_hourglass_pointer_shape
))
1122 CHECK_NUMBER (Vx_hourglass_pointer_shape
);
1124 = XCreateFontCursor (dpy
, XINT (Vx_hourglass_pointer_shape
));
1127 hourglass_cursor
= XCreateFontCursor (dpy
, XC_watch
);
1128 x_check_errors (dpy
, "bad hourglass pointer cursor: %s");
1130 x_check_errors (dpy
, "bad nontext pointer cursor: %s");
1131 if (!NILP (Vx_mode_pointer_shape
))
1133 CHECK_NUMBER (Vx_mode_pointer_shape
);
1134 mode_cursor
= XCreateFontCursor (dpy
, XINT (Vx_mode_pointer_shape
));
1137 mode_cursor
= XCreateFontCursor (dpy
, XC_xterm
);
1138 x_check_errors (dpy
, "bad modeline pointer cursor: %s");
1140 if (!NILP (Vx_sensitive_text_pointer_shape
))
1142 CHECK_NUMBER (Vx_sensitive_text_pointer_shape
);
1144 = XCreateFontCursor (dpy
, XINT (Vx_sensitive_text_pointer_shape
));
1147 hand_cursor
= XCreateFontCursor (dpy
, XC_hand2
);
1149 if (!NILP (Vx_window_horizontal_drag_shape
))
1151 CHECK_NUMBER (Vx_window_horizontal_drag_shape
);
1152 horizontal_drag_cursor
1153 = XCreateFontCursor (dpy
, XINT (Vx_window_horizontal_drag_shape
));
1156 horizontal_drag_cursor
1157 = XCreateFontCursor (dpy
, XC_sb_h_double_arrow
);
1159 /* Check and report errors with the above calls. */
1160 x_check_errors (dpy
, "can't set cursor shape: %s");
1161 x_uncatch_errors (dpy
, count
);
1164 XColor fore_color
, back_color
;
1166 fore_color
.pixel
= x
->mouse_pixel
;
1167 x_query_color (f
, &fore_color
);
1168 back_color
.pixel
= mask_color
;
1169 x_query_color (f
, &back_color
);
1171 XRecolorCursor (dpy
, cursor
, &fore_color
, &back_color
);
1172 XRecolorCursor (dpy
, nontext_cursor
, &fore_color
, &back_color
);
1173 XRecolorCursor (dpy
, mode_cursor
, &fore_color
, &back_color
);
1174 XRecolorCursor (dpy
, hand_cursor
, &fore_color
, &back_color
);
1175 XRecolorCursor (dpy
, hourglass_cursor
, &fore_color
, &back_color
);
1176 XRecolorCursor (dpy
, horizontal_drag_cursor
, &fore_color
, &back_color
);
1179 if (FRAME_X_WINDOW (f
) != 0)
1180 XDefineCursor (dpy
, FRAME_X_WINDOW (f
), cursor
);
1182 if (cursor
!= x
->text_cursor
1183 && x
->text_cursor
!= 0)
1184 XFreeCursor (dpy
, x
->text_cursor
);
1185 x
->text_cursor
= cursor
;
1187 if (nontext_cursor
!= x
->nontext_cursor
1188 && x
->nontext_cursor
!= 0)
1189 XFreeCursor (dpy
, x
->nontext_cursor
);
1190 x
->nontext_cursor
= nontext_cursor
;
1192 if (hourglass_cursor
!= x
->hourglass_cursor
1193 && x
->hourglass_cursor
!= 0)
1194 XFreeCursor (dpy
, x
->hourglass_cursor
);
1195 x
->hourglass_cursor
= hourglass_cursor
;
1197 if (mode_cursor
!= x
->modeline_cursor
1198 && x
->modeline_cursor
!= 0)
1199 XFreeCursor (dpy
, f
->output_data
.x
->modeline_cursor
);
1200 x
->modeline_cursor
= mode_cursor
;
1202 if (hand_cursor
!= x
->hand_cursor
1203 && x
->hand_cursor
!= 0)
1204 XFreeCursor (dpy
, x
->hand_cursor
);
1205 x
->hand_cursor
= hand_cursor
;
1207 if (horizontal_drag_cursor
!= x
->horizontal_drag_cursor
1208 && x
->horizontal_drag_cursor
!= 0)
1209 XFreeCursor (dpy
, x
->horizontal_drag_cursor
);
1210 x
->horizontal_drag_cursor
= horizontal_drag_cursor
;
1215 update_face_from_frame_parameter (f
, Qmouse_color
, arg
);
1219 x_set_cursor_color (f
, arg
, oldval
)
1221 Lisp_Object arg
, oldval
;
1223 unsigned long fore_pixel
, pixel
;
1224 int fore_pixel_allocated_p
= 0, pixel_allocated_p
= 0;
1225 struct x_output
*x
= f
->output_data
.x
;
1227 if (!NILP (Vx_cursor_fore_pixel
))
1229 fore_pixel
= x_decode_color (f
, Vx_cursor_fore_pixel
,
1230 WHITE_PIX_DEFAULT (f
));
1231 fore_pixel_allocated_p
= 1;
1234 fore_pixel
= x
->background_pixel
;
1236 pixel
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1237 pixel_allocated_p
= 1;
1239 /* Make sure that the cursor color differs from the background color. */
1240 if (pixel
== x
->background_pixel
)
1242 if (pixel_allocated_p
)
1244 x_free_colors (f
, &pixel
, 1);
1245 pixel_allocated_p
= 0;
1248 pixel
= x
->mouse_pixel
;
1249 if (pixel
== fore_pixel
)
1251 if (fore_pixel_allocated_p
)
1253 x_free_colors (f
, &fore_pixel
, 1);
1254 fore_pixel_allocated_p
= 0;
1256 fore_pixel
= x
->background_pixel
;
1260 unload_color (f
, x
->cursor_foreground_pixel
);
1261 if (!fore_pixel_allocated_p
)
1262 fore_pixel
= x_copy_color (f
, fore_pixel
);
1263 x
->cursor_foreground_pixel
= fore_pixel
;
1265 unload_color (f
, x
->cursor_pixel
);
1266 if (!pixel_allocated_p
)
1267 pixel
= x_copy_color (f
, pixel
);
1268 x
->cursor_pixel
= pixel
;
1270 if (FRAME_X_WINDOW (f
) != 0)
1273 XSetBackground (FRAME_X_DISPLAY (f
), x
->cursor_gc
, x
->cursor_pixel
);
1274 XSetForeground (FRAME_X_DISPLAY (f
), x
->cursor_gc
, fore_pixel
);
1277 if (FRAME_VISIBLE_P (f
))
1279 x_update_cursor (f
, 0);
1280 x_update_cursor (f
, 1);
1284 update_face_from_frame_parameter (f
, Qcursor_color
, arg
);
1287 /* Set the border-color of frame F to pixel value PIX.
1288 Note that this does not fully take effect if done before
1289 F has an x-window. */
1292 x_set_border_pixel (f
, pix
)
1296 unload_color (f
, f
->output_data
.x
->border_pixel
);
1297 f
->output_data
.x
->border_pixel
= pix
;
1299 if (FRAME_X_WINDOW (f
) != 0 && f
->output_data
.x
->border_width
> 0)
1302 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1303 (unsigned long)pix
);
1306 if (FRAME_VISIBLE_P (f
))
1311 /* Set the border-color of frame F to value described by ARG.
1312 ARG can be a string naming a color.
1313 The border-color is used for the border that is drawn by the X server.
1314 Note that this does not fully take effect if done before
1315 F has an x-window; it must be redone when the window is created.
1317 Note: this is done in two routines because of the way X10 works.
1319 Note: under X11, this is normally the province of the window manager,
1320 and so emacs' border colors may be overridden. */
1323 x_set_border_color (f
, arg
, oldval
)
1325 Lisp_Object arg
, oldval
;
1330 pix
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1331 x_set_border_pixel (f
, pix
);
1332 update_face_from_frame_parameter (f
, Qborder_color
, arg
);
1337 x_set_cursor_type (f
, arg
, oldval
)
1339 Lisp_Object arg
, oldval
;
1341 set_frame_cursor_types (f
, arg
);
1343 /* Make sure the cursor gets redrawn. */
1344 cursor_type_changed
= 1;
1348 x_set_icon_type (f
, arg
, oldval
)
1350 Lisp_Object arg
, oldval
;
1356 if (STRINGP (oldval
) && EQ (Fstring_equal (oldval
, arg
), Qt
))
1359 else if (!STRINGP (oldval
) && EQ (oldval
, Qnil
) == EQ (arg
, Qnil
))
1364 result
= x_text_icon (f
,
1365 (char *) SDATA ((!NILP (f
->icon_name
)
1369 result
= x_bitmap_icon (f
, arg
);
1374 error ("No icon window available");
1377 XFlush (FRAME_X_DISPLAY (f
));
1382 x_set_icon_name (f
, arg
, oldval
)
1384 Lisp_Object arg
, oldval
;
1390 if (STRINGP (oldval
) && EQ (Fstring_equal (oldval
, arg
), Qt
))
1393 else if (!STRINGP (oldval
) && EQ (oldval
, Qnil
) == EQ (arg
, Qnil
))
1398 if (f
->output_data
.x
->icon_bitmap
!= 0)
1403 result
= x_text_icon (f
,
1404 (char *) SDATA ((!NILP (f
->icon_name
)
1413 error ("No icon window available");
1416 XFlush (FRAME_X_DISPLAY (f
));
1422 x_set_menu_bar_lines (f
, value
, oldval
)
1424 Lisp_Object value
, oldval
;
1427 #ifndef USE_X_TOOLKIT
1428 int olines
= FRAME_MENU_BAR_LINES (f
);
1431 /* Right now, menu bars don't work properly in minibuf-only frames;
1432 most of the commands try to apply themselves to the minibuffer
1433 frame itself, and get an error because you can't switch buffers
1434 in or split the minibuffer window. */
1435 if (FRAME_MINIBUF_ONLY_P (f
))
1438 if (INTEGERP (value
))
1439 nlines
= XINT (value
);
1443 /* Make sure we redisplay all windows in this frame. */
1444 windows_or_buffers_changed
++;
1446 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1447 FRAME_MENU_BAR_LINES (f
) = 0;
1450 FRAME_EXTERNAL_MENU_BAR (f
) = 1;
1451 if (FRAME_X_P (f
) && f
->output_data
.x
->menubar_widget
== 0)
1452 /* Make sure next redisplay shows the menu bar. */
1453 XWINDOW (FRAME_SELECTED_WINDOW (f
))->update_mode_line
= Qt
;
1457 if (FRAME_EXTERNAL_MENU_BAR (f
) == 1)
1458 free_frame_menubar (f
);
1459 FRAME_EXTERNAL_MENU_BAR (f
) = 0;
1461 f
->output_data
.x
->menubar_widget
= 0;
1463 #else /* not USE_X_TOOLKIT && not USE_GTK */
1464 FRAME_MENU_BAR_LINES (f
) = nlines
;
1465 change_window_heights (f
->root_window
, nlines
- olines
);
1466 #endif /* not USE_X_TOOLKIT */
1471 /* Set the number of lines used for the tool bar of frame F to VALUE.
1472 VALUE not an integer, or < 0 means set the lines to zero. OLDVAL
1473 is the old number of tool bar lines. This function changes the
1474 height of all windows on frame F to match the new tool bar height.
1475 The frame's height doesn't change. */
1478 x_set_tool_bar_lines (f
, value
, oldval
)
1480 Lisp_Object value
, oldval
;
1482 int delta
, nlines
, root_height
;
1483 Lisp_Object root_window
;
1485 /* Treat tool bars like menu bars. */
1486 if (FRAME_MINIBUF_ONLY_P (f
))
1489 /* Use VALUE only if an integer >= 0. */
1490 if (INTEGERP (value
) && XINT (value
) >= 0)
1491 nlines
= XFASTINT (value
);
1496 FRAME_TOOL_BAR_LINES (f
) = 0;
1499 FRAME_EXTERNAL_TOOL_BAR (f
) = 1;
1500 if (FRAME_X_P (f
) && f
->output_data
.x
->toolbar_widget
== 0)
1501 /* Make sure next redisplay shows the tool bar. */
1502 XWINDOW (FRAME_SELECTED_WINDOW (f
))->update_mode_line
= Qt
;
1503 update_frame_tool_bar (f
);
1507 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1508 free_frame_tool_bar (f
);
1509 FRAME_EXTERNAL_TOOL_BAR (f
) = 0;
1515 /* Make sure we redisplay all windows in this frame. */
1516 ++windows_or_buffers_changed
;
1518 delta
= nlines
- FRAME_TOOL_BAR_LINES (f
);
1520 /* Don't resize the tool-bar to more than we have room for. */
1521 root_window
= FRAME_ROOT_WINDOW (f
);
1522 root_height
= XINT (XWINDOW (root_window
)->height
);
1523 if (root_height
- delta
< 1)
1525 delta
= root_height
- 1;
1526 nlines
= FRAME_TOOL_BAR_LINES (f
) + delta
;
1529 FRAME_TOOL_BAR_LINES (f
) = nlines
;
1530 change_window_heights (root_window
, delta
);
1533 /* We also have to make sure that the internal border at the top of
1534 the frame, below the menu bar or tool bar, is redrawn when the
1535 tool bar disappears. This is so because the internal border is
1536 below the tool bar if one is displayed, but is below the menu bar
1537 if there isn't a tool bar. The tool bar draws into the area
1538 below the menu bar. */
1539 if (FRAME_X_WINDOW (f
) && FRAME_TOOL_BAR_LINES (f
) == 0)
1543 clear_current_matrices (f
);
1544 updating_frame
= NULL
;
1547 /* If the tool bar gets smaller, the internal border below it
1548 has to be cleared. It was formerly part of the display
1549 of the larger tool bar, and updating windows won't clear it. */
1552 int height
= FRAME_INTERNAL_BORDER_WIDTH (f
);
1553 int width
= PIXEL_WIDTH (f
);
1554 int y
= nlines
* CANON_Y_UNIT (f
);
1557 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1558 0, y
, width
, height
, False
);
1561 if (WINDOWP (f
->tool_bar_window
))
1562 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
1567 /* Set the foreground color for scroll bars on frame F to VALUE.
1568 VALUE should be a string, a color name. If it isn't a string or
1569 isn't a valid color name, do nothing. OLDVAL is the old value of
1570 the frame parameter. */
1573 x_set_scroll_bar_foreground (f
, value
, oldval
)
1575 Lisp_Object value
, oldval
;
1577 unsigned long pixel
;
1579 if (STRINGP (value
))
1580 pixel
= x_decode_color (f
, value
, BLACK_PIX_DEFAULT (f
));
1584 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
1585 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
1587 f
->output_data
.x
->scroll_bar_foreground_pixel
= pixel
;
1588 if (FRAME_X_WINDOW (f
) && FRAME_VISIBLE_P (f
))
1590 /* Remove all scroll bars because they have wrong colors. */
1591 if (condemn_scroll_bars_hook
)
1592 (*condemn_scroll_bars_hook
) (f
);
1593 if (judge_scroll_bars_hook
)
1594 (*judge_scroll_bars_hook
) (f
);
1596 update_face_from_frame_parameter (f
, Qscroll_bar_foreground
, value
);
1602 /* Set the background color for scroll bars on frame F to VALUE VALUE
1603 should be a string, a color name. If it isn't a string or isn't a
1604 valid color name, do nothing. OLDVAL is the old value of the frame
1608 x_set_scroll_bar_background (f
, value
, oldval
)
1610 Lisp_Object value
, oldval
;
1612 unsigned long pixel
;
1614 if (STRINGP (value
))
1615 pixel
= x_decode_color (f
, value
, WHITE_PIX_DEFAULT (f
));
1619 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
1620 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
1622 #ifdef USE_TOOLKIT_SCROLL_BARS
1623 /* Scrollbar shadow colors. */
1624 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
1626 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
1627 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= -1;
1629 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
1631 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
1632 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= -1;
1634 #endif /* USE_TOOLKIT_SCROLL_BARS */
1636 f
->output_data
.x
->scroll_bar_background_pixel
= pixel
;
1637 if (FRAME_X_WINDOW (f
) && FRAME_VISIBLE_P (f
))
1639 /* Remove all scroll bars because they have wrong colors. */
1640 if (condemn_scroll_bars_hook
)
1641 (*condemn_scroll_bars_hook
) (f
);
1642 if (judge_scroll_bars_hook
)
1643 (*judge_scroll_bars_hook
) (f
);
1645 update_face_from_frame_parameter (f
, Qscroll_bar_background
, value
);
1651 /* Encode Lisp string STRING as a text in a format appropriate for
1652 XICCC (X Inter Client Communication Conventions).
1654 If STRING contains only ASCII characters, do no conversion and
1655 return the string data of STRING. Otherwise, encode the text by
1656 CODING_SYSTEM, and return a newly allocated memory area which
1657 should be freed by `xfree' by a caller.
1659 SELECTIONP non-zero means the string is being encoded for an X
1660 selection, so it is safe to run pre-write conversions (which
1663 Store the byte length of resulting text in *TEXT_BYTES.
1665 If the text contains only ASCII and Latin-1, store 1 in *STRING_P,
1666 which means that the `encoding' of the result can be `STRING'.
1667 Otherwise store 0 in *STRINGP, which means that the `encoding' of
1668 the result should be `COMPOUND_TEXT'. */
1671 x_encode_text (string
, coding_system
, selectionp
, text_bytes
, stringp
)
1672 Lisp_Object string
, coding_system
;
1673 int *text_bytes
, *stringp
;
1676 unsigned char *str
= SDATA (string
);
1677 int chars
= SCHARS (string
);
1678 int bytes
= SBYTES (string
);
1682 struct coding_system coding
;
1683 extern Lisp_Object Qcompound_text_with_extensions
;
1685 charset_info
= find_charset_in_text (str
, chars
, bytes
, NULL
, Qnil
);
1686 if (charset_info
== 0)
1688 /* No multibyte character in OBJ. We need not encode it. */
1689 *text_bytes
= bytes
;
1694 setup_coding_system (coding_system
, &coding
);
1696 && SYMBOLP (coding
.pre_write_conversion
)
1697 && !NILP (Ffboundp (coding
.pre_write_conversion
)))
1699 string
= run_pre_post_conversion_on_str (string
, &coding
, 1);
1700 str
= SDATA (string
);
1701 chars
= SCHARS (string
);
1702 bytes
= SBYTES (string
);
1704 coding
.src_multibyte
= 1;
1705 coding
.dst_multibyte
= 0;
1706 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
1707 if (coding
.type
== coding_type_iso2022
)
1708 coding
.flags
|= CODING_FLAG_ISO_SAFE
;
1709 /* We suppress producing escape sequences for composition. */
1710 coding
.composing
= COMPOSITION_DISABLED
;
1711 bufsize
= encoding_buffer_size (&coding
, bytes
);
1712 buf
= (unsigned char *) xmalloc (bufsize
);
1713 encode_coding (&coding
, str
, buf
, bytes
, bufsize
);
1714 *text_bytes
= coding
.produced
;
1715 *stringp
= (charset_info
== 1
1716 || (!EQ (coding_system
, Qcompound_text
)
1717 && !EQ (coding_system
, Qcompound_text_with_extensions
)));
1722 /* Change the name of frame F to NAME. If NAME is nil, set F's name to
1725 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1726 name; if NAME is a string, set F's name to NAME and set
1727 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1729 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1730 suggesting a new name, which lisp code should override; if
1731 F->explicit_name is set, ignore the new name; otherwise, set it. */
1734 x_set_name (f
, name
, explicit)
1739 /* Make sure that requests from lisp code override requests from
1740 Emacs redisplay code. */
1743 /* If we're switching from explicit to implicit, we had better
1744 update the mode lines and thereby update the title. */
1745 if (f
->explicit_name
&& NILP (name
))
1746 update_mode_lines
= 1;
1748 f
->explicit_name
= ! NILP (name
);
1750 else if (f
->explicit_name
)
1753 /* If NAME is nil, set the name to the x_id_name. */
1756 /* Check for no change needed in this very common case
1757 before we do any consing. */
1758 if (!strcmp (FRAME_X_DISPLAY_INFO (f
)->x_id_name
,
1761 name
= build_string (FRAME_X_DISPLAY_INFO (f
)->x_id_name
);
1764 CHECK_STRING (name
);
1766 /* Don't change the name if it's already NAME. */
1767 if (! NILP (Fstring_equal (name
, f
->name
)))
1772 /* For setting the frame title, the title parameter should override
1773 the name parameter. */
1774 if (! NILP (f
->title
))
1777 if (FRAME_X_WINDOW (f
))
1782 XTextProperty text
, icon
;
1784 Lisp_Object coding_system
;
1786 /* Note: Encoding strategy
1788 We encode NAME by compound-text and use "COMPOUND-TEXT" in
1789 text.encoding. But, there are non-internationalized window
1790 managers which don't support that encoding. So, if NAME
1791 contains only ASCII and 8859-1 characters, encode it by
1792 iso-latin-1, and use "STRING" in text.encoding hoping that
1793 such window manager at least analize this format correctly,
1794 i.e. treat 8-bit bytes as 8859-1 characters.
1796 We may also be able to use "UTF8_STRING" in text.encoding
1797 in the feature which can encode all Unicode characters.
1798 But, for the moment, there's no way to know that the
1799 current window manager supports it or not. */
1800 coding_system
= Qcompound_text
;
1801 text
.value
= x_encode_text (name
, coding_system
, 0, &bytes
, &stringp
);
1802 text
.encoding
= (stringp
? XA_STRING
1803 : FRAME_X_DISPLAY_INFO (f
)->Xatom_COMPOUND_TEXT
);
1805 text
.nitems
= bytes
;
1807 if (NILP (f
->icon_name
))
1813 /* See the above comment "Note: Encoding strategy". */
1814 icon
.value
= x_encode_text (f
->icon_name
, coding_system
, 0,
1816 icon
.encoding
= (stringp
? XA_STRING
1817 : FRAME_X_DISPLAY_INFO (f
)->Xatom_COMPOUND_TEXT
);
1819 icon
.nitems
= bytes
;
1822 gtk_window_set_title (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1824 #else /* not USE_GTK */
1825 XSetWMName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
1826 #endif /* not USE_GTK */
1828 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &icon
);
1830 if (!NILP (f
->icon_name
)
1831 && icon
.value
!= (unsigned char *) SDATA (f
->icon_name
))
1833 if (text
.value
!= (unsigned char *) SDATA (name
))
1836 #else /* not HAVE_X11R4 */
1837 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1839 XStoreName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1841 #endif /* not HAVE_X11R4 */
1846 /* This function should be called when the user's lisp code has
1847 specified a name for the frame; the name will override any set by the
1850 x_explicitly_set_name (f
, arg
, oldval
)
1852 Lisp_Object arg
, oldval
;
1854 x_set_name (f
, arg
, 1);
1857 /* This function should be called by Emacs redisplay code to set the
1858 name; names set this way will never override names set by the user's
1861 x_implicitly_set_name (f
, arg
, oldval
)
1863 Lisp_Object arg
, oldval
;
1865 x_set_name (f
, arg
, 0);
1868 /* Change the title of frame F to NAME.
1869 If NAME is nil, use the frame name as the title.
1871 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1872 name; if NAME is a string, set F's name to NAME and set
1873 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1875 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1876 suggesting a new name, which lisp code should override; if
1877 F->explicit_name is set, ignore the new name; otherwise, set it. */
1880 x_set_title (f
, name
, old_name
)
1882 Lisp_Object name
, old_name
;
1884 /* Don't change the title if it's already NAME. */
1885 if (EQ (name
, f
->title
))
1888 update_mode_lines
= 1;
1895 CHECK_STRING (name
);
1897 if (FRAME_X_WINDOW (f
))
1902 XTextProperty text
, icon
;
1904 Lisp_Object coding_system
;
1906 coding_system
= Qcompound_text
;
1907 /* See the comment "Note: Encoding strategy" in x_set_name. */
1908 text
.value
= x_encode_text (name
, coding_system
, 0, &bytes
, &stringp
);
1909 text
.encoding
= (stringp
? XA_STRING
1910 : FRAME_X_DISPLAY_INFO (f
)->Xatom_COMPOUND_TEXT
);
1912 text
.nitems
= bytes
;
1914 if (NILP (f
->icon_name
))
1920 /* See the comment "Note: Encoding strategy" in x_set_name. */
1921 icon
.value
= x_encode_text (f
->icon_name
, coding_system
, 0,
1923 icon
.encoding
= (stringp
? XA_STRING
1924 : FRAME_X_DISPLAY_INFO (f
)->Xatom_COMPOUND_TEXT
);
1926 icon
.nitems
= bytes
;
1930 gtk_window_set_title (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1932 #else /* not USE_GTK */
1933 XSetWMName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
1934 #endif /* not USE_GTK */
1936 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
1939 if (!NILP (f
->icon_name
)
1940 && icon
.value
!= (unsigned char *) SDATA (f
->icon_name
))
1942 if (text
.value
!= (unsigned char *) SDATA (name
))
1945 #else /* not HAVE_X11R4 */
1946 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1948 XStoreName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1950 #endif /* not HAVE_X11R4 */
1956 x_set_scroll_bar_default_width (f
)
1959 int wid
= FONT_WIDTH (f
->output_data
.x
->font
);
1961 #ifdef USE_TOOLKIT_SCROLL_BARS
1962 /* A minimum width of 14 doesn't look good for toolkit scroll bars. */
1963 int width
= 16 + 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
1964 FRAME_SCROLL_BAR_COLS (f
) = (width
+ wid
- 1) / wid
;
1965 FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) = width
;
1967 /* Make the actual width at least 14 pixels and a multiple of a
1969 FRAME_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
1971 /* Use all of that space (aside from required margins) for the
1973 FRAME_SCROLL_BAR_PIXEL_WIDTH (f
) = 0;
1978 /* Record in frame F the specified or default value according to ALIST
1979 of the parameter named PROP (a Lisp symbol). If no value is
1980 specified for PROP, look for an X default for XPROP on the frame
1981 named NAME. If that is not found either, use the value DEFLT. */
1984 x_default_scroll_bar_color_parameter (f
, alist
, prop
, xprop
, xclass
,
1993 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1996 tem
= x_get_arg (dpyinfo
, alist
, prop
, xprop
, xclass
, RES_TYPE_STRING
);
1997 if (EQ (tem
, Qunbound
))
1999 #ifdef USE_TOOLKIT_SCROLL_BARS
2001 /* See if an X resource for the scroll bar color has been
2003 tem
= display_x_get_resource (dpyinfo
,
2004 build_string (foreground_p
2008 build_string ("verticalScrollBar"),
2012 /* If nothing has been specified, scroll bars will use a
2013 toolkit-dependent default. Because these defaults are
2014 difficult to get at without actually creating a scroll
2015 bar, use nil to indicate that no color has been
2020 #else /* not USE_TOOLKIT_SCROLL_BARS */
2024 #endif /* not USE_TOOLKIT_SCROLL_BARS */
2027 x_set_frame_parameters (f
, Fcons (Fcons (prop
, tem
), Qnil
));
2033 #if !defined (HAVE_X11R4) && !defined (HAVE_XSETWMPROTOCOLS)
2036 XSetWMProtocols (dpy
, w
, protocols
, count
)
2043 prop
= XInternAtom (dpy
, "WM_PROTOCOLS", False
);
2044 if (prop
== None
) return False
;
2045 XChangeProperty (dpy
, w
, prop
, XA_ATOM
, 32, PropModeReplace
,
2046 (unsigned char *) protocols
, count
);
2049 #endif /* not HAVE_X11R4 && not HAVE_XSETWMPROTOCOLS */
2051 #ifdef USE_X_TOOLKIT
2053 /* If the WM_PROTOCOLS property does not already contain WM_TAKE_FOCUS,
2054 WM_DELETE_WINDOW, and WM_SAVE_YOURSELF, then add them. (They may
2055 already be present because of the toolkit (Motif adds some of them,
2056 for example, but Xt doesn't). */
2059 hack_wm_protocols (f
, widget
)
2063 Display
*dpy
= XtDisplay (widget
);
2064 Window w
= XtWindow (widget
);
2065 int need_delete
= 1;
2071 Atom type
, *atoms
= 0;
2073 unsigned long nitems
= 0;
2074 unsigned long bytes_after
;
2076 if ((XGetWindowProperty (dpy
, w
,
2077 FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_protocols
,
2078 (long)0, (long)100, False
, XA_ATOM
,
2079 &type
, &format
, &nitems
, &bytes_after
,
2080 (unsigned char **) &atoms
)
2082 && format
== 32 && type
== XA_ATOM
)
2086 if (atoms
[nitems
] == FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_delete_window
)
2088 else if (atoms
[nitems
] == FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_take_focus
)
2090 else if (atoms
[nitems
] == FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_save_yourself
)
2093 if (atoms
) XFree ((char *) atoms
);
2099 props
[count
++] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_delete_window
;
2101 props
[count
++] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_take_focus
;
2103 props
[count
++] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_save_yourself
;
2105 XChangeProperty (dpy
, w
, FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_protocols
,
2106 XA_ATOM
, 32, PropModeAppend
,
2107 (unsigned char *) props
, count
);
2115 /* Support routines for XIC (X Input Context). */
2119 static XFontSet xic_create_xfontset
P_ ((struct frame
*, char *));
2120 static XIMStyle best_xim_style
P_ ((XIMStyles
*, XIMStyles
*));
2123 /* Supported XIM styles, ordered by preference. */
2125 static XIMStyle supported_xim_styles
[] =
2127 XIMPreeditPosition
| XIMStatusArea
,
2128 XIMPreeditPosition
| XIMStatusNothing
,
2129 XIMPreeditPosition
| XIMStatusNone
,
2130 XIMPreeditNothing
| XIMStatusArea
,
2131 XIMPreeditNothing
| XIMStatusNothing
,
2132 XIMPreeditNothing
| XIMStatusNone
,
2133 XIMPreeditNone
| XIMStatusArea
,
2134 XIMPreeditNone
| XIMStatusNothing
,
2135 XIMPreeditNone
| XIMStatusNone
,
2140 /* Create an X fontset on frame F with base font name
2144 xic_create_xfontset (f
, base_fontname
)
2146 char *base_fontname
;
2149 char **missing_list
;
2153 xfs
= XCreateFontSet (FRAME_X_DISPLAY (f
),
2154 base_fontname
, &missing_list
,
2155 &missing_count
, &def_string
);
2157 XFreeStringList (missing_list
);
2159 /* No need to free def_string. */
2164 /* Value is the best input style, given user preferences USER (already
2165 checked to be supported by Emacs), and styles supported by the
2166 input method XIM. */
2169 best_xim_style (user
, xim
)
2175 for (i
= 0; i
< user
->count_styles
; ++i
)
2176 for (j
= 0; j
< xim
->count_styles
; ++j
)
2177 if (user
->supported_styles
[i
] == xim
->supported_styles
[j
])
2178 return user
->supported_styles
[i
];
2180 /* Return the default style. */
2181 return XIMPreeditNothing
| XIMStatusNothing
;
2184 /* Create XIC for frame F. */
2186 static XIMStyle xic_style
;
2189 create_frame_xic (f
)
2194 XFontSet xfs
= NULL
;
2199 xim
= FRAME_X_XIM (f
);
2204 XVaNestedList preedit_attr
;
2205 XVaNestedList status_attr
;
2206 char *base_fontname
;
2209 s_area
.x
= 0; s_area
.y
= 0; s_area
.width
= 1; s_area
.height
= 1;
2210 spot
.x
= 0; spot
.y
= 1;
2211 /* Create X fontset. */
2212 fontset
= FRAME_FONTSET (f
);
2214 base_fontname
= "-*-*-*-r-normal--14-*-*-*-*-*-*-*";
2217 /* Determine the base fontname from the ASCII font name of
2219 char *ascii_font
= (char *) SDATA (fontset_ascii (fontset
));
2220 char *p
= ascii_font
;
2223 for (i
= 0; *p
; p
++)
2226 /* As the font name doesn't conform to XLFD, we can't
2227 modify it to get a suitable base fontname for the
2229 base_fontname
= "-*-*-*-r-normal--14-*-*-*-*-*-*-*";
2232 int len
= strlen (ascii_font
) + 1;
2235 for (i
= 0, p
= ascii_font
; i
< 8; p
++)
2244 base_fontname
= (char *) alloca (len
);
2245 bzero (base_fontname
, len
);
2246 strcpy (base_fontname
, "-*-*-");
2247 bcopy (p1
, base_fontname
+ 5, p
- p1
);
2248 strcat (base_fontname
, "*-*-*-*-*-*-*");
2251 xfs
= xic_create_xfontset (f
, base_fontname
);
2253 /* Determine XIC style. */
2256 XIMStyles supported_list
;
2257 supported_list
.count_styles
= (sizeof supported_xim_styles
2258 / sizeof supported_xim_styles
[0]);
2259 supported_list
.supported_styles
= supported_xim_styles
;
2260 xic_style
= best_xim_style (&supported_list
,
2261 FRAME_X_XIM_STYLES (f
));
2264 preedit_attr
= XVaCreateNestedList (0,
2267 FRAME_FOREGROUND_PIXEL (f
),
2269 FRAME_BACKGROUND_PIXEL (f
),
2270 (xic_style
& XIMPreeditPosition
2275 status_attr
= XVaCreateNestedList (0,
2281 FRAME_FOREGROUND_PIXEL (f
),
2283 FRAME_BACKGROUND_PIXEL (f
),
2286 xic
= XCreateIC (xim
,
2287 XNInputStyle
, xic_style
,
2288 XNClientWindow
, FRAME_X_WINDOW(f
),
2289 XNFocusWindow
, FRAME_X_WINDOW(f
),
2290 XNStatusAttributes
, status_attr
,
2291 XNPreeditAttributes
, preedit_attr
,
2293 XFree (preedit_attr
);
2294 XFree (status_attr
);
2297 FRAME_XIC (f
) = xic
;
2298 FRAME_XIC_STYLE (f
) = xic_style
;
2299 FRAME_XIC_FONTSET (f
) = xfs
;
2303 /* Destroy XIC and free XIC fontset of frame F, if any. */
2309 if (FRAME_XIC (f
) == NULL
)
2312 XDestroyIC (FRAME_XIC (f
));
2313 if (FRAME_XIC_FONTSET (f
))
2314 XFreeFontSet (FRAME_X_DISPLAY (f
), FRAME_XIC_FONTSET (f
));
2316 FRAME_XIC (f
) = NULL
;
2317 FRAME_XIC_FONTSET (f
) = NULL
;
2321 /* Place preedit area for XIC of window W's frame to specified
2322 pixel position X/Y. X and Y are relative to window W. */
2325 xic_set_preeditarea (w
, x
, y
)
2329 struct frame
*f
= XFRAME (w
->frame
);
2333 spot
.x
= WINDOW_TO_FRAME_PIXEL_X (w
, x
);
2334 spot
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, y
) + FONT_BASE (FRAME_FONT (f
));
2335 attr
= XVaCreateNestedList (0, XNSpotLocation
, &spot
, NULL
);
2336 XSetICValues (FRAME_XIC (f
), XNPreeditAttributes
, attr
, NULL
);
2341 /* Place status area for XIC in bottom right corner of frame F.. */
2344 xic_set_statusarea (f
)
2347 XIC xic
= FRAME_XIC (f
);
2352 /* Negotiate geometry of status area. If input method has existing
2353 status area, use its current size. */
2354 area
.x
= area
.y
= area
.width
= area
.height
= 0;
2355 attr
= XVaCreateNestedList (0, XNAreaNeeded
, &area
, NULL
);
2356 XSetICValues (xic
, XNStatusAttributes
, attr
, NULL
);
2359 attr
= XVaCreateNestedList (0, XNAreaNeeded
, &needed
, NULL
);
2360 XGetICValues (xic
, XNStatusAttributes
, attr
, NULL
);
2363 if (needed
->width
== 0) /* Use XNArea instead of XNAreaNeeded */
2365 attr
= XVaCreateNestedList (0, XNArea
, &needed
, NULL
);
2366 XGetICValues (xic
, XNStatusAttributes
, attr
, NULL
);
2370 area
.width
= needed
->width
;
2371 area
.height
= needed
->height
;
2372 area
.x
= PIXEL_WIDTH (f
) - area
.width
- FRAME_INTERNAL_BORDER_WIDTH (f
);
2373 area
.y
= (PIXEL_HEIGHT (f
) - area
.height
2374 - FRAME_MENUBAR_HEIGHT (f
)
2375 - FRAME_TOOLBAR_HEIGHT (f
)
2376 - FRAME_INTERNAL_BORDER_WIDTH (f
));
2379 attr
= XVaCreateNestedList (0, XNArea
, &area
, NULL
);
2380 XSetICValues(xic
, XNStatusAttributes
, attr
, NULL
);
2385 /* Set X fontset for XIC of frame F, using base font name
2386 BASE_FONTNAME. Called when a new Emacs fontset is chosen. */
2389 xic_set_xfontset (f
, base_fontname
)
2391 char *base_fontname
;
2396 xfs
= xic_create_xfontset (f
, base_fontname
);
2398 attr
= XVaCreateNestedList (0, XNFontSet
, xfs
, NULL
);
2399 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
2400 XSetICValues (FRAME_XIC (f
), XNPreeditAttributes
, attr
, NULL
);
2401 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
2402 XSetICValues (FRAME_XIC (f
), XNStatusAttributes
, attr
, NULL
);
2405 if (FRAME_XIC_FONTSET (f
))
2406 XFreeFontSet (FRAME_X_DISPLAY (f
), FRAME_XIC_FONTSET (f
));
2407 FRAME_XIC_FONTSET (f
) = xfs
;
2410 #endif /* HAVE_X_I18N */
2414 #ifdef USE_X_TOOLKIT
2416 /* Create and set up the X widget for frame F. */
2419 x_window (f
, window_prompting
, minibuffer_only
)
2421 long window_prompting
;
2422 int minibuffer_only
;
2424 XClassHint class_hints
;
2425 XSetWindowAttributes attributes
;
2426 unsigned long attribute_mask
;
2427 Widget shell_widget
;
2429 Widget frame_widget
;
2435 /* Use the resource name as the top-level widget name
2436 for looking up resources. Make a non-Lisp copy
2437 for the window manager, so GC relocation won't bother it.
2439 Elsewhere we specify the window name for the window manager. */
2442 char *str
= (char *) SDATA (Vx_resource_name
);
2443 f
->namebuf
= (char *) xmalloc (strlen (str
) + 1);
2444 strcpy (f
->namebuf
, str
);
2448 XtSetArg (al
[ac
], XtNallowShellResize
, 1); ac
++;
2449 XtSetArg (al
[ac
], XtNinput
, 1); ac
++;
2450 XtSetArg (al
[ac
], XtNmappedWhenManaged
, 0); ac
++;
2451 XtSetArg (al
[ac
], XtNborderWidth
, f
->output_data
.x
->border_width
); ac
++;
2452 XtSetArg (al
[ac
], XtNvisual
, FRAME_X_VISUAL (f
)); ac
++;
2453 XtSetArg (al
[ac
], XtNdepth
, FRAME_X_DISPLAY_INFO (f
)->n_planes
); ac
++;
2454 XtSetArg (al
[ac
], XtNcolormap
, FRAME_X_COLORMAP (f
)); ac
++;
2455 shell_widget
= XtAppCreateShell (f
->namebuf
, EMACS_CLASS
,
2456 applicationShellWidgetClass
,
2457 FRAME_X_DISPLAY (f
), al
, ac
);
2459 f
->output_data
.x
->widget
= shell_widget
;
2460 /* maybe_set_screen_title_format (shell_widget); */
2462 pane_widget
= lw_create_widget ("main", "pane", widget_id_tick
++,
2463 (widget_value
*) NULL
,
2464 shell_widget
, False
,
2468 (lw_callback
) NULL
);
2471 XtSetArg (al
[ac
], XtNvisual
, FRAME_X_VISUAL (f
)); ac
++;
2472 XtSetArg (al
[ac
], XtNdepth
, FRAME_X_DISPLAY_INFO (f
)->n_planes
); ac
++;
2473 XtSetArg (al
[ac
], XtNcolormap
, FRAME_X_COLORMAP (f
)); ac
++;
2474 XtSetValues (pane_widget
, al
, ac
);
2475 f
->output_data
.x
->column_widget
= pane_widget
;
2477 /* mappedWhenManaged to false tells to the paned window to not map/unmap
2478 the emacs screen when changing menubar. This reduces flickering. */
2481 XtSetArg (al
[ac
], XtNmappedWhenManaged
, 0); ac
++;
2482 XtSetArg (al
[ac
], XtNshowGrip
, 0); ac
++;
2483 XtSetArg (al
[ac
], XtNallowResize
, 1); ac
++;
2484 XtSetArg (al
[ac
], XtNresizeToPreferred
, 1); ac
++;
2485 XtSetArg (al
[ac
], XtNemacsFrame
, f
); ac
++;
2486 XtSetArg (al
[ac
], XtNvisual
, FRAME_X_VISUAL (f
)); ac
++;
2487 XtSetArg (al
[ac
], XtNdepth
, FRAME_X_DISPLAY_INFO (f
)->n_planes
); ac
++;
2488 XtSetArg (al
[ac
], XtNcolormap
, FRAME_X_COLORMAP (f
)); ac
++;
2489 frame_widget
= XtCreateWidget (f
->namebuf
, emacsFrameClass
, pane_widget
,
2492 f
->output_data
.x
->edit_widget
= frame_widget
;
2494 XtManageChild (frame_widget
);
2496 /* Do some needed geometry management. */
2499 char *tem
, shell_position
[32];
2502 int extra_borders
= 0;
2504 = (f
->output_data
.x
->menubar_widget
2505 ? (f
->output_data
.x
->menubar_widget
->core
.height
2506 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
2509 #if 0 /* Experimentally, we now get the right results
2510 for -geometry -0-0 without this. 24 Aug 96, rms. */
2511 if (FRAME_EXTERNAL_MENU_BAR (f
))
2514 XtVaGetValues (pane_widget
, XtNinternalBorderWidth
, &ibw
, NULL
);
2515 menubar_size
+= ibw
;
2519 f
->output_data
.x
->menubar_height
= menubar_size
;
2522 /* Motif seems to need this amount added to the sizes
2523 specified for the shell widget. The Athena/Lucid widgets don't.
2524 Both conclusions reached experimentally. -- rms. */
2525 XtVaGetValues (f
->output_data
.x
->edit_widget
, XtNinternalBorderWidth
,
2526 &extra_borders
, NULL
);
2530 /* Convert our geometry parameters into a geometry string
2532 Note that we do not specify here whether the position
2533 is a user-specified or program-specified one.
2534 We pass that information later, in x_wm_set_size_hints. */
2536 int left
= f
->output_data
.x
->left_pos
;
2537 int xneg
= window_prompting
& XNegative
;
2538 int top
= f
->output_data
.x
->top_pos
;
2539 int yneg
= window_prompting
& YNegative
;
2545 if (window_prompting
& USPosition
)
2546 sprintf (shell_position
, "=%dx%d%c%d%c%d",
2547 PIXEL_WIDTH (f
) + extra_borders
,
2548 PIXEL_HEIGHT (f
) + menubar_size
+ extra_borders
,
2549 (xneg
? '-' : '+'), left
,
2550 (yneg
? '-' : '+'), top
);
2552 sprintf (shell_position
, "=%dx%d",
2553 PIXEL_WIDTH (f
) + extra_borders
,
2554 PIXEL_HEIGHT (f
) + menubar_size
+ extra_borders
);
2557 len
= strlen (shell_position
) + 1;
2558 /* We don't free this because we don't know whether
2559 it is safe to free it while the frame exists.
2560 It isn't worth the trouble of arranging to free it
2561 when the frame is deleted. */
2562 tem
= (char *) xmalloc (len
);
2563 strncpy (tem
, shell_position
, len
);
2564 XtSetArg (al
[ac
], XtNgeometry
, tem
); ac
++;
2565 XtSetValues (shell_widget
, al
, ac
);
2568 XtManageChild (pane_widget
);
2569 XtRealizeWidget (shell_widget
);
2571 FRAME_X_WINDOW (f
) = XtWindow (frame_widget
);
2573 validate_x_resource_name ();
2575 class_hints
.res_name
= (char *) SDATA (Vx_resource_name
);
2576 class_hints
.res_class
= (char *) SDATA (Vx_resource_class
);
2577 XSetClassHint (FRAME_X_DISPLAY (f
), XtWindow (shell_widget
), &class_hints
);
2580 FRAME_XIC (f
) = NULL
;
2582 create_frame_xic (f
);
2585 f
->output_data
.x
->wm_hints
.input
= True
;
2586 f
->output_data
.x
->wm_hints
.flags
|= InputHint
;
2587 XSetWMHints (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2588 &f
->output_data
.x
->wm_hints
);
2590 hack_wm_protocols (f
, shell_widget
);
2593 XtAddEventHandler (shell_widget
, 0, True
, _XEditResCheckMessages
, 0);
2596 /* Do a stupid property change to force the server to generate a
2597 PropertyNotify event so that the event_stream server timestamp will
2598 be initialized to something relevant to the time we created the window.
2600 XChangeProperty (XtDisplay (frame_widget
), XtWindow (frame_widget
),
2601 FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_protocols
,
2602 XA_ATOM
, 32, PropModeAppend
,
2603 (unsigned char*) NULL
, 0);
2605 /* Make all the standard events reach the Emacs frame. */
2606 attributes
.event_mask
= STANDARD_EVENT_SET
;
2611 /* XIM server might require some X events. */
2612 unsigned long fevent
= NoEventMask
;
2613 XGetICValues(FRAME_XIC (f
), XNFilterEvents
, &fevent
, NULL
);
2614 attributes
.event_mask
|= fevent
;
2616 #endif /* HAVE_X_I18N */
2618 attribute_mask
= CWEventMask
;
2619 XChangeWindowAttributes (XtDisplay (shell_widget
), XtWindow (shell_widget
),
2620 attribute_mask
, &attributes
);
2622 XtMapWidget (frame_widget
);
2624 /* x_set_name normally ignores requests to set the name if the
2625 requested name is the same as the current name. This is the one
2626 place where that assumption isn't correct; f->name is set, but
2627 the X server hasn't been told. */
2630 int explicit = f
->explicit_name
;
2632 f
->explicit_name
= 0;
2635 x_set_name (f
, name
, explicit);
2638 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2639 f
->output_data
.x
->text_cursor
);
2643 /* This is a no-op, except under Motif. Make sure main areas are
2644 set to something reasonable, in case we get an error later. */
2645 lw_set_main_areas (pane_widget
, 0, frame_widget
);
2648 #else /* not USE_X_TOOLKIT */
2654 if (! xg_create_frame_widgets (f
))
2655 error ("Unable to create window");
2658 FRAME_XIC (f
) = NULL
;
2662 create_frame_xic (f
);
2665 /* XIM server might require some X events. */
2666 unsigned long fevent
= NoEventMask
;
2667 XGetICValues(FRAME_XIC (f
), XNFilterEvents
, &fevent
, NULL
);
2669 if (fevent
!= NoEventMask
)
2671 XSetWindowAttributes attributes
;
2672 XWindowAttributes wattr
;
2673 unsigned long attribute_mask
;
2675 XGetWindowAttributes (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2677 attributes
.event_mask
= wattr
.your_event_mask
| fevent
;
2678 attribute_mask
= CWEventMask
;
2679 XChangeWindowAttributes (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2680 attribute_mask
, &attributes
);
2688 #else /*! USE_GTK */
2689 /* Create and set up the X window for frame F. */
2696 XClassHint class_hints
;
2697 XSetWindowAttributes attributes
;
2698 unsigned long attribute_mask
;
2700 attributes
.background_pixel
= f
->output_data
.x
->background_pixel
;
2701 attributes
.border_pixel
= f
->output_data
.x
->border_pixel
;
2702 attributes
.bit_gravity
= StaticGravity
;
2703 attributes
.backing_store
= NotUseful
;
2704 attributes
.save_under
= True
;
2705 attributes
.event_mask
= STANDARD_EVENT_SET
;
2706 attributes
.colormap
= FRAME_X_COLORMAP (f
);
2707 attribute_mask
= (CWBackPixel
| CWBorderPixel
| CWBitGravity
| CWEventMask
2712 = XCreateWindow (FRAME_X_DISPLAY (f
),
2713 f
->output_data
.x
->parent_desc
,
2714 f
->output_data
.x
->left_pos
,
2715 f
->output_data
.x
->top_pos
,
2716 PIXEL_WIDTH (f
), PIXEL_HEIGHT (f
),
2717 f
->output_data
.x
->border_width
,
2718 CopyFromParent
, /* depth */
2719 InputOutput
, /* class */
2721 attribute_mask
, &attributes
);
2726 create_frame_xic (f
);
2729 /* XIM server might require some X events. */
2730 unsigned long fevent
= NoEventMask
;
2731 XGetICValues(FRAME_XIC (f
), XNFilterEvents
, &fevent
, NULL
);
2732 attributes
.event_mask
|= fevent
;
2733 attribute_mask
= CWEventMask
;
2734 XChangeWindowAttributes (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2735 attribute_mask
, &attributes
);
2738 #endif /* HAVE_X_I18N */
2740 validate_x_resource_name ();
2742 class_hints
.res_name
= (char *) SDATA (Vx_resource_name
);
2743 class_hints
.res_class
= (char *) SDATA (Vx_resource_class
);
2744 XSetClassHint (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &class_hints
);
2746 /* The menubar is part of the ordinary display;
2747 it does not count in addition to the height of the window. */
2748 f
->output_data
.x
->menubar_height
= 0;
2750 /* This indicates that we use the "Passive Input" input model.
2751 Unless we do this, we don't get the Focus{In,Out} events that we
2752 need to draw the cursor correctly. Accursed bureaucrats.
2753 XWhipsAndChains (FRAME_X_DISPLAY (f), IronMaiden, &TheRack); */
2755 f
->output_data
.x
->wm_hints
.input
= True
;
2756 f
->output_data
.x
->wm_hints
.flags
|= InputHint
;
2757 XSetWMHints (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2758 &f
->output_data
.x
->wm_hints
);
2759 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
2761 /* Request "save yourself" and "delete window" commands from wm. */
2764 protocols
[0] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_delete_window
;
2765 protocols
[1] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_save_yourself
;
2766 XSetWMProtocols (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), protocols
, 2);
2769 /* x_set_name normally ignores requests to set the name if the
2770 requested name is the same as the current name. This is the one
2771 place where that assumption isn't correct; f->name is set, but
2772 the X server hasn't been told. */
2775 int explicit = f
->explicit_name
;
2777 f
->explicit_name
= 0;
2780 x_set_name (f
, name
, explicit);
2783 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2784 f
->output_data
.x
->text_cursor
);
2788 if (FRAME_X_WINDOW (f
) == 0)
2789 error ("Unable to create window");
2792 #endif /* not USE_GTK */
2793 #endif /* not USE_X_TOOLKIT */
2795 /* Handle the icon stuff for this window. Perhaps later we might
2796 want an x_set_icon_position which can be called interactively as
2804 Lisp_Object icon_x
, icon_y
;
2805 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2807 /* Set the position of the icon. Note that twm groups all
2808 icons in an icon window. */
2809 icon_x
= x_frame_get_and_record_arg (f
, parms
, Qicon_left
, 0, 0, RES_TYPE_NUMBER
);
2810 icon_y
= x_frame_get_and_record_arg (f
, parms
, Qicon_top
, 0, 0, RES_TYPE_NUMBER
);
2811 if (!EQ (icon_x
, Qunbound
) && !EQ (icon_y
, Qunbound
))
2813 CHECK_NUMBER (icon_x
);
2814 CHECK_NUMBER (icon_y
);
2816 else if (!EQ (icon_x
, Qunbound
) || !EQ (icon_y
, Qunbound
))
2817 error ("Both left and top icon corners of icon must be specified");
2821 if (! EQ (icon_x
, Qunbound
))
2822 x_wm_set_icon_position (f
, XINT (icon_x
), XINT (icon_y
));
2824 /* Start up iconic or window? */
2825 x_wm_set_window_state
2826 (f
, (EQ (x_get_arg (dpyinfo
, parms
, Qvisibility
, 0, 0, RES_TYPE_SYMBOL
),
2831 x_text_icon (f
, (char *) SDATA ((!NILP (f
->icon_name
)
2838 /* Make the GCs needed for this window, setting the
2839 background, border and mouse colors; also create the
2840 mouse cursor and the gray border tile. */
2842 static char cursor_bits
[] =
2844 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2845 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2846 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
2847 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2854 XGCValues gc_values
;
2858 /* Create the GCs of this frame.
2859 Note that many default values are used. */
2862 gc_values
.font
= f
->output_data
.x
->font
->fid
;
2863 gc_values
.foreground
= f
->output_data
.x
->foreground_pixel
;
2864 gc_values
.background
= f
->output_data
.x
->background_pixel
;
2865 gc_values
.line_width
= 0; /* Means 1 using fast algorithm. */
2866 f
->output_data
.x
->normal_gc
2867 = XCreateGC (FRAME_X_DISPLAY (f
),
2869 GCLineWidth
| GCFont
| GCForeground
| GCBackground
,
2872 /* Reverse video style. */
2873 gc_values
.foreground
= f
->output_data
.x
->background_pixel
;
2874 gc_values
.background
= f
->output_data
.x
->foreground_pixel
;
2875 f
->output_data
.x
->reverse_gc
2876 = XCreateGC (FRAME_X_DISPLAY (f
),
2878 GCFont
| GCForeground
| GCBackground
| GCLineWidth
,
2881 /* Cursor has cursor-color background, background-color foreground. */
2882 gc_values
.foreground
= f
->output_data
.x
->background_pixel
;
2883 gc_values
.background
= f
->output_data
.x
->cursor_pixel
;
2884 gc_values
.fill_style
= FillOpaqueStippled
;
2886 = XCreateBitmapFromData (FRAME_X_DISPLAY (f
),
2887 FRAME_X_DISPLAY_INFO (f
)->root_window
,
2888 cursor_bits
, 16, 16);
2889 f
->output_data
.x
->cursor_gc
2890 = XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2891 (GCFont
| GCForeground
| GCBackground
2892 | GCFillStyle
/* | GCStipple */ | GCLineWidth
),
2896 f
->output_data
.x
->white_relief
.gc
= 0;
2897 f
->output_data
.x
->black_relief
.gc
= 0;
2899 /* Create the gray border tile used when the pointer is not in
2900 the frame. Since this depends on the frame's pixel values,
2901 this must be done on a per-frame basis. */
2902 f
->output_data
.x
->border_tile
2903 = (XCreatePixmapFromBitmapData
2904 (FRAME_X_DISPLAY (f
), FRAME_X_DISPLAY_INFO (f
)->root_window
,
2905 gray_bits
, gray_width
, gray_height
,
2906 f
->output_data
.x
->foreground_pixel
,
2907 f
->output_data
.x
->background_pixel
,
2908 DefaultDepth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
))));
2914 /* Free what was was allocated in x_make_gc. */
2920 Display
*dpy
= FRAME_X_DISPLAY (f
);
2924 if (f
->output_data
.x
->normal_gc
)
2926 XFreeGC (dpy
, f
->output_data
.x
->normal_gc
);
2927 f
->output_data
.x
->normal_gc
= 0;
2930 if (f
->output_data
.x
->reverse_gc
)
2932 XFreeGC (dpy
, f
->output_data
.x
->reverse_gc
);
2933 f
->output_data
.x
->reverse_gc
= 0;
2936 if (f
->output_data
.x
->cursor_gc
)
2938 XFreeGC (dpy
, f
->output_data
.x
->cursor_gc
);
2939 f
->output_data
.x
->cursor_gc
= 0;
2942 if (f
->output_data
.x
->border_tile
)
2944 XFreePixmap (dpy
, f
->output_data
.x
->border_tile
);
2945 f
->output_data
.x
->border_tile
= 0;
2952 /* Handler for signals raised during x_create_frame and
2953 x_create_top_frame. FRAME is the frame which is partially
2957 unwind_create_frame (frame
)
2960 struct frame
*f
= XFRAME (frame
);
2962 /* If frame is ``official'', nothing to do. */
2963 if (!CONSP (Vframe_list
) || !EQ (XCAR (Vframe_list
), frame
))
2966 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2969 x_free_frame_resources (f
);
2971 /* Check that reference counts are indeed correct. */
2972 xassert (dpyinfo
->reference_count
== dpyinfo_refcount
);
2973 xassert (dpyinfo
->image_cache
->refcount
== image_cache_refcount
);
2981 DEFUN ("x-create-frame", Fx_create_frame
, Sx_create_frame
,
2983 doc
: /* Make a new X window, which is called a "frame" in Emacs terms.
2984 Returns an Emacs frame object.
2985 ALIST is an alist of frame parameters.
2986 If the parameters specify that the frame should not have a minibuffer,
2987 and do not specify a specific minibuffer window to use,
2988 then `default-minibuffer-frame' must be a frame whose minibuffer can
2989 be shared by the new frame.
2991 This function is an internal primitive--use `make-frame' instead. */)
2996 Lisp_Object frame
, tem
;
2998 int minibuffer_only
= 0;
2999 long window_prompting
= 0;
3001 int count
= SPECPDL_INDEX ();
3002 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
3003 Lisp_Object display
;
3004 struct x_display_info
*dpyinfo
= NULL
;
3010 /* Use this general default value to start with
3011 until we know if this frame has a specified name. */
3012 Vx_resource_name
= Vinvocation_name
;
3014 display
= x_get_arg (dpyinfo
, parms
, Qdisplay
, 0, 0, RES_TYPE_STRING
);
3015 if (EQ (display
, Qunbound
))
3017 dpyinfo
= check_x_display_info (display
);
3019 kb
= dpyinfo
->kboard
;
3021 kb
= &the_only_kboard
;
3024 name
= x_get_arg (dpyinfo
, parms
, Qname
, "name", "Name", RES_TYPE_STRING
);
3026 && ! EQ (name
, Qunbound
)
3028 error ("Invalid frame name--not a string or nil");
3031 Vx_resource_name
= name
;
3033 /* See if parent window is specified. */
3034 parent
= x_get_arg (dpyinfo
, parms
, Qparent_id
, NULL
, NULL
, RES_TYPE_NUMBER
);
3035 if (EQ (parent
, Qunbound
))
3037 if (! NILP (parent
))
3038 CHECK_NUMBER (parent
);
3040 /* make_frame_without_minibuffer can run Lisp code and garbage collect. */
3041 /* No need to protect DISPLAY because that's not used after passing
3042 it to make_frame_without_minibuffer. */
3044 GCPRO4 (parms
, parent
, name
, frame
);
3045 tem
= x_get_arg (dpyinfo
, parms
, Qminibuffer
, "minibuffer", "Minibuffer",
3047 if (EQ (tem
, Qnone
) || NILP (tem
))
3048 f
= make_frame_without_minibuffer (Qnil
, kb
, display
);
3049 else if (EQ (tem
, Qonly
))
3051 f
= make_minibuffer_frame ();
3052 minibuffer_only
= 1;
3054 else if (WINDOWP (tem
))
3055 f
= make_frame_without_minibuffer (tem
, kb
, display
);
3059 XSETFRAME (frame
, f
);
3061 /* Note that X Windows does support scroll bars. */
3062 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 1;
3064 f
->output_method
= output_x_window
;
3065 f
->output_data
.x
= (struct x_output
*) xmalloc (sizeof (struct x_output
));
3066 bzero (f
->output_data
.x
, sizeof (struct x_output
));
3067 f
->output_data
.x
->icon_bitmap
= -1;
3068 f
->output_data
.x
->fontset
= -1;
3069 f
->output_data
.x
->scroll_bar_foreground_pixel
= -1;
3070 f
->output_data
.x
->scroll_bar_background_pixel
= -1;
3071 #ifdef USE_TOOLKIT_SCROLL_BARS
3072 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= -1;
3073 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= -1;
3074 #endif /* USE_TOOLKIT_SCROLL_BARS */
3075 record_unwind_protect (unwind_create_frame
, frame
);
3078 = x_get_arg (dpyinfo
, parms
, Qicon_name
, "iconName", "Title",
3080 if (! STRINGP (f
->icon_name
))
3081 f
->icon_name
= Qnil
;
3083 FRAME_X_DISPLAY_INFO (f
) = dpyinfo
;
3085 image_cache_refcount
= FRAME_X_IMAGE_CACHE (f
)->refcount
;
3086 dpyinfo_refcount
= dpyinfo
->reference_count
;
3087 #endif /* GLYPH_DEBUG */
3089 FRAME_KBOARD (f
) = kb
;
3092 /* These colors will be set anyway later, but it's important
3093 to get the color reference counts right, so initialize them! */
3096 struct gcpro gcpro1
;
3098 /* Function x_decode_color can signal an error. Make
3099 sure to initialize color slots so that we won't try
3100 to free colors we haven't allocated. */
3101 f
->output_data
.x
->foreground_pixel
= -1;
3102 f
->output_data
.x
->background_pixel
= -1;
3103 f
->output_data
.x
->cursor_pixel
= -1;
3104 f
->output_data
.x
->cursor_foreground_pixel
= -1;
3105 f
->output_data
.x
->border_pixel
= -1;
3106 f
->output_data
.x
->mouse_pixel
= -1;
3108 black
= build_string ("black");
3110 f
->output_data
.x
->foreground_pixel
3111 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3112 f
->output_data
.x
->background_pixel
3113 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3114 f
->output_data
.x
->cursor_pixel
3115 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3116 f
->output_data
.x
->cursor_foreground_pixel
3117 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3118 f
->output_data
.x
->border_pixel
3119 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3120 f
->output_data
.x
->mouse_pixel
3121 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3125 /* Specify the parent under which to make this X window. */
3129 f
->output_data
.x
->parent_desc
= (Window
) XFASTINT (parent
);
3130 f
->output_data
.x
->explicit_parent
= 1;
3134 f
->output_data
.x
->parent_desc
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
3135 f
->output_data
.x
->explicit_parent
= 0;
3138 /* Set the name; the functions to which we pass f expect the name to
3140 if (EQ (name
, Qunbound
) || NILP (name
))
3142 f
->name
= build_string (dpyinfo
->x_id_name
);
3143 f
->explicit_name
= 0;
3148 f
->explicit_name
= 1;
3149 /* use the frame's title when getting resources for this frame. */
3150 specbind (Qx_resource_name
, name
);
3153 /* Extract the window parameters from the supplied values
3154 that are needed to determine window geometry. */
3158 font
= x_get_arg (dpyinfo
, parms
, Qfont
, "font", "Font", RES_TYPE_STRING
);
3161 /* First, try whatever font the caller has specified. */
3164 tem
= Fquery_fontset (font
, Qnil
);
3166 font
= x_new_fontset (f
, SDATA (tem
));
3168 font
= x_new_font (f
, SDATA (font
));
3171 /* Try out a font which we hope has bold and italic variations. */
3172 if (!STRINGP (font
))
3173 font
= x_new_font (f
, "-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1");
3174 if (!STRINGP (font
))
3175 font
= x_new_font (f
, "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
3176 if (! STRINGP (font
))
3177 font
= x_new_font (f
, "-*-*-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
3178 if (! STRINGP (font
))
3179 /* This was formerly the first thing tried, but it finds too many fonts
3180 and takes too long. */
3181 font
= x_new_font (f
, "-*-*-medium-r-*-*-*-*-*-*-c-*-iso8859-1");
3182 /* If those didn't work, look for something which will at least work. */
3183 if (! STRINGP (font
))
3184 font
= x_new_font (f
, "-*-fixed-*-*-*-*-*-140-*-*-c-*-iso8859-1");
3186 if (! STRINGP (font
))
3187 font
= build_string ("fixed");
3189 x_default_parameter (f
, parms
, Qfont
, font
,
3190 "font", "Font", RES_TYPE_STRING
);
3194 /* Prevent lwlib/xlwmenu.c from crashing because of a bug
3195 whereby it fails to get any font. */
3196 xlwmenu_default_font
= f
->output_data
.x
->font
;
3199 x_default_parameter (f
, parms
, Qborder_width
, make_number (2),
3200 "borderWidth", "BorderWidth", RES_TYPE_NUMBER
);
3202 /* This defaults to 1 in order to match xterm. We recognize either
3203 internalBorderWidth or internalBorder (which is what xterm calls
3205 if (NILP (Fassq (Qinternal_border_width
, parms
)))
3209 value
= x_get_arg (dpyinfo
, parms
, Qinternal_border_width
,
3210 "internalBorder", "internalBorder", RES_TYPE_NUMBER
);
3211 if (! EQ (value
, Qunbound
))
3212 parms
= Fcons (Fcons (Qinternal_border_width
, value
),
3215 x_default_parameter (f
, parms
, Qinternal_border_width
, make_number (1),
3216 "internalBorderWidth", "internalBorderWidth",
3218 x_default_parameter (f
, parms
, Qvertical_scroll_bars
, Qleft
,
3219 "verticalScrollBars", "ScrollBars",
3222 /* Also do the stuff which must be set before the window exists. */
3223 x_default_parameter (f
, parms
, Qforeground_color
, build_string ("black"),
3224 "foreground", "Foreground", RES_TYPE_STRING
);
3225 x_default_parameter (f
, parms
, Qbackground_color
, build_string ("white"),
3226 "background", "Background", RES_TYPE_STRING
);
3227 x_default_parameter (f
, parms
, Qmouse_color
, build_string ("black"),
3228 "pointerColor", "Foreground", RES_TYPE_STRING
);
3229 x_default_parameter (f
, parms
, Qcursor_color
, build_string ("black"),
3230 "cursorColor", "Foreground", RES_TYPE_STRING
);
3231 x_default_parameter (f
, parms
, Qborder_color
, build_string ("black"),
3232 "borderColor", "BorderColor", RES_TYPE_STRING
);
3233 x_default_parameter (f
, parms
, Qscreen_gamma
, Qnil
,
3234 "screenGamma", "ScreenGamma", RES_TYPE_FLOAT
);
3235 x_default_parameter (f
, parms
, Qline_spacing
, Qnil
,
3236 "lineSpacing", "LineSpacing", RES_TYPE_NUMBER
);
3237 x_default_parameter (f
, parms
, Qleft_fringe
, Qnil
,
3238 "leftFringe", "LeftFringe", RES_TYPE_NUMBER
);
3239 x_default_parameter (f
, parms
, Qright_fringe
, Qnil
,
3240 "rightFringe", "RightFringe", RES_TYPE_NUMBER
);
3242 x_default_scroll_bar_color_parameter (f
, parms
, Qscroll_bar_foreground
,
3243 "scrollBarForeground",
3244 "ScrollBarForeground", 1);
3245 x_default_scroll_bar_color_parameter (f
, parms
, Qscroll_bar_background
,
3246 "scrollBarBackground",
3247 "ScrollBarBackground", 0);
3249 /* Init faces before x_default_parameter is called for scroll-bar
3250 parameters because that function calls x_set_scroll_bar_width,
3251 which calls change_frame_size, which calls Fset_window_buffer,
3252 which runs hooks, which call Fvertical_motion. At the end, we
3253 end up in init_iterator with a null face cache, which should not
3255 init_frame_faces (f
);
3257 x_default_parameter (f
, parms
, Qmenu_bar_lines
, make_number (1),
3258 "menuBar", "MenuBar", RES_TYPE_NUMBER
);
3259 x_default_parameter (f
, parms
, Qtool_bar_lines
, make_number (1),
3260 "toolBar", "ToolBar", RES_TYPE_NUMBER
);
3261 x_default_parameter (f
, parms
, Qbuffer_predicate
, Qnil
,
3262 "bufferPredicate", "BufferPredicate",
3264 x_default_parameter (f
, parms
, Qtitle
, Qnil
,
3265 "title", "Title", RES_TYPE_STRING
);
3266 x_default_parameter (f
, parms
, Qwait_for_wm
, Qt
,
3267 "waitForWM", "WaitForWM", RES_TYPE_BOOLEAN
);
3268 x_default_parameter (f
, parms
, Qfullscreen
, Qnil
,
3269 "fullscreen", "Fullscreen", RES_TYPE_SYMBOL
);
3271 f
->output_data
.x
->parent_desc
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
3273 /* Compute the size of the X window. */
3274 window_prompting
= x_figure_window_size (f
, parms
, 1);
3276 tem
= x_get_arg (dpyinfo
, parms
, Qunsplittable
, 0, 0, RES_TYPE_BOOLEAN
);
3277 f
->no_split
= minibuffer_only
|| EQ (tem
, Qt
);
3279 /* Create the X widget or window. */
3280 #ifdef USE_X_TOOLKIT
3281 x_window (f
, window_prompting
, minibuffer_only
);
3289 /* Now consider the frame official. */
3290 FRAME_X_DISPLAY_INFO (f
)->reference_count
++;
3291 Vframe_list
= Fcons (frame
, Vframe_list
);
3293 /* We need to do this after creating the X window, so that the
3294 icon-creation functions can say whose icon they're describing. */
3295 x_default_parameter (f
, parms
, Qicon_type
, Qnil
,
3296 "bitmapIcon", "BitmapIcon", RES_TYPE_SYMBOL
);
3298 x_default_parameter (f
, parms
, Qauto_raise
, Qnil
,
3299 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
3300 x_default_parameter (f
, parms
, Qauto_lower
, Qnil
,
3301 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
3302 x_default_parameter (f
, parms
, Qcursor_type
, Qbox
,
3303 "cursorType", "CursorType", RES_TYPE_SYMBOL
);
3304 x_default_parameter (f
, parms
, Qscroll_bar_width
, Qnil
,
3305 "scrollBarWidth", "ScrollBarWidth",
3308 /* Dimensions, especially f->height, must be done via change_frame_size.
3309 Change will not be effected unless different from the current
3315 SET_FRAME_WIDTH (f
, 0);
3316 change_frame_size (f
, height
, width
, 1, 0, 0);
3318 /* Set up faces after all frame parameters are known. This call
3319 also merges in face attributes specified for new frames. If we
3320 don't do this, the `menu' face for instance won't have the right
3321 colors, and the menu bar won't appear in the specified colors for
3323 call1 (Qface_set_after_frame_default
, frame
);
3325 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
3326 /* Create the menu bar. */
3327 if (!minibuffer_only
&& FRAME_EXTERNAL_MENU_BAR (f
))
3329 /* If this signals an error, we haven't set size hints for the
3330 frame and we didn't make it visible. */
3331 initialize_frame_menubar (f
);
3334 /* This is a no-op, except under Motif where it arranges the
3335 main window for the widgets on it. */
3336 lw_set_main_areas (f
->output_data
.x
->column_widget
,
3337 f
->output_data
.x
->menubar_widget
,
3338 f
->output_data
.x
->edit_widget
);
3339 #endif /* not USE_GTK */
3341 #endif /* USE_X_TOOLKIT || USE_GTK */
3343 /* Tell the server what size and position, etc, we want, and how
3344 badly we want them. This should be done after we have the menu
3345 bar so that its size can be taken into account. */
3347 x_wm_set_size_hint (f
, window_prompting
, 0);
3350 /* Make the window appear on the frame and enable display, unless
3351 the caller says not to. However, with explicit parent, Emacs
3352 cannot control visibility, so don't try. */
3353 if (! f
->output_data
.x
->explicit_parent
)
3355 Lisp_Object visibility
;
3357 visibility
= x_get_arg (dpyinfo
, parms
, Qvisibility
, 0, 0,
3359 if (EQ (visibility
, Qunbound
))
3362 if (EQ (visibility
, Qicon
))
3363 x_iconify_frame (f
);
3364 else if (! NILP (visibility
))
3365 x_make_frame_visible (f
);
3367 /* Must have been Qnil. */
3373 /* Make sure windows on this frame appear in calls to next-window
3374 and similar functions. */
3375 Vwindow_list
= Qnil
;
3377 return unbind_to (count
, frame
);
3381 /* FRAME is used only to get a handle on the X display. We don't pass the
3382 display info directly because we're called from frame.c, which doesn't
3383 know about that structure. */
3386 x_get_focus_frame (frame
)
3387 struct frame
*frame
;
3389 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (frame
);
3391 if (! dpyinfo
->x_focus_frame
)
3394 XSETFRAME (xfocus
, dpyinfo
->x_focus_frame
);
3399 /* In certain situations, when the window manager follows a
3400 click-to-focus policy, there seems to be no way around calling
3401 XSetInputFocus to give another frame the input focus .
3403 In an ideal world, XSetInputFocus should generally be avoided so
3404 that applications don't interfere with the window manager's focus
3405 policy. But I think it's okay to use when it's clearly done
3406 following a user-command. */
3408 DEFUN ("x-focus-frame", Fx_focus_frame
, Sx_focus_frame
, 1, 1, 0,
3409 doc
: /* Set the input focus to FRAME.
3410 FRAME nil means use the selected frame. */)
3414 struct frame
*f
= check_x_frame (frame
);
3415 Display
*dpy
= FRAME_X_DISPLAY (f
);
3419 count
= x_catch_errors (dpy
);
3420 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3421 RevertToParent
, CurrentTime
);
3422 x_uncatch_errors (dpy
, count
);
3429 DEFUN ("xw-color-defined-p", Fxw_color_defined_p
, Sxw_color_defined_p
, 1, 2, 0,
3430 doc
: /* Internal function called by `color-defined-p', which see. */)
3432 Lisp_Object color
, frame
;
3435 FRAME_PTR f
= check_x_frame (frame
);
3437 CHECK_STRING (color
);
3439 if (x_defined_color (f
, SDATA (color
), &foo
, 0))
3445 DEFUN ("xw-color-values", Fxw_color_values
, Sxw_color_values
, 1, 2, 0,
3446 doc
: /* Internal function called by `color-values', which see. */)
3448 Lisp_Object color
, frame
;
3451 FRAME_PTR f
= check_x_frame (frame
);
3453 CHECK_STRING (color
);
3455 if (x_defined_color (f
, SDATA (color
), &foo
, 0))
3459 rgb
[0] = make_number (foo
.red
);
3460 rgb
[1] = make_number (foo
.green
);
3461 rgb
[2] = make_number (foo
.blue
);
3462 return Flist (3, rgb
);
3468 DEFUN ("xw-display-color-p", Fxw_display_color_p
, Sxw_display_color_p
, 0, 1, 0,
3469 doc
: /* Internal function called by `display-color-p', which see. */)
3471 Lisp_Object display
;
3473 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3475 if (dpyinfo
->n_planes
<= 2)
3478 switch (dpyinfo
->visual
->class)
3491 DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p
, Sx_display_grayscale_p
,
3493 doc
: /* Return t if the X display supports shades of gray.
3494 Note that color displays do support shades of gray.
3495 The optional argument DISPLAY specifies which display to ask about.
3496 DISPLAY should be either a frame or a display name (a string).
3497 If omitted or nil, that stands for the selected frame's display. */)
3499 Lisp_Object display
;
3501 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3503 if (dpyinfo
->n_planes
<= 1)
3506 switch (dpyinfo
->visual
->class)
3521 DEFUN ("x-display-pixel-width", Fx_display_pixel_width
, Sx_display_pixel_width
,
3523 doc
: /* Returns the width in pixels of the X display DISPLAY.
3524 The optional argument DISPLAY specifies which display to ask about.
3525 DISPLAY should be either a frame or a display name (a string).
3526 If omitted or nil, that stands for the selected frame's display. */)
3528 Lisp_Object display
;
3530 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3532 return make_number (dpyinfo
->width
);
3535 DEFUN ("x-display-pixel-height", Fx_display_pixel_height
,
3536 Sx_display_pixel_height
, 0, 1, 0,
3537 doc
: /* Returns the height in pixels of the X display DISPLAY.
3538 The optional argument DISPLAY specifies which display to ask about.
3539 DISPLAY should be either a frame or a display name (a string).
3540 If omitted or nil, that stands for the selected frame's display. */)
3542 Lisp_Object display
;
3544 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3546 return make_number (dpyinfo
->height
);
3549 DEFUN ("x-display-planes", Fx_display_planes
, Sx_display_planes
,
3551 doc
: /* Returns the number of bitplanes of the X display DISPLAY.
3552 The optional argument DISPLAY specifies which display to ask about.
3553 DISPLAY should be either a frame or a display name (a string).
3554 If omitted or nil, that stands for the selected frame's display. */)
3556 Lisp_Object display
;
3558 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3560 return make_number (dpyinfo
->n_planes
);
3563 DEFUN ("x-display-color-cells", Fx_display_color_cells
, Sx_display_color_cells
,
3565 doc
: /* Returns the number of color cells of the X display DISPLAY.
3566 The optional argument DISPLAY specifies which display to ask about.
3567 DISPLAY should be either a frame or a display name (a string).
3568 If omitted or nil, that stands for the selected frame's display. */)
3570 Lisp_Object display
;
3572 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3574 return make_number (DisplayCells (dpyinfo
->display
,
3575 XScreenNumberOfScreen (dpyinfo
->screen
)));
3578 DEFUN ("x-server-max-request-size", Fx_server_max_request_size
,
3579 Sx_server_max_request_size
,
3581 doc
: /* Returns the maximum request size of the X server of display DISPLAY.
3582 The optional argument DISPLAY specifies which display to ask about.
3583 DISPLAY should be either a frame or a display name (a string).
3584 If omitted or nil, that stands for the selected frame's display. */)
3586 Lisp_Object display
;
3588 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3590 return make_number (MAXREQUEST (dpyinfo
->display
));
3593 DEFUN ("x-server-vendor", Fx_server_vendor
, Sx_server_vendor
, 0, 1, 0,
3594 doc
: /* Returns the vendor ID string of the X server of display DISPLAY.
3595 The optional argument DISPLAY specifies which display to ask about.
3596 DISPLAY should be either a frame or a display name (a string).
3597 If omitted or nil, that stands for the selected frame's display. */)
3599 Lisp_Object display
;
3601 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3602 char *vendor
= ServerVendor (dpyinfo
->display
);
3604 if (! vendor
) vendor
= "";
3605 return build_string (vendor
);
3608 DEFUN ("x-server-version", Fx_server_version
, Sx_server_version
, 0, 1, 0,
3609 doc
: /* Returns the version numbers of the X server of display DISPLAY.
3610 The value is a list of three integers: the major and minor
3611 version numbers of the X Protocol in use, and the vendor-specific release
3612 number. See also the function `x-server-vendor'.
3614 The optional argument DISPLAY specifies which display to ask about.
3615 DISPLAY should be either a frame or a display name (a string).
3616 If omitted or nil, that stands for the selected frame's display. */)
3618 Lisp_Object display
;
3620 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3621 Display
*dpy
= dpyinfo
->display
;
3623 return Fcons (make_number (ProtocolVersion (dpy
)),
3624 Fcons (make_number (ProtocolRevision (dpy
)),
3625 Fcons (make_number (VendorRelease (dpy
)), Qnil
)));
3628 DEFUN ("x-display-screens", Fx_display_screens
, Sx_display_screens
, 0, 1, 0,
3629 doc
: /* Return the number of screens on the X server of display DISPLAY.
3630 The optional argument DISPLAY specifies which display to ask about.
3631 DISPLAY should be either a frame or a display name (a string).
3632 If omitted or nil, that stands for the selected frame's display. */)
3634 Lisp_Object display
;
3636 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3638 return make_number (ScreenCount (dpyinfo
->display
));
3641 DEFUN ("x-display-mm-height", Fx_display_mm_height
, Sx_display_mm_height
, 0, 1, 0,
3642 doc
: /* Return the height in millimeters of the X display DISPLAY.
3643 The optional argument DISPLAY specifies which display to ask about.
3644 DISPLAY should be either a frame or a display name (a string).
3645 If omitted or nil, that stands for the selected frame's display. */)
3647 Lisp_Object display
;
3649 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3651 return make_number (HeightMMOfScreen (dpyinfo
->screen
));
3654 DEFUN ("x-display-mm-width", Fx_display_mm_width
, Sx_display_mm_width
, 0, 1, 0,
3655 doc
: /* Return the width in millimeters of the X display DISPLAY.
3656 The optional argument DISPLAY specifies which display to ask about.
3657 DISPLAY should be either a frame or a display name (a string).
3658 If omitted or nil, that stands for the selected frame's display. */)
3660 Lisp_Object display
;
3662 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3664 return make_number (WidthMMOfScreen (dpyinfo
->screen
));
3667 DEFUN ("x-display-backing-store", Fx_display_backing_store
,
3668 Sx_display_backing_store
, 0, 1, 0,
3669 doc
: /* Returns an indication of whether X display DISPLAY does backing store.
3670 The value may be `always', `when-mapped', or `not-useful'.
3671 The optional argument DISPLAY specifies which display to ask about.
3672 DISPLAY should be either a frame or a display name (a string).
3673 If omitted or nil, that stands for the selected frame's display. */)
3675 Lisp_Object display
;
3677 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3680 switch (DoesBackingStore (dpyinfo
->screen
))
3683 result
= intern ("always");
3687 result
= intern ("when-mapped");
3691 result
= intern ("not-useful");
3695 error ("Strange value for BackingStore parameter of screen");
3702 DEFUN ("x-display-visual-class", Fx_display_visual_class
,
3703 Sx_display_visual_class
, 0, 1, 0,
3704 doc
: /* Return the visual class of the X display DISPLAY.
3705 The value is one of the symbols `static-gray', `gray-scale',
3706 `static-color', `pseudo-color', `true-color', or `direct-color'.
3708 The optional argument DISPLAY specifies which display to ask about.
3709 DISPLAY should be either a frame or a display name (a string).
3710 If omitted or nil, that stands for the selected frame's display. */)
3712 Lisp_Object display
;
3714 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3717 switch (dpyinfo
->visual
->class)
3720 result
= intern ("static-gray");
3723 result
= intern ("gray-scale");
3726 result
= intern ("static-color");
3729 result
= intern ("pseudo-color");
3732 result
= intern ("true-color");
3735 result
= intern ("direct-color");
3738 error ("Display has an unknown visual class");
3745 DEFUN ("x-display-save-under", Fx_display_save_under
,
3746 Sx_display_save_under
, 0, 1, 0,
3747 doc
: /* Returns t if the X display DISPLAY supports the save-under feature.
3748 The optional argument DISPLAY specifies which display to ask about.
3749 DISPLAY should be either a frame or a display name (a string).
3750 If omitted or nil, that stands for the selected frame's display. */)
3752 Lisp_Object display
;
3754 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3756 if (DoesSaveUnders (dpyinfo
->screen
) == True
)
3764 register struct frame
*f
;
3766 return PIXEL_WIDTH (f
);
3771 register struct frame
*f
;
3773 return PIXEL_HEIGHT (f
);
3778 register struct frame
*f
;
3780 return FONT_WIDTH (f
->output_data
.x
->font
);
3785 register struct frame
*f
;
3787 return f
->output_data
.x
->line_height
;
3792 register struct frame
*f
;
3794 return FRAME_X_DISPLAY_INFO (f
)->n_planes
;
3799 /************************************************************************
3801 ************************************************************************/
3804 /* Mapping visual names to visuals. */
3806 static struct visual_class
3813 {"StaticGray", StaticGray
},
3814 {"GrayScale", GrayScale
},
3815 {"StaticColor", StaticColor
},
3816 {"PseudoColor", PseudoColor
},
3817 {"TrueColor", TrueColor
},
3818 {"DirectColor", DirectColor
},
3823 #ifndef HAVE_XSCREENNUMBEROFSCREEN
3825 /* Value is the screen number of screen SCR. This is a substitute for
3826 the X function with the same name when that doesn't exist. */
3829 XScreenNumberOfScreen (scr
)
3830 register Screen
*scr
;
3832 Display
*dpy
= scr
->display
;
3835 for (i
= 0; i
< dpy
->nscreens
; ++i
)
3836 if (scr
== dpy
->screens
+ i
)
3842 #endif /* not HAVE_XSCREENNUMBEROFSCREEN */
3845 /* Select the visual that should be used on display DPYINFO. Set
3846 members of DPYINFO appropriately. Called from x_term_init. */
3849 select_visual (dpyinfo
)
3850 struct x_display_info
*dpyinfo
;
3852 Display
*dpy
= dpyinfo
->display
;
3853 Screen
*screen
= dpyinfo
->screen
;
3856 /* See if a visual is specified. */
3857 value
= display_x_get_resource (dpyinfo
,
3858 build_string ("visualClass"),
3859 build_string ("VisualClass"),
3861 if (STRINGP (value
))
3863 /* VALUE should be of the form CLASS-DEPTH, where CLASS is one
3864 of `PseudoColor', `TrueColor' etc. and DEPTH is the color
3865 depth, a decimal number. NAME is compared with case ignored. */
3866 char *s
= (char *) alloca (SBYTES (value
) + 1);
3871 strcpy (s
, SDATA (value
));
3872 dash
= index (s
, '-');
3875 dpyinfo
->n_planes
= atoi (dash
+ 1);
3879 /* We won't find a matching visual with depth 0, so that
3880 an error will be printed below. */
3881 dpyinfo
->n_planes
= 0;
3883 /* Determine the visual class. */
3884 for (i
= 0; visual_classes
[i
].name
; ++i
)
3885 if (xstricmp (s
, visual_classes
[i
].name
) == 0)
3887 class = visual_classes
[i
].class;
3891 /* Look up a matching visual for the specified class. */
3893 || !XMatchVisualInfo (dpy
, XScreenNumberOfScreen (screen
),
3894 dpyinfo
->n_planes
, class, &vinfo
))
3895 fatal ("Invalid visual specification `%s'", SDATA (value
));
3897 dpyinfo
->visual
= vinfo
.visual
;
3902 XVisualInfo
*vinfo
, vinfo_template
;
3904 dpyinfo
->visual
= DefaultVisualOfScreen (screen
);
3907 vinfo_template
.visualid
= XVisualIDFromVisual (dpyinfo
->visual
);
3909 vinfo_template
.visualid
= dpyinfo
->visual
->visualid
;
3911 vinfo_template
.screen
= XScreenNumberOfScreen (screen
);
3912 vinfo
= XGetVisualInfo (dpy
, VisualIDMask
| VisualScreenMask
,
3913 &vinfo_template
, &n_visuals
);
3915 fatal ("Can't get proper X visual info");
3917 dpyinfo
->n_planes
= vinfo
->depth
;
3918 XFree ((char *) vinfo
);
3923 /* Return the X display structure for the display named NAME.
3924 Open a new connection if necessary. */
3926 struct x_display_info
*
3927 x_display_info_for_name (name
)
3931 struct x_display_info
*dpyinfo
;
3933 CHECK_STRING (name
);
3935 if (! EQ (Vwindow_system
, intern ("x")))
3936 error ("Not using X Windows");
3938 for (dpyinfo
= x_display_list
, names
= x_display_name_list
;
3940 dpyinfo
= dpyinfo
->next
, names
= XCDR (names
))
3943 tem
= Fstring_equal (XCAR (XCAR (names
)), name
);
3948 /* Use this general default value to start with. */
3949 Vx_resource_name
= Vinvocation_name
;
3951 validate_x_resource_name ();
3953 dpyinfo
= x_term_init (name
, (char *)0,
3954 (char *) SDATA (Vx_resource_name
));
3957 error ("Cannot connect to X server %s", SDATA (name
));
3960 XSETFASTINT (Vwindow_system_version
, 11);
3966 DEFUN ("x-open-connection", Fx_open_connection
, Sx_open_connection
,
3968 doc
: /* Open a connection to an X server.
3969 DISPLAY is the name of the display to connect to.
3970 Optional second arg XRM-STRING is a string of resources in xrdb format.
3971 If the optional third arg MUST-SUCCEED is non-nil,
3972 terminate Emacs if we can't open the connection. */)
3973 (display
, xrm_string
, must_succeed
)
3974 Lisp_Object display
, xrm_string
, must_succeed
;
3976 unsigned char *xrm_option
;
3977 struct x_display_info
*dpyinfo
;
3979 CHECK_STRING (display
);
3980 if (! NILP (xrm_string
))
3981 CHECK_STRING (xrm_string
);
3983 if (! EQ (Vwindow_system
, intern ("x")))
3984 error ("Not using X Windows");
3986 if (! NILP (xrm_string
))
3987 xrm_option
= (unsigned char *) SDATA (xrm_string
);
3989 xrm_option
= (unsigned char *) 0;
3991 validate_x_resource_name ();
3993 /* This is what opens the connection and sets x_current_display.
3994 This also initializes many symbols, such as those used for input. */
3995 dpyinfo
= x_term_init (display
, xrm_option
,
3996 (char *) SDATA (Vx_resource_name
));
4000 if (!NILP (must_succeed
))
4001 fatal ("Cannot connect to X server %s.\n\
4002 Check the DISPLAY environment variable or use `-d'.\n\
4003 Also use the `xauth' program to verify that you have the proper\n\
4004 authorization information needed to connect the X server.\n\
4005 An insecure way to solve the problem may be to use `xhost'.\n",
4008 error ("Cannot connect to X server %s", SDATA (display
));
4013 XSETFASTINT (Vwindow_system_version
, 11);
4017 DEFUN ("x-close-connection", Fx_close_connection
,
4018 Sx_close_connection
, 1, 1, 0,
4019 doc
: /* Close the connection to DISPLAY's X server.
4020 For DISPLAY, specify either a frame or a display name (a string).
4021 If DISPLAY is nil, that stands for the selected frame's display. */)
4023 Lisp_Object display
;
4025 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
4028 if (dpyinfo
->reference_count
> 0)
4029 error ("Display still has frames on it");
4032 /* Free the fonts in the font table. */
4033 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
4034 if (dpyinfo
->font_table
[i
].name
)
4036 if (dpyinfo
->font_table
[i
].name
!= dpyinfo
->font_table
[i
].full_name
)
4037 xfree (dpyinfo
->font_table
[i
].full_name
);
4038 xfree (dpyinfo
->font_table
[i
].name
);
4039 XFreeFont (dpyinfo
->display
, dpyinfo
->font_table
[i
].font
);
4042 x_destroy_all_bitmaps (dpyinfo
);
4043 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
4045 #ifdef USE_X_TOOLKIT
4046 XtCloseDisplay (dpyinfo
->display
);
4048 XCloseDisplay (dpyinfo
->display
);
4051 x_delete_display (dpyinfo
);
4057 DEFUN ("x-display-list", Fx_display_list
, Sx_display_list
, 0, 0, 0,
4058 doc
: /* Return the list of display names that Emacs has connections to. */)
4061 Lisp_Object tail
, result
;
4064 for (tail
= x_display_name_list
; ! NILP (tail
); tail
= XCDR (tail
))
4065 result
= Fcons (XCAR (XCAR (tail
)), result
);
4070 DEFUN ("x-synchronize", Fx_synchronize
, Sx_synchronize
, 1, 2, 0,
4071 doc
: /* If ON is non-nil, report X errors as soon as the erring request is made.
4072 If ON is nil, allow buffering of requests.
4073 Turning on synchronization prohibits the Xlib routines from buffering
4074 requests and seriously degrades performance, but makes debugging much
4076 The optional second argument DISPLAY specifies which display to act on.
4077 DISPLAY should be either a frame or a display name (a string).
4078 If DISPLAY is omitted or nil, that stands for the selected frame's display. */)
4080 Lisp_Object display
, on
;
4082 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
4084 XSynchronize (dpyinfo
->display
, !EQ (on
, Qnil
));
4089 /* Wait for responses to all X commands issued so far for frame F. */
4096 XSync (FRAME_X_DISPLAY (f
), False
);
4101 /***********************************************************************
4103 ***********************************************************************/
4105 /* Value is the number of elements of vector VECTOR. */
4107 #define DIM(VECTOR) (sizeof (VECTOR) / sizeof *(VECTOR))
4109 /* List of supported image types. Use define_image_type to add new
4110 types. Use lookup_image_type to find a type for a given symbol. */
4112 static struct image_type
*image_types
;
4114 /* The symbol `image' which is the car of the lists used to represent
4117 extern Lisp_Object Qimage
;
4119 /* The symbol `xbm' which is used as the type symbol for XBM images. */
4125 extern Lisp_Object QCwidth
, QCheight
, QCforeground
, QCbackground
, QCfile
;
4126 extern Lisp_Object QCdata
, QCtype
;
4127 Lisp_Object QCascent
, QCmargin
, QCrelief
;
4128 Lisp_Object QCconversion
, QCcolor_symbols
, QCheuristic_mask
;
4129 Lisp_Object QCindex
, QCmatrix
, QCcolor_adjustment
, QCmask
;
4131 /* Other symbols. */
4133 Lisp_Object Qlaplace
, Qemboss
, Qedge_detection
, Qheuristic
;
4135 /* Time in seconds after which images should be removed from the cache
4136 if not displayed. */
4138 Lisp_Object Vimage_cache_eviction_delay
;
4140 /* Function prototypes. */
4142 static void define_image_type
P_ ((struct image_type
*type
));
4143 static struct image_type
*lookup_image_type
P_ ((Lisp_Object symbol
));
4144 static void image_error
P_ ((char *format
, Lisp_Object
, Lisp_Object
));
4145 static void x_laplace
P_ ((struct frame
*, struct image
*));
4146 static void x_emboss
P_ ((struct frame
*, struct image
*));
4147 static int x_build_heuristic_mask
P_ ((struct frame
*, struct image
*,
4151 /* Define a new image type from TYPE. This adds a copy of TYPE to
4152 image_types and adds the symbol *TYPE->type to Vimage_types. */
4155 define_image_type (type
)
4156 struct image_type
*type
;
4158 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
4159 The initialized data segment is read-only. */
4160 struct image_type
*p
= (struct image_type
*) xmalloc (sizeof *p
);
4161 bcopy (type
, p
, sizeof *p
);
4162 p
->next
= image_types
;
4164 Vimage_types
= Fcons (*p
->type
, Vimage_types
);
4168 /* Look up image type SYMBOL, and return a pointer to its image_type
4169 structure. Value is null if SYMBOL is not a known image type. */
4171 static INLINE
struct image_type
*
4172 lookup_image_type (symbol
)
4175 struct image_type
*type
;
4177 for (type
= image_types
; type
; type
= type
->next
)
4178 if (EQ (symbol
, *type
->type
))
4185 /* Value is non-zero if OBJECT is a valid Lisp image specification. A
4186 valid image specification is a list whose car is the symbol
4187 `image', and whose rest is a property list. The property list must
4188 contain a value for key `:type'. That value must be the name of a
4189 supported image type. The rest of the property list depends on the
4193 valid_image_p (object
)
4198 if (CONSP (object
) && EQ (XCAR (object
), Qimage
))
4202 for (tem
= XCDR (object
); CONSP (tem
); tem
= XCDR (tem
))
4203 if (EQ (XCAR (tem
), QCtype
))
4206 if (CONSP (tem
) && SYMBOLP (XCAR (tem
)))
4208 struct image_type
*type
;
4209 type
= lookup_image_type (XCAR (tem
));
4211 valid_p
= type
->valid_p (object
);
4222 /* Log error message with format string FORMAT and argument ARG.
4223 Signaling an error, e.g. when an image cannot be loaded, is not a
4224 good idea because this would interrupt redisplay, and the error
4225 message display would lead to another redisplay. This function
4226 therefore simply displays a message. */
4229 image_error (format
, arg1
, arg2
)
4231 Lisp_Object arg1
, arg2
;
4233 add_to_log (format
, arg1
, arg2
);
4238 /***********************************************************************
4239 Image specifications
4240 ***********************************************************************/
4242 enum image_value_type
4244 IMAGE_DONT_CHECK_VALUE_TYPE
,
4246 IMAGE_STRING_OR_NIL_VALUE
,
4248 IMAGE_POSITIVE_INTEGER_VALUE
,
4249 IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
,
4250 IMAGE_NON_NEGATIVE_INTEGER_VALUE
,
4252 IMAGE_INTEGER_VALUE
,
4253 IMAGE_FUNCTION_VALUE
,
4258 /* Structure used when parsing image specifications. */
4260 struct image_keyword
4262 /* Name of keyword. */
4265 /* The type of value allowed. */
4266 enum image_value_type type
;
4268 /* Non-zero means key must be present. */
4271 /* Used to recognize duplicate keywords in a property list. */
4274 /* The value that was found. */
4279 static int parse_image_spec
P_ ((Lisp_Object
, struct image_keyword
*,
4281 static Lisp_Object image_spec_value
P_ ((Lisp_Object
, Lisp_Object
, int *));
4284 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
4285 has the format (image KEYWORD VALUE ...). One of the keyword/
4286 value pairs must be `:type TYPE'. KEYWORDS is a vector of
4287 image_keywords structures of size NKEYWORDS describing other
4288 allowed keyword/value pairs. Value is non-zero if SPEC is valid. */
4291 parse_image_spec (spec
, keywords
, nkeywords
, type
)
4293 struct image_keyword
*keywords
;
4300 if (!CONSP (spec
) || !EQ (XCAR (spec
), Qimage
))
4303 plist
= XCDR (spec
);
4304 while (CONSP (plist
))
4306 Lisp_Object key
, value
;
4308 /* First element of a pair must be a symbol. */
4310 plist
= XCDR (plist
);
4314 /* There must follow a value. */
4317 value
= XCAR (plist
);
4318 plist
= XCDR (plist
);
4320 /* Find key in KEYWORDS. Error if not found. */
4321 for (i
= 0; i
< nkeywords
; ++i
)
4322 if (strcmp (keywords
[i
].name
, SDATA (SYMBOL_NAME (key
))) == 0)
4328 /* Record that we recognized the keyword. If a keywords
4329 was found more than once, it's an error. */
4330 keywords
[i
].value
= value
;
4331 ++keywords
[i
].count
;
4333 if (keywords
[i
].count
> 1)
4336 /* Check type of value against allowed type. */
4337 switch (keywords
[i
].type
)
4339 case IMAGE_STRING_VALUE
:
4340 if (!STRINGP (value
))
4344 case IMAGE_STRING_OR_NIL_VALUE
:
4345 if (!STRINGP (value
) && !NILP (value
))
4349 case IMAGE_SYMBOL_VALUE
:
4350 if (!SYMBOLP (value
))
4354 case IMAGE_POSITIVE_INTEGER_VALUE
:
4355 if (!INTEGERP (value
) || XINT (value
) <= 0)
4359 case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
:
4360 if (INTEGERP (value
) && XINT (value
) >= 0)
4363 && INTEGERP (XCAR (value
)) && INTEGERP (XCDR (value
))
4364 && XINT (XCAR (value
)) >= 0 && XINT (XCDR (value
)) >= 0)
4368 case IMAGE_ASCENT_VALUE
:
4369 if (SYMBOLP (value
) && EQ (value
, Qcenter
))
4371 else if (INTEGERP (value
)
4372 && XINT (value
) >= 0
4373 && XINT (value
) <= 100)
4377 case IMAGE_NON_NEGATIVE_INTEGER_VALUE
:
4378 if (!INTEGERP (value
) || XINT (value
) < 0)
4382 case IMAGE_DONT_CHECK_VALUE_TYPE
:
4385 case IMAGE_FUNCTION_VALUE
:
4386 value
= indirect_function (value
);
4388 || COMPILEDP (value
)
4389 || (CONSP (value
) && EQ (XCAR (value
), Qlambda
)))
4393 case IMAGE_NUMBER_VALUE
:
4394 if (!INTEGERP (value
) && !FLOATP (value
))
4398 case IMAGE_INTEGER_VALUE
:
4399 if (!INTEGERP (value
))
4403 case IMAGE_BOOL_VALUE
:
4404 if (!NILP (value
) && !EQ (value
, Qt
))
4413 if (EQ (key
, QCtype
) && !EQ (type
, value
))
4417 /* Check that all mandatory fields are present. */
4418 for (i
= 0; i
< nkeywords
; ++i
)
4419 if (keywords
[i
].mandatory_p
&& keywords
[i
].count
== 0)
4422 return NILP (plist
);
4426 /* Return the value of KEY in image specification SPEC. Value is nil
4427 if KEY is not present in SPEC. if FOUND is not null, set *FOUND
4428 to 1 if KEY was found in SPEC, set it to 0 otherwise. */
4431 image_spec_value (spec
, key
, found
)
4432 Lisp_Object spec
, key
;
4437 xassert (valid_image_p (spec
));
4439 for (tail
= XCDR (spec
);
4440 CONSP (tail
) && CONSP (XCDR (tail
));
4441 tail
= XCDR (XCDR (tail
)))
4443 if (EQ (XCAR (tail
), key
))
4447 return XCAR (XCDR (tail
));
4457 DEFUN ("image-size", Fimage_size
, Simage_size
, 1, 3, 0,
4458 doc
: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
4459 PIXELS non-nil means return the size in pixels, otherwise return the
4460 size in canonical character units.
4461 FRAME is the frame on which the image will be displayed. FRAME nil
4462 or omitted means use the selected frame. */)
4463 (spec
, pixels
, frame
)
4464 Lisp_Object spec
, pixels
, frame
;
4469 if (valid_image_p (spec
))
4471 struct frame
*f
= check_x_frame (frame
);
4472 int id
= lookup_image (f
, spec
);
4473 struct image
*img
= IMAGE_FROM_ID (f
, id
);
4474 int width
= img
->width
+ 2 * img
->hmargin
;
4475 int height
= img
->height
+ 2 * img
->vmargin
;
4478 size
= Fcons (make_float ((double) width
/ CANON_X_UNIT (f
)),
4479 make_float ((double) height
/ CANON_Y_UNIT (f
)));
4481 size
= Fcons (make_number (width
), make_number (height
));
4484 error ("Invalid image specification");
4490 DEFUN ("image-mask-p", Fimage_mask_p
, Simage_mask_p
, 1, 2, 0,
4491 doc
: /* Return t if image SPEC has a mask bitmap.
4492 FRAME is the frame on which the image will be displayed. FRAME nil
4493 or omitted means use the selected frame. */)
4495 Lisp_Object spec
, frame
;
4500 if (valid_image_p (spec
))
4502 struct frame
*f
= check_x_frame (frame
);
4503 int id
= lookup_image (f
, spec
);
4504 struct image
*img
= IMAGE_FROM_ID (f
, id
);
4509 error ("Invalid image specification");
4516 /***********************************************************************
4517 Image type independent image structures
4518 ***********************************************************************/
4520 static struct image
*make_image
P_ ((Lisp_Object spec
, unsigned hash
));
4521 static void free_image
P_ ((struct frame
*f
, struct image
*img
));
4524 /* Allocate and return a new image structure for image specification
4525 SPEC. SPEC has a hash value of HASH. */
4527 static struct image
*
4528 make_image (spec
, hash
)
4532 struct image
*img
= (struct image
*) xmalloc (sizeof *img
);
4534 xassert (valid_image_p (spec
));
4535 bzero (img
, sizeof *img
);
4536 img
->type
= lookup_image_type (image_spec_value (spec
, QCtype
, NULL
));
4537 xassert (img
->type
!= NULL
);
4539 img
->data
.lisp_val
= Qnil
;
4540 img
->ascent
= DEFAULT_IMAGE_ASCENT
;
4546 /* Free image IMG which was used on frame F, including its resources. */
4555 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
4557 /* Remove IMG from the hash table of its cache. */
4559 img
->prev
->next
= img
->next
;
4561 c
->buckets
[img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
] = img
->next
;
4564 img
->next
->prev
= img
->prev
;
4566 c
->images
[img
->id
] = NULL
;
4568 /* Free resources, then free IMG. */
4569 img
->type
->free (f
, img
);
4575 /* Prepare image IMG for display on frame F. Must be called before
4576 drawing an image. */
4579 prepare_image_for_display (f
, img
)
4585 /* We're about to display IMG, so set its timestamp to `now'. */
4587 img
->timestamp
= EMACS_SECS (t
);
4589 /* If IMG doesn't have a pixmap yet, load it now, using the image
4590 type dependent loader function. */
4591 if (img
->pixmap
== None
&& !img
->load_failed_p
)
4592 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
4596 /* Value is the number of pixels for the ascent of image IMG when
4597 drawn in face FACE. */
4600 image_ascent (img
, face
)
4604 int height
= img
->height
+ img
->vmargin
;
4607 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
4610 /* This expression is arranged so that if the image can't be
4611 exactly centered, it will be moved slightly up. This is
4612 because a typical font is `top-heavy' (due to the presence
4613 uppercase letters), so the image placement should err towards
4614 being top-heavy too. It also just generally looks better. */
4615 ascent
= (height
+ face
->font
->ascent
- face
->font
->descent
+ 1) / 2;
4617 ascent
= height
/ 2;
4620 ascent
= height
* img
->ascent
/ 100.0;
4626 /* Image background colors. */
4628 static unsigned long
4629 four_corners_best (ximg
, width
, height
)
4631 unsigned long width
, height
;
4633 unsigned long corners
[4], best
;
4636 /* Get the colors at the corners of ximg. */
4637 corners
[0] = XGetPixel (ximg
, 0, 0);
4638 corners
[1] = XGetPixel (ximg
, width
- 1, 0);
4639 corners
[2] = XGetPixel (ximg
, width
- 1, height
- 1);
4640 corners
[3] = XGetPixel (ximg
, 0, height
- 1);
4642 /* Choose the most frequently found color as background. */
4643 for (i
= best_count
= 0; i
< 4; ++i
)
4647 for (j
= n
= 0; j
< 4; ++j
)
4648 if (corners
[i
] == corners
[j
])
4652 best
= corners
[i
], best_count
= n
;
4658 /* Return the `background' field of IMG. If IMG doesn't have one yet,
4659 it is guessed heuristically. If non-zero, XIMG is an existing XImage
4660 object to use for the heuristic. */
4663 image_background (img
, f
, ximg
)
4668 if (! img
->background_valid
)
4669 /* IMG doesn't have a background yet, try to guess a reasonable value. */
4671 int free_ximg
= !ximg
;
4674 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4675 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4677 img
->background
= four_corners_best (ximg
, img
->width
, img
->height
);
4680 XDestroyImage (ximg
);
4682 img
->background_valid
= 1;
4685 return img
->background
;
4688 /* Return the `background_transparent' field of IMG. If IMG doesn't
4689 have one yet, it is guessed heuristically. If non-zero, MASK is an
4690 existing XImage object to use for the heuristic. */
4693 image_background_transparent (img
, f
, mask
)
4698 if (! img
->background_transparent_valid
)
4699 /* IMG doesn't have a background yet, try to guess a reasonable value. */
4703 int free_mask
= !mask
;
4706 mask
= XGetImage (FRAME_X_DISPLAY (f
), img
->mask
,
4707 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4709 img
->background_transparent
4710 = !four_corners_best (mask
, img
->width
, img
->height
);
4713 XDestroyImage (mask
);
4716 img
->background_transparent
= 0;
4718 img
->background_transparent_valid
= 1;
4721 return img
->background_transparent
;
4725 /***********************************************************************
4726 Helper functions for X image types
4727 ***********************************************************************/
4729 static void x_clear_image_1
P_ ((struct frame
*, struct image
*, int,
4731 static void x_clear_image
P_ ((struct frame
*f
, struct image
*img
));
4732 static unsigned long x_alloc_image_color
P_ ((struct frame
*f
,
4734 Lisp_Object color_name
,
4735 unsigned long dflt
));
4738 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
4739 free the pixmap if any. MASK_P non-zero means clear the mask
4740 pixmap if any. COLORS_P non-zero means free colors allocated for
4741 the image, if any. */
4744 x_clear_image_1 (f
, img
, pixmap_p
, mask_p
, colors_p
)
4747 int pixmap_p
, mask_p
, colors_p
;
4749 if (pixmap_p
&& img
->pixmap
)
4751 XFreePixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
4753 img
->background_valid
= 0;
4756 if (mask_p
&& img
->mask
)
4758 XFreePixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4760 img
->background_transparent_valid
= 0;
4763 if (colors_p
&& img
->ncolors
)
4765 x_free_colors (f
, img
->colors
, img
->ncolors
);
4766 xfree (img
->colors
);
4772 /* Free X resources of image IMG which is used on frame F. */
4775 x_clear_image (f
, img
)
4780 x_clear_image_1 (f
, img
, 1, 1, 1);
4785 /* Allocate color COLOR_NAME for image IMG on frame F. If color
4786 cannot be allocated, use DFLT. Add a newly allocated color to
4787 IMG->colors, so that it can be freed again. Value is the pixel
4790 static unsigned long
4791 x_alloc_image_color (f
, img
, color_name
, dflt
)
4794 Lisp_Object color_name
;
4798 unsigned long result
;
4800 xassert (STRINGP (color_name
));
4802 if (x_defined_color (f
, SDATA (color_name
), &color
, 1))
4804 /* This isn't called frequently so we get away with simply
4805 reallocating the color vector to the needed size, here. */
4808 (unsigned long *) xrealloc (img
->colors
,
4809 img
->ncolors
* sizeof *img
->colors
);
4810 img
->colors
[img
->ncolors
- 1] = color
.pixel
;
4811 result
= color
.pixel
;
4821 /***********************************************************************
4823 ***********************************************************************/
4825 static void cache_image
P_ ((struct frame
*f
, struct image
*img
));
4826 static void postprocess_image
P_ ((struct frame
*, struct image
*));
4829 /* Return a new, initialized image cache that is allocated from the
4830 heap. Call free_image_cache to free an image cache. */
4832 struct image_cache
*
4835 struct image_cache
*c
= (struct image_cache
*) xmalloc (sizeof *c
);
4838 bzero (c
, sizeof *c
);
4840 c
->images
= (struct image
**) xmalloc (c
->size
* sizeof *c
->images
);
4841 size
= IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
;
4842 c
->buckets
= (struct image
**) xmalloc (size
);
4843 bzero (c
->buckets
, size
);
4848 /* Free image cache of frame F. Be aware that X frames share images
4852 free_image_cache (f
)
4855 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
4860 /* Cache should not be referenced by any frame when freed. */
4861 xassert (c
->refcount
== 0);
4863 for (i
= 0; i
< c
->used
; ++i
)
4864 free_image (f
, c
->images
[i
]);
4868 FRAME_X_IMAGE_CACHE (f
) = NULL
;
4873 /* Clear image cache of frame F. FORCE_P non-zero means free all
4874 images. FORCE_P zero means clear only images that haven't been
4875 displayed for some time. Should be called from time to time to
4876 reduce the number of loaded images. If image-eviction-seconds is
4877 non-nil, this frees images in the cache which weren't displayed for
4878 at least that many seconds. */
4881 clear_image_cache (f
, force_p
)
4885 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
4887 if (c
&& INTEGERP (Vimage_cache_eviction_delay
))
4894 old
= EMACS_SECS (t
) - XFASTINT (Vimage_cache_eviction_delay
);
4896 /* Block input so that we won't be interrupted by a SIGIO
4897 while being in an inconsistent state. */
4900 for (i
= nfreed
= 0; i
< c
->used
; ++i
)
4902 struct image
*img
= c
->images
[i
];
4904 && (force_p
|| img
->timestamp
< old
))
4906 free_image (f
, img
);
4911 /* We may be clearing the image cache because, for example,
4912 Emacs was iconified for a longer period of time. In that
4913 case, current matrices may still contain references to
4914 images freed above. So, clear these matrices. */
4917 Lisp_Object tail
, frame
;
4919 FOR_EACH_FRAME (tail
, frame
)
4921 struct frame
*f
= XFRAME (frame
);
4923 && FRAME_X_IMAGE_CACHE (f
) == c
)
4924 clear_current_matrices (f
);
4927 ++windows_or_buffers_changed
;
4935 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
4937 doc
: /* Clear the image cache of FRAME.
4938 FRAME nil or omitted means use the selected frame.
4939 FRAME t means clear the image caches of all frames. */)
4947 FOR_EACH_FRAME (tail
, frame
)
4948 if (FRAME_X_P (XFRAME (frame
)))
4949 clear_image_cache (XFRAME (frame
), 1);
4952 clear_image_cache (check_x_frame (frame
), 1);
4958 /* Compute masks and transform image IMG on frame F, as specified
4959 by the image's specification, */
4962 postprocess_image (f
, img
)
4966 /* Manipulation of the image's mask. */
4969 Lisp_Object conversion
, spec
;
4974 /* `:heuristic-mask t'
4976 means build a mask heuristically.
4977 `:heuristic-mask (R G B)'
4978 `:mask (heuristic (R G B))'
4979 means build a mask from color (R G B) in the
4982 means remove a mask, if any. */
4984 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
4986 x_build_heuristic_mask (f
, img
, mask
);
4991 mask
= image_spec_value (spec
, QCmask
, &found_p
);
4993 if (EQ (mask
, Qheuristic
))
4994 x_build_heuristic_mask (f
, img
, Qt
);
4995 else if (CONSP (mask
)
4996 && EQ (XCAR (mask
), Qheuristic
))
4998 if (CONSP (XCDR (mask
)))
4999 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
5001 x_build_heuristic_mask (f
, img
, XCDR (mask
));
5003 else if (NILP (mask
) && found_p
&& img
->mask
)
5005 XFreePixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5011 /* Should we apply an image transformation algorithm? */
5012 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
5013 if (EQ (conversion
, Qdisabled
))
5014 x_disable_image (f
, img
);
5015 else if (EQ (conversion
, Qlaplace
))
5017 else if (EQ (conversion
, Qemboss
))
5019 else if (CONSP (conversion
)
5020 && EQ (XCAR (conversion
), Qedge_detection
))
5023 tem
= XCDR (conversion
);
5025 x_edge_detection (f
, img
,
5026 Fplist_get (tem
, QCmatrix
),
5027 Fplist_get (tem
, QCcolor_adjustment
));
5033 /* Return the id of image with Lisp specification SPEC on frame F.
5034 SPEC must be a valid Lisp image specification (see valid_image_p). */
5037 lookup_image (f
, spec
)
5041 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5045 struct gcpro gcpro1
;
5048 /* F must be a window-system frame, and SPEC must be a valid image
5050 xassert (FRAME_WINDOW_P (f
));
5051 xassert (valid_image_p (spec
));
5055 /* Look up SPEC in the hash table of the image cache. */
5056 hash
= sxhash (spec
, 0);
5057 i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
5059 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
5060 if (img
->hash
== hash
&& !NILP (Fequal (img
->spec
, spec
)))
5063 /* If not found, create a new image and cache it. */
5066 extern Lisp_Object Qpostscript
;
5069 img
= make_image (spec
, hash
);
5070 cache_image (f
, img
);
5071 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
5073 /* If we can't load the image, and we don't have a width and
5074 height, use some arbitrary width and height so that we can
5075 draw a rectangle for it. */
5076 if (img
->load_failed_p
)
5080 value
= image_spec_value (spec
, QCwidth
, NULL
);
5081 img
->width
= (INTEGERP (value
)
5082 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
5083 value
= image_spec_value (spec
, QCheight
, NULL
);
5084 img
->height
= (INTEGERP (value
)
5085 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
5089 /* Handle image type independent image attributes
5090 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
5091 `:background COLOR'. */
5092 Lisp_Object ascent
, margin
, relief
, bg
;
5094 ascent
= image_spec_value (spec
, QCascent
, NULL
);
5095 if (INTEGERP (ascent
))
5096 img
->ascent
= XFASTINT (ascent
);
5097 else if (EQ (ascent
, Qcenter
))
5098 img
->ascent
= CENTERED_IMAGE_ASCENT
;
5100 margin
= image_spec_value (spec
, QCmargin
, NULL
);
5101 if (INTEGERP (margin
) && XINT (margin
) >= 0)
5102 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
5103 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
5104 && INTEGERP (XCDR (margin
)))
5106 if (XINT (XCAR (margin
)) > 0)
5107 img
->hmargin
= XFASTINT (XCAR (margin
));
5108 if (XINT (XCDR (margin
)) > 0)
5109 img
->vmargin
= XFASTINT (XCDR (margin
));
5112 relief
= image_spec_value (spec
, QCrelief
, NULL
);
5113 if (INTEGERP (relief
))
5115 img
->relief
= XINT (relief
);
5116 img
->hmargin
+= abs (img
->relief
);
5117 img
->vmargin
+= abs (img
->relief
);
5120 if (! img
->background_valid
)
5122 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
5126 = x_alloc_image_color (f
, img
, bg
,
5127 FRAME_BACKGROUND_PIXEL (f
));
5128 img
->background_valid
= 1;
5132 /* Do image transformations and compute masks, unless we
5133 don't have the image yet. */
5134 if (!EQ (*img
->type
->type
, Qpostscript
))
5135 postprocess_image (f
, img
);
5139 xassert (!interrupt_input_blocked
);
5142 /* We're using IMG, so set its timestamp to `now'. */
5143 EMACS_GET_TIME (now
);
5144 img
->timestamp
= EMACS_SECS (now
);
5148 /* Value is the image id. */
5153 /* Cache image IMG in the image cache of frame F. */
5156 cache_image (f
, img
)
5160 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5163 /* Find a free slot in c->images. */
5164 for (i
= 0; i
< c
->used
; ++i
)
5165 if (c
->images
[i
] == NULL
)
5168 /* If no free slot found, maybe enlarge c->images. */
5169 if (i
== c
->used
&& c
->used
== c
->size
)
5172 c
->images
= (struct image
**) xrealloc (c
->images
,
5173 c
->size
* sizeof *c
->images
);
5176 /* Add IMG to c->images, and assign IMG an id. */
5182 /* Add IMG to the cache's hash table. */
5183 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
5184 img
->next
= c
->buckets
[i
];
5186 img
->next
->prev
= img
;
5188 c
->buckets
[i
] = img
;
5192 /* Call FN on every image in the image cache of frame F. Used to mark
5193 Lisp Objects in the image cache. */
5196 forall_images_in_image_cache (f
, fn
)
5198 void (*fn
) P_ ((struct image
*img
));
5200 if (FRAME_LIVE_P (f
) && FRAME_X_P (f
))
5202 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5206 for (i
= 0; i
< c
->used
; ++i
)
5215 /***********************************************************************
5217 ***********************************************************************/
5219 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
5220 XImage
**, Pixmap
*));
5221 static void x_destroy_x_image
P_ ((XImage
*));
5222 static void x_put_x_image
P_ ((struct frame
*, XImage
*, Pixmap
, int, int));
5225 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
5226 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
5227 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
5228 via xmalloc. Print error messages via image_error if an error
5229 occurs. Value is non-zero if successful. */
5232 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
5234 int width
, height
, depth
;
5238 Display
*display
= FRAME_X_DISPLAY (f
);
5239 Screen
*screen
= FRAME_X_SCREEN (f
);
5240 Window window
= FRAME_X_WINDOW (f
);
5242 xassert (interrupt_input_blocked
);
5245 depth
= DefaultDepthOfScreen (screen
);
5246 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
5247 depth
, ZPixmap
, 0, NULL
, width
, height
,
5248 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
5251 image_error ("Unable to allocate X image", Qnil
, Qnil
);
5255 /* Allocate image raster. */
5256 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
5258 /* Allocate a pixmap of the same size. */
5259 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
5260 if (*pixmap
== None
)
5262 x_destroy_x_image (*ximg
);
5264 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
5272 /* Destroy XImage XIMG. Free XIMG->data. */
5275 x_destroy_x_image (ximg
)
5278 xassert (interrupt_input_blocked
);
5283 XDestroyImage (ximg
);
5288 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
5289 are width and height of both the image and pixmap. */
5292 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
5300 xassert (interrupt_input_blocked
);
5301 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
5302 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
5303 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
5308 /***********************************************************************
5310 ***********************************************************************/
5312 static Lisp_Object x_find_image_file
P_ ((Lisp_Object
));
5313 static char *slurp_file
P_ ((char *, int *));
5316 /* Find image file FILE. Look in data-directory, then
5317 x-bitmap-file-path. Value is the full name of the file found, or
5318 nil if not found. */
5321 x_find_image_file (file
)
5324 Lisp_Object file_found
, search_path
;
5325 struct gcpro gcpro1
, gcpro2
;
5329 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
5330 GCPRO2 (file_found
, search_path
);
5332 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
5333 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
5345 /* Read FILE into memory. Value is a pointer to a buffer allocated
5346 with xmalloc holding FILE's contents. Value is null if an error
5347 occurred. *SIZE is set to the size of the file. */
5350 slurp_file (file
, size
)
5358 if (stat (file
, &st
) == 0
5359 && (fp
= fopen (file
, "r")) != NULL
5360 && (buf
= (char *) xmalloc (st
.st_size
),
5361 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5382 /***********************************************************************
5384 ***********************************************************************/
5386 static int xbm_scan
P_ ((char **, char *, char *, int *));
5387 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
5388 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
5390 static int xbm_image_p
P_ ((Lisp_Object object
));
5391 static int xbm_read_bitmap_data
P_ ((char *, char *, int *, int *,
5393 static int xbm_file_p
P_ ((Lisp_Object
));
5396 /* Indices of image specification fields in xbm_format, below. */
5398 enum xbm_keyword_index
5416 /* Vector of image_keyword structures describing the format
5417 of valid XBM image specifications. */
5419 static struct image_keyword xbm_format
[XBM_LAST
] =
5421 {":type", IMAGE_SYMBOL_VALUE
, 1},
5422 {":file", IMAGE_STRING_VALUE
, 0},
5423 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
5424 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
5425 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5426 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5427 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
5428 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5429 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5430 {":relief", IMAGE_INTEGER_VALUE
, 0},
5431 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5432 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5433 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
5436 /* Structure describing the image type XBM. */
5438 static struct image_type xbm_type
=
5447 /* Tokens returned from xbm_scan. */
5456 /* Return non-zero if OBJECT is a valid XBM-type image specification.
5457 A valid specification is a list starting with the symbol `image'
5458 The rest of the list is a property list which must contain an
5461 If the specification specifies a file to load, it must contain
5462 an entry `:file FILENAME' where FILENAME is a string.
5464 If the specification is for a bitmap loaded from memory it must
5465 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
5466 WIDTH and HEIGHT are integers > 0. DATA may be:
5468 1. a string large enough to hold the bitmap data, i.e. it must
5469 have a size >= (WIDTH + 7) / 8 * HEIGHT
5471 2. a bool-vector of size >= WIDTH * HEIGHT
5473 3. a vector of strings or bool-vectors, one for each line of the
5476 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
5477 may not be specified in this case because they are defined in the
5480 Both the file and data forms may contain the additional entries
5481 `:background COLOR' and `:foreground COLOR'. If not present,
5482 foreground and background of the frame on which the image is
5483 displayed is used. */
5486 xbm_image_p (object
)
5489 struct image_keyword kw
[XBM_LAST
];
5491 bcopy (xbm_format
, kw
, sizeof kw
);
5492 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
5495 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
5497 if (kw
[XBM_FILE
].count
)
5499 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
5502 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
5504 /* In-memory XBM file. */
5505 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
5513 /* Entries for `:width', `:height' and `:data' must be present. */
5514 if (!kw
[XBM_WIDTH
].count
5515 || !kw
[XBM_HEIGHT
].count
5516 || !kw
[XBM_DATA
].count
)
5519 data
= kw
[XBM_DATA
].value
;
5520 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
5521 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
5523 /* Check type of data, and width and height against contents of
5529 /* Number of elements of the vector must be >= height. */
5530 if (XVECTOR (data
)->size
< height
)
5533 /* Each string or bool-vector in data must be large enough
5534 for one line of the image. */
5535 for (i
= 0; i
< height
; ++i
)
5537 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
5542 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
5545 else if (BOOL_VECTOR_P (elt
))
5547 if (XBOOL_VECTOR (elt
)->size
< width
)
5554 else if (STRINGP (data
))
5557 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
5560 else if (BOOL_VECTOR_P (data
))
5562 if (XBOOL_VECTOR (data
)->size
< width
* height
)
5573 /* Scan a bitmap file. FP is the stream to read from. Value is
5574 either an enumerator from enum xbm_token, or a character for a
5575 single-character token, or 0 at end of file. If scanning an
5576 identifier, store the lexeme of the identifier in SVAL. If
5577 scanning a number, store its value in *IVAL. */
5580 xbm_scan (s
, end
, sval
, ival
)
5589 /* Skip white space. */
5590 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5595 else if (isdigit (c
))
5597 int value
= 0, digit
;
5599 if (c
== '0' && *s
< end
)
5602 if (c
== 'x' || c
== 'X')
5609 else if (c
>= 'a' && c
<= 'f')
5610 digit
= c
- 'a' + 10;
5611 else if (c
>= 'A' && c
<= 'F')
5612 digit
= c
- 'A' + 10;
5615 value
= 16 * value
+ digit
;
5618 else if (isdigit (c
))
5622 && (c
= *(*s
)++, isdigit (c
)))
5623 value
= 8 * value
+ c
- '0';
5630 && (c
= *(*s
)++, isdigit (c
)))
5631 value
= 10 * value
+ c
- '0';
5639 else if (isalpha (c
) || c
== '_')
5643 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
5650 else if (c
== '/' && **s
== '*')
5652 /* C-style comment. */
5654 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
5667 /* Replacement for XReadBitmapFileData which isn't available under old
5668 X versions. CONTENTS is a pointer to a buffer to parse; END is the
5669 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
5670 the image. Return in *DATA the bitmap data allocated with xmalloc.
5671 Value is non-zero if successful. DATA null means just test if
5672 CONTENTS looks like an in-memory XBM file. */
5675 xbm_read_bitmap_data (contents
, end
, width
, height
, data
)
5676 char *contents
, *end
;
5677 int *width
, *height
;
5678 unsigned char **data
;
5681 char buffer
[BUFSIZ
];
5684 int bytes_per_line
, i
, nbytes
;
5690 LA1 = xbm_scan (&s, end, buffer, &value)
5692 #define expect(TOKEN) \
5693 if (LA1 != (TOKEN)) \
5698 #define expect_ident(IDENT) \
5699 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
5704 *width
= *height
= -1;
5707 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
5709 /* Parse defines for width, height and hot-spots. */
5713 expect_ident ("define");
5714 expect (XBM_TK_IDENT
);
5716 if (LA1
== XBM_TK_NUMBER
);
5718 char *p
= strrchr (buffer
, '_');
5719 p
= p
? p
+ 1 : buffer
;
5720 if (strcmp (p
, "width") == 0)
5722 else if (strcmp (p
, "height") == 0)
5725 expect (XBM_TK_NUMBER
);
5728 if (*width
< 0 || *height
< 0)
5730 else if (data
== NULL
)
5733 /* Parse bits. Must start with `static'. */
5734 expect_ident ("static");
5735 if (LA1
== XBM_TK_IDENT
)
5737 if (strcmp (buffer
, "unsigned") == 0)
5740 expect_ident ("char");
5742 else if (strcmp (buffer
, "short") == 0)
5746 if (*width
% 16 && *width
% 16 < 9)
5749 else if (strcmp (buffer
, "char") == 0)
5757 expect (XBM_TK_IDENT
);
5763 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
5764 nbytes
= bytes_per_line
* *height
;
5765 p
= *data
= (char *) xmalloc (nbytes
);
5769 for (i
= 0; i
< nbytes
; i
+= 2)
5772 expect (XBM_TK_NUMBER
);
5775 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
5778 if (LA1
== ',' || LA1
== '}')
5786 for (i
= 0; i
< nbytes
; ++i
)
5789 expect (XBM_TK_NUMBER
);
5793 if (LA1
== ',' || LA1
== '}')
5818 /* Load XBM image IMG which will be displayed on frame F from buffer
5819 CONTENTS. END is the end of the buffer. Value is non-zero if
5823 xbm_load_image (f
, img
, contents
, end
)
5826 char *contents
, *end
;
5829 unsigned char *data
;
5832 rc
= xbm_read_bitmap_data (contents
, end
, &img
->width
, &img
->height
, &data
);
5835 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
5836 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
5837 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
5840 xassert (img
->width
> 0 && img
->height
> 0);
5842 /* Get foreground and background colors, maybe allocate colors. */
5843 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
5845 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
5846 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
5849 background
= x_alloc_image_color (f
, img
, value
, background
);
5850 img
->background
= background
;
5851 img
->background_valid
= 1;
5855 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
5858 img
->width
, img
->height
,
5859 foreground
, background
,
5863 if (img
->pixmap
== None
)
5865 x_clear_image (f
, img
);
5866 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
5872 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
5878 /* Value is non-zero if DATA looks like an in-memory XBM file. */
5885 return (STRINGP (data
)
5886 && xbm_read_bitmap_data (SDATA (data
),
5893 /* Fill image IMG which is used on frame F with pixmap data. Value is
5894 non-zero if successful. */
5902 Lisp_Object file_name
;
5904 xassert (xbm_image_p (img
->spec
));
5906 /* If IMG->spec specifies a file name, create a non-file spec from it. */
5907 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
5908 if (STRINGP (file_name
))
5913 struct gcpro gcpro1
;
5915 file
= x_find_image_file (file_name
);
5917 if (!STRINGP (file
))
5919 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
5924 contents
= slurp_file (SDATA (file
), &size
);
5925 if (contents
== NULL
)
5927 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
5932 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
5937 struct image_keyword fmt
[XBM_LAST
];
5940 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
5941 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
5944 int in_memory_file_p
= 0;
5946 /* See if data looks like an in-memory XBM file. */
5947 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5948 in_memory_file_p
= xbm_file_p (data
);
5950 /* Parse the image specification. */
5951 bcopy (xbm_format
, fmt
, sizeof fmt
);
5952 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
5955 /* Get specified width, and height. */
5956 if (!in_memory_file_p
)
5958 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
5959 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
5960 xassert (img
->width
> 0 && img
->height
> 0);
5963 /* Get foreground and background colors, maybe allocate colors. */
5964 if (fmt
[XBM_FOREGROUND
].count
5965 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
5966 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
5968 if (fmt
[XBM_BACKGROUND
].count
5969 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
5970 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
5973 if (in_memory_file_p
)
5974 success_p
= xbm_load_image (f
, img
, SDATA (data
),
5983 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
5985 p
= bits
= (char *) alloca (nbytes
* img
->height
);
5986 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
5988 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
5990 bcopy (SDATA (line
), p
, nbytes
);
5992 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
5995 else if (STRINGP (data
))
5996 bits
= SDATA (data
);
5998 bits
= XBOOL_VECTOR (data
)->data
;
6000 /* Create the pixmap. */
6001 depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
6003 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
6006 img
->width
, img
->height
,
6007 foreground
, background
,
6013 image_error ("Unable to create pixmap for XBM image `%s'",
6015 x_clear_image (f
, img
);
6025 /***********************************************************************
6027 ***********************************************************************/
6031 static int xpm_image_p
P_ ((Lisp_Object object
));
6032 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
6033 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
6035 #include "X11/xpm.h"
6037 /* The symbol `xpm' identifying XPM-format images. */
6041 /* Indices of image specification fields in xpm_format, below. */
6043 enum xpm_keyword_index
6059 /* Vector of image_keyword structures describing the format
6060 of valid XPM image specifications. */
6062 static struct image_keyword xpm_format
[XPM_LAST
] =
6064 {":type", IMAGE_SYMBOL_VALUE
, 1},
6065 {":file", IMAGE_STRING_VALUE
, 0},
6066 {":data", IMAGE_STRING_VALUE
, 0},
6067 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6068 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6069 {":relief", IMAGE_INTEGER_VALUE
, 0},
6070 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6071 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6072 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6073 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6074 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6077 /* Structure describing the image type XBM. */
6079 static struct image_type xpm_type
=
6089 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
6090 functions for allocating image colors. Our own functions handle
6091 color allocation failures more gracefully than the ones on the XPM
6094 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
6095 #define ALLOC_XPM_COLORS
6098 #ifdef ALLOC_XPM_COLORS
6100 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
6101 static void xpm_free_color_cache
P_ ((void));
6102 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
6103 static int xpm_color_bucket
P_ ((char *));
6104 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
6107 /* An entry in a hash table used to cache color definitions of named
6108 colors. This cache is necessary to speed up XPM image loading in
6109 case we do color allocations ourselves. Without it, we would need
6110 a call to XParseColor per pixel in the image. */
6112 struct xpm_cached_color
6114 /* Next in collision chain. */
6115 struct xpm_cached_color
*next
;
6117 /* Color definition (RGB and pixel color). */
6124 /* The hash table used for the color cache, and its bucket vector
6127 #define XPM_COLOR_CACHE_BUCKETS 1001
6128 struct xpm_cached_color
**xpm_color_cache
;
6130 /* Initialize the color cache. */
6133 xpm_init_color_cache (f
, attrs
)
6135 XpmAttributes
*attrs
;
6137 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
6138 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
6139 memset (xpm_color_cache
, 0, nbytes
);
6140 init_color_table ();
6142 if (attrs
->valuemask
& XpmColorSymbols
)
6147 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
6148 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
6149 attrs
->colorsymbols
[i
].value
, &color
))
6151 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
6153 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
6159 /* Free the color cache. */
6162 xpm_free_color_cache ()
6164 struct xpm_cached_color
*p
, *next
;
6167 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
6168 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
6174 xfree (xpm_color_cache
);
6175 xpm_color_cache
= NULL
;
6176 free_color_table ();
6180 /* Return the bucket index for color named COLOR_NAME in the color
6184 xpm_color_bucket (color_name
)
6190 for (s
= color_name
; *s
; ++s
)
6192 return h
%= XPM_COLOR_CACHE_BUCKETS
;
6196 /* On frame F, cache values COLOR for color with name COLOR_NAME.
6197 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
6200 static struct xpm_cached_color
*
6201 xpm_cache_color (f
, color_name
, color
, bucket
)
6208 struct xpm_cached_color
*p
;
6211 bucket
= xpm_color_bucket (color_name
);
6213 nbytes
= sizeof *p
+ strlen (color_name
);
6214 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
6215 strcpy (p
->name
, color_name
);
6217 p
->next
= xpm_color_cache
[bucket
];
6218 xpm_color_cache
[bucket
] = p
;
6223 /* Look up color COLOR_NAME for frame F in the color cache. If found,
6224 return the cached definition in *COLOR. Otherwise, make a new
6225 entry in the cache and allocate the color. Value is zero if color
6226 allocation failed. */
6229 xpm_lookup_color (f
, color_name
, color
)
6234 struct xpm_cached_color
*p
;
6235 int h
= xpm_color_bucket (color_name
);
6237 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
6238 if (strcmp (p
->name
, color_name
) == 0)
6243 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
6246 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
6248 p
= xpm_cache_color (f
, color_name
, color
, h
);
6250 /* You get `opaque' at least from ImageMagick converting pbm to xpm
6251 with transparency, and it's useful. */
6252 else if (strcmp ("opaque", color_name
) == 0)
6254 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
6255 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
6256 p
= xpm_cache_color (f
, color_name
, color
, h
);
6263 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
6264 CLOSURE is a pointer to the frame on which we allocate the
6265 color. Return in *COLOR the allocated color. Value is non-zero
6269 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
6276 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
6280 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
6281 is a pointer to the frame on which we allocate the color. Value is
6282 non-zero if successful. */
6285 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
6295 #endif /* ALLOC_XPM_COLORS */
6298 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
6299 for XPM images. Such a list must consist of conses whose car and
6303 xpm_valid_color_symbols_p (color_symbols
)
6304 Lisp_Object color_symbols
;
6306 while (CONSP (color_symbols
))
6308 Lisp_Object sym
= XCAR (color_symbols
);
6310 || !STRINGP (XCAR (sym
))
6311 || !STRINGP (XCDR (sym
)))
6313 color_symbols
= XCDR (color_symbols
);
6316 return NILP (color_symbols
);
6320 /* Value is non-zero if OBJECT is a valid XPM image specification. */
6323 xpm_image_p (object
)
6326 struct image_keyword fmt
[XPM_LAST
];
6327 bcopy (xpm_format
, fmt
, sizeof fmt
);
6328 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
6329 /* Either `:file' or `:data' must be present. */
6330 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
6331 /* Either no `:color-symbols' or it's a list of conses
6332 whose car and cdr are strings. */
6333 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
6334 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
6338 /* Load image IMG which will be displayed on frame F. Value is
6339 non-zero if successful. */
6347 XpmAttributes attrs
;
6348 Lisp_Object specified_file
, color_symbols
;
6350 /* Configure the XPM lib. Use the visual of frame F. Allocate
6351 close colors. Return colors allocated. */
6352 bzero (&attrs
, sizeof attrs
);
6353 attrs
.visual
= FRAME_X_VISUAL (f
);
6354 attrs
.colormap
= FRAME_X_COLORMAP (f
);
6355 attrs
.valuemask
|= XpmVisual
;
6356 attrs
.valuemask
|= XpmColormap
;
6358 #ifdef ALLOC_XPM_COLORS
6359 /* Allocate colors with our own functions which handle
6360 failing color allocation more gracefully. */
6361 attrs
.color_closure
= f
;
6362 attrs
.alloc_color
= xpm_alloc_color
;
6363 attrs
.free_colors
= xpm_free_colors
;
6364 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
6365 #else /* not ALLOC_XPM_COLORS */
6366 /* Let the XPM lib allocate colors. */
6367 attrs
.valuemask
|= XpmReturnAllocPixels
;
6368 #ifdef XpmAllocCloseColors
6369 attrs
.alloc_close_colors
= 1;
6370 attrs
.valuemask
|= XpmAllocCloseColors
;
6371 #else /* not XpmAllocCloseColors */
6372 attrs
.closeness
= 600;
6373 attrs
.valuemask
|= XpmCloseness
;
6374 #endif /* not XpmAllocCloseColors */
6375 #endif /* ALLOC_XPM_COLORS */
6377 /* If image specification contains symbolic color definitions, add
6378 these to `attrs'. */
6379 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
6380 if (CONSP (color_symbols
))
6383 XpmColorSymbol
*xpm_syms
;
6386 attrs
.valuemask
|= XpmColorSymbols
;
6388 /* Count number of symbols. */
6389 attrs
.numsymbols
= 0;
6390 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
6393 /* Allocate an XpmColorSymbol array. */
6394 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
6395 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
6396 bzero (xpm_syms
, size
);
6397 attrs
.colorsymbols
= xpm_syms
;
6399 /* Fill the color symbol array. */
6400 for (tail
= color_symbols
, i
= 0;
6402 ++i
, tail
= XCDR (tail
))
6404 Lisp_Object name
= XCAR (XCAR (tail
));
6405 Lisp_Object color
= XCDR (XCAR (tail
));
6406 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
6407 strcpy (xpm_syms
[i
].name
, SDATA (name
));
6408 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
6409 strcpy (xpm_syms
[i
].value
, SDATA (color
));
6413 /* Create a pixmap for the image, either from a file, or from a
6414 string buffer containing data in the same format as an XPM file. */
6415 #ifdef ALLOC_XPM_COLORS
6416 xpm_init_color_cache (f
, &attrs
);
6419 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6420 if (STRINGP (specified_file
))
6422 Lisp_Object file
= x_find_image_file (specified_file
);
6423 if (!STRINGP (file
))
6425 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6429 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6430 SDATA (file
), &img
->pixmap
, &img
->mask
,
6435 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
6436 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6438 &img
->pixmap
, &img
->mask
,
6442 if (rc
== XpmSuccess
)
6444 #ifdef ALLOC_XPM_COLORS
6445 img
->colors
= colors_in_color_table (&img
->ncolors
);
6446 #else /* not ALLOC_XPM_COLORS */
6449 img
->ncolors
= attrs
.nalloc_pixels
;
6450 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
6451 * sizeof *img
->colors
);
6452 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
6454 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
6455 #ifdef DEBUG_X_COLORS
6456 register_color (img
->colors
[i
]);
6459 #endif /* not ALLOC_XPM_COLORS */
6461 img
->width
= attrs
.width
;
6462 img
->height
= attrs
.height
;
6463 xassert (img
->width
> 0 && img
->height
> 0);
6465 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
6466 XpmFreeAttributes (&attrs
);
6473 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
6476 case XpmFileInvalid
:
6477 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
6481 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
6484 case XpmColorFailed
:
6485 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
6489 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
6494 #ifdef ALLOC_XPM_COLORS
6495 xpm_free_color_cache ();
6497 return rc
== XpmSuccess
;
6500 #endif /* HAVE_XPM != 0 */
6503 /***********************************************************************
6505 ***********************************************************************/
6507 /* An entry in the color table mapping an RGB color to a pixel color. */
6512 unsigned long pixel
;
6514 /* Next in color table collision list. */
6515 struct ct_color
*next
;
6518 /* The bucket vector size to use. Must be prime. */
6522 /* Value is a hash of the RGB color given by R, G, and B. */
6524 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
6526 /* The color hash table. */
6528 struct ct_color
**ct_table
;
6530 /* Number of entries in the color table. */
6532 int ct_colors_allocated
;
6534 /* Initialize the color table. */
6539 int size
= CT_SIZE
* sizeof (*ct_table
);
6540 ct_table
= (struct ct_color
**) xmalloc (size
);
6541 bzero (ct_table
, size
);
6542 ct_colors_allocated
= 0;
6546 /* Free memory associated with the color table. */
6552 struct ct_color
*p
, *next
;
6554 for (i
= 0; i
< CT_SIZE
; ++i
)
6555 for (p
= ct_table
[i
]; p
; p
= next
)
6566 /* Value is a pixel color for RGB color R, G, B on frame F. If an
6567 entry for that color already is in the color table, return the
6568 pixel color of that entry. Otherwise, allocate a new color for R,
6569 G, B, and make an entry in the color table. */
6571 static unsigned long
6572 lookup_rgb_color (f
, r
, g
, b
)
6576 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
6577 int i
= hash
% CT_SIZE
;
6580 for (p
= ct_table
[i
]; p
; p
= p
->next
)
6581 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
6594 cmap
= FRAME_X_COLORMAP (f
);
6595 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
6599 ++ct_colors_allocated
;
6601 p
= (struct ct_color
*) xmalloc (sizeof *p
);
6605 p
->pixel
= color
.pixel
;
6606 p
->next
= ct_table
[i
];
6610 return FRAME_FOREGROUND_PIXEL (f
);
6617 /* Look up pixel color PIXEL which is used on frame F in the color
6618 table. If not already present, allocate it. Value is PIXEL. */
6620 static unsigned long
6621 lookup_pixel_color (f
, pixel
)
6623 unsigned long pixel
;
6625 int i
= pixel
% CT_SIZE
;
6628 for (p
= ct_table
[i
]; p
; p
= p
->next
)
6629 if (p
->pixel
== pixel
)
6638 cmap
= FRAME_X_COLORMAP (f
);
6639 color
.pixel
= pixel
;
6640 x_query_color (f
, &color
);
6641 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
6645 ++ct_colors_allocated
;
6647 p
= (struct ct_color
*) xmalloc (sizeof *p
);
6652 p
->next
= ct_table
[i
];
6656 return FRAME_FOREGROUND_PIXEL (f
);
6663 /* Value is a vector of all pixel colors contained in the color table,
6664 allocated via xmalloc. Set *N to the number of colors. */
6666 static unsigned long *
6667 colors_in_color_table (n
)
6672 unsigned long *colors
;
6674 if (ct_colors_allocated
== 0)
6681 colors
= (unsigned long *) xmalloc (ct_colors_allocated
6683 *n
= ct_colors_allocated
;
6685 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
6686 for (p
= ct_table
[i
]; p
; p
= p
->next
)
6687 colors
[j
++] = p
->pixel
;
6695 /***********************************************************************
6697 ***********************************************************************/
6699 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
6700 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
6701 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
6703 /* Non-zero means draw a cross on images having `:conversion
6706 int cross_disabled_images
;
6708 /* Edge detection matrices for different edge-detection
6711 static int emboss_matrix
[9] = {
6713 2, -1, 0, /* y - 1 */
6715 0, 1, -2 /* y + 1 */
6718 static int laplace_matrix
[9] = {
6720 1, 0, 0, /* y - 1 */
6722 0, 0, -1 /* y + 1 */
6725 /* Value is the intensity of the color whose red/green/blue values
6728 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
6731 /* On frame F, return an array of XColor structures describing image
6732 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
6733 non-zero means also fill the red/green/blue members of the XColor
6734 structures. Value is a pointer to the array of XColors structures,
6735 allocated with xmalloc; it must be freed by the caller. */
6738 x_to_xcolors (f
, img
, rgb_p
)
6747 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
6749 /* Get the X image IMG->pixmap. */
6750 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
6751 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
6753 /* Fill the `pixel' members of the XColor array. I wished there
6754 were an easy and portable way to circumvent XGetPixel. */
6756 for (y
= 0; y
< img
->height
; ++y
)
6760 for (x
= 0; x
< img
->width
; ++x
, ++p
)
6761 p
->pixel
= XGetPixel (ximg
, x
, y
);
6764 x_query_colors (f
, row
, img
->width
);
6767 XDestroyImage (ximg
);
6772 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
6773 RGB members are set. F is the frame on which this all happens.
6774 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
6777 x_from_xcolors (f
, img
, colors
)
6787 init_color_table ();
6789 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
6792 for (y
= 0; y
< img
->height
; ++y
)
6793 for (x
= 0; x
< img
->width
; ++x
, ++p
)
6795 unsigned long pixel
;
6796 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
6797 XPutPixel (oimg
, x
, y
, pixel
);
6801 x_clear_image_1 (f
, img
, 1, 0, 1);
6803 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
6804 x_destroy_x_image (oimg
);
6805 img
->pixmap
= pixmap
;
6806 img
->colors
= colors_in_color_table (&img
->ncolors
);
6807 free_color_table ();
6811 /* On frame F, perform edge-detection on image IMG.
6813 MATRIX is a nine-element array specifying the transformation
6814 matrix. See emboss_matrix for an example.
6816 COLOR_ADJUST is a color adjustment added to each pixel of the
6820 x_detect_edges (f
, img
, matrix
, color_adjust
)
6823 int matrix
[9], color_adjust
;
6825 XColor
*colors
= x_to_xcolors (f
, img
, 1);
6829 for (i
= sum
= 0; i
< 9; ++i
)
6830 sum
+= abs (matrix
[i
]);
6832 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
6834 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
6836 for (y
= 0; y
< img
->height
; ++y
)
6838 p
= COLOR (new, 0, y
);
6839 p
->red
= p
->green
= p
->blue
= 0xffff/2;
6840 p
= COLOR (new, img
->width
- 1, y
);
6841 p
->red
= p
->green
= p
->blue
= 0xffff/2;
6844 for (x
= 1; x
< img
->width
- 1; ++x
)
6846 p
= COLOR (new, x
, 0);
6847 p
->red
= p
->green
= p
->blue
= 0xffff/2;
6848 p
= COLOR (new, x
, img
->height
- 1);
6849 p
->red
= p
->green
= p
->blue
= 0xffff/2;
6852 for (y
= 1; y
< img
->height
- 1; ++y
)
6854 p
= COLOR (new, 1, y
);
6856 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
6858 int r
, g
, b
, y1
, x1
;
6861 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
6862 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
6865 XColor
*t
= COLOR (colors
, x1
, y1
);
6866 r
+= matrix
[i
] * t
->red
;
6867 g
+= matrix
[i
] * t
->green
;
6868 b
+= matrix
[i
] * t
->blue
;
6871 r
= (r
/ sum
+ color_adjust
) & 0xffff;
6872 g
= (g
/ sum
+ color_adjust
) & 0xffff;
6873 b
= (b
/ sum
+ color_adjust
) & 0xffff;
6874 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
6879 x_from_xcolors (f
, img
, new);
6885 /* Perform the pre-defined `emboss' edge-detection on image IMG
6893 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
6897 /* Perform the pre-defined `laplace' edge-detection on image IMG
6905 x_detect_edges (f
, img
, laplace_matrix
, 45000);
6909 /* Perform edge-detection on image IMG on frame F, with specified
6910 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
6912 MATRIX must be either
6914 - a list of at least 9 numbers in row-major form
6915 - a vector of at least 9 numbers
6917 COLOR_ADJUST nil means use a default; otherwise it must be a
6921 x_edge_detection (f
, img
, matrix
, color_adjust
)
6924 Lisp_Object matrix
, color_adjust
;
6932 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
6933 ++i
, matrix
= XCDR (matrix
))
6934 trans
[i
] = XFLOATINT (XCAR (matrix
));
6936 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
6938 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
6939 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
6942 if (NILP (color_adjust
))
6943 color_adjust
= make_number (0xffff / 2);
6945 if (i
== 9 && NUMBERP (color_adjust
))
6946 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
6950 /* Transform image IMG on frame F so that it looks disabled. */
6953 x_disable_image (f
, img
)
6957 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6959 if (dpyinfo
->n_planes
>= 2)
6961 /* Color (or grayscale). Convert to gray, and equalize. Just
6962 drawing such images with a stipple can look very odd, so
6963 we're using this method instead. */
6964 XColor
*colors
= x_to_xcolors (f
, img
, 1);
6966 const int h
= 15000;
6967 const int l
= 30000;
6969 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
6973 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
6974 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
6975 p
->red
= p
->green
= p
->blue
= i2
;
6978 x_from_xcolors (f
, img
, colors
);
6981 /* Draw a cross over the disabled image, if we must or if we
6983 if (dpyinfo
->n_planes
< 2 || cross_disabled_images
)
6985 Display
*dpy
= FRAME_X_DISPLAY (f
);
6988 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
6989 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
6990 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
6991 img
->width
- 1, img
->height
- 1);
6992 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
6998 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
6999 XSetForeground (dpy
, gc
, WHITE_PIX_DEFAULT (f
));
7000 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
7001 img
->width
- 1, img
->height
- 1);
7002 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
7010 /* Build a mask for image IMG which is used on frame F. FILE is the
7011 name of an image file, for error messages. HOW determines how to
7012 determine the background color of IMG. If it is a list '(R G B)',
7013 with R, G, and B being integers >= 0, take that as the color of the
7014 background. Otherwise, determine the background color of IMG
7015 heuristically. Value is non-zero if successful. */
7018 x_build_heuristic_mask (f
, img
, how
)
7023 Display
*dpy
= FRAME_X_DISPLAY (f
);
7024 XImage
*ximg
, *mask_img
;
7025 int x
, y
, rc
, use_img_background
;
7026 unsigned long bg
= 0;
7030 XFreePixmap (FRAME_X_DISPLAY (f
), img
->mask
);
7032 img
->background_transparent_valid
= 0;
7035 /* Create an image and pixmap serving as mask. */
7036 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
7037 &mask_img
, &img
->mask
);
7041 /* Get the X image of IMG->pixmap. */
7042 ximg
= XGetImage (dpy
, img
->pixmap
, 0, 0, img
->width
, img
->height
,
7045 /* Determine the background color of ximg. If HOW is `(R G B)'
7046 take that as color. Otherwise, use the image's background color. */
7047 use_img_background
= 1;
7053 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
7055 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
7059 if (i
== 3 && NILP (how
))
7061 char color_name
[30];
7062 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
7063 bg
= x_alloc_image_color (f
, img
, build_string (color_name
), 0);
7064 use_img_background
= 0;
7068 if (use_img_background
)
7069 bg
= four_corners_best (ximg
, img
->width
, img
->height
);
7071 /* Set all bits in mask_img to 1 whose color in ximg is different
7072 from the background color bg. */
7073 for (y
= 0; y
< img
->height
; ++y
)
7074 for (x
= 0; x
< img
->width
; ++x
)
7075 XPutPixel (mask_img
, x
, y
, XGetPixel (ximg
, x
, y
) != bg
);
7077 /* Fill in the background_transparent field while we have the mask handy. */
7078 image_background_transparent (img
, f
, mask_img
);
7080 /* Put mask_img into img->mask. */
7081 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
7082 x_destroy_x_image (mask_img
);
7083 XDestroyImage (ximg
);
7090 /***********************************************************************
7091 PBM (mono, gray, color)
7092 ***********************************************************************/
7094 static int pbm_image_p
P_ ((Lisp_Object object
));
7095 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
7096 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
7098 /* The symbol `pbm' identifying images of this type. */
7102 /* Indices of image specification fields in gs_format, below. */
7104 enum pbm_keyword_index
7120 /* Vector of image_keyword structures describing the format
7121 of valid user-defined image specifications. */
7123 static struct image_keyword pbm_format
[PBM_LAST
] =
7125 {":type", IMAGE_SYMBOL_VALUE
, 1},
7126 {":file", IMAGE_STRING_VALUE
, 0},
7127 {":data", IMAGE_STRING_VALUE
, 0},
7128 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7129 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7130 {":relief", IMAGE_INTEGER_VALUE
, 0},
7131 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7132 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7133 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7134 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
7135 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7138 /* Structure describing the image type `pbm'. */
7140 static struct image_type pbm_type
=
7150 /* Return non-zero if OBJECT is a valid PBM image specification. */
7153 pbm_image_p (object
)
7156 struct image_keyword fmt
[PBM_LAST
];
7158 bcopy (pbm_format
, fmt
, sizeof fmt
);
7160 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
7163 /* Must specify either :data or :file. */
7164 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
7168 /* Scan a decimal number from *S and return it. Advance *S while
7169 reading the number. END is the end of the string. Value is -1 at
7173 pbm_scan_number (s
, end
)
7174 unsigned char **s
, *end
;
7176 int c
= 0, val
= -1;
7180 /* Skip white-space. */
7181 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
7186 /* Skip comment to end of line. */
7187 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
7190 else if (isdigit (c
))
7192 /* Read decimal number. */
7194 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
7195 val
= 10 * val
+ c
- '0';
7206 /* Load PBM image IMG for use on frame F. */
7214 int width
, height
, max_color_idx
= 0;
7216 Lisp_Object file
, specified_file
;
7217 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
7218 struct gcpro gcpro1
;
7219 unsigned char *contents
= NULL
;
7220 unsigned char *end
, *p
;
7223 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7227 if (STRINGP (specified_file
))
7229 file
= x_find_image_file (specified_file
);
7230 if (!STRINGP (file
))
7232 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7237 contents
= slurp_file (SDATA (file
), &size
);
7238 if (contents
== NULL
)
7240 image_error ("Error reading `%s'", file
, Qnil
);
7246 end
= contents
+ size
;
7251 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7253 end
= p
+ SBYTES (data
);
7256 /* Check magic number. */
7257 if (end
- p
< 2 || *p
++ != 'P')
7259 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
7269 raw_p
= 0, type
= PBM_MONO
;
7273 raw_p
= 0, type
= PBM_GRAY
;
7277 raw_p
= 0, type
= PBM_COLOR
;
7281 raw_p
= 1, type
= PBM_MONO
;
7285 raw_p
= 1, type
= PBM_GRAY
;
7289 raw_p
= 1, type
= PBM_COLOR
;
7293 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
7297 /* Read width, height, maximum color-component. Characters
7298 starting with `#' up to the end of a line are ignored. */
7299 width
= pbm_scan_number (&p
, end
);
7300 height
= pbm_scan_number (&p
, end
);
7302 if (type
!= PBM_MONO
)
7304 max_color_idx
= pbm_scan_number (&p
, end
);
7305 if (raw_p
&& max_color_idx
> 255)
7306 max_color_idx
= 255;
7311 || (type
!= PBM_MONO
&& max_color_idx
< 0))
7314 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
7315 &ximg
, &img
->pixmap
))
7318 /* Initialize the color hash table. */
7319 init_color_table ();
7321 if (type
== PBM_MONO
)
7324 struct image_keyword fmt
[PBM_LAST
];
7325 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
7326 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
7328 /* Parse the image specification. */
7329 bcopy (pbm_format
, fmt
, sizeof fmt
);
7330 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
7332 /* Get foreground and background colors, maybe allocate colors. */
7333 if (fmt
[PBM_FOREGROUND
].count
7334 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
7335 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
7336 if (fmt
[PBM_BACKGROUND
].count
7337 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
7339 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
7340 img
->background
= bg
;
7341 img
->background_valid
= 1;
7344 for (y
= 0; y
< height
; ++y
)
7345 for (x
= 0; x
< width
; ++x
)
7355 g
= pbm_scan_number (&p
, end
);
7357 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
7362 for (y
= 0; y
< height
; ++y
)
7363 for (x
= 0; x
< width
; ++x
)
7367 if (type
== PBM_GRAY
)
7368 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
7377 r
= pbm_scan_number (&p
, end
);
7378 g
= pbm_scan_number (&p
, end
);
7379 b
= pbm_scan_number (&p
, end
);
7382 if (r
< 0 || g
< 0 || b
< 0)
7386 XDestroyImage (ximg
);
7387 image_error ("Invalid pixel value in image `%s'",
7392 /* RGB values are now in the range 0..max_color_idx.
7393 Scale this to the range 0..0xffff supported by X. */
7394 r
= (double) r
* 65535 / max_color_idx
;
7395 g
= (double) g
* 65535 / max_color_idx
;
7396 b
= (double) b
* 65535 / max_color_idx
;
7397 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
7401 /* Store in IMG->colors the colors allocated for the image, and
7402 free the color table. */
7403 img
->colors
= colors_in_color_table (&img
->ncolors
);
7404 free_color_table ();
7406 /* Maybe fill in the background field while we have ximg handy. */
7407 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7408 IMAGE_BACKGROUND (img
, f
, ximg
);
7410 /* Put the image into a pixmap. */
7411 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7412 x_destroy_x_image (ximg
);
7415 img
->height
= height
;
7424 /***********************************************************************
7426 ***********************************************************************/
7432 /* Function prototypes. */
7434 static int png_image_p
P_ ((Lisp_Object object
));
7435 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
7437 /* The symbol `png' identifying images of this type. */
7441 /* Indices of image specification fields in png_format, below. */
7443 enum png_keyword_index
7458 /* Vector of image_keyword structures describing the format
7459 of valid user-defined image specifications. */
7461 static struct image_keyword png_format
[PNG_LAST
] =
7463 {":type", IMAGE_SYMBOL_VALUE
, 1},
7464 {":data", IMAGE_STRING_VALUE
, 0},
7465 {":file", IMAGE_STRING_VALUE
, 0},
7466 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7467 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7468 {":relief", IMAGE_INTEGER_VALUE
, 0},
7469 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7470 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7471 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7472 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7475 /* Structure describing the image type `png'. */
7477 static struct image_type png_type
=
7487 /* Return non-zero if OBJECT is a valid PNG image specification. */
7490 png_image_p (object
)
7493 struct image_keyword fmt
[PNG_LAST
];
7494 bcopy (png_format
, fmt
, sizeof fmt
);
7496 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
7499 /* Must specify either the :data or :file keyword. */
7500 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
7504 /* Error and warning handlers installed when the PNG library
7508 my_png_error (png_ptr
, msg
)
7509 png_struct
*png_ptr
;
7512 xassert (png_ptr
!= NULL
);
7513 image_error ("PNG error: %s", build_string (msg
), Qnil
);
7514 longjmp (png_ptr
->jmpbuf
, 1);
7519 my_png_warning (png_ptr
, msg
)
7520 png_struct
*png_ptr
;
7523 xassert (png_ptr
!= NULL
);
7524 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
7527 /* Memory source for PNG decoding. */
7529 struct png_memory_storage
7531 unsigned char *bytes
; /* The data */
7532 size_t len
; /* How big is it? */
7533 int index
; /* Where are we? */
7537 /* Function set as reader function when reading PNG image from memory.
7538 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
7539 bytes from the input to DATA. */
7542 png_read_from_memory (png_ptr
, data
, length
)
7543 png_structp png_ptr
;
7547 struct png_memory_storage
*tbr
7548 = (struct png_memory_storage
*) png_get_io_ptr (png_ptr
);
7550 if (length
> tbr
->len
- tbr
->index
)
7551 png_error (png_ptr
, "Read error");
7553 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
7554 tbr
->index
= tbr
->index
+ length
;
7557 /* Load PNG image IMG for use on frame F. Value is non-zero if
7565 Lisp_Object file
, specified_file
;
7566 Lisp_Object specified_data
;
7568 XImage
*ximg
, *mask_img
= NULL
;
7569 struct gcpro gcpro1
;
7570 png_struct
*png_ptr
= NULL
;
7571 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
7572 FILE *volatile fp
= NULL
;
7574 png_byte
* volatile pixels
= NULL
;
7575 png_byte
** volatile rows
= NULL
;
7576 png_uint_32 width
, height
;
7577 int bit_depth
, color_type
, interlace_type
;
7579 png_uint_32 row_bytes
;
7581 double screen_gamma
, image_gamma
;
7583 struct png_memory_storage tbr
; /* Data to be read */
7585 /* Find out what file to load. */
7586 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7587 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7591 if (NILP (specified_data
))
7593 file
= x_find_image_file (specified_file
);
7594 if (!STRINGP (file
))
7596 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7601 /* Open the image file. */
7602 fp
= fopen (SDATA (file
), "rb");
7605 image_error ("Cannot open image file `%s'", file
, Qnil
);
7611 /* Check PNG signature. */
7612 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
7613 || !png_check_sig (sig
, sizeof sig
))
7615 image_error ("Not a PNG file: `%s'", file
, Qnil
);
7623 /* Read from memory. */
7624 tbr
.bytes
= SDATA (specified_data
);
7625 tbr
.len
= SBYTES (specified_data
);
7628 /* Check PNG signature. */
7629 if (tbr
.len
< sizeof sig
7630 || !png_check_sig (tbr
.bytes
, sizeof sig
))
7632 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
7637 /* Need to skip past the signature. */
7638 tbr
.bytes
+= sizeof (sig
);
7641 /* Initialize read and info structs for PNG lib. */
7642 png_ptr
= png_create_read_struct (PNG_LIBPNG_VER_STRING
, NULL
,
7643 my_png_error
, my_png_warning
);
7646 if (fp
) fclose (fp
);
7651 info_ptr
= png_create_info_struct (png_ptr
);
7654 png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
7655 if (fp
) fclose (fp
);
7660 end_info
= png_create_info_struct (png_ptr
);
7663 png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
7664 if (fp
) fclose (fp
);
7669 /* Set error jump-back. We come back here when the PNG library
7670 detects an error. */
7671 if (setjmp (png_ptr
->jmpbuf
))
7675 png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
7678 if (fp
) fclose (fp
);
7683 /* Read image info. */
7684 if (!NILP (specified_data
))
7685 png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
7687 png_init_io (png_ptr
, fp
);
7689 png_set_sig_bytes (png_ptr
, sizeof sig
);
7690 png_read_info (png_ptr
, info_ptr
);
7691 png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
7692 &interlace_type
, NULL
, NULL
);
7694 /* If image contains simply transparency data, we prefer to
7695 construct a clipping mask. */
7696 if (png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
7701 /* This function is easier to write if we only have to handle
7702 one data format: RGB or RGBA with 8 bits per channel. Let's
7703 transform other formats into that format. */
7705 /* Strip more than 8 bits per channel. */
7706 if (bit_depth
== 16)
7707 png_set_strip_16 (png_ptr
);
7709 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
7711 png_set_expand (png_ptr
);
7713 /* Convert grayscale images to RGB. */
7714 if (color_type
== PNG_COLOR_TYPE_GRAY
7715 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
7716 png_set_gray_to_rgb (png_ptr
);
7718 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
7720 #if 0 /* Avoid double gamma correction for PNG images. */
7721 /* Tell the PNG lib to handle gamma correction for us. */
7722 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
7723 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
7724 /* The libpng documentation says this is right in this case. */
7725 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
7728 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
7729 /* Image contains gamma information. */
7730 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
7732 /* Use the standard default for the image gamma. */
7733 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
7736 /* Handle alpha channel by combining the image with a background
7737 color. Do this only if a real alpha channel is supplied. For
7738 simple transparency, we prefer a clipping mask. */
7741 png_color_16
*image_bg
;
7742 Lisp_Object specified_bg
7743 = image_spec_value (img
->spec
, QCbackground
, NULL
);
7745 if (STRINGP (specified_bg
))
7746 /* The user specified `:background', use that. */
7749 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
7751 png_color_16 user_bg
;
7753 bzero (&user_bg
, sizeof user_bg
);
7754 user_bg
.red
= color
.red
;
7755 user_bg
.green
= color
.green
;
7756 user_bg
.blue
= color
.blue
;
7758 png_set_background (png_ptr
, &user_bg
,
7759 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
7762 else if (png_get_bKGD (png_ptr
, info_ptr
, &image_bg
))
7763 /* Image contains a background color with which to
7764 combine the image. */
7765 png_set_background (png_ptr
, image_bg
,
7766 PNG_BACKGROUND_GAMMA_FILE
, 1, 1.0);
7769 /* Image does not contain a background color with which
7770 to combine the image data via an alpha channel. Use
7771 the frame's background instead. */
7774 png_color_16 frame_background
;
7776 cmap
= FRAME_X_COLORMAP (f
);
7777 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
7778 x_query_color (f
, &color
);
7780 bzero (&frame_background
, sizeof frame_background
);
7781 frame_background
.red
= color
.red
;
7782 frame_background
.green
= color
.green
;
7783 frame_background
.blue
= color
.blue
;
7785 png_set_background (png_ptr
, &frame_background
,
7786 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
7790 /* Update info structure. */
7791 png_read_update_info (png_ptr
, info_ptr
);
7793 /* Get number of channels. Valid values are 1 for grayscale images
7794 and images with a palette, 2 for grayscale images with transparency
7795 information (alpha channel), 3 for RGB images, and 4 for RGB
7796 images with alpha channel, i.e. RGBA. If conversions above were
7797 sufficient we should only have 3 or 4 channels here. */
7798 channels
= png_get_channels (png_ptr
, info_ptr
);
7799 xassert (channels
== 3 || channels
== 4);
7801 /* Number of bytes needed for one row of the image. */
7802 row_bytes
= png_get_rowbytes (png_ptr
, info_ptr
);
7804 /* Allocate memory for the image. */
7805 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
7806 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
7807 for (i
= 0; i
< height
; ++i
)
7808 rows
[i
] = pixels
+ i
* row_bytes
;
7810 /* Read the entire image. */
7811 png_read_image (png_ptr
, rows
);
7812 png_read_end (png_ptr
, info_ptr
);
7819 /* Create the X image and pixmap. */
7820 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
7824 /* Create an image and pixmap serving as mask if the PNG image
7825 contains an alpha channel. */
7828 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
7829 &mask_img
, &img
->mask
))
7831 x_destroy_x_image (ximg
);
7832 XFreePixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
7837 /* Fill the X image and mask from PNG data. */
7838 init_color_table ();
7840 for (y
= 0; y
< height
; ++y
)
7842 png_byte
*p
= rows
[y
];
7844 for (x
= 0; x
< width
; ++x
)
7851 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
7853 /* An alpha channel, aka mask channel, associates variable
7854 transparency with an image. Where other image formats
7855 support binary transparency---fully transparent or fully
7856 opaque---PNG allows up to 254 levels of partial transparency.
7857 The PNG library implements partial transparency by combining
7858 the image with a specified background color.
7860 I'm not sure how to handle this here nicely: because the
7861 background on which the image is displayed may change, for
7862 real alpha channel support, it would be necessary to create
7863 a new image for each possible background.
7865 What I'm doing now is that a mask is created if we have
7866 boolean transparency information. Otherwise I'm using
7867 the frame's background color to combine the image with. */
7872 XPutPixel (mask_img
, x
, y
, *p
> 0);
7878 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7879 /* Set IMG's background color from the PNG image, unless the user
7883 if (png_get_bKGD (png_ptr
, info_ptr
, &bg
))
7885 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
7886 img
->background_valid
= 1;
7890 /* Remember colors allocated for this image. */
7891 img
->colors
= colors_in_color_table (&img
->ncolors
);
7892 free_color_table ();
7895 png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
7900 img
->height
= height
;
7902 /* Maybe fill in the background field while we have ximg handy. */
7903 IMAGE_BACKGROUND (img
, f
, ximg
);
7905 /* Put the image into the pixmap, then free the X image and its buffer. */
7906 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7907 x_destroy_x_image (ximg
);
7909 /* Same for the mask. */
7912 /* Fill in the background_transparent field while we have the mask
7914 image_background_transparent (img
, f
, mask_img
);
7916 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
7917 x_destroy_x_image (mask_img
);
7924 #endif /* HAVE_PNG != 0 */
7928 /***********************************************************************
7930 ***********************************************************************/
7934 /* Work around a warning about HAVE_STDLIB_H being redefined in
7936 #ifdef HAVE_STDLIB_H
7937 #define HAVE_STDLIB_H_1
7938 #undef HAVE_STDLIB_H
7939 #endif /* HAVE_STLIB_H */
7941 #include <jpeglib.h>
7945 #ifdef HAVE_STLIB_H_1
7946 #define HAVE_STDLIB_H 1
7949 static int jpeg_image_p
P_ ((Lisp_Object object
));
7950 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
7952 /* The symbol `jpeg' identifying images of this type. */
7956 /* Indices of image specification fields in gs_format, below. */
7958 enum jpeg_keyword_index
7967 JPEG_HEURISTIC_MASK
,
7973 /* Vector of image_keyword structures describing the format
7974 of valid user-defined image specifications. */
7976 static struct image_keyword jpeg_format
[JPEG_LAST
] =
7978 {":type", IMAGE_SYMBOL_VALUE
, 1},
7979 {":data", IMAGE_STRING_VALUE
, 0},
7980 {":file", IMAGE_STRING_VALUE
, 0},
7981 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7982 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7983 {":relief", IMAGE_INTEGER_VALUE
, 0},
7984 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7985 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7986 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7987 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7990 /* Structure describing the image type `jpeg'. */
7992 static struct image_type jpeg_type
=
8002 /* Return non-zero if OBJECT is a valid JPEG image specification. */
8005 jpeg_image_p (object
)
8008 struct image_keyword fmt
[JPEG_LAST
];
8010 bcopy (jpeg_format
, fmt
, sizeof fmt
);
8012 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
8015 /* Must specify either the :data or :file keyword. */
8016 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
8020 struct my_jpeg_error_mgr
8022 struct jpeg_error_mgr pub
;
8023 jmp_buf setjmp_buffer
;
8028 my_error_exit (cinfo
)
8031 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
8032 longjmp (mgr
->setjmp_buffer
, 1);
8036 /* Init source method for JPEG data source manager. Called by
8037 jpeg_read_header() before any data is actually read. See
8038 libjpeg.doc from the JPEG lib distribution. */
8041 our_init_source (cinfo
)
8042 j_decompress_ptr cinfo
;
8047 /* Fill input buffer method for JPEG data source manager. Called
8048 whenever more data is needed. We read the whole image in one step,
8049 so this only adds a fake end of input marker at the end. */
8052 our_fill_input_buffer (cinfo
)
8053 j_decompress_ptr cinfo
;
8055 /* Insert a fake EOI marker. */
8056 struct jpeg_source_mgr
*src
= cinfo
->src
;
8057 static JOCTET buffer
[2];
8059 buffer
[0] = (JOCTET
) 0xFF;
8060 buffer
[1] = (JOCTET
) JPEG_EOI
;
8062 src
->next_input_byte
= buffer
;
8063 src
->bytes_in_buffer
= 2;
8068 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
8069 is the JPEG data source manager. */
8072 our_skip_input_data (cinfo
, num_bytes
)
8073 j_decompress_ptr cinfo
;
8076 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
8080 if (num_bytes
> src
->bytes_in_buffer
)
8081 ERREXIT (cinfo
, JERR_INPUT_EOF
);
8083 src
->bytes_in_buffer
-= num_bytes
;
8084 src
->next_input_byte
+= num_bytes
;
8089 /* Method to terminate data source. Called by
8090 jpeg_finish_decompress() after all data has been processed. */
8093 our_term_source (cinfo
)
8094 j_decompress_ptr cinfo
;
8099 /* Set up the JPEG lib for reading an image from DATA which contains
8100 LEN bytes. CINFO is the decompression info structure created for
8101 reading the image. */
8104 jpeg_memory_src (cinfo
, data
, len
)
8105 j_decompress_ptr cinfo
;
8109 struct jpeg_source_mgr
*src
;
8111 if (cinfo
->src
== NULL
)
8113 /* First time for this JPEG object? */
8114 cinfo
->src
= (struct jpeg_source_mgr
*)
8115 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
8116 sizeof (struct jpeg_source_mgr
));
8117 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
8118 src
->next_input_byte
= data
;
8121 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
8122 src
->init_source
= our_init_source
;
8123 src
->fill_input_buffer
= our_fill_input_buffer
;
8124 src
->skip_input_data
= our_skip_input_data
;
8125 src
->resync_to_restart
= jpeg_resync_to_restart
; /* Use default method. */
8126 src
->term_source
= our_term_source
;
8127 src
->bytes_in_buffer
= len
;
8128 src
->next_input_byte
= data
;
8132 /* Load image IMG for use on frame F. Patterned after example.c
8133 from the JPEG lib. */
8140 struct jpeg_decompress_struct cinfo
;
8141 struct my_jpeg_error_mgr mgr
;
8142 Lisp_Object file
, specified_file
;
8143 Lisp_Object specified_data
;
8144 FILE * volatile fp
= NULL
;
8146 int row_stride
, x
, y
;
8147 XImage
*ximg
= NULL
;
8149 unsigned long *colors
;
8151 struct gcpro gcpro1
;
8153 /* Open the JPEG file. */
8154 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
8155 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8159 if (NILP (specified_data
))
8161 file
= x_find_image_file (specified_file
);
8162 if (!STRINGP (file
))
8164 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
8169 fp
= fopen (SDATA (file
), "r");
8172 image_error ("Cannot open `%s'", file
, Qnil
);
8178 /* Customize libjpeg's error handling to call my_error_exit when an
8179 error is detected. This function will perform a longjmp. */
8180 cinfo
.err
= jpeg_std_error (&mgr
.pub
);
8181 mgr
.pub
.error_exit
= my_error_exit
;
8183 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
8187 /* Called from my_error_exit. Display a JPEG error. */
8188 char buffer
[JMSG_LENGTH_MAX
];
8189 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
8190 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
8191 build_string (buffer
));
8194 /* Close the input file and destroy the JPEG object. */
8196 fclose ((FILE *) fp
);
8197 jpeg_destroy_decompress (&cinfo
);
8199 /* If we already have an XImage, free that. */
8200 x_destroy_x_image (ximg
);
8202 /* Free pixmap and colors. */
8203 x_clear_image (f
, img
);
8209 /* Create the JPEG decompression object. Let it read from fp.
8210 Read the JPEG image header. */
8211 jpeg_create_decompress (&cinfo
);
8213 if (NILP (specified_data
))
8214 jpeg_stdio_src (&cinfo
, (FILE *) fp
);
8216 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
8217 SBYTES (specified_data
));
8219 jpeg_read_header (&cinfo
, TRUE
);
8221 /* Customize decompression so that color quantization will be used.
8222 Start decompression. */
8223 cinfo
.quantize_colors
= TRUE
;
8224 jpeg_start_decompress (&cinfo
);
8225 width
= img
->width
= cinfo
.output_width
;
8226 height
= img
->height
= cinfo
.output_height
;
8228 /* Create X image and pixmap. */
8229 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8230 longjmp (mgr
.setjmp_buffer
, 2);
8232 /* Allocate colors. When color quantization is used,
8233 cinfo.actual_number_of_colors has been set with the number of
8234 colors generated, and cinfo.colormap is a two-dimensional array
8235 of color indices in the range 0..cinfo.actual_number_of_colors.
8236 No more than 255 colors will be generated. */
8240 if (cinfo
.out_color_components
> 2)
8241 ir
= 0, ig
= 1, ib
= 2;
8242 else if (cinfo
.out_color_components
> 1)
8243 ir
= 0, ig
= 1, ib
= 0;
8245 ir
= 0, ig
= 0, ib
= 0;
8247 /* Use the color table mechanism because it handles colors that
8248 cannot be allocated nicely. Such colors will be replaced with
8249 a default color, and we don't have to care about which colors
8250 can be freed safely, and which can't. */
8251 init_color_table ();
8252 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
8255 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
8257 /* Multiply RGB values with 255 because X expects RGB values
8258 in the range 0..0xffff. */
8259 int r
= cinfo
.colormap
[ir
][i
] << 8;
8260 int g
= cinfo
.colormap
[ig
][i
] << 8;
8261 int b
= cinfo
.colormap
[ib
][i
] << 8;
8262 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
8265 /* Remember those colors actually allocated. */
8266 img
->colors
= colors_in_color_table (&img
->ncolors
);
8267 free_color_table ();
8271 row_stride
= width
* cinfo
.output_components
;
8272 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
8274 for (y
= 0; y
< height
; ++y
)
8276 jpeg_read_scanlines (&cinfo
, buffer
, 1);
8277 for (x
= 0; x
< cinfo
.output_width
; ++x
)
8278 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
8282 jpeg_finish_decompress (&cinfo
);
8283 jpeg_destroy_decompress (&cinfo
);
8285 fclose ((FILE *) fp
);
8287 /* Maybe fill in the background field while we have ximg handy. */
8288 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8289 IMAGE_BACKGROUND (img
, f
, ximg
);
8291 /* Put the image into the pixmap. */
8292 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8293 x_destroy_x_image (ximg
);
8298 #endif /* HAVE_JPEG */
8302 /***********************************************************************
8304 ***********************************************************************/
8310 static int tiff_image_p
P_ ((Lisp_Object object
));
8311 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
8313 /* The symbol `tiff' identifying images of this type. */
8317 /* Indices of image specification fields in tiff_format, below. */
8319 enum tiff_keyword_index
8328 TIFF_HEURISTIC_MASK
,
8334 /* Vector of image_keyword structures describing the format
8335 of valid user-defined image specifications. */
8337 static struct image_keyword tiff_format
[TIFF_LAST
] =
8339 {":type", IMAGE_SYMBOL_VALUE
, 1},
8340 {":data", IMAGE_STRING_VALUE
, 0},
8341 {":file", IMAGE_STRING_VALUE
, 0},
8342 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8343 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8344 {":relief", IMAGE_INTEGER_VALUE
, 0},
8345 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8346 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8347 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8348 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8351 /* Structure describing the image type `tiff'. */
8353 static struct image_type tiff_type
=
8363 /* Return non-zero if OBJECT is a valid TIFF image specification. */
8366 tiff_image_p (object
)
8369 struct image_keyword fmt
[TIFF_LAST
];
8370 bcopy (tiff_format
, fmt
, sizeof fmt
);
8372 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
8375 /* Must specify either the :data or :file keyword. */
8376 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
8380 /* Reading from a memory buffer for TIFF images Based on the PNG
8381 memory source, but we have to provide a lot of extra functions.
8384 We really only need to implement read and seek, but I am not
8385 convinced that the TIFF library is smart enough not to destroy
8386 itself if we only hand it the function pointers we need to
8391 unsigned char *bytes
;
8399 tiff_read_from_memory (data
, buf
, size
)
8404 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
8406 if (size
> src
->len
- src
->index
)
8408 bcopy (src
->bytes
+ src
->index
, buf
, size
);
8415 tiff_write_from_memory (data
, buf
, size
)
8425 tiff_seek_in_memory (data
, off
, whence
)
8430 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
8435 case SEEK_SET
: /* Go from beginning of source. */
8439 case SEEK_END
: /* Go from end of source. */
8440 idx
= src
->len
+ off
;
8443 case SEEK_CUR
: /* Go from current position. */
8444 idx
= src
->index
+ off
;
8447 default: /* Invalid `whence'. */
8451 if (idx
> src
->len
|| idx
< 0)
8460 tiff_close_memory (data
)
8469 tiff_mmap_memory (data
, pbase
, psize
)
8474 /* It is already _IN_ memory. */
8480 tiff_unmap_memory (data
, base
, size
)
8485 /* We don't need to do this. */
8490 tiff_size_of_memory (data
)
8493 return ((tiff_memory_source
*) data
)->len
;
8498 tiff_error_handler (title
, format
, ap
)
8499 const char *title
, *format
;
8505 len
= sprintf (buf
, "TIFF error: %s ", title
);
8506 vsprintf (buf
+ len
, format
, ap
);
8507 add_to_log (buf
, Qnil
, Qnil
);
8512 tiff_warning_handler (title
, format
, ap
)
8513 const char *title
, *format
;
8519 len
= sprintf (buf
, "TIFF warning: %s ", title
);
8520 vsprintf (buf
+ len
, format
, ap
);
8521 add_to_log (buf
, Qnil
, Qnil
);
8525 /* Load TIFF image IMG for use on frame F. Value is non-zero if
8533 Lisp_Object file
, specified_file
;
8534 Lisp_Object specified_data
;
8536 int width
, height
, x
, y
;
8540 struct gcpro gcpro1
;
8541 tiff_memory_source memsrc
;
8543 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
8544 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8548 TIFFSetErrorHandler (tiff_error_handler
);
8549 TIFFSetWarningHandler (tiff_warning_handler
);
8551 if (NILP (specified_data
))
8553 /* Read from a file */
8554 file
= x_find_image_file (specified_file
);
8555 if (!STRINGP (file
))
8557 image_error ("Cannot find image file `%s'", file
, Qnil
);
8562 /* Try to open the image file. */
8563 tiff
= TIFFOpen (SDATA (file
), "r");
8566 image_error ("Cannot open `%s'", file
, Qnil
);
8573 /* Memory source! */
8574 memsrc
.bytes
= SDATA (specified_data
);
8575 memsrc
.len
= SBYTES (specified_data
);
8578 tiff
= TIFFClientOpen ("memory_source", "r", &memsrc
,
8579 (TIFFReadWriteProc
) tiff_read_from_memory
,
8580 (TIFFReadWriteProc
) tiff_write_from_memory
,
8581 tiff_seek_in_memory
,
8583 tiff_size_of_memory
,
8589 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
8595 /* Get width and height of the image, and allocate a raster buffer
8596 of width x height 32-bit values. */
8597 TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
8598 TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
8599 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
8601 rc
= TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
8605 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
8611 /* Create the X image and pixmap. */
8612 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8619 /* Initialize the color table. */
8620 init_color_table ();
8622 /* Process the pixel raster. Origin is in the lower-left corner. */
8623 for (y
= 0; y
< height
; ++y
)
8625 uint32
*row
= buf
+ y
* width
;
8627 for (x
= 0; x
< width
; ++x
)
8629 uint32 abgr
= row
[x
];
8630 int r
= TIFFGetR (abgr
) << 8;
8631 int g
= TIFFGetG (abgr
) << 8;
8632 int b
= TIFFGetB (abgr
) << 8;
8633 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
8637 /* Remember the colors allocated for the image. Free the color table. */
8638 img
->colors
= colors_in_color_table (&img
->ncolors
);
8639 free_color_table ();
8642 img
->height
= height
;
8644 /* Maybe fill in the background field while we have ximg handy. */
8645 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8646 IMAGE_BACKGROUND (img
, f
, ximg
);
8648 /* Put the image into the pixmap, then free the X image and its buffer. */
8649 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8650 x_destroy_x_image (ximg
);
8657 #endif /* HAVE_TIFF != 0 */
8661 /***********************************************************************
8663 ***********************************************************************/
8667 #include <gif_lib.h>
8669 static int gif_image_p
P_ ((Lisp_Object object
));
8670 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
8672 /* The symbol `gif' identifying images of this type. */
8676 /* Indices of image specification fields in gif_format, below. */
8678 enum gif_keyword_index
8694 /* Vector of image_keyword structures describing the format
8695 of valid user-defined image specifications. */
8697 static struct image_keyword gif_format
[GIF_LAST
] =
8699 {":type", IMAGE_SYMBOL_VALUE
, 1},
8700 {":data", IMAGE_STRING_VALUE
, 0},
8701 {":file", IMAGE_STRING_VALUE
, 0},
8702 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8703 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8704 {":relief", IMAGE_INTEGER_VALUE
, 0},
8705 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8706 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8707 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8708 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
8709 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8712 /* Structure describing the image type `gif'. */
8714 static struct image_type gif_type
=
8724 /* Return non-zero if OBJECT is a valid GIF image specification. */
8727 gif_image_p (object
)
8730 struct image_keyword fmt
[GIF_LAST
];
8731 bcopy (gif_format
, fmt
, sizeof fmt
);
8733 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
8736 /* Must specify either the :data or :file keyword. */
8737 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
8741 /* Reading a GIF image from memory
8742 Based on the PNG memory stuff to a certain extent. */
8746 unsigned char *bytes
;
8753 /* Make the current memory source available to gif_read_from_memory.
8754 It's done this way because not all versions of libungif support
8755 a UserData field in the GifFileType structure. */
8756 static gif_memory_source
*current_gif_memory_src
;
8759 gif_read_from_memory (file
, buf
, len
)
8764 gif_memory_source
*src
= current_gif_memory_src
;
8766 if (len
> src
->len
- src
->index
)
8769 bcopy (src
->bytes
+ src
->index
, buf
, len
);
8775 /* Load GIF image IMG for use on frame F. Value is non-zero if
8783 Lisp_Object file
, specified_file
;
8784 Lisp_Object specified_data
;
8785 int rc
, width
, height
, x
, y
, i
;
8787 ColorMapObject
*gif_color_map
;
8788 unsigned long pixel_colors
[256];
8790 struct gcpro gcpro1
;
8792 int ino
, image_left
, image_top
, image_width
, image_height
;
8793 gif_memory_source memsrc
;
8794 unsigned char *raster
;
8796 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
8797 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8801 if (NILP (specified_data
))
8803 file
= x_find_image_file (specified_file
);
8804 if (!STRINGP (file
))
8806 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
8811 /* Open the GIF file. */
8812 gif
= DGifOpenFileName (SDATA (file
));
8815 image_error ("Cannot open `%s'", file
, Qnil
);
8822 /* Read from memory! */
8823 current_gif_memory_src
= &memsrc
;
8824 memsrc
.bytes
= SDATA (specified_data
);
8825 memsrc
.len
= SBYTES (specified_data
);
8828 gif
= DGifOpen(&memsrc
, gif_read_from_memory
);
8831 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
8837 /* Read entire contents. */
8838 rc
= DGifSlurp (gif
);
8839 if (rc
== GIF_ERROR
)
8841 image_error ("Error reading `%s'", img
->spec
, Qnil
);
8842 DGifCloseFile (gif
);
8847 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
8848 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
8849 if (ino
>= gif
->ImageCount
)
8851 image_error ("Invalid image number `%s' in image `%s'",
8853 DGifCloseFile (gif
);
8858 width
= img
->width
= max (gif
->SWidth
, gif
->Image
.Left
+ gif
->Image
.Width
);
8859 height
= img
->height
= max (gif
->SHeight
, gif
->Image
.Top
+ gif
->Image
.Height
);
8861 /* Create the X image and pixmap. */
8862 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8864 DGifCloseFile (gif
);
8869 /* Allocate colors. */
8870 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
8872 gif_color_map
= gif
->SColorMap
;
8873 init_color_table ();
8874 bzero (pixel_colors
, sizeof pixel_colors
);
8876 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
8878 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
8879 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
8880 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
8881 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
8884 img
->colors
= colors_in_color_table (&img
->ncolors
);
8885 free_color_table ();
8887 /* Clear the part of the screen image that are not covered by
8888 the image from the GIF file. Full animated GIF support
8889 requires more than can be done here (see the gif89 spec,
8890 disposal methods). Let's simply assume that the part
8891 not covered by a sub-image is in the frame's background color. */
8892 image_top
= gif
->SavedImages
[ino
].ImageDesc
.Top
;
8893 image_left
= gif
->SavedImages
[ino
].ImageDesc
.Left
;
8894 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
8895 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
8897 for (y
= 0; y
< image_top
; ++y
)
8898 for (x
= 0; x
< width
; ++x
)
8899 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
8901 for (y
= image_top
+ image_height
; y
< height
; ++y
)
8902 for (x
= 0; x
< width
; ++x
)
8903 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
8905 for (y
= image_top
; y
< image_top
+ image_height
; ++y
)
8907 for (x
= 0; x
< image_left
; ++x
)
8908 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
8909 for (x
= image_left
+ image_width
; x
< width
; ++x
)
8910 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
8913 /* Read the GIF image into the X image. We use a local variable
8914 `raster' here because RasterBits below is a char *, and invites
8915 problems with bytes >= 0x80. */
8916 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
8918 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
8920 static int interlace_start
[] = {0, 4, 2, 1};
8921 static int interlace_increment
[] = {8, 8, 4, 2};
8923 int row
= interlace_start
[0];
8927 for (y
= 0; y
< image_height
; y
++)
8929 if (row
>= image_height
)
8931 row
= interlace_start
[++pass
];
8932 while (row
>= image_height
)
8933 row
= interlace_start
[++pass
];
8936 for (x
= 0; x
< image_width
; x
++)
8938 int i
= raster
[(y
* image_width
) + x
];
8939 XPutPixel (ximg
, x
+ image_left
, row
+ image_top
,
8943 row
+= interlace_increment
[pass
];
8948 for (y
= 0; y
< image_height
; ++y
)
8949 for (x
= 0; x
< image_width
; ++x
)
8951 int i
= raster
[y
* image_width
+ x
];
8952 XPutPixel (ximg
, x
+ image_left
, y
+ image_top
, pixel_colors
[i
]);
8956 DGifCloseFile (gif
);
8958 /* Maybe fill in the background field while we have ximg handy. */
8959 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8960 IMAGE_BACKGROUND (img
, f
, ximg
);
8962 /* Put the image into the pixmap, then free the X image and its buffer. */
8963 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8964 x_destroy_x_image (ximg
);
8970 #endif /* HAVE_GIF != 0 */
8974 /***********************************************************************
8976 ***********************************************************************/
8978 static int gs_image_p
P_ ((Lisp_Object object
));
8979 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
8980 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
8982 /* The symbol `postscript' identifying images of this type. */
8984 Lisp_Object Qpostscript
;
8986 /* Keyword symbols. */
8988 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
8990 /* Indices of image specification fields in gs_format, below. */
8992 enum gs_keyword_index
9010 /* Vector of image_keyword structures describing the format
9011 of valid user-defined image specifications. */
9013 static struct image_keyword gs_format
[GS_LAST
] =
9015 {":type", IMAGE_SYMBOL_VALUE
, 1},
9016 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
9017 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
9018 {":file", IMAGE_STRING_VALUE
, 1},
9019 {":loader", IMAGE_FUNCTION_VALUE
, 0},
9020 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
9021 {":ascent", IMAGE_ASCENT_VALUE
, 0},
9022 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
9023 {":relief", IMAGE_INTEGER_VALUE
, 0},
9024 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9025 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9026 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9027 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
9030 /* Structure describing the image type `ghostscript'. */
9032 static struct image_type gs_type
=
9042 /* Free X resources of Ghostscript image IMG which is used on frame F. */
9045 gs_clear_image (f
, img
)
9049 /* IMG->data.ptr_val may contain a recorded colormap. */
9050 xfree (img
->data
.ptr_val
);
9051 x_clear_image (f
, img
);
9055 /* Return non-zero if OBJECT is a valid Ghostscript image
9062 struct image_keyword fmt
[GS_LAST
];
9066 bcopy (gs_format
, fmt
, sizeof fmt
);
9068 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
9071 /* Bounding box must be a list or vector containing 4 integers. */
9072 tem
= fmt
[GS_BOUNDING_BOX
].value
;
9075 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
9076 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
9081 else if (VECTORP (tem
))
9083 if (XVECTOR (tem
)->size
!= 4)
9085 for (i
= 0; i
< 4; ++i
)
9086 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
9096 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
9105 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
9106 struct gcpro gcpro1
, gcpro2
;
9108 double in_width
, in_height
;
9109 Lisp_Object pixel_colors
= Qnil
;
9111 /* Compute pixel size of pixmap needed from the given size in the
9112 image specification. Sizes in the specification are in pt. 1 pt
9113 = 1/72 in, xdpi and ydpi are stored in the frame's X display
9115 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
9116 in_width
= XFASTINT (pt_width
) / 72.0;
9117 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
9118 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
9119 in_height
= XFASTINT (pt_height
) / 72.0;
9120 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
9122 /* Create the pixmap. */
9123 xassert (img
->pixmap
== None
);
9124 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9125 img
->width
, img
->height
,
9126 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
9130 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
9134 /* Call the loader to fill the pixmap. It returns a process object
9135 if successful. We do not record_unwind_protect here because
9136 other places in redisplay like calling window scroll functions
9137 don't either. Let the Lisp loader use `unwind-protect' instead. */
9138 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
9140 sprintf (buffer
, "%lu %lu",
9141 (unsigned long) FRAME_X_WINDOW (f
),
9142 (unsigned long) img
->pixmap
);
9143 window_and_pixmap_id
= build_string (buffer
);
9145 sprintf (buffer
, "%lu %lu",
9146 FRAME_FOREGROUND_PIXEL (f
),
9147 FRAME_BACKGROUND_PIXEL (f
));
9148 pixel_colors
= build_string (buffer
);
9150 XSETFRAME (frame
, f
);
9151 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
9153 loader
= intern ("gs-load-image");
9155 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
9156 make_number (img
->width
),
9157 make_number (img
->height
),
9158 window_and_pixmap_id
,
9161 return PROCESSP (img
->data
.lisp_val
);
9165 /* Kill the Ghostscript process that was started to fill PIXMAP on
9166 frame F. Called from XTread_socket when receiving an event
9167 telling Emacs that Ghostscript has finished drawing. */
9170 x_kill_gs_process (pixmap
, f
)
9174 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
9178 /* Find the image containing PIXMAP. */
9179 for (i
= 0; i
< c
->used
; ++i
)
9180 if (c
->images
[i
]->pixmap
== pixmap
)
9183 /* Should someone in between have cleared the image cache, for
9184 instance, give up. */
9188 /* Kill the GS process. We should have found PIXMAP in the image
9189 cache and its image should contain a process object. */
9191 xassert (PROCESSP (img
->data
.lisp_val
));
9192 Fkill_process (img
->data
.lisp_val
, Qnil
);
9193 img
->data
.lisp_val
= Qnil
;
9195 /* On displays with a mutable colormap, figure out the colors
9196 allocated for the image by looking at the pixels of an XImage for
9198 class = FRAME_X_VISUAL (f
)->class;
9199 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
9205 /* Try to get an XImage for img->pixmep. */
9206 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
9207 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
9212 /* Initialize the color table. */
9213 init_color_table ();
9215 /* For each pixel of the image, look its color up in the
9216 color table. After having done so, the color table will
9217 contain an entry for each color used by the image. */
9218 for (y
= 0; y
< img
->height
; ++y
)
9219 for (x
= 0; x
< img
->width
; ++x
)
9221 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
9222 lookup_pixel_color (f
, pixel
);
9225 /* Record colors in the image. Free color table and XImage. */
9226 img
->colors
= colors_in_color_table (&img
->ncolors
);
9227 free_color_table ();
9228 XDestroyImage (ximg
);
9230 #if 0 /* This doesn't seem to be the case. If we free the colors
9231 here, we get a BadAccess later in x_clear_image when
9232 freeing the colors. */
9233 /* We have allocated colors once, but Ghostscript has also
9234 allocated colors on behalf of us. So, to get the
9235 reference counts right, free them once. */
9237 x_free_colors (f
, img
->colors
, img
->ncolors
);
9241 image_error ("Cannot get X image of `%s'; colors will not be freed",
9247 /* Now that we have the pixmap, compute mask and transform the
9248 image if requested. */
9250 postprocess_image (f
, img
);
9256 /***********************************************************************
9258 ***********************************************************************/
9260 DEFUN ("x-change-window-property", Fx_change_window_property
,
9261 Sx_change_window_property
, 2, 3, 0,
9262 doc
: /* Change window property PROP to VALUE on the X window of FRAME.
9263 PROP and VALUE must be strings. FRAME nil or omitted means use the
9264 selected frame. Value is VALUE. */)
9265 (prop
, value
, frame
)
9266 Lisp_Object frame
, prop
, value
;
9268 struct frame
*f
= check_x_frame (frame
);
9271 CHECK_STRING (prop
);
9272 CHECK_STRING (value
);
9275 prop_atom
= XInternAtom (FRAME_X_DISPLAY (f
), SDATA (prop
), False
);
9276 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9277 prop_atom
, XA_STRING
, 8, PropModeReplace
,
9278 SDATA (value
), SCHARS (value
));
9280 /* Make sure the property is set when we return. */
9281 XFlush (FRAME_X_DISPLAY (f
));
9288 DEFUN ("x-delete-window-property", Fx_delete_window_property
,
9289 Sx_delete_window_property
, 1, 2, 0,
9290 doc
: /* Remove window property PROP from X window of FRAME.
9291 FRAME nil or omitted means use the selected frame. Value is PROP. */)
9293 Lisp_Object prop
, frame
;
9295 struct frame
*f
= check_x_frame (frame
);
9298 CHECK_STRING (prop
);
9300 prop_atom
= XInternAtom (FRAME_X_DISPLAY (f
), SDATA (prop
), False
);
9301 XDeleteProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), prop_atom
);
9303 /* Make sure the property is removed when we return. */
9304 XFlush (FRAME_X_DISPLAY (f
));
9311 DEFUN ("x-window-property", Fx_window_property
, Sx_window_property
,
9313 doc
: /* Value is the value of window property PROP on FRAME.
9314 If FRAME is nil or omitted, use the selected frame. Value is nil
9315 if FRAME hasn't a property with name PROP or if PROP has no string
9318 Lisp_Object prop
, frame
;
9320 struct frame
*f
= check_x_frame (frame
);
9323 Lisp_Object prop_value
= Qnil
;
9324 char *tmp_data
= NULL
;
9327 unsigned long actual_size
, bytes_remaining
;
9329 CHECK_STRING (prop
);
9331 prop_atom
= XInternAtom (FRAME_X_DISPLAY (f
), SDATA (prop
), False
);
9332 rc
= XGetWindowProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9333 prop_atom
, 0, 0, False
, XA_STRING
,
9334 &actual_type
, &actual_format
, &actual_size
,
9335 &bytes_remaining
, (unsigned char **) &tmp_data
);
9338 int size
= bytes_remaining
;
9343 rc
= XGetWindowProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9344 prop_atom
, 0, bytes_remaining
,
9346 &actual_type
, &actual_format
,
9347 &actual_size
, &bytes_remaining
,
9348 (unsigned char **) &tmp_data
);
9349 if (rc
== Success
&& tmp_data
)
9350 prop_value
= make_string (tmp_data
, size
);
9361 /***********************************************************************
9363 ***********************************************************************/
9365 /* If non-null, an asynchronous timer that, when it expires, displays
9366 an hourglass cursor on all frames. */
9368 static struct atimer
*hourglass_atimer
;
9370 /* Non-zero means an hourglass cursor is currently shown. */
9372 static int hourglass_shown_p
;
9374 /* Number of seconds to wait before displaying an hourglass cursor. */
9376 static Lisp_Object Vhourglass_delay
;
9378 /* Default number of seconds to wait before displaying an hourglass
9381 #define DEFAULT_HOURGLASS_DELAY 1
9383 /* Function prototypes. */
9385 static void show_hourglass
P_ ((struct atimer
*));
9386 static void hide_hourglass
P_ ((void));
9389 /* Cancel a currently active hourglass timer, and start a new one. */
9395 int secs
, usecs
= 0;
9397 cancel_hourglass ();
9399 if (INTEGERP (Vhourglass_delay
)
9400 && XINT (Vhourglass_delay
) > 0)
9401 secs
= XFASTINT (Vhourglass_delay
);
9402 else if (FLOATP (Vhourglass_delay
)
9403 && XFLOAT_DATA (Vhourglass_delay
) > 0)
9406 tem
= Ftruncate (Vhourglass_delay
, Qnil
);
9407 secs
= XFASTINT (tem
);
9408 usecs
= (XFLOAT_DATA (Vhourglass_delay
) - secs
) * 1000000;
9411 secs
= DEFAULT_HOURGLASS_DELAY
;
9413 EMACS_SET_SECS_USECS (delay
, secs
, usecs
);
9414 hourglass_atimer
= start_atimer (ATIMER_RELATIVE
, delay
,
9415 show_hourglass
, NULL
);
9419 /* Cancel the hourglass cursor timer if active, hide a busy cursor if
9425 if (hourglass_atimer
)
9427 cancel_atimer (hourglass_atimer
);
9428 hourglass_atimer
= NULL
;
9431 if (hourglass_shown_p
)
9436 /* Timer function of hourglass_atimer. TIMER is equal to
9439 Display an hourglass pointer on all frames by mapping the frames'
9440 hourglass_window. Set the hourglass_p flag in the frames'
9441 output_data.x structure to indicate that an hourglass cursor is
9442 shown on the frames. */
9445 show_hourglass (timer
)
9446 struct atimer
*timer
;
9448 /* The timer implementation will cancel this timer automatically
9449 after this function has run. Set hourglass_atimer to null
9450 so that we know the timer doesn't have to be canceled. */
9451 hourglass_atimer
= NULL
;
9453 if (!hourglass_shown_p
)
9455 Lisp_Object rest
, frame
;
9459 FOR_EACH_FRAME (rest
, frame
)
9461 struct frame
*f
= XFRAME (frame
);
9463 if (FRAME_LIVE_P (f
) && FRAME_X_P (f
) && FRAME_X_DISPLAY (f
))
9465 Display
*dpy
= FRAME_X_DISPLAY (f
);
9467 #ifdef USE_X_TOOLKIT
9468 if (f
->output_data
.x
->widget
)
9470 if (FRAME_OUTER_WINDOW (f
))
9473 f
->output_data
.x
->hourglass_p
= 1;
9475 if (!f
->output_data
.x
->hourglass_window
)
9477 unsigned long mask
= CWCursor
;
9478 XSetWindowAttributes attrs
;
9480 attrs
.cursor
= f
->output_data
.x
->hourglass_cursor
;
9482 f
->output_data
.x
->hourglass_window
9483 = XCreateWindow (dpy
, FRAME_OUTER_WINDOW (f
),
9484 0, 0, 32000, 32000, 0, 0,
9490 XMapRaised (dpy
, f
->output_data
.x
->hourglass_window
);
9496 hourglass_shown_p
= 1;
9502 /* Hide the hourglass pointer on all frames, if it is currently
9508 if (hourglass_shown_p
)
9510 Lisp_Object rest
, frame
;
9513 FOR_EACH_FRAME (rest
, frame
)
9515 struct frame
*f
= XFRAME (frame
);
9518 /* Watch out for newly created frames. */
9519 && f
->output_data
.x
->hourglass_window
)
9521 XUnmapWindow (FRAME_X_DISPLAY (f
),
9522 f
->output_data
.x
->hourglass_window
);
9523 /* Sync here because XTread_socket looks at the
9524 hourglass_p flag that is reset to zero below. */
9525 XSync (FRAME_X_DISPLAY (f
), False
);
9526 f
->output_data
.x
->hourglass_p
= 0;
9530 hourglass_shown_p
= 0;
9537 /***********************************************************************
9539 ***********************************************************************/
9541 static Lisp_Object x_create_tip_frame
P_ ((struct x_display_info
*,
9542 Lisp_Object
, Lisp_Object
));
9543 static void compute_tip_xy
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
,
9544 Lisp_Object
, int, int, int *, int *));
9546 /* The frame of a currently visible tooltip. */
9548 Lisp_Object tip_frame
;
9550 /* If non-nil, a timer started that hides the last tooltip when it
9553 Lisp_Object tip_timer
;
9556 /* If non-nil, a vector of 3 elements containing the last args
9557 with which x-show-tip was called. See there. */
9559 Lisp_Object last_show_tip_args
;
9561 /* Maximum size for tooltips; a cons (COLUMNS . ROWS). */
9563 Lisp_Object Vx_max_tooltip_size
;
9567 unwind_create_tip_frame (frame
)
9570 Lisp_Object deleted
;
9572 deleted
= unwind_create_frame (frame
);
9573 if (EQ (deleted
, Qt
))
9583 /* Create a frame for a tooltip on the display described by DPYINFO.
9584 PARMS is a list of frame parameters. TEXT is the string to
9585 display in the tip frame. Value is the frame.
9587 Note that functions called here, esp. x_default_parameter can
9588 signal errors, for instance when a specified color name is
9589 undefined. We have to make sure that we're in a consistent state
9590 when this happens. */
9593 x_create_tip_frame (dpyinfo
, parms
, text
)
9594 struct x_display_info
*dpyinfo
;
9595 Lisp_Object parms
, text
;
9598 Lisp_Object frame
, tem
;
9600 long window_prompting
= 0;
9602 int count
= SPECPDL_INDEX ();
9603 struct gcpro gcpro1
, gcpro2
, gcpro3
;
9605 int face_change_count_before
= face_change_count
;
9607 struct buffer
*old_buffer
;
9611 /* Use this general default value to start with until we know if
9612 this frame has a specified name. */
9613 Vx_resource_name
= Vinvocation_name
;
9616 kb
= dpyinfo
->kboard
;
9618 kb
= &the_only_kboard
;
9621 /* Get the name of the frame to use for resource lookup. */
9622 name
= x_get_arg (dpyinfo
, parms
, Qname
, "name", "Name", RES_TYPE_STRING
);
9624 && !EQ (name
, Qunbound
)
9626 error ("Invalid frame name--not a string or nil");
9627 Vx_resource_name
= name
;
9630 GCPRO3 (parms
, name
, frame
);
9632 XSETFRAME (frame
, f
);
9634 buffer
= Fget_buffer_create (build_string (" *tip*"));
9635 Fset_window_buffer (FRAME_ROOT_WINDOW (f
), buffer
);
9636 old_buffer
= current_buffer
;
9637 set_buffer_internal_1 (XBUFFER (buffer
));
9638 current_buffer
->truncate_lines
= Qnil
;
9641 set_buffer_internal_1 (old_buffer
);
9643 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 0;
9644 record_unwind_protect (unwind_create_tip_frame
, frame
);
9646 /* By setting the output method, we're essentially saying that
9647 the frame is live, as per FRAME_LIVE_P. If we get a signal
9648 from this point on, x_destroy_window might screw up reference
9650 f
->output_method
= output_x_window
;
9651 f
->output_data
.x
= (struct x_output
*) xmalloc (sizeof (struct x_output
));
9652 bzero (f
->output_data
.x
, sizeof (struct x_output
));
9653 f
->output_data
.x
->icon_bitmap
= -1;
9654 f
->output_data
.x
->fontset
= -1;
9655 f
->output_data
.x
->scroll_bar_foreground_pixel
= -1;
9656 f
->output_data
.x
->scroll_bar_background_pixel
= -1;
9657 #ifdef USE_TOOLKIT_SCROLL_BARS
9658 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= -1;
9659 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= -1;
9660 #endif /* USE_TOOLKIT_SCROLL_BARS */
9661 f
->icon_name
= Qnil
;
9662 FRAME_X_DISPLAY_INFO (f
) = dpyinfo
;
9664 image_cache_refcount
= FRAME_X_IMAGE_CACHE (f
)->refcount
;
9665 dpyinfo_refcount
= dpyinfo
->reference_count
;
9666 #endif /* GLYPH_DEBUG */
9668 FRAME_KBOARD (f
) = kb
;
9670 f
->output_data
.x
->parent_desc
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
9671 f
->output_data
.x
->explicit_parent
= 0;
9673 /* These colors will be set anyway later, but it's important
9674 to get the color reference counts right, so initialize them! */
9677 struct gcpro gcpro1
;
9679 black
= build_string ("black");
9681 f
->output_data
.x
->foreground_pixel
9682 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
9683 f
->output_data
.x
->background_pixel
9684 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
9685 f
->output_data
.x
->cursor_pixel
9686 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
9687 f
->output_data
.x
->cursor_foreground_pixel
9688 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
9689 f
->output_data
.x
->border_pixel
9690 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
9691 f
->output_data
.x
->mouse_pixel
9692 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
9696 /* Set the name; the functions to which we pass f expect the name to
9698 if (EQ (name
, Qunbound
) || NILP (name
))
9700 f
->name
= build_string (dpyinfo
->x_id_name
);
9701 f
->explicit_name
= 0;
9706 f
->explicit_name
= 1;
9707 /* use the frame's title when getting resources for this frame. */
9708 specbind (Qx_resource_name
, name
);
9711 /* Extract the window parameters from the supplied values that are
9712 needed to determine window geometry. */
9716 font
= x_get_arg (dpyinfo
, parms
, Qfont
, "font", "Font", RES_TYPE_STRING
);
9719 /* First, try whatever font the caller has specified. */
9722 tem
= Fquery_fontset (font
, Qnil
);
9724 font
= x_new_fontset (f
, SDATA (tem
));
9726 font
= x_new_font (f
, SDATA (font
));
9729 /* Try out a font which we hope has bold and italic variations. */
9730 if (!STRINGP (font
))
9731 font
= x_new_font (f
, "-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1");
9732 if (!STRINGP (font
))
9733 font
= x_new_font (f
, "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
9734 if (! STRINGP (font
))
9735 font
= x_new_font (f
, "-*-*-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
9736 if (! STRINGP (font
))
9737 /* This was formerly the first thing tried, but it finds too many fonts
9738 and takes too long. */
9739 font
= x_new_font (f
, "-*-*-medium-r-*-*-*-*-*-*-c-*-iso8859-1");
9740 /* If those didn't work, look for something which will at least work. */
9741 if (! STRINGP (font
))
9742 font
= x_new_font (f
, "-*-fixed-*-*-*-*-*-140-*-*-c-*-iso8859-1");
9744 if (! STRINGP (font
))
9745 font
= build_string ("fixed");
9747 x_default_parameter (f
, parms
, Qfont
, font
,
9748 "font", "Font", RES_TYPE_STRING
);
9751 x_default_parameter (f
, parms
, Qborder_width
, make_number (2),
9752 "borderWidth", "BorderWidth", RES_TYPE_NUMBER
);
9754 /* This defaults to 2 in order to match xterm. We recognize either
9755 internalBorderWidth or internalBorder (which is what xterm calls
9757 if (NILP (Fassq (Qinternal_border_width
, parms
)))
9761 value
= x_get_arg (dpyinfo
, parms
, Qinternal_border_width
,
9762 "internalBorder", "internalBorder", RES_TYPE_NUMBER
);
9763 if (! EQ (value
, Qunbound
))
9764 parms
= Fcons (Fcons (Qinternal_border_width
, value
),
9768 x_default_parameter (f
, parms
, Qinternal_border_width
, make_number (1),
9769 "internalBorderWidth", "internalBorderWidth",
9772 /* Also do the stuff which must be set before the window exists. */
9773 x_default_parameter (f
, parms
, Qforeground_color
, build_string ("black"),
9774 "foreground", "Foreground", RES_TYPE_STRING
);
9775 x_default_parameter (f
, parms
, Qbackground_color
, build_string ("white"),
9776 "background", "Background", RES_TYPE_STRING
);
9777 x_default_parameter (f
, parms
, Qmouse_color
, build_string ("black"),
9778 "pointerColor", "Foreground", RES_TYPE_STRING
);
9779 x_default_parameter (f
, parms
, Qcursor_color
, build_string ("black"),
9780 "cursorColor", "Foreground", RES_TYPE_STRING
);
9781 x_default_parameter (f
, parms
, Qborder_color
, build_string ("black"),
9782 "borderColor", "BorderColor", RES_TYPE_STRING
);
9784 /* Init faces before x_default_parameter is called for scroll-bar
9785 parameters because that function calls x_set_scroll_bar_width,
9786 which calls change_frame_size, which calls Fset_window_buffer,
9787 which runs hooks, which call Fvertical_motion. At the end, we
9788 end up in init_iterator with a null face cache, which should not
9790 init_frame_faces (f
);
9792 f
->output_data
.x
->parent_desc
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
9794 window_prompting
= x_figure_window_size (f
, parms
, 0);
9797 XSetWindowAttributes attrs
;
9801 mask
= CWBackPixel
| CWOverrideRedirect
| CWEventMask
;
9802 if (DoesSaveUnders (dpyinfo
->screen
))
9803 mask
|= CWSaveUnder
;
9805 /* Window managers look at the override-redirect flag to determine
9806 whether or net to give windows a decoration (Xlib spec, chapter
9808 attrs
.override_redirect
= True
;
9809 attrs
.save_under
= True
;
9810 attrs
.background_pixel
= FRAME_BACKGROUND_PIXEL (f
);
9811 /* Arrange for getting MapNotify and UnmapNotify events. */
9812 attrs
.event_mask
= StructureNotifyMask
;
9814 = FRAME_X_WINDOW (f
)
9815 = XCreateWindow (FRAME_X_DISPLAY (f
),
9816 FRAME_X_DISPLAY_INFO (f
)->root_window
,
9817 /* x, y, width, height */
9821 CopyFromParent
, InputOutput
, CopyFromParent
,
9828 x_default_parameter (f
, parms
, Qauto_raise
, Qnil
,
9829 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
9830 x_default_parameter (f
, parms
, Qauto_lower
, Qnil
,
9831 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
9832 x_default_parameter (f
, parms
, Qcursor_type
, Qbox
,
9833 "cursorType", "CursorType", RES_TYPE_SYMBOL
);
9835 /* Dimensions, especially f->height, must be done via change_frame_size.
9836 Change will not be effected unless different from the current
9841 SET_FRAME_WIDTH (f
, 0);
9842 change_frame_size (f
, height
, width
, 1, 0, 0);
9844 /* Add `tooltip' frame parameter's default value. */
9845 if (NILP (Fframe_parameter (frame
, intern ("tooltip"))))
9846 Fmodify_frame_parameters (frame
, Fcons (Fcons (intern ("tooltip"), Qt
),
9849 /* Set up faces after all frame parameters are known. This call
9850 also merges in face attributes specified for new frames.
9852 Frame parameters may be changed if .Xdefaults contains
9853 specifications for the default font. For example, if there is an
9854 `Emacs.default.attributeBackground: pink', the `background-color'
9855 attribute of the frame get's set, which let's the internal border
9856 of the tooltip frame appear in pink. Prevent this. */
9858 Lisp_Object bg
= Fframe_parameter (frame
, Qbackground_color
);
9860 /* Set tip_frame here, so that */
9862 call1 (Qface_set_after_frame_default
, frame
);
9864 if (!EQ (bg
, Fframe_parameter (frame
, Qbackground_color
)))
9865 Fmodify_frame_parameters (frame
, Fcons (Fcons (Qbackground_color
, bg
),
9873 /* It is now ok to make the frame official even if we get an error
9874 below. And the frame needs to be on Vframe_list or making it
9875 visible won't work. */
9876 Vframe_list
= Fcons (frame
, Vframe_list
);
9878 /* Now that the frame is official, it counts as a reference to
9880 FRAME_X_DISPLAY_INFO (f
)->reference_count
++;
9882 /* Setting attributes of faces of the tooltip frame from resources
9883 and similar will increment face_change_count, which leads to the
9884 clearing of all current matrices. Since this isn't necessary
9885 here, avoid it by resetting face_change_count to the value it
9886 had before we created the tip frame. */
9887 face_change_count
= face_change_count_before
;
9889 /* Discard the unwind_protect. */
9890 return unbind_to (count
, frame
);
9894 /* Compute where to display tip frame F. PARMS is the list of frame
9895 parameters for F. DX and DY are specified offsets from the current
9896 location of the mouse. WIDTH and HEIGHT are the width and height
9897 of the tooltip. Return coordinates relative to the root window of
9898 the display in *ROOT_X, and *ROOT_Y. */
9901 compute_tip_xy (f
, parms
, dx
, dy
, width
, height
, root_x
, root_y
)
9903 Lisp_Object parms
, dx
, dy
;
9905 int *root_x
, *root_y
;
9907 Lisp_Object left
, top
;
9912 /* User-specified position? */
9913 left
= Fcdr (Fassq (Qleft
, parms
));
9914 top
= Fcdr (Fassq (Qtop
, parms
));
9916 /* Move the tooltip window where the mouse pointer is. Resize and
9918 if (!INTEGERP (left
) || !INTEGERP (top
))
9921 XQueryPointer (FRAME_X_DISPLAY (f
), FRAME_X_DISPLAY_INFO (f
)->root_window
,
9922 &root
, &child
, root_x
, root_y
, &win_x
, &win_y
, &pmask
);
9927 *root_y
= XINT (top
);
9928 else if (*root_y
+ XINT (dy
) - height
< 0)
9929 *root_y
-= XINT (dy
);
9933 *root_y
+= XINT (dy
);
9936 if (INTEGERP (left
))
9937 *root_x
= XINT (left
);
9938 else if (*root_x
+ XINT (dx
) + width
<= FRAME_X_DISPLAY_INFO (f
)->width
)
9939 /* It fits to the right of the pointer. */
9940 *root_x
+= XINT (dx
);
9941 else if (width
+ XINT (dx
) <= *root_x
)
9942 /* It fits to the left of the pointer. */
9943 *root_x
-= width
+ XINT (dx
);
9945 /* Put it left-justified on the screen--it ought to fit that way. */
9950 DEFUN ("x-show-tip", Fx_show_tip
, Sx_show_tip
, 1, 6, 0,
9951 doc
: /* Show STRING in a "tooltip" window on frame FRAME.
9952 A tooltip window is a small X window displaying a string.
9954 FRAME nil or omitted means use the selected frame.
9956 PARMS is an optional list of frame parameters which can be used to
9957 change the tooltip's appearance.
9959 Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
9960 means use the default timeout of 5 seconds.
9962 If the list of frame parameters PARAMS contains a `left' parameters,
9963 the tooltip is displayed at that x-position. Otherwise it is
9964 displayed at the mouse position, with offset DX added (default is 5 if
9965 DX isn't specified). Likewise for the y-position; if a `top' frame
9966 parameter is specified, it determines the y-position of the tooltip
9967 window, otherwise it is displayed at the mouse position, with offset
9968 DY added (default is -10).
9970 A tooltip's maximum size is specified by `x-max-tooltip-size'.
9971 Text larger than the specified size is clipped. */)
9972 (string
, frame
, parms
, timeout
, dx
, dy
)
9973 Lisp_Object string
, frame
, parms
, timeout
, dx
, dy
;
9978 struct buffer
*old_buffer
;
9979 struct text_pos pos
;
9980 int i
, width
, height
;
9981 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
9982 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
9983 int count
= SPECPDL_INDEX ();
9985 specbind (Qinhibit_redisplay
, Qt
);
9987 GCPRO4 (string
, parms
, frame
, timeout
);
9989 CHECK_STRING (string
);
9990 f
= check_x_frame (frame
);
9992 timeout
= make_number (5);
9994 CHECK_NATNUM (timeout
);
9997 dx
= make_number (5);
10002 dy
= make_number (-10);
10006 if (NILP (last_show_tip_args
))
10007 last_show_tip_args
= Fmake_vector (make_number (3), Qnil
);
10009 if (!NILP (tip_frame
))
10011 Lisp_Object last_string
= AREF (last_show_tip_args
, 0);
10012 Lisp_Object last_frame
= AREF (last_show_tip_args
, 1);
10013 Lisp_Object last_parms
= AREF (last_show_tip_args
, 2);
10015 if (EQ (frame
, last_frame
)
10016 && !NILP (Fequal (last_string
, string
))
10017 && !NILP (Fequal (last_parms
, parms
)))
10019 struct frame
*f
= XFRAME (tip_frame
);
10021 /* Only DX and DY have changed. */
10022 if (!NILP (tip_timer
))
10024 Lisp_Object timer
= tip_timer
;
10026 call1 (Qcancel_timer
, timer
);
10030 compute_tip_xy (f
, parms
, dx
, dy
, PIXEL_WIDTH (f
),
10031 PIXEL_HEIGHT (f
), &root_x
, &root_y
);
10032 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
10039 /* Hide a previous tip, if any. */
10042 ASET (last_show_tip_args
, 0, string
);
10043 ASET (last_show_tip_args
, 1, frame
);
10044 ASET (last_show_tip_args
, 2, parms
);
10046 /* Add default values to frame parameters. */
10047 if (NILP (Fassq (Qname
, parms
)))
10048 parms
= Fcons (Fcons (Qname
, build_string ("tooltip")), parms
);
10049 if (NILP (Fassq (Qinternal_border_width
, parms
)))
10050 parms
= Fcons (Fcons (Qinternal_border_width
, make_number (3)), parms
);
10051 if (NILP (Fassq (Qborder_width
, parms
)))
10052 parms
= Fcons (Fcons (Qborder_width
, make_number (1)), parms
);
10053 if (NILP (Fassq (Qborder_color
, parms
)))
10054 parms
= Fcons (Fcons (Qborder_color
, build_string ("lightyellow")), parms
);
10055 if (NILP (Fassq (Qbackground_color
, parms
)))
10056 parms
= Fcons (Fcons (Qbackground_color
, build_string ("lightyellow")),
10059 /* Create a frame for the tooltip, and record it in the global
10060 variable tip_frame. */
10061 frame
= x_create_tip_frame (FRAME_X_DISPLAY_INFO (f
), parms
, string
);
10062 f
= XFRAME (frame
);
10064 /* Set up the frame's root window. */
10065 w
= XWINDOW (FRAME_ROOT_WINDOW (f
));
10066 w
->left
= w
->top
= make_number (0);
10068 if (CONSP (Vx_max_tooltip_size
)
10069 && INTEGERP (XCAR (Vx_max_tooltip_size
))
10070 && XINT (XCAR (Vx_max_tooltip_size
)) > 0
10071 && INTEGERP (XCDR (Vx_max_tooltip_size
))
10072 && XINT (XCDR (Vx_max_tooltip_size
)) > 0)
10074 w
->width
= XCAR (Vx_max_tooltip_size
);
10075 w
->height
= XCDR (Vx_max_tooltip_size
);
10079 w
->width
= make_number (80);
10080 w
->height
= make_number (40);
10083 f
->window_width
= XINT (w
->width
);
10085 w
->pseudo_window_p
= 1;
10087 /* Display the tooltip text in a temporary buffer. */
10088 old_buffer
= current_buffer
;
10089 set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f
))->buffer
));
10090 current_buffer
->truncate_lines
= Qnil
;
10091 clear_glyph_matrix (w
->desired_matrix
);
10092 clear_glyph_matrix (w
->current_matrix
);
10093 SET_TEXT_POS (pos
, BEGV
, BEGV_BYTE
);
10094 try_window (FRAME_ROOT_WINDOW (f
), pos
);
10096 /* Compute width and height of the tooltip. */
10097 width
= height
= 0;
10098 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
10100 struct glyph_row
*row
= &w
->desired_matrix
->rows
[i
];
10101 struct glyph
*last
;
10104 /* Stop at the first empty row at the end. */
10105 if (!row
->enabled_p
|| !row
->displays_text_p
)
10108 /* Let the row go over the full width of the frame. */
10109 row
->full_width_p
= 1;
10111 /* There's a glyph at the end of rows that is used to place
10112 the cursor there. Don't include the width of this glyph. */
10113 if (row
->used
[TEXT_AREA
])
10115 last
= &row
->glyphs
[TEXT_AREA
][row
->used
[TEXT_AREA
] - 1];
10116 row_width
= row
->pixel_width
- last
->pixel_width
;
10119 row_width
= row
->pixel_width
;
10121 height
+= row
->height
;
10122 width
= max (width
, row_width
);
10125 /* Add the frame's internal border to the width and height the X
10126 window should have. */
10127 height
+= 2 * FRAME_INTERNAL_BORDER_WIDTH (f
);
10128 width
+= 2 * FRAME_INTERNAL_BORDER_WIDTH (f
);
10130 /* Move the tooltip window where the mouse pointer is. Resize and
10132 compute_tip_xy (f
, parms
, dx
, dy
, width
, height
, &root_x
, &root_y
);
10135 XMoveResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
10136 root_x
, root_y
, width
, height
);
10137 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10140 /* Draw into the window. */
10141 w
->must_be_updated_p
= 1;
10142 update_single_window (w
, 1);
10144 /* Restore original current buffer. */
10145 set_buffer_internal_1 (old_buffer
);
10146 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
10149 /* Let the tip disappear after timeout seconds. */
10150 tip_timer
= call3 (intern ("run-at-time"), timeout
, Qnil
,
10151 intern ("x-hide-tip"));
10154 return unbind_to (count
, Qnil
);
10158 DEFUN ("x-hide-tip", Fx_hide_tip
, Sx_hide_tip
, 0, 0, 0,
10159 doc
: /* Hide the current tooltip window, if there is any.
10160 Value is t if tooltip was open, nil otherwise. */)
10164 Lisp_Object deleted
, frame
, timer
;
10165 struct gcpro gcpro1
, gcpro2
;
10167 /* Return quickly if nothing to do. */
10168 if (NILP (tip_timer
) && NILP (tip_frame
))
10173 GCPRO2 (frame
, timer
);
10174 tip_frame
= tip_timer
= deleted
= Qnil
;
10176 count
= SPECPDL_INDEX ();
10177 specbind (Qinhibit_redisplay
, Qt
);
10178 specbind (Qinhibit_quit
, Qt
);
10181 call1 (Qcancel_timer
, timer
);
10183 if (FRAMEP (frame
))
10185 Fdelete_frame (frame
, Qnil
);
10189 /* Bloodcurdling hack alert: The Lucid menu bar widget's
10190 redisplay procedure is not called when a tip frame over menu
10191 items is unmapped. Redisplay the menu manually... */
10193 struct frame
*f
= SELECTED_FRAME ();
10194 Widget w
= f
->output_data
.x
->menubar_widget
;
10195 extern void xlwmenu_redisplay
P_ ((Widget
));
10197 if (!DoesSaveUnders (FRAME_X_DISPLAY_INFO (f
)->screen
)
10201 xlwmenu_redisplay (w
);
10205 #endif /* USE_LUCID */
10209 return unbind_to (count
, deleted
);
10214 /***********************************************************************
10215 File selection dialog
10216 ***********************************************************************/
10220 /* Callback for "OK" and "Cancel" on file selection dialog. */
10223 file_dialog_cb (widget
, client_data
, call_data
)
10225 XtPointer call_data
, client_data
;
10227 int *result
= (int *) client_data
;
10228 XmAnyCallbackStruct
*cb
= (XmAnyCallbackStruct
*) call_data
;
10229 *result
= cb
->reason
;
10233 /* Callback for unmapping a file selection dialog. This is used to
10234 capture the case where a dialog is closed via a window manager's
10235 closer button, for example. Using a XmNdestroyCallback didn't work
10239 file_dialog_unmap_cb (widget
, client_data
, call_data
)
10241 XtPointer call_data
, client_data
;
10243 int *result
= (int *) client_data
;
10244 *result
= XmCR_CANCEL
;
10248 DEFUN ("x-file-dialog", Fx_file_dialog
, Sx_file_dialog
, 2, 4, 0,
10249 doc
: /* Read file name, prompting with PROMPT in directory DIR.
10250 Use a file selection dialog.
10251 Select DEFAULT-FILENAME in the dialog's file selection box, if
10252 specified. Don't let the user enter a file name in the file
10253 selection dialog's entry field, if MUSTMATCH is non-nil. */)
10254 (prompt
, dir
, default_filename
, mustmatch
)
10255 Lisp_Object prompt
, dir
, default_filename
, mustmatch
;
10258 struct frame
*f
= SELECTED_FRAME ();
10259 Lisp_Object file
= Qnil
;
10260 Widget dialog
, text
, list
, help
;
10263 extern XtAppContext Xt_app_con
;
10264 XmString dir_xmstring
, pattern_xmstring
;
10265 int count
= SPECPDL_INDEX ();
10266 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
10268 GCPRO5 (prompt
, dir
, default_filename
, mustmatch
, file
);
10269 CHECK_STRING (prompt
);
10270 CHECK_STRING (dir
);
10272 /* Prevent redisplay. */
10273 specbind (Qinhibit_redisplay
, Qt
);
10277 /* Create the dialog with PROMPT as title, using DIR as initial
10278 directory and using "*" as pattern. */
10279 dir
= Fexpand_file_name (dir
, Qnil
);
10280 dir_xmstring
= XmStringCreateLocalized (SDATA (dir
));
10281 pattern_xmstring
= XmStringCreateLocalized ("*");
10283 XtSetArg (al
[ac
], XmNtitle
, SDATA (prompt
)); ++ac
;
10284 XtSetArg (al
[ac
], XmNdirectory
, dir_xmstring
); ++ac
;
10285 XtSetArg (al
[ac
], XmNpattern
, pattern_xmstring
); ++ac
;
10286 XtSetArg (al
[ac
], XmNresizePolicy
, XmRESIZE_GROW
); ++ac
;
10287 XtSetArg (al
[ac
], XmNdialogStyle
, XmDIALOG_APPLICATION_MODAL
); ++ac
;
10288 dialog
= XmCreateFileSelectionDialog (f
->output_data
.x
->widget
,
10290 XmStringFree (dir_xmstring
);
10291 XmStringFree (pattern_xmstring
);
10293 /* Add callbacks for OK and Cancel. */
10294 XtAddCallback (dialog
, XmNokCallback
, file_dialog_cb
,
10295 (XtPointer
) &result
);
10296 XtAddCallback (dialog
, XmNcancelCallback
, file_dialog_cb
,
10297 (XtPointer
) &result
);
10298 XtAddCallback (dialog
, XmNunmapCallback
, file_dialog_unmap_cb
,
10299 (XtPointer
) &result
);
10301 /* Disable the help button since we can't display help. */
10302 help
= XmFileSelectionBoxGetChild (dialog
, XmDIALOG_HELP_BUTTON
);
10303 XtSetSensitive (help
, False
);
10305 /* Mark OK button as default. */
10306 XtVaSetValues (XmFileSelectionBoxGetChild (dialog
, XmDIALOG_OK_BUTTON
),
10307 XmNshowAsDefault
, True
, NULL
);
10309 /* If MUSTMATCH is non-nil, disable the file entry field of the
10310 dialog, so that the user must select a file from the files list
10311 box. We can't remove it because we wouldn't have a way to get at
10312 the result file name, then. */
10313 text
= XmFileSelectionBoxGetChild (dialog
, XmDIALOG_TEXT
);
10314 if (!NILP (mustmatch
))
10317 label
= XmFileSelectionBoxGetChild (dialog
, XmDIALOG_SELECTION_LABEL
);
10318 XtSetSensitive (text
, False
);
10319 XtSetSensitive (label
, False
);
10322 /* Manage the dialog, so that list boxes get filled. */
10323 XtManageChild (dialog
);
10325 /* Select DEFAULT_FILENAME in the files list box. DEFAULT_FILENAME
10326 must include the path for this to work. */
10327 list
= XmFileSelectionBoxGetChild (dialog
, XmDIALOG_LIST
);
10328 if (STRINGP (default_filename
))
10330 XmString default_xmstring
;
10334 = XmStringCreateLocalized (SDATA (default_filename
));
10336 if (!XmListItemExists (list
, default_xmstring
))
10338 /* Add a new item if DEFAULT_FILENAME is not in the list. */
10339 XmListAddItem (list
, default_xmstring
, 0);
10343 item_pos
= XmListItemPos (list
, default_xmstring
);
10344 XmStringFree (default_xmstring
);
10346 /* Select the item and scroll it into view. */
10347 XmListSelectPos (list
, item_pos
, True
);
10348 XmListSetPos (list
, item_pos
);
10351 /* Process events until the user presses Cancel or OK. */
10353 while (result
== 0)
10356 XtAppNextEvent (Xt_app_con
, &event
);
10357 (void) x_dispatch_event (&event
, FRAME_X_DISPLAY (f
) );
10360 /* Get the result. */
10361 if (result
== XmCR_OK
)
10366 XtVaGetValues (dialog
, XmNtextString
, &text
, NULL
);
10367 XmStringGetLtoR (text
, XmFONTLIST_DEFAULT_TAG
, &data
);
10368 XmStringFree (text
);
10369 file
= build_string (data
);
10376 XtUnmanageChild (dialog
);
10377 XtDestroyWidget (dialog
);
10381 /* Make "Cancel" equivalent to C-g. */
10383 Fsignal (Qquit
, Qnil
);
10385 return unbind_to (count
, file
);
10388 #endif /* USE_MOTIF */
10392 DEFUN ("x-file-dialog", Fx_file_dialog
, Sx_file_dialog
, 2, 4, 0,
10393 "Read file name, prompting with PROMPT in directory DIR.\n\
10394 Use a file selection dialog.\n\
10395 Select DEFAULT-FILENAME in the dialog's file selection box, if\n\
10396 specified. Don't let the user enter a file name in the file\n\
10397 selection dialog's entry field, if MUSTMATCH is non-nil.")
10398 (prompt
, dir
, default_filename
, mustmatch
)
10399 Lisp_Object prompt
, dir
, default_filename
, mustmatch
;
10401 FRAME_PTR f
= SELECTED_FRAME ();
10403 Lisp_Object file
= Qnil
;
10404 int count
= specpdl_ptr
- specpdl
;
10405 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
10409 GCPRO5 (prompt
, dir
, default_filename
, mustmatch
, file
);
10410 CHECK_STRING (prompt
);
10411 CHECK_STRING (dir
);
10413 /* Prevent redisplay. */
10414 specbind (Qinhibit_redisplay
, Qt
);
10418 if (STRINGP (default_filename
))
10419 cdef_file
= SDATA (default_filename
);
10421 cdef_file
= SDATA (dir
);
10423 fn
= xg_get_file_name (f
, SDATA (prompt
), cdef_file
, ! NILP (mustmatch
));
10427 file
= build_string (fn
);
10434 /* Make "Cancel" equivalent to C-g. */
10436 Fsignal (Qquit
, Qnil
);
10438 return unbind_to (count
, file
);
10441 #endif /* USE_GTK */
10444 /***********************************************************************
10446 ***********************************************************************/
10448 #ifdef HAVE_XKBGETKEYBOARD
10449 #include <X11/XKBlib.h>
10450 #include <X11/keysym.h>
10453 DEFUN ("x-backspace-delete-keys-p", Fx_backspace_delete_keys_p
,
10454 Sx_backspace_delete_keys_p
, 0, 1, 0,
10455 doc
: /* Check if both Backspace and Delete keys are on the keyboard of FRAME.
10456 FRAME nil means use the selected frame.
10457 Value is t if we know that both keys are present, and are mapped to the
10458 usual X keysyms. */)
10462 #ifdef HAVE_XKBGETKEYBOARD
10464 struct frame
*f
= check_x_frame (frame
);
10465 Display
*dpy
= FRAME_X_DISPLAY (f
);
10466 Lisp_Object have_keys
;
10467 int major
, minor
, op
, event
, error
;
10471 /* Check library version in case we're dynamically linked. */
10472 major
= XkbMajorVersion
;
10473 minor
= XkbMinorVersion
;
10474 if (!XkbLibraryVersion (&major
, &minor
))
10480 /* Check that the server supports XKB. */
10481 major
= XkbMajorVersion
;
10482 minor
= XkbMinorVersion
;
10483 if (!XkbQueryExtension (dpy
, &op
, &event
, &error
, &major
, &minor
))
10490 kb
= XkbGetMap (dpy
, XkbAllMapComponentsMask
, XkbUseCoreKbd
);
10493 int delete_keycode
= 0, backspace_keycode
= 0, i
;
10495 if (XkbGetNames (dpy
, XkbAllNamesMask
, kb
) == Success
)
10497 for (i
= kb
->min_key_code
;
10498 (i
< kb
->max_key_code
10499 && (delete_keycode
== 0 || backspace_keycode
== 0));
10502 /* The XKB symbolic key names can be seen most easily in
10503 the PS file generated by `xkbprint -label name
10505 if (bcmp ("DELE", kb
->names
->keys
[i
].name
, 4) == 0)
10506 delete_keycode
= i
;
10507 else if (bcmp ("BKSP", kb
->names
->keys
[i
].name
, 4) == 0)
10508 backspace_keycode
= i
;
10511 XkbFreeNames (kb
, 0, True
);
10514 XkbFreeClientMap (kb
, 0, True
);
10517 && backspace_keycode
10518 && XKeysymToKeycode (dpy
, XK_Delete
) == delete_keycode
10519 && XKeysymToKeycode (dpy
, XK_BackSpace
) == backspace_keycode
)
10524 #else /* not HAVE_XKBGETKEYBOARD */
10526 #endif /* not HAVE_XKBGETKEYBOARD */
10531 /***********************************************************************
10533 ***********************************************************************/
10535 /* Keep this list in the same order as frame_parms in frame.c.
10536 Use 0 for unsupported frame parameters. */
10538 frame_parm_handler x_frame_parm_handlers
[] =
10542 x_set_background_color
,
10543 x_set_border_color
,
10544 x_set_border_width
,
10545 x_set_cursor_color
,
10548 x_set_foreground_color
,
10551 x_set_internal_border_width
,
10552 x_set_menu_bar_lines
,
10554 x_explicitly_set_name
,
10555 x_set_scroll_bar_width
,
10557 x_set_unsplittable
,
10558 x_set_vertical_scroll_bars
,
10560 x_set_tool_bar_lines
,
10561 x_set_scroll_bar_foreground
,
10562 x_set_scroll_bar_background
,
10563 x_set_screen_gamma
,
10564 x_set_line_spacing
,
10565 x_set_fringe_width
,
10566 x_set_fringe_width
,
10574 /* This is zero if not using X windows. */
10577 /* The section below is built by the lisp expression at the top of the file,
10578 just above where these variables are declared. */
10579 /*&&& init symbols here &&&*/
10580 Qnone
= intern ("none");
10581 staticpro (&Qnone
);
10582 Qsuppress_icon
= intern ("suppress-icon");
10583 staticpro (&Qsuppress_icon
);
10584 Qundefined_color
= intern ("undefined-color");
10585 staticpro (&Qundefined_color
);
10586 Qcenter
= intern ("center");
10587 staticpro (&Qcenter
);
10588 Qcompound_text
= intern ("compound-text");
10589 staticpro (&Qcompound_text
);
10590 Qcancel_timer
= intern ("cancel-timer");
10591 staticpro (&Qcancel_timer
);
10592 /* This is the end of symbol initialization. */
10594 /* Text property `display' should be nonsticky by default. */
10595 Vtext_property_default_nonsticky
10596 = Fcons (Fcons (Qdisplay
, Qt
), Vtext_property_default_nonsticky
);
10599 Qlaplace
= intern ("laplace");
10600 staticpro (&Qlaplace
);
10601 Qemboss
= intern ("emboss");
10602 staticpro (&Qemboss
);
10603 Qedge_detection
= intern ("edge-detection");
10604 staticpro (&Qedge_detection
);
10605 Qheuristic
= intern ("heuristic");
10606 staticpro (&Qheuristic
);
10607 QCmatrix
= intern (":matrix");
10608 staticpro (&QCmatrix
);
10609 QCcolor_adjustment
= intern (":color-adjustment");
10610 staticpro (&QCcolor_adjustment
);
10611 QCmask
= intern (":mask");
10612 staticpro (&QCmask
);
10614 Fput (Qundefined_color
, Qerror_conditions
,
10615 Fcons (Qundefined_color
, Fcons (Qerror
, Qnil
)));
10616 Fput (Qundefined_color
, Qerror_message
,
10617 build_string ("Undefined color"));
10619 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
10620 doc
: /* Non-nil means always draw a cross over disabled images.
10621 Disabled images are those having an `:conversion disabled' property.
10622 A cross is always drawn on black & white displays. */);
10623 cross_disabled_images
= 0;
10625 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
10626 doc
: /* List of directories to search for window system bitmap files. */);
10627 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
10629 DEFVAR_LISP ("x-pointer-shape", &Vx_pointer_shape
,
10630 doc
: /* The shape of the pointer when over text.
10631 Changing the value does not affect existing frames
10632 unless you set the mouse color. */);
10633 Vx_pointer_shape
= Qnil
;
10635 #if 0 /* This doesn't really do anything. */
10636 DEFVAR_LISP ("x-nontext-pointer-shape", &Vx_nontext_pointer_shape
,
10637 doc
: /* The shape of the pointer when not over text.
10638 This variable takes effect when you create a new frame
10639 or when you set the mouse color. */);
10641 Vx_nontext_pointer_shape
= Qnil
;
10643 DEFVAR_LISP ("x-hourglass-pointer-shape", &Vx_hourglass_pointer_shape
,
10644 doc
: /* The shape of the pointer when Emacs is busy.
10645 This variable takes effect when you create a new frame
10646 or when you set the mouse color. */);
10647 Vx_hourglass_pointer_shape
= Qnil
;
10649 DEFVAR_BOOL ("display-hourglass", &display_hourglass_p
,
10650 doc
: /* Non-zero means Emacs displays an hourglass pointer on window systems. */);
10651 display_hourglass_p
= 1;
10653 DEFVAR_LISP ("hourglass-delay", &Vhourglass_delay
,
10654 doc
: /* *Seconds to wait before displaying an hourglass pointer.
10655 Value must be an integer or float. */);
10656 Vhourglass_delay
= make_number (DEFAULT_HOURGLASS_DELAY
);
10658 #if 0 /* This doesn't really do anything. */
10659 DEFVAR_LISP ("x-mode-pointer-shape", &Vx_mode_pointer_shape
,
10660 doc
: /* The shape of the pointer when over the mode line.
10661 This variable takes effect when you create a new frame
10662 or when you set the mouse color. */);
10664 Vx_mode_pointer_shape
= Qnil
;
10666 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
10667 &Vx_sensitive_text_pointer_shape
,
10668 doc
: /* The shape of the pointer when over mouse-sensitive text.
10669 This variable takes effect when you create a new frame
10670 or when you set the mouse color. */);
10671 Vx_sensitive_text_pointer_shape
= Qnil
;
10673 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
10674 &Vx_window_horizontal_drag_shape
,
10675 doc
: /* Pointer shape to use for indicating a window can be dragged horizontally.
10676 This variable takes effect when you create a new frame
10677 or when you set the mouse color. */);
10678 Vx_window_horizontal_drag_shape
= Qnil
;
10680 DEFVAR_LISP ("x-cursor-fore-pixel", &Vx_cursor_fore_pixel
,
10681 doc
: /* A string indicating the foreground color of the cursor box. */);
10682 Vx_cursor_fore_pixel
= Qnil
;
10684 DEFVAR_LISP ("x-max-tooltip-size", &Vx_max_tooltip_size
,
10685 doc
: /* Maximum size for tooltips. Value is a pair (COLUMNS . ROWS).
10686 Text larger than this is clipped. */);
10687 Vx_max_tooltip_size
= Fcons (make_number (80), make_number (40));
10689 DEFVAR_LISP ("x-no-window-manager", &Vx_no_window_manager
,
10690 doc
: /* Non-nil if no X window manager is in use.
10691 Emacs doesn't try to figure this out; this is always nil
10692 unless you set it to something else. */);
10693 /* We don't have any way to find this out, so set it to nil
10694 and maybe the user would like to set it to t. */
10695 Vx_no_window_manager
= Qnil
;
10697 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
10698 &Vx_pixel_size_width_font_regexp
,
10699 doc
: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
10701 Since Emacs gets width of a font matching with this regexp from
10702 PIXEL_SIZE field of the name, font finding mechanism gets faster for
10703 such a font. This is especially effective for such large fonts as
10704 Chinese, Japanese, and Korean. */);
10705 Vx_pixel_size_width_font_regexp
= Qnil
;
10707 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
10708 doc
: /* Time after which cached images are removed from the cache.
10709 When an image has not been displayed this many seconds, remove it
10710 from the image cache. Value must be an integer or nil with nil
10711 meaning don't clear the cache. */);
10712 Vimage_cache_eviction_delay
= make_number (30 * 60);
10714 #ifdef USE_X_TOOLKIT
10715 Fprovide (intern ("x-toolkit"), Qnil
);
10717 Fprovide (intern ("motif"), Qnil
);
10719 DEFVAR_LISP ("motif-version-string", &Vmotif_version_string
,
10720 doc
: /* Version info for LessTif/Motif. */);
10721 Vmotif_version_string
= build_string (XmVERSION_STRING
);
10722 #endif /* USE_MOTIF */
10723 #endif /* USE_X_TOOLKIT */
10725 /* X window properties. */
10726 defsubr (&Sx_change_window_property
);
10727 defsubr (&Sx_delete_window_property
);
10728 defsubr (&Sx_window_property
);
10730 defsubr (&Sxw_display_color_p
);
10731 defsubr (&Sx_display_grayscale_p
);
10732 defsubr (&Sxw_color_defined_p
);
10733 defsubr (&Sxw_color_values
);
10734 defsubr (&Sx_server_max_request_size
);
10735 defsubr (&Sx_server_vendor
);
10736 defsubr (&Sx_server_version
);
10737 defsubr (&Sx_display_pixel_width
);
10738 defsubr (&Sx_display_pixel_height
);
10739 defsubr (&Sx_display_mm_width
);
10740 defsubr (&Sx_display_mm_height
);
10741 defsubr (&Sx_display_screens
);
10742 defsubr (&Sx_display_planes
);
10743 defsubr (&Sx_display_color_cells
);
10744 defsubr (&Sx_display_visual_class
);
10745 defsubr (&Sx_display_backing_store
);
10746 defsubr (&Sx_display_save_under
);
10747 defsubr (&Sx_create_frame
);
10748 defsubr (&Sx_open_connection
);
10749 defsubr (&Sx_close_connection
);
10750 defsubr (&Sx_display_list
);
10751 defsubr (&Sx_synchronize
);
10752 defsubr (&Sx_focus_frame
);
10753 defsubr (&Sx_backspace_delete_keys_p
);
10755 /* Setting callback functions for fontset handler. */
10756 get_font_info_func
= x_get_font_info
;
10758 #if 0 /* This function pointer doesn't seem to be used anywhere.
10759 And the pointer assigned has the wrong type, anyway. */
10760 list_fonts_func
= x_list_fonts
;
10763 load_font_func
= x_load_font
;
10764 find_ccl_program_func
= x_find_ccl_program
;
10765 query_font_func
= x_query_font
;
10766 set_frame_fontset_func
= x_set_font
;
10767 check_window_system_func
= check_x
;
10770 Qxbm
= intern ("xbm");
10772 QCconversion
= intern (":conversion");
10773 staticpro (&QCconversion
);
10774 QCheuristic_mask
= intern (":heuristic-mask");
10775 staticpro (&QCheuristic_mask
);
10776 QCcolor_symbols
= intern (":color-symbols");
10777 staticpro (&QCcolor_symbols
);
10778 QCascent
= intern (":ascent");
10779 staticpro (&QCascent
);
10780 QCmargin
= intern (":margin");
10781 staticpro (&QCmargin
);
10782 QCrelief
= intern (":relief");
10783 staticpro (&QCrelief
);
10784 Qpostscript
= intern ("postscript");
10785 staticpro (&Qpostscript
);
10786 QCloader
= intern (":loader");
10787 staticpro (&QCloader
);
10788 QCbounding_box
= intern (":bounding-box");
10789 staticpro (&QCbounding_box
);
10790 QCpt_width
= intern (":pt-width");
10791 staticpro (&QCpt_width
);
10792 QCpt_height
= intern (":pt-height");
10793 staticpro (&QCpt_height
);
10794 QCindex
= intern (":index");
10795 staticpro (&QCindex
);
10796 Qpbm
= intern ("pbm");
10800 Qxpm
= intern ("xpm");
10805 Qjpeg
= intern ("jpeg");
10806 staticpro (&Qjpeg
);
10810 Qtiff
= intern ("tiff");
10811 staticpro (&Qtiff
);
10815 Qgif
= intern ("gif");
10820 Qpng
= intern ("png");
10824 defsubr (&Sclear_image_cache
);
10825 defsubr (&Simage_size
);
10826 defsubr (&Simage_mask_p
);
10828 hourglass_atimer
= NULL
;
10829 hourglass_shown_p
= 0;
10831 defsubr (&Sx_show_tip
);
10832 defsubr (&Sx_hide_tip
);
10834 staticpro (&tip_timer
);
10836 staticpro (&tip_frame
);
10838 last_show_tip_args
= Qnil
;
10839 staticpro (&last_show_tip_args
);
10842 defsubr (&Sx_file_dialog
);
10850 image_types
= NULL
;
10851 Vimage_types
= Qnil
;
10853 define_image_type (&xbm_type
);
10854 define_image_type (&gs_type
);
10855 define_image_type (&pbm_type
);
10858 define_image_type (&xpm_type
);
10862 define_image_type (&jpeg_type
);
10866 define_image_type (&tiff_type
);
10870 define_image_type (&gif_type
);
10874 define_image_type (&png_type
);
10878 #endif /* HAVE_X_WINDOWS */