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
->x_pixels_diff
= -win_x
;
874 f
->y_pixels_diff
= -win_y
;
876 FRAME_X_OUTPUT (f
)->x_pixels_outer_diff
= -outer_x
;
877 FRAME_X_OUTPUT (f
)->y_pixels_outer_diff
= -outer_y
;
886 /* Gamma-correct COLOR on frame F. */
889 gamma_correct (f
, color
)
895 color
->red
= pow (color
->red
/ 65535.0, f
->gamma
) * 65535.0 + 0.5;
896 color
->green
= pow (color
->green
/ 65535.0, f
->gamma
) * 65535.0 + 0.5;
897 color
->blue
= pow (color
->blue
/ 65535.0, f
->gamma
) * 65535.0 + 0.5;
902 /* Decide if color named COLOR_NAME is valid for use on frame F. If
903 so, return the RGB values in COLOR. If ALLOC_P is non-zero,
904 allocate the color. Value is zero if COLOR_NAME is invalid, or
905 no color could be allocated. */
908 x_defined_color (f
, color_name
, color
, alloc_p
)
915 Display
*dpy
= FRAME_X_DISPLAY (f
);
916 Colormap cmap
= FRAME_X_COLORMAP (f
);
919 success_p
= XParseColor (dpy
, cmap
, color_name
, color
);
920 if (success_p
&& alloc_p
)
921 success_p
= x_alloc_nearest_color (f
, cmap
, color
);
928 /* Return the pixel color value for color COLOR_NAME on frame F. If F
929 is a monochrome frame, return MONO_COLOR regardless of what ARG says.
930 Signal an error if color can't be allocated. */
933 x_decode_color (f
, color_name
, mono_color
)
935 Lisp_Object color_name
;
940 CHECK_STRING (color_name
);
942 #if 0 /* Don't do this. It's wrong when we're not using the default
943 colormap, it makes freeing difficult, and it's probably not
944 an important optimization. */
945 if (strcmp (SDATA (color_name
), "black") == 0)
946 return BLACK_PIX_DEFAULT (f
);
947 else if (strcmp (SDATA (color_name
), "white") == 0)
948 return WHITE_PIX_DEFAULT (f
);
951 /* Return MONO_COLOR for monochrome frames. */
952 if (FRAME_X_DISPLAY_INFO (f
)->n_planes
== 1)
955 /* x_defined_color is responsible for coping with failures
956 by looking for a near-miss. */
957 if (x_defined_color (f
, SDATA (color_name
), &cdef
, 1))
960 Fsignal (Qerror
, Fcons (build_string ("Undefined color"),
961 Fcons (color_name
, Qnil
)));
967 /* Change the `wait-for-wm' frame parameter of frame F. OLD_VALUE is
968 the previous value of that parameter, NEW_VALUE is the new value.
969 See also the comment of wait_for_wm in struct x_output. */
972 x_set_wait_for_wm (f
, new_value
, old_value
)
974 Lisp_Object new_value
, old_value
;
976 f
->output_data
.x
->wait_for_wm
= !NILP (new_value
);
980 /* Functions called only from `x_set_frame_param'
981 to set individual parameters.
983 If FRAME_X_WINDOW (f) is 0,
984 the frame is being created and its X-window does not exist yet.
985 In that case, just record the parameter's new value
986 in the standard place; do not attempt to change the window. */
989 x_set_foreground_color (f
, arg
, oldval
)
991 Lisp_Object arg
, oldval
;
993 struct x_output
*x
= f
->output_data
.x
;
994 unsigned long fg
, old_fg
;
996 fg
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
997 old_fg
= x
->foreground_pixel
;
998 x
->foreground_pixel
= fg
;
1000 if (FRAME_X_WINDOW (f
) != 0)
1002 Display
*dpy
= FRAME_X_DISPLAY (f
);
1005 XSetForeground (dpy
, x
->normal_gc
, fg
);
1006 XSetBackground (dpy
, x
->reverse_gc
, fg
);
1008 if (x
->cursor_pixel
== old_fg
)
1010 unload_color (f
, x
->cursor_pixel
);
1011 x
->cursor_pixel
= x_copy_color (f
, fg
);
1012 XSetBackground (dpy
, x
->cursor_gc
, x
->cursor_pixel
);
1017 update_face_from_frame_parameter (f
, Qforeground_color
, arg
);
1019 if (FRAME_VISIBLE_P (f
))
1023 unload_color (f
, old_fg
);
1027 x_set_background_color (f
, arg
, oldval
)
1029 Lisp_Object arg
, oldval
;
1031 struct x_output
*x
= f
->output_data
.x
;
1034 bg
= x_decode_color (f
, arg
, WHITE_PIX_DEFAULT (f
));
1035 unload_color (f
, x
->background_pixel
);
1036 x
->background_pixel
= bg
;
1038 if (FRAME_X_WINDOW (f
) != 0)
1040 Display
*dpy
= FRAME_X_DISPLAY (f
);
1043 XSetBackground (dpy
, x
->normal_gc
, bg
);
1044 XSetForeground (dpy
, x
->reverse_gc
, bg
);
1045 XSetWindowBackground (dpy
, FRAME_X_WINDOW (f
), bg
);
1046 XSetForeground (dpy
, x
->cursor_gc
, bg
);
1049 xg_set_background_color (f
, bg
);
1052 #ifndef USE_TOOLKIT_SCROLL_BARS /* Turns out to be annoying with
1053 toolkit scroll bars. */
1056 for (bar
= FRAME_SCROLL_BARS (f
);
1058 bar
= XSCROLL_BAR (bar
)->next
)
1060 Window window
= SCROLL_BAR_X_WINDOW (XSCROLL_BAR (bar
));
1061 XSetWindowBackground (dpy
, window
, bg
);
1064 #endif /* USE_TOOLKIT_SCROLL_BARS */
1067 update_face_from_frame_parameter (f
, Qbackground_color
, arg
);
1069 if (FRAME_VISIBLE_P (f
))
1075 x_set_mouse_color (f
, arg
, oldval
)
1077 Lisp_Object arg
, oldval
;
1079 struct x_output
*x
= f
->output_data
.x
;
1080 Display
*dpy
= FRAME_X_DISPLAY (f
);
1081 Cursor cursor
, nontext_cursor
, mode_cursor
, hand_cursor
;
1082 Cursor hourglass_cursor
, horizontal_drag_cursor
;
1084 unsigned long pixel
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1085 unsigned long mask_color
= x
->background_pixel
;
1087 /* Don't let pointers be invisible. */
1088 if (mask_color
== pixel
)
1090 x_free_colors (f
, &pixel
, 1);
1091 pixel
= x_copy_color (f
, x
->foreground_pixel
);
1094 unload_color (f
, x
->mouse_pixel
);
1095 x
->mouse_pixel
= pixel
;
1099 /* It's not okay to crash if the user selects a screwy cursor. */
1100 count
= x_catch_errors (dpy
);
1102 if (!NILP (Vx_pointer_shape
))
1104 CHECK_NUMBER (Vx_pointer_shape
);
1105 cursor
= XCreateFontCursor (dpy
, XINT (Vx_pointer_shape
));
1108 cursor
= XCreateFontCursor (dpy
, XC_xterm
);
1109 x_check_errors (dpy
, "bad text pointer cursor: %s");
1111 if (!NILP (Vx_nontext_pointer_shape
))
1113 CHECK_NUMBER (Vx_nontext_pointer_shape
);
1115 = XCreateFontCursor (dpy
, XINT (Vx_nontext_pointer_shape
));
1118 nontext_cursor
= XCreateFontCursor (dpy
, XC_left_ptr
);
1119 x_check_errors (dpy
, "bad nontext pointer cursor: %s");
1121 if (!NILP (Vx_hourglass_pointer_shape
))
1123 CHECK_NUMBER (Vx_hourglass_pointer_shape
);
1125 = XCreateFontCursor (dpy
, XINT (Vx_hourglass_pointer_shape
));
1128 hourglass_cursor
= XCreateFontCursor (dpy
, XC_watch
);
1129 x_check_errors (dpy
, "bad hourglass pointer cursor: %s");
1131 x_check_errors (dpy
, "bad nontext pointer cursor: %s");
1132 if (!NILP (Vx_mode_pointer_shape
))
1134 CHECK_NUMBER (Vx_mode_pointer_shape
);
1135 mode_cursor
= XCreateFontCursor (dpy
, XINT (Vx_mode_pointer_shape
));
1138 mode_cursor
= XCreateFontCursor (dpy
, XC_xterm
);
1139 x_check_errors (dpy
, "bad modeline pointer cursor: %s");
1141 if (!NILP (Vx_sensitive_text_pointer_shape
))
1143 CHECK_NUMBER (Vx_sensitive_text_pointer_shape
);
1145 = XCreateFontCursor (dpy
, XINT (Vx_sensitive_text_pointer_shape
));
1148 hand_cursor
= XCreateFontCursor (dpy
, XC_hand2
);
1150 if (!NILP (Vx_window_horizontal_drag_shape
))
1152 CHECK_NUMBER (Vx_window_horizontal_drag_shape
);
1153 horizontal_drag_cursor
1154 = XCreateFontCursor (dpy
, XINT (Vx_window_horizontal_drag_shape
));
1157 horizontal_drag_cursor
1158 = XCreateFontCursor (dpy
, XC_sb_h_double_arrow
);
1160 /* Check and report errors with the above calls. */
1161 x_check_errors (dpy
, "can't set cursor shape: %s");
1162 x_uncatch_errors (dpy
, count
);
1165 XColor fore_color
, back_color
;
1167 fore_color
.pixel
= x
->mouse_pixel
;
1168 x_query_color (f
, &fore_color
);
1169 back_color
.pixel
= mask_color
;
1170 x_query_color (f
, &back_color
);
1172 XRecolorCursor (dpy
, cursor
, &fore_color
, &back_color
);
1173 XRecolorCursor (dpy
, nontext_cursor
, &fore_color
, &back_color
);
1174 XRecolorCursor (dpy
, mode_cursor
, &fore_color
, &back_color
);
1175 XRecolorCursor (dpy
, hand_cursor
, &fore_color
, &back_color
);
1176 XRecolorCursor (dpy
, hourglass_cursor
, &fore_color
, &back_color
);
1177 XRecolorCursor (dpy
, horizontal_drag_cursor
, &fore_color
, &back_color
);
1180 if (FRAME_X_WINDOW (f
) != 0)
1181 XDefineCursor (dpy
, FRAME_X_WINDOW (f
), cursor
);
1183 if (cursor
!= x
->text_cursor
1184 && x
->text_cursor
!= 0)
1185 XFreeCursor (dpy
, x
->text_cursor
);
1186 x
->text_cursor
= cursor
;
1188 if (nontext_cursor
!= x
->nontext_cursor
1189 && x
->nontext_cursor
!= 0)
1190 XFreeCursor (dpy
, x
->nontext_cursor
);
1191 x
->nontext_cursor
= nontext_cursor
;
1193 if (hourglass_cursor
!= x
->hourglass_cursor
1194 && x
->hourglass_cursor
!= 0)
1195 XFreeCursor (dpy
, x
->hourglass_cursor
);
1196 x
->hourglass_cursor
= hourglass_cursor
;
1198 if (mode_cursor
!= x
->modeline_cursor
1199 && x
->modeline_cursor
!= 0)
1200 XFreeCursor (dpy
, f
->output_data
.x
->modeline_cursor
);
1201 x
->modeline_cursor
= mode_cursor
;
1203 if (hand_cursor
!= x
->hand_cursor
1204 && x
->hand_cursor
!= 0)
1205 XFreeCursor (dpy
, x
->hand_cursor
);
1206 x
->hand_cursor
= hand_cursor
;
1208 if (horizontal_drag_cursor
!= x
->horizontal_drag_cursor
1209 && x
->horizontal_drag_cursor
!= 0)
1210 XFreeCursor (dpy
, x
->horizontal_drag_cursor
);
1211 x
->horizontal_drag_cursor
= horizontal_drag_cursor
;
1216 update_face_from_frame_parameter (f
, Qmouse_color
, arg
);
1220 x_set_cursor_color (f
, arg
, oldval
)
1222 Lisp_Object arg
, oldval
;
1224 unsigned long fore_pixel
, pixel
;
1225 int fore_pixel_allocated_p
= 0, pixel_allocated_p
= 0;
1226 struct x_output
*x
= f
->output_data
.x
;
1228 if (!NILP (Vx_cursor_fore_pixel
))
1230 fore_pixel
= x_decode_color (f
, Vx_cursor_fore_pixel
,
1231 WHITE_PIX_DEFAULT (f
));
1232 fore_pixel_allocated_p
= 1;
1235 fore_pixel
= x
->background_pixel
;
1237 pixel
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1238 pixel_allocated_p
= 1;
1240 /* Make sure that the cursor color differs from the background color. */
1241 if (pixel
== x
->background_pixel
)
1243 if (pixel_allocated_p
)
1245 x_free_colors (f
, &pixel
, 1);
1246 pixel_allocated_p
= 0;
1249 pixel
= x
->mouse_pixel
;
1250 if (pixel
== fore_pixel
)
1252 if (fore_pixel_allocated_p
)
1254 x_free_colors (f
, &fore_pixel
, 1);
1255 fore_pixel_allocated_p
= 0;
1257 fore_pixel
= x
->background_pixel
;
1261 unload_color (f
, x
->cursor_foreground_pixel
);
1262 if (!fore_pixel_allocated_p
)
1263 fore_pixel
= x_copy_color (f
, fore_pixel
);
1264 x
->cursor_foreground_pixel
= fore_pixel
;
1266 unload_color (f
, x
->cursor_pixel
);
1267 if (!pixel_allocated_p
)
1268 pixel
= x_copy_color (f
, pixel
);
1269 x
->cursor_pixel
= pixel
;
1271 if (FRAME_X_WINDOW (f
) != 0)
1274 XSetBackground (FRAME_X_DISPLAY (f
), x
->cursor_gc
, x
->cursor_pixel
);
1275 XSetForeground (FRAME_X_DISPLAY (f
), x
->cursor_gc
, fore_pixel
);
1278 if (FRAME_VISIBLE_P (f
))
1280 x_update_cursor (f
, 0);
1281 x_update_cursor (f
, 1);
1285 update_face_from_frame_parameter (f
, Qcursor_color
, arg
);
1288 /* Set the border-color of frame F to pixel value PIX.
1289 Note that this does not fully take effect if done before
1290 F has an x-window. */
1293 x_set_border_pixel (f
, pix
)
1297 unload_color (f
, f
->output_data
.x
->border_pixel
);
1298 f
->output_data
.x
->border_pixel
= pix
;
1300 if (FRAME_X_WINDOW (f
) != 0 && f
->border_width
> 0)
1303 XSetWindowBorder (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1304 (unsigned long)pix
);
1307 if (FRAME_VISIBLE_P (f
))
1312 /* Set the border-color of frame F to value described by ARG.
1313 ARG can be a string naming a color.
1314 The border-color is used for the border that is drawn by the X server.
1315 Note that this does not fully take effect if done before
1316 F has an x-window; it must be redone when the window is created.
1318 Note: this is done in two routines because of the way X10 works.
1320 Note: under X11, this is normally the province of the window manager,
1321 and so emacs' border colors may be overridden. */
1324 x_set_border_color (f
, arg
, oldval
)
1326 Lisp_Object arg
, oldval
;
1331 pix
= x_decode_color (f
, arg
, BLACK_PIX_DEFAULT (f
));
1332 x_set_border_pixel (f
, pix
);
1333 update_face_from_frame_parameter (f
, Qborder_color
, arg
);
1338 x_set_cursor_type (f
, arg
, oldval
)
1340 Lisp_Object arg
, oldval
;
1342 set_frame_cursor_types (f
, arg
);
1344 /* Make sure the cursor gets redrawn. */
1345 cursor_type_changed
= 1;
1349 x_set_icon_type (f
, arg
, oldval
)
1351 Lisp_Object arg
, oldval
;
1357 if (STRINGP (oldval
) && EQ (Fstring_equal (oldval
, arg
), Qt
))
1360 else if (!STRINGP (oldval
) && EQ (oldval
, Qnil
) == EQ (arg
, Qnil
))
1365 result
= x_text_icon (f
,
1366 (char *) SDATA ((!NILP (f
->icon_name
)
1370 result
= x_bitmap_icon (f
, arg
);
1375 error ("No icon window available");
1378 XFlush (FRAME_X_DISPLAY (f
));
1383 x_set_icon_name (f
, arg
, oldval
)
1385 Lisp_Object arg
, oldval
;
1391 if (STRINGP (oldval
) && EQ (Fstring_equal (oldval
, arg
), Qt
))
1394 else if (!STRINGP (oldval
) && EQ (oldval
, Qnil
) == EQ (arg
, Qnil
))
1399 if (f
->output_data
.x
->icon_bitmap
!= 0)
1404 result
= x_text_icon (f
,
1405 (char *) SDATA ((!NILP (f
->icon_name
)
1414 error ("No icon window available");
1417 XFlush (FRAME_X_DISPLAY (f
));
1423 x_set_menu_bar_lines (f
, value
, oldval
)
1425 Lisp_Object value
, oldval
;
1428 #ifndef USE_X_TOOLKIT
1429 int olines
= FRAME_MENU_BAR_LINES (f
);
1432 /* Right now, menu bars don't work properly in minibuf-only frames;
1433 most of the commands try to apply themselves to the minibuffer
1434 frame itself, and get an error because you can't switch buffers
1435 in or split the minibuffer window. */
1436 if (FRAME_MINIBUF_ONLY_P (f
))
1439 if (INTEGERP (value
))
1440 nlines
= XINT (value
);
1444 /* Make sure we redisplay all windows in this frame. */
1445 windows_or_buffers_changed
++;
1447 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
1448 FRAME_MENU_BAR_LINES (f
) = 0;
1451 FRAME_EXTERNAL_MENU_BAR (f
) = 1;
1452 if (FRAME_X_P (f
) && f
->output_data
.x
->menubar_widget
== 0)
1453 /* Make sure next redisplay shows the menu bar. */
1454 XWINDOW (FRAME_SELECTED_WINDOW (f
))->update_mode_line
= Qt
;
1458 if (FRAME_EXTERNAL_MENU_BAR (f
) == 1)
1459 free_frame_menubar (f
);
1460 FRAME_EXTERNAL_MENU_BAR (f
) = 0;
1462 f
->output_data
.x
->menubar_widget
= 0;
1464 #else /* not USE_X_TOOLKIT && not USE_GTK */
1465 FRAME_MENU_BAR_LINES (f
) = nlines
;
1466 change_window_heights (f
->root_window
, nlines
- olines
);
1467 #endif /* not USE_X_TOOLKIT */
1472 /* Set the number of lines used for the tool bar of frame F to VALUE.
1473 VALUE not an integer, or < 0 means set the lines to zero. OLDVAL
1474 is the old number of tool bar lines. This function changes the
1475 height of all windows on frame F to match the new tool bar height.
1476 The frame's height doesn't change. */
1479 x_set_tool_bar_lines (f
, value
, oldval
)
1481 Lisp_Object value
, oldval
;
1483 int delta
, nlines
, root_height
;
1484 Lisp_Object root_window
;
1486 /* Treat tool bars like menu bars. */
1487 if (FRAME_MINIBUF_ONLY_P (f
))
1490 /* Use VALUE only if an integer >= 0. */
1491 if (INTEGERP (value
) && XINT (value
) >= 0)
1492 nlines
= XFASTINT (value
);
1497 FRAME_TOOL_BAR_LINES (f
) = 0;
1500 FRAME_EXTERNAL_TOOL_BAR (f
) = 1;
1501 if (FRAME_X_P (f
) && f
->output_data
.x
->toolbar_widget
== 0)
1502 /* Make sure next redisplay shows the tool bar. */
1503 XWINDOW (FRAME_SELECTED_WINDOW (f
))->update_mode_line
= Qt
;
1504 update_frame_tool_bar (f
);
1508 if (FRAME_EXTERNAL_TOOL_BAR (f
))
1509 free_frame_tool_bar (f
);
1510 FRAME_EXTERNAL_TOOL_BAR (f
) = 0;
1516 /* Make sure we redisplay all windows in this frame. */
1517 ++windows_or_buffers_changed
;
1519 delta
= nlines
- FRAME_TOOL_BAR_LINES (f
);
1521 /* Don't resize the tool-bar to more than we have room for. */
1522 root_window
= FRAME_ROOT_WINDOW (f
);
1523 root_height
= WINDOW_TOTAL_LINES (XWINDOW (root_window
));
1524 if (root_height
- delta
< 1)
1526 delta
= root_height
- 1;
1527 nlines
= FRAME_TOOL_BAR_LINES (f
) + delta
;
1530 FRAME_TOOL_BAR_LINES (f
) = nlines
;
1531 change_window_heights (root_window
, delta
);
1534 /* We also have to make sure that the internal border at the top of
1535 the frame, below the menu bar or tool bar, is redrawn when the
1536 tool bar disappears. This is so because the internal border is
1537 below the tool bar if one is displayed, but is below the menu bar
1538 if there isn't a tool bar. The tool bar draws into the area
1539 below the menu bar. */
1540 if (FRAME_X_WINDOW (f
) && FRAME_TOOL_BAR_LINES (f
) == 0)
1544 clear_current_matrices (f
);
1545 updating_frame
= NULL
;
1548 /* If the tool bar gets smaller, the internal border below it
1549 has to be cleared. It was formerly part of the display
1550 of the larger tool bar, and updating windows won't clear it. */
1553 int height
= FRAME_INTERNAL_BORDER_WIDTH (f
);
1554 int width
= FRAME_PIXEL_WIDTH (f
);
1555 int y
= nlines
* FRAME_LINE_HEIGHT (f
);
1558 x_clear_area (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1559 0, y
, width
, height
, False
);
1562 if (WINDOWP (f
->tool_bar_window
))
1563 clear_glyph_matrix (XWINDOW (f
->tool_bar_window
)->current_matrix
);
1568 /* Set the foreground color for scroll bars on frame F to VALUE.
1569 VALUE should be a string, a color name. If it isn't a string or
1570 isn't a valid color name, do nothing. OLDVAL is the old value of
1571 the frame parameter. */
1574 x_set_scroll_bar_foreground (f
, value
, oldval
)
1576 Lisp_Object value
, oldval
;
1578 unsigned long pixel
;
1580 if (STRINGP (value
))
1581 pixel
= x_decode_color (f
, value
, BLACK_PIX_DEFAULT (f
));
1585 if (f
->output_data
.x
->scroll_bar_foreground_pixel
!= -1)
1586 unload_color (f
, f
->output_data
.x
->scroll_bar_foreground_pixel
);
1588 f
->output_data
.x
->scroll_bar_foreground_pixel
= pixel
;
1589 if (FRAME_X_WINDOW (f
) && FRAME_VISIBLE_P (f
))
1591 /* Remove all scroll bars because they have wrong colors. */
1592 if (condemn_scroll_bars_hook
)
1593 (*condemn_scroll_bars_hook
) (f
);
1594 if (judge_scroll_bars_hook
)
1595 (*judge_scroll_bars_hook
) (f
);
1597 update_face_from_frame_parameter (f
, Qscroll_bar_foreground
, value
);
1603 /* Set the background color for scroll bars on frame F to VALUE VALUE
1604 should be a string, a color name. If it isn't a string or isn't a
1605 valid color name, do nothing. OLDVAL is the old value of the frame
1609 x_set_scroll_bar_background (f
, value
, oldval
)
1611 Lisp_Object value
, oldval
;
1613 unsigned long pixel
;
1615 if (STRINGP (value
))
1616 pixel
= x_decode_color (f
, value
, WHITE_PIX_DEFAULT (f
));
1620 if (f
->output_data
.x
->scroll_bar_background_pixel
!= -1)
1621 unload_color (f
, f
->output_data
.x
->scroll_bar_background_pixel
);
1623 #ifdef USE_TOOLKIT_SCROLL_BARS
1624 /* Scrollbar shadow colors. */
1625 if (f
->output_data
.x
->scroll_bar_top_shadow_pixel
!= -1)
1627 unload_color (f
, f
->output_data
.x
->scroll_bar_top_shadow_pixel
);
1628 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= -1;
1630 if (f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
!= -1)
1632 unload_color (f
, f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
);
1633 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= -1;
1635 #endif /* USE_TOOLKIT_SCROLL_BARS */
1637 f
->output_data
.x
->scroll_bar_background_pixel
= pixel
;
1638 if (FRAME_X_WINDOW (f
) && FRAME_VISIBLE_P (f
))
1640 /* Remove all scroll bars because they have wrong colors. */
1641 if (condemn_scroll_bars_hook
)
1642 (*condemn_scroll_bars_hook
) (f
);
1643 if (judge_scroll_bars_hook
)
1644 (*judge_scroll_bars_hook
) (f
);
1646 update_face_from_frame_parameter (f
, Qscroll_bar_background
, value
);
1652 /* Encode Lisp string STRING as a text in a format appropriate for
1653 XICCC (X Inter Client Communication Conventions).
1655 If STRING contains only ASCII characters, do no conversion and
1656 return the string data of STRING. Otherwise, encode the text by
1657 CODING_SYSTEM, and return a newly allocated memory area which
1658 should be freed by `xfree' by a caller.
1660 SELECTIONP non-zero means the string is being encoded for an X
1661 selection, so it is safe to run pre-write conversions (which
1664 Store the byte length of resulting text in *TEXT_BYTES.
1666 If the text contains only ASCII and Latin-1, store 1 in *STRING_P,
1667 which means that the `encoding' of the result can be `STRING'.
1668 Otherwise store 0 in *STRINGP, which means that the `encoding' of
1669 the result should be `COMPOUND_TEXT'. */
1672 x_encode_text (string
, coding_system
, selectionp
, text_bytes
, stringp
)
1673 Lisp_Object string
, coding_system
;
1674 int *text_bytes
, *stringp
;
1677 unsigned char *str
= SDATA (string
);
1678 int chars
= SCHARS (string
);
1679 int bytes
= SBYTES (string
);
1683 struct coding_system coding
;
1684 extern Lisp_Object Qcompound_text_with_extensions
;
1686 charset_info
= find_charset_in_text (str
, chars
, bytes
, NULL
, Qnil
);
1687 if (charset_info
== 0)
1689 /* No multibyte character in OBJ. We need not encode it. */
1690 *text_bytes
= bytes
;
1695 setup_coding_system (coding_system
, &coding
);
1697 && SYMBOLP (coding
.pre_write_conversion
)
1698 && !NILP (Ffboundp (coding
.pre_write_conversion
)))
1700 string
= run_pre_post_conversion_on_str (string
, &coding
, 1);
1701 str
= SDATA (string
);
1702 chars
= SCHARS (string
);
1703 bytes
= SBYTES (string
);
1705 coding
.src_multibyte
= 1;
1706 coding
.dst_multibyte
= 0;
1707 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
1708 if (coding
.type
== coding_type_iso2022
)
1709 coding
.flags
|= CODING_FLAG_ISO_SAFE
;
1710 /* We suppress producing escape sequences for composition. */
1711 coding
.composing
= COMPOSITION_DISABLED
;
1712 bufsize
= encoding_buffer_size (&coding
, bytes
);
1713 buf
= (unsigned char *) xmalloc (bufsize
);
1714 encode_coding (&coding
, str
, buf
, bytes
, bufsize
);
1715 *text_bytes
= coding
.produced
;
1716 *stringp
= (charset_info
== 1
1717 || (!EQ (coding_system
, Qcompound_text
)
1718 && !EQ (coding_system
, Qcompound_text_with_extensions
)));
1723 /* Change the name of frame F to NAME. If NAME is nil, set F's name to
1726 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1727 name; if NAME is a string, set F's name to NAME and set
1728 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1730 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1731 suggesting a new name, which lisp code should override; if
1732 F->explicit_name is set, ignore the new name; otherwise, set it. */
1735 x_set_name (f
, name
, explicit)
1740 /* Make sure that requests from lisp code override requests from
1741 Emacs redisplay code. */
1744 /* If we're switching from explicit to implicit, we had better
1745 update the mode lines and thereby update the title. */
1746 if (f
->explicit_name
&& NILP (name
))
1747 update_mode_lines
= 1;
1749 f
->explicit_name
= ! NILP (name
);
1751 else if (f
->explicit_name
)
1754 /* If NAME is nil, set the name to the x_id_name. */
1757 /* Check for no change needed in this very common case
1758 before we do any consing. */
1759 if (!strcmp (FRAME_X_DISPLAY_INFO (f
)->x_id_name
,
1762 name
= build_string (FRAME_X_DISPLAY_INFO (f
)->x_id_name
);
1765 CHECK_STRING (name
);
1767 /* Don't change the name if it's already NAME. */
1768 if (! NILP (Fstring_equal (name
, f
->name
)))
1773 /* For setting the frame title, the title parameter should override
1774 the name parameter. */
1775 if (! NILP (f
->title
))
1778 if (FRAME_X_WINDOW (f
))
1783 XTextProperty text
, icon
;
1785 Lisp_Object coding_system
;
1787 /* Note: Encoding strategy
1789 We encode NAME by compound-text and use "COMPOUND-TEXT" in
1790 text.encoding. But, there are non-internationalized window
1791 managers which don't support that encoding. So, if NAME
1792 contains only ASCII and 8859-1 characters, encode it by
1793 iso-latin-1, and use "STRING" in text.encoding hoping that
1794 such window manager at least analize this format correctly,
1795 i.e. treat 8-bit bytes as 8859-1 characters.
1797 We may also be able to use "UTF8_STRING" in text.encoding
1798 in the feature which can encode all Unicode characters.
1799 But, for the moment, there's no way to know that the
1800 current window manager supports it or not. */
1801 coding_system
= Qcompound_text
;
1802 text
.value
= x_encode_text (name
, coding_system
, 0, &bytes
, &stringp
);
1803 text
.encoding
= (stringp
? XA_STRING
1804 : FRAME_X_DISPLAY_INFO (f
)->Xatom_COMPOUND_TEXT
);
1806 text
.nitems
= bytes
;
1808 if (NILP (f
->icon_name
))
1814 /* See the above comment "Note: Encoding strategy". */
1815 icon
.value
= x_encode_text (f
->icon_name
, coding_system
, 0,
1817 icon
.encoding
= (stringp
? XA_STRING
1818 : FRAME_X_DISPLAY_INFO (f
)->Xatom_COMPOUND_TEXT
);
1820 icon
.nitems
= bytes
;
1823 gtk_window_set_title (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1825 #else /* not USE_GTK */
1826 XSetWMName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
1827 #endif /* not USE_GTK */
1829 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &icon
);
1831 if (!NILP (f
->icon_name
)
1832 && icon
.value
!= (unsigned char *) SDATA (f
->icon_name
))
1834 if (text
.value
!= (unsigned char *) SDATA (name
))
1837 #else /* not HAVE_X11R4 */
1838 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1840 XStoreName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1842 #endif /* not HAVE_X11R4 */
1847 /* This function should be called when the user's lisp code has
1848 specified a name for the frame; the name will override any set by the
1851 x_explicitly_set_name (f
, arg
, oldval
)
1853 Lisp_Object arg
, oldval
;
1855 x_set_name (f
, arg
, 1);
1858 /* This function should be called by Emacs redisplay code to set the
1859 name; names set this way will never override names set by the user's
1862 x_implicitly_set_name (f
, arg
, oldval
)
1864 Lisp_Object arg
, oldval
;
1866 x_set_name (f
, arg
, 0);
1869 /* Change the title of frame F to NAME.
1870 If NAME is nil, use the frame name as the title.
1872 If EXPLICIT is non-zero, that indicates that lisp code is setting the
1873 name; if NAME is a string, set F's name to NAME and set
1874 F->explicit_name; if NAME is Qnil, then clear F->explicit_name.
1876 If EXPLICIT is zero, that indicates that Emacs redisplay code is
1877 suggesting a new name, which lisp code should override; if
1878 F->explicit_name is set, ignore the new name; otherwise, set it. */
1881 x_set_title (f
, name
, old_name
)
1883 Lisp_Object name
, old_name
;
1885 /* Don't change the title if it's already NAME. */
1886 if (EQ (name
, f
->title
))
1889 update_mode_lines
= 1;
1896 CHECK_STRING (name
);
1898 if (FRAME_X_WINDOW (f
))
1903 XTextProperty text
, icon
;
1905 Lisp_Object coding_system
;
1907 coding_system
= Qcompound_text
;
1908 /* See the comment "Note: Encoding strategy" in x_set_name. */
1909 text
.value
= x_encode_text (name
, coding_system
, 0, &bytes
, &stringp
);
1910 text
.encoding
= (stringp
? XA_STRING
1911 : FRAME_X_DISPLAY_INFO (f
)->Xatom_COMPOUND_TEXT
);
1913 text
.nitems
= bytes
;
1915 if (NILP (f
->icon_name
))
1921 /* See the comment "Note: Encoding strategy" in x_set_name. */
1922 icon
.value
= x_encode_text (f
->icon_name
, coding_system
, 0,
1924 icon
.encoding
= (stringp
? XA_STRING
1925 : FRAME_X_DISPLAY_INFO (f
)->Xatom_COMPOUND_TEXT
);
1927 icon
.nitems
= bytes
;
1931 gtk_window_set_title (GTK_WINDOW (FRAME_GTK_OUTER_WIDGET (f
)),
1933 #else /* not USE_GTK */
1934 XSetWMName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
), &text
);
1935 #endif /* not USE_GTK */
1937 XSetWMIconName (FRAME_X_DISPLAY (f
), FRAME_OUTER_WINDOW (f
),
1940 if (!NILP (f
->icon_name
)
1941 && icon
.value
!= (unsigned char *) SDATA (f
->icon_name
))
1943 if (text
.value
!= (unsigned char *) SDATA (name
))
1946 #else /* not HAVE_X11R4 */
1947 XSetIconName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1949 XStoreName (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
1951 #endif /* not HAVE_X11R4 */
1957 x_set_scroll_bar_default_width (f
)
1960 int wid
= FRAME_COLUMN_WIDTH (f
);
1962 #ifdef USE_TOOLKIT_SCROLL_BARS
1963 /* A minimum width of 14 doesn't look good for toolkit scroll bars. */
1964 int width
= 16 + 2 * VERTICAL_SCROLL_BAR_WIDTH_TRIM
;
1965 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (width
+ wid
- 1) / wid
;
1966 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) = width
;
1968 /* Make the actual width at least 14 pixels and a multiple of a
1970 FRAME_CONFIG_SCROLL_BAR_COLS (f
) = (14 + wid
- 1) / wid
;
1972 /* Use all of that space (aside from required margins) for the
1974 FRAME_CONFIG_SCROLL_BAR_WIDTH (f
) = 0;
1979 /* Record in frame F the specified or default value according to ALIST
1980 of the parameter named PROP (a Lisp symbol). If no value is
1981 specified for PROP, look for an X default for XPROP on the frame
1982 named NAME. If that is not found either, use the value DEFLT. */
1985 x_default_scroll_bar_color_parameter (f
, alist
, prop
, xprop
, xclass
,
1994 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1997 tem
= x_get_arg (dpyinfo
, alist
, prop
, xprop
, xclass
, RES_TYPE_STRING
);
1998 if (EQ (tem
, Qunbound
))
2000 #ifdef USE_TOOLKIT_SCROLL_BARS
2002 /* See if an X resource for the scroll bar color has been
2004 tem
= display_x_get_resource (dpyinfo
,
2005 build_string (foreground_p
2009 build_string ("verticalScrollBar"),
2013 /* If nothing has been specified, scroll bars will use a
2014 toolkit-dependent default. Because these defaults are
2015 difficult to get at without actually creating a scroll
2016 bar, use nil to indicate that no color has been
2021 #else /* not USE_TOOLKIT_SCROLL_BARS */
2025 #endif /* not USE_TOOLKIT_SCROLL_BARS */
2028 x_set_frame_parameters (f
, Fcons (Fcons (prop
, tem
), Qnil
));
2034 #if !defined (HAVE_X11R4) && !defined (HAVE_XSETWMPROTOCOLS)
2037 XSetWMProtocols (dpy
, w
, protocols
, count
)
2044 prop
= XInternAtom (dpy
, "WM_PROTOCOLS", False
);
2045 if (prop
== None
) return False
;
2046 XChangeProperty (dpy
, w
, prop
, XA_ATOM
, 32, PropModeReplace
,
2047 (unsigned char *) protocols
, count
);
2050 #endif /* not HAVE_X11R4 && not HAVE_XSETWMPROTOCOLS */
2052 #ifdef USE_X_TOOLKIT
2054 /* If the WM_PROTOCOLS property does not already contain WM_TAKE_FOCUS,
2055 WM_DELETE_WINDOW, and WM_SAVE_YOURSELF, then add them. (They may
2056 already be present because of the toolkit (Motif adds some of them,
2057 for example, but Xt doesn't). */
2060 hack_wm_protocols (f
, widget
)
2064 Display
*dpy
= XtDisplay (widget
);
2065 Window w
= XtWindow (widget
);
2066 int need_delete
= 1;
2072 Atom type
, *atoms
= 0;
2074 unsigned long nitems
= 0;
2075 unsigned long bytes_after
;
2077 if ((XGetWindowProperty (dpy
, w
,
2078 FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_protocols
,
2079 (long)0, (long)100, False
, XA_ATOM
,
2080 &type
, &format
, &nitems
, &bytes_after
,
2081 (unsigned char **) &atoms
)
2083 && format
== 32 && type
== XA_ATOM
)
2087 if (atoms
[nitems
] == FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_delete_window
)
2089 else if (atoms
[nitems
] == FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_take_focus
)
2091 else if (atoms
[nitems
] == FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_save_yourself
)
2094 if (atoms
) XFree ((char *) atoms
);
2100 props
[count
++] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_delete_window
;
2102 props
[count
++] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_take_focus
;
2104 props
[count
++] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_save_yourself
;
2106 XChangeProperty (dpy
, w
, FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_protocols
,
2107 XA_ATOM
, 32, PropModeAppend
,
2108 (unsigned char *) props
, count
);
2116 /* Support routines for XIC (X Input Context). */
2120 static XFontSet xic_create_xfontset
P_ ((struct frame
*, char *));
2121 static XIMStyle best_xim_style
P_ ((XIMStyles
*, XIMStyles
*));
2124 /* Supported XIM styles, ordered by preference. */
2126 static XIMStyle supported_xim_styles
[] =
2128 XIMPreeditPosition
| XIMStatusArea
,
2129 XIMPreeditPosition
| XIMStatusNothing
,
2130 XIMPreeditPosition
| XIMStatusNone
,
2131 XIMPreeditNothing
| XIMStatusArea
,
2132 XIMPreeditNothing
| XIMStatusNothing
,
2133 XIMPreeditNothing
| XIMStatusNone
,
2134 XIMPreeditNone
| XIMStatusArea
,
2135 XIMPreeditNone
| XIMStatusNothing
,
2136 XIMPreeditNone
| XIMStatusNone
,
2141 /* Create an X fontset on frame F with base font name
2145 xic_create_xfontset (f
, base_fontname
)
2147 char *base_fontname
;
2150 char **missing_list
;
2154 xfs
= XCreateFontSet (FRAME_X_DISPLAY (f
),
2155 base_fontname
, &missing_list
,
2156 &missing_count
, &def_string
);
2158 XFreeStringList (missing_list
);
2160 /* No need to free def_string. */
2165 /* Value is the best input style, given user preferences USER (already
2166 checked to be supported by Emacs), and styles supported by the
2167 input method XIM. */
2170 best_xim_style (user
, xim
)
2176 for (i
= 0; i
< user
->count_styles
; ++i
)
2177 for (j
= 0; j
< xim
->count_styles
; ++j
)
2178 if (user
->supported_styles
[i
] == xim
->supported_styles
[j
])
2179 return user
->supported_styles
[i
];
2181 /* Return the default style. */
2182 return XIMPreeditNothing
| XIMStatusNothing
;
2185 /* Create XIC for frame F. */
2187 static XIMStyle xic_style
;
2190 create_frame_xic (f
)
2195 XFontSet xfs
= NULL
;
2200 xim
= FRAME_X_XIM (f
);
2205 XVaNestedList preedit_attr
;
2206 XVaNestedList status_attr
;
2207 char *base_fontname
;
2210 s_area
.x
= 0; s_area
.y
= 0; s_area
.width
= 1; s_area
.height
= 1;
2211 spot
.x
= 0; spot
.y
= 1;
2212 /* Create X fontset. */
2213 fontset
= FRAME_FONTSET (f
);
2215 base_fontname
= "-*-*-*-r-normal--14-*-*-*-*-*-*-*";
2218 /* Determine the base fontname from the ASCII font name of
2220 char *ascii_font
= (char *) SDATA (fontset_ascii (fontset
));
2221 char *p
= ascii_font
;
2224 for (i
= 0; *p
; p
++)
2227 /* As the font name doesn't conform to XLFD, we can't
2228 modify it to get a suitable base fontname for the
2230 base_fontname
= "-*-*-*-r-normal--14-*-*-*-*-*-*-*";
2233 int len
= strlen (ascii_font
) + 1;
2236 for (i
= 0, p
= ascii_font
; i
< 8; p
++)
2245 base_fontname
= (char *) alloca (len
);
2246 bzero (base_fontname
, len
);
2247 strcpy (base_fontname
, "-*-*-");
2248 bcopy (p1
, base_fontname
+ 5, p
- p1
);
2249 strcat (base_fontname
, "*-*-*-*-*-*-*");
2252 xfs
= xic_create_xfontset (f
, base_fontname
);
2254 /* Determine XIC style. */
2257 XIMStyles supported_list
;
2258 supported_list
.count_styles
= (sizeof supported_xim_styles
2259 / sizeof supported_xim_styles
[0]);
2260 supported_list
.supported_styles
= supported_xim_styles
;
2261 xic_style
= best_xim_style (&supported_list
,
2262 FRAME_X_XIM_STYLES (f
));
2265 preedit_attr
= XVaCreateNestedList (0,
2268 FRAME_FOREGROUND_PIXEL (f
),
2270 FRAME_BACKGROUND_PIXEL (f
),
2271 (xic_style
& XIMPreeditPosition
2276 status_attr
= XVaCreateNestedList (0,
2282 FRAME_FOREGROUND_PIXEL (f
),
2284 FRAME_BACKGROUND_PIXEL (f
),
2287 xic
= XCreateIC (xim
,
2288 XNInputStyle
, xic_style
,
2289 XNClientWindow
, FRAME_X_WINDOW(f
),
2290 XNFocusWindow
, FRAME_X_WINDOW(f
),
2291 XNStatusAttributes
, status_attr
,
2292 XNPreeditAttributes
, preedit_attr
,
2294 XFree (preedit_attr
);
2295 XFree (status_attr
);
2298 FRAME_XIC (f
) = xic
;
2299 FRAME_XIC_STYLE (f
) = xic_style
;
2300 FRAME_XIC_FONTSET (f
) = xfs
;
2304 /* Destroy XIC and free XIC fontset of frame F, if any. */
2310 if (FRAME_XIC (f
) == NULL
)
2313 XDestroyIC (FRAME_XIC (f
));
2314 if (FRAME_XIC_FONTSET (f
))
2315 XFreeFontSet (FRAME_X_DISPLAY (f
), FRAME_XIC_FONTSET (f
));
2317 FRAME_XIC (f
) = NULL
;
2318 FRAME_XIC_FONTSET (f
) = NULL
;
2322 /* Place preedit area for XIC of window W's frame to specified
2323 pixel position X/Y. X and Y are relative to window W. */
2326 xic_set_preeditarea (w
, x
, y
)
2330 struct frame
*f
= XFRAME (w
->frame
);
2334 spot
.x
= WINDOW_TO_FRAME_PIXEL_X (w
, x
);
2335 spot
.y
= WINDOW_TO_FRAME_PIXEL_Y (w
, y
) + FONT_BASE (FRAME_FONT (f
));
2336 attr
= XVaCreateNestedList (0, XNSpotLocation
, &spot
, NULL
);
2337 XSetICValues (FRAME_XIC (f
), XNPreeditAttributes
, attr
, NULL
);
2342 /* Place status area for XIC in bottom right corner of frame F.. */
2345 xic_set_statusarea (f
)
2348 XIC xic
= FRAME_XIC (f
);
2353 /* Negotiate geometry of status area. If input method has existing
2354 status area, use its current size. */
2355 area
.x
= area
.y
= area
.width
= area
.height
= 0;
2356 attr
= XVaCreateNestedList (0, XNAreaNeeded
, &area
, NULL
);
2357 XSetICValues (xic
, XNStatusAttributes
, attr
, NULL
);
2360 attr
= XVaCreateNestedList (0, XNAreaNeeded
, &needed
, NULL
);
2361 XGetICValues (xic
, XNStatusAttributes
, attr
, NULL
);
2364 if (needed
->width
== 0) /* Use XNArea instead of XNAreaNeeded */
2366 attr
= XVaCreateNestedList (0, XNArea
, &needed
, NULL
);
2367 XGetICValues (xic
, XNStatusAttributes
, attr
, NULL
);
2371 area
.width
= needed
->width
;
2372 area
.height
= needed
->height
;
2373 area
.x
= FRAME_PIXEL_WIDTH (f
) - area
.width
- FRAME_INTERNAL_BORDER_WIDTH (f
);
2374 area
.y
= (FRAME_PIXEL_HEIGHT (f
) - area
.height
2375 - FRAME_MENUBAR_HEIGHT (f
)
2376 - FRAME_TOOLBAR_HEIGHT (f
)
2377 - FRAME_INTERNAL_BORDER_WIDTH (f
));
2380 attr
= XVaCreateNestedList (0, XNArea
, &area
, NULL
);
2381 XSetICValues(xic
, XNStatusAttributes
, attr
, NULL
);
2386 /* Set X fontset for XIC of frame F, using base font name
2387 BASE_FONTNAME. Called when a new Emacs fontset is chosen. */
2390 xic_set_xfontset (f
, base_fontname
)
2392 char *base_fontname
;
2397 xfs
= xic_create_xfontset (f
, base_fontname
);
2399 attr
= XVaCreateNestedList (0, XNFontSet
, xfs
, NULL
);
2400 if (FRAME_XIC_STYLE (f
) & XIMPreeditPosition
)
2401 XSetICValues (FRAME_XIC (f
), XNPreeditAttributes
, attr
, NULL
);
2402 if (FRAME_XIC_STYLE (f
) & XIMStatusArea
)
2403 XSetICValues (FRAME_XIC (f
), XNStatusAttributes
, attr
, NULL
);
2406 if (FRAME_XIC_FONTSET (f
))
2407 XFreeFontSet (FRAME_X_DISPLAY (f
), FRAME_XIC_FONTSET (f
));
2408 FRAME_XIC_FONTSET (f
) = xfs
;
2411 #endif /* HAVE_X_I18N */
2415 #ifdef USE_X_TOOLKIT
2417 /* Create and set up the X widget for frame F. */
2420 x_window (f
, window_prompting
, minibuffer_only
)
2422 long window_prompting
;
2423 int minibuffer_only
;
2425 XClassHint class_hints
;
2426 XSetWindowAttributes attributes
;
2427 unsigned long attribute_mask
;
2428 Widget shell_widget
;
2430 Widget frame_widget
;
2436 /* Use the resource name as the top-level widget name
2437 for looking up resources. Make a non-Lisp copy
2438 for the window manager, so GC relocation won't bother it.
2440 Elsewhere we specify the window name for the window manager. */
2443 char *str
= (char *) SDATA (Vx_resource_name
);
2444 f
->namebuf
= (char *) xmalloc (strlen (str
) + 1);
2445 strcpy (f
->namebuf
, str
);
2449 XtSetArg (al
[ac
], XtNallowShellResize
, 1); ac
++;
2450 XtSetArg (al
[ac
], XtNinput
, 1); ac
++;
2451 XtSetArg (al
[ac
], XtNmappedWhenManaged
, 0); ac
++;
2452 XtSetArg (al
[ac
], XtNborderWidth
, f
->border_width
); ac
++;
2453 XtSetArg (al
[ac
], XtNvisual
, FRAME_X_VISUAL (f
)); ac
++;
2454 XtSetArg (al
[ac
], XtNdepth
, FRAME_X_DISPLAY_INFO (f
)->n_planes
); ac
++;
2455 XtSetArg (al
[ac
], XtNcolormap
, FRAME_X_COLORMAP (f
)); ac
++;
2456 shell_widget
= XtAppCreateShell (f
->namebuf
, EMACS_CLASS
,
2457 applicationShellWidgetClass
,
2458 FRAME_X_DISPLAY (f
), al
, ac
);
2460 f
->output_data
.x
->widget
= shell_widget
;
2461 /* maybe_set_screen_title_format (shell_widget); */
2463 pane_widget
= lw_create_widget ("main", "pane", widget_id_tick
++,
2464 (widget_value
*) NULL
,
2465 shell_widget
, False
,
2469 (lw_callback
) NULL
);
2472 XtSetArg (al
[ac
], XtNvisual
, FRAME_X_VISUAL (f
)); ac
++;
2473 XtSetArg (al
[ac
], XtNdepth
, FRAME_X_DISPLAY_INFO (f
)->n_planes
); ac
++;
2474 XtSetArg (al
[ac
], XtNcolormap
, FRAME_X_COLORMAP (f
)); ac
++;
2475 XtSetValues (pane_widget
, al
, ac
);
2476 f
->output_data
.x
->column_widget
= pane_widget
;
2478 /* mappedWhenManaged to false tells to the paned window to not map/unmap
2479 the emacs screen when changing menubar. This reduces flickering. */
2482 XtSetArg (al
[ac
], XtNmappedWhenManaged
, 0); ac
++;
2483 XtSetArg (al
[ac
], XtNshowGrip
, 0); ac
++;
2484 XtSetArg (al
[ac
], XtNallowResize
, 1); ac
++;
2485 XtSetArg (al
[ac
], XtNresizeToPreferred
, 1); ac
++;
2486 XtSetArg (al
[ac
], XtNemacsFrame
, f
); ac
++;
2487 XtSetArg (al
[ac
], XtNvisual
, FRAME_X_VISUAL (f
)); ac
++;
2488 XtSetArg (al
[ac
], XtNdepth
, FRAME_X_DISPLAY_INFO (f
)->n_planes
); ac
++;
2489 XtSetArg (al
[ac
], XtNcolormap
, FRAME_X_COLORMAP (f
)); ac
++;
2490 frame_widget
= XtCreateWidget (f
->namebuf
, emacsFrameClass
, pane_widget
,
2493 f
->output_data
.x
->edit_widget
= frame_widget
;
2495 XtManageChild (frame_widget
);
2497 /* Do some needed geometry management. */
2500 char *tem
, shell_position
[32];
2503 int extra_borders
= 0;
2505 = (f
->output_data
.x
->menubar_widget
2506 ? (f
->output_data
.x
->menubar_widget
->core
.height
2507 + f
->output_data
.x
->menubar_widget
->core
.border_width
)
2510 #if 0 /* Experimentally, we now get the right results
2511 for -geometry -0-0 without this. 24 Aug 96, rms. */
2512 if (FRAME_EXTERNAL_MENU_BAR (f
))
2515 XtVaGetValues (pane_widget
, XtNinternalBorderWidth
, &ibw
, NULL
);
2516 menubar_size
+= ibw
;
2520 f
->output_data
.x
->menubar_height
= menubar_size
;
2523 /* Motif seems to need this amount added to the sizes
2524 specified for the shell widget. The Athena/Lucid widgets don't.
2525 Both conclusions reached experimentally. -- rms. */
2526 XtVaGetValues (f
->output_data
.x
->edit_widget
, XtNinternalBorderWidth
,
2527 &extra_borders
, NULL
);
2531 /* Convert our geometry parameters into a geometry string
2533 Note that we do not specify here whether the position
2534 is a user-specified or program-specified one.
2535 We pass that information later, in x_wm_set_size_hints. */
2537 int left
= f
->left_pos
;
2538 int xneg
= window_prompting
& XNegative
;
2539 int top
= f
->top_pos
;
2540 int yneg
= window_prompting
& YNegative
;
2546 if (window_prompting
& USPosition
)
2547 sprintf (shell_position
, "=%dx%d%c%d%c%d",
2548 FRAME_PIXEL_WIDTH (f
) + extra_borders
,
2549 FRAME_PIXEL_HEIGHT (f
) + menubar_size
+ extra_borders
,
2550 (xneg
? '-' : '+'), left
,
2551 (yneg
? '-' : '+'), top
);
2553 sprintf (shell_position
, "=%dx%d",
2554 FRAME_PIXEL_WIDTH (f
) + extra_borders
,
2555 FRAME_PIXEL_HEIGHT (f
) + menubar_size
+ extra_borders
);
2558 len
= strlen (shell_position
) + 1;
2559 /* We don't free this because we don't know whether
2560 it is safe to free it while the frame exists.
2561 It isn't worth the trouble of arranging to free it
2562 when the frame is deleted. */
2563 tem
= (char *) xmalloc (len
);
2564 strncpy (tem
, shell_position
, len
);
2565 XtSetArg (al
[ac
], XtNgeometry
, tem
); ac
++;
2566 XtSetValues (shell_widget
, al
, ac
);
2569 XtManageChild (pane_widget
);
2570 XtRealizeWidget (shell_widget
);
2572 FRAME_X_WINDOW (f
) = XtWindow (frame_widget
);
2574 validate_x_resource_name ();
2576 class_hints
.res_name
= (char *) SDATA (Vx_resource_name
);
2577 class_hints
.res_class
= (char *) SDATA (Vx_resource_class
);
2578 XSetClassHint (FRAME_X_DISPLAY (f
), XtWindow (shell_widget
), &class_hints
);
2581 FRAME_XIC (f
) = NULL
;
2583 create_frame_xic (f
);
2586 f
->output_data
.x
->wm_hints
.input
= True
;
2587 f
->output_data
.x
->wm_hints
.flags
|= InputHint
;
2588 XSetWMHints (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2589 &f
->output_data
.x
->wm_hints
);
2591 hack_wm_protocols (f
, shell_widget
);
2594 XtAddEventHandler (shell_widget
, 0, True
, _XEditResCheckMessages
, 0);
2597 /* Do a stupid property change to force the server to generate a
2598 PropertyNotify event so that the event_stream server timestamp will
2599 be initialized to something relevant to the time we created the window.
2601 XChangeProperty (XtDisplay (frame_widget
), XtWindow (frame_widget
),
2602 FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_protocols
,
2603 XA_ATOM
, 32, PropModeAppend
,
2604 (unsigned char*) NULL
, 0);
2606 /* Make all the standard events reach the Emacs frame. */
2607 attributes
.event_mask
= STANDARD_EVENT_SET
;
2612 /* XIM server might require some X events. */
2613 unsigned long fevent
= NoEventMask
;
2614 XGetICValues(FRAME_XIC (f
), XNFilterEvents
, &fevent
, NULL
);
2615 attributes
.event_mask
|= fevent
;
2617 #endif /* HAVE_X_I18N */
2619 attribute_mask
= CWEventMask
;
2620 XChangeWindowAttributes (XtDisplay (shell_widget
), XtWindow (shell_widget
),
2621 attribute_mask
, &attributes
);
2623 XtMapWidget (frame_widget
);
2625 /* x_set_name normally ignores requests to set the name if the
2626 requested name is the same as the current name. This is the one
2627 place where that assumption isn't correct; f->name is set, but
2628 the X server hasn't been told. */
2631 int explicit = f
->explicit_name
;
2633 f
->explicit_name
= 0;
2636 x_set_name (f
, name
, explicit);
2639 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2640 f
->output_data
.x
->text_cursor
);
2644 /* This is a no-op, except under Motif. Make sure main areas are
2645 set to something reasonable, in case we get an error later. */
2646 lw_set_main_areas (pane_widget
, 0, frame_widget
);
2649 #else /* not USE_X_TOOLKIT */
2655 if (! xg_create_frame_widgets (f
))
2656 error ("Unable to create window");
2659 FRAME_XIC (f
) = NULL
;
2663 create_frame_xic (f
);
2666 /* XIM server might require some X events. */
2667 unsigned long fevent
= NoEventMask
;
2668 XGetICValues(FRAME_XIC (f
), XNFilterEvents
, &fevent
, NULL
);
2670 if (fevent
!= NoEventMask
)
2672 XSetWindowAttributes attributes
;
2673 XWindowAttributes wattr
;
2674 unsigned long attribute_mask
;
2676 XGetWindowAttributes (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2678 attributes
.event_mask
= wattr
.your_event_mask
| fevent
;
2679 attribute_mask
= CWEventMask
;
2680 XChangeWindowAttributes (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2681 attribute_mask
, &attributes
);
2689 #else /*! USE_GTK */
2690 /* Create and set up the X window for frame F. */
2697 XClassHint class_hints
;
2698 XSetWindowAttributes attributes
;
2699 unsigned long attribute_mask
;
2701 attributes
.background_pixel
= f
->output_data
.x
->background_pixel
;
2702 attributes
.border_pixel
= f
->output_data
.x
->border_pixel
;
2703 attributes
.bit_gravity
= StaticGravity
;
2704 attributes
.backing_store
= NotUseful
;
2705 attributes
.save_under
= True
;
2706 attributes
.event_mask
= STANDARD_EVENT_SET
;
2707 attributes
.colormap
= FRAME_X_COLORMAP (f
);
2708 attribute_mask
= (CWBackPixel
| CWBorderPixel
| CWBitGravity
| CWEventMask
2713 = XCreateWindow (FRAME_X_DISPLAY (f
),
2714 f
->output_data
.x
->parent_desc
,
2717 FRAME_PIXEL_WIDTH (f
), FRAME_PIXEL_HEIGHT (f
),
2719 CopyFromParent
, /* depth */
2720 InputOutput
, /* class */
2722 attribute_mask
, &attributes
);
2727 create_frame_xic (f
);
2730 /* XIM server might require some X events. */
2731 unsigned long fevent
= NoEventMask
;
2732 XGetICValues(FRAME_XIC (f
), XNFilterEvents
, &fevent
, NULL
);
2733 attributes
.event_mask
|= fevent
;
2734 attribute_mask
= CWEventMask
;
2735 XChangeWindowAttributes (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2736 attribute_mask
, &attributes
);
2739 #endif /* HAVE_X_I18N */
2741 validate_x_resource_name ();
2743 class_hints
.res_name
= (char *) SDATA (Vx_resource_name
);
2744 class_hints
.res_class
= (char *) SDATA (Vx_resource_class
);
2745 XSetClassHint (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), &class_hints
);
2747 /* The menubar is part of the ordinary display;
2748 it does not count in addition to the height of the window. */
2749 f
->output_data
.x
->menubar_height
= 0;
2751 /* This indicates that we use the "Passive Input" input model.
2752 Unless we do this, we don't get the Focus{In,Out} events that we
2753 need to draw the cursor correctly. Accursed bureaucrats.
2754 XWhipsAndChains (FRAME_X_DISPLAY (f), IronMaiden, &TheRack); */
2756 f
->output_data
.x
->wm_hints
.input
= True
;
2757 f
->output_data
.x
->wm_hints
.flags
|= InputHint
;
2758 XSetWMHints (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2759 &f
->output_data
.x
->wm_hints
);
2760 f
->output_data
.x
->wm_hints
.icon_pixmap
= None
;
2762 /* Request "save yourself" and "delete window" commands from wm. */
2765 protocols
[0] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_delete_window
;
2766 protocols
[1] = FRAME_X_DISPLAY_INFO (f
)->Xatom_wm_save_yourself
;
2767 XSetWMProtocols (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), protocols
, 2);
2770 /* x_set_name normally ignores requests to set the name if the
2771 requested name is the same as the current name. This is the one
2772 place where that assumption isn't correct; f->name is set, but
2773 the X server hasn't been told. */
2776 int explicit = f
->explicit_name
;
2778 f
->explicit_name
= 0;
2781 x_set_name (f
, name
, explicit);
2784 XDefineCursor (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2785 f
->output_data
.x
->text_cursor
);
2789 if (FRAME_X_WINDOW (f
) == 0)
2790 error ("Unable to create window");
2793 #endif /* not USE_GTK */
2794 #endif /* not USE_X_TOOLKIT */
2796 /* Handle the icon stuff for this window. Perhaps later we might
2797 want an x_set_icon_position which can be called interactively as
2805 Lisp_Object icon_x
, icon_y
;
2806 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2808 /* Set the position of the icon. Note that twm groups all
2809 icons in an icon window. */
2810 icon_x
= x_frame_get_and_record_arg (f
, parms
, Qicon_left
, 0, 0, RES_TYPE_NUMBER
);
2811 icon_y
= x_frame_get_and_record_arg (f
, parms
, Qicon_top
, 0, 0, RES_TYPE_NUMBER
);
2812 if (!EQ (icon_x
, Qunbound
) && !EQ (icon_y
, Qunbound
))
2814 CHECK_NUMBER (icon_x
);
2815 CHECK_NUMBER (icon_y
);
2817 else if (!EQ (icon_x
, Qunbound
) || !EQ (icon_y
, Qunbound
))
2818 error ("Both left and top icon corners of icon must be specified");
2822 if (! EQ (icon_x
, Qunbound
))
2823 x_wm_set_icon_position (f
, XINT (icon_x
), XINT (icon_y
));
2825 /* Start up iconic or window? */
2826 x_wm_set_window_state
2827 (f
, (EQ (x_get_arg (dpyinfo
, parms
, Qvisibility
, 0, 0, RES_TYPE_SYMBOL
),
2832 x_text_icon (f
, (char *) SDATA ((!NILP (f
->icon_name
)
2839 /* Make the GCs needed for this window, setting the
2840 background, border and mouse colors; also create the
2841 mouse cursor and the gray border tile. */
2843 static char cursor_bits
[] =
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,
2848 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
2855 XGCValues gc_values
;
2859 /* Create the GCs of this frame.
2860 Note that many default values are used. */
2863 gc_values
.font
= FRAME_FONT (f
)->fid
;
2864 gc_values
.foreground
= f
->output_data
.x
->foreground_pixel
;
2865 gc_values
.background
= f
->output_data
.x
->background_pixel
;
2866 gc_values
.line_width
= 0; /* Means 1 using fast algorithm. */
2867 f
->output_data
.x
->normal_gc
2868 = XCreateGC (FRAME_X_DISPLAY (f
),
2870 GCLineWidth
| GCFont
| GCForeground
| GCBackground
,
2873 /* Reverse video style. */
2874 gc_values
.foreground
= f
->output_data
.x
->background_pixel
;
2875 gc_values
.background
= f
->output_data
.x
->foreground_pixel
;
2876 f
->output_data
.x
->reverse_gc
2877 = XCreateGC (FRAME_X_DISPLAY (f
),
2879 GCFont
| GCForeground
| GCBackground
| GCLineWidth
,
2882 /* Cursor has cursor-color background, background-color foreground. */
2883 gc_values
.foreground
= f
->output_data
.x
->background_pixel
;
2884 gc_values
.background
= f
->output_data
.x
->cursor_pixel
;
2885 gc_values
.fill_style
= FillOpaqueStippled
;
2887 = XCreateBitmapFromData (FRAME_X_DISPLAY (f
),
2888 FRAME_X_DISPLAY_INFO (f
)->root_window
,
2889 cursor_bits
, 16, 16);
2890 f
->output_data
.x
->cursor_gc
2891 = XCreateGC (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2892 (GCFont
| GCForeground
| GCBackground
2893 | GCFillStyle
/* | GCStipple */ | GCLineWidth
),
2897 f
->output_data
.x
->white_relief
.gc
= 0;
2898 f
->output_data
.x
->black_relief
.gc
= 0;
2900 /* Create the gray border tile used when the pointer is not in
2901 the frame. Since this depends on the frame's pixel values,
2902 this must be done on a per-frame basis. */
2903 f
->output_data
.x
->border_tile
2904 = (XCreatePixmapFromBitmapData
2905 (FRAME_X_DISPLAY (f
), FRAME_X_DISPLAY_INFO (f
)->root_window
,
2906 gray_bits
, gray_width
, gray_height
,
2907 f
->output_data
.x
->foreground_pixel
,
2908 f
->output_data
.x
->background_pixel
,
2909 DefaultDepth (FRAME_X_DISPLAY (f
), FRAME_X_SCREEN_NUMBER (f
))));
2915 /* Free what was was allocated in x_make_gc. */
2921 Display
*dpy
= FRAME_X_DISPLAY (f
);
2925 if (f
->output_data
.x
->normal_gc
)
2927 XFreeGC (dpy
, f
->output_data
.x
->normal_gc
);
2928 f
->output_data
.x
->normal_gc
= 0;
2931 if (f
->output_data
.x
->reverse_gc
)
2933 XFreeGC (dpy
, f
->output_data
.x
->reverse_gc
);
2934 f
->output_data
.x
->reverse_gc
= 0;
2937 if (f
->output_data
.x
->cursor_gc
)
2939 XFreeGC (dpy
, f
->output_data
.x
->cursor_gc
);
2940 f
->output_data
.x
->cursor_gc
= 0;
2943 if (f
->output_data
.x
->border_tile
)
2945 XFreePixmap (dpy
, f
->output_data
.x
->border_tile
);
2946 f
->output_data
.x
->border_tile
= 0;
2953 /* Handler for signals raised during x_create_frame and
2954 x_create_top_frame. FRAME is the frame which is partially
2958 unwind_create_frame (frame
)
2961 struct frame
*f
= XFRAME (frame
);
2963 /* If frame is ``official'', nothing to do. */
2964 if (!CONSP (Vframe_list
) || !EQ (XCAR (Vframe_list
), frame
))
2967 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2970 x_free_frame_resources (f
);
2972 /* Check that reference counts are indeed correct. */
2973 xassert (dpyinfo
->reference_count
== dpyinfo_refcount
);
2974 xassert (dpyinfo
->image_cache
->refcount
== image_cache_refcount
);
2982 DEFUN ("x-create-frame", Fx_create_frame
, Sx_create_frame
,
2984 doc
: /* Make a new X window, which is called a "frame" in Emacs terms.
2985 Returns an Emacs frame object.
2986 ALIST is an alist of frame parameters.
2987 If the parameters specify that the frame should not have a minibuffer,
2988 and do not specify a specific minibuffer window to use,
2989 then `default-minibuffer-frame' must be a frame whose minibuffer can
2990 be shared by the new frame.
2992 This function is an internal primitive--use `make-frame' instead. */)
2997 Lisp_Object frame
, tem
;
2999 int minibuffer_only
= 0;
3000 long window_prompting
= 0;
3002 int count
= SPECPDL_INDEX ();
3003 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
3004 Lisp_Object display
;
3005 struct x_display_info
*dpyinfo
= NULL
;
3011 /* Use this general default value to start with
3012 until we know if this frame has a specified name. */
3013 Vx_resource_name
= Vinvocation_name
;
3015 display
= x_get_arg (dpyinfo
, parms
, Qdisplay
, 0, 0, RES_TYPE_STRING
);
3016 if (EQ (display
, Qunbound
))
3018 dpyinfo
= check_x_display_info (display
);
3020 kb
= dpyinfo
->kboard
;
3022 kb
= &the_only_kboard
;
3025 name
= x_get_arg (dpyinfo
, parms
, Qname
, "name", "Name", RES_TYPE_STRING
);
3027 && ! EQ (name
, Qunbound
)
3029 error ("Invalid frame name--not a string or nil");
3032 Vx_resource_name
= name
;
3034 /* See if parent window is specified. */
3035 parent
= x_get_arg (dpyinfo
, parms
, Qparent_id
, NULL
, NULL
, RES_TYPE_NUMBER
);
3036 if (EQ (parent
, Qunbound
))
3038 if (! NILP (parent
))
3039 CHECK_NUMBER (parent
);
3041 /* make_frame_without_minibuffer can run Lisp code and garbage collect. */
3042 /* No need to protect DISPLAY because that's not used after passing
3043 it to make_frame_without_minibuffer. */
3045 GCPRO4 (parms
, parent
, name
, frame
);
3046 tem
= x_get_arg (dpyinfo
, parms
, Qminibuffer
, "minibuffer", "Minibuffer",
3048 if (EQ (tem
, Qnone
) || NILP (tem
))
3049 f
= make_frame_without_minibuffer (Qnil
, kb
, display
);
3050 else if (EQ (tem
, Qonly
))
3052 f
= make_minibuffer_frame ();
3053 minibuffer_only
= 1;
3055 else if (WINDOWP (tem
))
3056 f
= make_frame_without_minibuffer (tem
, kb
, display
);
3060 XSETFRAME (frame
, f
);
3062 /* Note that X Windows does support scroll bars. */
3063 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 1;
3065 f
->output_method
= output_x_window
;
3066 f
->output_data
.x
= (struct x_output
*) xmalloc (sizeof (struct x_output
));
3067 bzero (f
->output_data
.x
, sizeof (struct x_output
));
3068 f
->output_data
.x
->icon_bitmap
= -1;
3069 FRAME_FONTSET (f
) = -1;
3070 f
->output_data
.x
->scroll_bar_foreground_pixel
= -1;
3071 f
->output_data
.x
->scroll_bar_background_pixel
= -1;
3072 #ifdef USE_TOOLKIT_SCROLL_BARS
3073 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= -1;
3074 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= -1;
3075 #endif /* USE_TOOLKIT_SCROLL_BARS */
3076 record_unwind_protect (unwind_create_frame
, frame
);
3079 = x_get_arg (dpyinfo
, parms
, Qicon_name
, "iconName", "Title",
3081 if (! STRINGP (f
->icon_name
))
3082 f
->icon_name
= Qnil
;
3084 FRAME_X_DISPLAY_INFO (f
) = dpyinfo
;
3086 image_cache_refcount
= FRAME_X_IMAGE_CACHE (f
)->refcount
;
3087 dpyinfo_refcount
= dpyinfo
->reference_count
;
3088 #endif /* GLYPH_DEBUG */
3090 FRAME_KBOARD (f
) = kb
;
3093 /* These colors will be set anyway later, but it's important
3094 to get the color reference counts right, so initialize them! */
3097 struct gcpro gcpro1
;
3099 /* Function x_decode_color can signal an error. Make
3100 sure to initialize color slots so that we won't try
3101 to free colors we haven't allocated. */
3102 f
->output_data
.x
->foreground_pixel
= -1;
3103 f
->output_data
.x
->background_pixel
= -1;
3104 f
->output_data
.x
->cursor_pixel
= -1;
3105 f
->output_data
.x
->cursor_foreground_pixel
= -1;
3106 f
->output_data
.x
->border_pixel
= -1;
3107 f
->output_data
.x
->mouse_pixel
= -1;
3109 black
= build_string ("black");
3111 f
->output_data
.x
->foreground_pixel
3112 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3113 f
->output_data
.x
->background_pixel
3114 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3115 f
->output_data
.x
->cursor_pixel
3116 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3117 f
->output_data
.x
->cursor_foreground_pixel
3118 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3119 f
->output_data
.x
->border_pixel
3120 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3121 f
->output_data
.x
->mouse_pixel
3122 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
3126 /* Specify the parent under which to make this X window. */
3130 f
->output_data
.x
->parent_desc
= (Window
) XFASTINT (parent
);
3131 f
->output_data
.x
->explicit_parent
= 1;
3135 f
->output_data
.x
->parent_desc
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
3136 f
->output_data
.x
->explicit_parent
= 0;
3139 /* Set the name; the functions to which we pass f expect the name to
3141 if (EQ (name
, Qunbound
) || NILP (name
))
3143 f
->name
= build_string (dpyinfo
->x_id_name
);
3144 f
->explicit_name
= 0;
3149 f
->explicit_name
= 1;
3150 /* use the frame's title when getting resources for this frame. */
3151 specbind (Qx_resource_name
, name
);
3154 /* Extract the window parameters from the supplied values
3155 that are needed to determine window geometry. */
3159 font
= x_get_arg (dpyinfo
, parms
, Qfont
, "font", "Font", RES_TYPE_STRING
);
3162 /* First, try whatever font the caller has specified. */
3165 tem
= Fquery_fontset (font
, Qnil
);
3167 font
= x_new_fontset (f
, SDATA (tem
));
3169 font
= x_new_font (f
, SDATA (font
));
3172 /* Try out a font which we hope has bold and italic variations. */
3173 if (!STRINGP (font
))
3174 font
= x_new_font (f
, "-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1");
3175 if (!STRINGP (font
))
3176 font
= x_new_font (f
, "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
3177 if (! STRINGP (font
))
3178 font
= x_new_font (f
, "-*-*-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
3179 if (! STRINGP (font
))
3180 /* This was formerly the first thing tried, but it finds too many fonts
3181 and takes too long. */
3182 font
= x_new_font (f
, "-*-*-medium-r-*-*-*-*-*-*-c-*-iso8859-1");
3183 /* If those didn't work, look for something which will at least work. */
3184 if (! STRINGP (font
))
3185 font
= x_new_font (f
, "-*-fixed-*-*-*-*-*-140-*-*-c-*-iso8859-1");
3187 if (! STRINGP (font
))
3188 font
= build_string ("fixed");
3190 x_default_parameter (f
, parms
, Qfont
, font
,
3191 "font", "Font", RES_TYPE_STRING
);
3195 /* Prevent lwlib/xlwmenu.c from crashing because of a bug
3196 whereby it fails to get any font. */
3197 xlwmenu_default_font
= FRAME_FONT (f
);
3200 x_default_parameter (f
, parms
, Qborder_width
, make_number (2),
3201 "borderWidth", "BorderWidth", RES_TYPE_NUMBER
);
3203 /* This defaults to 1 in order to match xterm. We recognize either
3204 internalBorderWidth or internalBorder (which is what xterm calls
3206 if (NILP (Fassq (Qinternal_border_width
, parms
)))
3210 value
= x_get_arg (dpyinfo
, parms
, Qinternal_border_width
,
3211 "internalBorder", "internalBorder", RES_TYPE_NUMBER
);
3212 if (! EQ (value
, Qunbound
))
3213 parms
= Fcons (Fcons (Qinternal_border_width
, value
),
3216 x_default_parameter (f
, parms
, Qinternal_border_width
, make_number (1),
3217 "internalBorderWidth", "internalBorderWidth",
3219 x_default_parameter (f
, parms
, Qvertical_scroll_bars
, Qleft
,
3220 "verticalScrollBars", "ScrollBars",
3223 /* Also do the stuff which must be set before the window exists. */
3224 x_default_parameter (f
, parms
, Qforeground_color
, build_string ("black"),
3225 "foreground", "Foreground", RES_TYPE_STRING
);
3226 x_default_parameter (f
, parms
, Qbackground_color
, build_string ("white"),
3227 "background", "Background", RES_TYPE_STRING
);
3228 x_default_parameter (f
, parms
, Qmouse_color
, build_string ("black"),
3229 "pointerColor", "Foreground", RES_TYPE_STRING
);
3230 x_default_parameter (f
, parms
, Qcursor_color
, build_string ("black"),
3231 "cursorColor", "Foreground", RES_TYPE_STRING
);
3232 x_default_parameter (f
, parms
, Qborder_color
, build_string ("black"),
3233 "borderColor", "BorderColor", RES_TYPE_STRING
);
3234 x_default_parameter (f
, parms
, Qscreen_gamma
, Qnil
,
3235 "screenGamma", "ScreenGamma", RES_TYPE_FLOAT
);
3236 x_default_parameter (f
, parms
, Qline_spacing
, Qnil
,
3237 "lineSpacing", "LineSpacing", RES_TYPE_NUMBER
);
3238 x_default_parameter (f
, parms
, Qleft_fringe
, Qnil
,
3239 "leftFringe", "LeftFringe", RES_TYPE_NUMBER
);
3240 x_default_parameter (f
, parms
, Qright_fringe
, Qnil
,
3241 "rightFringe", "RightFringe", RES_TYPE_NUMBER
);
3243 x_default_scroll_bar_color_parameter (f
, parms
, Qscroll_bar_foreground
,
3244 "scrollBarForeground",
3245 "ScrollBarForeground", 1);
3246 x_default_scroll_bar_color_parameter (f
, parms
, Qscroll_bar_background
,
3247 "scrollBarBackground",
3248 "ScrollBarBackground", 0);
3250 /* Init faces before x_default_parameter is called for scroll-bar
3251 parameters because that function calls x_set_scroll_bar_width,
3252 which calls change_frame_size, which calls Fset_window_buffer,
3253 which runs hooks, which call Fvertical_motion. At the end, we
3254 end up in init_iterator with a null face cache, which should not
3256 init_frame_faces (f
);
3258 x_default_parameter (f
, parms
, Qmenu_bar_lines
, make_number (1),
3259 "menuBar", "MenuBar", RES_TYPE_NUMBER
);
3260 x_default_parameter (f
, parms
, Qtool_bar_lines
, make_number (1),
3261 "toolBar", "ToolBar", RES_TYPE_NUMBER
);
3262 x_default_parameter (f
, parms
, Qbuffer_predicate
, Qnil
,
3263 "bufferPredicate", "BufferPredicate",
3265 x_default_parameter (f
, parms
, Qtitle
, Qnil
,
3266 "title", "Title", RES_TYPE_STRING
);
3267 x_default_parameter (f
, parms
, Qwait_for_wm
, Qt
,
3268 "waitForWM", "WaitForWM", RES_TYPE_BOOLEAN
);
3269 x_default_parameter (f
, parms
, Qfullscreen
, Qnil
,
3270 "fullscreen", "Fullscreen", RES_TYPE_SYMBOL
);
3272 f
->output_data
.x
->parent_desc
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
3274 /* Compute the size of the X window. */
3275 window_prompting
= x_figure_window_size (f
, parms
, 1);
3277 tem
= x_get_arg (dpyinfo
, parms
, Qunsplittable
, 0, 0, RES_TYPE_BOOLEAN
);
3278 f
->no_split
= minibuffer_only
|| EQ (tem
, Qt
);
3280 /* Create the X widget or window. */
3281 #ifdef USE_X_TOOLKIT
3282 x_window (f
, window_prompting
, minibuffer_only
);
3290 /* Now consider the frame official. */
3291 FRAME_X_DISPLAY_INFO (f
)->reference_count
++;
3292 Vframe_list
= Fcons (frame
, Vframe_list
);
3294 /* We need to do this after creating the X window, so that the
3295 icon-creation functions can say whose icon they're describing. */
3296 x_default_parameter (f
, parms
, Qicon_type
, Qnil
,
3297 "bitmapIcon", "BitmapIcon", RES_TYPE_SYMBOL
);
3299 x_default_parameter (f
, parms
, Qauto_raise
, Qnil
,
3300 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
3301 x_default_parameter (f
, parms
, Qauto_lower
, Qnil
,
3302 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
3303 x_default_parameter (f
, parms
, Qcursor_type
, Qbox
,
3304 "cursorType", "CursorType", RES_TYPE_SYMBOL
);
3305 x_default_parameter (f
, parms
, Qscroll_bar_width
, Qnil
,
3306 "scrollBarWidth", "ScrollBarWidth",
3309 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
3310 Change will not be effected unless different from the current
3312 width
= FRAME_COLS (f
);
3313 height
= FRAME_LINES (f
);
3315 SET_FRAME_COLS (f
, 0);
3316 FRAME_LINES (f
) = 0;
3317 change_frame_size (f
, height
, width
, 1, 0, 0);
3319 /* Set up faces after all frame parameters are known. This call
3320 also merges in face attributes specified for new frames. If we
3321 don't do this, the `menu' face for instance won't have the right
3322 colors, and the menu bar won't appear in the specified colors for
3324 call1 (Qface_set_after_frame_default
, frame
);
3326 #if defined (USE_X_TOOLKIT) || defined (USE_GTK)
3327 /* Create the menu bar. */
3328 if (!minibuffer_only
&& FRAME_EXTERNAL_MENU_BAR (f
))
3330 /* If this signals an error, we haven't set size hints for the
3331 frame and we didn't make it visible. */
3332 initialize_frame_menubar (f
);
3335 /* This is a no-op, except under Motif where it arranges the
3336 main window for the widgets on it. */
3337 lw_set_main_areas (f
->output_data
.x
->column_widget
,
3338 f
->output_data
.x
->menubar_widget
,
3339 f
->output_data
.x
->edit_widget
);
3340 #endif /* not USE_GTK */
3342 #endif /* USE_X_TOOLKIT || USE_GTK */
3344 /* Tell the server what size and position, etc, we want, and how
3345 badly we want them. This should be done after we have the menu
3346 bar so that its size can be taken into account. */
3348 x_wm_set_size_hint (f
, window_prompting
, 0);
3351 /* Make the window appear on the frame and enable display, unless
3352 the caller says not to. However, with explicit parent, Emacs
3353 cannot control visibility, so don't try. */
3354 if (! f
->output_data
.x
->explicit_parent
)
3356 Lisp_Object visibility
;
3358 visibility
= x_get_arg (dpyinfo
, parms
, Qvisibility
, 0, 0,
3360 if (EQ (visibility
, Qunbound
))
3363 if (EQ (visibility
, Qicon
))
3364 x_iconify_frame (f
);
3365 else if (! NILP (visibility
))
3366 x_make_frame_visible (f
);
3368 /* Must have been Qnil. */
3374 /* Make sure windows on this frame appear in calls to next-window
3375 and similar functions. */
3376 Vwindow_list
= Qnil
;
3378 return unbind_to (count
, frame
);
3382 /* FRAME is used only to get a handle on the X display. We don't pass the
3383 display info directly because we're called from frame.c, which doesn't
3384 know about that structure. */
3387 x_get_focus_frame (frame
)
3388 struct frame
*frame
;
3390 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (frame
);
3392 if (! dpyinfo
->x_focus_frame
)
3395 XSETFRAME (xfocus
, dpyinfo
->x_focus_frame
);
3400 /* In certain situations, when the window manager follows a
3401 click-to-focus policy, there seems to be no way around calling
3402 XSetInputFocus to give another frame the input focus .
3404 In an ideal world, XSetInputFocus should generally be avoided so
3405 that applications don't interfere with the window manager's focus
3406 policy. But I think it's okay to use when it's clearly done
3407 following a user-command. */
3409 DEFUN ("x-focus-frame", Fx_focus_frame
, Sx_focus_frame
, 1, 1, 0,
3410 doc
: /* Set the input focus to FRAME.
3411 FRAME nil means use the selected frame. */)
3415 struct frame
*f
= check_x_frame (frame
);
3416 Display
*dpy
= FRAME_X_DISPLAY (f
);
3420 count
= x_catch_errors (dpy
);
3421 XSetInputFocus (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
3422 RevertToParent
, CurrentTime
);
3423 x_uncatch_errors (dpy
, count
);
3430 DEFUN ("xw-color-defined-p", Fxw_color_defined_p
, Sxw_color_defined_p
, 1, 2, 0,
3431 doc
: /* Internal function called by `color-defined-p', which see. */)
3433 Lisp_Object color
, frame
;
3436 FRAME_PTR f
= check_x_frame (frame
);
3438 CHECK_STRING (color
);
3440 if (x_defined_color (f
, SDATA (color
), &foo
, 0))
3446 DEFUN ("xw-color-values", Fxw_color_values
, Sxw_color_values
, 1, 2, 0,
3447 doc
: /* Internal function called by `color-values', which see. */)
3449 Lisp_Object color
, frame
;
3452 FRAME_PTR f
= check_x_frame (frame
);
3454 CHECK_STRING (color
);
3456 if (x_defined_color (f
, SDATA (color
), &foo
, 0))
3460 rgb
[0] = make_number (foo
.red
);
3461 rgb
[1] = make_number (foo
.green
);
3462 rgb
[2] = make_number (foo
.blue
);
3463 return Flist (3, rgb
);
3469 DEFUN ("xw-display-color-p", Fxw_display_color_p
, Sxw_display_color_p
, 0, 1, 0,
3470 doc
: /* Internal function called by `display-color-p', which see. */)
3472 Lisp_Object display
;
3474 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3476 if (dpyinfo
->n_planes
<= 2)
3479 switch (dpyinfo
->visual
->class)
3492 DEFUN ("x-display-grayscale-p", Fx_display_grayscale_p
, Sx_display_grayscale_p
,
3494 doc
: /* Return t if the X display supports shades of gray.
3495 Note that color displays do support shades of gray.
3496 The optional argument DISPLAY specifies which display to ask about.
3497 DISPLAY should be either a frame or a display name (a string).
3498 If omitted or nil, that stands for the selected frame's display. */)
3500 Lisp_Object display
;
3502 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3504 if (dpyinfo
->n_planes
<= 1)
3507 switch (dpyinfo
->visual
->class)
3522 DEFUN ("x-display-pixel-width", Fx_display_pixel_width
, Sx_display_pixel_width
,
3524 doc
: /* Returns the width in pixels of the X display DISPLAY.
3525 The optional argument DISPLAY specifies which display to ask about.
3526 DISPLAY should be either a frame or a display name (a string).
3527 If omitted or nil, that stands for the selected frame's display. */)
3529 Lisp_Object display
;
3531 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3533 return make_number (dpyinfo
->width
);
3536 DEFUN ("x-display-pixel-height", Fx_display_pixel_height
,
3537 Sx_display_pixel_height
, 0, 1, 0,
3538 doc
: /* Returns the height in pixels of the X display DISPLAY.
3539 The optional argument DISPLAY specifies which display to ask about.
3540 DISPLAY should be either a frame or a display name (a string).
3541 If omitted or nil, that stands for the selected frame's display. */)
3543 Lisp_Object display
;
3545 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3547 return make_number (dpyinfo
->height
);
3550 DEFUN ("x-display-planes", Fx_display_planes
, Sx_display_planes
,
3552 doc
: /* Returns the number of bitplanes of the X display DISPLAY.
3553 The optional argument DISPLAY specifies which display to ask about.
3554 DISPLAY should be either a frame or a display name (a string).
3555 If omitted or nil, that stands for the selected frame's display. */)
3557 Lisp_Object display
;
3559 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3561 return make_number (dpyinfo
->n_planes
);
3564 DEFUN ("x-display-color-cells", Fx_display_color_cells
, Sx_display_color_cells
,
3566 doc
: /* Returns the number of color cells of the X display DISPLAY.
3567 The optional argument DISPLAY specifies which display to ask about.
3568 DISPLAY should be either a frame or a display name (a string).
3569 If omitted or nil, that stands for the selected frame's display. */)
3571 Lisp_Object display
;
3573 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3575 return make_number (DisplayCells (dpyinfo
->display
,
3576 XScreenNumberOfScreen (dpyinfo
->screen
)));
3579 DEFUN ("x-server-max-request-size", Fx_server_max_request_size
,
3580 Sx_server_max_request_size
,
3582 doc
: /* Returns the maximum request size of the X server of display DISPLAY.
3583 The optional argument DISPLAY specifies which display to ask about.
3584 DISPLAY should be either a frame or a display name (a string).
3585 If omitted or nil, that stands for the selected frame's display. */)
3587 Lisp_Object display
;
3589 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3591 return make_number (MAXREQUEST (dpyinfo
->display
));
3594 DEFUN ("x-server-vendor", Fx_server_vendor
, Sx_server_vendor
, 0, 1, 0,
3595 doc
: /* Returns the vendor ID string of the X server of display DISPLAY.
3596 The optional argument DISPLAY specifies which display to ask about.
3597 DISPLAY should be either a frame or a display name (a string).
3598 If omitted or nil, that stands for the selected frame's display. */)
3600 Lisp_Object display
;
3602 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3603 char *vendor
= ServerVendor (dpyinfo
->display
);
3605 if (! vendor
) vendor
= "";
3606 return build_string (vendor
);
3609 DEFUN ("x-server-version", Fx_server_version
, Sx_server_version
, 0, 1, 0,
3610 doc
: /* Returns the version numbers of the X server of display DISPLAY.
3611 The value is a list of three integers: the major and minor
3612 version numbers of the X Protocol in use, and the vendor-specific release
3613 number. See also the function `x-server-vendor'.
3615 The optional argument DISPLAY specifies which display to ask about.
3616 DISPLAY should be either a frame or a display name (a string).
3617 If omitted or nil, that stands for the selected frame's display. */)
3619 Lisp_Object display
;
3621 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3622 Display
*dpy
= dpyinfo
->display
;
3624 return Fcons (make_number (ProtocolVersion (dpy
)),
3625 Fcons (make_number (ProtocolRevision (dpy
)),
3626 Fcons (make_number (VendorRelease (dpy
)), Qnil
)));
3629 DEFUN ("x-display-screens", Fx_display_screens
, Sx_display_screens
, 0, 1, 0,
3630 doc
: /* Return the number of screens on the X server of display DISPLAY.
3631 The optional argument DISPLAY specifies which display to ask about.
3632 DISPLAY should be either a frame or a display name (a string).
3633 If omitted or nil, that stands for the selected frame's display. */)
3635 Lisp_Object display
;
3637 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3639 return make_number (ScreenCount (dpyinfo
->display
));
3642 DEFUN ("x-display-mm-height", Fx_display_mm_height
, Sx_display_mm_height
, 0, 1, 0,
3643 doc
: /* Return the height in millimeters of the X display DISPLAY.
3644 The optional argument DISPLAY specifies which display to ask about.
3645 DISPLAY should be either a frame or a display name (a string).
3646 If omitted or nil, that stands for the selected frame's display. */)
3648 Lisp_Object display
;
3650 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3652 return make_number (HeightMMOfScreen (dpyinfo
->screen
));
3655 DEFUN ("x-display-mm-width", Fx_display_mm_width
, Sx_display_mm_width
, 0, 1, 0,
3656 doc
: /* Return the width in millimeters of the X display DISPLAY.
3657 The optional argument DISPLAY specifies which display to ask about.
3658 DISPLAY should be either a frame or a display name (a string).
3659 If omitted or nil, that stands for the selected frame's display. */)
3661 Lisp_Object display
;
3663 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3665 return make_number (WidthMMOfScreen (dpyinfo
->screen
));
3668 DEFUN ("x-display-backing-store", Fx_display_backing_store
,
3669 Sx_display_backing_store
, 0, 1, 0,
3670 doc
: /* Returns an indication of whether X display DISPLAY does backing store.
3671 The value may be `always', `when-mapped', or `not-useful'.
3672 The optional argument DISPLAY specifies which display to ask about.
3673 DISPLAY should be either a frame or a display name (a string).
3674 If omitted or nil, that stands for the selected frame's display. */)
3676 Lisp_Object display
;
3678 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3681 switch (DoesBackingStore (dpyinfo
->screen
))
3684 result
= intern ("always");
3688 result
= intern ("when-mapped");
3692 result
= intern ("not-useful");
3696 error ("Strange value for BackingStore parameter of screen");
3703 DEFUN ("x-display-visual-class", Fx_display_visual_class
,
3704 Sx_display_visual_class
, 0, 1, 0,
3705 doc
: /* Return the visual class of the X display DISPLAY.
3706 The value is one of the symbols `static-gray', `gray-scale',
3707 `static-color', `pseudo-color', `true-color', or `direct-color'.
3709 The optional argument DISPLAY specifies which display to ask about.
3710 DISPLAY should be either a frame or a display name (a string).
3711 If omitted or nil, that stands for the selected frame's display. */)
3713 Lisp_Object display
;
3715 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3718 switch (dpyinfo
->visual
->class)
3721 result
= intern ("static-gray");
3724 result
= intern ("gray-scale");
3727 result
= intern ("static-color");
3730 result
= intern ("pseudo-color");
3733 result
= intern ("true-color");
3736 result
= intern ("direct-color");
3739 error ("Display has an unknown visual class");
3746 DEFUN ("x-display-save-under", Fx_display_save_under
,
3747 Sx_display_save_under
, 0, 1, 0,
3748 doc
: /* Returns t if the X display DISPLAY supports the save-under feature.
3749 The optional argument DISPLAY specifies which display to ask about.
3750 DISPLAY should be either a frame or a display name (a string).
3751 If omitted or nil, that stands for the selected frame's display. */)
3753 Lisp_Object display
;
3755 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
3757 if (DoesSaveUnders (dpyinfo
->screen
) == True
)
3765 register struct frame
*f
;
3767 return FRAME_PIXEL_WIDTH (f
);
3772 register struct frame
*f
;
3774 return FRAME_PIXEL_HEIGHT (f
);
3779 register struct frame
*f
;
3781 return FRAME_COLUMN_WIDTH (f
);
3786 register struct frame
*f
;
3788 return FRAME_LINE_HEIGHT (f
);
3793 register struct frame
*f
;
3795 return FRAME_X_DISPLAY_INFO (f
)->n_planes
;
3800 /************************************************************************
3802 ************************************************************************/
3805 /* Mapping visual names to visuals. */
3807 static struct visual_class
3814 {"StaticGray", StaticGray
},
3815 {"GrayScale", GrayScale
},
3816 {"StaticColor", StaticColor
},
3817 {"PseudoColor", PseudoColor
},
3818 {"TrueColor", TrueColor
},
3819 {"DirectColor", DirectColor
},
3824 #ifndef HAVE_XSCREENNUMBEROFSCREEN
3826 /* Value is the screen number of screen SCR. This is a substitute for
3827 the X function with the same name when that doesn't exist. */
3830 XScreenNumberOfScreen (scr
)
3831 register Screen
*scr
;
3833 Display
*dpy
= scr
->display
;
3836 for (i
= 0; i
< dpy
->nscreens
; ++i
)
3837 if (scr
== dpy
->screens
+ i
)
3843 #endif /* not HAVE_XSCREENNUMBEROFSCREEN */
3846 /* Select the visual that should be used on display DPYINFO. Set
3847 members of DPYINFO appropriately. Called from x_term_init. */
3850 select_visual (dpyinfo
)
3851 struct x_display_info
*dpyinfo
;
3853 Display
*dpy
= dpyinfo
->display
;
3854 Screen
*screen
= dpyinfo
->screen
;
3857 /* See if a visual is specified. */
3858 value
= display_x_get_resource (dpyinfo
,
3859 build_string ("visualClass"),
3860 build_string ("VisualClass"),
3862 if (STRINGP (value
))
3864 /* VALUE should be of the form CLASS-DEPTH, where CLASS is one
3865 of `PseudoColor', `TrueColor' etc. and DEPTH is the color
3866 depth, a decimal number. NAME is compared with case ignored. */
3867 char *s
= (char *) alloca (SBYTES (value
) + 1);
3872 strcpy (s
, SDATA (value
));
3873 dash
= index (s
, '-');
3876 dpyinfo
->n_planes
= atoi (dash
+ 1);
3880 /* We won't find a matching visual with depth 0, so that
3881 an error will be printed below. */
3882 dpyinfo
->n_planes
= 0;
3884 /* Determine the visual class. */
3885 for (i
= 0; visual_classes
[i
].name
; ++i
)
3886 if (xstricmp (s
, visual_classes
[i
].name
) == 0)
3888 class = visual_classes
[i
].class;
3892 /* Look up a matching visual for the specified class. */
3894 || !XMatchVisualInfo (dpy
, XScreenNumberOfScreen (screen
),
3895 dpyinfo
->n_planes
, class, &vinfo
))
3896 fatal ("Invalid visual specification `%s'", SDATA (value
));
3898 dpyinfo
->visual
= vinfo
.visual
;
3903 XVisualInfo
*vinfo
, vinfo_template
;
3905 dpyinfo
->visual
= DefaultVisualOfScreen (screen
);
3908 vinfo_template
.visualid
= XVisualIDFromVisual (dpyinfo
->visual
);
3910 vinfo_template
.visualid
= dpyinfo
->visual
->visualid
;
3912 vinfo_template
.screen
= XScreenNumberOfScreen (screen
);
3913 vinfo
= XGetVisualInfo (dpy
, VisualIDMask
| VisualScreenMask
,
3914 &vinfo_template
, &n_visuals
);
3916 fatal ("Can't get proper X visual info");
3918 dpyinfo
->n_planes
= vinfo
->depth
;
3919 XFree ((char *) vinfo
);
3924 /* Return the X display structure for the display named NAME.
3925 Open a new connection if necessary. */
3927 struct x_display_info
*
3928 x_display_info_for_name (name
)
3932 struct x_display_info
*dpyinfo
;
3934 CHECK_STRING (name
);
3936 if (! EQ (Vwindow_system
, intern ("x")))
3937 error ("Not using X Windows");
3939 for (dpyinfo
= x_display_list
, names
= x_display_name_list
;
3941 dpyinfo
= dpyinfo
->next
, names
= XCDR (names
))
3944 tem
= Fstring_equal (XCAR (XCAR (names
)), name
);
3949 /* Use this general default value to start with. */
3950 Vx_resource_name
= Vinvocation_name
;
3952 validate_x_resource_name ();
3954 dpyinfo
= x_term_init (name
, (char *)0,
3955 (char *) SDATA (Vx_resource_name
));
3958 error ("Cannot connect to X server %s", SDATA (name
));
3961 XSETFASTINT (Vwindow_system_version
, 11);
3967 DEFUN ("x-open-connection", Fx_open_connection
, Sx_open_connection
,
3969 doc
: /* Open a connection to an X server.
3970 DISPLAY is the name of the display to connect to.
3971 Optional second arg XRM-STRING is a string of resources in xrdb format.
3972 If the optional third arg MUST-SUCCEED is non-nil,
3973 terminate Emacs if we can't open the connection. */)
3974 (display
, xrm_string
, must_succeed
)
3975 Lisp_Object display
, xrm_string
, must_succeed
;
3977 unsigned char *xrm_option
;
3978 struct x_display_info
*dpyinfo
;
3980 CHECK_STRING (display
);
3981 if (! NILP (xrm_string
))
3982 CHECK_STRING (xrm_string
);
3984 if (! EQ (Vwindow_system
, intern ("x")))
3985 error ("Not using X Windows");
3987 if (! NILP (xrm_string
))
3988 xrm_option
= (unsigned char *) SDATA (xrm_string
);
3990 xrm_option
= (unsigned char *) 0;
3992 validate_x_resource_name ();
3994 /* This is what opens the connection and sets x_current_display.
3995 This also initializes many symbols, such as those used for input. */
3996 dpyinfo
= x_term_init (display
, xrm_option
,
3997 (char *) SDATA (Vx_resource_name
));
4001 if (!NILP (must_succeed
))
4002 fatal ("Cannot connect to X server %s.\n\
4003 Check the DISPLAY environment variable or use `-d'.\n\
4004 Also use the `xauth' program to verify that you have the proper\n\
4005 authorization information needed to connect the X server.\n\
4006 An insecure way to solve the problem may be to use `xhost'.\n",
4009 error ("Cannot connect to X server %s", SDATA (display
));
4014 XSETFASTINT (Vwindow_system_version
, 11);
4018 DEFUN ("x-close-connection", Fx_close_connection
,
4019 Sx_close_connection
, 1, 1, 0,
4020 doc
: /* Close the connection to DISPLAY's X server.
4021 For DISPLAY, specify either a frame or a display name (a string).
4022 If DISPLAY is nil, that stands for the selected frame's display. */)
4024 Lisp_Object display
;
4026 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
4029 if (dpyinfo
->reference_count
> 0)
4030 error ("Display still has frames on it");
4033 /* Free the fonts in the font table. */
4034 for (i
= 0; i
< dpyinfo
->n_fonts
; i
++)
4035 if (dpyinfo
->font_table
[i
].name
)
4037 if (dpyinfo
->font_table
[i
].name
!= dpyinfo
->font_table
[i
].full_name
)
4038 xfree (dpyinfo
->font_table
[i
].full_name
);
4039 xfree (dpyinfo
->font_table
[i
].name
);
4040 XFreeFont (dpyinfo
->display
, dpyinfo
->font_table
[i
].font
);
4043 x_destroy_all_bitmaps (dpyinfo
);
4044 XSetCloseDownMode (dpyinfo
->display
, DestroyAll
);
4046 #ifdef USE_X_TOOLKIT
4047 XtCloseDisplay (dpyinfo
->display
);
4049 XCloseDisplay (dpyinfo
->display
);
4052 x_delete_display (dpyinfo
);
4058 DEFUN ("x-display-list", Fx_display_list
, Sx_display_list
, 0, 0, 0,
4059 doc
: /* Return the list of display names that Emacs has connections to. */)
4062 Lisp_Object tail
, result
;
4065 for (tail
= x_display_name_list
; ! NILP (tail
); tail
= XCDR (tail
))
4066 result
= Fcons (XCAR (XCAR (tail
)), result
);
4071 DEFUN ("x-synchronize", Fx_synchronize
, Sx_synchronize
, 1, 2, 0,
4072 doc
: /* If ON is non-nil, report X errors as soon as the erring request is made.
4073 If ON is nil, allow buffering of requests.
4074 Turning on synchronization prohibits the Xlib routines from buffering
4075 requests and seriously degrades performance, but makes debugging much
4077 The optional second argument DISPLAY specifies which display to act on.
4078 DISPLAY should be either a frame or a display name (a string).
4079 If DISPLAY is omitted or nil, that stands for the selected frame's display. */)
4081 Lisp_Object display
, on
;
4083 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
4085 XSynchronize (dpyinfo
->display
, !EQ (on
, Qnil
));
4090 /* Wait for responses to all X commands issued so far for frame F. */
4097 XSync (FRAME_X_DISPLAY (f
), False
);
4102 /***********************************************************************
4104 ***********************************************************************/
4106 /* Value is the number of elements of vector VECTOR. */
4108 #define DIM(VECTOR) (sizeof (VECTOR) / sizeof *(VECTOR))
4110 /* List of supported image types. Use define_image_type to add new
4111 types. Use lookup_image_type to find a type for a given symbol. */
4113 static struct image_type
*image_types
;
4115 /* The symbol `image' which is the car of the lists used to represent
4118 extern Lisp_Object Qimage
;
4120 /* The symbol `xbm' which is used as the type symbol for XBM images. */
4126 extern Lisp_Object QCwidth
, QCheight
, QCforeground
, QCbackground
, QCfile
;
4127 extern Lisp_Object QCdata
, QCtype
;
4128 Lisp_Object QCascent
, QCmargin
, QCrelief
;
4129 Lisp_Object QCconversion
, QCcolor_symbols
, QCheuristic_mask
;
4130 Lisp_Object QCindex
, QCmatrix
, QCcolor_adjustment
, QCmask
;
4132 /* Other symbols. */
4134 Lisp_Object Qlaplace
, Qemboss
, Qedge_detection
, Qheuristic
;
4136 /* Time in seconds after which images should be removed from the cache
4137 if not displayed. */
4139 Lisp_Object Vimage_cache_eviction_delay
;
4141 /* Function prototypes. */
4143 static void define_image_type
P_ ((struct image_type
*type
));
4144 static struct image_type
*lookup_image_type
P_ ((Lisp_Object symbol
));
4145 static void image_error
P_ ((char *format
, Lisp_Object
, Lisp_Object
));
4146 static void x_laplace
P_ ((struct frame
*, struct image
*));
4147 static void x_emboss
P_ ((struct frame
*, struct image
*));
4148 static int x_build_heuristic_mask
P_ ((struct frame
*, struct image
*,
4152 /* Define a new image type from TYPE. This adds a copy of TYPE to
4153 image_types and adds the symbol *TYPE->type to Vimage_types. */
4156 define_image_type (type
)
4157 struct image_type
*type
;
4159 /* Make a copy of TYPE to avoid a bus error in a dumped Emacs.
4160 The initialized data segment is read-only. */
4161 struct image_type
*p
= (struct image_type
*) xmalloc (sizeof *p
);
4162 bcopy (type
, p
, sizeof *p
);
4163 p
->next
= image_types
;
4165 Vimage_types
= Fcons (*p
->type
, Vimage_types
);
4169 /* Look up image type SYMBOL, and return a pointer to its image_type
4170 structure. Value is null if SYMBOL is not a known image type. */
4172 static INLINE
struct image_type
*
4173 lookup_image_type (symbol
)
4176 struct image_type
*type
;
4178 for (type
= image_types
; type
; type
= type
->next
)
4179 if (EQ (symbol
, *type
->type
))
4186 /* Value is non-zero if OBJECT is a valid Lisp image specification. A
4187 valid image specification is a list whose car is the symbol
4188 `image', and whose rest is a property list. The property list must
4189 contain a value for key `:type'. That value must be the name of a
4190 supported image type. The rest of the property list depends on the
4194 valid_image_p (object
)
4199 if (CONSP (object
) && EQ (XCAR (object
), Qimage
))
4203 for (tem
= XCDR (object
); CONSP (tem
); tem
= XCDR (tem
))
4204 if (EQ (XCAR (tem
), QCtype
))
4207 if (CONSP (tem
) && SYMBOLP (XCAR (tem
)))
4209 struct image_type
*type
;
4210 type
= lookup_image_type (XCAR (tem
));
4212 valid_p
= type
->valid_p (object
);
4223 /* Log error message with format string FORMAT and argument ARG.
4224 Signaling an error, e.g. when an image cannot be loaded, is not a
4225 good idea because this would interrupt redisplay, and the error
4226 message display would lead to another redisplay. This function
4227 therefore simply displays a message. */
4230 image_error (format
, arg1
, arg2
)
4232 Lisp_Object arg1
, arg2
;
4234 add_to_log (format
, arg1
, arg2
);
4239 /***********************************************************************
4240 Image specifications
4241 ***********************************************************************/
4243 enum image_value_type
4245 IMAGE_DONT_CHECK_VALUE_TYPE
,
4247 IMAGE_STRING_OR_NIL_VALUE
,
4249 IMAGE_POSITIVE_INTEGER_VALUE
,
4250 IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
,
4251 IMAGE_NON_NEGATIVE_INTEGER_VALUE
,
4253 IMAGE_INTEGER_VALUE
,
4254 IMAGE_FUNCTION_VALUE
,
4259 /* Structure used when parsing image specifications. */
4261 struct image_keyword
4263 /* Name of keyword. */
4266 /* The type of value allowed. */
4267 enum image_value_type type
;
4269 /* Non-zero means key must be present. */
4272 /* Used to recognize duplicate keywords in a property list. */
4275 /* The value that was found. */
4280 static int parse_image_spec
P_ ((Lisp_Object
, struct image_keyword
*,
4282 static Lisp_Object image_spec_value
P_ ((Lisp_Object
, Lisp_Object
, int *));
4285 /* Parse image spec SPEC according to KEYWORDS. A valid image spec
4286 has the format (image KEYWORD VALUE ...). One of the keyword/
4287 value pairs must be `:type TYPE'. KEYWORDS is a vector of
4288 image_keywords structures of size NKEYWORDS describing other
4289 allowed keyword/value pairs. Value is non-zero if SPEC is valid. */
4292 parse_image_spec (spec
, keywords
, nkeywords
, type
)
4294 struct image_keyword
*keywords
;
4301 if (!CONSP (spec
) || !EQ (XCAR (spec
), Qimage
))
4304 plist
= XCDR (spec
);
4305 while (CONSP (plist
))
4307 Lisp_Object key
, value
;
4309 /* First element of a pair must be a symbol. */
4311 plist
= XCDR (plist
);
4315 /* There must follow a value. */
4318 value
= XCAR (plist
);
4319 plist
= XCDR (plist
);
4321 /* Find key in KEYWORDS. Error if not found. */
4322 for (i
= 0; i
< nkeywords
; ++i
)
4323 if (strcmp (keywords
[i
].name
, SDATA (SYMBOL_NAME (key
))) == 0)
4329 /* Record that we recognized the keyword. If a keywords
4330 was found more than once, it's an error. */
4331 keywords
[i
].value
= value
;
4332 ++keywords
[i
].count
;
4334 if (keywords
[i
].count
> 1)
4337 /* Check type of value against allowed type. */
4338 switch (keywords
[i
].type
)
4340 case IMAGE_STRING_VALUE
:
4341 if (!STRINGP (value
))
4345 case IMAGE_STRING_OR_NIL_VALUE
:
4346 if (!STRINGP (value
) && !NILP (value
))
4350 case IMAGE_SYMBOL_VALUE
:
4351 if (!SYMBOLP (value
))
4355 case IMAGE_POSITIVE_INTEGER_VALUE
:
4356 if (!INTEGERP (value
) || XINT (value
) <= 0)
4360 case IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
:
4361 if (INTEGERP (value
) && XINT (value
) >= 0)
4364 && INTEGERP (XCAR (value
)) && INTEGERP (XCDR (value
))
4365 && XINT (XCAR (value
)) >= 0 && XINT (XCDR (value
)) >= 0)
4369 case IMAGE_ASCENT_VALUE
:
4370 if (SYMBOLP (value
) && EQ (value
, Qcenter
))
4372 else if (INTEGERP (value
)
4373 && XINT (value
) >= 0
4374 && XINT (value
) <= 100)
4378 case IMAGE_NON_NEGATIVE_INTEGER_VALUE
:
4379 if (!INTEGERP (value
) || XINT (value
) < 0)
4383 case IMAGE_DONT_CHECK_VALUE_TYPE
:
4386 case IMAGE_FUNCTION_VALUE
:
4387 value
= indirect_function (value
);
4389 || COMPILEDP (value
)
4390 || (CONSP (value
) && EQ (XCAR (value
), Qlambda
)))
4394 case IMAGE_NUMBER_VALUE
:
4395 if (!INTEGERP (value
) && !FLOATP (value
))
4399 case IMAGE_INTEGER_VALUE
:
4400 if (!INTEGERP (value
))
4404 case IMAGE_BOOL_VALUE
:
4405 if (!NILP (value
) && !EQ (value
, Qt
))
4414 if (EQ (key
, QCtype
) && !EQ (type
, value
))
4418 /* Check that all mandatory fields are present. */
4419 for (i
= 0; i
< nkeywords
; ++i
)
4420 if (keywords
[i
].mandatory_p
&& keywords
[i
].count
== 0)
4423 return NILP (plist
);
4427 /* Return the value of KEY in image specification SPEC. Value is nil
4428 if KEY is not present in SPEC. if FOUND is not null, set *FOUND
4429 to 1 if KEY was found in SPEC, set it to 0 otherwise. */
4432 image_spec_value (spec
, key
, found
)
4433 Lisp_Object spec
, key
;
4438 xassert (valid_image_p (spec
));
4440 for (tail
= XCDR (spec
);
4441 CONSP (tail
) && CONSP (XCDR (tail
));
4442 tail
= XCDR (XCDR (tail
)))
4444 if (EQ (XCAR (tail
), key
))
4448 return XCAR (XCDR (tail
));
4458 DEFUN ("image-size", Fimage_size
, Simage_size
, 1, 3, 0,
4459 doc
: /* Return the size of image SPEC as pair (WIDTH . HEIGHT).
4460 PIXELS non-nil means return the size in pixels, otherwise return the
4461 size in canonical character units.
4462 FRAME is the frame on which the image will be displayed. FRAME nil
4463 or omitted means use the selected frame. */)
4464 (spec
, pixels
, frame
)
4465 Lisp_Object spec
, pixels
, frame
;
4470 if (valid_image_p (spec
))
4472 struct frame
*f
= check_x_frame (frame
);
4473 int id
= lookup_image (f
, spec
);
4474 struct image
*img
= IMAGE_FROM_ID (f
, id
);
4475 int width
= img
->width
+ 2 * img
->hmargin
;
4476 int height
= img
->height
+ 2 * img
->vmargin
;
4479 size
= Fcons (make_float ((double) width
/ FRAME_COLUMN_WIDTH (f
)),
4480 make_float ((double) height
/ FRAME_LINE_HEIGHT (f
)));
4482 size
= Fcons (make_number (width
), make_number (height
));
4485 error ("Invalid image specification");
4491 DEFUN ("image-mask-p", Fimage_mask_p
, Simage_mask_p
, 1, 2, 0,
4492 doc
: /* Return t if image SPEC has a mask bitmap.
4493 FRAME is the frame on which the image will be displayed. FRAME nil
4494 or omitted means use the selected frame. */)
4496 Lisp_Object spec
, frame
;
4501 if (valid_image_p (spec
))
4503 struct frame
*f
= check_x_frame (frame
);
4504 int id
= lookup_image (f
, spec
);
4505 struct image
*img
= IMAGE_FROM_ID (f
, id
);
4510 error ("Invalid image specification");
4517 /***********************************************************************
4518 Image type independent image structures
4519 ***********************************************************************/
4521 static struct image
*make_image
P_ ((Lisp_Object spec
, unsigned hash
));
4522 static void free_image
P_ ((struct frame
*f
, struct image
*img
));
4525 /* Allocate and return a new image structure for image specification
4526 SPEC. SPEC has a hash value of HASH. */
4528 static struct image
*
4529 make_image (spec
, hash
)
4533 struct image
*img
= (struct image
*) xmalloc (sizeof *img
);
4535 xassert (valid_image_p (spec
));
4536 bzero (img
, sizeof *img
);
4537 img
->type
= lookup_image_type (image_spec_value (spec
, QCtype
, NULL
));
4538 xassert (img
->type
!= NULL
);
4540 img
->data
.lisp_val
= Qnil
;
4541 img
->ascent
= DEFAULT_IMAGE_ASCENT
;
4547 /* Free image IMG which was used on frame F, including its resources. */
4556 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
4558 /* Remove IMG from the hash table of its cache. */
4560 img
->prev
->next
= img
->next
;
4562 c
->buckets
[img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
] = img
->next
;
4565 img
->next
->prev
= img
->prev
;
4567 c
->images
[img
->id
] = NULL
;
4569 /* Free resources, then free IMG. */
4570 img
->type
->free (f
, img
);
4576 /* Prepare image IMG for display on frame F. Must be called before
4577 drawing an image. */
4580 prepare_image_for_display (f
, img
)
4586 /* We're about to display IMG, so set its timestamp to `now'. */
4588 img
->timestamp
= EMACS_SECS (t
);
4590 /* If IMG doesn't have a pixmap yet, load it now, using the image
4591 type dependent loader function. */
4592 if (img
->pixmap
== None
&& !img
->load_failed_p
)
4593 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
4597 /* Value is the number of pixels for the ascent of image IMG when
4598 drawn in face FACE. */
4601 image_ascent (img
, face
)
4605 int height
= img
->height
+ img
->vmargin
;
4608 if (img
->ascent
== CENTERED_IMAGE_ASCENT
)
4611 /* This expression is arranged so that if the image can't be
4612 exactly centered, it will be moved slightly up. This is
4613 because a typical font is `top-heavy' (due to the presence
4614 uppercase letters), so the image placement should err towards
4615 being top-heavy too. It also just generally looks better. */
4616 ascent
= (height
+ face
->font
->ascent
- face
->font
->descent
+ 1) / 2;
4618 ascent
= height
/ 2;
4621 ascent
= height
* img
->ascent
/ 100.0;
4627 /* Image background colors. */
4629 static unsigned long
4630 four_corners_best (ximg
, width
, height
)
4632 unsigned long width
, height
;
4634 unsigned long corners
[4], best
;
4637 /* Get the colors at the corners of ximg. */
4638 corners
[0] = XGetPixel (ximg
, 0, 0);
4639 corners
[1] = XGetPixel (ximg
, width
- 1, 0);
4640 corners
[2] = XGetPixel (ximg
, width
- 1, height
- 1);
4641 corners
[3] = XGetPixel (ximg
, 0, height
- 1);
4643 /* Choose the most frequently found color as background. */
4644 for (i
= best_count
= 0; i
< 4; ++i
)
4648 for (j
= n
= 0; j
< 4; ++j
)
4649 if (corners
[i
] == corners
[j
])
4653 best
= corners
[i
], best_count
= n
;
4659 /* Return the `background' field of IMG. If IMG doesn't have one yet,
4660 it is guessed heuristically. If non-zero, XIMG is an existing XImage
4661 object to use for the heuristic. */
4664 image_background (img
, f
, ximg
)
4669 if (! img
->background_valid
)
4670 /* IMG doesn't have a background yet, try to guess a reasonable value. */
4672 int free_ximg
= !ximg
;
4675 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
4676 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4678 img
->background
= four_corners_best (ximg
, img
->width
, img
->height
);
4681 XDestroyImage (ximg
);
4683 img
->background_valid
= 1;
4686 return img
->background
;
4689 /* Return the `background_transparent' field of IMG. If IMG doesn't
4690 have one yet, it is guessed heuristically. If non-zero, MASK is an
4691 existing XImage object to use for the heuristic. */
4694 image_background_transparent (img
, f
, mask
)
4699 if (! img
->background_transparent_valid
)
4700 /* IMG doesn't have a background yet, try to guess a reasonable value. */
4704 int free_mask
= !mask
;
4707 mask
= XGetImage (FRAME_X_DISPLAY (f
), img
->mask
,
4708 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
4710 img
->background_transparent
4711 = !four_corners_best (mask
, img
->width
, img
->height
);
4714 XDestroyImage (mask
);
4717 img
->background_transparent
= 0;
4719 img
->background_transparent_valid
= 1;
4722 return img
->background_transparent
;
4726 /***********************************************************************
4727 Helper functions for X image types
4728 ***********************************************************************/
4730 static void x_clear_image_1
P_ ((struct frame
*, struct image
*, int,
4732 static void x_clear_image
P_ ((struct frame
*f
, struct image
*img
));
4733 static unsigned long x_alloc_image_color
P_ ((struct frame
*f
,
4735 Lisp_Object color_name
,
4736 unsigned long dflt
));
4739 /* Clear X resources of image IMG on frame F. PIXMAP_P non-zero means
4740 free the pixmap if any. MASK_P non-zero means clear the mask
4741 pixmap if any. COLORS_P non-zero means free colors allocated for
4742 the image, if any. */
4745 x_clear_image_1 (f
, img
, pixmap_p
, mask_p
, colors_p
)
4748 int pixmap_p
, mask_p
, colors_p
;
4750 if (pixmap_p
&& img
->pixmap
)
4752 XFreePixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
4754 img
->background_valid
= 0;
4757 if (mask_p
&& img
->mask
)
4759 XFreePixmap (FRAME_X_DISPLAY (f
), img
->mask
);
4761 img
->background_transparent_valid
= 0;
4764 if (colors_p
&& img
->ncolors
)
4766 x_free_colors (f
, img
->colors
, img
->ncolors
);
4767 xfree (img
->colors
);
4773 /* Free X resources of image IMG which is used on frame F. */
4776 x_clear_image (f
, img
)
4781 x_clear_image_1 (f
, img
, 1, 1, 1);
4786 /* Allocate color COLOR_NAME for image IMG on frame F. If color
4787 cannot be allocated, use DFLT. Add a newly allocated color to
4788 IMG->colors, so that it can be freed again. Value is the pixel
4791 static unsigned long
4792 x_alloc_image_color (f
, img
, color_name
, dflt
)
4795 Lisp_Object color_name
;
4799 unsigned long result
;
4801 xassert (STRINGP (color_name
));
4803 if (x_defined_color (f
, SDATA (color_name
), &color
, 1))
4805 /* This isn't called frequently so we get away with simply
4806 reallocating the color vector to the needed size, here. */
4809 (unsigned long *) xrealloc (img
->colors
,
4810 img
->ncolors
* sizeof *img
->colors
);
4811 img
->colors
[img
->ncolors
- 1] = color
.pixel
;
4812 result
= color
.pixel
;
4822 /***********************************************************************
4824 ***********************************************************************/
4826 static void cache_image
P_ ((struct frame
*f
, struct image
*img
));
4827 static void postprocess_image
P_ ((struct frame
*, struct image
*));
4830 /* Return a new, initialized image cache that is allocated from the
4831 heap. Call free_image_cache to free an image cache. */
4833 struct image_cache
*
4836 struct image_cache
*c
= (struct image_cache
*) xmalloc (sizeof *c
);
4839 bzero (c
, sizeof *c
);
4841 c
->images
= (struct image
**) xmalloc (c
->size
* sizeof *c
->images
);
4842 size
= IMAGE_CACHE_BUCKETS_SIZE
* sizeof *c
->buckets
;
4843 c
->buckets
= (struct image
**) xmalloc (size
);
4844 bzero (c
->buckets
, size
);
4849 /* Free image cache of frame F. Be aware that X frames share images
4853 free_image_cache (f
)
4856 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
4861 /* Cache should not be referenced by any frame when freed. */
4862 xassert (c
->refcount
== 0);
4864 for (i
= 0; i
< c
->used
; ++i
)
4865 free_image (f
, c
->images
[i
]);
4869 FRAME_X_IMAGE_CACHE (f
) = NULL
;
4874 /* Clear image cache of frame F. FORCE_P non-zero means free all
4875 images. FORCE_P zero means clear only images that haven't been
4876 displayed for some time. Should be called from time to time to
4877 reduce the number of loaded images. If image-eviction-seconds is
4878 non-nil, this frees images in the cache which weren't displayed for
4879 at least that many seconds. */
4882 clear_image_cache (f
, force_p
)
4886 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
4888 if (c
&& INTEGERP (Vimage_cache_eviction_delay
))
4895 old
= EMACS_SECS (t
) - XFASTINT (Vimage_cache_eviction_delay
);
4897 /* Block input so that we won't be interrupted by a SIGIO
4898 while being in an inconsistent state. */
4901 for (i
= nfreed
= 0; i
< c
->used
; ++i
)
4903 struct image
*img
= c
->images
[i
];
4905 && (force_p
|| img
->timestamp
< old
))
4907 free_image (f
, img
);
4912 /* We may be clearing the image cache because, for example,
4913 Emacs was iconified for a longer period of time. In that
4914 case, current matrices may still contain references to
4915 images freed above. So, clear these matrices. */
4918 Lisp_Object tail
, frame
;
4920 FOR_EACH_FRAME (tail
, frame
)
4922 struct frame
*f
= XFRAME (frame
);
4924 && FRAME_X_IMAGE_CACHE (f
) == c
)
4925 clear_current_matrices (f
);
4928 ++windows_or_buffers_changed
;
4936 DEFUN ("clear-image-cache", Fclear_image_cache
, Sclear_image_cache
,
4938 doc
: /* Clear the image cache of FRAME.
4939 FRAME nil or omitted means use the selected frame.
4940 FRAME t means clear the image caches of all frames. */)
4948 FOR_EACH_FRAME (tail
, frame
)
4949 if (FRAME_X_P (XFRAME (frame
)))
4950 clear_image_cache (XFRAME (frame
), 1);
4953 clear_image_cache (check_x_frame (frame
), 1);
4959 /* Compute masks and transform image IMG on frame F, as specified
4960 by the image's specification, */
4963 postprocess_image (f
, img
)
4967 /* Manipulation of the image's mask. */
4970 Lisp_Object conversion
, spec
;
4975 /* `:heuristic-mask t'
4977 means build a mask heuristically.
4978 `:heuristic-mask (R G B)'
4979 `:mask (heuristic (R G B))'
4980 means build a mask from color (R G B) in the
4983 means remove a mask, if any. */
4985 mask
= image_spec_value (spec
, QCheuristic_mask
, NULL
);
4987 x_build_heuristic_mask (f
, img
, mask
);
4992 mask
= image_spec_value (spec
, QCmask
, &found_p
);
4994 if (EQ (mask
, Qheuristic
))
4995 x_build_heuristic_mask (f
, img
, Qt
);
4996 else if (CONSP (mask
)
4997 && EQ (XCAR (mask
), Qheuristic
))
4999 if (CONSP (XCDR (mask
)))
5000 x_build_heuristic_mask (f
, img
, XCAR (XCDR (mask
)));
5002 x_build_heuristic_mask (f
, img
, XCDR (mask
));
5004 else if (NILP (mask
) && found_p
&& img
->mask
)
5006 XFreePixmap (FRAME_X_DISPLAY (f
), img
->mask
);
5012 /* Should we apply an image transformation algorithm? */
5013 conversion
= image_spec_value (spec
, QCconversion
, NULL
);
5014 if (EQ (conversion
, Qdisabled
))
5015 x_disable_image (f
, img
);
5016 else if (EQ (conversion
, Qlaplace
))
5018 else if (EQ (conversion
, Qemboss
))
5020 else if (CONSP (conversion
)
5021 && EQ (XCAR (conversion
), Qedge_detection
))
5024 tem
= XCDR (conversion
);
5026 x_edge_detection (f
, img
,
5027 Fplist_get (tem
, QCmatrix
),
5028 Fplist_get (tem
, QCcolor_adjustment
));
5034 /* Return the id of image with Lisp specification SPEC on frame F.
5035 SPEC must be a valid Lisp image specification (see valid_image_p). */
5038 lookup_image (f
, spec
)
5042 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5046 struct gcpro gcpro1
;
5049 /* F must be a window-system frame, and SPEC must be a valid image
5051 xassert (FRAME_WINDOW_P (f
));
5052 xassert (valid_image_p (spec
));
5056 /* Look up SPEC in the hash table of the image cache. */
5057 hash
= sxhash (spec
, 0);
5058 i
= hash
% IMAGE_CACHE_BUCKETS_SIZE
;
5060 for (img
= c
->buckets
[i
]; img
; img
= img
->next
)
5061 if (img
->hash
== hash
&& !NILP (Fequal (img
->spec
, spec
)))
5064 /* If not found, create a new image and cache it. */
5067 extern Lisp_Object Qpostscript
;
5070 img
= make_image (spec
, hash
);
5071 cache_image (f
, img
);
5072 img
->load_failed_p
= img
->type
->load (f
, img
) == 0;
5074 /* If we can't load the image, and we don't have a width and
5075 height, use some arbitrary width and height so that we can
5076 draw a rectangle for it. */
5077 if (img
->load_failed_p
)
5081 value
= image_spec_value (spec
, QCwidth
, NULL
);
5082 img
->width
= (INTEGERP (value
)
5083 ? XFASTINT (value
) : DEFAULT_IMAGE_WIDTH
);
5084 value
= image_spec_value (spec
, QCheight
, NULL
);
5085 img
->height
= (INTEGERP (value
)
5086 ? XFASTINT (value
) : DEFAULT_IMAGE_HEIGHT
);
5090 /* Handle image type independent image attributes
5091 `:ascent ASCENT', `:margin MARGIN', `:relief RELIEF',
5092 `:background COLOR'. */
5093 Lisp_Object ascent
, margin
, relief
, bg
;
5095 ascent
= image_spec_value (spec
, QCascent
, NULL
);
5096 if (INTEGERP (ascent
))
5097 img
->ascent
= XFASTINT (ascent
);
5098 else if (EQ (ascent
, Qcenter
))
5099 img
->ascent
= CENTERED_IMAGE_ASCENT
;
5101 margin
= image_spec_value (spec
, QCmargin
, NULL
);
5102 if (INTEGERP (margin
) && XINT (margin
) >= 0)
5103 img
->vmargin
= img
->hmargin
= XFASTINT (margin
);
5104 else if (CONSP (margin
) && INTEGERP (XCAR (margin
))
5105 && INTEGERP (XCDR (margin
)))
5107 if (XINT (XCAR (margin
)) > 0)
5108 img
->hmargin
= XFASTINT (XCAR (margin
));
5109 if (XINT (XCDR (margin
)) > 0)
5110 img
->vmargin
= XFASTINT (XCDR (margin
));
5113 relief
= image_spec_value (spec
, QCrelief
, NULL
);
5114 if (INTEGERP (relief
))
5116 img
->relief
= XINT (relief
);
5117 img
->hmargin
+= abs (img
->relief
);
5118 img
->vmargin
+= abs (img
->relief
);
5121 if (! img
->background_valid
)
5123 bg
= image_spec_value (img
->spec
, QCbackground
, NULL
);
5127 = x_alloc_image_color (f
, img
, bg
,
5128 FRAME_BACKGROUND_PIXEL (f
));
5129 img
->background_valid
= 1;
5133 /* Do image transformations and compute masks, unless we
5134 don't have the image yet. */
5135 if (!EQ (*img
->type
->type
, Qpostscript
))
5136 postprocess_image (f
, img
);
5140 xassert (!interrupt_input_blocked
);
5143 /* We're using IMG, so set its timestamp to `now'. */
5144 EMACS_GET_TIME (now
);
5145 img
->timestamp
= EMACS_SECS (now
);
5149 /* Value is the image id. */
5154 /* Cache image IMG in the image cache of frame F. */
5157 cache_image (f
, img
)
5161 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5164 /* Find a free slot in c->images. */
5165 for (i
= 0; i
< c
->used
; ++i
)
5166 if (c
->images
[i
] == NULL
)
5169 /* If no free slot found, maybe enlarge c->images. */
5170 if (i
== c
->used
&& c
->used
== c
->size
)
5173 c
->images
= (struct image
**) xrealloc (c
->images
,
5174 c
->size
* sizeof *c
->images
);
5177 /* Add IMG to c->images, and assign IMG an id. */
5183 /* Add IMG to the cache's hash table. */
5184 i
= img
->hash
% IMAGE_CACHE_BUCKETS_SIZE
;
5185 img
->next
= c
->buckets
[i
];
5187 img
->next
->prev
= img
;
5189 c
->buckets
[i
] = img
;
5193 /* Call FN on every image in the image cache of frame F. Used to mark
5194 Lisp Objects in the image cache. */
5197 forall_images_in_image_cache (f
, fn
)
5199 void (*fn
) P_ ((struct image
*img
));
5201 if (FRAME_LIVE_P (f
) && FRAME_X_P (f
))
5203 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
5207 for (i
= 0; i
< c
->used
; ++i
)
5216 /***********************************************************************
5218 ***********************************************************************/
5220 static int x_create_x_image_and_pixmap
P_ ((struct frame
*, int, int, int,
5221 XImage
**, Pixmap
*));
5222 static void x_destroy_x_image
P_ ((XImage
*));
5223 static void x_put_x_image
P_ ((struct frame
*, XImage
*, Pixmap
, int, int));
5226 /* Create an XImage and a pixmap of size WIDTH x HEIGHT for use on
5227 frame F. Set *XIMG and *PIXMAP to the XImage and Pixmap created.
5228 Set (*XIMG)->data to a raster of WIDTH x HEIGHT pixels allocated
5229 via xmalloc. Print error messages via image_error if an error
5230 occurs. Value is non-zero if successful. */
5233 x_create_x_image_and_pixmap (f
, width
, height
, depth
, ximg
, pixmap
)
5235 int width
, height
, depth
;
5239 Display
*display
= FRAME_X_DISPLAY (f
);
5240 Screen
*screen
= FRAME_X_SCREEN (f
);
5241 Window window
= FRAME_X_WINDOW (f
);
5243 xassert (interrupt_input_blocked
);
5246 depth
= DefaultDepthOfScreen (screen
);
5247 *ximg
= XCreateImage (display
, DefaultVisualOfScreen (screen
),
5248 depth
, ZPixmap
, 0, NULL
, width
, height
,
5249 depth
> 16 ? 32 : depth
> 8 ? 16 : 8, 0);
5252 image_error ("Unable to allocate X image", Qnil
, Qnil
);
5256 /* Allocate image raster. */
5257 (*ximg
)->data
= (char *) xmalloc ((*ximg
)->bytes_per_line
* height
);
5259 /* Allocate a pixmap of the same size. */
5260 *pixmap
= XCreatePixmap (display
, window
, width
, height
, depth
);
5261 if (*pixmap
== None
)
5263 x_destroy_x_image (*ximg
);
5265 image_error ("Unable to create X pixmap", Qnil
, Qnil
);
5273 /* Destroy XImage XIMG. Free XIMG->data. */
5276 x_destroy_x_image (ximg
)
5279 xassert (interrupt_input_blocked
);
5284 XDestroyImage (ximg
);
5289 /* Put XImage XIMG into pixmap PIXMAP on frame F. WIDTH and HEIGHT
5290 are width and height of both the image and pixmap. */
5293 x_put_x_image (f
, ximg
, pixmap
, width
, height
)
5301 xassert (interrupt_input_blocked
);
5302 gc
= XCreateGC (FRAME_X_DISPLAY (f
), pixmap
, 0, NULL
);
5303 XPutImage (FRAME_X_DISPLAY (f
), pixmap
, gc
, ximg
, 0, 0, 0, 0, width
, height
);
5304 XFreeGC (FRAME_X_DISPLAY (f
), gc
);
5309 /***********************************************************************
5311 ***********************************************************************/
5313 static Lisp_Object x_find_image_file
P_ ((Lisp_Object
));
5314 static char *slurp_file
P_ ((char *, int *));
5317 /* Find image file FILE. Look in data-directory, then
5318 x-bitmap-file-path. Value is the full name of the file found, or
5319 nil if not found. */
5322 x_find_image_file (file
)
5325 Lisp_Object file_found
, search_path
;
5326 struct gcpro gcpro1
, gcpro2
;
5330 search_path
= Fcons (Vdata_directory
, Vx_bitmap_file_path
);
5331 GCPRO2 (file_found
, search_path
);
5333 /* Try to find FILE in data-directory, then x-bitmap-file-path. */
5334 fd
= openp (search_path
, file
, Qnil
, &file_found
, Qnil
);
5346 /* Read FILE into memory. Value is a pointer to a buffer allocated
5347 with xmalloc holding FILE's contents. Value is null if an error
5348 occurred. *SIZE is set to the size of the file. */
5351 slurp_file (file
, size
)
5359 if (stat (file
, &st
) == 0
5360 && (fp
= fopen (file
, "r")) != NULL
5361 && (buf
= (char *) xmalloc (st
.st_size
),
5362 fread (buf
, 1, st
.st_size
, fp
) == st
.st_size
))
5383 /***********************************************************************
5385 ***********************************************************************/
5387 static int xbm_scan
P_ ((char **, char *, char *, int *));
5388 static int xbm_load
P_ ((struct frame
*f
, struct image
*img
));
5389 static int xbm_load_image
P_ ((struct frame
*f
, struct image
*img
,
5391 static int xbm_image_p
P_ ((Lisp_Object object
));
5392 static int xbm_read_bitmap_data
P_ ((char *, char *, int *, int *,
5394 static int xbm_file_p
P_ ((Lisp_Object
));
5397 /* Indices of image specification fields in xbm_format, below. */
5399 enum xbm_keyword_index
5417 /* Vector of image_keyword structures describing the format
5418 of valid XBM image specifications. */
5420 static struct image_keyword xbm_format
[XBM_LAST
] =
5422 {":type", IMAGE_SYMBOL_VALUE
, 1},
5423 {":file", IMAGE_STRING_VALUE
, 0},
5424 {":width", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
5425 {":height", IMAGE_POSITIVE_INTEGER_VALUE
, 0},
5426 {":data", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5427 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
5428 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0},
5429 {":ascent", IMAGE_ASCENT_VALUE
, 0},
5430 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
5431 {":relief", IMAGE_INTEGER_VALUE
, 0},
5432 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5433 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
5434 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0}
5437 /* Structure describing the image type XBM. */
5439 static struct image_type xbm_type
=
5448 /* Tokens returned from xbm_scan. */
5457 /* Return non-zero if OBJECT is a valid XBM-type image specification.
5458 A valid specification is a list starting with the symbol `image'
5459 The rest of the list is a property list which must contain an
5462 If the specification specifies a file to load, it must contain
5463 an entry `:file FILENAME' where FILENAME is a string.
5465 If the specification is for a bitmap loaded from memory it must
5466 contain `:width WIDTH', `:height HEIGHT', and `:data DATA', where
5467 WIDTH and HEIGHT are integers > 0. DATA may be:
5469 1. a string large enough to hold the bitmap data, i.e. it must
5470 have a size >= (WIDTH + 7) / 8 * HEIGHT
5472 2. a bool-vector of size >= WIDTH * HEIGHT
5474 3. a vector of strings or bool-vectors, one for each line of the
5477 4. A string containing an in-memory XBM file. WIDTH and HEIGHT
5478 may not be specified in this case because they are defined in the
5481 Both the file and data forms may contain the additional entries
5482 `:background COLOR' and `:foreground COLOR'. If not present,
5483 foreground and background of the frame on which the image is
5484 displayed is used. */
5487 xbm_image_p (object
)
5490 struct image_keyword kw
[XBM_LAST
];
5492 bcopy (xbm_format
, kw
, sizeof kw
);
5493 if (!parse_image_spec (object
, kw
, XBM_LAST
, Qxbm
))
5496 xassert (EQ (kw
[XBM_TYPE
].value
, Qxbm
));
5498 if (kw
[XBM_FILE
].count
)
5500 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_DATA
].count
)
5503 else if (kw
[XBM_DATA
].count
&& xbm_file_p (kw
[XBM_DATA
].value
))
5505 /* In-memory XBM file. */
5506 if (kw
[XBM_WIDTH
].count
|| kw
[XBM_HEIGHT
].count
|| kw
[XBM_FILE
].count
)
5514 /* Entries for `:width', `:height' and `:data' must be present. */
5515 if (!kw
[XBM_WIDTH
].count
5516 || !kw
[XBM_HEIGHT
].count
5517 || !kw
[XBM_DATA
].count
)
5520 data
= kw
[XBM_DATA
].value
;
5521 width
= XFASTINT (kw
[XBM_WIDTH
].value
);
5522 height
= XFASTINT (kw
[XBM_HEIGHT
].value
);
5524 /* Check type of data, and width and height against contents of
5530 /* Number of elements of the vector must be >= height. */
5531 if (XVECTOR (data
)->size
< height
)
5534 /* Each string or bool-vector in data must be large enough
5535 for one line of the image. */
5536 for (i
= 0; i
< height
; ++i
)
5538 Lisp_Object elt
= XVECTOR (data
)->contents
[i
];
5543 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
)
5546 else if (BOOL_VECTOR_P (elt
))
5548 if (XBOOL_VECTOR (elt
)->size
< width
)
5555 else if (STRINGP (data
))
5558 < (width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
* height
)
5561 else if (BOOL_VECTOR_P (data
))
5563 if (XBOOL_VECTOR (data
)->size
< width
* height
)
5574 /* Scan a bitmap file. FP is the stream to read from. Value is
5575 either an enumerator from enum xbm_token, or a character for a
5576 single-character token, or 0 at end of file. If scanning an
5577 identifier, store the lexeme of the identifier in SVAL. If
5578 scanning a number, store its value in *IVAL. */
5581 xbm_scan (s
, end
, sval
, ival
)
5590 /* Skip white space. */
5591 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
5596 else if (isdigit (c
))
5598 int value
= 0, digit
;
5600 if (c
== '0' && *s
< end
)
5603 if (c
== 'x' || c
== 'X')
5610 else if (c
>= 'a' && c
<= 'f')
5611 digit
= c
- 'a' + 10;
5612 else if (c
>= 'A' && c
<= 'F')
5613 digit
= c
- 'A' + 10;
5616 value
= 16 * value
+ digit
;
5619 else if (isdigit (c
))
5623 && (c
= *(*s
)++, isdigit (c
)))
5624 value
= 8 * value
+ c
- '0';
5631 && (c
= *(*s
)++, isdigit (c
)))
5632 value
= 10 * value
+ c
- '0';
5640 else if (isalpha (c
) || c
== '_')
5644 && (c
= *(*s
)++, (isalnum (c
) || c
== '_')))
5651 else if (c
== '/' && **s
== '*')
5653 /* C-style comment. */
5655 while (**s
&& (**s
!= '*' || *(*s
+ 1) != '/'))
5668 /* Replacement for XReadBitmapFileData which isn't available under old
5669 X versions. CONTENTS is a pointer to a buffer to parse; END is the
5670 buffer's end. Set *WIDTH and *HEIGHT to the width and height of
5671 the image. Return in *DATA the bitmap data allocated with xmalloc.
5672 Value is non-zero if successful. DATA null means just test if
5673 CONTENTS looks like an in-memory XBM file. */
5676 xbm_read_bitmap_data (contents
, end
, width
, height
, data
)
5677 char *contents
, *end
;
5678 int *width
, *height
;
5679 unsigned char **data
;
5682 char buffer
[BUFSIZ
];
5685 int bytes_per_line
, i
, nbytes
;
5691 LA1 = xbm_scan (&s, end, buffer, &value)
5693 #define expect(TOKEN) \
5694 if (LA1 != (TOKEN)) \
5699 #define expect_ident(IDENT) \
5700 if (LA1 == XBM_TK_IDENT && strcmp (buffer, (IDENT)) == 0) \
5705 *width
= *height
= -1;
5708 LA1
= xbm_scan (&s
, end
, buffer
, &value
);
5710 /* Parse defines for width, height and hot-spots. */
5714 expect_ident ("define");
5715 expect (XBM_TK_IDENT
);
5717 if (LA1
== XBM_TK_NUMBER
);
5719 char *p
= strrchr (buffer
, '_');
5720 p
= p
? p
+ 1 : buffer
;
5721 if (strcmp (p
, "width") == 0)
5723 else if (strcmp (p
, "height") == 0)
5726 expect (XBM_TK_NUMBER
);
5729 if (*width
< 0 || *height
< 0)
5731 else if (data
== NULL
)
5734 /* Parse bits. Must start with `static'. */
5735 expect_ident ("static");
5736 if (LA1
== XBM_TK_IDENT
)
5738 if (strcmp (buffer
, "unsigned") == 0)
5741 expect_ident ("char");
5743 else if (strcmp (buffer
, "short") == 0)
5747 if (*width
% 16 && *width
% 16 < 9)
5750 else if (strcmp (buffer
, "char") == 0)
5758 expect (XBM_TK_IDENT
);
5764 bytes_per_line
= (*width
+ 7) / 8 + padding_p
;
5765 nbytes
= bytes_per_line
* *height
;
5766 p
= *data
= (char *) xmalloc (nbytes
);
5770 for (i
= 0; i
< nbytes
; i
+= 2)
5773 expect (XBM_TK_NUMBER
);
5776 if (!padding_p
|| ((i
+ 2) % bytes_per_line
))
5779 if (LA1
== ',' || LA1
== '}')
5787 for (i
= 0; i
< nbytes
; ++i
)
5790 expect (XBM_TK_NUMBER
);
5794 if (LA1
== ',' || LA1
== '}')
5819 /* Load XBM image IMG which will be displayed on frame F from buffer
5820 CONTENTS. END is the end of the buffer. Value is non-zero if
5824 xbm_load_image (f
, img
, contents
, end
)
5827 char *contents
, *end
;
5830 unsigned char *data
;
5833 rc
= xbm_read_bitmap_data (contents
, end
, &img
->width
, &img
->height
, &data
);
5836 int depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
5837 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
5838 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
5841 xassert (img
->width
> 0 && img
->height
> 0);
5843 /* Get foreground and background colors, maybe allocate colors. */
5844 value
= image_spec_value (img
->spec
, QCforeground
, NULL
);
5846 foreground
= x_alloc_image_color (f
, img
, value
, foreground
);
5847 value
= image_spec_value (img
->spec
, QCbackground
, NULL
);
5850 background
= x_alloc_image_color (f
, img
, value
, background
);
5851 img
->background
= background
;
5852 img
->background_valid
= 1;
5856 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
5859 img
->width
, img
->height
,
5860 foreground
, background
,
5864 if (img
->pixmap
== None
)
5866 x_clear_image (f
, img
);
5867 image_error ("Unable to create X pixmap for `%s'", img
->spec
, Qnil
);
5873 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
5879 /* Value is non-zero if DATA looks like an in-memory XBM file. */
5886 return (STRINGP (data
)
5887 && xbm_read_bitmap_data (SDATA (data
),
5894 /* Fill image IMG which is used on frame F with pixmap data. Value is
5895 non-zero if successful. */
5903 Lisp_Object file_name
;
5905 xassert (xbm_image_p (img
->spec
));
5907 /* If IMG->spec specifies a file name, create a non-file spec from it. */
5908 file_name
= image_spec_value (img
->spec
, QCfile
, NULL
);
5909 if (STRINGP (file_name
))
5914 struct gcpro gcpro1
;
5916 file
= x_find_image_file (file_name
);
5918 if (!STRINGP (file
))
5920 image_error ("Cannot find image file `%s'", file_name
, Qnil
);
5925 contents
= slurp_file (SDATA (file
), &size
);
5926 if (contents
== NULL
)
5928 image_error ("Error loading XBM image `%s'", img
->spec
, Qnil
);
5933 success_p
= xbm_load_image (f
, img
, contents
, contents
+ size
);
5938 struct image_keyword fmt
[XBM_LAST
];
5941 unsigned long foreground
= FRAME_FOREGROUND_PIXEL (f
);
5942 unsigned long background
= FRAME_BACKGROUND_PIXEL (f
);
5945 int in_memory_file_p
= 0;
5947 /* See if data looks like an in-memory XBM file. */
5948 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
5949 in_memory_file_p
= xbm_file_p (data
);
5951 /* Parse the image specification. */
5952 bcopy (xbm_format
, fmt
, sizeof fmt
);
5953 parsed_p
= parse_image_spec (img
->spec
, fmt
, XBM_LAST
, Qxbm
);
5956 /* Get specified width, and height. */
5957 if (!in_memory_file_p
)
5959 img
->width
= XFASTINT (fmt
[XBM_WIDTH
].value
);
5960 img
->height
= XFASTINT (fmt
[XBM_HEIGHT
].value
);
5961 xassert (img
->width
> 0 && img
->height
> 0);
5964 /* Get foreground and background colors, maybe allocate colors. */
5965 if (fmt
[XBM_FOREGROUND
].count
5966 && STRINGP (fmt
[XBM_FOREGROUND
].value
))
5967 foreground
= x_alloc_image_color (f
, img
, fmt
[XBM_FOREGROUND
].value
,
5969 if (fmt
[XBM_BACKGROUND
].count
5970 && STRINGP (fmt
[XBM_BACKGROUND
].value
))
5971 background
= x_alloc_image_color (f
, img
, fmt
[XBM_BACKGROUND
].value
,
5974 if (in_memory_file_p
)
5975 success_p
= xbm_load_image (f
, img
, SDATA (data
),
5984 int nbytes
= (img
->width
+ BITS_PER_CHAR
- 1) / BITS_PER_CHAR
;
5986 p
= bits
= (char *) alloca (nbytes
* img
->height
);
5987 for (i
= 0; i
< img
->height
; ++i
, p
+= nbytes
)
5989 Lisp_Object line
= XVECTOR (data
)->contents
[i
];
5991 bcopy (SDATA (line
), p
, nbytes
);
5993 bcopy (XBOOL_VECTOR (line
)->data
, p
, nbytes
);
5996 else if (STRINGP (data
))
5997 bits
= SDATA (data
);
5999 bits
= XBOOL_VECTOR (data
)->data
;
6001 /* Create the pixmap. */
6002 depth
= DefaultDepthOfScreen (FRAME_X_SCREEN (f
));
6004 = XCreatePixmapFromBitmapData (FRAME_X_DISPLAY (f
),
6007 img
->width
, img
->height
,
6008 foreground
, background
,
6014 image_error ("Unable to create pixmap for XBM image `%s'",
6016 x_clear_image (f
, img
);
6026 /***********************************************************************
6028 ***********************************************************************/
6032 static int xpm_image_p
P_ ((Lisp_Object object
));
6033 static int xpm_load
P_ ((struct frame
*f
, struct image
*img
));
6034 static int xpm_valid_color_symbols_p
P_ ((Lisp_Object
));
6036 #include "X11/xpm.h"
6038 /* The symbol `xpm' identifying XPM-format images. */
6042 /* Indices of image specification fields in xpm_format, below. */
6044 enum xpm_keyword_index
6060 /* Vector of image_keyword structures describing the format
6061 of valid XPM image specifications. */
6063 static struct image_keyword xpm_format
[XPM_LAST
] =
6065 {":type", IMAGE_SYMBOL_VALUE
, 1},
6066 {":file", IMAGE_STRING_VALUE
, 0},
6067 {":data", IMAGE_STRING_VALUE
, 0},
6068 {":ascent", IMAGE_ASCENT_VALUE
, 0},
6069 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
6070 {":relief", IMAGE_INTEGER_VALUE
, 0},
6071 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6072 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6073 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6074 {":color-symbols", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
6075 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
6078 /* Structure describing the image type XBM. */
6080 static struct image_type xpm_type
=
6090 /* Define ALLOC_XPM_COLORS if we can use Emacs' own color allocation
6091 functions for allocating image colors. Our own functions handle
6092 color allocation failures more gracefully than the ones on the XPM
6095 #if defined XpmAllocColor && defined XpmFreeColors && defined XpmColorClosure
6096 #define ALLOC_XPM_COLORS
6099 #ifdef ALLOC_XPM_COLORS
6101 static void xpm_init_color_cache
P_ ((struct frame
*, XpmAttributes
*));
6102 static void xpm_free_color_cache
P_ ((void));
6103 static int xpm_lookup_color
P_ ((struct frame
*, char *, XColor
*));
6104 static int xpm_color_bucket
P_ ((char *));
6105 static struct xpm_cached_color
*xpm_cache_color
P_ ((struct frame
*, char *,
6108 /* An entry in a hash table used to cache color definitions of named
6109 colors. This cache is necessary to speed up XPM image loading in
6110 case we do color allocations ourselves. Without it, we would need
6111 a call to XParseColor per pixel in the image. */
6113 struct xpm_cached_color
6115 /* Next in collision chain. */
6116 struct xpm_cached_color
*next
;
6118 /* Color definition (RGB and pixel color). */
6125 /* The hash table used for the color cache, and its bucket vector
6128 #define XPM_COLOR_CACHE_BUCKETS 1001
6129 struct xpm_cached_color
**xpm_color_cache
;
6131 /* Initialize the color cache. */
6134 xpm_init_color_cache (f
, attrs
)
6136 XpmAttributes
*attrs
;
6138 size_t nbytes
= XPM_COLOR_CACHE_BUCKETS
* sizeof *xpm_color_cache
;
6139 xpm_color_cache
= (struct xpm_cached_color
**) xmalloc (nbytes
);
6140 memset (xpm_color_cache
, 0, nbytes
);
6141 init_color_table ();
6143 if (attrs
->valuemask
& XpmColorSymbols
)
6148 for (i
= 0; i
< attrs
->numsymbols
; ++i
)
6149 if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
6150 attrs
->colorsymbols
[i
].value
, &color
))
6152 color
.pixel
= lookup_rgb_color (f
, color
.red
, color
.green
,
6154 xpm_cache_color (f
, attrs
->colorsymbols
[i
].name
, &color
, -1);
6160 /* Free the color cache. */
6163 xpm_free_color_cache ()
6165 struct xpm_cached_color
*p
, *next
;
6168 for (i
= 0; i
< XPM_COLOR_CACHE_BUCKETS
; ++i
)
6169 for (p
= xpm_color_cache
[i
]; p
; p
= next
)
6175 xfree (xpm_color_cache
);
6176 xpm_color_cache
= NULL
;
6177 free_color_table ();
6181 /* Return the bucket index for color named COLOR_NAME in the color
6185 xpm_color_bucket (color_name
)
6191 for (s
= color_name
; *s
; ++s
)
6193 return h
%= XPM_COLOR_CACHE_BUCKETS
;
6197 /* On frame F, cache values COLOR for color with name COLOR_NAME.
6198 BUCKET, if >= 0, is a precomputed bucket index. Value is the cache
6201 static struct xpm_cached_color
*
6202 xpm_cache_color (f
, color_name
, color
, bucket
)
6209 struct xpm_cached_color
*p
;
6212 bucket
= xpm_color_bucket (color_name
);
6214 nbytes
= sizeof *p
+ strlen (color_name
);
6215 p
= (struct xpm_cached_color
*) xmalloc (nbytes
);
6216 strcpy (p
->name
, color_name
);
6218 p
->next
= xpm_color_cache
[bucket
];
6219 xpm_color_cache
[bucket
] = p
;
6224 /* Look up color COLOR_NAME for frame F in the color cache. If found,
6225 return the cached definition in *COLOR. Otherwise, make a new
6226 entry in the cache and allocate the color. Value is zero if color
6227 allocation failed. */
6230 xpm_lookup_color (f
, color_name
, color
)
6235 struct xpm_cached_color
*p
;
6236 int h
= xpm_color_bucket (color_name
);
6238 for (p
= xpm_color_cache
[h
]; p
; p
= p
->next
)
6239 if (strcmp (p
->name
, color_name
) == 0)
6244 else if (XParseColor (FRAME_X_DISPLAY (f
), FRAME_X_COLORMAP (f
),
6247 color
->pixel
= lookup_rgb_color (f
, color
->red
, color
->green
,
6249 p
= xpm_cache_color (f
, color_name
, color
, h
);
6251 /* You get `opaque' at least from ImageMagick converting pbm to xpm
6252 with transparency, and it's useful. */
6253 else if (strcmp ("opaque", color_name
) == 0)
6255 bzero (color
, sizeof (XColor
)); /* Is this necessary/correct? */
6256 color
->pixel
= FRAME_FOREGROUND_PIXEL (f
);
6257 p
= xpm_cache_color (f
, color_name
, color
, h
);
6264 /* Callback for allocating color COLOR_NAME. Called from the XPM lib.
6265 CLOSURE is a pointer to the frame on which we allocate the
6266 color. Return in *COLOR the allocated color. Value is non-zero
6270 xpm_alloc_color (dpy
, cmap
, color_name
, color
, closure
)
6277 return xpm_lookup_color ((struct frame
*) closure
, color_name
, color
);
6281 /* Callback for freeing NPIXELS colors contained in PIXELS. CLOSURE
6282 is a pointer to the frame on which we allocate the color. Value is
6283 non-zero if successful. */
6286 xpm_free_colors (dpy
, cmap
, pixels
, npixels
, closure
)
6296 #endif /* ALLOC_XPM_COLORS */
6299 /* Value is non-zero if COLOR_SYMBOLS is a valid color symbols list
6300 for XPM images. Such a list must consist of conses whose car and
6304 xpm_valid_color_symbols_p (color_symbols
)
6305 Lisp_Object color_symbols
;
6307 while (CONSP (color_symbols
))
6309 Lisp_Object sym
= XCAR (color_symbols
);
6311 || !STRINGP (XCAR (sym
))
6312 || !STRINGP (XCDR (sym
)))
6314 color_symbols
= XCDR (color_symbols
);
6317 return NILP (color_symbols
);
6321 /* Value is non-zero if OBJECT is a valid XPM image specification. */
6324 xpm_image_p (object
)
6327 struct image_keyword fmt
[XPM_LAST
];
6328 bcopy (xpm_format
, fmt
, sizeof fmt
);
6329 return (parse_image_spec (object
, fmt
, XPM_LAST
, Qxpm
)
6330 /* Either `:file' or `:data' must be present. */
6331 && fmt
[XPM_FILE
].count
+ fmt
[XPM_DATA
].count
== 1
6332 /* Either no `:color-symbols' or it's a list of conses
6333 whose car and cdr are strings. */
6334 && (fmt
[XPM_COLOR_SYMBOLS
].count
== 0
6335 || xpm_valid_color_symbols_p (fmt
[XPM_COLOR_SYMBOLS
].value
)));
6339 /* Load image IMG which will be displayed on frame F. Value is
6340 non-zero if successful. */
6348 XpmAttributes attrs
;
6349 Lisp_Object specified_file
, color_symbols
;
6351 /* Configure the XPM lib. Use the visual of frame F. Allocate
6352 close colors. Return colors allocated. */
6353 bzero (&attrs
, sizeof attrs
);
6354 attrs
.visual
= FRAME_X_VISUAL (f
);
6355 attrs
.colormap
= FRAME_X_COLORMAP (f
);
6356 attrs
.valuemask
|= XpmVisual
;
6357 attrs
.valuemask
|= XpmColormap
;
6359 #ifdef ALLOC_XPM_COLORS
6360 /* Allocate colors with our own functions which handle
6361 failing color allocation more gracefully. */
6362 attrs
.color_closure
= f
;
6363 attrs
.alloc_color
= xpm_alloc_color
;
6364 attrs
.free_colors
= xpm_free_colors
;
6365 attrs
.valuemask
|= XpmAllocColor
| XpmFreeColors
| XpmColorClosure
;
6366 #else /* not ALLOC_XPM_COLORS */
6367 /* Let the XPM lib allocate colors. */
6368 attrs
.valuemask
|= XpmReturnAllocPixels
;
6369 #ifdef XpmAllocCloseColors
6370 attrs
.alloc_close_colors
= 1;
6371 attrs
.valuemask
|= XpmAllocCloseColors
;
6372 #else /* not XpmAllocCloseColors */
6373 attrs
.closeness
= 600;
6374 attrs
.valuemask
|= XpmCloseness
;
6375 #endif /* not XpmAllocCloseColors */
6376 #endif /* ALLOC_XPM_COLORS */
6378 /* If image specification contains symbolic color definitions, add
6379 these to `attrs'. */
6380 color_symbols
= image_spec_value (img
->spec
, QCcolor_symbols
, NULL
);
6381 if (CONSP (color_symbols
))
6384 XpmColorSymbol
*xpm_syms
;
6387 attrs
.valuemask
|= XpmColorSymbols
;
6389 /* Count number of symbols. */
6390 attrs
.numsymbols
= 0;
6391 for (tail
= color_symbols
; CONSP (tail
); tail
= XCDR (tail
))
6394 /* Allocate an XpmColorSymbol array. */
6395 size
= attrs
.numsymbols
* sizeof *xpm_syms
;
6396 xpm_syms
= (XpmColorSymbol
*) alloca (size
);
6397 bzero (xpm_syms
, size
);
6398 attrs
.colorsymbols
= xpm_syms
;
6400 /* Fill the color symbol array. */
6401 for (tail
= color_symbols
, i
= 0;
6403 ++i
, tail
= XCDR (tail
))
6405 Lisp_Object name
= XCAR (XCAR (tail
));
6406 Lisp_Object color
= XCDR (XCAR (tail
));
6407 xpm_syms
[i
].name
= (char *) alloca (SCHARS (name
) + 1);
6408 strcpy (xpm_syms
[i
].name
, SDATA (name
));
6409 xpm_syms
[i
].value
= (char *) alloca (SCHARS (color
) + 1);
6410 strcpy (xpm_syms
[i
].value
, SDATA (color
));
6414 /* Create a pixmap for the image, either from a file, or from a
6415 string buffer containing data in the same format as an XPM file. */
6416 #ifdef ALLOC_XPM_COLORS
6417 xpm_init_color_cache (f
, &attrs
);
6420 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
6421 if (STRINGP (specified_file
))
6423 Lisp_Object file
= x_find_image_file (specified_file
);
6424 if (!STRINGP (file
))
6426 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
6430 rc
= XpmReadFileToPixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6431 SDATA (file
), &img
->pixmap
, &img
->mask
,
6436 Lisp_Object buffer
= image_spec_value (img
->spec
, QCdata
, NULL
);
6437 rc
= XpmCreatePixmapFromBuffer (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
6439 &img
->pixmap
, &img
->mask
,
6443 if (rc
== XpmSuccess
)
6445 #ifdef ALLOC_XPM_COLORS
6446 img
->colors
= colors_in_color_table (&img
->ncolors
);
6447 #else /* not ALLOC_XPM_COLORS */
6450 img
->ncolors
= attrs
.nalloc_pixels
;
6451 img
->colors
= (unsigned long *) xmalloc (img
->ncolors
6452 * sizeof *img
->colors
);
6453 for (i
= 0; i
< attrs
.nalloc_pixels
; ++i
)
6455 img
->colors
[i
] = attrs
.alloc_pixels
[i
];
6456 #ifdef DEBUG_X_COLORS
6457 register_color (img
->colors
[i
]);
6460 #endif /* not ALLOC_XPM_COLORS */
6462 img
->width
= attrs
.width
;
6463 img
->height
= attrs
.height
;
6464 xassert (img
->width
> 0 && img
->height
> 0);
6466 /* The call to XpmFreeAttributes below frees attrs.alloc_pixels. */
6467 XpmFreeAttributes (&attrs
);
6474 image_error ("Error opening XPM file (%s)", img
->spec
, Qnil
);
6477 case XpmFileInvalid
:
6478 image_error ("Invalid XPM file (%s)", img
->spec
, Qnil
);
6482 image_error ("Out of memory (%s)", img
->spec
, Qnil
);
6485 case XpmColorFailed
:
6486 image_error ("Color allocation error (%s)", img
->spec
, Qnil
);
6490 image_error ("Unknown error (%s)", img
->spec
, Qnil
);
6495 #ifdef ALLOC_XPM_COLORS
6496 xpm_free_color_cache ();
6498 return rc
== XpmSuccess
;
6501 #endif /* HAVE_XPM != 0 */
6504 /***********************************************************************
6506 ***********************************************************************/
6508 /* An entry in the color table mapping an RGB color to a pixel color. */
6513 unsigned long pixel
;
6515 /* Next in color table collision list. */
6516 struct ct_color
*next
;
6519 /* The bucket vector size to use. Must be prime. */
6523 /* Value is a hash of the RGB color given by R, G, and B. */
6525 #define CT_HASH_RGB(R, G, B) (((R) << 16) ^ ((G) << 8) ^ (B))
6527 /* The color hash table. */
6529 struct ct_color
**ct_table
;
6531 /* Number of entries in the color table. */
6533 int ct_colors_allocated
;
6535 /* Initialize the color table. */
6540 int size
= CT_SIZE
* sizeof (*ct_table
);
6541 ct_table
= (struct ct_color
**) xmalloc (size
);
6542 bzero (ct_table
, size
);
6543 ct_colors_allocated
= 0;
6547 /* Free memory associated with the color table. */
6553 struct ct_color
*p
, *next
;
6555 for (i
= 0; i
< CT_SIZE
; ++i
)
6556 for (p
= ct_table
[i
]; p
; p
= next
)
6567 /* Value is a pixel color for RGB color R, G, B on frame F. If an
6568 entry for that color already is in the color table, return the
6569 pixel color of that entry. Otherwise, allocate a new color for R,
6570 G, B, and make an entry in the color table. */
6572 static unsigned long
6573 lookup_rgb_color (f
, r
, g
, b
)
6577 unsigned hash
= CT_HASH_RGB (r
, g
, b
);
6578 int i
= hash
% CT_SIZE
;
6581 for (p
= ct_table
[i
]; p
; p
= p
->next
)
6582 if (p
->r
== r
&& p
->g
== g
&& p
->b
== b
)
6595 cmap
= FRAME_X_COLORMAP (f
);
6596 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
6600 ++ct_colors_allocated
;
6602 p
= (struct ct_color
*) xmalloc (sizeof *p
);
6606 p
->pixel
= color
.pixel
;
6607 p
->next
= ct_table
[i
];
6611 return FRAME_FOREGROUND_PIXEL (f
);
6618 /* Look up pixel color PIXEL which is used on frame F in the color
6619 table. If not already present, allocate it. Value is PIXEL. */
6621 static unsigned long
6622 lookup_pixel_color (f
, pixel
)
6624 unsigned long pixel
;
6626 int i
= pixel
% CT_SIZE
;
6629 for (p
= ct_table
[i
]; p
; p
= p
->next
)
6630 if (p
->pixel
== pixel
)
6639 cmap
= FRAME_X_COLORMAP (f
);
6640 color
.pixel
= pixel
;
6641 x_query_color (f
, &color
);
6642 rc
= x_alloc_nearest_color (f
, cmap
, &color
);
6646 ++ct_colors_allocated
;
6648 p
= (struct ct_color
*) xmalloc (sizeof *p
);
6653 p
->next
= ct_table
[i
];
6657 return FRAME_FOREGROUND_PIXEL (f
);
6664 /* Value is a vector of all pixel colors contained in the color table,
6665 allocated via xmalloc. Set *N to the number of colors. */
6667 static unsigned long *
6668 colors_in_color_table (n
)
6673 unsigned long *colors
;
6675 if (ct_colors_allocated
== 0)
6682 colors
= (unsigned long *) xmalloc (ct_colors_allocated
6684 *n
= ct_colors_allocated
;
6686 for (i
= j
= 0; i
< CT_SIZE
; ++i
)
6687 for (p
= ct_table
[i
]; p
; p
= p
->next
)
6688 colors
[j
++] = p
->pixel
;
6696 /***********************************************************************
6698 ***********************************************************************/
6700 static XColor
*x_to_xcolors
P_ ((struct frame
*, struct image
*, int));
6701 static void x_from_xcolors
P_ ((struct frame
*, struct image
*, XColor
*));
6702 static void x_detect_edges
P_ ((struct frame
*, struct image
*, int[9], int));
6704 /* Non-zero means draw a cross on images having `:conversion
6707 int cross_disabled_images
;
6709 /* Edge detection matrices for different edge-detection
6712 static int emboss_matrix
[9] = {
6714 2, -1, 0, /* y - 1 */
6716 0, 1, -2 /* y + 1 */
6719 static int laplace_matrix
[9] = {
6721 1, 0, 0, /* y - 1 */
6723 0, 0, -1 /* y + 1 */
6726 /* Value is the intensity of the color whose red/green/blue values
6729 #define COLOR_INTENSITY(R, G, B) ((2 * (R) + 3 * (G) + (B)) / 6)
6732 /* On frame F, return an array of XColor structures describing image
6733 IMG->pixmap. Each XColor structure has its pixel color set. RGB_P
6734 non-zero means also fill the red/green/blue members of the XColor
6735 structures. Value is a pointer to the array of XColors structures,
6736 allocated with xmalloc; it must be freed by the caller. */
6739 x_to_xcolors (f
, img
, rgb_p
)
6748 colors
= (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *colors
);
6750 /* Get the X image IMG->pixmap. */
6751 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
6752 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
6754 /* Fill the `pixel' members of the XColor array. I wished there
6755 were an easy and portable way to circumvent XGetPixel. */
6757 for (y
= 0; y
< img
->height
; ++y
)
6761 for (x
= 0; x
< img
->width
; ++x
, ++p
)
6762 p
->pixel
= XGetPixel (ximg
, x
, y
);
6765 x_query_colors (f
, row
, img
->width
);
6768 XDestroyImage (ximg
);
6773 /* Create IMG->pixmap from an array COLORS of XColor structures, whose
6774 RGB members are set. F is the frame on which this all happens.
6775 COLORS will be freed; an existing IMG->pixmap will be freed, too. */
6778 x_from_xcolors (f
, img
, colors
)
6788 init_color_table ();
6790 x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 0,
6793 for (y
= 0; y
< img
->height
; ++y
)
6794 for (x
= 0; x
< img
->width
; ++x
, ++p
)
6796 unsigned long pixel
;
6797 pixel
= lookup_rgb_color (f
, p
->red
, p
->green
, p
->blue
);
6798 XPutPixel (oimg
, x
, y
, pixel
);
6802 x_clear_image_1 (f
, img
, 1, 0, 1);
6804 x_put_x_image (f
, oimg
, pixmap
, img
->width
, img
->height
);
6805 x_destroy_x_image (oimg
);
6806 img
->pixmap
= pixmap
;
6807 img
->colors
= colors_in_color_table (&img
->ncolors
);
6808 free_color_table ();
6812 /* On frame F, perform edge-detection on image IMG.
6814 MATRIX is a nine-element array specifying the transformation
6815 matrix. See emboss_matrix for an example.
6817 COLOR_ADJUST is a color adjustment added to each pixel of the
6821 x_detect_edges (f
, img
, matrix
, color_adjust
)
6824 int matrix
[9], color_adjust
;
6826 XColor
*colors
= x_to_xcolors (f
, img
, 1);
6830 for (i
= sum
= 0; i
< 9; ++i
)
6831 sum
+= abs (matrix
[i
]);
6833 #define COLOR(A, X, Y) ((A) + (Y) * img->width + (X))
6835 new = (XColor
*) xmalloc (img
->width
* img
->height
* sizeof *new);
6837 for (y
= 0; y
< img
->height
; ++y
)
6839 p
= COLOR (new, 0, y
);
6840 p
->red
= p
->green
= p
->blue
= 0xffff/2;
6841 p
= COLOR (new, img
->width
- 1, y
);
6842 p
->red
= p
->green
= p
->blue
= 0xffff/2;
6845 for (x
= 1; x
< img
->width
- 1; ++x
)
6847 p
= COLOR (new, x
, 0);
6848 p
->red
= p
->green
= p
->blue
= 0xffff/2;
6849 p
= COLOR (new, x
, img
->height
- 1);
6850 p
->red
= p
->green
= p
->blue
= 0xffff/2;
6853 for (y
= 1; y
< img
->height
- 1; ++y
)
6855 p
= COLOR (new, 1, y
);
6857 for (x
= 1; x
< img
->width
- 1; ++x
, ++p
)
6859 int r
, g
, b
, y1
, x1
;
6862 for (y1
= y
- 1; y1
< y
+ 2; ++y1
)
6863 for (x1
= x
- 1; x1
< x
+ 2; ++x1
, ++i
)
6866 XColor
*t
= COLOR (colors
, x1
, y1
);
6867 r
+= matrix
[i
] * t
->red
;
6868 g
+= matrix
[i
] * t
->green
;
6869 b
+= matrix
[i
] * t
->blue
;
6872 r
= (r
/ sum
+ color_adjust
) & 0xffff;
6873 g
= (g
/ sum
+ color_adjust
) & 0xffff;
6874 b
= (b
/ sum
+ color_adjust
) & 0xffff;
6875 p
->red
= p
->green
= p
->blue
= COLOR_INTENSITY (r
, g
, b
);
6880 x_from_xcolors (f
, img
, new);
6886 /* Perform the pre-defined `emboss' edge-detection on image IMG
6894 x_detect_edges (f
, img
, emboss_matrix
, 0xffff / 2);
6898 /* Perform the pre-defined `laplace' edge-detection on image IMG
6906 x_detect_edges (f
, img
, laplace_matrix
, 45000);
6910 /* Perform edge-detection on image IMG on frame F, with specified
6911 transformation matrix MATRIX and color-adjustment COLOR_ADJUST.
6913 MATRIX must be either
6915 - a list of at least 9 numbers in row-major form
6916 - a vector of at least 9 numbers
6918 COLOR_ADJUST nil means use a default; otherwise it must be a
6922 x_edge_detection (f
, img
, matrix
, color_adjust
)
6925 Lisp_Object matrix
, color_adjust
;
6933 i
< 9 && CONSP (matrix
) && NUMBERP (XCAR (matrix
));
6934 ++i
, matrix
= XCDR (matrix
))
6935 trans
[i
] = XFLOATINT (XCAR (matrix
));
6937 else if (VECTORP (matrix
) && ASIZE (matrix
) >= 9)
6939 for (i
= 0; i
< 9 && NUMBERP (AREF (matrix
, i
)); ++i
)
6940 trans
[i
] = XFLOATINT (AREF (matrix
, i
));
6943 if (NILP (color_adjust
))
6944 color_adjust
= make_number (0xffff / 2);
6946 if (i
== 9 && NUMBERP (color_adjust
))
6947 x_detect_edges (f
, img
, trans
, (int) XFLOATINT (color_adjust
));
6951 /* Transform image IMG on frame F so that it looks disabled. */
6954 x_disable_image (f
, img
)
6958 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
6960 if (dpyinfo
->n_planes
>= 2)
6962 /* Color (or grayscale). Convert to gray, and equalize. Just
6963 drawing such images with a stipple can look very odd, so
6964 we're using this method instead. */
6965 XColor
*colors
= x_to_xcolors (f
, img
, 1);
6967 const int h
= 15000;
6968 const int l
= 30000;
6970 for (p
= colors
, end
= colors
+ img
->width
* img
->height
;
6974 int i
= COLOR_INTENSITY (p
->red
, p
->green
, p
->blue
);
6975 int i2
= (0xffff - h
- l
) * i
/ 0xffff + l
;
6976 p
->red
= p
->green
= p
->blue
= i2
;
6979 x_from_xcolors (f
, img
, colors
);
6982 /* Draw a cross over the disabled image, if we must or if we
6984 if (dpyinfo
->n_planes
< 2 || cross_disabled_images
)
6986 Display
*dpy
= FRAME_X_DISPLAY (f
);
6989 gc
= XCreateGC (dpy
, img
->pixmap
, 0, NULL
);
6990 XSetForeground (dpy
, gc
, BLACK_PIX_DEFAULT (f
));
6991 XDrawLine (dpy
, img
->pixmap
, gc
, 0, 0,
6992 img
->width
- 1, img
->height
- 1);
6993 XDrawLine (dpy
, img
->pixmap
, gc
, 0, img
->height
- 1,
6999 gc
= XCreateGC (dpy
, img
->mask
, 0, NULL
);
7000 XSetForeground (dpy
, gc
, WHITE_PIX_DEFAULT (f
));
7001 XDrawLine (dpy
, img
->mask
, gc
, 0, 0,
7002 img
->width
- 1, img
->height
- 1);
7003 XDrawLine (dpy
, img
->mask
, gc
, 0, img
->height
- 1,
7011 /* Build a mask for image IMG which is used on frame F. FILE is the
7012 name of an image file, for error messages. HOW determines how to
7013 determine the background color of IMG. If it is a list '(R G B)',
7014 with R, G, and B being integers >= 0, take that as the color of the
7015 background. Otherwise, determine the background color of IMG
7016 heuristically. Value is non-zero if successful. */
7019 x_build_heuristic_mask (f
, img
, how
)
7024 Display
*dpy
= FRAME_X_DISPLAY (f
);
7025 XImage
*ximg
, *mask_img
;
7026 int x
, y
, rc
, use_img_background
;
7027 unsigned long bg
= 0;
7031 XFreePixmap (FRAME_X_DISPLAY (f
), img
->mask
);
7033 img
->background_transparent_valid
= 0;
7036 /* Create an image and pixmap serving as mask. */
7037 rc
= x_create_x_image_and_pixmap (f
, img
->width
, img
->height
, 1,
7038 &mask_img
, &img
->mask
);
7042 /* Get the X image of IMG->pixmap. */
7043 ximg
= XGetImage (dpy
, img
->pixmap
, 0, 0, img
->width
, img
->height
,
7046 /* Determine the background color of ximg. If HOW is `(R G B)'
7047 take that as color. Otherwise, use the image's background color. */
7048 use_img_background
= 1;
7054 for (i
= 0; i
< 3 && CONSP (how
) && NATNUMP (XCAR (how
)); ++i
)
7056 rgb
[i
] = XFASTINT (XCAR (how
)) & 0xffff;
7060 if (i
== 3 && NILP (how
))
7062 char color_name
[30];
7063 sprintf (color_name
, "#%04x%04x%04x", rgb
[0], rgb
[1], rgb
[2]);
7064 bg
= x_alloc_image_color (f
, img
, build_string (color_name
), 0);
7065 use_img_background
= 0;
7069 if (use_img_background
)
7070 bg
= four_corners_best (ximg
, img
->width
, img
->height
);
7072 /* Set all bits in mask_img to 1 whose color in ximg is different
7073 from the background color bg. */
7074 for (y
= 0; y
< img
->height
; ++y
)
7075 for (x
= 0; x
< img
->width
; ++x
)
7076 XPutPixel (mask_img
, x
, y
, XGetPixel (ximg
, x
, y
) != bg
);
7078 /* Fill in the background_transparent field while we have the mask handy. */
7079 image_background_transparent (img
, f
, mask_img
);
7081 /* Put mask_img into img->mask. */
7082 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
7083 x_destroy_x_image (mask_img
);
7084 XDestroyImage (ximg
);
7091 /***********************************************************************
7092 PBM (mono, gray, color)
7093 ***********************************************************************/
7095 static int pbm_image_p
P_ ((Lisp_Object object
));
7096 static int pbm_load
P_ ((struct frame
*f
, struct image
*img
));
7097 static int pbm_scan_number
P_ ((unsigned char **, unsigned char *));
7099 /* The symbol `pbm' identifying images of this type. */
7103 /* Indices of image specification fields in gs_format, below. */
7105 enum pbm_keyword_index
7121 /* Vector of image_keyword structures describing the format
7122 of valid user-defined image specifications. */
7124 static struct image_keyword pbm_format
[PBM_LAST
] =
7126 {":type", IMAGE_SYMBOL_VALUE
, 1},
7127 {":file", IMAGE_STRING_VALUE
, 0},
7128 {":data", IMAGE_STRING_VALUE
, 0},
7129 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7130 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7131 {":relief", IMAGE_INTEGER_VALUE
, 0},
7132 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7133 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7134 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7135 {":foreground", IMAGE_STRING_OR_NIL_VALUE
, 0},
7136 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7139 /* Structure describing the image type `pbm'. */
7141 static struct image_type pbm_type
=
7151 /* Return non-zero if OBJECT is a valid PBM image specification. */
7154 pbm_image_p (object
)
7157 struct image_keyword fmt
[PBM_LAST
];
7159 bcopy (pbm_format
, fmt
, sizeof fmt
);
7161 if (!parse_image_spec (object
, fmt
, PBM_LAST
, Qpbm
))
7164 /* Must specify either :data or :file. */
7165 return fmt
[PBM_DATA
].count
+ fmt
[PBM_FILE
].count
== 1;
7169 /* Scan a decimal number from *S and return it. Advance *S while
7170 reading the number. END is the end of the string. Value is -1 at
7174 pbm_scan_number (s
, end
)
7175 unsigned char **s
, *end
;
7177 int c
= 0, val
= -1;
7181 /* Skip white-space. */
7182 while (*s
< end
&& (c
= *(*s
)++, isspace (c
)))
7187 /* Skip comment to end of line. */
7188 while (*s
< end
&& (c
= *(*s
)++, c
!= '\n'))
7191 else if (isdigit (c
))
7193 /* Read decimal number. */
7195 while (*s
< end
&& (c
= *(*s
)++, isdigit (c
)))
7196 val
= 10 * val
+ c
- '0';
7207 /* Load PBM image IMG for use on frame F. */
7215 int width
, height
, max_color_idx
= 0;
7217 Lisp_Object file
, specified_file
;
7218 enum {PBM_MONO
, PBM_GRAY
, PBM_COLOR
} type
;
7219 struct gcpro gcpro1
;
7220 unsigned char *contents
= NULL
;
7221 unsigned char *end
, *p
;
7224 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7228 if (STRINGP (specified_file
))
7230 file
= x_find_image_file (specified_file
);
7231 if (!STRINGP (file
))
7233 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7238 contents
= slurp_file (SDATA (file
), &size
);
7239 if (contents
== NULL
)
7241 image_error ("Error reading `%s'", file
, Qnil
);
7247 end
= contents
+ size
;
7252 data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7254 end
= p
+ SBYTES (data
);
7257 /* Check magic number. */
7258 if (end
- p
< 2 || *p
++ != 'P')
7260 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
7270 raw_p
= 0, type
= PBM_MONO
;
7274 raw_p
= 0, type
= PBM_GRAY
;
7278 raw_p
= 0, type
= PBM_COLOR
;
7282 raw_p
= 1, type
= PBM_MONO
;
7286 raw_p
= 1, type
= PBM_GRAY
;
7290 raw_p
= 1, type
= PBM_COLOR
;
7294 image_error ("Not a PBM image: `%s'", img
->spec
, Qnil
);
7298 /* Read width, height, maximum color-component. Characters
7299 starting with `#' up to the end of a line are ignored. */
7300 width
= pbm_scan_number (&p
, end
);
7301 height
= pbm_scan_number (&p
, end
);
7303 if (type
!= PBM_MONO
)
7305 max_color_idx
= pbm_scan_number (&p
, end
);
7306 if (raw_p
&& max_color_idx
> 255)
7307 max_color_idx
= 255;
7312 || (type
!= PBM_MONO
&& max_color_idx
< 0))
7315 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0,
7316 &ximg
, &img
->pixmap
))
7319 /* Initialize the color hash table. */
7320 init_color_table ();
7322 if (type
== PBM_MONO
)
7325 struct image_keyword fmt
[PBM_LAST
];
7326 unsigned long fg
= FRAME_FOREGROUND_PIXEL (f
);
7327 unsigned long bg
= FRAME_BACKGROUND_PIXEL (f
);
7329 /* Parse the image specification. */
7330 bcopy (pbm_format
, fmt
, sizeof fmt
);
7331 parse_image_spec (img
->spec
, fmt
, PBM_LAST
, Qpbm
);
7333 /* Get foreground and background colors, maybe allocate colors. */
7334 if (fmt
[PBM_FOREGROUND
].count
7335 && STRINGP (fmt
[PBM_FOREGROUND
].value
))
7336 fg
= x_alloc_image_color (f
, img
, fmt
[PBM_FOREGROUND
].value
, fg
);
7337 if (fmt
[PBM_BACKGROUND
].count
7338 && STRINGP (fmt
[PBM_BACKGROUND
].value
))
7340 bg
= x_alloc_image_color (f
, img
, fmt
[PBM_BACKGROUND
].value
, bg
);
7341 img
->background
= bg
;
7342 img
->background_valid
= 1;
7345 for (y
= 0; y
< height
; ++y
)
7346 for (x
= 0; x
< width
; ++x
)
7356 g
= pbm_scan_number (&p
, end
);
7358 XPutPixel (ximg
, x
, y
, g
? fg
: bg
);
7363 for (y
= 0; y
< height
; ++y
)
7364 for (x
= 0; x
< width
; ++x
)
7368 if (type
== PBM_GRAY
)
7369 r
= g
= b
= raw_p
? *p
++ : pbm_scan_number (&p
, end
);
7378 r
= pbm_scan_number (&p
, end
);
7379 g
= pbm_scan_number (&p
, end
);
7380 b
= pbm_scan_number (&p
, end
);
7383 if (r
< 0 || g
< 0 || b
< 0)
7387 XDestroyImage (ximg
);
7388 image_error ("Invalid pixel value in image `%s'",
7393 /* RGB values are now in the range 0..max_color_idx.
7394 Scale this to the range 0..0xffff supported by X. */
7395 r
= (double) r
* 65535 / max_color_idx
;
7396 g
= (double) g
* 65535 / max_color_idx
;
7397 b
= (double) b
* 65535 / max_color_idx
;
7398 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
7402 /* Store in IMG->colors the colors allocated for the image, and
7403 free the color table. */
7404 img
->colors
= colors_in_color_table (&img
->ncolors
);
7405 free_color_table ();
7407 /* Maybe fill in the background field while we have ximg handy. */
7408 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7409 IMAGE_BACKGROUND (img
, f
, ximg
);
7411 /* Put the image into a pixmap. */
7412 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7413 x_destroy_x_image (ximg
);
7416 img
->height
= height
;
7425 /***********************************************************************
7427 ***********************************************************************/
7433 /* Function prototypes. */
7435 static int png_image_p
P_ ((Lisp_Object object
));
7436 static int png_load
P_ ((struct frame
*f
, struct image
*img
));
7438 /* The symbol `png' identifying images of this type. */
7442 /* Indices of image specification fields in png_format, below. */
7444 enum png_keyword_index
7459 /* Vector of image_keyword structures describing the format
7460 of valid user-defined image specifications. */
7462 static struct image_keyword png_format
[PNG_LAST
] =
7464 {":type", IMAGE_SYMBOL_VALUE
, 1},
7465 {":data", IMAGE_STRING_VALUE
, 0},
7466 {":file", IMAGE_STRING_VALUE
, 0},
7467 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7468 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7469 {":relief", IMAGE_INTEGER_VALUE
, 0},
7470 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7471 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7472 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7473 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7476 /* Structure describing the image type `png'. */
7478 static struct image_type png_type
=
7488 /* Return non-zero if OBJECT is a valid PNG image specification. */
7491 png_image_p (object
)
7494 struct image_keyword fmt
[PNG_LAST
];
7495 bcopy (png_format
, fmt
, sizeof fmt
);
7497 if (!parse_image_spec (object
, fmt
, PNG_LAST
, Qpng
))
7500 /* Must specify either the :data or :file keyword. */
7501 return fmt
[PNG_FILE
].count
+ fmt
[PNG_DATA
].count
== 1;
7505 /* Error and warning handlers installed when the PNG library
7509 my_png_error (png_ptr
, msg
)
7510 png_struct
*png_ptr
;
7513 xassert (png_ptr
!= NULL
);
7514 image_error ("PNG error: %s", build_string (msg
), Qnil
);
7515 longjmp (png_ptr
->jmpbuf
, 1);
7520 my_png_warning (png_ptr
, msg
)
7521 png_struct
*png_ptr
;
7524 xassert (png_ptr
!= NULL
);
7525 image_error ("PNG warning: %s", build_string (msg
), Qnil
);
7528 /* Memory source for PNG decoding. */
7530 struct png_memory_storage
7532 unsigned char *bytes
; /* The data */
7533 size_t len
; /* How big is it? */
7534 int index
; /* Where are we? */
7538 /* Function set as reader function when reading PNG image from memory.
7539 PNG_PTR is a pointer to the PNG control structure. Copy LENGTH
7540 bytes from the input to DATA. */
7543 png_read_from_memory (png_ptr
, data
, length
)
7544 png_structp png_ptr
;
7548 struct png_memory_storage
*tbr
7549 = (struct png_memory_storage
*) png_get_io_ptr (png_ptr
);
7551 if (length
> tbr
->len
- tbr
->index
)
7552 png_error (png_ptr
, "Read error");
7554 bcopy (tbr
->bytes
+ tbr
->index
, data
, length
);
7555 tbr
->index
= tbr
->index
+ length
;
7558 /* Load PNG image IMG for use on frame F. Value is non-zero if
7566 Lisp_Object file
, specified_file
;
7567 Lisp_Object specified_data
;
7569 XImage
*ximg
, *mask_img
= NULL
;
7570 struct gcpro gcpro1
;
7571 png_struct
*png_ptr
= NULL
;
7572 png_info
*info_ptr
= NULL
, *end_info
= NULL
;
7573 FILE *volatile fp
= NULL
;
7575 png_byte
* volatile pixels
= NULL
;
7576 png_byte
** volatile rows
= NULL
;
7577 png_uint_32 width
, height
;
7578 int bit_depth
, color_type
, interlace_type
;
7580 png_uint_32 row_bytes
;
7582 double screen_gamma
, image_gamma
;
7584 struct png_memory_storage tbr
; /* Data to be read */
7586 /* Find out what file to load. */
7587 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
7588 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
7592 if (NILP (specified_data
))
7594 file
= x_find_image_file (specified_file
);
7595 if (!STRINGP (file
))
7597 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
7602 /* Open the image file. */
7603 fp
= fopen (SDATA (file
), "rb");
7606 image_error ("Cannot open image file `%s'", file
, Qnil
);
7612 /* Check PNG signature. */
7613 if (fread (sig
, 1, sizeof sig
, fp
) != sizeof sig
7614 || !png_check_sig (sig
, sizeof sig
))
7616 image_error ("Not a PNG file: `%s'", file
, Qnil
);
7624 /* Read from memory. */
7625 tbr
.bytes
= SDATA (specified_data
);
7626 tbr
.len
= SBYTES (specified_data
);
7629 /* Check PNG signature. */
7630 if (tbr
.len
< sizeof sig
7631 || !png_check_sig (tbr
.bytes
, sizeof sig
))
7633 image_error ("Not a PNG image: `%s'", img
->spec
, Qnil
);
7638 /* Need to skip past the signature. */
7639 tbr
.bytes
+= sizeof (sig
);
7642 /* Initialize read and info structs for PNG lib. */
7643 png_ptr
= png_create_read_struct (PNG_LIBPNG_VER_STRING
, NULL
,
7644 my_png_error
, my_png_warning
);
7647 if (fp
) fclose (fp
);
7652 info_ptr
= png_create_info_struct (png_ptr
);
7655 png_destroy_read_struct (&png_ptr
, NULL
, NULL
);
7656 if (fp
) fclose (fp
);
7661 end_info
= png_create_info_struct (png_ptr
);
7664 png_destroy_read_struct (&png_ptr
, &info_ptr
, NULL
);
7665 if (fp
) fclose (fp
);
7670 /* Set error jump-back. We come back here when the PNG library
7671 detects an error. */
7672 if (setjmp (png_ptr
->jmpbuf
))
7676 png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
7679 if (fp
) fclose (fp
);
7684 /* Read image info. */
7685 if (!NILP (specified_data
))
7686 png_set_read_fn (png_ptr
, (void *) &tbr
, png_read_from_memory
);
7688 png_init_io (png_ptr
, fp
);
7690 png_set_sig_bytes (png_ptr
, sizeof sig
);
7691 png_read_info (png_ptr
, info_ptr
);
7692 png_get_IHDR (png_ptr
, info_ptr
, &width
, &height
, &bit_depth
, &color_type
,
7693 &interlace_type
, NULL
, NULL
);
7695 /* If image contains simply transparency data, we prefer to
7696 construct a clipping mask. */
7697 if (png_get_valid (png_ptr
, info_ptr
, PNG_INFO_tRNS
))
7702 /* This function is easier to write if we only have to handle
7703 one data format: RGB or RGBA with 8 bits per channel. Let's
7704 transform other formats into that format. */
7706 /* Strip more than 8 bits per channel. */
7707 if (bit_depth
== 16)
7708 png_set_strip_16 (png_ptr
);
7710 /* Expand data to 24 bit RGB, or 8 bit grayscale, with alpha channel
7712 png_set_expand (png_ptr
);
7714 /* Convert grayscale images to RGB. */
7715 if (color_type
== PNG_COLOR_TYPE_GRAY
7716 || color_type
== PNG_COLOR_TYPE_GRAY_ALPHA
)
7717 png_set_gray_to_rgb (png_ptr
);
7719 screen_gamma
= (f
->gamma
? 1 / f
->gamma
/ 0.45455 : 2.2);
7721 #if 0 /* Avoid double gamma correction for PNG images. */
7722 /* Tell the PNG lib to handle gamma correction for us. */
7723 #if defined(PNG_READ_sRGB_SUPPORTED) || defined(PNG_WRITE_sRGB_SUPPORTED)
7724 if (png_get_sRGB (png_ptr
, info_ptr
, &intent
))
7725 /* The libpng documentation says this is right in this case. */
7726 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
7729 if (png_get_gAMA (png_ptr
, info_ptr
, &image_gamma
))
7730 /* Image contains gamma information. */
7731 png_set_gamma (png_ptr
, screen_gamma
, image_gamma
);
7733 /* Use the standard default for the image gamma. */
7734 png_set_gamma (png_ptr
, screen_gamma
, 0.45455);
7737 /* Handle alpha channel by combining the image with a background
7738 color. Do this only if a real alpha channel is supplied. For
7739 simple transparency, we prefer a clipping mask. */
7742 png_color_16
*image_bg
;
7743 Lisp_Object specified_bg
7744 = image_spec_value (img
->spec
, QCbackground
, NULL
);
7746 if (STRINGP (specified_bg
))
7747 /* The user specified `:background', use that. */
7750 if (x_defined_color (f
, SDATA (specified_bg
), &color
, 0))
7752 png_color_16 user_bg
;
7754 bzero (&user_bg
, sizeof user_bg
);
7755 user_bg
.red
= color
.red
;
7756 user_bg
.green
= color
.green
;
7757 user_bg
.blue
= color
.blue
;
7759 png_set_background (png_ptr
, &user_bg
,
7760 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
7763 else if (png_get_bKGD (png_ptr
, info_ptr
, &image_bg
))
7764 /* Image contains a background color with which to
7765 combine the image. */
7766 png_set_background (png_ptr
, image_bg
,
7767 PNG_BACKGROUND_GAMMA_FILE
, 1, 1.0);
7770 /* Image does not contain a background color with which
7771 to combine the image data via an alpha channel. Use
7772 the frame's background instead. */
7775 png_color_16 frame_background
;
7777 cmap
= FRAME_X_COLORMAP (f
);
7778 color
.pixel
= FRAME_BACKGROUND_PIXEL (f
);
7779 x_query_color (f
, &color
);
7781 bzero (&frame_background
, sizeof frame_background
);
7782 frame_background
.red
= color
.red
;
7783 frame_background
.green
= color
.green
;
7784 frame_background
.blue
= color
.blue
;
7786 png_set_background (png_ptr
, &frame_background
,
7787 PNG_BACKGROUND_GAMMA_SCREEN
, 0, 1.0);
7791 /* Update info structure. */
7792 png_read_update_info (png_ptr
, info_ptr
);
7794 /* Get number of channels. Valid values are 1 for grayscale images
7795 and images with a palette, 2 for grayscale images with transparency
7796 information (alpha channel), 3 for RGB images, and 4 for RGB
7797 images with alpha channel, i.e. RGBA. If conversions above were
7798 sufficient we should only have 3 or 4 channels here. */
7799 channels
= png_get_channels (png_ptr
, info_ptr
);
7800 xassert (channels
== 3 || channels
== 4);
7802 /* Number of bytes needed for one row of the image. */
7803 row_bytes
= png_get_rowbytes (png_ptr
, info_ptr
);
7805 /* Allocate memory for the image. */
7806 pixels
= (png_byte
*) xmalloc (row_bytes
* height
* sizeof *pixels
);
7807 rows
= (png_byte
**) xmalloc (height
* sizeof *rows
);
7808 for (i
= 0; i
< height
; ++i
)
7809 rows
[i
] = pixels
+ i
* row_bytes
;
7811 /* Read the entire image. */
7812 png_read_image (png_ptr
, rows
);
7813 png_read_end (png_ptr
, info_ptr
);
7820 /* Create the X image and pixmap. */
7821 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
,
7825 /* Create an image and pixmap serving as mask if the PNG image
7826 contains an alpha channel. */
7829 && !x_create_x_image_and_pixmap (f
, width
, height
, 1,
7830 &mask_img
, &img
->mask
))
7832 x_destroy_x_image (ximg
);
7833 XFreePixmap (FRAME_X_DISPLAY (f
), img
->pixmap
);
7838 /* Fill the X image and mask from PNG data. */
7839 init_color_table ();
7841 for (y
= 0; y
< height
; ++y
)
7843 png_byte
*p
= rows
[y
];
7845 for (x
= 0; x
< width
; ++x
)
7852 XPutPixel (ximg
, x
, y
, lookup_rgb_color (f
, r
, g
, b
));
7854 /* An alpha channel, aka mask channel, associates variable
7855 transparency with an image. Where other image formats
7856 support binary transparency---fully transparent or fully
7857 opaque---PNG allows up to 254 levels of partial transparency.
7858 The PNG library implements partial transparency by combining
7859 the image with a specified background color.
7861 I'm not sure how to handle this here nicely: because the
7862 background on which the image is displayed may change, for
7863 real alpha channel support, it would be necessary to create
7864 a new image for each possible background.
7866 What I'm doing now is that a mask is created if we have
7867 boolean transparency information. Otherwise I'm using
7868 the frame's background color to combine the image with. */
7873 XPutPixel (mask_img
, x
, y
, *p
> 0);
7879 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
7880 /* Set IMG's background color from the PNG image, unless the user
7884 if (png_get_bKGD (png_ptr
, info_ptr
, &bg
))
7886 img
->background
= lookup_rgb_color (f
, bg
->red
, bg
->green
, bg
->blue
);
7887 img
->background_valid
= 1;
7891 /* Remember colors allocated for this image. */
7892 img
->colors
= colors_in_color_table (&img
->ncolors
);
7893 free_color_table ();
7896 png_destroy_read_struct (&png_ptr
, &info_ptr
, &end_info
);
7901 img
->height
= height
;
7903 /* Maybe fill in the background field while we have ximg handy. */
7904 IMAGE_BACKGROUND (img
, f
, ximg
);
7906 /* Put the image into the pixmap, then free the X image and its buffer. */
7907 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
7908 x_destroy_x_image (ximg
);
7910 /* Same for the mask. */
7913 /* Fill in the background_transparent field while we have the mask
7915 image_background_transparent (img
, f
, mask_img
);
7917 x_put_x_image (f
, mask_img
, img
->mask
, img
->width
, img
->height
);
7918 x_destroy_x_image (mask_img
);
7925 #endif /* HAVE_PNG != 0 */
7929 /***********************************************************************
7931 ***********************************************************************/
7935 /* Work around a warning about HAVE_STDLIB_H being redefined in
7937 #ifdef HAVE_STDLIB_H
7938 #define HAVE_STDLIB_H_1
7939 #undef HAVE_STDLIB_H
7940 #endif /* HAVE_STLIB_H */
7942 #include <jpeglib.h>
7946 #ifdef HAVE_STLIB_H_1
7947 #define HAVE_STDLIB_H 1
7950 static int jpeg_image_p
P_ ((Lisp_Object object
));
7951 static int jpeg_load
P_ ((struct frame
*f
, struct image
*img
));
7953 /* The symbol `jpeg' identifying images of this type. */
7957 /* Indices of image specification fields in gs_format, below. */
7959 enum jpeg_keyword_index
7968 JPEG_HEURISTIC_MASK
,
7974 /* Vector of image_keyword structures describing the format
7975 of valid user-defined image specifications. */
7977 static struct image_keyword jpeg_format
[JPEG_LAST
] =
7979 {":type", IMAGE_SYMBOL_VALUE
, 1},
7980 {":data", IMAGE_STRING_VALUE
, 0},
7981 {":file", IMAGE_STRING_VALUE
, 0},
7982 {":ascent", IMAGE_ASCENT_VALUE
, 0},
7983 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
7984 {":relief", IMAGE_INTEGER_VALUE
, 0},
7985 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7986 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7987 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
7988 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
7991 /* Structure describing the image type `jpeg'. */
7993 static struct image_type jpeg_type
=
8003 /* Return non-zero if OBJECT is a valid JPEG image specification. */
8006 jpeg_image_p (object
)
8009 struct image_keyword fmt
[JPEG_LAST
];
8011 bcopy (jpeg_format
, fmt
, sizeof fmt
);
8013 if (!parse_image_spec (object
, fmt
, JPEG_LAST
, Qjpeg
))
8016 /* Must specify either the :data or :file keyword. */
8017 return fmt
[JPEG_FILE
].count
+ fmt
[JPEG_DATA
].count
== 1;
8021 struct my_jpeg_error_mgr
8023 struct jpeg_error_mgr pub
;
8024 jmp_buf setjmp_buffer
;
8029 my_error_exit (cinfo
)
8032 struct my_jpeg_error_mgr
*mgr
= (struct my_jpeg_error_mgr
*) cinfo
->err
;
8033 longjmp (mgr
->setjmp_buffer
, 1);
8037 /* Init source method for JPEG data source manager. Called by
8038 jpeg_read_header() before any data is actually read. See
8039 libjpeg.doc from the JPEG lib distribution. */
8042 our_init_source (cinfo
)
8043 j_decompress_ptr cinfo
;
8048 /* Fill input buffer method for JPEG data source manager. Called
8049 whenever more data is needed. We read the whole image in one step,
8050 so this only adds a fake end of input marker at the end. */
8053 our_fill_input_buffer (cinfo
)
8054 j_decompress_ptr cinfo
;
8056 /* Insert a fake EOI marker. */
8057 struct jpeg_source_mgr
*src
= cinfo
->src
;
8058 static JOCTET buffer
[2];
8060 buffer
[0] = (JOCTET
) 0xFF;
8061 buffer
[1] = (JOCTET
) JPEG_EOI
;
8063 src
->next_input_byte
= buffer
;
8064 src
->bytes_in_buffer
= 2;
8069 /* Method to skip over NUM_BYTES bytes in the image data. CINFO->src
8070 is the JPEG data source manager. */
8073 our_skip_input_data (cinfo
, num_bytes
)
8074 j_decompress_ptr cinfo
;
8077 struct jpeg_source_mgr
*src
= (struct jpeg_source_mgr
*) cinfo
->src
;
8081 if (num_bytes
> src
->bytes_in_buffer
)
8082 ERREXIT (cinfo
, JERR_INPUT_EOF
);
8084 src
->bytes_in_buffer
-= num_bytes
;
8085 src
->next_input_byte
+= num_bytes
;
8090 /* Method to terminate data source. Called by
8091 jpeg_finish_decompress() after all data has been processed. */
8094 our_term_source (cinfo
)
8095 j_decompress_ptr cinfo
;
8100 /* Set up the JPEG lib for reading an image from DATA which contains
8101 LEN bytes. CINFO is the decompression info structure created for
8102 reading the image. */
8105 jpeg_memory_src (cinfo
, data
, len
)
8106 j_decompress_ptr cinfo
;
8110 struct jpeg_source_mgr
*src
;
8112 if (cinfo
->src
== NULL
)
8114 /* First time for this JPEG object? */
8115 cinfo
->src
= (struct jpeg_source_mgr
*)
8116 (*cinfo
->mem
->alloc_small
) ((j_common_ptr
) cinfo
, JPOOL_PERMANENT
,
8117 sizeof (struct jpeg_source_mgr
));
8118 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
8119 src
->next_input_byte
= data
;
8122 src
= (struct jpeg_source_mgr
*) cinfo
->src
;
8123 src
->init_source
= our_init_source
;
8124 src
->fill_input_buffer
= our_fill_input_buffer
;
8125 src
->skip_input_data
= our_skip_input_data
;
8126 src
->resync_to_restart
= jpeg_resync_to_restart
; /* Use default method. */
8127 src
->term_source
= our_term_source
;
8128 src
->bytes_in_buffer
= len
;
8129 src
->next_input_byte
= data
;
8133 /* Load image IMG for use on frame F. Patterned after example.c
8134 from the JPEG lib. */
8141 struct jpeg_decompress_struct cinfo
;
8142 struct my_jpeg_error_mgr mgr
;
8143 Lisp_Object file
, specified_file
;
8144 Lisp_Object specified_data
;
8145 FILE * volatile fp
= NULL
;
8147 int row_stride
, x
, y
;
8148 XImage
*ximg
= NULL
;
8150 unsigned long *colors
;
8152 struct gcpro gcpro1
;
8154 /* Open the JPEG file. */
8155 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
8156 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8160 if (NILP (specified_data
))
8162 file
= x_find_image_file (specified_file
);
8163 if (!STRINGP (file
))
8165 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
8170 fp
= fopen (SDATA (file
), "r");
8173 image_error ("Cannot open `%s'", file
, Qnil
);
8179 /* Customize libjpeg's error handling to call my_error_exit when an
8180 error is detected. This function will perform a longjmp. */
8181 cinfo
.err
= jpeg_std_error (&mgr
.pub
);
8182 mgr
.pub
.error_exit
= my_error_exit
;
8184 if ((rc
= setjmp (mgr
.setjmp_buffer
)) != 0)
8188 /* Called from my_error_exit. Display a JPEG error. */
8189 char buffer
[JMSG_LENGTH_MAX
];
8190 cinfo
.err
->format_message ((j_common_ptr
) &cinfo
, buffer
);
8191 image_error ("Error reading JPEG image `%s': %s", img
->spec
,
8192 build_string (buffer
));
8195 /* Close the input file and destroy the JPEG object. */
8197 fclose ((FILE *) fp
);
8198 jpeg_destroy_decompress (&cinfo
);
8200 /* If we already have an XImage, free that. */
8201 x_destroy_x_image (ximg
);
8203 /* Free pixmap and colors. */
8204 x_clear_image (f
, img
);
8210 /* Create the JPEG decompression object. Let it read from fp.
8211 Read the JPEG image header. */
8212 jpeg_create_decompress (&cinfo
);
8214 if (NILP (specified_data
))
8215 jpeg_stdio_src (&cinfo
, (FILE *) fp
);
8217 jpeg_memory_src (&cinfo
, SDATA (specified_data
),
8218 SBYTES (specified_data
));
8220 jpeg_read_header (&cinfo
, TRUE
);
8222 /* Customize decompression so that color quantization will be used.
8223 Start decompression. */
8224 cinfo
.quantize_colors
= TRUE
;
8225 jpeg_start_decompress (&cinfo
);
8226 width
= img
->width
= cinfo
.output_width
;
8227 height
= img
->height
= cinfo
.output_height
;
8229 /* Create X image and pixmap. */
8230 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8231 longjmp (mgr
.setjmp_buffer
, 2);
8233 /* Allocate colors. When color quantization is used,
8234 cinfo.actual_number_of_colors has been set with the number of
8235 colors generated, and cinfo.colormap is a two-dimensional array
8236 of color indices in the range 0..cinfo.actual_number_of_colors.
8237 No more than 255 colors will be generated. */
8241 if (cinfo
.out_color_components
> 2)
8242 ir
= 0, ig
= 1, ib
= 2;
8243 else if (cinfo
.out_color_components
> 1)
8244 ir
= 0, ig
= 1, ib
= 0;
8246 ir
= 0, ig
= 0, ib
= 0;
8248 /* Use the color table mechanism because it handles colors that
8249 cannot be allocated nicely. Such colors will be replaced with
8250 a default color, and we don't have to care about which colors
8251 can be freed safely, and which can't. */
8252 init_color_table ();
8253 colors
= (unsigned long *) alloca (cinfo
.actual_number_of_colors
8256 for (i
= 0; i
< cinfo
.actual_number_of_colors
; ++i
)
8258 /* Multiply RGB values with 255 because X expects RGB values
8259 in the range 0..0xffff. */
8260 int r
= cinfo
.colormap
[ir
][i
] << 8;
8261 int g
= cinfo
.colormap
[ig
][i
] << 8;
8262 int b
= cinfo
.colormap
[ib
][i
] << 8;
8263 colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
8266 /* Remember those colors actually allocated. */
8267 img
->colors
= colors_in_color_table (&img
->ncolors
);
8268 free_color_table ();
8272 row_stride
= width
* cinfo
.output_components
;
8273 buffer
= cinfo
.mem
->alloc_sarray ((j_common_ptr
) &cinfo
, JPOOL_IMAGE
,
8275 for (y
= 0; y
< height
; ++y
)
8277 jpeg_read_scanlines (&cinfo
, buffer
, 1);
8278 for (x
= 0; x
< cinfo
.output_width
; ++x
)
8279 XPutPixel (ximg
, x
, y
, colors
[buffer
[0][x
]]);
8283 jpeg_finish_decompress (&cinfo
);
8284 jpeg_destroy_decompress (&cinfo
);
8286 fclose ((FILE *) fp
);
8288 /* Maybe fill in the background field while we have ximg handy. */
8289 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8290 IMAGE_BACKGROUND (img
, f
, ximg
);
8292 /* Put the image into the pixmap. */
8293 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8294 x_destroy_x_image (ximg
);
8299 #endif /* HAVE_JPEG */
8303 /***********************************************************************
8305 ***********************************************************************/
8311 static int tiff_image_p
P_ ((Lisp_Object object
));
8312 static int tiff_load
P_ ((struct frame
*f
, struct image
*img
));
8314 /* The symbol `tiff' identifying images of this type. */
8318 /* Indices of image specification fields in tiff_format, below. */
8320 enum tiff_keyword_index
8329 TIFF_HEURISTIC_MASK
,
8335 /* Vector of image_keyword structures describing the format
8336 of valid user-defined image specifications. */
8338 static struct image_keyword tiff_format
[TIFF_LAST
] =
8340 {":type", IMAGE_SYMBOL_VALUE
, 1},
8341 {":data", IMAGE_STRING_VALUE
, 0},
8342 {":file", IMAGE_STRING_VALUE
, 0},
8343 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8344 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8345 {":relief", IMAGE_INTEGER_VALUE
, 0},
8346 {":conversions", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8347 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8348 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8349 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8352 /* Structure describing the image type `tiff'. */
8354 static struct image_type tiff_type
=
8364 /* Return non-zero if OBJECT is a valid TIFF image specification. */
8367 tiff_image_p (object
)
8370 struct image_keyword fmt
[TIFF_LAST
];
8371 bcopy (tiff_format
, fmt
, sizeof fmt
);
8373 if (!parse_image_spec (object
, fmt
, TIFF_LAST
, Qtiff
))
8376 /* Must specify either the :data or :file keyword. */
8377 return fmt
[TIFF_FILE
].count
+ fmt
[TIFF_DATA
].count
== 1;
8381 /* Reading from a memory buffer for TIFF images Based on the PNG
8382 memory source, but we have to provide a lot of extra functions.
8385 We really only need to implement read and seek, but I am not
8386 convinced that the TIFF library is smart enough not to destroy
8387 itself if we only hand it the function pointers we need to
8392 unsigned char *bytes
;
8400 tiff_read_from_memory (data
, buf
, size
)
8405 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
8407 if (size
> src
->len
- src
->index
)
8409 bcopy (src
->bytes
+ src
->index
, buf
, size
);
8416 tiff_write_from_memory (data
, buf
, size
)
8426 tiff_seek_in_memory (data
, off
, whence
)
8431 tiff_memory_source
*src
= (tiff_memory_source
*) data
;
8436 case SEEK_SET
: /* Go from beginning of source. */
8440 case SEEK_END
: /* Go from end of source. */
8441 idx
= src
->len
+ off
;
8444 case SEEK_CUR
: /* Go from current position. */
8445 idx
= src
->index
+ off
;
8448 default: /* Invalid `whence'. */
8452 if (idx
> src
->len
|| idx
< 0)
8461 tiff_close_memory (data
)
8470 tiff_mmap_memory (data
, pbase
, psize
)
8475 /* It is already _IN_ memory. */
8481 tiff_unmap_memory (data
, base
, size
)
8486 /* We don't need to do this. */
8491 tiff_size_of_memory (data
)
8494 return ((tiff_memory_source
*) data
)->len
;
8499 tiff_error_handler (title
, format
, ap
)
8500 const char *title
, *format
;
8506 len
= sprintf (buf
, "TIFF error: %s ", title
);
8507 vsprintf (buf
+ len
, format
, ap
);
8508 add_to_log (buf
, Qnil
, Qnil
);
8513 tiff_warning_handler (title
, format
, ap
)
8514 const char *title
, *format
;
8520 len
= sprintf (buf
, "TIFF warning: %s ", title
);
8521 vsprintf (buf
+ len
, format
, ap
);
8522 add_to_log (buf
, Qnil
, Qnil
);
8526 /* Load TIFF image IMG for use on frame F. Value is non-zero if
8534 Lisp_Object file
, specified_file
;
8535 Lisp_Object specified_data
;
8537 int width
, height
, x
, y
;
8541 struct gcpro gcpro1
;
8542 tiff_memory_source memsrc
;
8544 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
8545 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8549 TIFFSetErrorHandler (tiff_error_handler
);
8550 TIFFSetWarningHandler (tiff_warning_handler
);
8552 if (NILP (specified_data
))
8554 /* Read from a file */
8555 file
= x_find_image_file (specified_file
);
8556 if (!STRINGP (file
))
8558 image_error ("Cannot find image file `%s'", file
, Qnil
);
8563 /* Try to open the image file. */
8564 tiff
= TIFFOpen (SDATA (file
), "r");
8567 image_error ("Cannot open `%s'", file
, Qnil
);
8574 /* Memory source! */
8575 memsrc
.bytes
= SDATA (specified_data
);
8576 memsrc
.len
= SBYTES (specified_data
);
8579 tiff
= TIFFClientOpen ("memory_source", "r", &memsrc
,
8580 (TIFFReadWriteProc
) tiff_read_from_memory
,
8581 (TIFFReadWriteProc
) tiff_write_from_memory
,
8582 tiff_seek_in_memory
,
8584 tiff_size_of_memory
,
8590 image_error ("Cannot open memory source for `%s'", img
->spec
, Qnil
);
8596 /* Get width and height of the image, and allocate a raster buffer
8597 of width x height 32-bit values. */
8598 TIFFGetField (tiff
, TIFFTAG_IMAGEWIDTH
, &width
);
8599 TIFFGetField (tiff
, TIFFTAG_IMAGELENGTH
, &height
);
8600 buf
= (uint32
*) xmalloc (width
* height
* sizeof *buf
);
8602 rc
= TIFFReadRGBAImage (tiff
, width
, height
, buf
, 0);
8606 image_error ("Error reading TIFF image `%s'", img
->spec
, Qnil
);
8612 /* Create the X image and pixmap. */
8613 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8620 /* Initialize the color table. */
8621 init_color_table ();
8623 /* Process the pixel raster. Origin is in the lower-left corner. */
8624 for (y
= 0; y
< height
; ++y
)
8626 uint32
*row
= buf
+ y
* width
;
8628 for (x
= 0; x
< width
; ++x
)
8630 uint32 abgr
= row
[x
];
8631 int r
= TIFFGetR (abgr
) << 8;
8632 int g
= TIFFGetG (abgr
) << 8;
8633 int b
= TIFFGetB (abgr
) << 8;
8634 XPutPixel (ximg
, x
, height
- 1 - y
, lookup_rgb_color (f
, r
, g
, b
));
8638 /* Remember the colors allocated for the image. Free the color table. */
8639 img
->colors
= colors_in_color_table (&img
->ncolors
);
8640 free_color_table ();
8643 img
->height
= height
;
8645 /* Maybe fill in the background field while we have ximg handy. */
8646 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8647 IMAGE_BACKGROUND (img
, f
, ximg
);
8649 /* Put the image into the pixmap, then free the X image and its buffer. */
8650 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8651 x_destroy_x_image (ximg
);
8658 #endif /* HAVE_TIFF != 0 */
8662 /***********************************************************************
8664 ***********************************************************************/
8668 #include <gif_lib.h>
8670 static int gif_image_p
P_ ((Lisp_Object object
));
8671 static int gif_load
P_ ((struct frame
*f
, struct image
*img
));
8673 /* The symbol `gif' identifying images of this type. */
8677 /* Indices of image specification fields in gif_format, below. */
8679 enum gif_keyword_index
8695 /* Vector of image_keyword structures describing the format
8696 of valid user-defined image specifications. */
8698 static struct image_keyword gif_format
[GIF_LAST
] =
8700 {":type", IMAGE_SYMBOL_VALUE
, 1},
8701 {":data", IMAGE_STRING_VALUE
, 0},
8702 {":file", IMAGE_STRING_VALUE
, 0},
8703 {":ascent", IMAGE_ASCENT_VALUE
, 0},
8704 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
8705 {":relief", IMAGE_INTEGER_VALUE
, 0},
8706 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8707 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8708 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
8709 {":image", IMAGE_NON_NEGATIVE_INTEGER_VALUE
, 0},
8710 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
8713 /* Structure describing the image type `gif'. */
8715 static struct image_type gif_type
=
8725 /* Return non-zero if OBJECT is a valid GIF image specification. */
8728 gif_image_p (object
)
8731 struct image_keyword fmt
[GIF_LAST
];
8732 bcopy (gif_format
, fmt
, sizeof fmt
);
8734 if (!parse_image_spec (object
, fmt
, GIF_LAST
, Qgif
))
8737 /* Must specify either the :data or :file keyword. */
8738 return fmt
[GIF_FILE
].count
+ fmt
[GIF_DATA
].count
== 1;
8742 /* Reading a GIF image from memory
8743 Based on the PNG memory stuff to a certain extent. */
8747 unsigned char *bytes
;
8754 /* Make the current memory source available to gif_read_from_memory.
8755 It's done this way because not all versions of libungif support
8756 a UserData field in the GifFileType structure. */
8757 static gif_memory_source
*current_gif_memory_src
;
8760 gif_read_from_memory (file
, buf
, len
)
8765 gif_memory_source
*src
= current_gif_memory_src
;
8767 if (len
> src
->len
- src
->index
)
8770 bcopy (src
->bytes
+ src
->index
, buf
, len
);
8776 /* Load GIF image IMG for use on frame F. Value is non-zero if
8784 Lisp_Object file
, specified_file
;
8785 Lisp_Object specified_data
;
8786 int rc
, width
, height
, x
, y
, i
;
8788 ColorMapObject
*gif_color_map
;
8789 unsigned long pixel_colors
[256];
8791 struct gcpro gcpro1
;
8793 int ino
, image_left
, image_top
, image_width
, image_height
;
8794 gif_memory_source memsrc
;
8795 unsigned char *raster
;
8797 specified_file
= image_spec_value (img
->spec
, QCfile
, NULL
);
8798 specified_data
= image_spec_value (img
->spec
, QCdata
, NULL
);
8802 if (NILP (specified_data
))
8804 file
= x_find_image_file (specified_file
);
8805 if (!STRINGP (file
))
8807 image_error ("Cannot find image file `%s'", specified_file
, Qnil
);
8812 /* Open the GIF file. */
8813 gif
= DGifOpenFileName (SDATA (file
));
8816 image_error ("Cannot open `%s'", file
, Qnil
);
8823 /* Read from memory! */
8824 current_gif_memory_src
= &memsrc
;
8825 memsrc
.bytes
= SDATA (specified_data
);
8826 memsrc
.len
= SBYTES (specified_data
);
8829 gif
= DGifOpen(&memsrc
, gif_read_from_memory
);
8832 image_error ("Cannot open memory source `%s'", img
->spec
, Qnil
);
8838 /* Read entire contents. */
8839 rc
= DGifSlurp (gif
);
8840 if (rc
== GIF_ERROR
)
8842 image_error ("Error reading `%s'", img
->spec
, Qnil
);
8843 DGifCloseFile (gif
);
8848 image
= image_spec_value (img
->spec
, QCindex
, NULL
);
8849 ino
= INTEGERP (image
) ? XFASTINT (image
) : 0;
8850 if (ino
>= gif
->ImageCount
)
8852 image_error ("Invalid image number `%s' in image `%s'",
8854 DGifCloseFile (gif
);
8859 width
= img
->width
= max (gif
->SWidth
, gif
->Image
.Left
+ gif
->Image
.Width
);
8860 height
= img
->height
= max (gif
->SHeight
, gif
->Image
.Top
+ gif
->Image
.Height
);
8862 /* Create the X image and pixmap. */
8863 if (!x_create_x_image_and_pixmap (f
, width
, height
, 0, &ximg
, &img
->pixmap
))
8865 DGifCloseFile (gif
);
8870 /* Allocate colors. */
8871 gif_color_map
= gif
->SavedImages
[ino
].ImageDesc
.ColorMap
;
8873 gif_color_map
= gif
->SColorMap
;
8874 init_color_table ();
8875 bzero (pixel_colors
, sizeof pixel_colors
);
8877 for (i
= 0; i
< gif_color_map
->ColorCount
; ++i
)
8879 int r
= gif_color_map
->Colors
[i
].Red
<< 8;
8880 int g
= gif_color_map
->Colors
[i
].Green
<< 8;
8881 int b
= gif_color_map
->Colors
[i
].Blue
<< 8;
8882 pixel_colors
[i
] = lookup_rgb_color (f
, r
, g
, b
);
8885 img
->colors
= colors_in_color_table (&img
->ncolors
);
8886 free_color_table ();
8888 /* Clear the part of the screen image that are not covered by
8889 the image from the GIF file. Full animated GIF support
8890 requires more than can be done here (see the gif89 spec,
8891 disposal methods). Let's simply assume that the part
8892 not covered by a sub-image is in the frame's background color. */
8893 image_top
= gif
->SavedImages
[ino
].ImageDesc
.Top
;
8894 image_left
= gif
->SavedImages
[ino
].ImageDesc
.Left
;
8895 image_width
= gif
->SavedImages
[ino
].ImageDesc
.Width
;
8896 image_height
= gif
->SavedImages
[ino
].ImageDesc
.Height
;
8898 for (y
= 0; y
< image_top
; ++y
)
8899 for (x
= 0; x
< width
; ++x
)
8900 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
8902 for (y
= image_top
+ image_height
; y
< height
; ++y
)
8903 for (x
= 0; x
< width
; ++x
)
8904 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
8906 for (y
= image_top
; y
< image_top
+ image_height
; ++y
)
8908 for (x
= 0; x
< image_left
; ++x
)
8909 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
8910 for (x
= image_left
+ image_width
; x
< width
; ++x
)
8911 XPutPixel (ximg
, x
, y
, FRAME_BACKGROUND_PIXEL (f
));
8914 /* Read the GIF image into the X image. We use a local variable
8915 `raster' here because RasterBits below is a char *, and invites
8916 problems with bytes >= 0x80. */
8917 raster
= (unsigned char *) gif
->SavedImages
[ino
].RasterBits
;
8919 if (gif
->SavedImages
[ino
].ImageDesc
.Interlace
)
8921 static int interlace_start
[] = {0, 4, 2, 1};
8922 static int interlace_increment
[] = {8, 8, 4, 2};
8924 int row
= interlace_start
[0];
8928 for (y
= 0; y
< image_height
; y
++)
8930 if (row
>= image_height
)
8932 row
= interlace_start
[++pass
];
8933 while (row
>= image_height
)
8934 row
= interlace_start
[++pass
];
8937 for (x
= 0; x
< image_width
; x
++)
8939 int i
= raster
[(y
* image_width
) + x
];
8940 XPutPixel (ximg
, x
+ image_left
, row
+ image_top
,
8944 row
+= interlace_increment
[pass
];
8949 for (y
= 0; y
< image_height
; ++y
)
8950 for (x
= 0; x
< image_width
; ++x
)
8952 int i
= raster
[y
* image_width
+ x
];
8953 XPutPixel (ximg
, x
+ image_left
, y
+ image_top
, pixel_colors
[i
]);
8957 DGifCloseFile (gif
);
8959 /* Maybe fill in the background field while we have ximg handy. */
8960 if (NILP (image_spec_value (img
->spec
, QCbackground
, NULL
)))
8961 IMAGE_BACKGROUND (img
, f
, ximg
);
8963 /* Put the image into the pixmap, then free the X image and its buffer. */
8964 x_put_x_image (f
, ximg
, img
->pixmap
, width
, height
);
8965 x_destroy_x_image (ximg
);
8971 #endif /* HAVE_GIF != 0 */
8975 /***********************************************************************
8977 ***********************************************************************/
8979 static int gs_image_p
P_ ((Lisp_Object object
));
8980 static int gs_load
P_ ((struct frame
*f
, struct image
*img
));
8981 static void gs_clear_image
P_ ((struct frame
*f
, struct image
*img
));
8983 /* The symbol `postscript' identifying images of this type. */
8985 Lisp_Object Qpostscript
;
8987 /* Keyword symbols. */
8989 Lisp_Object QCloader
, QCbounding_box
, QCpt_width
, QCpt_height
;
8991 /* Indices of image specification fields in gs_format, below. */
8993 enum gs_keyword_index
9011 /* Vector of image_keyword structures describing the format
9012 of valid user-defined image specifications. */
9014 static struct image_keyword gs_format
[GS_LAST
] =
9016 {":type", IMAGE_SYMBOL_VALUE
, 1},
9017 {":pt-width", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
9018 {":pt-height", IMAGE_POSITIVE_INTEGER_VALUE
, 1},
9019 {":file", IMAGE_STRING_VALUE
, 1},
9020 {":loader", IMAGE_FUNCTION_VALUE
, 0},
9021 {":bounding-box", IMAGE_DONT_CHECK_VALUE_TYPE
, 1},
9022 {":ascent", IMAGE_ASCENT_VALUE
, 0},
9023 {":margin", IMAGE_POSITIVE_INTEGER_VALUE_OR_PAIR
, 0},
9024 {":relief", IMAGE_INTEGER_VALUE
, 0},
9025 {":conversion", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9026 {":heuristic-mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9027 {":mask", IMAGE_DONT_CHECK_VALUE_TYPE
, 0},
9028 {":background", IMAGE_STRING_OR_NIL_VALUE
, 0}
9031 /* Structure describing the image type `ghostscript'. */
9033 static struct image_type gs_type
=
9043 /* Free X resources of Ghostscript image IMG which is used on frame F. */
9046 gs_clear_image (f
, img
)
9050 /* IMG->data.ptr_val may contain a recorded colormap. */
9051 xfree (img
->data
.ptr_val
);
9052 x_clear_image (f
, img
);
9056 /* Return non-zero if OBJECT is a valid Ghostscript image
9063 struct image_keyword fmt
[GS_LAST
];
9067 bcopy (gs_format
, fmt
, sizeof fmt
);
9069 if (!parse_image_spec (object
, fmt
, GS_LAST
, Qpostscript
))
9072 /* Bounding box must be a list or vector containing 4 integers. */
9073 tem
= fmt
[GS_BOUNDING_BOX
].value
;
9076 for (i
= 0; i
< 4; ++i
, tem
= XCDR (tem
))
9077 if (!CONSP (tem
) || !INTEGERP (XCAR (tem
)))
9082 else if (VECTORP (tem
))
9084 if (XVECTOR (tem
)->size
!= 4)
9086 for (i
= 0; i
< 4; ++i
)
9087 if (!INTEGERP (XVECTOR (tem
)->contents
[i
]))
9097 /* Load Ghostscript image IMG for use on frame F. Value is non-zero
9106 Lisp_Object window_and_pixmap_id
= Qnil
, loader
, pt_height
, pt_width
;
9107 struct gcpro gcpro1
, gcpro2
;
9109 double in_width
, in_height
;
9110 Lisp_Object pixel_colors
= Qnil
;
9112 /* Compute pixel size of pixmap needed from the given size in the
9113 image specification. Sizes in the specification are in pt. 1 pt
9114 = 1/72 in, xdpi and ydpi are stored in the frame's X display
9116 pt_width
= image_spec_value (img
->spec
, QCpt_width
, NULL
);
9117 in_width
= XFASTINT (pt_width
) / 72.0;
9118 img
->width
= in_width
* FRAME_X_DISPLAY_INFO (f
)->resx
;
9119 pt_height
= image_spec_value (img
->spec
, QCpt_height
, NULL
);
9120 in_height
= XFASTINT (pt_height
) / 72.0;
9121 img
->height
= in_height
* FRAME_X_DISPLAY_INFO (f
)->resy
;
9123 /* Create the pixmap. */
9124 xassert (img
->pixmap
== None
);
9125 img
->pixmap
= XCreatePixmap (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9126 img
->width
, img
->height
,
9127 DefaultDepthOfScreen (FRAME_X_SCREEN (f
)));
9131 image_error ("Unable to create pixmap for `%s'", img
->spec
, Qnil
);
9135 /* Call the loader to fill the pixmap. It returns a process object
9136 if successful. We do not record_unwind_protect here because
9137 other places in redisplay like calling window scroll functions
9138 don't either. Let the Lisp loader use `unwind-protect' instead. */
9139 GCPRO2 (window_and_pixmap_id
, pixel_colors
);
9141 sprintf (buffer
, "%lu %lu",
9142 (unsigned long) FRAME_X_WINDOW (f
),
9143 (unsigned long) img
->pixmap
);
9144 window_and_pixmap_id
= build_string (buffer
);
9146 sprintf (buffer
, "%lu %lu",
9147 FRAME_FOREGROUND_PIXEL (f
),
9148 FRAME_BACKGROUND_PIXEL (f
));
9149 pixel_colors
= build_string (buffer
);
9151 XSETFRAME (frame
, f
);
9152 loader
= image_spec_value (img
->spec
, QCloader
, NULL
);
9154 loader
= intern ("gs-load-image");
9156 img
->data
.lisp_val
= call6 (loader
, frame
, img
->spec
,
9157 make_number (img
->width
),
9158 make_number (img
->height
),
9159 window_and_pixmap_id
,
9162 return PROCESSP (img
->data
.lisp_val
);
9166 /* Kill the Ghostscript process that was started to fill PIXMAP on
9167 frame F. Called from XTread_socket when receiving an event
9168 telling Emacs that Ghostscript has finished drawing. */
9171 x_kill_gs_process (pixmap
, f
)
9175 struct image_cache
*c
= FRAME_X_IMAGE_CACHE (f
);
9179 /* Find the image containing PIXMAP. */
9180 for (i
= 0; i
< c
->used
; ++i
)
9181 if (c
->images
[i
]->pixmap
== pixmap
)
9184 /* Should someone in between have cleared the image cache, for
9185 instance, give up. */
9189 /* Kill the GS process. We should have found PIXMAP in the image
9190 cache and its image should contain a process object. */
9192 xassert (PROCESSP (img
->data
.lisp_val
));
9193 Fkill_process (img
->data
.lisp_val
, Qnil
);
9194 img
->data
.lisp_val
= Qnil
;
9196 /* On displays with a mutable colormap, figure out the colors
9197 allocated for the image by looking at the pixels of an XImage for
9199 class = FRAME_X_VISUAL (f
)->class;
9200 if (class != StaticColor
&& class != StaticGray
&& class != TrueColor
)
9206 /* Try to get an XImage for img->pixmep. */
9207 ximg
= XGetImage (FRAME_X_DISPLAY (f
), img
->pixmap
,
9208 0, 0, img
->width
, img
->height
, ~0, ZPixmap
);
9213 /* Initialize the color table. */
9214 init_color_table ();
9216 /* For each pixel of the image, look its color up in the
9217 color table. After having done so, the color table will
9218 contain an entry for each color used by the image. */
9219 for (y
= 0; y
< img
->height
; ++y
)
9220 for (x
= 0; x
< img
->width
; ++x
)
9222 unsigned long pixel
= XGetPixel (ximg
, x
, y
);
9223 lookup_pixel_color (f
, pixel
);
9226 /* Record colors in the image. Free color table and XImage. */
9227 img
->colors
= colors_in_color_table (&img
->ncolors
);
9228 free_color_table ();
9229 XDestroyImage (ximg
);
9231 #if 0 /* This doesn't seem to be the case. If we free the colors
9232 here, we get a BadAccess later in x_clear_image when
9233 freeing the colors. */
9234 /* We have allocated colors once, but Ghostscript has also
9235 allocated colors on behalf of us. So, to get the
9236 reference counts right, free them once. */
9238 x_free_colors (f
, img
->colors
, img
->ncolors
);
9242 image_error ("Cannot get X image of `%s'; colors will not be freed",
9248 /* Now that we have the pixmap, compute mask and transform the
9249 image if requested. */
9251 postprocess_image (f
, img
);
9257 /***********************************************************************
9259 ***********************************************************************/
9261 DEFUN ("x-change-window-property", Fx_change_window_property
,
9262 Sx_change_window_property
, 2, 3, 0,
9263 doc
: /* Change window property PROP to VALUE on the X window of FRAME.
9264 PROP and VALUE must be strings. FRAME nil or omitted means use the
9265 selected frame. Value is VALUE. */)
9266 (prop
, value
, frame
)
9267 Lisp_Object frame
, prop
, value
;
9269 struct frame
*f
= check_x_frame (frame
);
9272 CHECK_STRING (prop
);
9273 CHECK_STRING (value
);
9276 prop_atom
= XInternAtom (FRAME_X_DISPLAY (f
), SDATA (prop
), False
);
9277 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9278 prop_atom
, XA_STRING
, 8, PropModeReplace
,
9279 SDATA (value
), SCHARS (value
));
9281 /* Make sure the property is set when we return. */
9282 XFlush (FRAME_X_DISPLAY (f
));
9289 DEFUN ("x-delete-window-property", Fx_delete_window_property
,
9290 Sx_delete_window_property
, 1, 2, 0,
9291 doc
: /* Remove window property PROP from X window of FRAME.
9292 FRAME nil or omitted means use the selected frame. Value is PROP. */)
9294 Lisp_Object prop
, frame
;
9296 struct frame
*f
= check_x_frame (frame
);
9299 CHECK_STRING (prop
);
9301 prop_atom
= XInternAtom (FRAME_X_DISPLAY (f
), SDATA (prop
), False
);
9302 XDeleteProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
), prop_atom
);
9304 /* Make sure the property is removed when we return. */
9305 XFlush (FRAME_X_DISPLAY (f
));
9312 DEFUN ("x-window-property", Fx_window_property
, Sx_window_property
,
9314 doc
: /* Value is the value of window property PROP on FRAME.
9315 If FRAME is nil or omitted, use the selected frame. Value is nil
9316 if FRAME hasn't a property with name PROP or if PROP has no string
9319 Lisp_Object prop
, frame
;
9321 struct frame
*f
= check_x_frame (frame
);
9324 Lisp_Object prop_value
= Qnil
;
9325 char *tmp_data
= NULL
;
9328 unsigned long actual_size
, bytes_remaining
;
9330 CHECK_STRING (prop
);
9332 prop_atom
= XInternAtom (FRAME_X_DISPLAY (f
), SDATA (prop
), False
);
9333 rc
= XGetWindowProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9334 prop_atom
, 0, 0, False
, XA_STRING
,
9335 &actual_type
, &actual_format
, &actual_size
,
9336 &bytes_remaining
, (unsigned char **) &tmp_data
);
9339 int size
= bytes_remaining
;
9344 rc
= XGetWindowProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
9345 prop_atom
, 0, bytes_remaining
,
9347 &actual_type
, &actual_format
,
9348 &actual_size
, &bytes_remaining
,
9349 (unsigned char **) &tmp_data
);
9350 if (rc
== Success
&& tmp_data
)
9351 prop_value
= make_string (tmp_data
, size
);
9362 /***********************************************************************
9364 ***********************************************************************/
9366 /* If non-null, an asynchronous timer that, when it expires, displays
9367 an hourglass cursor on all frames. */
9369 static struct atimer
*hourglass_atimer
;
9371 /* Non-zero means an hourglass cursor is currently shown. */
9373 static int hourglass_shown_p
;
9375 /* Number of seconds to wait before displaying an hourglass cursor. */
9377 static Lisp_Object Vhourglass_delay
;
9379 /* Default number of seconds to wait before displaying an hourglass
9382 #define DEFAULT_HOURGLASS_DELAY 1
9384 /* Function prototypes. */
9386 static void show_hourglass
P_ ((struct atimer
*));
9387 static void hide_hourglass
P_ ((void));
9390 /* Cancel a currently active hourglass timer, and start a new one. */
9396 int secs
, usecs
= 0;
9398 cancel_hourglass ();
9400 if (INTEGERP (Vhourglass_delay
)
9401 && XINT (Vhourglass_delay
) > 0)
9402 secs
= XFASTINT (Vhourglass_delay
);
9403 else if (FLOATP (Vhourglass_delay
)
9404 && XFLOAT_DATA (Vhourglass_delay
) > 0)
9407 tem
= Ftruncate (Vhourglass_delay
, Qnil
);
9408 secs
= XFASTINT (tem
);
9409 usecs
= (XFLOAT_DATA (Vhourglass_delay
) - secs
) * 1000000;
9412 secs
= DEFAULT_HOURGLASS_DELAY
;
9414 EMACS_SET_SECS_USECS (delay
, secs
, usecs
);
9415 hourglass_atimer
= start_atimer (ATIMER_RELATIVE
, delay
,
9416 show_hourglass
, NULL
);
9420 /* Cancel the hourglass cursor timer if active, hide a busy cursor if
9426 if (hourglass_atimer
)
9428 cancel_atimer (hourglass_atimer
);
9429 hourglass_atimer
= NULL
;
9432 if (hourglass_shown_p
)
9437 /* Timer function of hourglass_atimer. TIMER is equal to
9440 Display an hourglass pointer on all frames by mapping the frames'
9441 hourglass_window. Set the hourglass_p flag in the frames'
9442 output_data.x structure to indicate that an hourglass cursor is
9443 shown on the frames. */
9446 show_hourglass (timer
)
9447 struct atimer
*timer
;
9449 /* The timer implementation will cancel this timer automatically
9450 after this function has run. Set hourglass_atimer to null
9451 so that we know the timer doesn't have to be canceled. */
9452 hourglass_atimer
= NULL
;
9454 if (!hourglass_shown_p
)
9456 Lisp_Object rest
, frame
;
9460 FOR_EACH_FRAME (rest
, frame
)
9462 struct frame
*f
= XFRAME (frame
);
9464 if (FRAME_LIVE_P (f
) && FRAME_X_P (f
) && FRAME_X_DISPLAY (f
))
9466 Display
*dpy
= FRAME_X_DISPLAY (f
);
9468 #ifdef USE_X_TOOLKIT
9469 if (f
->output_data
.x
->widget
)
9471 if (FRAME_OUTER_WINDOW (f
))
9474 f
->output_data
.x
->hourglass_p
= 1;
9476 if (!f
->output_data
.x
->hourglass_window
)
9478 unsigned long mask
= CWCursor
;
9479 XSetWindowAttributes attrs
;
9481 attrs
.cursor
= f
->output_data
.x
->hourglass_cursor
;
9483 f
->output_data
.x
->hourglass_window
9484 = XCreateWindow (dpy
, FRAME_OUTER_WINDOW (f
),
9485 0, 0, 32000, 32000, 0, 0,
9491 XMapRaised (dpy
, f
->output_data
.x
->hourglass_window
);
9497 hourglass_shown_p
= 1;
9503 /* Hide the hourglass pointer on all frames, if it is currently
9509 if (hourglass_shown_p
)
9511 Lisp_Object rest
, frame
;
9514 FOR_EACH_FRAME (rest
, frame
)
9516 struct frame
*f
= XFRAME (frame
);
9519 /* Watch out for newly created frames. */
9520 && f
->output_data
.x
->hourglass_window
)
9522 XUnmapWindow (FRAME_X_DISPLAY (f
),
9523 f
->output_data
.x
->hourglass_window
);
9524 /* Sync here because XTread_socket looks at the
9525 hourglass_p flag that is reset to zero below. */
9526 XSync (FRAME_X_DISPLAY (f
), False
);
9527 f
->output_data
.x
->hourglass_p
= 0;
9531 hourglass_shown_p
= 0;
9538 /***********************************************************************
9540 ***********************************************************************/
9542 static Lisp_Object x_create_tip_frame
P_ ((struct x_display_info
*,
9543 Lisp_Object
, Lisp_Object
));
9544 static void compute_tip_xy
P_ ((struct frame
*, Lisp_Object
, Lisp_Object
,
9545 Lisp_Object
, int, int, int *, int *));
9547 /* The frame of a currently visible tooltip. */
9549 Lisp_Object tip_frame
;
9551 /* If non-nil, a timer started that hides the last tooltip when it
9554 Lisp_Object tip_timer
;
9557 /* If non-nil, a vector of 3 elements containing the last args
9558 with which x-show-tip was called. See there. */
9560 Lisp_Object last_show_tip_args
;
9562 /* Maximum size for tooltips; a cons (COLUMNS . ROWS). */
9564 Lisp_Object Vx_max_tooltip_size
;
9568 unwind_create_tip_frame (frame
)
9571 Lisp_Object deleted
;
9573 deleted
= unwind_create_frame (frame
);
9574 if (EQ (deleted
, Qt
))
9584 /* Create a frame for a tooltip on the display described by DPYINFO.
9585 PARMS is a list of frame parameters. TEXT is the string to
9586 display in the tip frame. Value is the frame.
9588 Note that functions called here, esp. x_default_parameter can
9589 signal errors, for instance when a specified color name is
9590 undefined. We have to make sure that we're in a consistent state
9591 when this happens. */
9594 x_create_tip_frame (dpyinfo
, parms
, text
)
9595 struct x_display_info
*dpyinfo
;
9596 Lisp_Object parms
, text
;
9599 Lisp_Object frame
, tem
;
9601 long window_prompting
= 0;
9603 int count
= SPECPDL_INDEX ();
9604 struct gcpro gcpro1
, gcpro2
, gcpro3
;
9606 int face_change_count_before
= face_change_count
;
9608 struct buffer
*old_buffer
;
9612 /* Use this general default value to start with until we know if
9613 this frame has a specified name. */
9614 Vx_resource_name
= Vinvocation_name
;
9617 kb
= dpyinfo
->kboard
;
9619 kb
= &the_only_kboard
;
9622 /* Get the name of the frame to use for resource lookup. */
9623 name
= x_get_arg (dpyinfo
, parms
, Qname
, "name", "Name", RES_TYPE_STRING
);
9625 && !EQ (name
, Qunbound
)
9627 error ("Invalid frame name--not a string or nil");
9628 Vx_resource_name
= name
;
9631 GCPRO3 (parms
, name
, frame
);
9633 XSETFRAME (frame
, f
);
9635 buffer
= Fget_buffer_create (build_string (" *tip*"));
9636 Fset_window_buffer (FRAME_ROOT_WINDOW (f
), buffer
, Qnil
);
9637 old_buffer
= current_buffer
;
9638 set_buffer_internal_1 (XBUFFER (buffer
));
9639 current_buffer
->truncate_lines
= Qnil
;
9642 set_buffer_internal_1 (old_buffer
);
9644 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 0;
9645 record_unwind_protect (unwind_create_tip_frame
, frame
);
9647 /* By setting the output method, we're essentially saying that
9648 the frame is live, as per FRAME_LIVE_P. If we get a signal
9649 from this point on, x_destroy_window might screw up reference
9651 f
->output_method
= output_x_window
;
9652 f
->output_data
.x
= (struct x_output
*) xmalloc (sizeof (struct x_output
));
9653 bzero (f
->output_data
.x
, sizeof (struct x_output
));
9654 f
->output_data
.x
->icon_bitmap
= -1;
9655 FRAME_FONTSET (f
) = -1;
9656 f
->output_data
.x
->scroll_bar_foreground_pixel
= -1;
9657 f
->output_data
.x
->scroll_bar_background_pixel
= -1;
9658 #ifdef USE_TOOLKIT_SCROLL_BARS
9659 f
->output_data
.x
->scroll_bar_top_shadow_pixel
= -1;
9660 f
->output_data
.x
->scroll_bar_bottom_shadow_pixel
= -1;
9661 #endif /* USE_TOOLKIT_SCROLL_BARS */
9662 f
->icon_name
= Qnil
;
9663 FRAME_X_DISPLAY_INFO (f
) = dpyinfo
;
9665 image_cache_refcount
= FRAME_X_IMAGE_CACHE (f
)->refcount
;
9666 dpyinfo_refcount
= dpyinfo
->reference_count
;
9667 #endif /* GLYPH_DEBUG */
9669 FRAME_KBOARD (f
) = kb
;
9671 f
->output_data
.x
->parent_desc
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
9672 f
->output_data
.x
->explicit_parent
= 0;
9674 /* These colors will be set anyway later, but it's important
9675 to get the color reference counts right, so initialize them! */
9678 struct gcpro gcpro1
;
9680 black
= build_string ("black");
9682 f
->output_data
.x
->foreground_pixel
9683 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
9684 f
->output_data
.x
->background_pixel
9685 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
9686 f
->output_data
.x
->cursor_pixel
9687 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
9688 f
->output_data
.x
->cursor_foreground_pixel
9689 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
9690 f
->output_data
.x
->border_pixel
9691 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
9692 f
->output_data
.x
->mouse_pixel
9693 = x_decode_color (f
, black
, BLACK_PIX_DEFAULT (f
));
9697 /* Set the name; the functions to which we pass f expect the name to
9699 if (EQ (name
, Qunbound
) || NILP (name
))
9701 f
->name
= build_string (dpyinfo
->x_id_name
);
9702 f
->explicit_name
= 0;
9707 f
->explicit_name
= 1;
9708 /* use the frame's title when getting resources for this frame. */
9709 specbind (Qx_resource_name
, name
);
9712 /* Extract the window parameters from the supplied values that are
9713 needed to determine window geometry. */
9717 font
= x_get_arg (dpyinfo
, parms
, Qfont
, "font", "Font", RES_TYPE_STRING
);
9720 /* First, try whatever font the caller has specified. */
9723 tem
= Fquery_fontset (font
, Qnil
);
9725 font
= x_new_fontset (f
, SDATA (tem
));
9727 font
= x_new_font (f
, SDATA (font
));
9730 /* Try out a font which we hope has bold and italic variations. */
9731 if (!STRINGP (font
))
9732 font
= x_new_font (f
, "-adobe-courier-medium-r-*-*-*-120-*-*-*-*-iso8859-1");
9733 if (!STRINGP (font
))
9734 font
= x_new_font (f
, "-misc-fixed-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
9735 if (! STRINGP (font
))
9736 font
= x_new_font (f
, "-*-*-medium-r-normal-*-*-140-*-*-c-*-iso8859-1");
9737 if (! STRINGP (font
))
9738 /* This was formerly the first thing tried, but it finds too many fonts
9739 and takes too long. */
9740 font
= x_new_font (f
, "-*-*-medium-r-*-*-*-*-*-*-c-*-iso8859-1");
9741 /* If those didn't work, look for something which will at least work. */
9742 if (! STRINGP (font
))
9743 font
= x_new_font (f
, "-*-fixed-*-*-*-*-*-140-*-*-c-*-iso8859-1");
9745 if (! STRINGP (font
))
9746 font
= build_string ("fixed");
9748 x_default_parameter (f
, parms
, Qfont
, font
,
9749 "font", "Font", RES_TYPE_STRING
);
9752 x_default_parameter (f
, parms
, Qborder_width
, make_number (2),
9753 "borderWidth", "BorderWidth", RES_TYPE_NUMBER
);
9755 /* This defaults to 2 in order to match xterm. We recognize either
9756 internalBorderWidth or internalBorder (which is what xterm calls
9758 if (NILP (Fassq (Qinternal_border_width
, parms
)))
9762 value
= x_get_arg (dpyinfo
, parms
, Qinternal_border_width
,
9763 "internalBorder", "internalBorder", RES_TYPE_NUMBER
);
9764 if (! EQ (value
, Qunbound
))
9765 parms
= Fcons (Fcons (Qinternal_border_width
, value
),
9769 x_default_parameter (f
, parms
, Qinternal_border_width
, make_number (1),
9770 "internalBorderWidth", "internalBorderWidth",
9773 /* Also do the stuff which must be set before the window exists. */
9774 x_default_parameter (f
, parms
, Qforeground_color
, build_string ("black"),
9775 "foreground", "Foreground", RES_TYPE_STRING
);
9776 x_default_parameter (f
, parms
, Qbackground_color
, build_string ("white"),
9777 "background", "Background", RES_TYPE_STRING
);
9778 x_default_parameter (f
, parms
, Qmouse_color
, build_string ("black"),
9779 "pointerColor", "Foreground", RES_TYPE_STRING
);
9780 x_default_parameter (f
, parms
, Qcursor_color
, build_string ("black"),
9781 "cursorColor", "Foreground", RES_TYPE_STRING
);
9782 x_default_parameter (f
, parms
, Qborder_color
, build_string ("black"),
9783 "borderColor", "BorderColor", RES_TYPE_STRING
);
9785 /* Init faces before x_default_parameter is called for scroll-bar
9786 parameters because that function calls x_set_scroll_bar_width,
9787 which calls change_frame_size, which calls Fset_window_buffer,
9788 which runs hooks, which call Fvertical_motion. At the end, we
9789 end up in init_iterator with a null face cache, which should not
9791 init_frame_faces (f
);
9793 f
->output_data
.x
->parent_desc
= FRAME_X_DISPLAY_INFO (f
)->root_window
;
9795 window_prompting
= x_figure_window_size (f
, parms
, 0);
9798 XSetWindowAttributes attrs
;
9802 mask
= CWBackPixel
| CWOverrideRedirect
| CWEventMask
;
9803 if (DoesSaveUnders (dpyinfo
->screen
))
9804 mask
|= CWSaveUnder
;
9806 /* Window managers look at the override-redirect flag to determine
9807 whether or net to give windows a decoration (Xlib spec, chapter
9809 attrs
.override_redirect
= True
;
9810 attrs
.save_under
= True
;
9811 attrs
.background_pixel
= FRAME_BACKGROUND_PIXEL (f
);
9812 /* Arrange for getting MapNotify and UnmapNotify events. */
9813 attrs
.event_mask
= StructureNotifyMask
;
9815 = FRAME_X_WINDOW (f
)
9816 = XCreateWindow (FRAME_X_DISPLAY (f
),
9817 FRAME_X_DISPLAY_INFO (f
)->root_window
,
9818 /* x, y, width, height */
9822 CopyFromParent
, InputOutput
, CopyFromParent
,
9829 x_default_parameter (f
, parms
, Qauto_raise
, Qnil
,
9830 "autoRaise", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
9831 x_default_parameter (f
, parms
, Qauto_lower
, Qnil
,
9832 "autoLower", "AutoRaiseLower", RES_TYPE_BOOLEAN
);
9833 x_default_parameter (f
, parms
, Qcursor_type
, Qbox
,
9834 "cursorType", "CursorType", RES_TYPE_SYMBOL
);
9836 /* Dimensions, especially FRAME_LINES (f), must be done via change_frame_size.
9837 Change will not be effected unless different from the current
9839 width
= FRAME_COLS (f
);
9840 height
= FRAME_LINES (f
);
9841 SET_FRAME_COLS (f
, 0);
9842 FRAME_LINES (f
) = 0;
9843 change_frame_size (f
, height
, width
, 1, 0, 0);
9845 /* Add `tooltip' frame parameter's default value. */
9846 if (NILP (Fframe_parameter (frame
, intern ("tooltip"))))
9847 Fmodify_frame_parameters (frame
, Fcons (Fcons (intern ("tooltip"), Qt
),
9850 /* Set up faces after all frame parameters are known. This call
9851 also merges in face attributes specified for new frames.
9853 Frame parameters may be changed if .Xdefaults contains
9854 specifications for the default font. For example, if there is an
9855 `Emacs.default.attributeBackground: pink', the `background-color'
9856 attribute of the frame get's set, which let's the internal border
9857 of the tooltip frame appear in pink. Prevent this. */
9859 Lisp_Object bg
= Fframe_parameter (frame
, Qbackground_color
);
9861 /* Set tip_frame here, so that */
9863 call1 (Qface_set_after_frame_default
, frame
);
9865 if (!EQ (bg
, Fframe_parameter (frame
, Qbackground_color
)))
9866 Fmodify_frame_parameters (frame
, Fcons (Fcons (Qbackground_color
, bg
),
9874 /* It is now ok to make the frame official even if we get an error
9875 below. And the frame needs to be on Vframe_list or making it
9876 visible won't work. */
9877 Vframe_list
= Fcons (frame
, Vframe_list
);
9879 /* Now that the frame is official, it counts as a reference to
9881 FRAME_X_DISPLAY_INFO (f
)->reference_count
++;
9883 /* Setting attributes of faces of the tooltip frame from resources
9884 and similar will increment face_change_count, which leads to the
9885 clearing of all current matrices. Since this isn't necessary
9886 here, avoid it by resetting face_change_count to the value it
9887 had before we created the tip frame. */
9888 face_change_count
= face_change_count_before
;
9890 /* Discard the unwind_protect. */
9891 return unbind_to (count
, frame
);
9895 /* Compute where to display tip frame F. PARMS is the list of frame
9896 parameters for F. DX and DY are specified offsets from the current
9897 location of the mouse. WIDTH and HEIGHT are the width and height
9898 of the tooltip. Return coordinates relative to the root window of
9899 the display in *ROOT_X, and *ROOT_Y. */
9902 compute_tip_xy (f
, parms
, dx
, dy
, width
, height
, root_x
, root_y
)
9904 Lisp_Object parms
, dx
, dy
;
9906 int *root_x
, *root_y
;
9908 Lisp_Object left
, top
;
9913 /* User-specified position? */
9914 left
= Fcdr (Fassq (Qleft
, parms
));
9915 top
= Fcdr (Fassq (Qtop
, parms
));
9917 /* Move the tooltip window where the mouse pointer is. Resize and
9919 if (!INTEGERP (left
) || !INTEGERP (top
))
9922 XQueryPointer (FRAME_X_DISPLAY (f
), FRAME_X_DISPLAY_INFO (f
)->root_window
,
9923 &root
, &child
, root_x
, root_y
, &win_x
, &win_y
, &pmask
);
9928 *root_y
= XINT (top
);
9929 else if (*root_y
+ XINT (dy
) - height
< 0)
9930 *root_y
-= XINT (dy
);
9934 *root_y
+= XINT (dy
);
9937 if (INTEGERP (left
))
9938 *root_x
= XINT (left
);
9939 else if (*root_x
+ XINT (dx
) + width
<= FRAME_X_DISPLAY_INFO (f
)->width
)
9940 /* It fits to the right of the pointer. */
9941 *root_x
+= XINT (dx
);
9942 else if (width
+ XINT (dx
) <= *root_x
)
9943 /* It fits to the left of the pointer. */
9944 *root_x
-= width
+ XINT (dx
);
9946 /* Put it left-justified on the screen--it ought to fit that way. */
9951 DEFUN ("x-show-tip", Fx_show_tip
, Sx_show_tip
, 1, 6, 0,
9952 doc
: /* Show STRING in a "tooltip" window on frame FRAME.
9953 A tooltip window is a small X window displaying a string.
9955 FRAME nil or omitted means use the selected frame.
9957 PARMS is an optional list of frame parameters which can be used to
9958 change the tooltip's appearance.
9960 Automatically hide the tooltip after TIMEOUT seconds. TIMEOUT nil
9961 means use the default timeout of 5 seconds.
9963 If the list of frame parameters PARAMS contains a `left' parameters,
9964 the tooltip is displayed at that x-position. Otherwise it is
9965 displayed at the mouse position, with offset DX added (default is 5 if
9966 DX isn't specified). Likewise for the y-position; if a `top' frame
9967 parameter is specified, it determines the y-position of the tooltip
9968 window, otherwise it is displayed at the mouse position, with offset
9969 DY added (default is -10).
9971 A tooltip's maximum size is specified by `x-max-tooltip-size'.
9972 Text larger than the specified size is clipped. */)
9973 (string
, frame
, parms
, timeout
, dx
, dy
)
9974 Lisp_Object string
, frame
, parms
, timeout
, dx
, dy
;
9979 struct buffer
*old_buffer
;
9980 struct text_pos pos
;
9981 int i
, width
, height
;
9982 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
;
9983 int old_windows_or_buffers_changed
= windows_or_buffers_changed
;
9984 int count
= SPECPDL_INDEX ();
9986 specbind (Qinhibit_redisplay
, Qt
);
9988 GCPRO4 (string
, parms
, frame
, timeout
);
9990 CHECK_STRING (string
);
9991 f
= check_x_frame (frame
);
9993 timeout
= make_number (5);
9995 CHECK_NATNUM (timeout
);
9998 dx
= make_number (5);
10003 dy
= make_number (-10);
10007 if (NILP (last_show_tip_args
))
10008 last_show_tip_args
= Fmake_vector (make_number (3), Qnil
);
10010 if (!NILP (tip_frame
))
10012 Lisp_Object last_string
= AREF (last_show_tip_args
, 0);
10013 Lisp_Object last_frame
= AREF (last_show_tip_args
, 1);
10014 Lisp_Object last_parms
= AREF (last_show_tip_args
, 2);
10016 if (EQ (frame
, last_frame
)
10017 && !NILP (Fequal (last_string
, string
))
10018 && !NILP (Fequal (last_parms
, parms
)))
10020 struct frame
*f
= XFRAME (tip_frame
);
10022 /* Only DX and DY have changed. */
10023 if (!NILP (tip_timer
))
10025 Lisp_Object timer
= tip_timer
;
10027 call1 (Qcancel_timer
, timer
);
10031 compute_tip_xy (f
, parms
, dx
, dy
, FRAME_PIXEL_WIDTH (f
),
10032 FRAME_PIXEL_HEIGHT (f
), &root_x
, &root_y
);
10033 XMoveWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
10040 /* Hide a previous tip, if any. */
10043 ASET (last_show_tip_args
, 0, string
);
10044 ASET (last_show_tip_args
, 1, frame
);
10045 ASET (last_show_tip_args
, 2, parms
);
10047 /* Add default values to frame parameters. */
10048 if (NILP (Fassq (Qname
, parms
)))
10049 parms
= Fcons (Fcons (Qname
, build_string ("tooltip")), parms
);
10050 if (NILP (Fassq (Qinternal_border_width
, parms
)))
10051 parms
= Fcons (Fcons (Qinternal_border_width
, make_number (3)), parms
);
10052 if (NILP (Fassq (Qborder_width
, parms
)))
10053 parms
= Fcons (Fcons (Qborder_width
, make_number (1)), parms
);
10054 if (NILP (Fassq (Qborder_color
, parms
)))
10055 parms
= Fcons (Fcons (Qborder_color
, build_string ("lightyellow")), parms
);
10056 if (NILP (Fassq (Qbackground_color
, parms
)))
10057 parms
= Fcons (Fcons (Qbackground_color
, build_string ("lightyellow")),
10060 /* Create a frame for the tooltip, and record it in the global
10061 variable tip_frame. */
10062 frame
= x_create_tip_frame (FRAME_X_DISPLAY_INFO (f
), parms
, string
);
10063 f
= XFRAME (frame
);
10065 /* Set up the frame's root window. */
10066 w
= XWINDOW (FRAME_ROOT_WINDOW (f
));
10067 w
->left_col
= w
->top_line
= make_number (0);
10069 if (CONSP (Vx_max_tooltip_size
)
10070 && INTEGERP (XCAR (Vx_max_tooltip_size
))
10071 && XINT (XCAR (Vx_max_tooltip_size
)) > 0
10072 && INTEGERP (XCDR (Vx_max_tooltip_size
))
10073 && XINT (XCDR (Vx_max_tooltip_size
)) > 0)
10075 w
->total_cols
= XCAR (Vx_max_tooltip_size
);
10076 w
->total_lines
= XCDR (Vx_max_tooltip_size
);
10080 w
->total_cols
= make_number (80);
10081 w
->total_lines
= make_number (40);
10084 FRAME_TOTAL_COLS (f
) = XINT (w
->total_cols
);
10086 w
->pseudo_window_p
= 1;
10088 /* Display the tooltip text in a temporary buffer. */
10089 old_buffer
= current_buffer
;
10090 set_buffer_internal_1 (XBUFFER (XWINDOW (FRAME_ROOT_WINDOW (f
))->buffer
));
10091 current_buffer
->truncate_lines
= Qnil
;
10092 clear_glyph_matrix (w
->desired_matrix
);
10093 clear_glyph_matrix (w
->current_matrix
);
10094 SET_TEXT_POS (pos
, BEGV
, BEGV_BYTE
);
10095 try_window (FRAME_ROOT_WINDOW (f
), pos
);
10097 /* Compute width and height of the tooltip. */
10098 width
= height
= 0;
10099 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
10101 struct glyph_row
*row
= &w
->desired_matrix
->rows
[i
];
10102 struct glyph
*last
;
10105 /* Stop at the first empty row at the end. */
10106 if (!row
->enabled_p
|| !row
->displays_text_p
)
10109 /* Let the row go over the full width of the frame. */
10110 row
->full_width_p
= 1;
10112 /* There's a glyph at the end of rows that is used to place
10113 the cursor there. Don't include the width of this glyph. */
10114 if (row
->used
[TEXT_AREA
])
10116 last
= &row
->glyphs
[TEXT_AREA
][row
->used
[TEXT_AREA
] - 1];
10117 row_width
= row
->pixel_width
- last
->pixel_width
;
10120 row_width
= row
->pixel_width
;
10122 height
+= row
->height
;
10123 width
= max (width
, row_width
);
10126 /* Add the frame's internal border to the width and height the X
10127 window should have. */
10128 height
+= 2 * FRAME_INTERNAL_BORDER_WIDTH (f
);
10129 width
+= 2 * FRAME_INTERNAL_BORDER_WIDTH (f
);
10131 /* Move the tooltip window where the mouse pointer is. Resize and
10133 compute_tip_xy (f
, parms
, dx
, dy
, width
, height
, &root_x
, &root_y
);
10136 XMoveResizeWindow (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
10137 root_x
, root_y
, width
, height
);
10138 XMapRaised (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
));
10141 /* Draw into the window. */
10142 w
->must_be_updated_p
= 1;
10143 update_single_window (w
, 1);
10145 /* Restore original current buffer. */
10146 set_buffer_internal_1 (old_buffer
);
10147 windows_or_buffers_changed
= old_windows_or_buffers_changed
;
10150 /* Let the tip disappear after timeout seconds. */
10151 tip_timer
= call3 (intern ("run-at-time"), timeout
, Qnil
,
10152 intern ("x-hide-tip"));
10155 return unbind_to (count
, Qnil
);
10159 DEFUN ("x-hide-tip", Fx_hide_tip
, Sx_hide_tip
, 0, 0, 0,
10160 doc
: /* Hide the current tooltip window, if there is any.
10161 Value is t if tooltip was open, nil otherwise. */)
10165 Lisp_Object deleted
, frame
, timer
;
10166 struct gcpro gcpro1
, gcpro2
;
10168 /* Return quickly if nothing to do. */
10169 if (NILP (tip_timer
) && NILP (tip_frame
))
10174 GCPRO2 (frame
, timer
);
10175 tip_frame
= tip_timer
= deleted
= Qnil
;
10177 count
= SPECPDL_INDEX ();
10178 specbind (Qinhibit_redisplay
, Qt
);
10179 specbind (Qinhibit_quit
, Qt
);
10182 call1 (Qcancel_timer
, timer
);
10184 if (FRAMEP (frame
))
10186 Fdelete_frame (frame
, Qnil
);
10190 /* Bloodcurdling hack alert: The Lucid menu bar widget's
10191 redisplay procedure is not called when a tip frame over menu
10192 items is unmapped. Redisplay the menu manually... */
10194 struct frame
*f
= SELECTED_FRAME ();
10195 Widget w
= f
->output_data
.x
->menubar_widget
;
10196 extern void xlwmenu_redisplay
P_ ((Widget
));
10198 if (!DoesSaveUnders (FRAME_X_DISPLAY_INFO (f
)->screen
)
10202 xlwmenu_redisplay (w
);
10206 #endif /* USE_LUCID */
10210 return unbind_to (count
, deleted
);
10215 /***********************************************************************
10216 File selection dialog
10217 ***********************************************************************/
10221 /* Callback for "OK" and "Cancel" on file selection dialog. */
10224 file_dialog_cb (widget
, client_data
, call_data
)
10226 XtPointer call_data
, client_data
;
10228 int *result
= (int *) client_data
;
10229 XmAnyCallbackStruct
*cb
= (XmAnyCallbackStruct
*) call_data
;
10230 *result
= cb
->reason
;
10234 /* Callback for unmapping a file selection dialog. This is used to
10235 capture the case where a dialog is closed via a window manager's
10236 closer button, for example. Using a XmNdestroyCallback didn't work
10240 file_dialog_unmap_cb (widget
, client_data
, call_data
)
10242 XtPointer call_data
, client_data
;
10244 int *result
= (int *) client_data
;
10245 *result
= XmCR_CANCEL
;
10249 DEFUN ("x-file-dialog", Fx_file_dialog
, Sx_file_dialog
, 2, 4, 0,
10250 doc
: /* Read file name, prompting with PROMPT in directory DIR.
10251 Use a file selection dialog.
10252 Select DEFAULT-FILENAME in the dialog's file selection box, if
10253 specified. Don't let the user enter a file name in the file
10254 selection dialog's entry field, if MUSTMATCH is non-nil. */)
10255 (prompt
, dir
, default_filename
, mustmatch
)
10256 Lisp_Object prompt
, dir
, default_filename
, mustmatch
;
10259 struct frame
*f
= SELECTED_FRAME ();
10260 Lisp_Object file
= Qnil
;
10261 Widget dialog
, text
, list
, help
;
10264 extern XtAppContext Xt_app_con
;
10265 XmString dir_xmstring
, pattern_xmstring
;
10266 int count
= SPECPDL_INDEX ();
10267 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
10269 GCPRO5 (prompt
, dir
, default_filename
, mustmatch
, file
);
10270 CHECK_STRING (prompt
);
10271 CHECK_STRING (dir
);
10273 /* Prevent redisplay. */
10274 specbind (Qinhibit_redisplay
, Qt
);
10278 /* Create the dialog with PROMPT as title, using DIR as initial
10279 directory and using "*" as pattern. */
10280 dir
= Fexpand_file_name (dir
, Qnil
);
10281 dir_xmstring
= XmStringCreateLocalized (SDATA (dir
));
10282 pattern_xmstring
= XmStringCreateLocalized ("*");
10284 XtSetArg (al
[ac
], XmNtitle
, SDATA (prompt
)); ++ac
;
10285 XtSetArg (al
[ac
], XmNdirectory
, dir_xmstring
); ++ac
;
10286 XtSetArg (al
[ac
], XmNpattern
, pattern_xmstring
); ++ac
;
10287 XtSetArg (al
[ac
], XmNresizePolicy
, XmRESIZE_GROW
); ++ac
;
10288 XtSetArg (al
[ac
], XmNdialogStyle
, XmDIALOG_APPLICATION_MODAL
); ++ac
;
10289 dialog
= XmCreateFileSelectionDialog (f
->output_data
.x
->widget
,
10291 XmStringFree (dir_xmstring
);
10292 XmStringFree (pattern_xmstring
);
10294 /* Add callbacks for OK and Cancel. */
10295 XtAddCallback (dialog
, XmNokCallback
, file_dialog_cb
,
10296 (XtPointer
) &result
);
10297 XtAddCallback (dialog
, XmNcancelCallback
, file_dialog_cb
,
10298 (XtPointer
) &result
);
10299 XtAddCallback (dialog
, XmNunmapCallback
, file_dialog_unmap_cb
,
10300 (XtPointer
) &result
);
10302 /* Disable the help button since we can't display help. */
10303 help
= XmFileSelectionBoxGetChild (dialog
, XmDIALOG_HELP_BUTTON
);
10304 XtSetSensitive (help
, False
);
10306 /* Mark OK button as default. */
10307 XtVaSetValues (XmFileSelectionBoxGetChild (dialog
, XmDIALOG_OK_BUTTON
),
10308 XmNshowAsDefault
, True
, NULL
);
10310 /* If MUSTMATCH is non-nil, disable the file entry field of the
10311 dialog, so that the user must select a file from the files list
10312 box. We can't remove it because we wouldn't have a way to get at
10313 the result file name, then. */
10314 text
= XmFileSelectionBoxGetChild (dialog
, XmDIALOG_TEXT
);
10315 if (!NILP (mustmatch
))
10318 label
= XmFileSelectionBoxGetChild (dialog
, XmDIALOG_SELECTION_LABEL
);
10319 XtSetSensitive (text
, False
);
10320 XtSetSensitive (label
, False
);
10323 /* Manage the dialog, so that list boxes get filled. */
10324 XtManageChild (dialog
);
10326 /* Select DEFAULT_FILENAME in the files list box. DEFAULT_FILENAME
10327 must include the path for this to work. */
10328 list
= XmFileSelectionBoxGetChild (dialog
, XmDIALOG_LIST
);
10329 if (STRINGP (default_filename
))
10331 XmString default_xmstring
;
10335 = XmStringCreateLocalized (SDATA (default_filename
));
10337 if (!XmListItemExists (list
, default_xmstring
))
10339 /* Add a new item if DEFAULT_FILENAME is not in the list. */
10340 XmListAddItem (list
, default_xmstring
, 0);
10344 item_pos
= XmListItemPos (list
, default_xmstring
);
10345 XmStringFree (default_xmstring
);
10347 /* Select the item and scroll it into view. */
10348 XmListSelectPos (list
, item_pos
, True
);
10349 XmListSetPos (list
, item_pos
);
10352 /* Process events until the user presses Cancel or OK. */
10354 while (result
== 0)
10357 XtAppNextEvent (Xt_app_con
, &event
);
10358 (void) x_dispatch_event (&event
, FRAME_X_DISPLAY (f
) );
10361 /* Get the result. */
10362 if (result
== XmCR_OK
)
10367 XtVaGetValues (dialog
, XmNtextString
, &text
, NULL
);
10368 XmStringGetLtoR (text
, XmFONTLIST_DEFAULT_TAG
, &data
);
10369 XmStringFree (text
);
10370 file
= build_string (data
);
10377 XtUnmanageChild (dialog
);
10378 XtDestroyWidget (dialog
);
10382 /* Make "Cancel" equivalent to C-g. */
10384 Fsignal (Qquit
, Qnil
);
10386 return unbind_to (count
, file
);
10389 #endif /* USE_MOTIF */
10393 DEFUN ("x-file-dialog", Fx_file_dialog
, Sx_file_dialog
, 2, 4, 0,
10394 "Read file name, prompting with PROMPT in directory DIR.\n\
10395 Use a file selection dialog.\n\
10396 Select DEFAULT-FILENAME in the dialog's file selection box, if\n\
10397 specified. Don't let the user enter a file name in the file\n\
10398 selection dialog's entry field, if MUSTMATCH is non-nil.")
10399 (prompt
, dir
, default_filename
, mustmatch
)
10400 Lisp_Object prompt
, dir
, default_filename
, mustmatch
;
10402 FRAME_PTR f
= SELECTED_FRAME ();
10404 Lisp_Object file
= Qnil
;
10405 int count
= specpdl_ptr
- specpdl
;
10406 struct gcpro gcpro1
, gcpro2
, gcpro3
, gcpro4
, gcpro5
;
10410 GCPRO5 (prompt
, dir
, default_filename
, mustmatch
, file
);
10411 CHECK_STRING (prompt
);
10412 CHECK_STRING (dir
);
10414 /* Prevent redisplay. */
10415 specbind (Qinhibit_redisplay
, Qt
);
10419 if (STRINGP (default_filename
))
10420 cdef_file
= SDATA (default_filename
);
10422 cdef_file
= SDATA (dir
);
10424 fn
= xg_get_file_name (f
, SDATA (prompt
), cdef_file
, ! NILP (mustmatch
));
10428 file
= build_string (fn
);
10435 /* Make "Cancel" equivalent to C-g. */
10437 Fsignal (Qquit
, Qnil
);
10439 return unbind_to (count
, file
);
10442 #endif /* USE_GTK */
10445 /***********************************************************************
10447 ***********************************************************************/
10449 #ifdef HAVE_XKBGETKEYBOARD
10450 #include <X11/XKBlib.h>
10451 #include <X11/keysym.h>
10454 DEFUN ("x-backspace-delete-keys-p", Fx_backspace_delete_keys_p
,
10455 Sx_backspace_delete_keys_p
, 0, 1, 0,
10456 doc
: /* Check if both Backspace and Delete keys are on the keyboard of FRAME.
10457 FRAME nil means use the selected frame.
10458 Value is t if we know that both keys are present, and are mapped to the
10459 usual X keysyms. */)
10463 #ifdef HAVE_XKBGETKEYBOARD
10465 struct frame
*f
= check_x_frame (frame
);
10466 Display
*dpy
= FRAME_X_DISPLAY (f
);
10467 Lisp_Object have_keys
;
10468 int major
, minor
, op
, event
, error
;
10472 /* Check library version in case we're dynamically linked. */
10473 major
= XkbMajorVersion
;
10474 minor
= XkbMinorVersion
;
10475 if (!XkbLibraryVersion (&major
, &minor
))
10481 /* Check that the server supports XKB. */
10482 major
= XkbMajorVersion
;
10483 minor
= XkbMinorVersion
;
10484 if (!XkbQueryExtension (dpy
, &op
, &event
, &error
, &major
, &minor
))
10491 kb
= XkbGetMap (dpy
, XkbAllMapComponentsMask
, XkbUseCoreKbd
);
10494 int delete_keycode
= 0, backspace_keycode
= 0, i
;
10496 if (XkbGetNames (dpy
, XkbAllNamesMask
, kb
) == Success
)
10498 for (i
= kb
->min_key_code
;
10499 (i
< kb
->max_key_code
10500 && (delete_keycode
== 0 || backspace_keycode
== 0));
10503 /* The XKB symbolic key names can be seen most easily in
10504 the PS file generated by `xkbprint -label name
10506 if (bcmp ("DELE", kb
->names
->keys
[i
].name
, 4) == 0)
10507 delete_keycode
= i
;
10508 else if (bcmp ("BKSP", kb
->names
->keys
[i
].name
, 4) == 0)
10509 backspace_keycode
= i
;
10512 XkbFreeNames (kb
, 0, True
);
10515 XkbFreeClientMap (kb
, 0, True
);
10518 && backspace_keycode
10519 && XKeysymToKeycode (dpy
, XK_Delete
) == delete_keycode
10520 && XKeysymToKeycode (dpy
, XK_BackSpace
) == backspace_keycode
)
10525 #else /* not HAVE_XKBGETKEYBOARD */
10527 #endif /* not HAVE_XKBGETKEYBOARD */
10532 /***********************************************************************
10534 ***********************************************************************/
10536 /* Keep this list in the same order as frame_parms in frame.c.
10537 Use 0 for unsupported frame parameters. */
10539 frame_parm_handler x_frame_parm_handlers
[] =
10543 x_set_background_color
,
10544 x_set_border_color
,
10545 x_set_border_width
,
10546 x_set_cursor_color
,
10549 x_set_foreground_color
,
10552 x_set_internal_border_width
,
10553 x_set_menu_bar_lines
,
10555 x_explicitly_set_name
,
10556 x_set_scroll_bar_width
,
10558 x_set_unsplittable
,
10559 x_set_vertical_scroll_bars
,
10561 x_set_tool_bar_lines
,
10562 x_set_scroll_bar_foreground
,
10563 x_set_scroll_bar_background
,
10564 x_set_screen_gamma
,
10565 x_set_line_spacing
,
10566 x_set_fringe_width
,
10567 x_set_fringe_width
,
10575 /* This is zero if not using X windows. */
10578 /* The section below is built by the lisp expression at the top of the file,
10579 just above where these variables are declared. */
10580 /*&&& init symbols here &&&*/
10581 Qnone
= intern ("none");
10582 staticpro (&Qnone
);
10583 Qsuppress_icon
= intern ("suppress-icon");
10584 staticpro (&Qsuppress_icon
);
10585 Qundefined_color
= intern ("undefined-color");
10586 staticpro (&Qundefined_color
);
10587 Qcenter
= intern ("center");
10588 staticpro (&Qcenter
);
10589 Qcompound_text
= intern ("compound-text");
10590 staticpro (&Qcompound_text
);
10591 Qcancel_timer
= intern ("cancel-timer");
10592 staticpro (&Qcancel_timer
);
10593 /* This is the end of symbol initialization. */
10595 /* Text property `display' should be nonsticky by default. */
10596 Vtext_property_default_nonsticky
10597 = Fcons (Fcons (Qdisplay
, Qt
), Vtext_property_default_nonsticky
);
10600 Qlaplace
= intern ("laplace");
10601 staticpro (&Qlaplace
);
10602 Qemboss
= intern ("emboss");
10603 staticpro (&Qemboss
);
10604 Qedge_detection
= intern ("edge-detection");
10605 staticpro (&Qedge_detection
);
10606 Qheuristic
= intern ("heuristic");
10607 staticpro (&Qheuristic
);
10608 QCmatrix
= intern (":matrix");
10609 staticpro (&QCmatrix
);
10610 QCcolor_adjustment
= intern (":color-adjustment");
10611 staticpro (&QCcolor_adjustment
);
10612 QCmask
= intern (":mask");
10613 staticpro (&QCmask
);
10615 Fput (Qundefined_color
, Qerror_conditions
,
10616 Fcons (Qundefined_color
, Fcons (Qerror
, Qnil
)));
10617 Fput (Qundefined_color
, Qerror_message
,
10618 build_string ("Undefined color"));
10620 DEFVAR_BOOL ("cross-disabled-images", &cross_disabled_images
,
10621 doc
: /* Non-nil means always draw a cross over disabled images.
10622 Disabled images are those having an `:conversion disabled' property.
10623 A cross is always drawn on black & white displays. */);
10624 cross_disabled_images
= 0;
10626 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
10627 doc
: /* List of directories to search for window system bitmap files. */);
10628 Vx_bitmap_file_path
= decode_env_path ((char *) 0, PATH_BITMAPS
);
10630 DEFVAR_LISP ("x-pointer-shape", &Vx_pointer_shape
,
10631 doc
: /* The shape of the pointer when over text.
10632 Changing the value does not affect existing frames
10633 unless you set the mouse color. */);
10634 Vx_pointer_shape
= Qnil
;
10636 #if 0 /* This doesn't really do anything. */
10637 DEFVAR_LISP ("x-nontext-pointer-shape", &Vx_nontext_pointer_shape
,
10638 doc
: /* The shape of the pointer when not over text.
10639 This variable takes effect when you create a new frame
10640 or when you set the mouse color. */);
10642 Vx_nontext_pointer_shape
= Qnil
;
10644 DEFVAR_LISP ("x-hourglass-pointer-shape", &Vx_hourglass_pointer_shape
,
10645 doc
: /* The shape of the pointer when Emacs is busy.
10646 This variable takes effect when you create a new frame
10647 or when you set the mouse color. */);
10648 Vx_hourglass_pointer_shape
= Qnil
;
10650 DEFVAR_BOOL ("display-hourglass", &display_hourglass_p
,
10651 doc
: /* Non-zero means Emacs displays an hourglass pointer on window systems. */);
10652 display_hourglass_p
= 1;
10654 DEFVAR_LISP ("hourglass-delay", &Vhourglass_delay
,
10655 doc
: /* *Seconds to wait before displaying an hourglass pointer.
10656 Value must be an integer or float. */);
10657 Vhourglass_delay
= make_number (DEFAULT_HOURGLASS_DELAY
);
10659 #if 0 /* This doesn't really do anything. */
10660 DEFVAR_LISP ("x-mode-pointer-shape", &Vx_mode_pointer_shape
,
10661 doc
: /* The shape of the pointer when over the mode line.
10662 This variable takes effect when you create a new frame
10663 or when you set the mouse color. */);
10665 Vx_mode_pointer_shape
= Qnil
;
10667 DEFVAR_LISP ("x-sensitive-text-pointer-shape",
10668 &Vx_sensitive_text_pointer_shape
,
10669 doc
: /* The shape of the pointer when over mouse-sensitive text.
10670 This variable takes effect when you create a new frame
10671 or when you set the mouse color. */);
10672 Vx_sensitive_text_pointer_shape
= Qnil
;
10674 DEFVAR_LISP ("x-window-horizontal-drag-cursor",
10675 &Vx_window_horizontal_drag_shape
,
10676 doc
: /* Pointer shape to use for indicating a window can be dragged horizontally.
10677 This variable takes effect when you create a new frame
10678 or when you set the mouse color. */);
10679 Vx_window_horizontal_drag_shape
= Qnil
;
10681 DEFVAR_LISP ("x-cursor-fore-pixel", &Vx_cursor_fore_pixel
,
10682 doc
: /* A string indicating the foreground color of the cursor box. */);
10683 Vx_cursor_fore_pixel
= Qnil
;
10685 DEFVAR_LISP ("x-max-tooltip-size", &Vx_max_tooltip_size
,
10686 doc
: /* Maximum size for tooltips. Value is a pair (COLUMNS . ROWS).
10687 Text larger than this is clipped. */);
10688 Vx_max_tooltip_size
= Fcons (make_number (80), make_number (40));
10690 DEFVAR_LISP ("x-no-window-manager", &Vx_no_window_manager
,
10691 doc
: /* Non-nil if no X window manager is in use.
10692 Emacs doesn't try to figure this out; this is always nil
10693 unless you set it to something else. */);
10694 /* We don't have any way to find this out, so set it to nil
10695 and maybe the user would like to set it to t. */
10696 Vx_no_window_manager
= Qnil
;
10698 DEFVAR_LISP ("x-pixel-size-width-font-regexp",
10699 &Vx_pixel_size_width_font_regexp
,
10700 doc
: /* Regexp matching a font name whose width is the same as `PIXEL_SIZE'.
10702 Since Emacs gets width of a font matching with this regexp from
10703 PIXEL_SIZE field of the name, font finding mechanism gets faster for
10704 such a font. This is especially effective for such large fonts as
10705 Chinese, Japanese, and Korean. */);
10706 Vx_pixel_size_width_font_regexp
= Qnil
;
10708 DEFVAR_LISP ("image-cache-eviction-delay", &Vimage_cache_eviction_delay
,
10709 doc
: /* Time after which cached images are removed from the cache.
10710 When an image has not been displayed this many seconds, remove it
10711 from the image cache. Value must be an integer or nil with nil
10712 meaning don't clear the cache. */);
10713 Vimage_cache_eviction_delay
= make_number (30 * 60);
10715 #ifdef USE_X_TOOLKIT
10716 Fprovide (intern ("x-toolkit"), Qnil
);
10718 Fprovide (intern ("motif"), Qnil
);
10720 DEFVAR_LISP ("motif-version-string", &Vmotif_version_string
,
10721 doc
: /* Version info for LessTif/Motif. */);
10722 Vmotif_version_string
= build_string (XmVERSION_STRING
);
10723 #endif /* USE_MOTIF */
10724 #endif /* USE_X_TOOLKIT */
10726 /* X window properties. */
10727 defsubr (&Sx_change_window_property
);
10728 defsubr (&Sx_delete_window_property
);
10729 defsubr (&Sx_window_property
);
10731 defsubr (&Sxw_display_color_p
);
10732 defsubr (&Sx_display_grayscale_p
);
10733 defsubr (&Sxw_color_defined_p
);
10734 defsubr (&Sxw_color_values
);
10735 defsubr (&Sx_server_max_request_size
);
10736 defsubr (&Sx_server_vendor
);
10737 defsubr (&Sx_server_version
);
10738 defsubr (&Sx_display_pixel_width
);
10739 defsubr (&Sx_display_pixel_height
);
10740 defsubr (&Sx_display_mm_width
);
10741 defsubr (&Sx_display_mm_height
);
10742 defsubr (&Sx_display_screens
);
10743 defsubr (&Sx_display_planes
);
10744 defsubr (&Sx_display_color_cells
);
10745 defsubr (&Sx_display_visual_class
);
10746 defsubr (&Sx_display_backing_store
);
10747 defsubr (&Sx_display_save_under
);
10748 defsubr (&Sx_create_frame
);
10749 defsubr (&Sx_open_connection
);
10750 defsubr (&Sx_close_connection
);
10751 defsubr (&Sx_display_list
);
10752 defsubr (&Sx_synchronize
);
10753 defsubr (&Sx_focus_frame
);
10754 defsubr (&Sx_backspace_delete_keys_p
);
10756 /* Setting callback functions for fontset handler. */
10757 get_font_info_func
= x_get_font_info
;
10759 #if 0 /* This function pointer doesn't seem to be used anywhere.
10760 And the pointer assigned has the wrong type, anyway. */
10761 list_fonts_func
= x_list_fonts
;
10764 load_font_func
= x_load_font
;
10765 find_ccl_program_func
= x_find_ccl_program
;
10766 query_font_func
= x_query_font
;
10767 set_frame_fontset_func
= x_set_font
;
10768 check_window_system_func
= check_x
;
10771 Qxbm
= intern ("xbm");
10773 QCconversion
= intern (":conversion");
10774 staticpro (&QCconversion
);
10775 QCheuristic_mask
= intern (":heuristic-mask");
10776 staticpro (&QCheuristic_mask
);
10777 QCcolor_symbols
= intern (":color-symbols");
10778 staticpro (&QCcolor_symbols
);
10779 QCascent
= intern (":ascent");
10780 staticpro (&QCascent
);
10781 QCmargin
= intern (":margin");
10782 staticpro (&QCmargin
);
10783 QCrelief
= intern (":relief");
10784 staticpro (&QCrelief
);
10785 Qpostscript
= intern ("postscript");
10786 staticpro (&Qpostscript
);
10787 QCloader
= intern (":loader");
10788 staticpro (&QCloader
);
10789 QCbounding_box
= intern (":bounding-box");
10790 staticpro (&QCbounding_box
);
10791 QCpt_width
= intern (":pt-width");
10792 staticpro (&QCpt_width
);
10793 QCpt_height
= intern (":pt-height");
10794 staticpro (&QCpt_height
);
10795 QCindex
= intern (":index");
10796 staticpro (&QCindex
);
10797 Qpbm
= intern ("pbm");
10801 Qxpm
= intern ("xpm");
10806 Qjpeg
= intern ("jpeg");
10807 staticpro (&Qjpeg
);
10811 Qtiff
= intern ("tiff");
10812 staticpro (&Qtiff
);
10816 Qgif
= intern ("gif");
10821 Qpng
= intern ("png");
10825 defsubr (&Sclear_image_cache
);
10826 defsubr (&Simage_size
);
10827 defsubr (&Simage_mask_p
);
10829 hourglass_atimer
= NULL
;
10830 hourglass_shown_p
= 0;
10832 defsubr (&Sx_show_tip
);
10833 defsubr (&Sx_hide_tip
);
10835 staticpro (&tip_timer
);
10837 staticpro (&tip_frame
);
10839 last_show_tip_args
= Qnil
;
10840 staticpro (&last_show_tip_args
);
10843 defsubr (&Sx_file_dialog
);
10851 image_types
= NULL
;
10852 Vimage_types
= Qnil
;
10854 define_image_type (&xbm_type
);
10855 define_image_type (&gs_type
);
10856 define_image_type (&pbm_type
);
10859 define_image_type (&xpm_type
);
10863 define_image_type (&jpeg_type
);
10867 define_image_type (&tiff_type
);
10871 define_image_type (&gif_type
);
10875 define_image_type (&png_type
);
10879 #endif /* HAVE_X_WINDOWS */